Add variables concept to expressions

This also includes the necessary setup work for using "position" and "direction" in action expressions.
Rework actions to use definitions
2026-11-07 22:56:30 -10:00 · 2021-01-10 22:47:49 +01:00 · 2021-01-10 12:22:00 +01:00 · 2021-01-07 21:36:28 +01:00 · 2021-01-07 13:34:10 +01:00 · 2021-01-06 19:13:12 +01:00
654 changed files with 19469 additions and 63419 deletions
@@ -6,7 +6,3 @@ code/executor/ @asarium
 code/scpui/ @asarium

 code/scripting/ @asarium
-
-code/controlconfig/ @z64555
-
-code/model/modelanimation*.* @bmagnu
@@ -15,7 +15,7 @@ jobs:
        configuration: [FastDebug, Release]
    name: Linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-11e553c
+    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
    steps:
      - name: Cache Qt
        id: cache-qt-lin
@@ -29,8 +29,6 @@ jobs:
          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
@@ -16,17 +16,6 @@ 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:
@@ -39,77 +28,36 @@ 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  # name of artifact
-          path: ${{ github.workspace }}/upload_url  # source location of artifact to upload
+          name: upload_url
+          path: ${{ github.workspace }}/upload_url

  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   # Don't run this job until create_release is done and successful
+    needs: create_release
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-11e553c
+    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
    steps:
      - name: Cache Qt
        id: cache-qt-lin
        uses: actions/cache@v1
-        # cache the Qt directory so we don't have to reinstall it every time
-        # cache.inputs:
-        #   path - A list of files, directories, and wildcard patterns to cache and restore. See @actions/glob for supported patterns.
-        #   key - An explicit key for restoring and saving the cache
-        #   restore-keys - An ordered list of keys to use for restoring the cache if no cache hit occurred for key
-        # cache.outputs:
-        #   cache-hit   true when an exact match was found for the key, false otherwise.
        with:
          path: ${{ github.workspace }}/../Qt
          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
      - name: Install Qt
        uses: jurplel/install-qt-action@v2
-        # installs Qt in the action workflow
-        # install-qt-action.inputs:
-        #   version     desired qt version to install
-        #   host        Host platform of Qt, default to platform used by runs-on
-        #   target      target platform of Qt, default to desktop
-        #   arch        target architecture of Qt, only used for windows or android builds
-        #   dir         root dir Qt will be installed to
-        #   install-deps    if true, auto-install dependencies on linux. Default true
-        #   modules     whitespace delimited list string of additional addon modules to install
-        #   archives    whitespace delimited list string of Qt archives to install
-        #   cached      if true, Don't download Qt but set ENVARs; use with cache.outputs.cache-hit
-        #   setup-python    Set to false to skip using setup-python to find/download a valid python version
-        #   set-env     if true, set ENVARs; default = false
-        #   aqtversion  version of aqtinstall to use; default = 2.0.0
-        #   py7zrversion    version of py7zr to use; default = 0.16.1
-        #   extra       additional arguments to pass to aqinstall
-        # ENVARS set:
-        #   Qt5_DIR / Qt6_DIR
-        #   Qt bin dir appended to PATH
-        #   QT_PLUGIN_PATH, QML2_IMPORT_PATH, PKG_CONFIG_PATH, LD_LIBRARY_PATH
        with:
          version: ${{ env.QT_VERSION }}
          dir: ${{ github.workspace }}/..
          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3

      - uses: actions/checkout@v1
-        # checks-out your repository under $GITHUB_WORKSPACE, so your workflow can access it.
        name: Checkout
        with:
-          submodules: true  # `true` to checkout submodules, `recursive` to recursively checkout submodules
+          submodules: true
      - name: Configure CMake
        env:
          CONFIGURATION: ${{ matrix.configuration }}
@@ -147,52 +95,38 @@ jobs:
        name: Checkout
        with:
          submodules: true
-          fetch-depth: '0'  # value 0 to fetch all history and tags for all branches
+          fetch-depth: '0'
      - 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
-        # Grab the release builds
-        uses: actions/download-artifact@v2
+        uses: actions/download-artifact@v1
        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
-        # 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
+        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
-          files: ${{ steps.generate_package.outputs.package_path }}
+          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 }}

  build_windows:
    strategy:
@@ -205,19 +139,16 @@ 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:
@@ -227,7 +158,6 @@ 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:
@@ -272,47 +202,39 @@ 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@v2
+        uses: actions/download-artifact@v1
        with:
          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
-
      - name: Download FastDebug builds
        uses: actions/download-artifact@v2
        with:
          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
          path: builds
-
      - name: Create Distribution package
        id: generate_package
        working-directory: ./builds
@@ -321,33 +243,21 @@ jobs:
          ARCH: ${{ matrix.arch }}
          SIMD: ${{ matrix.simd }}
        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-
      - name: Upload result package
-        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
+        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
-          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 }}
+          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 }}
@@ -1,53 +0,0 @@
-name: Publish Standalone docker image
-
-on:
-  push:
-    tags:
-    - 'nightly_*'
-    - 'release_*'
-
-jobs:
-  build_images:
-    if: github.repository == 'scp-fs2open/fs2open.github.com'
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        include:
-        - configuration: FastDebug
-          tag_suffix: -debug
-        - configuration: Release
-          tag_suffix: ""
-      fail-fast: false
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-      name: Checkout
-      with:
-        submodules: true
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v1
-
-    - name: Docker meta
-      id: docker_meta
-      uses: crazy-max/ghaction-docker-meta@v1
-      with:
-        images: ghcr.io/scp-fs2open/standalone_server
-        tag-latest: false
-
-    - name: Login to GitHub Docker Registry
-      uses: docker/login-action@v1
-      with:
-        registry: ghcr.io
-        username: ${{ github.repository_owner }}
-        password: ${{ secrets.CR_PAT }}
-    - name: Build and push
-      id: docker_build
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./docker/standalone/Dockerfile
-        push: true
-        tags: ${{ steps.docker_meta.outputs.tags }}${{ matrix.tag_suffix }}
-        labels: ${{ steps.docker_meta.outputs.labels }}
-        build-args: |
-          build_type=${{ matrix.configuration }}
@@ -15,7 +15,7 @@ jobs:
        configuration: [FastDebug, Release]
    name: Linux
    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-11e553c
+    container: ghcr.io/scp-fs2open/linux_build:sha-a8ca321
    steps:
      - name: Cache Qt
        id: cache-qt-lin
@@ -29,8 +29,6 @@ jobs:
          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
@@ -1,62 +0,0 @@
-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
@@ -1,64 +0,0 @@
-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
@@ -8,6 +8,7 @@ env:
 jobs:
  build_linux:
    strategy:
+      fail-fast: false
      matrix:
        configuration: [Debug, Release]
        compiler: [gcc-5, gcc-10, clang-9]
@@ -22,7 +23,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-11e553c
+    container: ghcr.io/scp-fs2open/linux_build:sha-e977d36
    steps:
      - name: Cache Qt
        id: cache-qt-lin
@@ -37,18 +38,12 @@ jobs:
          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
          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 }}
@@ -0,0 +1,48 @@
+name: Publish Standalone docker image
+
+on:
+  push:
+    tags:
+    - '*'
+
+jobs:
+  build_images:
+    strategy:
+      matrix:
+        configuration: [FastDebug, Release]
+        include:
+        - configuration: FastDebug
+          latest_tag: latest_debug
+          nightly_tag: nightly_debug
+          release_tag: release_debug
+        - configuration: Release
+          latest_tag: latest
+          nightly_tag: nightly
+          release_tag: release
+      fail-fast: false
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+      name: Checkout
+      with:
+        submodules: true
+    - name: Docker login
+      run: echo ${{ secrets.DOCKER_ACCESSTOKEN }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
+    - name: Docker build
+      run: docker build --build-arg build_type=${{ matrix.configuration }} -f docker/standalone/Dockerfile -t ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} .
+
+    - name: Push latest tag
+      run: |
+        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }}
+
+    - name: Push nightly tag
+      if: contains(github.ref, 'refs/tags/nightly_')
+      run: |
+        docker tag ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.nightly_tag }}
+        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.nightly_tag }}
+
+    - name: Push release tag
+      if: contains(github.ref, 'refs/tags/release_')
+      run: |
+        docker tag ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.latest_tag }} ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.release_tag }}
+        docker push ${{ secrets.DOCKER_REPOSITORY }}:${{ matrix.release_tag }}
@@ -1,228 +0,0 @@
-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
@@ -1,65 +0,0 @@
-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"])
@@ -1,88 +0,0 @@
-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")
@@ -1,260 +0,0 @@
-# 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()
@@ -1,241 +0,0 @@
-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
@@ -1,27 +0,0 @@
-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]
@@ -1,68 +0,0 @@
-
-<%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]
@@ -1,3 +0,0 @@
-Mako==1.1.5
-requests==2.26.0
-semantic-version==2.8.5
@@ -1,46 +0,0 @@
-# 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"])
@@ -1,3 +1,15 @@

+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
+)
@@ -21,6 +21,8 @@ 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)
@@ -8,6 +8,8 @@
 #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
@@ -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 5)
+set_if_not_defined(FSO_VERSION_MAJOR 20)
+set_if_not_defined(FSO_VERSION_MINOR 1)
 set_if_not_defined(FSO_VERSION_BUILD 0)

 # A numeric revision e.g. the CI build number
@@ -26,7 +26,6 @@ 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)

@@ -66,8 +65,6 @@ 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})
@@ -7,7 +7,6 @@ ActionDefinition::ActionDefinition(SCP_string name, SCP_vector<ActionParameter>
 	: m_name(std::move(name)), m_parameters(std::move(parameters))
 {
 }
-ActionDefinition::~ActionDefinition() = default;

 const SCP_string& ActionDefinition::getName() const
 {
@@ -15,7 +15,6 @@ struct ActionParameter {
 class ActionDefinition {
  public:
 	ActionDefinition(SCP_string name, SCP_vector<ActionParameter> parameters);
-	virtual ~ActionDefinition();

 	const SCP_string& getName() const;
 	const SCP_vector<actions::ActionParameter>& getParameters() const;
@@ -47,7 +47,24 @@ void parseActionParameters(const SCP_vector<ActionParameter>& params,

 const ActionDefinitionManager& ActionDefinitionManager::instance()
 {
-	static const ActionDefinitionManager manager;
+	static const ActionDefinitionManager manager = []() {
+		ActionDefinitionManager newManager;
+
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::MoveToSubmodel>("Move To Subobject")));
+		newManager.addDefinition(std::unique_ptr<ActionDefinition>(
+			new BuiltinActionDefinition<types::ParticleEffectAction>("Start Particle Effect")));
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::PlaySoundAction>("Play 3D Sound")));
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::SetDirectionAction>("Set Direction")));
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::SetPositionAction>("Set Position")));
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::WaitAction>("Wait")));
+
+		return newManager;
+	}();
 	return manager;
 }
 void ActionDefinitionManager::addDefinition(std::unique_ptr<ActionDefinition> def)
@@ -127,19 +144,5 @@ std::unique_ptr<Action> ActionDefinitionManager::parseAction(const flagset<Progr

 	return std::unique_ptr<Action>();
 }
-ActionDefinitionManager::ActionDefinitionManager()
-{
-	addDefinition(
-		std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::MoveToSubmodel>("Move To Subobject")));
-	addDefinition(std::unique_ptr<ActionDefinition>(
-		new BuiltinActionDefinition<types::ParticleEffectAction>("Start Particle Effect")));
-	addDefinition(
-		std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::PlaySoundAction>("Play 3D Sound")));
-	addDefinition(
-		std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::SetDirectionAction>("Set Direction")));
-	addDefinition(
-		std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::SetPositionAction>("Set Position")));
-	addDefinition(std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::WaitAction>("Wait")));
-}

 } // namespace actions
@@ -19,7 +19,7 @@ class ActionDefinitionManager {
 	static const ActionDefinitionManager& instance();

  private:
-	ActionDefinitionManager();
+	ActionDefinitionManager() = default;

 	void addDefinition(std::unique_ptr<ActionDefinition> def);

@@ -0,0 +1,2 @@
+
+#include "BuiltinActionDefinition.h"
@@ -15,7 +15,6 @@ class BuiltinActionDefinition : public ActionDefinition {
 		: ActionDefinition(std::move(name), {{"parameter", expression::ValueTypeTraits<ActionValueType>::type}})
 	{
 	}
-	~BuiltinActionDefinition() override = default;

 	flagset<ProgramContextFlags> getRequiredContext() const override
 	{
@@ -123,9 +123,9 @@ Program& Program::operator=(const Program& other)
 Program& Program::operator=(Program&&) noexcept = default;
 Program::Program(Program&&) noexcept = default;

-bool ProgramSet::isEmpty() const
+const SCP_vector<actions::Program>& ProgramSet::getPrograms() const
 {
-	return _programs.empty();
+	return _programs;
 }

 ProgramSet::ProgramSet() = default;
@@ -84,7 +84,7 @@ class ProgramSet {
 	ProgramSet();
 	explicit ProgramSet(const flagset<ProgramContextFlags>& context_flags);

-	bool isEmpty() const;
+	const SCP_vector<actions::Program>& getPrograms() const;

 	/**
 	 * @brief Starts the execution of all programs within this set with the specified parameters
@@ -14,12 +14,6 @@ class AbstractExpression;
 template <typename T>
 class TypedActionExpression;

-/**
- * @brief An expression that can be executed to compute a value at runtime
- *
- * This is the basis of having dynamic values in actions by allowing mods to specify complex expressions that make use
- * of variables and functions for computing their values at runtime.
- */
 class ActionExpression {
  public:
 	ActionExpression() = default;
@@ -42,13 +36,6 @@ class ActionExpression {
 	std::shared_ptr<nodes::AbstractExpression> m_expression;
 };

-/**
- * @brief An action expression with a specific type specified at compile time
- *
- * This is most useful for built-in actions that have the required type fixed at compile time.
- *
- * @tparam T The type of the expression value.
- */
 template <typename T>
 class TypedActionExpression {
  public:
@@ -22,7 +22,19 @@ Value value_minus(const SCP_vector<Value>& parameters)

 const FunctionManager& FunctionManager::instance()
 {
-	static const FunctionManager manager;
+	static const FunctionManager manager = []() {
+		FunctionManager newManager;
+
+		newManager.addOperator("+", {ValueType::Integer, ValueType::Integer}, ValueType::Integer, value_plus<int>);
+		newManager.addOperator("+", {ValueType::Float, ValueType::Float}, ValueType::Float, value_plus<float>);
+		newManager.addOperator("+", {ValueType::Vector, ValueType::Vector}, ValueType::Vector, value_plus<vec3d>);
+
+		newManager.addOperator("-", {ValueType::Integer, ValueType::Integer}, ValueType::Integer, value_minus<int>);
+		newManager.addOperator("-", {ValueType::Float, ValueType::Float}, ValueType::Float, value_minus<float>);
+		newManager.addOperator("-", {ValueType::Vector, ValueType::Vector}, ValueType::Vector, value_minus<vec3d>);
+
+		return newManager;
+	}();
 	return manager;
 }
 void FunctionManager::addOperator(const SCP_string& name,
@@ -75,16 +87,7 @@ const FunctionDefinition* FunctionManager::findOperator(const SCP_string& name,
 	return nullptr;
 }

-FunctionManager::FunctionManager()
-{
-	addOperator("+", {ValueType::Integer, ValueType::Integer}, ValueType::Integer, value_plus<int>);
-	addOperator("+", {ValueType::Float, ValueType::Float}, ValueType::Float, value_plus<float>);
-	addOperator("+", {ValueType::Vector, ValueType::Vector}, ValueType::Vector, value_plus<vec3d>);
-
-	addOperator("-", {ValueType::Integer, ValueType::Integer}, ValueType::Integer, value_minus<int>);
-	addOperator("-", {ValueType::Float, ValueType::Float}, ValueType::Float, value_minus<float>);
-	addOperator("-", {ValueType::Vector, ValueType::Vector}, ValueType::Vector, value_minus<vec3d>);
-}
+FunctionManager::FunctionManager() = default;

 } // namespace expression
 } // namespace actions
@@ -43,13 +43,13 @@ ActionResult ParticleEffectAction::execute(ProgramLocals& locals) const
 		auto pmi = model_get_instance(instance);
 		auto pm = model_get(pmi->model_num);

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

-		model_instance_local_to_global_point_orient(&local_pos,
+		find_submodel_instance_point_orient(&local_pos,
 			&local_orient,
-			&locals.localPosition,
-			&locals.localOrient,
 			pm,
 			pmi,
-			locals.hostSubobject);
+			locals.hostSubobject,
+			&locals.localPosition,
+			&locals.localOrient);
 	} else {
 		local_pos = locals.localPosition;
 		local_orient = locals.localOrient;
@@ -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_rvec;		//Rotational orientation associated with the path
+	vec3d	path_depart_orient;		//Rotational orientation associated with the path

 	int		submode;
 	int		previous_submode;		// previous submode, get it?
@@ -405,6 +405,7 @@ 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.
 	};

@@ -490,9 +491,6 @@ 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
@@ -563,7 +561,7 @@ const char *ai_get_goal_target_name(const char *name, int *index);
 void ai_clear_goal_target_names();

 extern void init_ai_system(void);
-extern void ai_attack_object(object *attacker, object *attacked, int ship_info_index = -1);
+extern void ai_attack_object(object *attacker, object *attacked, ship_subsys *ssp, int ship_info_index = -1);
 extern void ai_evade_object(object *evader, object *evaded);
 extern void ai_ignore_object(object *ignorer, object *ignored, int ignore_new);
 extern void ai_ignore_wing(object *ignorer, int wingnum);
@@ -607,7 +605,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);
+int ai_acquire_emerge_path(object *pl_objp, int parent_objnum, int path_mask, vec3d *pos, vec3d *fvec);
 int ai_acquire_depart_path(object *pl_objp, int parent_objnum, int path_mask);

 // used by AiBig.cpp
@@ -659,7 +657,7 @@ void ai_start_fly_to_ship(object *objp, int shipnum);
 void ai_fly_to_ship();

 //Moved declaration here for player ship -WMC
-void ai_process_subobjects(int objnum);
+void 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);
@@ -5,7 +5,7 @@

 namespace AI {
 	FLAG_LIST(AI_Flags) {
-		Formation_wing,				//	Fly in formation as part of wing. Also used when flying waypoints.
+		Formation_wing,				//	Fly in formation as part of wing.
 		Awaiting_repair,			//	Awaiting a repair ship.
 		Being_repaired,				//	Currently docked with repair ship.
 		Repairing,					//	Repairing a ship (or going to repair a ship)
@@ -130,20 +130,9 @@ namespace AI {
        Use_only_single_fov_for_turrets,
        No_turning_directional_bias,
 		Use_axial_turnrate_differences,
-		all_nonshielded_ships_can_manage_ets,
-		fightercraft_nonshielded_ships_can_manage_ets,
+		nonshielded_ships_can_manage_ets,
 		Better_collision_avoidance,
 		Require_exact_los,
-		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
 	};
@@ -58,26 +58,6 @@ 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;
@@ -468,10 +448,7 @@ void parse_ai_profiles_tbl(const char *filename)

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

-				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);
-
+				profile->ai_path_mode = AI_PATH_MODE_NORMAL;
 				if (optional_string("$ai path mode:"))
 				{
 					stuff_string(buf, F_NAME, NAME_LENGTH);
@@ -504,12 +481,14 @@ 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.\n", 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. ", 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);
 				}
@@ -541,64 +520,15 @@ void parse_ai_profiles_tbl(const char *filename)
 						profile->second_order_lead_predict_factor = 0;
 					}
 				}
-				if (optional_string("$ships with no shields can manage ETS:"))
-				{
-					mprintf(("Warning: \"$ships with no shields can manage ETS\" flag is deprecated in favor of \"$any ship with no shields can manage ETS\"\n"));
-					bool temp;
-					stuff_boolean(&temp);
-                    profile->flags.set(AI::Profile_Flags::all_nonshielded_ships_can_manage_ets, temp);
-				}

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

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

-				set_flag(profile, "$any ship with no shields can manage ETS:", AI::Profile_Flags::all_nonshielded_ships_can_manage_ets);
-
-				set_flag(profile, "$fighters/bombers with no shields can manage ETS:", AI::Profile_Flags::fightercraft_nonshielded_ships_can_manage_ets);
+				set_flag(profile, "$ships with no shields can manage ETS:", AI::Profile_Flags::nonshielded_ships_can_manage_ets);

 				set_flag(profile, "$better combat collision avoidance for fightercraft:", AI::Profile_Flags::Better_collision_avoidance);

-				set_flag(profile, "$improved missile avoidance for fightercraft:", AI::Profile_Flags::Improved_missile_avoidance);
-
-				set_flag(profile, "$friendly ships use AI profile countermeasure chance:", AI::Profile_Flags::Friendlies_use_countermeasure_firechance);
-
-				set_flag(profile, "$improved subsystem attack pathing:", AI::Profile_Flags::Improved_subsystem_attack_pathing);
-
-				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))
 				{
@@ -670,13 +600,11 @@ void ai_profile_t::reset()

    flags.reset();

-    ai_path_mode = AI_PATH_MODE_NORMAL;
+    ai_path_mode = 0;
 	subsystem_path_radii = 0;
-    bay_arrive_speed_mult = 1.0f;
-    bay_depart_speed_mult = 1.0f;
+    bay_arrive_speed_mult = 0;
+    bay_depart_speed_mult = 0;
 	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;
@@ -748,22 +676,10 @@ void ai_profile_t::reset()
 		flags.set(AI::Profile_Flags::Fix_ai_path_order_bug);
 		flags.set(AI::Profile_Flags::Aspect_invulnerability_fix);
 		flags.set(AI::Profile_Flags::Use_actual_primary_range);
-		flags.set(AI::Profile_Flags::fightercraft_nonshielded_ships_can_manage_ets);
+		flags.set(AI::Profile_Flags::nonshielded_ships_can_manage_ets);
 	}
 	// this flag has been enabled ever since 3.7.2
 	if (mod_supports_version(3, 7, 2)) {
 		flags.set(AI::Profile_Flags::Fix_ramming_stationary_targets_bug);
 	}
-	// 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);
-	}
 }
@@ -17,9 +17,6 @@
 // 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

@@ -110,12 +107,6 @@ 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();
 };
@@ -17,13 +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"

+
 #ifdef _MSC_VER
 #pragma optimize("", off)
 #pragma auto_inline(off)
@@ -407,7 +406,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_local_to_global_point( &geye, &ep->pnt, pm, pmi, 0, &Pl_objp->orient, &Pl_objp->pos );
+			model_instance_find_world_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);
@@ -530,112 +529,6 @@ int ai_big_maybe_follow_subsys_path(int do_dot_check)
 	return 0;
 }

-bool ai_new_maybe_reposition_attack_subsys() {
-
-	ai_info* aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
-
-	if (aip->target_objnum < 0 || aip->targeted_subsys == nullptr)
-		return false;
-
-	object* target_objp = &Objects[aip->target_objnum];
-
-	// dont bother with this if you're still far away
-	if (vm_vec_dist(&Pl_objp->pos, &target_objp->pos) > target_objp->radius * 2.0f + 2000.0f)
-		return false;
-
-	vec3d		geye, gsubpos;
-	eye* ep;
-	polymodel* pm = model_get(Ship_info[Ships[Pl_objp->instance].ship_info_index].model_num);
-
-	// get world pos of eye (stored in geye)
-	ep = &(pm->view_positions[Ships[Pl_objp->instance].current_viewpoint]);
-	model_local_to_global_point(&geye, &ep->pnt, pm->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);
-	vm_vec_add2(&gsubpos, &En_objp->pos);
-
-	// you're in sight! shoot it!
-	if (ship_subsystem_in_sight(En_objp, aip->targeted_subsys, &geye, &gsubpos, 0))
-		return false;
-
-	// not in sight, gotta get there
-	vec3d tgt2pl = Pl_objp->pos - target_objp->pos;
-	vec3d tgt2subsys = gsubpos - target_objp->pos;
-	float pl_dist = vm_vec_mag(&tgt2pl);
-	float subsys_dist = vm_vec_mag(&tgt2subsys) * 1.3f; // add a bit to this, we don't want to go directly at the subsys, we want to go above it
-
-	float angle2subsys = vm_vec_delta_ang(&tgt2pl, &tgt2subsys, nullptr);
-	float angle2goal = angle2subsys;
-	if (angle2goal > 1.2f) // let's not try to go more than about 70 degrees around the ship
-		angle2goal = 1.2f;
-
-	// we'll start by travelling along the sphere at our current distance around the ship
-	// remember that goal_pos will be relative to our target_ship (so we can scale in and out easily)
-	vec3d goal_pos, cross;
-	vm_vec_cross(&cross, &tgt2pl, &tgt2subsys);
-	vm_vec_normalize(&cross);
-	vm_vec_negate(&cross);
-	vm_rot_point_around_line(&goal_pos, &tgt2pl, angle2goal, &vmd_zero_vector, &cross);
-
-	// then scale in (or out) towards our subsys
-	vec3d world_goal_pos;
-	float new_radius = ((subsys_dist - pl_dist) * (angle2goal / angle2subsys)) + pl_dist;
-	vm_vec_copy_scale(&world_goal_pos, &goal_pos, new_radius / pl_dist);
-	world_goal_pos += target_objp->pos;
-
-	vec3d* good_pos = nullptr;
-	if (pp_collide(&Pl_objp->pos, &world_goal_pos, target_objp, Pl_objp->radius * 4.0f)) {
-		// ok best case won't work
-		if (pl_dist > subsys_dist) {
-			//we're farther away than the subsys, let's try at our current distance
-			world_goal_pos = goal_pos + target_objp->pos;
-			if (!pp_collide(&Pl_objp->pos, &world_goal_pos, target_objp, Pl_objp->radius * 4.0f))
-				good_pos = &world_goal_pos;
-		}
-
-		// ok, let's start moving it away and see if that's better
-		for (float i = 1.0f; i < 4.0f; i += 1.0f) {
-			if (good_pos)
-				break;
-
-			vm_vec_copy_scale(&world_goal_pos, &goal_pos, (new_radius / pl_dist) * powf(1.3f,i));
-			world_goal_pos += target_objp->pos;
-			if (!pp_collide(&Pl_objp->pos, &world_goal_pos, target_objp, Pl_objp->radius * 4.0f))
-				good_pos = &world_goal_pos;
-		}
-
-		// welp this sucks, just run away i guess
-		if (!good_pos) {
-			vm_vec_copy_normalize(&world_goal_pos, &tgt2pl);
-			world_goal_pos *= target_objp->radius + pl_dist;
-			world_goal_pos += target_objp->pos;
-			good_pos = &world_goal_pos;
-		}
-	}
-	else
-		good_pos = &world_goal_pos;
-
-	ai_turn_towards_vector(good_pos, Pl_objp, nullptr, nullptr, 0.0f, 0);
-	float subsys_distance = vm_vec_dist(&Pl_objp->pos, &gsubpos);
-
-	// full speed until you're close, then slow down a bit
-	accelerate_ship(aip, subsys_distance > 200.0f ? 1.0f : subsys_distance / 200.0f);
-
-	if (!(Ships[Pl_objp->instance].flags[Ship::Ship_Flags::Afterburner_locked])) {
-		if (subsys_distance > 300.0f) {
-			if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
-				afterburners_start(Pl_objp);
-				aip->afterburner_stop_time = Missiontime + 2 * F1_0;
-			}
-		}
-		else
-			afterburners_stop(Pl_objp);
-	}
-	return true;
-
-}
-
 // This function is only called from ai_big_chase_attack() when a ship is flying very slowly and
 // attacking a big ship.  The ship should scan for enemy fighter/bombers... if any are close, then
 // return 1, otherwise return 0;
@@ -744,10 +637,7 @@ void ai_big_chase_attack(ai_info *aip, ship_info *sip, vec3d *enemy_pos, float d
 		}

 		// see if Pl_objp needs to reposition to get a good shot at subsystem which is being attacked
-		if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing]) {
-			if (ai_new_maybe_reposition_attack_subsys())
-				return;
-		} else if ( ai_big_maybe_follow_subsys_path() ) {
+		if ( ai_big_maybe_follow_subsys_path() ) {
 			if ((Pl_objp->phys_info.flags & PF_AFTERBURNER_ON) && !(aip->ai_flags[AI::AI_Flags::Kamikaze])) {
 				afterburners_stop(Pl_objp);
 			}
@@ -777,28 +667,14 @@ 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 > (optimal_range > 0.0f ? optimal_range : (weapon_travel_dist-20))) {
+			if (dist_to_enemy > (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);
@@ -823,7 +699,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 > (optimal_range > 0.0f ? optimal_range : (weapon_travel_dist/2.0f))) {
+				if (dist_to_enemy > weapon_travel_dist/2.0f) {
 					accel = 1.0f;
 				} else {
 					accel = 1.0f - dot_to_enemy;
@@ -840,6 +716,7 @@ 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);
@@ -880,14 +757,7 @@ static void ai_big_maybe_fire_weapons(float dist_to_enemy, float dot_to_enemy)
 	aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
 	swp = &Ships[Pl_objp->instance].weapons;

-	float target_radius = En_objp->radius;
-
-	// normal subsystem attacking uses whether or not its on a path and skips this function entirely to stop "over-eager" firing
-	// since the improved method doesnt use paths, refine the target radius to stop over-eager shooting
-	if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing] && aip->targeted_subsys != nullptr)
-		target_radius = aip->targeted_subsys->system_info->radius;
-
-	if (dot_to_enemy > 0.95f - 0.5f * target_radius/MAX(1.0f, target_radius + dist_to_enemy)) {
+	if (dot_to_enemy > 0.95f - 0.5f * En_objp->radius/MAX(1.0f, En_objp->radius + dist_to_enemy)) {
 		aip->time_enemy_in_range += flFrametime;
 		
 		//	Chance of hitting ship is based on dot product of firing ship's forward vector with vector to ship
@@ -927,7 +797,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]) && weapon_target_satisfies_lock_restrictions(swip, En_objp)) {
+								if (timestamp_elapsed(swp->next_secondary_fire_stamp[current_bank])) {
 									float firing_range;
 									if (swip->wi_flags[Weapon::Info_Flags::Local_ssm])
 										firing_range=swip->lssm_lock_range;
@@ -957,11 +827,10 @@ 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] = Random::next(swip->burst_shots);
+															swp->burst_counter[current_bank_adjusted] = myrand() % swip->burst_shots;
 														} else {
 															swp->burst_counter[current_bank_adjusted] = 0;
 														}
-														swp->burst_seed[current_bank_adjusted] = Random::next();
 													}
 												} else {
 													if (swip->burst_shots > swp->burst_counter[current_bank_adjusted]) {
@@ -970,11 +839,10 @@ 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] = Random::next(swip->burst_shots);
+															swp->burst_counter[current_bank_adjusted] = myrand() % swip->burst_shots;
 														} else {
 															swp->burst_counter[current_bank_adjusted] = 0;
 														}
-														swp->burst_seed[current_bank_adjusted] = Random::next();
 													}
 												}
 												swp->next_secondary_fire_stamp[current_bank] = timestamp((int) (t*1000.0f));
@@ -1171,10 +1039,7 @@ void ai_big_chase()
 		float dist_normal_to_enemy;

 		if (vm_vec_mag_squared(&aip->big_attack_surface_normal) > 0.9) {
-			if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing])
-				dist_normal_to_enemy = fl_abs((dist_to_enemy / vm_vec_dot(&vec_to_enemy, &aip->big_attack_surface_normal)));
-			else // I'm fairly sure this retail code VVV meant to use / instead of * 
-				dist_normal_to_enemy = fl_abs((dist_to_enemy * vm_vec_dot(&vec_to_enemy, &aip->big_attack_surface_normal)));
+			dist_normal_to_enemy = fl_abs((dist_to_enemy * vm_vec_dot(&vec_to_enemy, &aip->big_attack_surface_normal)));
 		} else {
 			// don;t have normal so use a conservative value here
 			dist_normal_to_enemy = 0.3f * dist_to_enemy;
@@ -1451,17 +1316,13 @@ void ai_big_strafe_attack()
 	ai_info	*aip;
 	vec3d	target_pos;
 	vec3d	rand_vec;
-	float	accel, t;
-	float target_dist = 0.0f;
-	float target_dot = 0.0f;
+	float		target_dist, target_dot, accel, t;

 	aip = &Ai_info[Ships[Pl_objp->instance].ai_index];

-	if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing]) {
-		if (ai_new_maybe_reposition_attack_subsys())
-			return;
-	} else if (ai_big_maybe_follow_subsys_path(0))
+	if ( ai_big_maybe_follow_subsys_path(0) ) {
 		return;
+	}

 	ai_big_attack_get_data(&target_pos, &target_dist, &target_dot);
 	if ( ai_big_strafe_maybe_retreat(&target_pos) )
@@ -1484,7 +1345,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(Random::next(4)) {
+			switch(rand()%4) {
 			case 0:
 				vm_vec_scale_add(&rand_vec, &Pl_objp->orient.vec.fvec, &Pl_objp->orient.vec.uvec, 2.0f);
 				break;
@@ -1578,11 +1439,9 @@ void ai_big_strafe_glide_attack()
 	flight_dot_to_enemy = vm_vec_dot(&target_objp->pos, &norm_vel_vec);	//Angle between flight path and target ship

 	//If we're following a path, then we shouldn't be doing glide strafe
-	if (aip->ai_profile_flags[AI::Profile_Flags::Improved_subsystem_attack_pathing]) {
-		if (ai_new_maybe_reposition_attack_subsys())
-			return;
-	} else if (ai_big_maybe_follow_subsys_path(0))
+	if ( ai_big_maybe_follow_subsys_path(0) ) {
 		return;
+	}

 	//Gets a point on the target ship to attack, as well as distance and the angle between the nose of the attacker and that point.
 	ai_big_attack_get_data(&target_pos, &target_dist, &target_dot);	
@@ -1716,7 +1575,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(Random::next(4)) {
+		switch(rand()%4) {
 		case 0:
 			vm_vec_add(&rand_vec, &Pl_objp->orient.vec.fvec, &Pl_objp->orient.vec.uvec);
 			break;
@@ -23,7 +23,6 @@
 #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
@@ -188,11 +187,6 @@ 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.
@@ -209,6 +203,7 @@ void ai_post_process_mission()
 				wingp = &Wings[Starting_wings[i]];

 				ai_maybe_add_form_goal( wingp );
+
 			}
 		}
 	}
@@ -266,20 +261,14 @@ 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] );
@@ -304,11 +293,9 @@ void ai_clear_ship_goals( ai_info *aip )
 	}

 	// add scripting hook for 'On Goals Cleared' --wookieejedi
-	if (Script_system.IsActiveAction(CHA_ONGOALSCLEARED)) {
-		Script_system.SetHookObject("Ship", &Objects[Ships[aip->shipnum].objnum]);
-		Script_system.RunCondition(CHA_ONGOALSCLEARED);
-		Script_system.RemHookVars({"Ship"});
-	}
+	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 )
@@ -2160,14 +2147,14 @@ void ai_process_mission_orders( int objnum, ai_info *aip )

 		//	Mike -- debug code!
 		//	If a ship has a subobject on it, attack that instead of the main ship!
-		ai_attack_object( objp, other_obj);
+		ai_attack_object( objp, other_obj, NULL);
 		break;

 	case AI_GOAL_CHASE_WEAPON:
 		Assert( Weapons[current_goal->target_instance].objnum >= 0 );
 		other_obj = &Objects[Weapons[current_goal->target_instance].objnum];
 		Assert( other_obj->signature == current_goal->target_signature );
-		ai_attack_object( objp, other_obj);
+		ai_attack_object( objp, other_obj, NULL );
 		break;

 	case AI_GOAL_GUARD:
@@ -2292,7 +2279,7 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 		shipnum = ship_name_lookup( current_goal->target_name );
 		Assert( shipnum >= 0 );
 		other_obj = &Objects[Ships[shipnum].objnum];
-		ai_attack_object( objp, other_obj);
+		ai_attack_object( objp, other_obj, NULL);
 		ai_set_attack_subsystem( objp, current_goal->ai_submode );		// submode stored the subsystem type
 		if (current_goal->ai_mode != AI_GOAL_DESTROY_SUBSYSTEM) {
 			if (aip->target_objnum != -1) {
@@ -2314,14 +2301,14 @@ void ai_process_mission_orders( int objnum, ai_info *aip )
 		break;

 	case AI_GOAL_CHASE_ANY:
-		ai_attack_object( objp, nullptr);
+		ai_attack_object( objp, NULL, NULL );
 		break;

 	// chase-ship-class is chase-any but restricted to a subset of ships
 	case AI_GOAL_CHASE_SHIP_CLASS:
 		shipnum = ship_info_lookup( current_goal->target_name );
 		Assertion( shipnum >= 0, "The target of AI_GOAL_CHASE_SHIP_CLASS must refer to a valid ship class!" );
-		ai_attack_object( objp, nullptr, shipnum );
+		ai_attack_object( objp, NULL, NULL, shipnum );
 		break;

 	case AI_GOAL_WARP: {
@@ -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_turret_execute_behavior(ship *shipp, ship_subsys *ss);
+void ai_fire_from_turret(ship *shipp, ship_subsys *ss);

 #endif
@@ -18,7 +18,6 @@
 #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"
@@ -88,18 +87,6 @@ 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?
 *
@@ -111,53 +98,117 @@ void turret_instance_find_world_orient(matrix* out_mat, int model_instance_num,
 *
 * @return 1 if objp is in fov of the specified turret.  Otherwise return 0.
 */
-bool object_in_turret_fov(object *objp, ship_subsys *ss, vec3d *tvec, vec3d *tpos, float dist)
+int object_in_turret_fov(object *objp, ship_subsys *ss, vec3d *tvec, vec3d *tpos, float dist)
 {
 	vec3d	v2e;
 	float size_mod;
-	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
+	bool  in_fov;

 	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 in_fov;
+	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]) {
+			vec3d temp_vec2;
+			vm_vec_rotate(&temp_vec2, &temp_vec, &ss->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, &ss->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;
 }

 /**
@@ -504,7 +555,6 @@ void evaluate_obj_as_target(object *objp, eval_enemy_obj_struct *eeo)

 	if ( objp->type == OBJ_SHIP ) {
 		shipp = &Ships[objp->instance];
-		ship_info* sip = &Ship_info[shipp->ship_info_index];

 		// check on enemy team
 		if ( !iff_matches_mask(shipp->team, eeo->enemy_team_mask) ) {
@@ -544,18 +594,16 @@ void evaluate_obj_as_target(object *objp, eval_enemy_obj_struct *eeo)
 			}
 		}

-		// don't shoot at big ships with huge weapons unless they have the flag
+		// don't shoot at small ships if we shouldn't
 		if (eeo->eeo_flags & EEOF_BIG_ONLY) {
-			if (sip->class_type == -1 || !(Ship_types[sip->class_type].flags[Ship::Type_Info_Flags::Targeted_by_huge_Ignored_by_small_only])) {
+			if (!(Ship_info[shipp->ship_info_index].is_big_or_huge())) {
 				return;
 			}
 		}
-		//  ^ Note the difference between these checks
-		//  V   "small only" EXCLUDES only big ships, "huge" INCLUDES only big ships

-		// don't shoot at ships ignored by small weapons if this is a small weapon
+		// don't shoot at big ships if we shouldn't
 		if (eeo->eeo_flags & EEOF_SMALL_ONLY) {
-			if (sip->class_type >= 0 && (Ship_types[sip->class_type].flags[Ship::Type_Info_Flags::Targeted_by_huge_Ignored_by_small_only])) {
+			if ((Ship_info[shipp->ship_info_index].is_big_or_huge())) {
 				return;
 			}
 		}
@@ -1131,18 +1179,23 @@ int find_turret_enemy(ship_subsys *turret_subsys, int objnum, vec3d *tpos, vec3d

 			if (!skip) {
 				if ( Objects[aip->target_objnum].type == OBJ_SHIP ) {
-					ship_info* esip = &Ship_info[Ships[Objects[aip->target_objnum].instance].ship_info_index];
 					// check for huge weapon and huge ship
-					if ( !big_only_flag || (esip->class_type >= 0 && Ship_types[esip->class_type].flags[Ship::Type_Info_Flags::Targeted_by_huge_Ignored_by_small_only]) ) {
+					if ( !big_only_flag || (Ship_info[Ships[Objects[aip->target_objnum].instance].ship_info_index].is_big_or_huge()) ) {
 						// check for tagged only and tagged ship
 						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;
-							vm_vec_normalized_dir(&v2e, &Objects[aip->target_objnum].pos, tpos);
+							dist = 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) {
@@ -1177,22 +1230,20 @@ int find_turret_enemy(ship_subsys *turret_subsys, int objnum, vec3d *tpos, vec3d
 * of the turret.
 *
 * @param objp  Pointer to object
- * @param tp    Turret model system on that object
+ * @param tp    Turrent model system on that object
 * @param gpos  [Output] Global absolute position of gun firing point
 * @param gvec  [Output] Global vector
 *
 * @note The gun normal is the unrotated gun normal, (the center of the FOV cone), not
 * the actual gun normal given using the current turret heading.  But it _is_ rotated into the model's orientation
 * in global space.
- * @note2 Because of this, both single-part and multi-part turrets are treated the same way; no need to find the multi-part's gun submodel.
 */
-void ship_get_global_turret_info(const object *objp, const model_subsystem *tp, vec3d *gpos, vec3d *gvec)
+void ship_get_global_turret_info(object *objp, model_subsystem *tp, vec3d *gpos, vec3d *gvec)
 {
-	auto model_instance_num = Ships[objp->instance].model_instance_num;
-	if (gpos)
-		model_instance_local_to_global_point(gpos, &vmd_zero_vector, model_instance_num, tp->subobj_num, &objp->orient, &objp->pos);
-	if (gvec)
-		model_instance_local_to_global_dir(gvec, &tp->turret_norm, model_instance_num, tp->subobj_num, &objp->orient, true);
+//	vm_vec_unrotate(gpos, &tp->turret_avg_firing_point, &objp->orient);
+	vm_vec_unrotate(gpos, &tp->pnt, &objp->orient);
+	vm_vec_add2(gpos, &objp->pos);
+	vm_vec_unrotate(gvec, &tp->turret_norm, &objp->orient);	
 }

 void turret_ai_update_aim(ai_info *aip, object *En_Objp, ship_subsys *ss);
@@ -1220,15 +1271,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_local_to_global_point(gpos, gun_pos, pm, pmi, tp->turret_gun_sobj, &objp->orient, &objp->pos);
+	model_instance_find_world_point(gpos, gun_pos, pm, pmi, tp->turret_gun_sobj, &objp->orient, &objp->pos);

 	if (use_angles) {
-		model_instance_local_to_global_dir(gvec, &tp->turret_norm, pm, pmi, tp->turret_gun_sobj, &objp->orient);
+		model_instance_find_world_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_local_to_global_point(&tmp_pos, &avg, pm, pmi, tp->turret_gun_sobj, &objp->orient, &objp->pos);
+		model_instance_find_world_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];
@@ -1252,8 +1303,7 @@ void ship_get_global_turret_gun_info(object *objp, ship_subsys *ssp, vec3d *gpos
 				vm_vec_add2(&enemy_point, &ssp->last_aim_enemy_pos);
 			} 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_local_to_global_dir(&turret_norm, &tp->turret_norm, pm, pmi, pm->submodel[tp->subobj_num].parent, &objp->orient);
+                    vm_vec_unrotate(&turret_norm, &tp->turret_norm, &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 {
@@ -1384,13 +1434,18 @@ 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, ss, predicted_enemy_pos);
+			ret_val = model_rotate_gun(objp, pm, pmi, tp, 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, ss, predicted_enemy_pos, true);
+			ret_val = model_rotate_gun(objp, pm, pmi, tp, 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, predicted_enemy_pos, true);
+		ret_val = model_rotate_gun(objp, pm, pmi, ss->system_info, predicted_enemy_pos, true);
 	}

 	// by default "ret_val" should be set to 1 for multi-part turrets, and 0 for single-part turrets
@@ -1422,7 +1477,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_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);
+		vm_vec_unrotate(&turret_norm, &turret_subsysp->system_info->turret_norm, &objp->orient);
 		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]) {
@@ -1492,7 +1547,8 @@ ship_subsys *aifft_find_turret_subsys(object *objp, ship_subsys *ssp, object *en

 	//	Compute absolute gun position.
 	vec3d	abs_gun_pos;
-	ship_get_global_turret_info(objp, ssp->system_info, &abs_gun_pos, nullptr);
+	vm_vec_unrotate(&abs_gun_pos, &ssp->system_info->pnt, &objp->orient);
+	vm_vec_add2(&abs_gun_pos, &objp->pos);

 	//	Only pick a turret to attack on large ships.
 	if (!esip->is_big_or_huge())
@@ -1605,10 +1661,8 @@ 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 (burst_shots > turret->weapons.burst_counter[weapon_num]) {
+	if (wip->burst_shots > turret->weapons.burst_counter[weapon_num]) {
 		wait *= wip->burst_delay;
 		turret->weapons.burst_counter[weapon_num]++;
 	} else {
@@ -1618,12 +1672,10 @@ void turret_set_next_fire_timestamp(int weapon_num, weapon_info *wip, ship_subsy
 		} else {
 			wait *= wip->fire_wait;
 		}
-		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();
+		if ((wip->burst_shots > 0) && (wip->burst_flags[Weapon::Burst_Flags::Random_length])) {
+			turret->weapons.burst_counter[weapon_num] = (myrand() % wip->burst_shots);
 		} else {
 			turret->weapons.burst_counter[weapon_num] = 0;
-			turret->weapons.burst_seed[weapon_num] = Random::next();
 		}
 	}

@@ -1634,7 +1686,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]) || ((burst_shots > 0) && (wip->burst_flags[Weapon::Burst_Flags::Fast_firing]))))
+	if(!((wip->wi_flags[Weapon::Info_Flags::Same_turret_cooldown]) || ((wip->burst_shots > 0) && (wip->burst_flags[Weapon::Burst_Flags::Fast_firing]))))
 	{

 		// make side even for team vs. team
@@ -1717,7 +1769,7 @@ void turret_update_enemy_in_range(ship_subsys *turret, float seconds)
 /**
 * Fire a weapon from a turret
 */
-bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum, vec3d *turret_pos, vec3d *firing_vec, vec3d *predicted_pos = nullptr, float flak_range_override = 100.0f)
+bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum, vec3d *turret_pos, vec3d *turret_fvec, vec3d *predicted_pos = NULL, float flak_range_override = 100.0f)
 {
 	matrix	turret_orient;
 	int weapon_objnum;
@@ -1782,25 +1834,8 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 #endif

 	if (check_ok_to_fire(parent_objnum, turret->turret_enemy_objnum, wip, -1, turret)) {
-		ship_weapon* swp = &turret->weapons;
-		turret->turret_last_fire_direction = *firing_vec;
-
-		if (turret->turret_inaccuracy > 0.0f)
-			vm_vec_random_cone(firing_vec, firing_vec, turret->turret_inaccuracy);
-
-		vm_vector_2_matrix(&turret_orient, firing_vec, nullptr, nullptr);
-
-		// 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;
-		}
+		vm_vector_2_matrix(&turret_orient, turret_fvec, NULL, NULL);
+		turret->turret_last_fire_direction = *turret_fvec;

 		// set next fire timestamp for the turret
 		if (last_shot_in_salvo)
@@ -1826,10 +1861,7 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 			else
 				fire_info.target_subsys = NULL;
 			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);
@@ -1840,11 +1872,9 @@ 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;

-				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"});
-				}
+				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
@@ -1852,11 +1882,12 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 		}
 		// don't fire swam, but set up swarm info instead
 		else if ((wip->wi_flags[Weapon::Info_Flags::Swarm]) || (wip->wi_flags[Weapon::Info_Flags::Corkscrew])) {
+			ship_weapon *swp = &turret->weapons;
 			if (swp->current_secondary_bank < 0) {
 				swp->current_secondary_bank = 0;
 			}
 			int bank_to_fire = swp->current_secondary_bank;
-			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::Turret_use_ammo]) && (swp->secondary_bank_ammo[bank_to_fire] < 0)) {
 				if (!(turret->system_info->flags[Model::Subsystem_Flags::Use_multiple_guns])) {
 					swp->current_secondary_bank++;
 					if (swp->current_secondary_bank >= swp->num_secondary_banks) {
@@ -1877,6 +1908,8 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 		else {
 			for (int i = 0; i < wip->shots; i++) {
 				if (turret->system_info->flags[Model::Subsystem_Flags::Turret_use_ammo]) {
+					ship_weapon *swp;
+					swp = &turret->weapons;
 					int bank_to_fire, num_slots = turret->system_info->turret_num_firing_points;
 					if (wip->subtype == WP_LASER) {
 						int points;
@@ -1904,10 +1937,7 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 							points = 1;
 						}

-						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
+						if (swp->primary_bank_ammo[bank_to_fire] >= 0) {
 							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++;
@@ -1939,17 +1969,11 @@ 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) {
-								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
+							if (swp->secondary_bank_ammo[bank_to_fire] >= 0) {
 								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++;
@@ -1965,7 +1989,7 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 				}
 				// zookeeper - Firepoints should cycle normally between shots, 
 				// so we need to get the position info separately for each shot
-				ship_get_global_turret_gun_info(&Objects[parent_objnum], turret, turret_pos, firing_vec, 1, nullptr);
+				ship_get_global_turret_gun_info(&Objects[parent_objnum], turret, turret_pos, turret_fvec, 1, NULL);

 				weapon_objnum = weapon_create( turret_pos, &turret_orient, turret_weapon_class, parent_objnum, -1, 1, 0,0.0f, turret);
 				weapon_set_tracking_info(weapon_objnum, parent_objnum, turret->turret_enemy_objnum, 1, turret->targeted_subsys);		
@@ -1983,14 +2007,14 @@ 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;	

-					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"});
-					}
+					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]) {
+					if (wip->wi_flags[Weapon::Info_Flags::Flak]) {			
+						// show a muzzle flash
+						flak_muzzle_flash(turret_pos, turret_fvec, &Objects[parent_ship->objnum].phys_info, turret_weapon_class);

 						if(predicted_pos != NULL)
 						{
@@ -2005,10 +2029,9 @@ bool turret_fire_weapon(int weapon_num, ship_subsys *turret, int parent_objnum,
 							flak_set_range(objp, flak_range_override);
 						}
 					}
-
-					// do mflash if the weapon has it
-					if (wip->muzzle_flash >= 0) {
-						mflash_create(turret_pos, firing_vec, &Objects[parent_ship->objnum].phys_info, wip->muzzle_flash);
+					// otherwise just do mflash if the weapon has it
+					else if (wip->muzzle_flash >= 0) {
+						mflash_create(turret_pos, turret_fvec, &Objects[parent_ship->objnum].phys_info, wip->muzzle_flash);
 					}

 					// in multiplayer (and the master), then send a turret fired packet.
@@ -2050,7 +2073,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
-	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);
+	model_anim_start_type(turret, AnimationTriggerType::TurretFired, ANIMATION_SUBTYPE_ALL, 1);
 	return true;
 }

@@ -2101,11 +2124,9 @@ 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;

-		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"});
-		}
+		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) {
@@ -2136,15 +2157,13 @@ int Num_find_turret_enemy = 0;
 int Num_turrets_fired = 0;

 /**
- * 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
+ * Given a turret tp and its parent parent_objnum, fire from the turret at its enemy.
 */
 extern int Nebula_sec_range;
-void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
+void ai_fire_from_turret(ship *shipp, ship_subsys *ss)
 {
 	float		weapon_firing_range;
-    float		weapon_min_range;			// *Weapon minimum firing range -Et1
+    float		WeaponMinRange;			// *Weapon minimum firing range -Et1
 	vec3d	v2e;
 	object	*lep;		//	Last enemy pointer
 	model_subsystem	*tp = ss->system_info;
@@ -2216,8 +2235,6 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 	{
 		ss->turret_enemy_objnum = -1;
 		lep = nullptr;
-		ss->flags.remove(Ship::Subsystem_Flags::Forced_target);
-		ss->flags.remove(Ship::Subsystem_Flags::Forced_subsys_target);
 	}

 	Assert((shipp->objnum >= 0) && (shipp->objnum < MAX_OBJECTS));
@@ -2225,10 +2242,25 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 	objp = &Objects[shipp->objnum];
 	Assert(objp->type == OBJ_SHIP);

+	// Wanderer - make sure turrets already have all the data
+	if ( !(tp->flags[Model::Subsystem_Flags::Turret_matrix]) )
+	{
+		if (!(tp->turret_gun_sobj == tp->subobj_num))
+		{
+			auto pmi = model_get_instance(shipp->model_instance_num);
+			auto pm = model_get(pmi->model_num);
+			model_make_turret_matrix(pm, pmi, tp);
+		}
+	}
+
 	// Use the turret info for all guns, not one gun in particular.
 	vec3d	 gvec, gpos;
 	ship_get_global_turret_info(objp, tp, &gpos, &gvec);

+	if (tp->flags[Model::Subsystem_Flags::Turret_alt_math]) {
+		vm_matrix_x_matrix( &ss->world_to_turret_matrix, &objp->orient, &tp->turret_matrix );
+	}
+
 	// Rotate the turret even if time hasn't elapsed, since it needs to turn to face its target.
 	int use_angles = aifft_rotate_turret(objp, shipp, ss, lep, &predicted_enemy_pos, &gvec);

@@ -2319,12 +2351,12 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 		if (wip->wi_flags[Weapon::Info_Flags::Local_ssm])
 		{
 			weapon_firing_range = wip->lssm_lock_range;
-			weapon_min_range = 0.0f;
+			WeaponMinRange = 0.0f;
 		}
 		else
 		{
 			weapon_firing_range = MIN(wip->lifetime * wip->max_speed, wip->weapon_range);
-			weapon_min_range = wip->weapon_min_range;
+			WeaponMinRange = wip->WeaponMinRange;
 		}

 		// if beam weapon in nebula and target not tagged, decrease firing range
@@ -2337,21 +2369,19 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 		}

 		// Don't try to fire beyond weapon_limit_range (or within min range)
-		if (dist_to_enemy < weapon_min_range || dist_to_enemy > weapon_firing_range) {
+		if (dist_to_enemy < WeaponMinRange || 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;
 		}

-		ship_info* esip = lep->type != OBJ_SHIP ? nullptr : &Ship_info[Ships[lep->instance].ship_info_index];
-
 		//	If targeted a small ship and have a huge weapon, don't fire.  But this shouldn't happen, as a small ship should not get selected.
 		if ( wip->wi_flags[Weapon::Info_Flags::Huge] ) {
 			if ( lep->type != OBJ_SHIP ) {
 				tentative_return = true;
 				continue;
 			}
-			if ( esip->class_type >= 0 && !(Ship_types[esip->class_type].flags[Ship::Type_Info_Flags::Targeted_by_huge_Ignored_by_small_only])) {
+			if ( !(Ship_info[Ships[lep->instance].ship_info_index].is_big_or_huge()) ) {
 				tentative_return = true;
 				continue;
 			}
@@ -2359,8 +2389,7 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)

 		// Similar check for small weapons
 		if ( wip->wi_flags[Weapon::Info_Flags::Small_only] ) {
-			if ( (lep->type == OBJ_SHIP) && esip->class_type >= 0 && 
-				(Ship_types[esip->class_type].flags[Ship::Type_Info_Flags::Targeted_by_huge_Ignored_by_small_only])) {
+			if ( (lep->type == OBJ_SHIP) && Ship_info[Ships[lep->instance].ship_info_index].is_big_or_huge() ) {
 				tentative_return = true;
 				continue;
 			}
@@ -2404,11 +2433,6 @@ void ai_turret_execute_behavior(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
@@ -2429,10 +2453,8 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)

 	//none of our guns can hit the enemy, so find a new enemy
 	if (num_valid == 0) {
-		if (!ss->flags[Ship::Subsystem_Flags::Forced_target]) {
-			ss->turret_enemy_objnum = -1;
-			ss->turret_time_enemy_in_range = 0.0f;
-		}
+		ss->turret_enemy_objnum = -1;
+		ss->turret_time_enemy_in_range = 0.0f;

 		// in the original code, we returned where the "tentative return" variable was set,
 		// so return for real now, since we don't have a reason to remain in the function
@@ -2440,16 +2462,8 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 			return;
 	}

-	// if we've got Forced_subsys_target targeted_subsys *really* shouldnt be null but just in case...
-	if (ss->flags[Ship::Subsystem_Flags::Forced_subsys_target] && ss->targeted_subsys != nullptr) {
-		if (ss->targeted_subsys->current_hits <= 0.0f) {
-			ss->flags.remove(Ship::Subsystem_Flags::Forced_subsys_target);
-			ss->flags.remove(Ship::Subsystem_Flags::Forced_target);
-		}
-	}
-
 	//	Maybe pick a new enemy, unless targeting has been taken over by scripting
-	if ( turret_should_pick_new_target(ss) && !ss->scripting_target_override && !(ss->flags[Ship::Subsystem_Flags::Forced_target])) {
+	if ( turret_should_pick_new_target(ss) && !ss->scripting_target_override ) {
 		Num_find_turret_enemy++;
 		int objnum = find_turret_enemy(ss, parent_objnum, &gpos, &gvec, ss->turret_enemy_objnum);

@@ -2475,10 +2489,9 @@ void ai_turret_execute_behavior(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);				
 			}
-			// 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)));
+			ss->turret_next_enemy_check_stamp = timestamp((int) (MAX(dot, 0.5f)*2000.0f) + 1000);
 		} else {
-			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
+			ss->turret_next_enemy_check_stamp = timestamp((int) (2000.0f * frand_range(0.9f, 1.1f)));	//	Check every two seconds
 		}
 	}

@@ -2667,15 +2680,8 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 			{
 				// starting animation checks
 				if (ss->turret_animation_position == MA_POS_NOT_SET) {
-					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);
+					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);
 						ss->turret_animation_position = MA_POS_SET;
 					}
 				}
@@ -2730,7 +2736,7 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 		{
 			// If nothing is OK to fire (lost track of the target?) 
 			// reset the target (so we don't continue to track what we can't hit)
-			if (tp->flags[Model::Subsystem_Flags::Turret_only_target_if_can_fire] && !(ss->flags[Ship::Subsystem_Flags::Forced_target]))
+			if (tp->flags[Model::Subsystem_Flags::Turret_only_target_if_can_fire])
 			{
 				ss->turret_enemy_objnum = -1;		//	Reset enemy objnum, find a new one next frame.
 				ss->turret_time_enemy_in_range = 0.0f;
@@ -2765,7 +2771,7 @@ void ai_turret_execute_behavior(ship *shipp, ship_subsys *ss)
 			}
 		}
 	}
-	else if (!(ss->flags[Ship::Subsystem_Flags::Forced_target]))
+	else
 	{
 		// Lost him!
 		ss->turret_enemy_objnum = -1;		//	Reset enemy objnum, find a new one next frame.
@@ -2788,20 +2794,16 @@ 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)) {
-		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, &turret_matrix);
-		if ((of_dst.xyz.x == 0) && (of_dst.xyz.z == 0)) 
-			return true; 
-		else {
-			of_dst.xyz.y = 0;
+		vm_vec_rotate( &of_dst, v2e, &ss->world_to_turret_matrix );
+		if ((of_dst.xyz.x == 0) && (of_dst.xyz.y == 0)) {
+			return true;
+		} else {
+			of_dst.xyz.z = 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.z + size_mod) >= tp->turret_base_fov)
+				if ((-of_dst.xyz.y + size_mod) >= tp->turret_y_fov)
 					return true;
 			}
 		}
@@ -2812,7 +2814,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_restricted_fov])
+	if (ss->system_info->flags[Model::Subsystem_Flags::Turret_alt_math])
 		in_fov = turret_adv_fov_test(ss, gvec, v2e, size_mod);
 	else
 		in_fov = turret_std_fov_test(ss, gvec, v2e, size_mod);
@@ -38,6 +38,7 @@
 #include "ship/ship.h"
 #include "ship/shipfx.h"
 #include "ship/shiphit.h"
+#include "species_defs/species_defs.h"
 #include "stats/scoring.h"
 #include "weapon/weapon.h"

@@ -49,12 +50,14 @@ asteroid_obj	Asteroid_objs[MAX_ASTEROID_OBJS];	// array used to store asteroid o
 asteroid_obj	Asteroid_obj_list;						// head of linked list of asteroid_obj structs

 // used for randomly generating debris type when there are multiple sizes.
-const float SMALL_DEBRIS_WEIGHT = 8.0f;
-const float MEDIUM_DEBRIS_WEIGHT = 4.0f;
-const float LARGE_DEBRIS_WEIGHT = 1.0f;
+#define SMALL_DEBRIS_WEIGHT	8
+#define MEDIUM_DEBRIS_WEIGHT	4
+#define LARGE_DEBRIS_WEIGHT	1

 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];
@@ -71,55 +74,6 @@ 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.
 */
@@ -205,28 +159,43 @@ 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 bool asteroid_in_inner_bound(asteroid_field *asfieldp, vec3d *pos, float delta) {
+static int asteroid_in_inner_bound(asteroid_field *asfieldp, vec3d *pos, float delta) {

-	if (!asfieldp->has_inner_bound)
-		return false;
+	if (!asfieldp->has_inner_bound) {
+		return 0;
+	}

-	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);
+	return (asteroid_in_inner_bound_with_axes(asfieldp, pos, delta) == 7);
 }

 /**
@@ -288,7 +257,7 @@ object *asteroid_create(asteroid_field *asfieldp, int asteroid_type, int asteroi
 		return NULL;
 	}

-	if((asteroid_type < 0) || (asteroid_type >= (int)Asteroid_info.size())) {
+	if((asteroid_type < 0) || (asteroid_type >= (((int)Species_info.size() + 1) * NUM_DEBRIS_SIZES))) {
 		return NULL;
 	}

@@ -356,7 +325,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, false);
+    objnum = obj_create(OBJ_ASTEROID, -1, n, &orient, &pos, radius, asteroid_default_flagset);
 	
 	if ( (objnum == -1) || (objnum >= MAX_OBJECTS) ) {
 		mprintf(("Couldn't create asteroid -- out of object slots\n"));
@@ -366,8 +335,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_MOTION) {
-		asp->model_instance_num = model_create_instance(objnum, asip->model_num[asteroid_subtype]);
+	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]);
 	}

 	// Add to Asteroid_used_list
@@ -519,6 +488,31 @@ static void asteroid_load(int asteroid_info_index, int asteroid_subtype)
 	}
 }

+/**
+ * Returns a weight that depends on asteroid size.
+ *
+ * The weight is then used to determine the frequencty of different sizes of ship debris
+ */
+static int get_debris_weight(int ship_debris_index)
+{
+	int size = ship_debris_index % NUM_DEBRIS_SIZES;
+	switch (size)
+	{
+		case ASTEROID_TYPE_SMALL:
+			return SMALL_DEBRIS_WEIGHT;
+
+		case ASTEROID_TYPE_MEDIUM:
+			return MEDIUM_DEBRIS_WEIGHT;
+
+		case ASTEROID_TYPE_LARGE:
+			return LARGE_DEBRIS_WEIGHT;
+
+		default:
+			Int3();
+			return 1;
+	}
+}
+
 /**
 * Create all the asteroids for the mission
 */
@@ -528,14 +522,14 @@ 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 Random::next()%max_weighted_range,
+	// choose next type from table ship_debris_odds_table by rand()%max_weighted_range,
 	// the threshold *below* which the debris type is selected.
 	struct {
-		float random_threshold;
+		int random_threshold;
 		int debris_type;
 	} ship_debris_odds_table[MAX_ACTIVE_DEBRIS_TYPES];

-	float max_weighted_range = 0.0f;
+	int max_weighted_range = 0;

 	if (!Asteroids_enabled)
 		return;
@@ -544,11 +538,6 @@ 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;
@@ -563,7 +552,7 @@ void asteroid_create_all()

 		// Calculate the odds table
 		for (idx=0; idx<num_debris_types; idx++) {
-			float debris_weight = Asteroid_info[Asteroid_field.field_debris_type[idx]].spawn_weight;
+			int debris_weight = get_debris_weight(Asteroid_field.field_debris_type[idx]);
 			ship_debris_odds_table[idx].random_threshold = max_weighted_range + debris_weight;
 			ship_debris_odds_table[idx].debris_type = Asteroid_field.field_debris_type[idx];
 			max_weighted_range += debris_weight;
@@ -601,24 +590,16 @@ void asteroid_create_all()
 			// For asteroid, load only large asteroids

 			// get a valid subtype
-			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--;
-				}
+			int subtype = rand() % NUM_DEBRIS_POFS;
+			while (Asteroid_field.field_debris_type[subtype] == -1) {
+				subtype = (subtype + 1) % NUM_DEBRIS_POFS;
 			}

-			if (subtype >= 0)
-				asteroid_create(&Asteroid_field, ASTEROID_TYPE_LARGE, subtype);
+			asteroid_create(&Asteroid_field, ASTEROID_TYPE_LARGE, subtype);
 		} else {
 			Assert(num_debris_types > 0);

-			float rand_choice = frand() * max_weighted_range;
+			int rand_choice = rand() % max_weighted_range;

 			for (idx=0; idx<MAX_ACTIVE_DEBRIS_TYPES; idx++) {
 				// for ship debris, choose type according to odds table
@@ -638,13 +619,11 @@ void asteroid_level_init()
 {
 	Asteroid_field.num_initial_asteroids=0;
 	Num_asteroids = 0;
-	Asteroid_targets.clear();
-	Default_asteroid_throwing_behavior = true;
+	Next_asteroid_throw = timestamp(1);
 	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;
 }

 /**
@@ -780,75 +759,52 @@ static void asteroid_aim_at_target(object *objp, object *asteroid_objp, float de
 }

 /**
-* 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.
+ * Call once per frame to maybe throw an asteroid at a ship.
 *
+ * @param count asteroids already targeted on
 */
-static void maybe_throw_asteroid()
+static void maybe_throw_asteroid(int count)
 {
+	if (!timestamp_elapsed(Next_asteroid_throw)) {
+		return;
+	}

-	for (asteroid_target& target : Asteroid_targets) {
-		if (!timestamp_elapsed(target.throw_stamp))
-			continue;
+	if (Asteroid_throw_objnum == -1) {
+		return;
+	}

-		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;
+	nprintf(("AI", "Incoming asteroids: %i\n", count));

-		nprintf(("AI", "Incoming asteroids to %s: %i\n", Ships[target_objp->instance].ship_name, target.incoming_asteroids));
+	if (count > The_mission.ai_profile->max_incoming_asteroids[Game_skill_level])
+		return;

-		target.throw_stamp = timestamp(1000 + 1200 * target.incoming_asteroids /(Game_skill_level+1));
+	Next_asteroid_throw = timestamp(1000 + 1200 * count/(Game_skill_level+1));

-		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;
+	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;
+			}
+			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;
+
+					if ( MULTIPLAYER_MASTER ) {
+						send_asteroid_throw( objp );
+					}
 				}
-				else
-					counter--;
 			}
-		}

-		// this really shouldn't happen but just in case...
-		if (subtype < 0)
 			return;
-
-		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 );
-				}
-			}
 		}
 	}

@@ -870,13 +826,6 @@ 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);
@@ -915,14 +864,7 @@ 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);
-					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;
+					Asteroids[objp->instance].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);
@@ -1002,9 +944,9 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 				vec3d normal;

 				if (mc.model_instance_num >= 0)
-					model_instance_local_to_global_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
+					model_instance_find_world_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
 				else
-					model_local_to_global_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);
+					model_find_world_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);

 				*hitnormal = normal;
 			}
@@ -1034,11 +976,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 rotation is less than 30 degree in frame
+	// Collision detection from rotation enabled if at rotaion 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 = true;
+		asteroid_hit_info->collide_rotate = 1;
 		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
@@ -1046,11 +988,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 = false;
+			asteroid_hit_info->collide_rotate = 0;
 			vm_vec_sub( &asteroid_hit_info->light_rel_vel, &lighter->phys_info.vel, &heavy->phys_info.vel );
 		}
 	} else {
-		asteroid_hit_info->collide_rotate = false;
+		asteroid_hit_info->collide_rotate = 0;
 		vm_vec_sub( &asteroid_hit_info->light_rel_vel, &lighter->phys_info.vel, &heavy->phys_info.vel );
 	}

@@ -1082,18 +1024,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 moving submodels and test one at a time
+				// We collide with the sphere, find the list of rotating submodels and test one at a time
 				SCP_vector<int> submodel_vector;
-				model_get_moving_submodel_list(submodel_vector, heavy_obj);
+				model_get_rotating_submodel_list(&submodel_vector, heavy_obj);

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

-				// Only check single submodel now, since children of moving submodels are handled as moving as well
-				mc.flags = copy_flags | MC_SUBMODEL;
+				// reset flags to check MC_CHECK_MODEL | MC_CHECK_SPHERELINE and maybe MC_CHECK_INVISIBLE_FACES and MC_SUBMODEL_INSTANCE
+				mc.flags = copy_flags | MC_SUBMODEL_INSTANCE;

 				// check each submodel in turn
 				for (auto submodel: submodel_vector) {
@@ -1102,9 +1044,15 @@ 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)
+					angles copy_angles = smi->angs;
+
 					// find the start and end positions of the sphere in submodel RF
-					model_instance_global_to_local_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos, true);
-					model_instance_global_to_local_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);
+					smi->angs = smi->prev_angs;
+					world_find_model_instance_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos);
+
+					smi->angs = copy_angles;
+					world_find_model_instance_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);

 					mc.p0 = &p0;
 					mc.p1 = &p1;
@@ -1117,18 +1065,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, true);
+							set_hit_struct_info(asteroid_hit_info, &mc, SUBMODEL_ROT_HIT);

 							// set up asteroid_hit_info for rotating submodel
-							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);
+							if (asteroid_hit_info->edge_hit == 0) {
+								model_instance_find_obj_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
 							}

 							// 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_local_to_global_point(&asteroid_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
+							model_instance_find_world_point(&asteroid_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
 						}
 					}
 					// Don't look at this submodel again
@@ -1149,11 +1097,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, false);
+					set_hit_struct_info(asteroid_hit_info, &mc, SUBMODEL_NO_ROT_HIT);

 					// get collision normal if not edge hit
-					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);
+					if (asteroid_hit_info->edge_hit == 0) {
+						model_instance_find_obj_dir(&asteroid_hit_info->collision_normal, &mc.hit_normal, pm, pmi, mc.hit_submodel, &heavy_obj->orient);
 					}

 					// find position in submodel RF of light object at collison
@@ -1178,7 +1126,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, false);
+			set_hit_struct_info(asteroid_hit_info, &mc, SUBMODEL_NO_ROT_HIT);

 			// set normal if not edge hit
 			if ( !asteroid_hit_info->edge_hit ) {
@@ -1402,7 +1350,7 @@ static void asteroid_do_area_effect(object *asteroid_objp)
 		if ( weapon_area_calc_damage(ship_objp, &asteroid_objp->pos, asip->inner_rad, asip->outer_rad, asip->blast, asip->damage, &blast, &damage, asip->outer_rad) == -1 )
 			continue;

-		ship_apply_global_damage(ship_objp, asteroid_objp, &asteroid_objp->pos, damage, asip->damage_type_idx);
+		ship_apply_global_damage(ship_objp, asteroid_objp, &asteroid_objp->pos, damage );
 		weapon_area_apply_blast(NULL, ship_objp, &asteroid_objp->pos, blast, 0);
 	}	// end for
 }
@@ -1510,14 +1458,9 @@ 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);

-		if (hooked) {
-			Script_system.SetHookObject("Self", pasteroid_obj);
-			skip = Script_system.IsConditionOverride(CHA_DEATH, pasteroid_obj);
-		}
-		if (!skip)
+		Script_system.SetHookObject("Self", pasteroid_obj);
+		if(!Script_system.IsConditionOverride(CHA_DEATH, pasteroid_obj))
 		{
 			pasteroid_obj->flags.set(Object::Object_Flags::Should_be_dead);

@@ -1567,7 +1510,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 += Random::next(num_roids_var);
+							num_roids += rand() % num_roids_var;

 						if (num_roids > 0)
 							for (int i=0; i<num_roids; i++)
@@ -1622,10 +1565,8 @@ static void asteroid_maybe_break_up(object *pasteroid_obj)
 			}
 			asp->final_death_time = timestamp(-1);
 		}
-		if (hooked) {
-			Script_system.RunCondition(CHA_DEATH, pasteroid_obj);
-			Script_system.RemHookVar("Self");
-		}
+		Script_system.RunCondition(CHA_DEATH, pasteroid_obj);
+		Script_system.RemHookVar("Self");
 	}
 }

@@ -1847,7 +1788,7 @@ static void asteroid_parse_section(asteroid_info *asip)
 	}

 	required_string("$Detail distance:");
-	asip->num_detail_levels = (int)stuff_int_list(asip->detail_distance, MAX_ASTEROID_DETAIL_LEVELS, RAW_INTEGER_TYPE);
+	asip->num_detail_levels = stuff_int_list(asip->detail_distance, MAX_ASTEROID_DETAIL_LEVELS, RAW_INTEGER_TYPE);

 	required_string("$Max Speed:");
 	stuff_float(&asip->max_speed);
@@ -1861,7 +1802,7 @@ static void asteroid_parse_section(asteroid_info *asip)
 	
 	if(optional_string("$Explosion Animations:")){
 		int temp[MAX_FIREBALL_TYPES];
-		auto parsed_ints = stuff_int_list(temp, MAX_FIREBALL_TYPES, RAW_INTEGER_TYPE);
+		int parsed_ints = stuff_int_list(temp, MAX_FIREBALL_TYPES, RAW_INTEGER_TYPE);
 		asip->explosion_bitmap_anims.clear();
 		asip->explosion_bitmap_anims.insert(asip->explosion_bitmap_anims.begin(), temp, temp+parsed_ints);
 	}
@@ -1908,81 +1849,20 @@ static void asteroid_parse_section(asteroid_info *asip)
 		} else
 			Warning(LOCATION, "Invalid asteroid reference %i used for $Split in asteroids table, ignoring.", split_type);
 	}
-
-	if (optional_string("$Spawn Weight:")) {
-		stuff_float(&asip->spawn_weight);
-		if (asip->spawn_weight <= 0.0f) {
-			Warning(LOCATION, "Spawn weight for asteroid '%s' must be greater than 0", asip->name);
-			asip->spawn_weight = 1.0f;
-		}
-	} else {
-		switch (Asteroid_info.size() % NUM_DEBRIS_SIZES)
-		{
-			case ASTEROID_TYPE_SMALL:
-				asip->spawn_weight = SMALL_DEBRIS_WEIGHT;
-				break;
-			case ASTEROID_TYPE_MEDIUM:
-				asip->spawn_weight = MEDIUM_DEBRIS_WEIGHT;
-				break;
-			case ASTEROID_TYPE_LARGE:
-				asip->spawn_weight = LARGE_DEBRIS_WEIGHT;
-				break;
-			default:
-				UNREACHABLE("Here be dragons");
-		}
-	}
-}
-
-// changes the name to "[species] Debris" if it had a name like "[species] debris #"
-void maybe_change_asteroid_name(asteroid_info* asip) {
-
-	SCP_string name = asip->name;
-	size_t split = std::string::npos;
-
-	for (species_info species : Species_info) {
-		if (name.compare(0, strlen(species.species_name), species.species_name) == 0) {
-			split = strlen(species.species_name);
-			break;
-		}
-	}
-
-	if (split == std::string::npos)
-		return;
-
-	SCP_string remaining_name = name.substr(split + 1, name.length());
-
-	split = remaining_name.find(' ');
-
-	if (split == std::string::npos)
-		return;
-
-	SCP_string debris = remaining_name.substr(0, split);
-	SCP_string num = remaining_name.substr(split + 1, remaining_name.length());
-
-	if (stricmp(debris.c_str(), "Debris") != 0)
-		return;
-
-	if (num.empty() || std::find_if(num.begin(), num.end(), [](char c) {
-	                       return !std::isdigit(c, SCP_default_locale);
-	                   }) != num.end())
-		return;
-
-	// make sure this asteroid would correspond the 'species section' of the old style retail asteroids
-	if (Asteroid_info.size() < NUM_DEBRIS_SIZES + Species_info.size() * NUM_DEBRIS_SIZES && Asteroid_info.size() >= NUM_DEBRIS_SIZES) {
-		int idx = (int)(Asteroid_info.size()) / NUM_DEBRIS_SIZES - 1;
-		strcpy_s(asip->name, Species_info[idx].species_name);
-		strcat(asip->name, " ");
-		strcat(asip->name, XSTR("debris", 348));
-	}
 }

 /**
 Read in data from asteroid.tbl into Asteroid_info[] array.

-After this function is complete, the Asteroid_info[] array 
-will have at least 3 generic asteroids plus whatever else 
-special ones were added in the table.  The generic asteroids are 
-a set of small, medium, and large asteroids in that exact order.
+After this function is completes, the Asteroid_info[] array will
+contain exactly three asteroids per species plus exactly three
+generic asteroids.  These three asteroids are a set
+of small, medium, and large asteroids in that exact order.
+
+If asteroid.tbl contains too many or too few asteroids as per
+the rules above this function will abort the engine with an
+error message stating the number expected and it will write
+to the debug.log how everything was parsed.

 Note that by saying "asteroid" this code is talking about
 the asteroids and the debris that make up asteroid fields
@@ -1994,6 +1874,12 @@ that is being protected.
 static void asteroid_parse_tbl()
 {
 	char impact_ani_file[MAX_FILENAME_LEN];
+
+	// How did we get here without having any species defined?
+	Assertion(!Species_info.empty(),
+		"Cannot parse asteroids/debris if there "
+		"are no species for them to belong to."
+		);
 	
 	try
 	{
@@ -2003,6 +1889,8 @@ static void asteroid_parse_tbl()
 		required_string("#Asteroid Types");

 		size_t tally = 0;
+		size_t max_asteroids =
+			NUM_DEBRIS_SIZES + Species_info.size() * NUM_DEBRIS_SIZES;

 #ifndef NDEBUG
 		SCP_vector<SCP_string> parsed_asteroids;
@@ -2015,41 +1903,82 @@ static void asteroid_parse_tbl()

 			asteroid_parse_section(&new_asteroid);

-			maybe_change_asteroid_name(&new_asteroid);
-
-#ifndef NDEBUG
-			SCP_string msg;
-			msg.append("Parsing asteroid: '");
-			msg.append(new_asteroid.name);
-			msg.append("' as a '");
-			msg.append((tally >= NUM_DEBRIS_SIZES) ? "generic" : "special");
-			msg.append("'");
-			switch (tally % NUM_DEBRIS_SIZES) {
-			case ASTEROID_TYPE_SMALL:
-				msg.append(" small\n");
-				break;
-			case ASTEROID_TYPE_MEDIUM:
-				msg.append(" medium\n");
-				break;
-			case ASTEROID_TYPE_LARGE:
-				msg.append(" large\n");
-				break;
-			default:
-				Error(LOCATION, "Get a coder! Math has broken!\n"
-					"Important numbers:\n"
-					"\ttally: " SIZE_T_ARG "\n"
-					"\tNUM_DEBRIS_SIZES: %d\n",
-					tally, NUM_DEBRIS_SIZES
-					);
-				msg.append(" unknown\n");
-			}
-			parsed_asteroids.push_back(msg);
+			size_t species = tally / NUM_DEBRIS_SIZES;
+			if (tally >= max_asteroids)
+			{
+#ifdef NDEBUG
+				// Bump the warning count in release so they get something
+				// even if the message never gets displayed.
+				Warning(LOCATION, "Ignoring extra asteroid/debris");
+#else
+				SCP_string msg("Ignoring extra asteroid/debris '");
+				msg.append(new_asteroid.name);
+				msg.append("'\n");
+				Warning(LOCATION, "%s", msg.c_str());
+				parsed_asteroids.push_back(msg);
 #endif
-			Asteroid_info.push_back(new_asteroid);
+			}
+			else
+			{
+#ifndef NDEBUG
+				SCP_string msg;
+				msg.append("Parsing asteroid: '");
+				msg.append(new_asteroid.name);
+				msg.append("' as a '");
+				msg.append((species == 0) ? "generic" : Species_info[species - 1].species_name);
+				msg.append("'");
+				switch (tally % NUM_DEBRIS_SIZES) {
+				case ASTEROID_TYPE_SMALL:
+					msg.append(" small\n");
+					break;
+				case ASTEROID_TYPE_MEDIUM:
+					msg.append(" medium\n");
+					break;
+				case ASTEROID_TYPE_LARGE:
+					msg.append(" large\n");
+					break;
+				default:
+					Error(LOCATION, "Get a coder! Math has broken!\n"
+						"Important numbers:\n"
+						"\ttally: " SIZE_T_ARG "\n"
+						"\tNUM_DEBRIS_SIZES: %d\n",
+						tally, NUM_DEBRIS_SIZES
+						);
+					msg.append(" unknown\n");
+				}
+				parsed_asteroids.push_back(msg);
+#endif
+				Asteroid_info.push_back(new_asteroid);
+			}
 			tally++;
 		}
 		required_string("#End");

+		if (tally != max_asteroids)
+		{
+#ifndef NDEBUG
+			mprintf(("Asteroid.tbl as parsed:\n"));
+			for (SCP_vector<SCP_string>::iterator iter = parsed_asteroids.begin();
+				iter != parsed_asteroids.end(); ++iter)
+			{
+				mprintf(("%s\n", iter->c_str()));
+			}
+#endif
+			Error(LOCATION,
+				"Found " SIZE_T_ARG " asteroids/debris when " SIZE_T_ARG " expected\n\n"
+				"<Number expected> = <Number of species> * %d + %d generic asteroids\n"
+				SIZE_T_ARG " = " SIZE_T_ARG "*%d + %d\n\n"
+#ifdef NDEBUG
+				"Run a debug build to see a list of all parsed asteroids\n",
+#else
+				"See the debug.log for a listing of all parsed asteroids\n",
+#endif
+				tally, max_asteroids,
+				NUM_DEBRIS_SIZES, NUM_DEBRIS_SIZES,
+				max_asteroids, Species_info.size(), NUM_DEBRIS_SIZES, NUM_DEBRIS_SIZES
+				);
+		}
+
 		Asteroid_impact_explosion_ani = -1;
 		required_string("$Impact Explosion:");
 		stuff_string(impact_ani_file, F_NAME, MAX_FILENAME_LEN);
@@ -2090,6 +2019,29 @@ 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.
@@ -2104,10 +2056,17 @@ 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 (asteroid_is_ship_inside_field(&Asteroid_field, &ship_objp->pos, ship_objp->radius))
-				return so->objnum;
+			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;
 		}
 	}
 	return -1;
@@ -2124,18 +2083,9 @@ void asteroid_frame()
 		return;
 	}

-	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]);
-		}
-	} 
+	Asteroid_throw_objnum = set_asteroid_throw_objnum();

-	sanitize_asteroid_targets_list();
-
-	maybe_throw_asteroid();
+	maybe_throw_asteroid(count_incident_asteroids());
 }

 /**
@@ -36,11 +36,6 @@ 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 {
@@ -78,8 +73,6 @@ public:
 	int			model_num[NUM_DEBRIS_POFS];
 	SCP_vector<int> explosion_bitmap_anims;
 	float		fireball_radius_multiplier;						// the model radius is multiplied by this to determine the fireball size
-	SCP_string	display_name;									// only used for hud targeting display and for 'ship' asteroids
-	float		spawn_weight;									// ship asteroids only, relative proportion to spawn compared to other types in its asteroid field

 	asteroid_info( )
 		: num_detail_levels( 0 ), max_speed( 0 ), damage_type_idx( 0 ),
@@ -143,7 +136,6 @@ 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;
@@ -171,7 +163,6 @@ 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);
@@ -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 (Random::next(24))
+		switch (myrand()%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,8 +795,7 @@ bool StartAutopilot()
 		vm_vec_scale(&perp,  Autopilot_flight_leader->radius+radius);

 		// randomly scale up/down by up to 20%
-		// jg18 - original comment said [-20,20] but preserving existing behavior
-		j = Random::next(-19, 20);
+		j = 20-myrand()%40; // [-20,20]

 		vm_vec_scale(&perp, 1.0f+(float(j)/100.0f));
 		vm_vec_add(&cameraPos, &pos, &perp);
@@ -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 dir_type) {
+int bm_load(const char *real_filename) {
 	int free_slot = -1;
 	int w, h, bpp = 8;
 	int rc = 0;
@@ -1152,7 +1152,6 @@ int bm_load(const char *real_filename, int dir_type) {
 	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...
@@ -1165,11 +1164,11 @@ int bm_load(const char *real_filename, int dir_type) {
 	// 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, dir_type))
+		if (bm_load_sub_fast(filename, &handle))
 			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, dir_type);
+		int rval = bm_load_sub_slow(filename, BM_NUM_TYPES, bm_ext_list, &img_cfp);

 		if (rval < 0)
 			return -1;
@@ -1225,7 +1224,7 @@ int bm_load(const char *real_filename, int dir_type) {
 	entry->bm.palette = nullptr;
 	entry->num_mipmaps = mm_lvl;
 	entry->mem_taken = (size_t)bm_size;
-	entry->dir_type = dir_type;
+	entry->dir_type = CF_TYPE_ANY;
 	entry->handle = handle;

 	entry->load_count++;
@@ -1236,8 +1235,8 @@ int bm_load(const char *real_filename, int dir_type) {
 	return handle;
 }

-int bm_load(const SCP_string& filename, int dir_type) {
-	return bm_load(filename.c_str(), dir_type);
+int bm_load(const SCP_string& filename) {
+	return bm_load(filename.c_str());
 }

 bool bm_load_and_parse_eff(const char *filename, int dir_type, int *nframes, int *nfps, int *key, BM_TYPE *type) {
@@ -1425,7 +1424,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, bool rethrow_exceptions) {
+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	i, n;
 	anim	the_anim;
 	CFILE	*img_cfp = nullptr;
@@ -1467,7 +1466,6 @@ 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...
@@ -1596,15 +1594,10 @@ 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);
-			if (rethrow_exceptions) {
-				throw e;
-			}
-			else {
-				mprintf(("Failed to load apng: %s\n", e.what()));
-				return -1;
-			}
+			return -1;
 		}
 	}
 	else {
@@ -1796,7 +1789,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, dir_type);
+		tidx = bm_load(filename);
 		if (tidx != -1 && nframes != NULL)
 			*nframes = 1;
 	}
@@ -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 dir_type = CF_TYPE_ANY);
+int bm_load(const char* filename);

 /**
 * @brief Loads a bitmap so we can draw with it later. (Preferred version)
@@ -187,7 +187,7 @@ int bm_load(const char* filename, int dir_type = CF_TYPE_ANY);
 * @returns The bitmap number if successful, else
 * @returns a negative value if not
 */
-int bm_load(const SCP_string& filename, int dir_type = CF_TYPE_ANY);
+int bm_load(const SCP_string& filename);

 /**
 * @brief Reloads a bitmap as a duplicate.
@@ -289,14 +289,7 @@ 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 = false,
-	int dir_type = CF_TYPE_ANY,
-	bool rethrow_exceptions = false);
+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);

 /**
 * @brief Loads either animation (bm_load_animation) or still image (bm_load)
@@ -43,7 +43,7 @@ auto FovOption = options::OptionBuilder<float>("Graphics.FOV", "Field Of View",
                     .finish();

 //*************************CLASS: camera*************************
-//This is where the camera class begins! :D
+//This is where the camera class beings! :D
 camera::camera(const char *in_name, int in_signature)
 {
 	set_name(in_name);
@@ -237,15 +237,12 @@ void camera::set_rotation_facing(vec3d *in_target, float in_rotation_time, float
 {
 	matrix temp_matrix = IDENTITY_MATRIX;

-	if (in_target != nullptr)
+	if(in_target != NULL)
 	{
-		vec3d position;
-		matrix orient_buf;
-		auto orient = Use_host_orientation_for_set_camera_facing ? &orient_buf : nullptr;
+		vec3d position = vmd_zero_vector;
+		this->get_info(&position, NULL);

-		this->get_info(&position, orient, false);
-
-		if (vm_vec_same(in_target, &position))
+		if(in_target->xyz.x == position.xyz.x && in_target->xyz.y == position.xyz.y && in_target->xyz.z == position.xyz.z)
 		{
 			Warning(LOCATION, "Camera tried to point to self");
 			return;
@@ -253,25 +250,7 @@ void camera::set_rotation_facing(vec3d *in_target, float in_rotation_time, float

 		vec3d targetvec;
 		vm_vec_normalized_dir(&targetvec, in_target, &position);
-
-		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);
-		}
+		vm_vector_2_matrix(&temp_matrix, &targetvec, NULL, NULL);
 	}

 	set_rotation(&temp_matrix, in_rotation_time, in_rotation_acceleration_time, in_rotation_deceleration_time);
@@ -319,16 +298,13 @@ float camera::get_fov()
 }

 eye* get_submodel_eye(polymodel *pm, int submodel_num);
-void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_orientation)
+void camera::get_info(vec3d *position, matrix *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())
 	{
@@ -366,19 +342,16 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 					Assertion(objp->type == OBJ_SHIP, "This part of the code expects the object to be a ship");

 					vec3d c_pos_in;
-					model_instance_local_to_global_point_dir(&c_pos_in, &host_normal, &eyep->pnt, &eyep->norm, pm, pmi, eyep->parent);
+					find_submodel_instance_point_normal(&c_pos_in, &host_normal, pm, pmi, eyep->parent, &eyep->pnt, &eyep->norm);
 					vm_vec_unrotate(&c_pos, &c_pos_in, &objp->orient);
 					vm_vec_add2(&c_pos, &objp->pos);
 				}
 				else
 				{
 					if (pmi != nullptr)
-					{
-						model_instance_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;
-					}
+						model_instance_find_world_point(&c_pos, &pt, pm, pmi, object_host_submodel, &objp->orient, &objp->pos);
 					else
-						model_local_to_global_point( &c_pos, &pt, pm, object_host_submodel, &objp->orient, &objp->pos );
+						model_find_world_point( &c_pos, &pt, pm, object_host_submodel, &objp->orient, &objp->pos );
 				}
 			}
 		}
@@ -394,7 +367,7 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 		}
 	}

-	if (position != nullptr)
+	if(position != NULL)
 		*position = c_pos;

 	//ORIENTATION
@@ -405,32 +378,32 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 		{
 			if(object_target.IsValid())
 			{
-				object *target_objp = object_target.objp;
-				int model_num = object_get_model(target_objp);
-				polymodel *target_pm = nullptr;
-				polymodel_instance *target_pmi = nullptr;
+				object *objp = object_target.objp;
+				int model_num = object_get_model(objp);
+				polymodel *pm = nullptr;
+				polymodel_instance *pmi = nullptr;
 				vec3d target_pos = vmd_zero_vector;
 				
 				//See if we can get the model
 				if(model_num >= 0)
 				{
-					target_pm = model_get(model_num);
-					if (target_objp->type == OBJ_SHIP)
-						target_pmi = model_get_instance(Ships[target_objp->instance].model_instance_num);
+					pm = model_get(model_num);
+					if (objp->type == OBJ_SHIP)
+						pmi = model_get_instance(Ships[objp->instance].model_instance_num);
 				}

 				//If we don't have a submodel or don't have the model use object pos
 				//Otherwise, find the submodel pos as it is rotated
-				if (object_target_submodel < 0 || target_pm == nullptr)
+				if(object_target_submodel < 0 || pm == NULL)
 				{
-					target_pos = target_objp->pos;
+					target_pos = objp->pos;
 				}
 				else
 				{
-					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);
+					if (pmi != nullptr)
+						model_instance_find_world_point(&target_pos, &vmd_zero_vector, pm, pmi, object_target_submodel, &objp->orient, &objp->pos);
 					else
-						model_local_to_global_point( &target_pos, &vmd_zero_vector, target_pm, object_target_submodel, &target_objp->orient, &target_objp->pos );
+						model_find_world_point( &target_pos, &vmd_zero_vector, pm, object_target_submodel, &objp->orient, &objp->pos );
 				}

 				vec3d targetvec;
@@ -445,10 +418,6 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 					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;
@@ -459,30 +428,23 @@ void camera::get_info(vec3d *position, matrix *orientation, bool apply_camera_or
 				c_ori = vmd_identity_matrix;
 			}

-			//Do custom orientation stuff, if needed
-			if (func_custom_orientation != nullptr && !target_set)
+			matrix mtxA = c_ori;
+			matrix mtxB = IDENTITY_MATRIX;
+			float pos = 0.0f;
+			for(int i = 0; i < 9; i++)
 			{
-				func_custom_orientation(this, &c_ori);
+				ori[i].get(&pos, NULL);
+				mtxB.a1d[i] = pos;
 			}
+			vm_matrix_x_matrix(&c_ori, &mtxA, &mtxB);

-			// 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);
-			}
+			vm_orthogonalize_matrix(&c_ori);
+		}
+		//Do custom orientation stuff, if needed
+		if(func_custom_orientation != NULL && !target_set)
+		{
+			func_custom_orientation(this, &c_ori);
 		}
-
 		*orientation = c_ori;
 	}
 }
@@ -598,9 +560,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, 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)
+	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)
 {
 	// Initialize color
 	gr_init_color(&text_color, 0, 0, 0);
@@ -611,6 +573,7 @@ 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;
@@ -622,6 +585,7 @@ 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];
@@ -644,7 +608,6 @@ 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);
@@ -683,7 +646,7 @@ subtitle::subtitle(int in_x_pos, int in_y_pos, const char* in_text, const char*
 			if(w > tw)
 				tw = w;

-			th += fl2i(line_height_factor * h);
+			th += h;
 		}

 		// restore old font
@@ -781,7 +744,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 += fl2i(line_height_factor * font_height);
+		y += font_height;
 	}

 	// restore old font
@@ -830,9 +793,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;
@@ -75,7 +75,7 @@ public:
 	object *get_object_target();
 	int get_object_target_submodel();
 	float get_fov();
-	void get_info(vec3d *position, matrix *orientation, bool apply_camera_orientation = true);
+	void get_info(vec3d *position, matrix *orientation);

 	//Is
 	bool is_empty(){return sig < 0;}
@@ -123,7 +123,6 @@ private:
 	float fade_time;
 	color text_color;
 	int text_fontnum;
-	float line_height_factor;

 	//Done with set
 	char imageanim[MAX_FILENAME_LEN];
@@ -140,8 +139,7 @@ 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,
-			 float in_line_height_factor = 1.0f);
+			 bool center_x = false, bool center_y = false, int in_width = 0, int in_height = 0, bool post_shaded=false);
 	~subtitle();

    subtitle(const subtitle &sub) { clone(sub); }
@@ -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 .jpg .dds .fs2 .txt",		CF_TYPE_DATA	},
+	{ CF_TYPE_MULTI_CACHE,			"data" DIR_SEPARATOR_STR "multidata",										".pcx .png .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,7 +91,6 @@ 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

@@ -288,7 +287,7 @@ static int _cfile_chdir(const char *new_dir, const char *cur_dir __UNUSED)
 	const char *colon = strchr(new_dir, ':');

 	if (colon) {
-		if (!cfile_chdrive(SCP_tolower(*(colon - 1)) - 'a' + 1, 1))
+		if (!cfile_chdrive(tolower(*(colon - 1)) - 'a' + 1, 1))
 			return 1;

 		path = colon + 1;
@@ -306,7 +305,7 @@ static int _cfile_chdir(const char *new_dir, const char *cur_dir __UNUSED)
 	status = _chdir(path);
 	if (status != 0) {
 #ifdef _WIN32
-		cfile_chdrive(SCP_tolower(cur_dir[0]) - 'a' + 1, 1);
+		cfile_chdrive(tolower(cur_dir[0]) - 'a' + 1, 1);
 #endif /* _WIN32 */
 		return 2;
 	}
@@ -867,7 +866,6 @@ static int cfget_cfile_block()
 			cfile->data = nullptr;
 			cfile->fp = nullptr;
 			cfile->type = CFILE_BLOCK_USED;
-			cf_clear_compression_info(cfile);
 			return i;
 		}
 	}
@@ -923,7 +921,7 @@ int cfclose( CFILE * cfile )
 	} else {
 		// VP  do nothing
 	}
-	cf_clear_compression_info(cfile);
+
 	cfile->type = CFILE_BLOCK_UNUSED;
 	return result;
 }
@@ -975,7 +973,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;
 	}
 }
@@ -1010,7 +1008,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;
 	}

@@ -1054,7 +1052,6 @@ 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) {
@@ -81,10 +81,9 @@ 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                                                                                              \
-	41 // Can be as high as you'd like //DTP; yeah but beware alot of things uses 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

 // TRUE if type is specified and valid
 #define CF_TYPE_SPECIFIED(path_type) (((path_type)>CF_TYPE_INVALID) && ((path_type)<CF_MAX_PATH_TYPES))
@@ -24,7 +24,6 @@

 #include "cfile/cfile.h"
 #include "cfile/cfilearchive.h"
-#include "cfile/cfilecompression.h"
 #include "luaconf.h"

 #include <sstream>
@@ -34,6 +33,7 @@
 #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,33 +54,6 @@ 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
@@ -88,11 +61,11 @@ void cf_clear_compression_info(CFILE* cfile)
 // 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)
@@ -119,8 +92,6 @@ 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) {
@@ -146,9 +117,6 @@ 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 );
 	
@@ -234,31 +202,23 @@ 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)
-	//Raw position is not the fp position with compressed files
-    if (cfile->fp && cfile->compression_info.header == 0) {
+    if (cfile->fp) {
 		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)
@@ -306,3 +266,4 @@ int cfread_lua_number(double *buf, CFILE *cfile)
 	return items_read;

 }
+
@@ -7,6 +7,7 @@
 *
 */ 

+
 #ifndef _CFILEARCHIVE_H
 #define _CFILEARCHIVE_H

@@ -22,17 +23,6 @@
 #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
@@ -54,19 +44,12 @@ 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);
-
-// 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);
+void cf_init_lowlevel_read_code( CFILE * cfile, size_t lib_offset, size_t size, size_t pos );

 #endif
@@ -1,206 +0,0 @@
-#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;
-}
@@ -1,66 +0,0 @@
-/*
-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
@@ -220,8 +220,6 @@ 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
@@ -248,13 +246,11 @@ 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

@@ -278,6 +274,7 @@ cmdline_parm gameclosed_arg("-closed", NULL, AT_NONE);		// Cmdline_closed_game
 cmdline_parm gamerestricted_arg("-restricted", NULL, AT_NONE);	// Cmdline_restricted_game
 cmdline_parm port_arg("-port", "Multiplayer network port", AT_INT);
 cmdline_parm multilog_arg("-multilog", NULL, AT_NONE);		// Cmdline_multi_log
+cmdline_parm client_dodamage("-clientdamage", NULL, AT_NONE);	// Cmdline_client_dodamage
 cmdline_parm pof_spew("-pofspew", NULL, AT_NONE);			// Cmdline_spew_pof_info
 cmdline_parm weapon_spew("-weaponspew", nullptr, AT_STRING);			// Cmdline_spew_weapon_stats
 cmdline_parm mouse_coords("-coords", NULL, AT_NONE);			// Cmdline_mouse_coords
@@ -290,6 +287,7 @@ char *Cmdline_game_password = NULL;
 char *Cmdline_rank_above = NULL;
 char *Cmdline_rank_below = NULL;
 int Cmdline_cd_check = 1;
+int Cmdline_client_dodamage = 0;
 int Cmdline_closed_game = 0;
 int Cmdline_freespace_no_music = 0;
 int Cmdline_freespace_no_sound = 0;
@@ -379,23 +377,21 @@ int Cmdline_rearm_timer = 0;
 int Cmdline_targetinfo = 0;

 // Gameplay related
-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 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 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
@@ -442,8 +438,6 @@ 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
@@ -462,8 +456,6 @@ 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
@@ -489,7 +481,6 @@ 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
@@ -497,7 +488,6 @@ 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;
@@ -522,7 +512,6 @@ 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;
@@ -530,7 +519,6 @@ 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);
@@ -824,7 +812,7 @@ void os_validate_parms(int argc, char *argv[])
 				if (!stricmp(token, "-help") || !stricmp(token, "--help") || !stricmp(token, "-h") || !stricmp(token, "-?")) {
 					printf("FreeSpace 2 Open, version %s\n", FS_VERSION_FULL);
 					printf("Website: http://scp.indiegames.us\n");
-					printf("Github (bug reporting): https://github.com/scp-fs2open/fs2open.github.com/issues\n\n");
+					printf("Mantis (bug reporting): http://scp.indiegames.us/mantis/\n\n");
 					printf("Usage: fs2_open [options]\n");

 					// not the prettiest thing but the job gets done
@@ -1331,7 +1319,6 @@ 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);
 	}
@@ -1423,7 +1410,24 @@ static json_t* json_get_v1() {
 		json_object_set_new(root, "openal", openal_obj);
 	}
 	{
-		auto joystick_array = io::joystick::getJsonArray();
+		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);
+		}

 		json_object_set_new(root, "joysticks", joystick_array);
 	}
@@ -1615,7 +1619,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';
 		}
 	}
@@ -1625,9 +1629,8 @@ bool SetCmdlineParams()
 		Cmdline_game_password = gamepassword_arg.str();

 		// be sure that this string fits in our limits
-		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';
+		if ( strlen(Cmdline_game_name) > MAX_PASSWD_LEN ) {
+			Cmdline_game_name[MAX_PASSWD_LEN-1] = '\0';
 		}
 	}

@@ -1660,6 +1663,12 @@ bool SetCmdlineParams()
 		Cmdline_multi_log = 1;
 	}	

+
+	// maybe use old-school client damage
+	if(client_dodamage.found()){
+		Cmdline_client_dodamage = 1;
+	}	
+
 	// spew pof info
 	if(pof_spew.found()){
 		Cmdline_spew_pof_info = 1;
@@ -1712,7 +1721,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>\".\n", Cmdline_res));
+			mprintf(("Failed to parse -res parameter \"%s\". Must be in format \"<width>x<height>\".", Cmdline_res));
 		}
 	}
 	if(center_res_arg.found()){
@@ -1838,10 +1847,6 @@ bool SetCmdlineParams()
 		Cmdline_no_screenshake = 1;
 	}
 	
-	if ( deadzone.found() ) {
-		Cmdline_deadzone = deadzone.get_int();
-	}
-
 	if ( stretch_menu.found() )	{
 		Cmdline_stretch_menu = 1;
 	}
@@ -2126,11 +2131,6 @@ bool SetCmdlineParams()
 		Cmdline_benchmark_mode = true;
 	}

-	if (pilot_arg.found())
-	{
-		Cmdline_pilot = pilot_arg.str();
-	}
-
 	if (noninteractive_arg.found())
 	{
 		Cmdline_noninteractive = true;
@@ -2158,10 +2158,6 @@ 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;
@@ -2263,22 +2259,6 @@ 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; 
 }
@@ -30,6 +30,7 @@ extern char *Cmdline_game_password;
 extern char *Cmdline_rank_above;
 extern char *Cmdline_rank_below;
 extern int Cmdline_cd_check;
+extern int Cmdline_client_dodamage;
 extern int Cmdline_closed_game;
 extern int Cmdline_freespace_no_music;
 extern int Cmdline_freespace_no_sound;
@@ -83,13 +84,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,8 +124,6 @@ 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
@@ -145,7 +144,6 @@ 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;
@@ -153,7 +151,6 @@ 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;
@@ -15,72 +15,69 @@

 #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 axis value from an array.
+ * These are used to index a corresponding joystick axis value from an array.
 * Currently only used by ::Axis_map_to[] and ::Axis_map_to_defaults[]
 */
-enum Joy_axis_index : short {
+enum Joy_axis_index {
 	JOY_X_AXIS		=0,
 	JOY_Y_AXIS,
 	JOY_Z_AXIS,
 	JOY_RX_AXIS,
 	JOY_RY_AXIS,
-	JOY_RZ_AXIS,
-
-	JOY_NUM_AXES	// Number of axes a joystick may have. Must be last enum in Joy_axis_index.
+	JOY_RZ_AXIS
 };

-// 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
+ * These are used to index a corresponding (analog) action, namely controlling the orientation angles and throttle.
 */
-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
+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
 };

+
+
 /*!
 * 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_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
+	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
 };

+/*!
+ * Control configuration item type.
+ */
+typedef struct config_item {
+	short key_default;		//!< default key bound to action
+	short joy_default;		//!< default joystick button bound to action
+	char tab;				//!< what tab (category) it belongs in
+	int indexXSTR;			//!< what string index we should use to translate this with an XSTR
+	const char *text;		//!< describes the action in the config screen
+	char type;				//!< manner control should be checked in
+	short key_id;			//!< actual key bound to action
+	short joy_id;			//!< joystick button bound to action
+	int used;				//!< has control been used yet in mission?  If so, this is the timestamp
+	bool disabled;			//!< whether this action should be available at all
+	bool continuous_ongoing;//!< whether this action is a continuous one and is currently ongoing
+} config_item;
+
 /*!
 * All available actions
 * This is the value of the id field in config_item
 * The first group of items are ship targeting.
- *
- * Note: Do not adjust the order or numeric value
 */
-enum IoActionId : int {
+enum IoActionId  {
 	TARGET_NEXT										=0,		//!< target next
 	TARGET_PREV										=1,		//!< target previous
 	TARGET_NEXT_CLOSEST_HOSTILE						=2,		//!< target the next hostile target
@@ -255,7 +252,7 @@ enum IoActionId : int {
 	DOWN_SLIDE_THRUST								=111,	//!< DOWN_SLIDE_THRUST
 	HUD_TARGETBOX_TOGGLE_WIREFRAME					=112,	//!< HUD_TARGETBOX_TOGGLE_WIREFRAME
 	VIEW_TOPDOWN									=113,	//!< VIEW_TOPDOWN
-	VIEW_TRACK_TARGET								=114,	//!< VIEW_TRACK_TARGET (Switfty) Toggle for VM_Track
+	VIEW_TRACK_TARGET								=114,	//!< VIEW_TRACK_TARGET

 	//!< @n
 	//!< AutoPilot - Kazan
@@ -282,644 +279,69 @@ enum IoActionId : int {
 	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:
-	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& 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 not equal to the given CC_bind
-	 */
-	bool operator!=(const CC_bind &B) const;
-
-	/*!
-	 * Checks if this CC_bind is equal to the given CC_bind, disregarding the inversion flag
-	 */
-	bool invert_agnostic_equals(const CC_bind &B) const;
-
-	/*!
-	 * Clears the binding and flags.  Some flags are retained.
-	 */
-	void clear();
-
-	/*!
-	 * True if not bound
-	 */
-	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.
-};
-
-/*!
- * A pair of bindings.
- * @note Please don't set the bindings directly, use ::take() instead.
- */
-class CCB {
-public:
-	CC_bind first;  // The primary binding
-	CC_bind second; // The secondary binding
-
-public:
-	CCB() = default;
-	CCB(const CCB& A) = default;
-
-	/*!
-	 * Returns true if nothing is bound
-	 */
-	bool empty() const;
-
-	/*!
-	 * Takes a given binding
-	 *
-	 * @param[in] A     The bind to take
-	 * @param[in] order 0 is primary, 1 is secondary, -1 is overwrite existing bind (if any)
-	 *
-	 * @note Should there be a binding to the same controller as the given binding, it is cleared
-	 */
-	void take(CC_bind A, int order);
-
-	/*!
-	 * Clears both bindings
-	 */
-	void clear();
-
-	/*!
-	 * Gets the value of btn if either CC_bind has the given CID
-	 *
-	 * @returns the btn of the bound controller, or
-	 * @returns -1 if that controller is not bound
-	 */
-	short get_btn(CID) const;
-
-	/*!
-	 * Assigns the contents of the given CCB to this CCB
-	 */
-	CCB& operator=(const CCB&) = default;
-
-	/*!
-	 * Checks if the given CCB is exactly equal to this
-	 */
-	bool operator==(const CCB&);
-
-	/*!
-	 * Checks if the given CCB differs from this
-	 */
-	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);
-};
-
-/*!
- * A preset, a collection of bindings for use in Control_config with an associated name
- */
-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&);
-};
-
-/*!
- * Control configuration item type.
- * @detail Contains binding info, documentation, behavior, etc. for a single control
- */
-class CCI : public CCB {
-public:
-// Inherited from CCB
-	// CC_bind first;
-	// CC_bind second;
-
-// Items Set in menu
-	char tab;               //!< what tab (category) it belongs in
-	int  indexXSTR;         //!< what string index we should use to translate this with an XSTR 0 = None, 1= Use item index + CONTROL_CONFIG_XSTR, 2 <= use CCI::indexXSTR directly
-	SCP_string text;        //!< describes the action in the config screen
-
-	CC_type type;           //!< manner control should be checked in
-
-// Items used during gameplay
-	int  used;                  //!< has control been used yet in mission?  If so, this is the timestamp
-	bool disabled = true;       //!< whether this action should be available at all
-	bool continuous_ongoing;    //!< whether this action is a continuous one and is currently ongoing
-
-public:
-	CCI() = default;
-	CCI(const CCI& A) = default;
-	
-	/*!
-	 * Assigns the contents of the given CCI to this CCI
-	 */
-	CCI& operator=(const CCI&);
-
-	/*!
-	 * @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();
-};
-
-/*!
- * Builder predicate to populate a ControlConfig vector with hardcoded default bindings.
- */
-class CCI_builder {
-public:
-	/*!
-	 * Initilizes the given ControlConfig vector
-	 */
-	CCI_builder(SCP_vector<CCI>& _ControlConfig);
-
-	/*!
-	 * Start a chain of factory methods. If there are any pre-init work to be done, that's done here.
-	 */
-	CCI_builder& start();
-
-	/*!
-	 * End a chain of factory methods.  If there any post-init work to be done, that's done here.
-	 */
-	void end();
-
-	/*!
-	 * 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 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
-	SCP_vector<CCI>& ControlConfig;
-};
-
-
 extern int Failed_key_index;

+extern int Axis_map_to[];
+extern int Invert_axis[];
+extern int Invert_axis_defaults[];
+
 extern int Joy_dead_zone_size;
 extern int Joy_sensitivity;

 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 config_item Control_config[];		//!< Stores the keyboard configuration
+extern SCP_vector<config_item*> Control_config_presets; // tabled control presets; pointers to config_item arrays
+extern SCP_vector<SCP_string> Control_config_preset_names; // names for Control_config_presets (identical order of items)
 extern const char **Scan_code_text;
-extern const char **Joy_button_text;			// String table of button labels.  XSTR'd on init.
+extern const char **Joy_button_text;

-// string table constants for labels and stuff.
-#define NUM_AXIS_TEXT			JOY_NUM_AXES
-#define NUM_MOUSE_TEXT			MOUSE_NUM_BUTTONS
+void control_config_common_init();			//!< initialize common control config stuff - call at game startup after localization has been initialized
+void control_config_common_close();			//!< close common control config stuff - call at game shutdown

-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
- *
- * @returns  0  if its the first element, or
- * @returns  1  if its the second element, or
- * @returns -1  if neither
- */
-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
-*/
-void control_config_common_init();
-
-/*!
- * @brief close common control config stuff - call at game shutdown
- */
-void control_config_common_close();
-
-/*!
- * @brief init config menu
- */
 void control_config_init();
-
-/*!
- * @brief do a frame of the config menu
- */
 void control_config_do_frame(float frametime);
-
-/*!
- * @brief close config menu
- */
 void control_config_close();

-/*!
- * @brief Cancel configuration of controls, revert any changes, return to previous menu/game state
- */
 void control_config_cancel_exit();

-/*!
- * @brief Copies all bindings within preset into Control_config
- */
-void control_config_use_preset(CC_preset &preset);
-
-/*!
- * @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.
- *
- * @details If find_override is set to true, then this returns the index of the action
- */
+void control_config_reset_defaults(int presetnum=-1);
 int translate_key_to_index(const char *key, bool find_override=true);
-
-
-/*!
- * @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 cstring) to a certain 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, 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
- */
-const char *translate_key(char *key);
+char *translate_key(char *key);

 /**
- * @brief Converts the specified key code to a human readable string, according to the selected locale
+ * @brief Converts the specified key code to a human readable string
 *
- * @param[in]   code    The key code to convert
- * @param[in]   use_default_locale  If true, return the default locale (English) translation of the key
+ * @note The returned value is localized to the current language
 *
- * @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
+ * @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.
 */
-const char *textify_scancode(int code, bool use_default_locale = false);
+const char *textify_scancode(int code);

-/*!
- * @brief Checks how long a control has been active
- *
- * @param[in] id The IoActionId of the control to check
- *
- * @returns Time, in milliseconds, that the control has been active.
- *
- * @note This function is only to be used on CC_CONTINOUS type controls, or it will trigger an assertion
+/**
+ * @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);
+
 float check_control_timef(int id);
-
-/**
- * @brief Wrapper for check_control_used. Allows the game to ignore the key if told to do so by the ignore-key SEXP.
- *
- * @param[in] id    The IoActionId of the control to check
- * @param[in] key   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[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
- *
- * @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 *axis_v, float frame_time);
-
-/**
- * @brief Markes the given control (by IoActionId) as used
- *
- * @details Updates the ::used timestamp, triggers a script hook, and marks ::continous_ongoing as true
- */
+void control_get_axes_readings(int *h, int *p, int *b, int *ta, int *tr);
 void control_used(int id);
-
-/**
- * @brief Clears the bindings of all controls
- */
 void control_config_clear();
-
-/**
- * @brief debug function used to indicate number of controls checked
- */
 void control_check_indicate();
-
-/**
- * @brief Clears the used timestamp of all controls
- */
 void control_config_clear_used_status();

-/**
- * @brief Applies sensitivity multiplier and deadzone histerisis to the raw axis value
- *
- * @param[in] raw  The raw axis value to transform
- *
- * @return The transformed value
- */
 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
@@ -1,481 +0,0 @@
-#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));
-}
@@ -1,222 +0,0 @@
-#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);
@@ -93,12 +93,13 @@ 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();

@@ -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], MAX_TEXT_LINE_LEN);
+									  Cutscene_max_text_lines[gr_screen.res]);
 				Assert(Text_size >= 0 && Text_size < Cutscene_max_text_lines[gr_screen.res]);
 			}
 		}
@@ -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, nullptr, 0);
+	auto videoStream = av_find_best_stream(ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &status->videoCodec, 0);
 	if (videoStream < 0) {
 		if (videoStream == AVERROR_STREAM_NOT_FOUND) {
 			mprintf(("FFmpeg: No video stream found in file!\n"));
@@ -242,26 +242,10 @@ 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, nullptr, 0);
+		audioStream = av_find_best_stream(ctx, AVMEDIA_TYPE_AUDIO, -1, videoStream, &status->audioCodec, 0);
 		if (audioStream < 0) {
 			if (audioStream == AVERROR_STREAM_NOT_FOUND) {
 				mprintf(("FFmpeg: No audio stream found in file!\n"));
@@ -270,21 +254,17 @@ 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();

@@ -298,19 +278,15 @@ 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;
-			// 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);
+			status->subtitleStreamIndex = subtStream;
 		}
 	}

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

@@ -336,6 +312,13 @@ 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);
@@ -365,6 +348,8 @@ 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);

@@ -391,6 +376,11 @@ 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);

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

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

 	for (auto ext : CHECKED_SUBT_EXTENSIONS) {
 		SCP_string fileName;
@@ -463,7 +453,7 @@ bool FFMPEGDecoder::initialize(const SCP_string& fileName, const PlaybackPropert
 {
 	SCP_string movieName = fileName;
 	// First make the file name lower case
-	SCP_tolower(movieName);
+	std::transform(movieName.begin(), movieName.end(), movieName.begin(), [](char c) { return (char)::tolower(c); });

 	// Then remove the extension
 	size_t dotPos = movieName.find('.');
@@ -24,13 +24,13 @@ struct DecoderStatus {
 	int videoStreamIndex = -1;
 	AVStream* videoStream = nullptr;
 	CodecContextParameters videoCodecPars;
-	const AVCodec* videoCodec = nullptr;
+	AVCodec* videoCodec = nullptr;
 	AVCodecContext* videoCodecCtx = nullptr;

 	int audioStreamIndex = -1;
 	AVStream* audioStream = nullptr;
 	CodecContextParameters audioCodecPars;
-	const AVCodec* audioCodec = nullptr;
+	AVCodec* audioCodec = nullptr;
 	AVCodecContext* audioCodecCtx = nullptr;

 	// Subtitles are a bit different since they max come from a different file
@@ -38,15 +38,17 @@ struct DecoderStatus {
 	int subtitleStreamIndex = -1;
 	AVStream* subtitleStream = nullptr;
 	CodecContextParameters subtitleCodecPars;
-	const AVCodec* subtitleCodec = nullptr;
+	AVCodec* subtitleCodec = nullptr;
 	AVCodecContext* subtitleCodecCtx = nullptr;

 	DecoderStatus();

 	~DecoderStatus();

-	DecoderStatus(const DecoderStatus&) = delete;
-	DecoderStatus& operator=(const DecoderStatus&) = delete;
+ private:
+	DecoderStatus(const DecoderStatus&) SCP_DELETED_FUNCTION;
+
+	DecoderStatus& operator=(const DecoderStatus&) SCP_DELETED_FUNCTION;
 };

 template<typename Frame>
@@ -65,8 +67,8 @@ class FFMPEGStreamDecoder {
 	explicit FFMPEGStreamDecoder(DecoderStatus* status);
 	virtual ~FFMPEGStreamDecoder();

-	FFMPEGStreamDecoder(const FFMPEGStreamDecoder&) = delete;
-	FFMPEGStreamDecoder& operator=(const FFMPEGStreamDecoder&) = delete;
+	FFMPEGStreamDecoder(const FFMPEGStreamDecoder&) SCP_DELETED_FUNCTION;
+	FFMPEGStreamDecoder& operator=(const FFMPEGStreamDecoder&) SCP_DELETED_FUNCTION;

 	virtual void decodePacket(AVPacket* packet) = 0;

@@ -205,14 +205,14 @@ void movie_display_loop(Player* player, PlaybackState* state) {
 	auto fpsCapSave = Cmdline_NoFPSCap;
 	Cmdline_NoFPSCap = 1;

-	auto lastDisplayTime = timer_get_microseconds();
+	auto lastDisplayTimestamp = timer_get_microseconds();
 	while (state->playing) {
 		TRACE_SCOPE(tracing::CutsceneStep);

-		auto now = timer_get_microseconds();
+		auto timestamp = timer_get_microseconds();

-		auto passed = now - lastDisplayTime;
-		lastDisplayTime = now;
+		auto passed = timestamp - lastDisplayTimestamp;
+		lastDisplayTimestamp = timestamp;

 		if (player->isPlaybackReady()) {
 			// Play as long as the player reports that there is more to display
@@ -30,9 +30,8 @@
 #include "ship/ship.h"
 #include "ship/shipfx.h"
 #include "species_defs/species_defs.h"
-#include "tracing/Monitor.h"
-#include "utils/Random.h"
 #include "weapon/weapon.h"
+#include "tracing/Monitor.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
@@ -52,6 +51,8 @@ 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(
@@ -74,7 +75,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 + Random::next(FIREBALL_NUM_LARGE_EXPLOSIONS);
+			fireball_type = FIREBALL_EXPLOSION_LARGE1 + rand()%FIREBALL_NUM_LARGE_EXPLOSIONS;
 		}
 		fireball_create( &debris_obj->pos, fireball_type, FIREBALL_LARGE_EXPLOSION, OBJ_INDEX(debris_obj), debris_obj->radius*1.75f);

@@ -195,6 +196,34 @@ 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
@@ -217,7 +246,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);
+			obj_snd_assign(objnum, db->ambient_sound, &vmd_zero_vector, 0);
 			db->sound_delay = 0;
 		}
 	}
@@ -231,6 +260,8 @@ 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
@@ -243,7 +274,7 @@ void debris_process_post(object * obj, float frame_time)

 		if (db->is_hull)	{

-			int n, n_arcs = Random::next(1, 3);		// Create 1-3 sparks
+			int n, n_arcs = ((rand()>>5) % 3)+1;		// Create 1-3 sparks

 			vec3d v1, v2, v3, v4;

@@ -252,7 +283,8 @@ void debris_process_post(object * obj, float frame_time)

 			n = 0;

-			int lifetime = Random::next(100, 1000);
+			int a = 100, b = 1000;
+			int lifetime = (myrand()%((b)-(a)+1))+(a);

 			// Create the spark effects
 			for (int i=0; i<MAX_DEBRIS_ARCS; ++i)	{
@@ -319,8 +351,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 = Random::next();
-				if ( mr < Random::MAX_VALUE/5 )	{
+				int mr = myrand();
+				if ( mr < RAND_MAX/5 )	{
 					vec3d v1, v2;

 					submodel_get_two_random_points_better(db->model_num, db->submodel_num, &v1, &v2);
@@ -392,6 +424,17 @@ 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 > 200.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
@@ -414,38 +457,8 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d

 	db = &Debris[n];

-	if (!hull_flag) {
-		if (model_num >= 0) {
-			db->model_num = model_num;
-			db->submodel_num = Random::next(sip->generic_debris_num_submodels);
-		}
-		else if (vaporize) {
-			db->model_num = Debris_vaporize_model;
-			db->submodel_num = Random::next(Debris_num_submodels);
-		}
-		else {
-			db->model_num = Debris_model;
-			db->submodel_num = Random::next(Debris_num_submodels);
-		}
-	}
-	else {
-		db->model_num = model_num;
-		db->submodel_num = submodel_num;
-	}
-
-	float radius = submodel_get_radius(db->model_num, db->submodel_num);
-
-	// 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;
-		}
-	}
+	//WMC - We must survive until now, at least.
+	db->must_survive_until = timestamp();

 	if(hull_flag && sip->debris_min_lifetime >= 0.0f && sip->debris_max_lifetime >= 0.0f)
 	{
@@ -455,16 +468,14 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 	{
 		// Create Debris piece n!
 		if ( hull_flag ) {
-			if (Random::next() < (Random::MAX_VALUE/6))	// Make some pieces blow up shortly after explosion.
-				db->lifeleft = 2.0f * (frand()) + 0.5f;
+			if (rand() < RAND_MAX/6)	// Make some pieces blow up shortly after explosion.
+				db->lifeleft = 2.0f * (myrand() * RAND_MAX_1f) + 0.5f;
 			else {
 				db->flags.set(Debris_Flags::DoNotExpire);
 				db->lifeleft = -1.0f;		// large hull pieces stay around forever
 			}
-		} else { 
-			// small non-hull pieces should stick around longer the larger they are
-			// sqrtf should make sure its never too crazy long
-			db->lifeleft = (frand() * 2.0f + 0.1f) * sqrtf(radius);
+		} else {
+			db->lifeleft = (myrand() * RAND_MAX_1f) * 2.0f + 0.1f;
 		}
 	}

@@ -473,10 +484,12 @@ 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;
 		}
@@ -501,6 +514,7 @@ 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;

@@ -519,9 +533,25 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 		db->arc_frequency = 0;
 	}

+	if ( model_num < 0 )	{
+		if (vaporize) {
+			db->model_num = Debris_vaporize_model;
+		} else {
+			db->model_num = Debris_model;
+		}
+		db->submodel_num = (myrand()>>4) % Debris_num_submodels;
+	} else {
+		db->model_num = model_num;
+		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 );
+
 	db->next_fireball = timestamp_rand(500,2000);	//start one 1/2 - 2 secs later

-	if ( pos == nullptr )
+	if ( pos == NULL )
 		pos = &source_obj->pos;

    flagset<Object::Object_Flags> default_flags;
@@ -529,18 +559,10 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
    default_flags.set(Object::Object_Flags::Physics);
    default_flags.set(Object::Object_Flags::Collides, hull_flag != 0);

-	matrix orient = source_obj->orient;
-	if (!db->is_hull) {
-		// non-hull debris has no relation to its parent orientation
-		vec3d rand;
-		vm_vec_rand_vec(&rand);
-		vm_vector_2_matrix(&orient, &rand);
-	}
-
-	objnum = obj_create(OBJ_DEBRIS, parent_objnum, n, &orient, pos, radius, default_flags, false);
+    objnum = obj_create( OBJ_DEBRIS, parent_objnum, n, &source_obj->orient, pos, radius, default_flags);
 	if ( objnum == -1 ) {
 		mprintf(("Couldn't create debris object -- out of object slots\n"));
-		return nullptr;
+		return NULL;
 	}

 	db->objnum = objnum;
@@ -548,8 +570,6 @@ 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;
@@ -592,7 +612,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d

 	if ( hull_flag )	{
 		float t;
-		scale = exp_force * i2fl(Random::next(10, 29));	// for radial_vel away from location of blast center
+		scale = exp_force * i2fl((myrand()%20) + 10);	// 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
@@ -604,7 +624,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 + Random::next(fl2i(1000*3*Objects[db->source_objnum].radius));
+		t = 1000*Objects[db->source_objnum].radius/3 + myrand()%(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 ) {
@@ -615,7 +635,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 		}
 	}
 	else {
-		scale = exp_force * i2fl(Random::next(10, 29));	// for radial_vel away from blast center (non-hull)
+		scale = exp_force * i2fl((myrand()%20) + 10);	// for radial_vel away from blast center (non-hull)
 	}

 	if ( vm_vec_mag_squared( &to_center ) < 0.1f )	{
@@ -642,7 +662,7 @@ object *debris_create(object *source_obj, int model_num, int submodel_num, vec3d
 		radius = 1.0f;
 	}

-	scale = (6.0f + i2fl(Random::next(4))) / radius;
+	scale = ( 6.0f + i2fl(myrand()%4) ) / radius;

 	vm_vec_rand_vec_quick(&rotvel);
 	vm_vec_scale(&rotvel, scale);
@@ -775,9 +795,9 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 				vec3d normal;

 				if (mc.model_instance_num >= 0)
-					model_instance_local_to_global_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
+					model_instance_find_world_dir(&normal, &mc.hit_normal, mc.model_instance_num, mc.hit_submodel, mc.orient);
 				else
-					model_local_to_global_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);
+					model_find_world_dir(&normal, &mc.hit_normal, mc.model_num, mc.hit_submodel, mc.orient);

 				*hitNormal = normal;
 			}
@@ -811,18 +831,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 rotation is less than 30 degree in frame
+	// Collision detection from rotation enabled if at rotaion 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 = true;
+		debris_hit_info->collide_rotate = 1;
 		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 = false;
+		debris_hit_info->collide_rotate = 0;
 		vm_vec_sub(&debris_hit_info->light_rel_vel, &lighter->phys_info.vel, &heavy->phys_info.vel);
 	}

@@ -854,18 +874,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 moving submodels and test one at a time
+				// We collide with the sphere, find the list of rotating submodels and test one at a time
 				SCP_vector<int> submodel_vector;
-				model_get_moving_submodel_list(submodel_vector, heavy_obj);
+				model_get_rotating_submodel_list(&submodel_vector, heavy_obj);

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

-				// Only check single submodel now, since children of moving submodels are handled as moving as well
-				mc.flags = copy_flags | MC_SUBMODEL;
+				// 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;

 				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;
@@ -878,9 +898,15 @@ 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)
+					angles copy_angles = smi->angs;
+
 					// find the start and end positions of the sphere in submodel RF
-					model_instance_global_to_local_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos, true);
-					model_instance_global_to_local_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);
+					smi->angs = smi->prev_angs;
+					world_find_model_instance_point(&p0, &light_obj->last_pos, pm, pmi, submodel, &heavy_obj->last_orient, &heavy_obj->last_pos);
+
+					smi->angs = copy_angles;
+					world_find_model_instance_point(&p1, &light_obj->pos, pm, pmi, submodel, &heavy_obj->orient, &heavy_obj->pos);

 					mc.p0 = &p0;
 					mc.p1 = &p1;
@@ -893,19 +919,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, 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_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 up debris_hit_info for rotating submodel
-							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);
+							if (debris_hit_info->edge_hit == 0) {
+								model_instance_find_obj_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_local_to_global_point(&debris_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
+							model_instance_find_world_point(&debris_hit_info->light_collision_cm_pos, &int_light_pos, pm, pmi, mc.hit_submodel, &heavy_obj->orient, &zero);
 						}
 					}

@@ -926,11 +952,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, false);
+					set_hit_struct_info(debris_hit_info, &mc, SUBMODEL_NO_ROT_HIT);

 					// get collision normal if not edge hit
-					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);
+					if (debris_hit_info->edge_hit == 0) {
+						model_instance_find_obj_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
@@ -956,7 +982,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, false);
+			set_hit_struct_info(debris_hit_info, &mc, SUBMODEL_NO_ROT_HIT);

 			// set normal if not edge hit
 			if ( !debris_hit_info->edge_hit ) {
@@ -1090,7 +1116,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_DAMAGED );
+				model_instance_add_arc( pm, pmi, db->submodel_num, &db->arc_pts[i][0], &db->arc_pts[i][1], MARC_TYPE_NORMAL );
 			}
 		}
 	}
@@ -1101,7 +1127,7 @@ void debris_render(object * obj, model_draw_list *scene)
 		MONITOR_INC(NumHullDebrisRend, 1);
 	} else {
 		MONITOR_INC(NumSmallDebrisRend, 1);
-		// render_info.set_flags(MR_NO_LIGHTING);
+		render_info.set_flags(MR_NO_LIGHTING);
 	}

 	submodel_render_queue( &render_info, scene, pm, pmi, db->submodel_num, &obj->orient, &obj->pos );
@@ -1120,19 +1146,3 @@ bool debris_is_vaporized(debris *db)
 {
 	return db->model_num == Debris_vaporize_model;
 }
-
-void create_generic_debris(object* ship_objp, vec3d* pos, float min_num_debris, float max_num_debris, float speed_mult, bool use_ship_debris) {
-	Assertion(ship_objp->type == OBJ_SHIP, "create_generic_debris called for a non-ship, only ships can spew debris!");
-	if (ship_objp->type != OBJ_SHIP)
-		return;
-
-	float num_debris = frand_range(min_num_debris, max_num_debris);
-
-	num_debris *= (Detail.num_small_debris + 0.5f) / 4.5f;
-
-	vec3d create_pos = *pos;
-	for (int i = 0; i < num_debris; i++) {
-		int model_num = use_ship_debris ? Ship_info[Ships[ship_objp->instance].ship_info_index].generic_debris_model_num : -1;
-		debris_create(ship_objp, model_num, -1, &create_pos, pos, 0, speed_mult);
-	}
-}
@@ -40,15 +40,17 @@ 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
 	int		next_fireball;			// When to start a fireball
-	int		is_hull;				// indicates whether this is a collideable, destructable piece of debris from the model, or just a generic debris fragment
+	int		is_hull;				// indicates a large hull chunk of debris
 	int		species;				// What species this is from.  -1 if don't care.
 	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
@@ -80,8 +82,4 @@ void debris_remove_from_hull_list(debris *db);
 bool debris_is_generic(debris *db);
 bool debris_is_vaporized(debris *db);

-// creates a burst of generic debris at hitpos from ship_objp, with a random number between min and max
-// use_ship_debris is for whether the ship's generic debris should be used, or simply debris01.pof
-void create_generic_debris(object* ship_objp, vec3d* hitpos, float min_num_debris, float max_num_debris, float speed_mult, bool use_ship_debris);
-
 #endif // _DEBRIS_H
@@ -244,9 +244,6 @@ 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",
@@ -273,9 +270,6 @@ struct Decal {
 			if (smi->blown_off) {
 				return false;
 			}
-		} else {
-			Assertion(false, "Only ships are currently supported for decals!");
-			return false;
 		}

 		return true;
@@ -411,7 +405,7 @@ matrix4 getDecalTransform(Decal& decal) {
 	auto pm = model_get(pmi->model_num);

 	vec3d worldPos;
-	model_instance_local_to_global_point(&worldPos,
+	model_instance_find_world_point(&worldPos,
 									&decal.position,
 									pm,
 									pmi,
@@ -420,21 +414,16 @@ matrix4 getDecalTransform(Decal& decal) {
 									&objp->pos);

 	vec3d worldDir;
-	model_instance_local_to_global_dir(&worldDir,
+	model_instance_find_world_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_local_to_global_dir(&worldUp,
-								  &decal.orientation.vec.uvec,
+	model_instance_find_world_dir(&worldUp,
+								  &decal.orientation.vec.fvec,
 								  pm,
 								  pmi,
 								  decal.submodel,
@@ -65,23 +65,15 @@ void GetLightInfo(vec3 position, out vec3 lightDir, out float attenuation)
 		if (lightType == LT_TUBE) {  // Tube light
 			float beamLength = length(beamVec);
 			vec3 beamDir = beamVec / beamLength;
-			//The actual 'lighting element' is shorter than the light volume cylinder
-			//To compensate the light is moved forward along the beam one radius and the length shortened
-			//this allows room for clean falloff of the light past the ends of beams.
-			vec3 adjustedLightPos = lightPosition - (beamDir * lightRadius);
-			beamLength = beamLength - (lightRadius * 2.0);
-			//adjustments having been made, lightdir needs recalculating
-			lightDir = adjustedLightPos - position.xyz;
 			// Get nearest point on line
 			float neardist = clamp(dot(lightDir, beamDir), 0.0, beamLength);
 			// Move back from the endpoint of the beam along the beam by the distance we calculated
-			vec3 nearest = adjustedLightPos - beamDir * neardist;
+			vec3 nearest = lightPosition - beamDir * neardist;
 			lightDir = nearest - position.xyz;
 			dist = length(lightDir);
 			if(dist > lightRadius) {
 				discard;
 			}
-			attenuation = 1.0 - clamp(dist / lightRadius, 0.0, 1.0);
 		} else if (lightType == LT_CONE) {
 			float coneDot = dot(normalize(-lightDir), coneDir);
 			if(dualCone) {
@@ -12,7 +12,7 @@ layout (std140) uniform genericData {
 	vec3 fog_color;
 	float fog_start;

-	float fog_density;
+	float fog_scale;
 	float zNear;
 	float zFar;
 };
@@ -23,15 +23,17 @@ void main()

 	// If the scene is in fog then we change the color we operate on based on the depth of the pixel
 	float depth_val = texture(depth_tex, fragTexCoord.xy).x;
-	// Transform depth value from [0, 1] to [-1, 1]
-	float depth_normalized = 2 * depth_val - 1;
+	// Transform depth value from [-1, 1] to [0, 1]
+	float depth_normalized = fma(depth_val, 0.5, 0.5);
 	// Now we compute the depth value in projection space using the clipping plane information
 	float view_depth = 2.0 * zNear * zFar / (zFar + zNear - depth_normalized * (zFar - zNear));

 	if (isinf(view_depth)) {
 		fragOut0.rgb = color_in.rgb;
 	} else {
-		float fog_dist = clamp(1 - pow(fog_density, view_depth - fog_start) , 0.0, 1.0);
+		// 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);
+
 		vec3 finalFogColor = srgb_to_linear(fog_color);

 		fragOut0.rgb = mix(color_in.rgb, finalFogColor, fog_dist);
@@ -4,8 +4,14 @@ 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)
@@ -94,8 +94,6 @@ layout (std140) uniform modelData {
 	int sNormalmapIndex;
 	int sAmbientmapIndex;
 	int sMiscmapIndex;
-
-	float alphaMult;
 };

 in VertexOutput {
@@ -263,11 +261,6 @@ 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
@@ -436,15 +429,7 @@ void main()
 	fragOut0 = baseColor;
 #ifdef FLAG_DEFERRED
 	fragOut1 = vec4(vertIn.position.xyz, 1.0);
-
-	// 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));
-
+	fragOut2 = vec4(normal, glossData);
 	fragOut3 = vec4(specColor.rgb, fresnelFactor);
 	fragOut4 = emissiveColor;
 #endif
@@ -103,8 +103,6 @@ layout (std140) uniform modelData {
 	int sNormalmapIndex;
 	int sAmbientmapIndex;
 	int sMiscmapIndex;
-
-	float alphaMult;
 };

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

 #ifdef FLAG_TRANSFORM
@@ -7,25 +7,9 @@ uniform sampler2D tex;

 layout (std140) uniform genericData {
 	float exposure;
-	int tonemapper;
-	float x0; //from here on these are for the PPC tonemappers
-	float y0;
-
-	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
+vec3 Uncharted2Tonemapping(vec3 hdr_color)
 {
 	float A = 0.15;
 	float B = 0.50;
@@ -33,185 +17,15 @@ vec3 Uncharted2ToneMapping(vec3 hdr_color) // John Hable's filmic
 	float D = 0.20;
 	float E = 0.02;
 	float F = 0.30;
-	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;
+	return ((hdr_color*(A*hdr_color+C*B)+D*E)/(hdr_color*(A*hdr_color+B)+D*F))-E/F;
 }

-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);
-	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;
-
-	}
+	// 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
 	fragOut0 = vec4(color.rgb, 1.0);
 }
@@ -221,7 +221,6 @@ $AI:
 	+Can Form Wing:			YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 $Name:					Freighter										
 $Counts for Alone:		YES												
@@ -251,7 +250,6 @@ $AI:
 	+Active docks:			( "cargo" )								
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 $Name:					AWACS											
 $Counts for Alone:		YES												
@@ -279,7 +277,6 @@ $AI:
 	+Can Form Wing:			YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 $Name:					Gas Miner										
 $Counts for Alone:		YES												
@@ -307,7 +304,6 @@ $AI:
 	+Can Form Wing:			YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES	
 $Vaporize Percent Chance: 0.0											
 $Name:					Cruiser											
 $Counts for Alone:		YES												
@@ -335,7 +331,6 @@ $AI:
 	+Can Form Wing:			YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 $Name:					Corvette										
 $Counts for Alone:		YES												
@@ -363,7 +358,6 @@ $AI:
 	+Can Form Wing:			YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 $Name:					Capital											
 $Counts for Alone:		YES												
@@ -392,7 +386,6 @@ $AI:
 	+Can Form Wing:			YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 $Name:					Super Cap										
 $Counts for Alone:		YES												
@@ -419,7 +412,6 @@ $AI:
 	+Can Form Wing:			YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 $Name:					Drydock											
 $Counts for Alone:		YES												
@@ -444,7 +436,6 @@ $AI:
 	+Turrets attack this:	YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 $Name:					Knossos Device									
 $Counts for Alone:		YES												
@@ -467,6 +458,5 @@ $AI:
 	+Turrets attack this:	YES											
 	+Passive docks:			( "support" )								
 	+Ignored on cripple by:	( "navbuoy" "sentry gun" "escape pod" "cargo" "support" "stealth" "fighter" "bomber" "fighter/bomber" "transport" "freighter" "awacs" "gas miner" "cruiser" "corvette" "capital" "super cap" "drydock" "knossos device" )	
-	+Targeted by 'Huge' weapons and Ignored by 'small only' weapons: YES
 $Vaporize Percent Chance: 0.0											
 #End																	
@@ -14,7 +14,6 @@
 #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"
@@ -26,21 +25,19 @@
 #include <cstdlib>


-bool Knossos_warp_ani_used;
+int 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)

 #define MAX_WARP_LOD	0

-constexpr int INTITIAL_FIREBALL_CONTAINTER_SIZE = 256;
-
-SCP_vector<fireball> Fireballs;
-SCP_vector<int> Unused_fireball_indices;
+fireball Fireballs[MAX_FIREBALLS];

 fireball_info Fireball_info[MAX_FIREBALL_TYPES];

 int fireball_used[MAX_FIREBALL_TYPES];

+int Num_fireballs = 0;
 int Num_fireball_types = 0;

 bool fireballs_inited = false;
@@ -203,10 +200,6 @@ 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;
 	}
 }
@@ -291,13 +284,11 @@ 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
@@ -321,7 +312,6 @@ 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
@@ -329,7 +319,6 @@ 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:"))
 			{
@@ -337,9 +326,6 @@ 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
@@ -370,13 +356,7 @@ 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");
@@ -455,6 +435,8 @@ void fireball_load_data()
 // This will get called at the start of each level.
 void fireball_init()
 {
+	int i;
+
 	if ( !fireballs_inited ) {
 		// Do all the processing that happens only once
 		fireball_parse_tbl();
@@ -464,13 +446,13 @@ void fireball_init()
 	}
 	
 	// Reset everything between levels
-	Fireballs.clear();
-	Fireballs.reserve(INTITIAL_FIREBALL_CONTAINTER_SIZE);
-	Unused_fireball_indices.clear();
-	Unused_fireball_indices.reserve(INTITIAL_FIREBALL_CONTAINTER_SIZE);
+	Num_fireballs = 0;
+	for (i=0; i<MAX_FIREBALLS; i++ )	{
+		Fireballs[i].objnum	= -1;
+	}

 	// Goober5000 - reset Knossos warp flag
-	Knossos_warp_ani_used = false;
+	Knossos_warp_ani_used = 0;
 }

 MONITOR( NumFireballsRend )
@@ -485,15 +467,13 @@ void fireball_delete( object * obj )
 	fireball	*fb;

 	num = obj->instance;
-	// Make sure the new system works fine.
-	Assert(obj->instance > -1);
-	Assert(static_cast<int>(Fireballs.size()) > obj->instance);
 	fb = &Fireballs[num];

 	Assert( fb->objnum == OBJ_INDEX(obj));

 	Fireballs[num].objnum = -1;
-	Unused_fireball_indices.push_back(num);
+	Num_fireballs--;
+	Assert( Num_fireballs >= 0 );
 }

 /**
@@ -501,9 +481,13 @@ void fireball_delete( object * obj )
 */
 void fireball_delete_all()
 {
-	for (auto& current_fireball : Fireballs) {
-		if ( current_fireball.objnum != -1 ) {
-			obj_delete(current_fireball.objnum);
+	fireball	*fb;
+	int		i;
+
+	for ( i = 0; i < MAX_FIREBALLS; i++ ) {
+		fb = &Fireballs[i];
+		if ( fb->objnum != -1 ) {
+			obj_delete(fb->objnum);
 		}
 	}
 }
@@ -515,8 +499,6 @@ void fireball_set_framenum(int num)
 	fireball_info	*fd;
 	fireball_lod	*fl;

-	Assert(static_cast<int>(Fireballs.size()) > num);
-
 	fb = &Fireballs[num];
 	fd = &Fireball_info[Fireballs[num].fireball_info_index];

@@ -555,9 +537,6 @@ int fireball_is_perishable(object * obj)

 	num = obj->instance;
 	objnum = OBJ_INDEX(obj);
-	// Make sure the new system works fine.
-	Assert(obj->instance > -1);
-	Assert((int)Fireballs.size() > obj->instance);
 	Assert( Fireballs[num].objnum == objnum );

 	fb = &Fireballs[num];
@@ -574,6 +553,43 @@ int fireball_is_perishable(object * obj)
 	return 0;
 }

+
+/**
+ * There are too many fireballs, so delete the oldest small one
+ * to free up a slot.  
+ *
+ * @return The fireball slot freed.
+ */
+int fireball_free_one()
+{
+	fireball	*fb;
+	int		i;
+
+	int		oldest_objnum = -1, oldest_slotnum = -1;
+	float		lifeleft, oldest_lifeleft = 0.0f;
+
+	for ( i = 0; i < MAX_FIREBALLS; i++ ) {
+		fb = &Fireballs[i];
+
+		// only remove the ones that aren't warp effects
+		if ( (fb->objnum >= 0) && fireball_is_perishable(&Objects[fb->objnum]) )	{
+
+			lifeleft = fb->total_time - fb->time_elapsed;
+			if ( (oldest_objnum < 0) || (lifeleft < oldest_lifeleft) )	{
+				oldest_slotnum = i;
+				oldest_lifeleft = lifeleft;
+				oldest_objnum = fb->objnum;
+			}
+			break;
+		}
+	}
+
+	if ( oldest_objnum > -1 )	{
+		obj_delete(oldest_objnum);
+	}
+	return oldest_slotnum;
+}
+
 int fireball_is_warp(object * obj)
 {
 	int			num, objnum;
@@ -581,9 +597,6 @@ int fireball_is_warp(object * obj)

 	num = obj->instance;
 	objnum = OBJ_INDEX(obj);
-	// Make sure the new system works fine.
-	Assert(obj->instance > -1);
-	Assert(static_cast<int>(Fireballs.size()) > obj->instance);
 	Assert( Fireballs[num].objnum == objnum );

 	fb = &Fireballs[num];
@@ -628,9 +641,6 @@ void fireball_process_post(object * obj, float frame_time)

 	num = obj->instance;
 	objnum = OBJ_INDEX(obj);
-	// Make sure the new system works fine.
-	Assert(obj->instance > -1);
-	Assert(static_cast<int>(Fireballs.size()) > obj->instance);
 	Assert( Fireballs[num].objnum == objnum );

 	fb = &Fireballs[num];
@@ -655,10 +665,6 @@ float fireball_lifeleft( object *obj )

 	num = obj->instance;
 	objnum = OBJ_INDEX(obj);
-	// Make sure the new system works fine.
-	Assert(obj->instance > -1);
-	Assert(static_cast<int>(Fireballs.size()) > obj->instance);
-
 	Assert( Fireballs[num].objnum == objnum );

 	fb = &Fireballs[num];
@@ -674,10 +680,6 @@ float fireball_lifeleft_percent( object *obj )
 	int			num, objnum;
 	fireball		*fb;

-	// Make sure the new system works fine.
-	Assert(obj->instance > -1);
-	Assert(static_cast<int>(Fireballs.size()) > obj->instance);
-
 	num = obj->instance;
 	objnum = OBJ_INDEX(obj);
 	Assert( Fireballs[num].objnum == objnum );
@@ -779,8 +781,10 @@ int fireball_create(vec3d *pos, int fireball_type, int render_type, int parent_o
 {
 	int				n, objnum, fb_lod;
 	object			*obj;
+	fireball			*fb;
 	fireball_info	*fd;
 	fireball_lod	*fl;
+
 	Assert( fireball_type > -1 );
 	Assert( fireball_type < Num_fireball_types );

@@ -796,21 +800,23 @@ int fireball_create(vec3d *pos, int fireball_type, int render_type, int parent_o
 		}
 	}

-	if (Num_objects >= MAX_OBJECTS) {
-		return -1;
+	if ( (Num_fireballs >= MAX_FIREBALLS) || (Num_objects >= MAX_OBJECTS) )	{
+
+		// out of slots, so free one up.
+		n = fireball_free_one();
+		if ( n < 0 ) {
+			return -1;
+		}
+	} else {
+		for ( n = 0; n < MAX_FIREBALLS; n++ )	{
+			if ( Fireballs[n].objnum < 0  )	{
+				break;
+			}
+		}
+		Assert( n != MAX_FIREBALLS );
 	}

-
-	if (!Unused_fireball_indices.empty()) {
-		n = Unused_fireball_indices.back();
-		Unused_fireball_indices.pop_back();
-	}
-	else {
-		n = static_cast<int>(Fireballs.size());
-		Fireballs.emplace_back();
-	}
-
-	fireball* new_fireball = &Fireballs[n];
+	fb = &Fireballs[n];

 	// get an lod to use	
 	fb_lod = fireball_get_lod(pos, fd, size);
@@ -827,13 +833,13 @@ int fireball_create(vec3d *pos, int fireball_type, int render_type, int parent_o
 	}
 	fl = &fd->lod[fb_lod];

-	new_fireball->lod = (char)fb_lod;
+	fb->lod = (char)fb_lod;

-	new_fireball->flags = extra_flags;
-	new_fireball->warp_open_sound_index = warp_open_sound;
-	new_fireball->warp_close_sound_index = warp_close_sound;
-	new_fireball->warp_open_duration = (warp_open_duration < 0.0f) ? WARPHOLE_GROW_TIME : warp_open_duration;
-	new_fireball->warp_close_duration = (warp_close_duration < 0.0f) ? WARPHOLE_GROW_TIME : warp_close_duration;
+	fb->flags = extra_flags;
+	fb->warp_open_sound_index = warp_open_sound;
+	fb->warp_close_sound_index = warp_close_sound;
+	fb->warp_open_duration = (warp_open_duration < 0.0f) ? WARPHOLE_GROW_TIME : warp_open_duration;
+	fb->warp_close_duration = (warp_close_duration < 0.0f) ? WARPHOLE_GROW_TIME : warp_close_duration;

 	matrix orient;
 	if(orient_override != NULL){
@@ -848,55 +854,60 @@ 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, false);
+	objnum = obj_create(OBJ_FIREBALL, parent_obj, n, &orient, pos, size, default_flags);
+
+	if (objnum < 0) {
+		Int3();				// Get John, we ran out of objects for fireballs
+		return objnum;
+	}

 	obj = &Objects[objnum];

-	new_fireball->fireball_info_index = fireball_type;
-	new_fireball->fireball_render_type = render_type;
-	new_fireball->time_elapsed = 0.0f;
-	new_fireball->objnum = objnum;
-	new_fireball->current_bitmap = -1;
+	fb->fireball_info_index = fireball_type;
+	fb->fireball_render_type = render_type;
+	fb->time_elapsed = 0.0f;
+	fb->objnum = objnum;
+	fb->current_bitmap = -1;
 	
-	switch( new_fireball->fireball_render_type )	{
+	switch( fb->fireball_render_type )	{

 		case FIREBALL_MEDIUM_EXPLOSION:	
-			new_fireball->orient = Random::next() & 7;							// 0 - 7
+			fb->orient = (myrand()>>8) & 7;							// 0 - 7
 			break;

 		case FIREBALL_LARGE_EXPLOSION:
-			new_fireball->orient = Random::next(360);						// 0 - 359
+			fb->orient = (myrand()>>8) % 360;						// 0 - 359
 			break;

 		case FIREBALL_WARP_EFFECT:
 			// Play sound effect for warp hole opening up
-			fireball_play_warphole_open_sound(ship_class, new_fireball);
+			fireball_play_warphole_open_sound(ship_class, fb);

 			// warp in type
 			if (reverse)	{
-				new_fireball->orient = 1;
+				fb->orient = 1;
 				// if warp out, then reverse the orientation
 				vm_vec_scale( &obj->orient.vec.fvec, -1.0f );	// Reverse the forward vector
 				vm_vec_scale( &obj->orient.vec.rvec, -1.0f );	// Reverse the right vector
 			} else {
-				new_fireball->orient = 0;
+				fb->orient = 0;
 			}
 			break;

 		default:
-			UNREACHABLE("Bad type set in fireball_create");
+			Int3();
 			break;
 	}

-	if ( new_fireball->fireball_render_type == FIREBALL_WARP_EFFECT )	{
+	if ( fb->fireball_render_type == FIREBALL_WARP_EFFECT )	{
 		Assert( warp_lifetime >= 4.0f );		// Warp lifetime must be at least 4 seconds!
 		if ( warp_lifetime < 4.0f )
 			warp_lifetime = 4.0f;
-		new_fireball->total_time = warp_lifetime;	// in seconds
+		fb->total_time = warp_lifetime;	// in seconds
 	} else {
-		new_fireball->total_time = i2fl(fl->num_frames) / fl->fps;	// in seconds
+		fb->total_time = i2fl(fl->num_frames) / fl->fps;	// in seconds
 	}
-
+	
 	fireball_set_framenum(n);

 	if ( velocity )	{
@@ -912,6 +923,7 @@ int fireball_create(vec3d *pos, int fireball_type, int render_type, int parent_o
 		vm_vec_zero(&obj->phys_info.max_rotvel);
 	}
 	
+	Num_fireballs++;
 	return objnum;
 }

@@ -996,9 +1008,9 @@ int fireball_ship_explosion_type(ship_info *sip)
 	}

 	if(ship_fireballs > 0){
-		index = sip->explosion_bitmap_anims[Random::next(ship_fireballs)];
+		index = sip->explosion_bitmap_anims[rand()%ship_fireballs];
 	} else if(objecttype_fireballs > 0){
-		index = Ship_types[sip->class_type].explosion_bitmap_anims[Random::next(objecttype_fireballs)];
+		index = Ship_types[sip->class_type].explosion_bitmap_anims[rand()%objecttype_fireballs];
 	}

 	return index;
@@ -1015,7 +1027,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[Random::next(roid_fireballs)];
+		index = aip->explosion_bitmap_anims[rand()%roid_fireballs];
 	}

 	return index;
@@ -1046,34 +1058,24 @@ void fireball_render(object* obj, model_draw_list *scene)

 	MONITOR_INC( NumFireballsRend, 1 );	

-	// Make sure the new system works fine.
-	Assert(obj->instance > -1);
-	Assert(static_cast<int>(Fireballs.size()) > obj->instance);
-
 	num = obj->instance;
 	fb = &Fireballs[num];

-	if ( fb->current_bitmap < 0 )
+	if ( Fireballs[num].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, alpha);
+			batching_add_volume_bitmap(Fireballs[num].current_bitmap, &p, fb->orient, obj->radius);
 		}
 		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, alpha);
+			batching_add_volume_bitmap_rotated(Fireballs[num].current_bitmap, &p, (i2fl(fb->orient)*PI) / 180.0f, obj->radius);
 		}
 		break;

@@ -1082,7 +1084,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, fi->use_3d_warp || (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, (fb->flags & FBF_WARP_3D) != 0, fi->warp_glow_bitmap, fi->warp_ball_bitmap, fi->warp_model_id);
 		}
 		break;

@@ -1091,14 +1093,3 @@ void fireball_render(object* obj, model_draw_list *scene)
 			Int3();
 	}
 }
-
-// Because fireballs are only added and removed in two places, and Unused_fireball_indices is always updated in those places to contain unused indices,
-// this very simple code will give you the correct count of currently existing fireballs in use. 
-int fireball_get_count()
-{
-	int count = static_cast<int>(Fireballs.size()) - static_cast<int>(Unused_fireball_indices.size());
-
-	Assert (count >= 0);
-	
-	return count;
-}
@@ -58,8 +58,6 @@ 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];
@@ -97,7 +95,8 @@ typedef struct fireball {
 } fireball;
 // end move

-extern SCP_vector<fireball> Fireballs;
+extern fireball Fireballs[MAX_FIREBALLS];
+extern int Num_fireballs;

 extern bool fireballs_inited;

@@ -143,11 +142,8 @@ int fireball_asteroid_explosion_type(asteroid_info *aip);
 float fireball_wormhole_intensity( fireball *fb );

 // Goober5000
-extern bool Knossos_warp_ani_used;
+extern int Knossos_warp_ani_used;

 extern bool Fireball_use_3d_warp;

-// Cyborg - get a count of how many valid fireballs are in the mission.
-int fireball_get_count();
-
 #endif /* _FIREBALLS_H */
@@ -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]) ? neb2_get_fog_visibility(&obj->pos, 1.0f) : 1.0f;
+			float alpha = (The_mission.flags[Mission::Mission_Flags::Fullneb]) ? (1.0f - neb2_get_fog_intensity(obj)) : 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) ) {
+	if ( (warp_model_id >= 0) && (warp_3d || Fireball_use_3d_warp) ) {
 		model_render_params render_info;

 		float scale = radius / 25.0f;
@@ -112,27 +112,35 @@ static int Current_help_page;

 void gameplay_help_blit_control_line(int x, int y, int id)
 {
+	int			has_key=0, has_joy=0;
 	char			buf[256];
+	config_item	*ci;

-	auto ci = &Control_config[id];
+	ci = &Control_config[id];

 	buf[0] = 0;

-	strcpy_s(buf, ci->first.textify().c_str());
-
-	if (!ci->second.empty()) {
-		strcat_s(buf, XSTR( ", ", 129));
-		strcat_s(buf, ci->second.textify().c_str());
+	if ( ci->key_id >= 0 ) {
+		strcpy_s(buf, textify_scancode(ci->key_id));
+		has_key=1;
 	}

-	if (ci->empty()) {
+	if ( ci->joy_id >= 0 ) {
+		if ( has_key ) {
+			strcat_s(buf, XSTR( ", ", 129));
+		}
+		strcat_s(buf, Joy_button_text[ci->joy_id]);
+		has_joy=1;
+	}
+
+	if ( !has_key && !has_joy ) {
 		strcpy_s(buf, XSTR( "no binding", 130));
 	}

 	gr_string(x,y,buf,GR_RESIZE_MENU);

 //	gr_string(x+KEY_DESCRIPTION_OFFSET,y,ci->text,GR_RESIZE_MENU);
-	gr_string(x+KEY_DESCRIPTION_OFFSET, y, XSTR(ci->text.c_str(), CONTROL_CONFIG_XSTR + id), GR_RESIZE_MENU);
+	gr_string(x+KEY_DESCRIPTION_OFFSET, y, XSTR(ci->text, CONTROL_CONFIG_XSTR + id), GR_RESIZE_MENU);
 }

 void gameplay_help_blit_control_line_raw(int x, int y, const char *control_text, const char *control_description)
@@ -239,10 +239,7 @@ 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;
@@ -659,12 +659,7 @@ void event_music_first_pattern()
 			audiostream_stop( Patterns[Current_pattern].handle );
 	}

-	// 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
-	}
+	Pattern_timer_id = 2000;	// start music delay
 	
 	Event_music_begun = FALSE;
 	if ( Event_Music_battle_started == TRUE ) {
@@ -675,13 +670,6 @@ 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() 
 //
@@ -107,7 +107,6 @@ 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();
@@ -304,10 +304,6 @@ gamesnd_id gamesnd_get_by_name(const char* name)
 {
 	Assert( Snds.size() <= INT_MAX );

-	// empty name is not valid!
-	if (name == nullptr || name[0] == '\0')
-		return gamesnd_id(-1);
-
 	int index = gamesnd_lookup_name(name, Snds);

 	if (index < 0)
@@ -526,7 +522,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.\n", tag, object_name, destination.size(), check));
+			mprintf(("%s in '%s' has " SIZE_T_ARG " entries. This does not match entered size of %i.", tag, object_name, destination.size(), check));
 		}
 	}
 }
@@ -544,12 +540,12 @@ void gamesnd_preload_common_sounds()
 		return;

 	Assert( Snds.size() <= INT_MAX );
-	for (auto& gs: Snds) {
-		if ( gs.preload ) {
-			for (auto& entry : gs.sound_entries) {
+	for (SCP_vector<game_snd>::iterator gs = Snds.begin(); gs != Snds.end(); ++gs) {
+		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 +561,12 @@ void gamesnd_load_gameplay_sounds()
 		return;

 	Assert( Snds.size() <= INT_MAX );
-	for (auto& gs: Snds) {
-		if ( !gs.preload ) { // don't try to load anything that's already preloaded
-			for (auto& entry : gs.sound_entries) {
+	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) {
 				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 +579,8 @@ void gamesnd_load_gameplay_sounds()
 void gamesnd_unload_gameplay_sounds()
 {
 	Assert( Snds.size() <= INT_MAX );
-	for (auto& gs: Snds) {
-		for (auto& entry : gs.sound_entries) {
+	for (SCP_vector<game_snd>::iterator gs = Snds.begin(); gs != Snds.end(); ++gs) {
+		for (auto& entry : gs->sound_entries) {
 			if (entry.id.isValid()) {
 				snd_unload(entry.id);
 				entry.id = sound_load_id::invalid();
@@ -602,10 +598,10 @@ void gamesnd_load_interface_sounds()
 		return;

 	Assert( Snds_iface.size() < INT_MAX );
-	for (auto& gs: Snds) {
-		for (auto& entry : gs.sound_entries) {
+	for (SCP_vector<game_snd>::iterator si = Snds_iface.begin(); si != Snds_iface.end(); ++si) {
+		for (auto& entry : si->sound_entries) {
 			if ( entry.filename[0] != 0 && strnicmp(entry.filename, NOX("none.wav"), 4) != 0 ) {
-				entry.id = snd_load(&entry, &gs.flags);
+				entry.id = snd_load(&entry, si->flags);
 			}
 		}
 	}
@@ -642,11 +638,10 @@ void parse_gamesnd_old(game_snd* gs)

 	stuff_string(entry.filename, F_NAME, MAX_FILENAME_LEN, ",");

-	if (!stricmp(entry.filename, NOX("empty")) || !stricmp(entry.filename, NOX("none")))
+	if (!stricmp(entry.filename, NOX("empty")))
 	{
 		entry.filename[0] = 0;
-		advance_to_eoln(nullptr);
-		gs->flags |= GAME_SND_NOT_VALID;
+		advance_to_eoln(NULL);
 		return;
 	}
 	Mp++;
@@ -680,9 +675,11 @@ void parse_gamesnd_old(game_snd* gs)
 		{
 			int temp_min, temp_max;

-			if (stuff_int_optional(&temp_min) == 2)
+			ignore_gray_space();
+			if (stuff_int_optional(&temp_min, true) == 2)
 			{
-				if (stuff_int_optional(&temp_max) == 2)
+				ignore_gray_space();
+				if (stuff_int_optional(&temp_max, true) == 2)
 				{
 					mprintf(("Dutifully converting retail sound %s, '%s' to a 3D sound...\n", gs->name.c_str(), entry.filename));
 					is_3d = 1;
@@ -696,7 +693,8 @@ void parse_gamesnd_old(game_snd* gs)
 	}

 	// check for extra values per Mantis #2408
-	if (stuff_int_optional(&temp) == 2)
+	ignore_gray_space();
+	if (stuff_int_optional(&temp, true) == 2)
 	{
 		Warning(LOCATION, "Unexpected extra value %d found for sound '%s' (filename '%s')!  Check the format of the sounds.tbl (or .tbm) entry.", temp, gs->name.c_str(), entry.filename);
 	}
@@ -752,14 +750,14 @@ bool required_string_no_create(const char* token, bool no_create)

 static GameSoundCycleType parse_cycle_type() {
 	if (optional_string("Sequential")) {
-		return GameSoundCycleType::SequentialCycle;
+		return GameSoundCycleType::Sequential;
 	} else if (optional_string("Random")) {
-		return GameSoundCycleType::RandomCycle;
+		return GameSoundCycleType::Random;
 	} 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::SequentialCycle;
+		return GameSoundCycleType::Sequential;
 	}
 }

@@ -861,10 +859,9 @@ 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")) || !stricmp(name, NOX("none")))
+	if (!stricmp(name, NOX("empty")))
 	{
 		entry->filename[0] = 0;
-		gs->flags |= GAME_SND_NOT_VALID;
 		return;
 	}

@@ -1345,31 +1342,13 @@ 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));
@@ -1382,14 +1361,14 @@ game_snd_entry* gamesnd_choose_entry(game_snd* gs) {

 	size_t index = 0;
 	switch(gs->cycle_type) {
-	case GameSoundCycleType::RandomCycle:
+	case GameSoundCycleType::Random:
 		if (gs->sound_entries.size() == 1) {
 			index = 0;
 		} else {
 			index = util::UniformRange<size_t>(0, gs->sound_entries.size() - 1).next();
 		}
 		break;
-	case GameSoundCycleType::SequentialCycle:
+	case GameSoundCycleType::Sequential:
 		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;
@@ -401,11 +401,6 @@ 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
@@ -31,6 +31,8 @@
 #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
@@ -113,8 +113,6 @@ 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;
@@ -130,7 +128,6 @@ typedef struct matrix {
 	};
 } matrix;

-// You might think this is also row-major. You fool! It is actually column-major.
 typedef struct matrix4 {
 	union {
 		struct {
@@ -306,6 +303,8 @@ 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?
@@ -351,6 +350,14 @@ 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 {
@@ -456,6 +463,7 @@ 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)
@@ -555,6 +563,7 @@ 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		// _PSTYPES_H
+#endif		// PS_TYPES_H
@@ -3,6 +3,8 @@
 #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)

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

@@ -108,6 +109,47 @@ 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;
@@ -243,8 +285,8 @@ detail_levels Detail_defaults[NUM_DEFAULT_DETAIL_LEVELS] = {
 	{				// Highest level
 		3,			// setting
 					// ===== Analogs (0-MAX_DETAIL_LEVEL) ====
-		4,			// nebula_detail;				// 0=lowest detail, MAX_DETAIL_LEVEL=highest detail
-		4,			// detail_distance;			// 0=lowest MAX_DETAIL_LEVEL=highest		
+		3,			// nebula_detail;				// 0=lowest detail, MAX_DETAIL_LEVEL=highest detail
+		3,			// 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
@@ -328,6 +370,9 @@ 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.
@@ -466,19 +511,3 @@ void insertion_sort(void *array_base, size_t array_size, size_t element_size, in
 	// free the allocated space
 	free(current);
 }
-
-// Stuff that can't be included in vmallocator.h
-
-std::locale SCP_default_locale("");
-
-void SCP_tolower(char *str)
-{
-	for (; *str != '\0'; ++str)
-		*str = SCP_tolower(*str);
-}
-
-void SCP_toupper(char *str)
-{
-	for (; *str != '\0'; ++str)
-		*str = SCP_toupper(*str);
-}
@@ -94,6 +94,7 @@ 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

@@ -67,7 +67,7 @@

 #define USED_VARIABLE __attribute__((used))

-#if __GNUC__ >= 7
+#if SCP_COMPILER_VERSION_MAJOR >= 7
 #define FALLTHROUGH [[fallthrough]]
 #else
 #define FALLTHROUGH
@@ -64,7 +64,7 @@

 #define USED_VARIABLE __attribute__((used))

-#if __GNUC__ >= 7
+#if SCP_COMPILER_VERSION_MAJOR >= 7
 #define FALLTHROUGH __attribute__((fallthrough))
 #else
 #define FALLTHROUGH
@@ -1,166 +0,0 @@
-/*
-* z64555's Undo system, created for the FreeSpace Source Code project
-*/
-
-#include "globalincs/pstypes.h"
-#include "globalincs/undosys.h"
-#include "globalincs/vmallocator.h"
-
-// Pure virtual deconstructors must be defined.
-Undo_item_base::~Undo_item_base() = default;
-
-Undo_system::Undo_system()
-	: max_undos(10) {};
-
-Undo_system::Undo_system(size_t _undos)
-	: max_undos(_undos) {};
-
-void Undo_system::clamp_stacks() {
-	while (undo_stack.size() > max_undos) {
-		// If we're past the stack limit, de-construct and remove until we're in the limit
-		// If max_undos is held constant (as it should be), the loop isn't necassary. 
-		//   But, it also isn't that much different from an if{} when assembled, so there's no harm in using it
-		delete undo_stack.front();
-		undo_stack.pop_front();
-	}
-
-	// This while() shouldn't ever be triggered, but this is a safety to prevent any weird edge-cases.
-	while (redo_stack.size() > max_undos) {
-		delete redo_stack.front();
-		undo_stack.pop_front();
-	}
-}
-
-void Undo_system::clear() {
-	clear_redo();
-
-	for (auto &element : undo_stack) {
-		delete element;
-	}
-	undo_stack.clear();
-}
-
-void Undo_system::clear_redo() {
-	for (auto &element : redo_stack) {
-		delete element;
-	}
-	redo_stack.clear();
-}
-
-size_t Undo_system::save_stack(Undo_stack& stack) {
-	if (stack.size() == 0) {
-		return 0;
-	}
-	
-	clear_redo();
-
-	// Copy the stack onto the heap, and push it into our undo_stack as a single item
-	Undo_item_base *new_item = new Undo_stack(stack);
-
-	Assert(new_item != nullptr);
-	undo_stack.push_back(new_item);
-
-	// Input stack is told to untrack the items, so that there's only one deletion handler for them
-	stack.untrack();
-
-	clamp_stacks();
-
-	return undo_stack.size();
-}
-
-std::pair<const void*, const void*> Undo_system::redo() {
-	std::pair<const void*, const void*> retval;
-
-	if (redo_stack.empty()) {
-		// Nothing to redo
-		return {nullptr, nullptr};
-	}
-
-	auto &item = redo_stack.back();
-	retval = item->restore();
-	undo_stack.push_back(item);
-	redo_stack.pop_back();
-
-	return retval;
-};
-
-std::pair<const void*, const void*> Undo_system::undo() {
-	std::pair<const void*, const void*> retval;
-	
-	if (undo_stack.empty()) {
-		// Nothing to undo
-		return {nullptr, nullptr};
-	}
-
-	auto &item = undo_stack.back();
-	retval = item->restore();
-	redo_stack.push_back(item);
-	undo_stack.pop_back();
-
-	return retval;
-};
-
-bool Undo_system::empty() {
-	return undo_stack.empty();
-}
-
-bool Undo_system::empty_redo() {
-	return redo_stack.empty();
-}
-size_t Undo_system::size() {
-	return undo_stack.size();
-}
-
-size_t Undo_system::size_redo() {
-	return redo_stack.size();
-}
-
-
-Undo_stack::Undo_stack()
-	: reverse(false) {
-}
-
-Undo_stack::Undo_stack(size_t size)
-	: reverse(false) {
-	stack.reserve(size);
-}
-
-Undo_stack::~Undo_stack() {
-	clear();
-}
-
-void Undo_stack::reserve(size_t size) {
-	stack.reserve(size);
-}
-
-std::pair<const void*, const void*> Undo_stack::restore() {
-	std::pair<const void*, const void*> retval;
-
-	if (reverse) {
-		for (auto it = stack.rbegin(); it != stack.rend(); ++it) {
-			retval = (*it)->restore();
-		}
-	} else {
-		for (auto &element : stack) {
-			retval = element->restore();
-		}
-	}
-
-	reverse = !reverse;
-	return retval;
-}
-
-size_t Undo_stack::size() {
-	return stack.size();
-}
-
-void Undo_stack::untrack() {
-	stack.clear();
-}
-
-void Undo_stack::clear() {
-	for (auto &element : stack) {
-		delete element;
-	}
-	stack.clear();
-}
@@ -1,326 +0,0 @@
-/*
- * z64555's Undo system, created for the FreeSpace Source Code project
- */
-
-#include "globalincs/pstypes.h"
-#include "globalincs/vmallocator.h"
-
-#include <utility>
-
-/**********************************************************
-Usage:
-First, you need an instance of the Undo_system within your module:
-	{
-		Undo_styem Undo_controls;
-	}
-
-From now on, you can save and restore items. (Just be sure to save them before you change them!)
-	{
-		Undo_controls.save(Control_config[z]);             // 1. Save the item!!
-		Control_config[z].bind(cid(CID_KEYBOARD, KEY_UP)); // 2. Make changes to the item!!
-		Undo_controls.undo();                              // 3. Undo's the changes you did in step 2!
-		Undo_controls.redo();                              // 4. Redo's the changes you did in step 2!
-	}
-The undo system can save any type of data, you don't have to have an instance of a system per data type.
-!!NOTE!! C style arrays and strings should be wrapped in a std::array when saving. Simply passing the array/string's head won't save the entire array.
-{
-	Undo_controls.save(std::array<int, JOY_AXIS_ACTIONS>(Axis_map_to));
-}
-
-In several cases, the client code would like to know exactly what was changed. The undo system provides a mechanism for doing this:
-	{
-		Undo_controls.save(Control_config[z], &Control_config[0]);   // Save the item, and a reference to its container. Here, we use the location of the first item in Control_config as our reference
-		Undo_controls.save(Axis_map_to[z], Axis_map_to);             // Saves an axis mapping, here, we use the array's head pointer as our reference (since a int[] is the same as a int*)
-
-		std::pair<const void*, const void*> ref = Undo_controls.undo();    // ::undo() returns a std::pair<const void*, const void*>, the first member referencing the item that changed, and the second referencing the item's container (if we provided it)
-
-		// Once we've stored the return value from ::undo, we can found out what the item is by comparing the second member with containers that we've been saving
-		if (ref.second == &Control_config[0]) {
-			cout << "I'm a button!";
-			Tab = static_cast<Config_item>(ref.first).tab;  // Sets the selected tab within the Controls Config menu. We do a static cast here so we can access the Config_item::tab member
-		} else if (ref.second == Axis_map_to) {
-			cout << "I'm an axis!";
-			Tab = SHIP_TAB;                                 // Sets the selected tab within the Controls config menu. Can't do a cast on this one, since it's a simple C array. But we already know where the axes are kept (on the ship tab)
-		} else {
-			cout << "I don't know what I am!!! D:";         // Usually an error condition. Depending on the client code this can be fatal or just a minor setback
-		}
-	}
-
-Lastly, you can make stacks of undo operations, so that a single op in the system can undo/redo multiple item changes.
-	{
-		Undo_stack stack;  // We'll want to save multiple changes as a single operation. So we have to make a stack.
-
-		for (int i = 0; i < JOY_AXIS_ACTIONS; ++i) {
-			stack.save(Axis_map_to[i], Axis_map_to);		// This example saves a C style array. Does the same thing without a wrapper, but wasteful
-		
-		Undo_controls.save_stack(stack) // Save the stack as a single item!
-	}
-
-	std::pair<const void*, const void*> ref = Undo_controls.undo();
-	// Undo rolls through the items as they were saved, should your data operate on the same location, this will apply the changes in the correct sequence
-	ref.second == Axis_map_to;
-	ref.first == &Axis_map_to[0];     // ::first references the _last_ item that the undo stack changed
-
-	//Also, performing an undo reverses the stack. So when you do a system undo, the changes are applied in reverse
-	ref = Undo_controls.redo();
-	ref.second == Axis_map_to;
-	ref.first == &Axis_map_to[JOY_AXIS_ACTIONS - 1];      // ::first references the _last_ item that the undo stack changed
-
-***********************************************************/
-
-/*!
- * @brief Base class of Undo_item. Use this when making an undo stack!
- * @sa Undo_item
- */
-class Undo_item_base
-{
-public:
-	virtual ~Undo_item_base() = 0;
-	virtual std::pair<const void*, const void*> restore() = 0;
-};
-
-
-/*!
- * @brief Class which handles undo operations.
- * @details This class works with a single data item, to make a undo or redo stack you'd use something like a
- *   std::vector or a std::deque of this class. Undo and Redo stacks would be separate. Before restoring data from
- *   either, you'd save a copy of the item in the opposite stack.
- *
- *   For example, if you're about to restore from the undo stack, you'd first save a copy of the current data to the
- *   redo stack, then do the undo. The Undo_item in the undo stack can then be popped off the stack.
- *
- * @note If you want to save changes to an entire C-style array (such as 'int array[]'), try wrapping it in a std::array first.
- *
- * @sa Undo_item_base
- */
-template<typename T> class Undo_item : public Undo_item_base
-{
-public:
-	Undo_item()
-		: dest(nullptr), data(nullptr) {};
-
-	Undo_item(T& _data) {
-		save(_data);
-	};
-
-	Undo_item(T& _data, T* _cont) {
-		save(_data, _cont);
-	};
-
-	~Undo_item() override {
-		if (data != nullptr) {
-			delete data;
-		}
-	};
-
-	/**
-	 * @brief Restores the saved data
-	 *
-	 * @returns A pair of const void* referencing the affected item and its container (if it was provided)
-	 * @details swaps the data with the destination's, effectively making an undo item into a redo item, and vice versa
-	 */
-	std::pair<const void*, const void*> restore() override {
-		Assert((dest != nullptr) && (data != nullptr));
-
-		std::swap(*static_cast<T*>(dest),*static_cast<T*>(data));
-
-		return std::pair<const void*, const void*>(dest, container);
-	};
-
-	/*!
-	 * @brief Saves data and its destination as an undo item
-	 *
-	 * @param[in] _data The data to save
-	 * @param[in] _cont The container this data is originally found in
-	 * @details The explicit definition is here to ensure type safety
-	 */
-	void save(T& _data, T* _cont = nullptr) {
-
-		dest = &_data;
-		data = new T(_data);
-		container = _cont;
-	};
-
-private:
-	T* dest;        //!< Destination of the data
-	T* data;        //!< Reference to a copy of data on the heap
-	T* container;   //!< Optional reference to this item's container
-};
-
-
-/*!
- * @brief Class which handles multiple undo operations as a single op within the Undo_system
- * @note Caution: Upon deconstruction the tracked Undo_items are deleted.
- */
-class Undo_stack : public Undo_item_base
-{
-public:
-	Undo_stack();
-
-	Undo_stack(size_t size);
-
-	~Undo_stack() override;
-
-	/*!
-	 * @brief Restores all items within the undo stack
-	 *
-	 * @details Maintains an internal flag which will reverse direction on the next call, thereby re-doing
-	 * 
-	 * @returns A pair of references to the last item restored
-	 */
-	std::pair<const void*, const void*> restore() override;
-
-	/*!
-	 * @brief Saves the item onto the undo stack
-	 *
-	 * @param[in] item      The item to save
-	 * @param[in] container (Optional) The container wherein this item is located
-	 * @note Call this _before_ you do your operation on the item
-	 */
-	template<typename T>
-	size_t save(T& item, T* container = nullptr) {
-		// Create a new instance of Undo_tem, with the correct type reference
-		Undo_item_base *new_item = new Undo_item<T>(item, container);
-
-		stack.push_back(new_item);
-
-		return stack.size();
-	};
-
-	/*!
-	 * @brief Calls ::reserve() on the internal vector
-	 */
-	void reserve(size_t size);
-
-	/*!
-	 * @brief Returns the size of the stack
-	 */
-	 size_t size();
-
-	 /*!
-	  * @brief Deletes all tracked items in the internal vector
-	  */
-	 void clear();
-
-protected:
-	friend class Undo_system;
-
-	/*!
-	 * @brief Calls ::clear() on the internal vector
-	 * @note Caution: This does not delete the tracked Undo_items
-	 */
-	void untrack();
-
-private:
-	bool reverse;   // Direction to walk the stack. forward = false, reverse = True
-
-	std::vector<Undo_item_base*> stack;
-};
-
-/*!
- * @brief Generic Undo/Redo system. Save whatever, restore whatever!
- *
- * @details Currently uses a pair of deques. Would ideally use a ring container so that the actual Undo_item instances don't go anywhere.
- */
-class Undo_system
-{
-public:
-	Undo_system();
-
-	Undo_system(size_t _undos);
-
-	/*!
-	 * @brief Deletes all undo and redo data
-	 */
-	void clear();
-	
-	/*!
-	 * @brief Saves the item onto the undo stack
-	 *
-	 * @param[in] item      The item to save
-	 * @param[in] container (Optional) The container wherein this item is located
-	 * @note Call this _before_ you do your operation on the item
-	 */
-	template<typename T>
-	size_t save(T& item, T* container = nullptr) {
-		// De-construct all intances of Undo_item on the redo stack, then clear the stack
-		clear_redo();
-
-		// Create a new instance of Undo_tem, with the correct type reference
-		Undo_item_base *new_item = new Undo_item<T>(item, container);
-
-		undo_stack.push_back(new_item);
-
-		clamp_stacks();
-
-		return undo_stack.size();
-	};
-
-	/*!
-	 * @brief Saves a stack of undo-items as a single undo-item within the system
-	 *
-	 * @param[in,out] stack  The undo stack to save to the undo system.  Data in the stack is "unspecified" after this operation
-	 *
-	 * @details  The undo system effectively moves the stack into its internal containers, claiming ownership of the
-	 *  Undo_items and deleting them upon going out of scope.  The input stack is told to untrack the Undo_items in
-	 *  the process, so that there is only ever one reference to the Undo_item like a std::unique_ptr
-	 */
-	size_t save_stack(Undo_stack& stack);
-
-	/*!
-	 * @brief Undo's the last changed item and save the changes into the Redo stack
-	 *
-	 * @returns A pair of const void* which reference the affected item, and its container (if it was provided)
-	 */
-	std::pair<const void*, const void*> undo();
-
-	/*!
-	 * @brief Redo's the last changed item and save the changes into the undo
-	 *
-	 * @returns A pair of const void* which reference the affected item, and its container (if it was provided)
-	 */
-	std::pair<const void*, const void*> redo();
-
-	/*!
-	 * @brief Returns the size of the undo stack
-	 */
-	size_t size();
-
-	/*!
-	 * @brief Returns the size of the redo stack
-	 */
-	size_t size_redo();
-
-	/*!
-	 * @brief True if undo stack size = 0
-	 */
-	bool empty();
-
-	/*!
-	 * @brief True if redo stack size = 0
-	 */
-	 bool empty_redo();
-
-protected:
-	/*!
-	 * @brief Deletes all redo data
-	 */
-	void clear_redo();
-
-	/*!
-	 * @brief Clamp the stack sizes to be <= max_undos, deleting data as needed
-	 */
-	void clamp_stacks();
-
-private:
-	size_t max_undos;	//!< Max number of Undo's available
-
-	/*! 
-	 * @brief The undo and redo stacks. These are containers of pointers, because we can't simply store the base class.
-	 *   If we did, then the data of the Undo_item instances would be sliced out.
-	 * @{
-	 */
-	SCP_deque<Undo_item_base*> undo_stack;
-	SCP_deque<Undo_item_base*> redo_stack;
-	//! @}
-};
@@ -1,10 +1,10 @@
 #ifndef _VMALLOCATOR_H_INCLUDED_
 #define _VMALLOCATOR_H_INCLUDED_

+/* SCP_vm_allocator - maintained by portej05 (i.e. please don't patch this one yourself!) */
+
 #include <deque>
-#include <iterator>
 #include <list>
-#include <locale>
 #include <map>
 #include <queue>
 #include <sstream>
@@ -25,31 +25,10 @@ bool SCP_vector_contains(SCP_vector<T>& vector, T item) {
 template< typename T >
 using SCP_list = std::list< T, std::allocator< T > >;

-
-extern std::locale SCP_default_locale;
-
-template< class charT >
-charT SCP_toupper(charT ch) { return std::toupper(ch, SCP_default_locale); }
-
-template< class charT >
-charT SCP_tolower(charT ch) { return std::tolower(ch, SCP_default_locale); }
-
 typedef std::basic_string<char, std::char_traits<char>, std::allocator<char> > SCP_string;

 typedef std::basic_stringstream<char, std::char_traits<char>, std::allocator<char> > SCP_stringstream;

-inline void SCP_tolower(SCP_string &str) {
-	std::transform(str.begin(), str.end(), str.begin(), [](char c) { return SCP_tolower(c); });
-}
-
-inline void SCP_toupper(SCP_string &str) {
-	std::transform(str.begin(), str.end(), str.begin(), [](char c) { return SCP_toupper(c); });
-}
-
-extern void SCP_tolower(char *str);
-extern void SCP_toupper(char *str);
-
-
 template< typename T, typename U >
 using SCP_map = std::map<T, U, std::less<T>, std::allocator<std::pair<const T, U> > >;

@@ -96,59 +75,6 @@ template <typename T>
 using SCP_hash = std::hash<T>;
 #endif

-struct SCP_string_lcase_hash {
-	size_t operator()(const SCP_string& elem) const {
-		SCP_string lcase_copy;
-		std::transform(elem.begin(), elem.end(), std::back_inserter(lcase_copy),
-			[](char c) {
-				return SCP_tolower(c);
-			});
-		return SCP_hash<SCP_string>()(lcase_copy);
-	}
-};
-
-struct SCP_string_lcase_equal_to {
-	bool operator()(const SCP_string& _Left, const SCP_string& _Right) const {
-		if (_Left.size() != _Right.size()) {
-			return false;
-		}
-		auto l_it = _Left.cbegin();
-		auto r_it = _Right.cbegin();
-		while (l_it != _Left.cend()) {
-			if (SCP_tolower(*l_it) != SCP_tolower(*r_it)) {
-				return false;
-			}
-			++l_it;
-			++r_it;
-		}
-		return true;
-	}
-};
-
-struct SCP_string_lcase_less_than {
-	bool operator()(const SCP_string& _Left, const SCP_string& _Right) const {
-		auto l_it = _Left.cbegin();
-		auto r_it = _Right.cbegin();
-		while (true) {
-			if (l_it == _Left.cend()) {
-				return (r_it != _Right.cend());
-			} else if (r_it == _Right.cend()) {
-				return false;
-			}
-			auto lch = SCP_tolower(*l_it);
-			auto rch = SCP_tolower(*r_it);
-			if (lch < rch) {
-				return true;
-			} else if (lch > rch) {
-				return false;
-			}
-			++l_it;
-			++r_it;
-		}
-		return true;
-	}
-};
-
 template <typename Key, typename T, typename Hash = SCP_hash<Key>, typename KeyEqual = std::equal_to<Key>>
 using SCP_unordered_map = std::unordered_map<Key, T, Hash, KeyEqual, std::allocator<std::pair<const Key, T>>>;
Author	SHA1	Message	Date
asarium	1588644fec	Add variables concept to expressions This also includes the necessary setup work for using "position" and "direction" in action expressions.	2021-01-10 22:47:49 +01:00
asarium	0abd592038	Rework actions to use definitions This introduces action definitions which can then be instantiated to form actual actions with expressions as their parameters.	2021-01-10 12:22:00 +01:00
asarium	909e799bdd	Allow implicit conversion from int to float This is generally a safe operation and will make the system a bit easier to use.	2021-01-07 21:36:28 +01:00
asarium	5a9f181aff	Rework function handling	2021-01-07 13:34:10 +01:00
asarium	b0ba22a43d	Add Action expressions This is a parser for a very simple language to allow for execution of dynamic expressions with return values for use as action parameters. The only "dynamic" part this currently supports are random ranges but more features are planned for the future.	2021-01-06 19:13:12 +01:00
asarium	c89faebe4e	Update GTest	2021-01-06 18:49:48 +01:00
asarium	059e149590	Add dynamic action programming system This system adds the code necessary for letting content creators specify complex events by specifying a simple, program-like sequence of operations that will be executed by the engine when a certain event is triggered.	2021-01-05 18:26:10 +01:00