Got autoconf to build w/ dx8 libs (for cutscenes). DX8 files must be in C:/dx8 dir for now, will fix later.

Also got rid of the fs2- prefix on the object files.
penguin

.circleci/config.yml

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

.clang-format

@@ -1,104 +0,0 @@
----
-Language:        Cpp
-Standard: Cpp11
-# BasedOnStyle:  LLVM
-AccessModifierOffset: -2
-AlignAfterOpenBracket: DontAlign
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Left
-AlignOperands:   true
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowAllArgumentsOnNextLine: false
-AllowShortBlocksOnASingleLine: Never
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortEnumsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: Yes
-BinPackArguments: false
-BinPackParameters: false
-BraceWrapping:   
-  AfterClass:      false
-  AfterControlStatement: false
-  AfterEnum:       false
-  AfterFunction:   true
-  AfterNamespace:  false
-  AfterObjCDeclaration: false
-  AfterStruct:     false
-  AfterUnion:      false
-  BeforeCatch:     false
-  BeforeElse:      false
-  IndentBraces:    false
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Custom
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit:     120
-CommentPragmas:  '^ IWYU pragma:'
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat:   false
-ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-IncludeBlocks: Regroup
-IncludeCategories:
-  - Regex:           '^(<.*\.(h|hh|hpp)>)$' # Includes of external libraries
-    Priority:        5
-  - Regex:           '^(<.*>)$' # standard library includes (won't match deprecated C headers)
-    Priority:        6
-  - Regex:           '^"globalincs\/.*\.h"$' # globalincs always come first
-    Priority:        1
-  - Regex:           '^"[^/]*\.(h)"$' # Local includes
-    Priority:        2
-  - Regex:           '^".*\.(h)"$' # standard engine includes
-    Priority:        3
-  - Regex:           '.*' # Catch all in case something is unhandled above
-    Priority:        4
-IncludeIsMainRegex: '$'
-IndentCaseLabels: false
-IndentWidth:     4
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBlockIndentWidth: 2
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Left
-ReflowComments:  true
-SortIncludes:    true
-SpaceAfterCStyleCast: false
-SpaceAfterTemplateKeyword: true
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeParens: ControlStatements
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-TabWidth:        4
-UseTab:          ForContinuationAndIndentation
-...
-

.clang-tidy

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

.dockerignore

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

.drone.yml

@@ -1,21 +0,0 @@
-
-build:
-  image: teaci/msys$$arch
-  pull: true
-  shell: mingw$$arch
-  commands:
-    - git submodule update --init --recursive
-    - if [ $$arch = 32 ]; then target=i686; fi
-    - if [ $$arch = 64 ]; then target=x86_64; fi
-    - pacman -S --needed --noconfirm --noprogressbar mingw-w64-${target}-pkg-config mingw-w64-${target}-cmake
-    - mkdir build && cd build
-    - cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=$$CONFIGURATION -DFSO_USE_SPEECH=OFF -DFSO_USE_VOICEREC=OFF -DFSO_FATAL_WARNINGS=ON -DFSO_BUILD_FRED2=OFF ..
-    - make -j$(nproc) all
-
-matrix:
-  arch:
-    - 64
-    - 32
-  CONFIGURATION:
-    - Debug
-    - Release

.editorconfig

@@ -1,15 +0,0 @@
-root = true
-
-[*.{h,cpp}]
-indent_style = tab
-
-[*.sdr]
-indent_style = tab
-
-[*.{yml,yaml}]
-indent_style = space
-indent_size = 2
-
-[*.sh]
-indent_style = space
-indent_size = 4

.gitattributes

@@ -1,7 +0,0 @@
-# Default for everything
-# * text=auto
-
-# For the test data and built-in files to make them consistent on all platforms
-*.tbl text eol=lf
-*.tbm text eol=lf
-*.sdr text eol=lf

.github/CODEOWNERS

@@ -1,14 +0,0 @@
-
-cmake/ @asarium
-
-ci/ @asarium @z64555
-
-code/executor/ @asarium
-
-code/scpui/ @asarium
-
-code/scripting/ @asarium
-
-code/controlconfig/ @z64555
-
-code/model/modelanimation*.* @bmagnu

.github/workflows/build-nightly.yaml

@@ -1,305 +0,0 @@
-name: Build Nightly package
-
-on:
-  push:
-    tags:
-      - 'nightly_*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: linux-${{ matrix.configuration }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2]
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Cache Qt
-        id: cache-qt-win
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt (32 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'Win32' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win32_msvc2017
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-      - name: Install Qt (64 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'x64' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win64_msvc2017_64
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
-            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
-            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
-            -G "Visual Studio 16 2019" -T "v142" ..
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    strategy:
-      matrix:
-        arch: [Win32, x64]
-        simd: [SSE2]
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        working-directory: ./builds
-        shell: bash
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        compiler: [clang]
-        arch: [x86_64]
-    name: Mac
-    runs-on: macos-latest
-    steps:
-      - name: Cache Qt
-        id: cache-qt-mac
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-mac.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"]
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          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 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Package build result
-        working-directory: ./build
-        run: cd bin && tar -cvzf macos-build.tar *.app
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: mac-${{ matrix.configuration }}
-          path: ${{ github.workspace }}/build/bin/macos-build.tar
-  mac_zip:
-    name: Build Mac distribution zip
-    needs: build_mac
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v2
-        with:
-          name: mac-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: mac-FastDebug
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly

.github/workflows/build-release.yaml

@@ -1,320 +0,0 @@
-name: Build Release package
-
-on:
-  push:
-    tags:
-      - 'release_*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  create_release:
-    name: Create GitHub release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        # 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:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: false
-
-  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
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        # cache the Qt directory so we don't have to reinstall it every time
-        # cache.inputs:
-        #   path - A list of files, directories, and wildcard patterns to cache and restore. See @actions/glob for supported patterns.
-        #   key - An explicit key for restoring and saving the cache
-        #   restore-keys - An ordered list of keys to use for restoring the cache if no cache hit occurred for key
-        # cache.outputs:
-        #   cache-hit   true when an exact match was found for the key, false otherwise.
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        # installs Qt in the action workflow
-        # install-qt-action.inputs:
-        #   version     desired qt version to install
-        #   host        Host platform of Qt, default to platform used by runs-on
-        #   target      target platform of Qt, default to desktop
-        #   arch        target architecture of Qt, only used for windows or android builds
-        #   dir         root dir Qt will be installed to
-        #   install-deps    if true, auto-install dependencies on linux. Default true
-        #   modules     whitespace delimited list string of additional addon modules to install
-        #   archives    whitespace delimited list string of Qt archives to install
-        #   cached      if true, Don't download Qt but set ENVARs; use with cache.outputs.cache-hit
-        #   setup-python    Set to false to skip using setup-python to find/download a valid python version
-        #   set-env     if true, set ENVARs; default = false
-        #   aqtversion  version of aqtinstall to use; default = 2.0.0
-        #   py7zrversion    version of py7zr to use; default = 0.16.1
-        #   extra       additional arguments to pass to aqinstall
-        # ENVARS set:
-        #   Qt5_DIR / Qt6_DIR
-        #   Qt bin dir appended to PATH
-        #   QT_PLUGIN_PATH, QML2_IMPORT_PATH, PKG_CONFIG_PATH, LD_LIBRARY_PATH
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3
-
-      - uses: actions/checkout@v1
-        # checks-out your repository under $GITHUB_WORKSPACE, so your workflow can access it.
-        name: Checkout
-        with:
-          submodules: true  # `true` to checkout submodules, `recursive` to recursively checkout submodules
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        # 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: linux-${{ matrix.configuration }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'  # value 0 to fetch all history and tags for all branches
-      - name: Download Release builds
-        # Grab the release builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        # Grab the debug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        # Zip both builds together
-        id: generate_package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        # Stash the result to artifact filespace
-        uses: actions/upload-artifact@v2
-        with:
-          name: ${{ steps.generate_package.outputs.package_name }}
-          path: ${{ steps.generate_package.outputs.package_path }}
-      - name: Publish result package
-        # publish the zipped result
-        uses: softprops/action-gh-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          files: ${{ steps.generate_package.outputs.package_path }}
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2, AVX]
-    needs: create_release
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - uses: actions/checkout@v1
-        # 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:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win32_msvc2017
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-      - name: Install Qt (64 bit)
-        # Install Qt 64bit if matrix.arch == x64
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'x64' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win64_msvc2017_64
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
-            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
-            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
-            -G "Visual Studio 16 2019" -T "v142" ..
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-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 Release builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-
-      - name: Create Distribution package
-        id: generate_package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-
-      - name: Upload result package
-        uses: actions/upload-artifact@v2
-        with:
-          name: ${{ steps.generate_package.outputs.package_name }}
-          path: ${{ steps.generate_package.outputs.package_path }}
-
-      - name: Upload debug package
-        uses: actions/upload-artifact@v2
-        with:
-          name: ${{ steps.generate_package.outputs.debug_name }}
-          path: ${{ steps.generate_package.outputs.debug_path }}
-
-      - name: Publish packages
-        uses: softprops/action-gh-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          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.linux_zip.result }}
-      windows_result: ${{ needs.windows_zip.result }}
-      releaseTag: ${{ github.ref_name }}

.github/workflows/build-standalone.yaml

@@ -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 }}

.github/workflows/build-test.yaml

@@ -1,318 +0,0 @@
-name: Build Test package
-
-on:
-  push:
-    branches:
-      - 'test/*'
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-5
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: |
-          LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: linux-${{ matrix.configuration }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: linux-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: linux-FastDebug
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        arch: [Win32, x64]
-        simd: [SSE2]
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Cache Qt
-        id: cache-qt-win
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt (32 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'Win32' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win32_msvc2017
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-      - name: Install Qt (64 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.arch == 'x64' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win64_msvc2017_64
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH="ON" \
-            -DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_TESTS=ON \
-            -DFSO_INSTALL_DEBUG_FILES="ON" -A "$ARCHITECTURE" \
-            -G "Visual Studio 16 2019" -T "v142" ..
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    strategy:
-      matrix:
-        arch: [Win32, x64]
-        simd: [SSE2]
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v1
-        with:
-          name: windows-Release-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-FastDebug-${{ matrix.arch }}-${{ matrix.simd }}
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        working-directory: ./builds
-        shell: bash
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        compiler: [clang]
-        arch: [x86_64]
-    name: Mac
-    runs-on: macos-latest
-    steps:
-      - name: Cache Qt
-        id: cache-qt-mac
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-mac.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Package build result
-        working-directory: ./build
-        run: cd bin && tar -cvzf macos-build.tar *.app
-      - name: Upload build result
-        uses: actions/upload-artifact@v2
-        with:
-          name: mac-${{ matrix.configuration }}
-          path: ${{ github.workspace }}/build/bin/macos-build.tar
-  mac_zip:
-    name: Build Mac distribution zip
-    needs: build_mac
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
-    steps:
-      - uses: actions/checkout@v2
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Download Release builds
-        uses: actions/download-artifact@v2
-        with:
-          name: mac-Release
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v2
-        with:
-          name: mac-FastDebug
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test

.github/workflows/cache-master.yaml

@@ -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-8a6bbbe
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: ccache
-        uses: hendrikmuhs/ccache-action@v1
-        with:
-          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all

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

@@ -1,69 +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: string
-      windows_result: # job.result
-        required: true
-        type: string
-      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: ${{ inputs.releaseTag }}
-
-jobs:
-  post_builds:
-    name: Post builds on Nebula and the forums
-    runs-on: ubuntu-latest
-    steps:
-      - name: Caller
-        # Name of what called this yaml.  Used to debug auto/manual step being triggered
-        run: echo "github.event_name= ${{ github.event_name }}"
-
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: '0'
-          ref: ${{ env.RELEASE_TAG }}
-
-      - name: Install Python dependencies
-        run: pip install -r ci/post/requirements.txt
-
-      - name: Post Builds (Auto trigger)
-        if: ${{ (github.event_name == 'workflow_call') || (github.event_name == 'push') }}
-        env:
-          LINUX_RESULT: ${{ inputs.linux_result }}
-          WINDOWS_RESULT: ${{ 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= ${{ env.RELEASE_TAG }}"
-          echo "repository= ${{ github.repository }}"
-          python ci/post/main.py release

.github/workflows/test-pull_request.yaml

@@ -1,219 +0,0 @@
-name: Check a pull request
-
-on: [pull_request]
-
-env:
-  QT_VERSION: 5.12.9
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [gcc-5, gcc-10, clang-9]
-        cmake_options: [""]
-        include:
-          # Also include configurations that check if the code compiles without the graphics backends
-          - configuration: Debug
-            compiler: gcc-10
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-          - configuration: Release
-            compiler: gcc-10
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-8a6bbbe
-    steps:
-      - name: Cache Qt
-        id: cache-qt-lin
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-lin.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3
-
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          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 }}
-          COMPILER: ${{ matrix.compiler }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Run Clang Tidy
-        # Clang-tidy reuses the precompiled headers so this only makes sense for the clang compilers
-        if: startsWith(matrix.compiler, 'clang-')
-        run: $GITHUB_WORKSPACE/ci/linux/clang_tidy.sh ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}
-      - name: Process clang-tidy warnings
-        if: startsWith(matrix.compiler, 'clang-')
-        uses: asarium/clang-tidy-action@v1
-        with:
-          fixesFile: clang-fixes.yaml
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [MSVC]
-        arch: [Win32, x64]
-    name: Windows
-    runs-on: windows-2019
-    steps:
-      - name: Prepare Environment
-        run: choco install ninja
-      - uses: actions/checkout@v1
-        name: Checkout
-        with:
-          submodules: true
-      - name: Cache Qt
-        id: cache-qt-win
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-${{ matrix.arch }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt (32 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.compiler  == 'MSVC' && matrix.arch == 'Win32' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win32_msvc2017
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-      - name: Install Qt (64 bit)
-        uses: jurplel/install-qt-action@v2
-        if: ${{ matrix.compiler  == 'MSVC' && matrix.arch == 'x64' }}
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          arch: win64_msvc2017_64
-          cached: ${{ steps.cache-qt-win.outputs.cache-hit }}
-          aqtversion: ==0.8
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          if [ "$COMPILER" = "MinGW" ]; then
-              cmake -DFSO_USE_SPEECH="OFF" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-                  -DFSO_BUILD_FRED2="OFF" -DCMAKE_BUILD_TYPE=$CONFIGURATION -G "Ninja" ..
-          else
-              cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-                  -DMSVC_SIMD_INSTRUCTIONS=SSE2 -DFSO_BUILD_FRED2="ON" -G "Visual Studio 16 2019" \
-                  -DFSO_BUILD_QTFRED=ON -T "v142" -A "$ARCHITECTURE" ..
-          fi
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          if [ "$COMPILER" = "MinGW" ]; then
-              cmake --build . --config "$CONFIGURATION"
-          else
-              cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-          fi
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          if [ "$COMPILER" = "MinGW" ]; then
-             ./bin/unittests --gtest_shuffle
-          else
-              "./bin/$CONFIGURATION/unittests" --gtest_shuffle
-          fi
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [clang]
-        arch: [x86_64]
-        cmake_options: [""]
-    name: Mac
-    runs-on: macos-latest
-    steps:
-      - name: Cache Qt
-        id: cache-qt-mac
-        uses: actions/cache@v1
-        with:
-          path: ${{ github.workspace }}/../Qt
-          key: ${{ runner.os }}-QtCache-${{ env.QT_VERSION }}
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v2
-        with:
-          version: ${{ env.QT_VERSION }}
-          dir: ${{ github.workspace }}/..
-          cached: ${{ steps.cache-qt-mac.outputs.cache-hit }}
-          setup-python: 'false'
-          aqtversion: ==1.1.3
-
-      - 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 }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          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 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Run Clang Tidy
-        # Clang-tidy reuses the precompiled headers so this only makes sense for the clang compilers
-        if: startsWith(matrix.compiler, 'clang-')
-        run: $GITHUB_WORKSPACE/ci/linux/clang_tidy.sh ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}
-      - name: Process clang-tidy warnings
-        if: startsWith(matrix.compiler, 'clang-')
-        uses: asarium/clang-tidy-action@v1
-        with:
-          fixesFile: clang-fixes.yaml

.gitignore

@@ -1,260 +0,0 @@
-#OS junk files
-[Tt]humbs.db
-*.DS_Store
-
-#Visual Studio files
-*.[Oo]bj
-*.user
-*.aps
-*.pch
-*.vspscc
-*.vssscc
-*_i.c
-*_p.c
-*.ncb
-*.suo
-*.tlb
-*.tlh
-*.bak
-*.[Cc]ache
-*.ilk
-*.log
-*.lib
-*.sbr
-*.sdf
-*.opensdf
-*.unsuccessfulbuild
-ipch/
-[Oo]bj/
-Ankh.NoLoad
-*.VC.db
-*.VC.VC.opendb
-
-#MonoDevelop
-*.pidb
-*.userprefs
-
-#Tooling
-_ReSharper*/
-*.resharper
-[Tt]est[Rr]esult*
-*.sass-cache
-
-#Project files
-[Bb]uild/
-
-#Subversion files
-.svn
-
-# Office Temp Files
-~$*
-
-# vim Temp Files
-*~
-
-#NuGet
-packages/
-*.nupkg
-
-#ncrunch
-*ncrunch*
-*crunch*.local.xml
-
-# visual studio database projects
-*.dbmdl
-
-#Test files
-*.testsettings
-
-#===========
-
-#########################
-# .gitignore file for Xcode4 and Xcode5 Source projects
-#
-# Apple bugs, waiting for Apple to fix/respond:
-#
-#    15564624 - what does the xccheckout file in Xcode5 do? Where's the documentation?
-#
-# Version 2.1
-# For latest version, see: http://stackoverflow.com/questions/49478/git-ignore-file-for-xcode-projects
-#
-# 2013 updates:
-# - fixed the broken "save personal Schemes"
-# - added line-by-line explanations for EVERYTHING (some were missing)
-#
-# NB: if you are storing "built" products, this WILL NOT WORK,
-# and you should use a different .gitignore (or none at all)
-# This file is for SOURCE projects, where there are many extra
-# files that we want to exclude
-#
-#########################
-
-#####
-# OS X temporary files that should never be committed
-#
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-.DS_Store
-
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-.Trashes
-
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-*.swp
-
-# *.lock - this is used and abused by many editors for many different things.
-#    For the main ones I use (e.g. Eclipse), it should be excluded
-#    from source-control, but YMMV
-
-*.lock
-
-#
-# profile - REMOVED temporarily (on double-checking, this seems incorrect; I can't find it in OS X docs?)
-#profile
-
-
-####
-# Xcode temporary files that should never be committed
-#
-# NB: NIB/XIB files still exist even on Storyboard projects, so we want this...
-
-*~.nib
-
-
-####
-# Xcode build files -
-#
-# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "DerivedData"
-
-DerivedData/
-
-# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "build"
-
-build/
-
-
-#####
-# Xcode private settings (window sizes, bookmarks, breakpoints, custom executables, smart groups)
-#
-# This is complicated:
-#
-# SOMETIMES you need to put this file in version control.
-# Apple designed it poorly - if you use "custom executables", they are
-#  saved in this file.
-# 99% of projects do NOT use those, so they do NOT want to version control this file.
-#  ..but if you're in the 1%, comment out the line "*.pbxuser"
-
-# .pbxuser: http://lists.apple.com/archives/xcode-users/2004/Jan/msg00193.html
-
-*.pbxuser
-
-# .mode1v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
-
-*.mode1v3
-
-# .mode2v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
-
-*.mode2v3
-
-# .perspectivev3: http://stackoverflow.com/questions/5223297/xcode-projects-what-is-a-perspectivev3-file
-
-*.perspectivev3
-
-#    NB: also, whitelist the default ones, some projects need to use these
-!default.pbxuser
-!default.mode1v3
-!default.mode2v3
-!default.perspectivev3
-
-
-####
-# Xcode 4 - semi-personal settings
-#
-#
-# OPTION 1: ---------------------------------
-#     throw away ALL personal settings (including custom schemes!
-#     - unless they are "shared")
-#
-# NB: this is exclusive with OPTION 2 below
-xcuserdata
-
-# OPTION 2: ---------------------------------
-#     get rid of ALL personal settings, but KEEP SOME OF THEM
-#     - NB: you must manually uncomment the bits you want to keep
-#
-# NB: this *requires* git v1.8.2 or above; you may need to upgrade to latest OS X,
-#    or manually install git over the top of the OS X version
-# NB: this is exclusive with OPTION 1 above
-#
-#xcuserdata/**/*
-
-#     (requires option 2 above): Personal Schemes
-#
-#!xcuserdata/**/xcschemes/*
-
-####
-# XCode 4 workspaces - more detailed
-#
-# Workspaces are important! They are a core feature of Xcode - don't exclude them :)
-#
-# Workspace layout is quite spammy. For reference:
-#
-# /(root)/
-#   /(project-name).xcodeproj/
-#     project.pbxproj
-#     /project.xcworkspace/
-#       contents.xcworkspacedata
-#       /xcuserdata/
-#         /(your name)/xcuserdatad/
-#           UserInterfaceState.xcuserstate
-#     /xcsshareddata/
-#       /xcschemes/
-#         (shared scheme name).xcscheme
-#     /xcuserdata/
-#       /(your name)/xcuserdatad/
-#         (private scheme).xcscheme
-#         xcschememanagement.plist
-#
-#
-
-####
-# Xcode 4 - Deprecated classes
-#
-# Allegedly, if you manually "deprecate" your classes, they get moved here.
-#
-# We're using source-control, so this is a "feature" that we do not want!
-
-*.moved-aside
-
-# .xccheckout
-#
-# Per http://stackoverflow.com/questions/18340453/should-xccheckout-files-in-xcode5-be-ignored-under-vcs
-#
-
-*.xccheckout
-
-####
-# Visual Studio Code
-.vscode
-
-####
-# Documentation
-#
-documentation/doxygen/*
-!documentation/doxygen/.gitkeep
-
-
-.idea/*
-projects/*
-/.vs
-CMakeSettings.json
-
-# Weird files created by Linux
-.fuse_hidden*
-
-# This gets ignored by one of the rules above for some reason...
-!/code/scripting/lua/LuaConvert.h
-!/code/debugconsole/
-!/docker/build

.gitmodules

@@ -1,6 +0,0 @@
-[submodule "cmake/external/rpavlik-cmake-modules"]
-	path = cmake/external/rpavlik-cmake-modules
-	url = https://github.com/asarium/cmake-modules.git
-[submodule "lib/libRocket"]
-	path = lib/libRocket
-	url = https://github.com/asarium/libRocket.git

.travis.yml

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

About.md

@@ -1,41 +0,0 @@
-## FreeSpace
-FreeSpace: The Great War (Released 1998) and FreeSpace 2 (1999) are mission-based space combat simulators, like X-Wing/TIE Fighter and Wing Commander. Among the greatest games of the genre, they were also effectively the last.
-
-The FreeSpace series follows humanity and their Vasudan allies as they fight to withstand the xenocidal, enigmatic Shivans, a species of unknown origin, vast technological capability, and seemingly limitless malice.
-
-## FreeSpace Open
-Thanks to Volition's generosity, we've continued development of FreeSpace 2 as FreeSpace Open, building graphical enhancements to bring the original games up to modern standards, telling new stories set in the FreeSpace universe and original worlds, and creating spectacular total conversions that let players fly in the beloved universes of Babylon 5, Battlestar Galactica, Wing Commander, and Star Wars.
-
-## Hard-Light Productions
-HLP is a fan community built on love and open-source code. We're dedicated to bringing modders together and giving them a place to share their own hard work and draw inspiration from the work of others. Thanks to Volition's generosity, we've continued development of FreeSpace 2 as FreeSpace Open, building graphical enhancements to bring the original games up to modern standards, telling new stories set in the FreeSpace universe and original worlds, and creating spectacular total conversions that let players fly in the beloved universes of Babylon 5, Battlestar Galactica, Wing Commander, and Star Wars.
-Find us at:
- - Our [website](http://www.hard-light.net/) and [forums](http://www.hard-light.net/forums/)
- - [Discord](https://discord.gg/YNVP3WR)
- - [Facebook](https://www.facebook.com/groups/Hardlightproductions/)
- - [Youtube](https://www.youtube.com/channel/UCxKkd609hDtY6yNetR1iT4w)
- - [Reddit](https://www.reddit.com/r/freespace/)
- - [Twitter](https://twitter.com/hardlightpro)
- - [IRC](irc://irc.esper.net/hard-light)
-
-
-## How to get the game
-FreeSpace Open requires a retail installation of FreeSpace 2, which is available at the following stores: 
- - [GOG.com](https://www.gog.com/game/freespace_2)
- - [Steam](https://store.steampowered.com/app/273620/Freespace_2/)  
-After installing retail FS2, use [Knossos](https://fsnebula.org/knossos/) to upgrade to the most recent release of FSO. Knossos is an advanced mod manager and launcher for FSO.
-
-## Improvements
-The new open source game engine has several distingushing features including:
- - Linux and Mac OS X support
- - OpenGL support
- - OpenAL audio support
- - Easy mod installation
- - OGG support
- - Hardware transform, clipping, and lighting
-
-## The FreeSpace Upgrade Project
-While the SCP improves the code of the game engine to enable new and exciting features, the FreeSpace Upgrade Project (FSU) creates material that takes advantage of the improved game engine.  
-The FSU improves the ships, effects, and background elements of FreeSpace 2. Every now and then these improvements are released as a pack called MediaVPs. These assorted improvements enhance the graphics of the game.  
-While the best way to experience the FSU is by playing the game with it, you can watch this [comparison video](https://www.youtube.com/watch?v=RM1YC_gK-qo) between 1999 and 2019 to have an idea of how much more beautiful FSU makes the game.
-
-^(Much of this content was pulled from existing sources, such as InsaneBaron's "What Is Hard Light Productions" [thread](https://www.hard-light.net/forums/index.php?topic=86650.0), the Wiki's [Getting Started article](https://wiki.hard-light.net/index.php/Getting_started) and more.) 

Authors.md

@@ -1,8 +0,0 @@
-Original source (Freespace 2) by Volition, Inc.; see "`credits.tbl`"
-
-Modifications by the FreeSpace 2 Source Code Project [(FSO SCP)](https://www.hard-light.net/forums/index.php?board=50.0)   
-[Project Contributors](https://github.com/scp-fs2open/fs2open.github.com/graphs/contributors)
-
-Special thanks to:
-Volition for making FS2 such a great game
-Dave Baranec for giving us the code and keeping us sanity checked

CMakeLists.txt

@@ -1,224 +0,0 @@
-
-CMAKE_MINIMUM_REQUIRED(VERSION 3.4)
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-
-# Make sure the source and binary directory are not the sample
-if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
-	message(FATAL_ERROR "Binary and source directory can not be the same! Choose another build directory.")
-endif()
-
-include(cmake/util.cmake)
-include(cmake/embed_file.cmake)
-
-# Set a few policies
-set_policy(CMP0051 NEW)
-set_policy(CMP0053 NEW)
-set_policy(CMP0054 NEW)
-
-SET(FSO_PROJECT_DESCRIPTION "Open source project based on the original FreeSpace 2 source code.")
-
-SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin CACHE PATH "Executable output path")
-SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin CACHE PATH "Library output path")
-
-# CMAKE_INSTALL_PREFIX is defined but also overwritten by the PROJECT command so we need to set it later
-IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
-	SET(RESET_INSTALL_PREFIX TRUE)
-ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX)
-
-# Reset this variable
-SET(TARGET_COPY_FILES "" CACHE INTERNAL "" FORCE)
-SET(TARGET_COPY_DIRS "" CACHE INTERNAL "" FORCE)
-
-### Define options and editable variables in the section below:
-# This is only needed for single configuration generators so don't annoy others
-if(NOT CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
-	set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Default build configuration used." FORCE)
-	message(WARNING "CMAKE_BUILD_TYPE was not specified, defaulting to Release configuration.")
-endif(NOT CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
-
-# Override standard CMake configurations
-set(CMAKE_CONFIGURATION_TYPES Debug Release FastDebug CACHE STRING "Available configurations" FORCE)
-
-PROJECT(FS2_Open)
-
-find_program(CCACHE_PROGRAM ccache)
-# Currently only GCC support ccache properly without generating additional warnings
-# Enable ccache on Mac even for clang
-if(CCACHE_PROGRAM AND ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR APPLE))
-	if(NOT CMAKE_C_COMPILER_LAUNCHER)
-		message(STATUS "Using ccache for C compilation: ${CCACHE_PROGRAM}")
-		SET(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
-	endif()
-	if(NOT CMAKE_CXX_COMPILER_LAUNCHER)
-		message(STATUS "Using ccache for C++ compilation: ${CCACHE_PROGRAM}")
-		SET(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
-	endif()
-endif()
-
-IF(CMAKE_CROSSCOMPILING)
-	SET(IMPORT_EXE_DIR "IMPORT_EXE_DIR-NOTFOUND" CACHE FILEPATH "Required for a cross compiling build, point to binary directory of a cmake build for the real OS")
-	INCLUDE(${IMPORT_EXE_DIR}/ImportExecutables.cmake)
-ENDIF(CMAKE_CROSSCOMPILING)
-
-# Check if the external modules exists
-IF(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/rpavlik-cmake-modules/launcher-templates")
-	message(FATAL_ERROR "External submodules could not be found. Please make sure you have updated your submodules.")
-endif()
-
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/finder")
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/rpavlik-cmake-modules")
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/cotire")
-
-IF(RESET_INSTALL_PREFIX)
-	IF(NOT $ENV{FS2PATH} STREQUAL "")
-		IF(NOT IS_DIRECTORY $ENV{FS2PATH})
-			MESSAGE(WARNING "The path '$ENV{FS2PATH}' of the environment variable FS2PATH does not point to a directory! Install prefix wasn't set.")
-		ELSE(NOT IS_DIRECTORY $ENV{FS2PATH})
-			SET(CMAKE_INSTALL_PREFIX "$ENV{FS2PATH}" CACHE FILEPATH "Install path" FORCE)
-			FILE(TO_CMAKE_PATH ${CMAKE_INSTALL_PREFIX} CMAKE_INSTALL_PREFIX)
-		ENDIF(NOT IS_DIRECTORY $ENV{FS2PATH})
-	ELSE(NOT $ENV{FS2PATH} STREQUAL "")
-		MESSAGE(STATUS "NO FS2PATH environment variable found, you can define this to point to your freespace install but it is not required.")
-	ENDIF(NOT $ENV{FS2PATH} STREQUAL "")
-ENDIF(RESET_INSTALL_PREFIX)
-
-IF (WIN32)
-	OPTION(FSO_USE_SPEECH "Use Windows specific text-to-speach libraries" ON)
-
-	OPTION(FSO_USE_VOICEREC "Enable voice recognition support" ON)
-
-	OPTION(FSO_BUILD_FRED2 "Build FRED2 binary" ON)
-elseif(UNIX)
-	option(FSO_BUILD_APPIMAGE "Build an AppImage package" OFF)
-ENDIF(WIN32)
-
-OPTION(FSO_BUILD_TOOLS "Build tools related to FSO" OFF)
-
-OPTION(FSO_BUILD_TESTS "Build unit tests" OFF)
-
-OPTION(FSO_DEVELOPMENT_MODE "Generate binaries in development mode, only use if you know what you're doing!" OFF)
-
-OPTION(FSO_BUILD_QTFRED "Build qtFRED2 binary" OFF)
-
-IF(WIN32 OR APPLE)
-	# On windows and mac the default should be to always build the included libraries
-	SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT ON)
-ELSE()
-	SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT OFF)
-ENDIF()
-
-OPTION(FSO_BUILD_INCLUDED_LIBS "Build and use the included libraries istead of using the system headers and libraries" ${FSO_BUILD_INCLUDED_LIBS_DEFAULT})
-
-OPTION(FSO_USE_LUAJIT "Use LuaJIT for Lua scripting, needs a working internet connection!" OFF)
-
-OPTION(FSO_USE_OPENALSOFT "Download and build OpenAL Soft instead of using the system libraries" OFF)
-
-OPTION(FSO_FATAL_WARNINGS "Determines if warnings in the build are considered fatal errors, primarily used for CI" OFF)
-
-SET(FSO_FREESPACE_PATH "${CMAKE_INSTALL_PREFIX}" CACHE FILEPATH "The path of the FreeSpace directory you want to use. Please note that you will have to change CMAKE_INSTALL_PREFIX if you change this at some point.")
-
-SET(FSO_RUN_ARGUMENTS "" CACHE STRING "Additional arguments passed to a generated executable when run with the generated build files.")
-
-option(FSO_INSTALL_DEBUG_FILES "Install some debug files (currently only PDB files on windows)" OFF)
-
-option(ENABLE_COTIRE "Enable cotire for faster compilation. Enabled by default." ON)
-
-option(FSO_RELEASE_LOGGING "Enable logging output for release builds" OFF)
-
-OPTION(FSO_BUILD_WITH_FFMPEG "Enable the usage of FFmpeg for sound and custscenes" ON)
-
-OPTION(FSO_BUILD_WITH_OPENGL "Enable compilation of the OpenGL renderer" ON)
-
-OPTION(FSO_BUILD_WITH_VULKAN "Enable compilation of the Vulkan renderer" ON)
-
-MARK_AS_ADVANCED(FORCE FSO_CMAKE_DEBUG)
-MARK_AS_ADVANCED(FORCE FSO_BUILD_INCLUDED_LIBS)
-MARK_AS_ADVANCED(FORCE FSO_USE_OPENALSOFT)
-MARK_AS_ADVANCED(FORCE FSO_USE_LUAJIT)
-MARK_AS_ADVANCED(FORCE FSO_DEVELOPMENT_MODE)
-MARK_AS_ADVANCED(FORCE FSO_FATAL_WARNINGS)
-mark_as_advanced(FORCE FSO_INSTALL_DEBUG_FILES)
-mark_as_advanced(FORCE ENABLE_COTIRE)
-mark_as_advanced(FORCE FSO_RELEASE_LOGGING)
-mark_as_advanced(FORCE FSO_BUILD_WITH_FFMPEG)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL)
-mark_as_advanced(FORCE FSO_BUILD_WITH_VULKAN)
-
-# Include cotire file from https://github.com/sakra/cotire/
-include(cotire)
-
-INCLUDE(globals)
-INCLUDE(toolchain)
-INCLUDE(platforms)
-include(version)
-
-INCLUDE(headers)
-
-SET(GENERATED_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/generated_source)
-
-include(generateHeaders)
-
-if(FSO_BUILD_APPIMAGE)
-	include(appimage)
-endif()
-
-include(clang-tidy)
-
-# This includes source code for some tools, either used in the build or also for something else
-ADD_SUBDIRECTORY(tools)
-
-ADD_SUBDIRECTORY(lib)
-
-ADD_SUBDIRECTORY(parsers)
-
-ADD_SUBDIRECTORY(code)
-
-ADD_SUBDIRECTORY(freespace2)
-
-IF(FSO_BUILD_FRED2)
-	ADD_SUBDIRECTORY(fred2)
-ENDIF(FSO_BUILD_FRED2)
-
-IF(FSO_BUILD_QTFRED)
-	ADD_SUBDIRECTORY(qtfred)
-ENDIF()
-
-if(FSO_BUILD_TESTS)
-	add_subdirectory(test)
-endif()
-
-if ("${CMAKE_VERSION}" VERSION_GREATER "3.5")
-	# Default to using Freespace2 as startup project if CMake supports it.
-	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT Freespace2)
-endif()
-
-IF(MSVC_USE_RUNTIME_DLL)
-	SET(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION "${BINARY_DESTINATION}")
-
-	IF(FSO_BUILD_FRED2)
-		SET(CMAKE_INSTALL_MFC_LIBRARIES ON)
-	ENDIF(FSO_BUILD_FRED2)
-
-	INCLUDE(InstallRequiredSystemLibraries)
-ENDIF(MSVC_USE_RUNTIME_DLL)
-
-include(package)
-
-include(doxygen)
-
-# Print used options to log
-IF (WIN32)
-	message(STATUS "Using text to speech: ${FSO_USE_SPEECH}")
-	message(STATUS "Using voice recogition: ${FSO_USE_VOICEREC}")
-	message(STATUS "Building FRED2: ${FSO_BUILD_FRED2}")
-elseif(UNIX)
-	message(STATUS "Building AppImage: ${FSO_BUILD_APPIMAGE}")
-ENDIF()
-message(STATUS "Building FSO tools: ${FSO_BUILD_TOOLS}")
-message(STATUS "Building qtFRED: ${FSO_BUILD_QTFRED}")
-message(STATUS "Fatal warnings: ${FSO_FATAL_WARNINGS}")
-message(STATUS "Release logging: ${FSO_RELEASE_LOGGING}")
-message(STATUS "With FFmpeg: ${FSO_BUILD_WITH_FFMPEG}")
-message(STATUS "With OpenGL: ${FSO_BUILD_WITH_OPENGL}")
-message(STATUS "With Vulkan: ${FSO_BUILD_WITH_VULKAN}")

CVSROOT/checkoutlist

@@ -0,0 +1,15 @@
+# The "checkoutlist" file is used to support additional version controlled
+# administrative files in $CVSROOT/CVSROOT, such as template files.
+#
+# The first entry on a line is a filename which will be checked out from
+# the corresponding RCS file in the $CVSROOT/CVSROOT directory.
+# The remainder of the line is an error message to use if the file cannot
+# be checked out.
+#
+# File format:
+#
+#	[<whitespace>]<filename><whitespace><error message><end-of-line>
+#
+# comment lines begin with '#'
+new_commit_prep	Error checking out/updating CVSROOT/new_commit_prep
+new_log_accum	Error checking out/updating CVSROOT/new_log_accum

CVSROOT/commitinfo

@@ -0,0 +1,17 @@
+# The "commitinfo" file is used to control pre-commit checks.
+# The filter on the right is invoked with the repository and a list 
+# of files to check.  A non-zero exit of the filter program will 
+# cause the commit to be aborted.
+#
+# The first entry on a line is a regular expression which is tested
+# against the directory that the change is being committed to, relative
+# to the $CVSROOT.  For the first match that is found, then the remainder
+# of the line is the name of the filter to run.
+#
+# If the repository name does not match any of the regular expressions in this
+# file, the "DEFAULT" line is used, if it is specified.
+#
+# If the name "ALL" appears as a regular expression it is always used
+# in addition to the first matching regex or "DEFAULT".
+DEFAULT	$CVSROOT/CVSROOT/new_commit_prep
+CVSROOT	$CVSROOT/CVSROOT/new_commit_prep

CVSROOT/config

@@ -0,0 +1,14 @@
+# Set this to "no" if pserver shouldn't check system users/passwords
+#SystemAuth=no
+
+# Put CVS lock files in this directory rather than directly in the repository.
+#LockDir=/var/lock/cvs
+
+# Set `TopLevelAdmin' to `yes' to create a CVS directory at the top
+# level of the new working directory when using the `cvs checkout'
+# command.
+#TopLevelAdmin=no
+
+# Set `LogHistory' to `all' or `TOFEWGCMAR' to log all transactions to the
+# history file, or a subset as needed (ie `TMAR' logs all write operations)
+#LogHistory=TOFEWGCMAR

CVSROOT/cvswrappers

@@ -0,0 +1,23 @@
+# This file affects handling of files based on their names.
+#
+# The -t/-f options allow one to treat directories of files
+# as a single file, or to transform a file in other ways on
+# its way in and out of CVS.
+#
+# The -m option specifies whether CVS attempts to merge files.
+#
+# The -k option specifies keyword expansion (e.g. -kb for binary).
+#
+# Format of wrapper file ($CVSROOT/CVSROOT/cvswrappers or .cvswrappers)
+#
+#  wildcard	[option value][option value]...
+#
+#  where option is one of
+#  -f		from cvs filter		value: path to filter
+#  -t		to cvs filter		value: path to filter
+#  -m		update methodology	value: MERGE or COPY
+#  -k		expansion mode		value: b, o, kkv, &c
+#
+#  and value is a single-quote delimited value.
+# For example:
+#*.gif -k 'b'

CVSROOT/editinfo

@@ -0,0 +1,21 @@
+# The "editinfo" file is used to allow verification of logging
+# information.  It works best when a template (as specified in the
+# rcsinfo file) is provided for the logging procedure.  Given a
+# template with locations for, a bug-id number, a list of people who
+# reviewed the code before it can be checked in, and an external
+# process to catalog the differences that were code reviewed, the
+# following test can be applied to the code:
+#
+#   Making sure that the entered bug-id number is correct.
+#   Validating that the code that was reviewed is indeed the code being
+#       checked in (using the bug-id number or a seperate review
+#       number to identify this particular code set.).
+#
+# If any of the above test failed, then the commit would be aborted.
+#
+# Actions such as mailing a copy of the report to each reviewer are
+# better handled by an entry in the loginfo file.
+#
+# One thing that should be noted is the the ALL keyword is not
+# supported.  There can be only one entry that matches a given
+# repository.

CVSROOT/loginfo

@@ -0,0 +1,30 @@
+# The "loginfo" file controls where "cvs commit" log information
+# is sent.  The first entry on a line is a regular expression which must match
+# the directory that the change is being made to, relative to the
+# $CVSROOT.  If a match is found, then the remainder of the line is a filter
+# program that should expect log information on its standard input.
+#
+# If the repository name does not match any of the regular expressions in this
+# file, the "DEFAULT" line is used, if it is specified.
+#
+# If the name ALL appears as a regular expression it is always used
+# in addition to the first matching regex or DEFAULT.
+#
+# You may specify a format string as part of the
+# filter.  The string is composed of a `%' followed
+# by a single format character, or followed by a set of format
+# characters surrounded by `{' and `}' as separators.  The format
+# characters are:
+#
+#   s = file name
+#   V = old version number (pre-checkin)
+#   v = new version number (post-checkin)
+#
+# For example:
+#DEFAULT (echo ""; id; echo %s; date; cat) >> $CVSROOT/CVSROOT/commitlog
+# or
+#DEFAULT (echo ""; id; echo %{sVv}; date; cat) >> $CVSROOT/CVSROOT/commitlog
+
+DEFAULT $CVSROOT/CVSROOT/new_log_accum -m [email protected] %{sVv}
+CVSROOT $CVSROOT/CVSROOT/new_log_accum -m [email protected] %{sVv}
+

CVSROOT/modules

@@ -0,0 +1,26 @@
+# Three different line formats are valid:
+#	key	-a    aliases...
+#	key [options] directory
+#	key [options] directory files...
+#
+# Where "options" are composed of:
+#	-i prog		Run "prog" on "cvs commit" from top-level of module.
+#	-o prog		Run "prog" on "cvs checkout" of module.
+#	-e prog		Run "prog" on "cvs export" of module.
+#	-t prog		Run "prog" on "cvs rtag" of module.
+#	-u prog		Run "prog" on "cvs update" of module.
+#	-d dir		Place module in directory "dir" instead of module name.
+#	-l		Top-level directory only -- do not recurse.
+#
+# NOTE:  If you change any of the "Run" options above, you'll have to
+# release and re-checkout any working directories of these modules.
+#
+# And "directory" is a path to a directory relative to $CVSROOT.
+#
+# The "-a" option specifies an alias.  An alias is interpreted as if
+# everything on the right of the "-a" had been typed on the command line.
+#
+# You can encode a module within a module by using the special '&'
+# character to interpose another module into the current module.  This
+# can be useful for creating a module that consists of many directories
+# spread out over the entire source repository.

CVSROOT/new_commit_prep

@@ -0,0 +1,104 @@
+#!/usr/bin/perl -w
+#
+# Copyright (C) 2000 by Kevin L. Mitchell <[email protected]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+#
+# Script to store the last visited directory for newlogaccum.pl.
+#
+# $Id: new_commit_prep,v 1.1 2002-08-11 23:05:15 drevil Exp $
+
+use strict;
+
+# This routine removes everything in a directory
+sub clear_dir {
+    my ($dir) = @_;
+    my ($file);
+
+    opendir(DIR, $dir) || die "Cannot clear directory $dir: $!";
+    while ($file = readdir(DIR)) {
+	next
+	    if ($file eq "." || $file eq "..");
+
+	$file = "$dir/$file";
+
+	if (-d $file) {
+	    # It's a directory, recurse into it, then delete it.
+	    clear_dir($file);
+	    rmdir($file);
+	} else {
+	    # It's a file, delete it.
+	    unlink($file);
+	}
+    }
+    closedir(DIR);
+}
+
+# This routine prepares a temporary directory, hopefully in a secure
+# fashion; it uses the process group to make secondary programs be able
+# to find it.
+sub tmpdir (;$) {
+    my ($clear) = @_;
+    my ($pgrp, $own, $mode, $tmpdir);
+
+    $pgrp = getpgrp();
+
+    die "Don't run $0 setuid!"
+	unless ($< == $>);
+
+    # Decide on the directory name, using various environment variables
+    $tmpdir = ($ENV{TMPDIR} || $ENV{TMP} || $ENV{TEMP} || "/tmp") .
+	"/.#cvs.$pgrp";
+
+    # Doesn't exist, but we can't create it...
+    die "Can't create temporary directory $tmpdir: $!"
+	unless (-e $tmpdir || mkdir($tmpdir, 0700));
+
+    die "Temporary directory $tmpdir is not a directory"
+	unless (-d $tmpdir);
+
+    # Check ownership and permissions
+    (undef, undef, $mode, undef, $own, undef) = stat($tmpdir);
+
+    die "Temporary directory $tmpdir not owned by $< (owned by $own)"
+	unless ($own == $<);
+
+    die "Temporary directory $tmpdir group-writable"
+	if ($mode & 0020);
+    die "Temporary directory $tmpdir other-writable"
+	if ($mode & 0002);
+
+    # If we're supposed to clear the directory, do so...
+    clear_dir($tmpdir)
+	if ($clear);
+
+    return $tmpdir;
+}
+
+# This routine writes a single line to a file
+sub write_line ($$) {
+    my ($fname, $line) = @_;
+
+    open(FILE, ">$fname") || die "Cannot open file $fname for writing";
+    print FILE "$line\n";
+    close(FILE);
+}
+
+# Create and empty the temporary directory
+my ($tmpdir) = (tmpdir(1));
+
+# Store the directory name
+write_line("$tmpdir/lastdir", shift(@ARGV));

CVSROOT/new_log_accum

@@ -0,0 +1,757 @@
+#!/usr/bin/perl -w
+#
+# Copyright (C) 2000 by Kevin L. Mitchell <[email protected]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+#
+# Script to accumulate log messages for an entire tree and send them along
+# with the diffs; deals correctly with all manner of branching (I hope)
+#
+# $Id: new_log_accum,v 1.1 2002-08-11 23:05:15 drevil Exp $
+#
+
+use strict;
+
+use vars qw($MAILER $CVS $debug $boundary);
+use MD5;
+
+# Set this to the full path of a mailer that takes a list
+# of email addresses as arguments...
+$MAILER = "/usr/sbin/sendmail -oi -oeq";
+
+# Set this to the path of the CVS binary responsible for this tree...
+$CVS = "/usr/bin/cvs";
+
+# Don't touch this; use the -d command line option
+$debug = 0;
+
+# This is initialized by build_mailheader()
+$boundary = '';
+
+use POSIX qw(setsid);
+
+# We have to dissociate from our parent, so that the CVS commit can
+# complete, before we try to extract the diffs
+sub daemonize {
+    defined(my $pid = fork()) || die "Can't fork: $!";
+    exit(0)
+	if $pid;
+    setsid() || die "Can't start a new session: $!";
+}
+
+# Debugging output
+sub debug (@) {
+    print STDERR @_
+	if ($debug);
+}
+
+# Constants used in the FSM below for parsing the log message
+sub STATE_NONE     { 0 }
+sub STATE_MODIFIED { 1 }
+sub STATE_ADDED    { 2 }
+sub STATE_REMOVED  { 3 }
+sub STATE_LOG1     { 4 }
+sub STATE_LOG2     { 5 }
+
+# This routine removes everything in a directory
+sub clear_dir {
+    my ($dir) = @_;
+    my ($file);
+
+    opendir(DIR, $dir) || die "Cannot clear directory $dir: $!";
+    while ($file = readdir(DIR)) {
+	next
+	    if ($file eq "." || $file eq "..");
+
+	$file = "$dir/$file";
+
+	if (-d $file) {
+	    # It's a directory, recurse into it, then delete it.
+	    clear_dir($file);
+	    rmdir($file);
+	} else {
+	    # It's a file, delete it.
+	    unlink($file);
+	}
+    }
+    closedir(DIR);
+}
+
+# This routine prepares a temporary directory, hopefully in a secure
+# fashion; it uses the process group to make secondary programs be able
+# to find it.
+sub tmpdir (;$) {
+    my ($clear) = @_;
+    my ($pgrp, $own, $mode, $tmpdir);
+
+    $pgrp = getpgrp();
+
+    die "Don't run $0 setuid!"
+	unless ($< == $>);
+
+    # Decide on the directory name, using various environment variables
+    $tmpdir = ($ENV{TMPDIR} || $ENV{TMP} || $ENV{TEMP} || "/tmp") .
+	"/.#cvs.$pgrp";
+
+    # Doesn't exist, but we can't create it...
+    die "Can't create temporary directory $tmpdir: $!"
+	unless (-e $tmpdir || mkdir($tmpdir, 0700));
+
+    die "Temporary directory $tmpdir is not a directory"
+	unless (-d $tmpdir);
+
+    # Check ownership and permissions
+    (undef, undef, $mode, undef, $own, undef) = stat($tmpdir);
+
+    die "Temporary directory $tmpdir not owned by $< (owned by $own)"
+	unless ($own == $<);
+
+    die "Temporary directory $tmpdir group-writable"
+	if ($mode & 0020);
+    die "Temporary directory $tmpdir other-writable"
+	if ($mode & 0002);
+
+    # If we're supposed to clear the directory, do so...
+    clear_dir($tmpdir)
+	if ($clear);
+
+    return $tmpdir;
+}
+
+# Routine to remove the temporary directory when done
+sub cleanup_dir ($) {
+    # If we're debugging, we may want to look at the contents...
+    return
+	if ($debug);
+
+    clear_dir($_[0]);
+    rmdir($_[0]);
+}
+
+# Retrieve a single line from a specified file
+sub get_line ($) {
+    my ($fname) = @_;
+
+    open(FILE, "<$fname") || die "Cannot open file $fname for reading";
+    my $line = <FILE>;
+    close(FILE);
+
+    # Chomp off the \n
+    chomp $line;
+
+    return $line;
+}
+
+# Routine that only allows one value to be pushed on the array;
+# implemented by making the first element of the array a hash-reference.
+# When we add a new value, we also increment the count of an element in
+# the hash with the key being the array value...
+sub push_once (\@@) {
+    my ($array, @values) = @_;
+
+    # If the array is empty, create our hash ref
+    push @{$array}, {}
+	if (@{$array} == 0);
+
+    foreach my $value (@values) {
+	push @{$array}, $value
+	    if (!exists($array->[0]{$value}));
+
+	$array->[0]{$value}++;
+    }
+
+    return @{$array} - 1;
+}
+
+# Filter //, /./, and remove leading ./ or / from filenames
+sub fname_filter ($) {
+    my ($fname) = @_;
+
+    $fname =~ s,//,/,g;
+    $fname =~ s,/\./,/,g;
+    $fname =~ s,^\.?/,,g;
+
+    return $fname;
+}
+
+# Store file data in a temporary file
+sub names_to_file ($$@) {
+    my ($fname, $dir, @names) = @_;
+
+    if (@names > 0) {
+	open(FILE, ">>$fname") || die "Cannot open file $fname for appending";
+
+	# Store the directory data
+	print FILE "D $dir\n";
+
+	foreach my $name (@names) {
+	    # Mark record as a file...
+	    print FILE "F ";
+
+	    # Store the tag, if there is one...
+	    print FILE "$name->{tag}"
+		if (defined($name->{tag}));
+
+	    # Then store old revision, new revision, and file name
+	    print FILE ":$name->{old}:$name->{new}:$name->{file}\n";
+	}
+
+	close(FILE);
+    }
+}
+
+# Retrieve file data from temporary file; updates branch tags with what it
+# reads
+sub file_to_names (\@$) {
+    my ($btags, $fname) = @_;
+    my ($dir) = (undef);
+    my (@names) = ();
+
+    debug "Reading file names from $fname...\n";
+
+    # We may not have, say, added a file in this subdirectory...
+    return ()
+	if (!-e $fname);
+
+    open(FILE, "<$fname");
+    while(<FILE>) {
+	chomp;
+
+	# Get record type...
+	my ($type, $data) = split(' ', $_, 2);
+
+	# ok, it's a directory, remember that...
+	if ($type eq "D") {
+	    $dir = $data;
+
+	    debug "Read directory $dir\n";
+
+	    next;
+	}
+
+	debug "Read file $data\n";
+
+	# Get all the information about the file
+	my ($tag, $old, $new, $file) = split(':', $data);
+
+	# and store it all
+	push(@names, { tag => $tag, old => $old, new => $new, file => $file,
+		       dir => $dir, name => fname_filter("$dir/$file") });
+
+	# Remember the tags...
+	push_once(@{$btags}, $tag)
+	    if (defined($tag) && $tag ne "");
+    }
+    close(FILE);
+
+    return @names;
+}
+
+# Create a text-formatted list of names
+sub name_to_list (\@@) {
+    my ($btags, @names) = @_;
+    my (@nlist, @nline) = ();
+
+    debug "Tags:", join(':', @{$btags}), "\n";
+
+    # We group them by tag
+    foreach my $tag ("", @{$btags}[1..$#{$btags}]) {
+	debug "Processing tag $tag...\n";
+
+	@nlist = ();
+
+	# Get a list of files by the tag...
+	foreach my $name (@names) {
+	    debug "Processing $name->{file}...\n";
+
+	    next
+		if ($name->{tag} ne $tag);
+
+	    debug "Pushing $name->{name} on \@nlist...\n";
+	    push(@nlist, $name->{name});
+	}
+
+	# If the tag is not the empty string, list the tag...
+	push(@nline, "  Tag: $tag", "    ")
+	    if ($tag ne "");
+
+	# Now list each file name
+	foreach my $name (@nlist) {
+	    # indent if we run past the end of line limit
+	    push(@nline, "    ")
+		if (@nline == 0 || ($nline[$#nline] ne "    " &&
+		    length($nline[$#nline]) + length($name) + 1 > 70));
+
+	    # add the file name to the list
+	    debug "Adding $name to \@nline...\n";
+	    $nline[$#nline] .= " $name";
+	}
+    }
+
+    return @nline;
+}
+
+# write the log message to a temporary file
+sub write_log ($@) {
+    my ($fname, @text) = @_;
+
+    open(FILE, ">$fname") || die "Cannot open file $fname for writing";
+    print FILE join("\n", @text), "\n";
+    close(FILE);
+}
+
+# Build the header of the commit message: CVSROOT, module name, any
+# branch tags, and the commit time
+sub build_header ($@) {
+	my ($module, $subject, $mailto, @branch_tags) = @_;
+	my (@text, @mailto);
+	my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = gmtime(time());
+	my ($user, $dummy);
+	my ($digest);
+
+	($user, $dummy, $dummy, $dummy, $dummy, $dummy, $dummy) = getpwuid($<);
+
+	@mailto = @{$mailto};
+
+	# generate a unique boundary by calculating the md5sum of the
+	# current time
+	$digest = new MD5;
+	$digest->reset();
+	$digest->add(time() . rand());
+	$boundary = "----=MIME." . unpack("H*", $digest->digest());
+	
+	# Build the mail header
+	push(@text, "From: $user");
+	push(@text, "To: " . join(' ', @mailto));
+	push(@text, "Subject: $subject");
+	push(@text, "MIME-Version: 1.0");
+	push(@text, "Content-Type: multipart/mixed; boundary=\"$boundary\"");
+	push(@text, "");
+	push(@text, "This is a multipart message as defined by RFC2049 (MIME)");
+	push(@text, "");
+	push(@text, "--$boundary");
+	push(@text, "Content-Type: text/plain; charset=us-ascii");
+	push(@text, "Content-Disposition: inline");
+	push(@text, "");
+
+	# Build the commit message header
+	push(@text, "Commiter   : $user");
+	push(@text, "CVSROOT    : $ENV{CVSROOT}");
+	push(@text, "Module     : $module");
+	push(@text, "Branch tags: " . join(' ', @branch_tags[1..$#branch_tags]))
+	if (@branch_tags > 0);
+		push(@text, sprintf("Commit time: %04d-%02d-%02d %02d:%02d:%02d UTC",
+			$year + 1900, $mon + 1, $mday, $hour, $min, $sec));
+
+	return @text, "";
+}
+
+# Send the mail message
+sub send_mail {
+    my ($mailto, $text) = @_;
+    my (@mailto, @text);
+    # I <heart> perl
+    @mailto = @{$mailto};
+    @text = @{$text};
+
+    open(MAIL, "|$MAILER " . join(' ', @mailto));
+    push(@text, "--$boundary--", "");
+    print MAIL join("\n", @text), "\n";
+    close(MAIL);
+}
+
+# Find the tmp directory
+my ($tmpdir) = (tmpdir());
+
+my (@mailto) = ();
+my (@files) = ();
+my (@path) = ();
+my ($modname, $repdir, $dir) = (undef, undef, undef);
+
+# Process command line arguments
+while (@ARGV > 0) {
+    my ($arg) = (shift(@ARGV));
+
+    if ($arg eq '-d') {
+	# Turn on debugging
+	$debug++;
+    } elsif ($arg eq '-M') {
+	# Module name explicitly set -- XXX Not tested, use at your own risk
+	die "Argument for -M missing"
+	    unless (@ARGV > 0);
+
+	$modname = shift(@ARGV);
+    } elsif ($arg eq '-m') {
+	# An address to mail the notification to
+	die "Argument for -m missing"
+	    unless (@ARGV > 0);
+
+	push(@mailto, shift(@ARGV));
+    } else {
+	# the list of filenames passed by CVS--you *must* use %{sVv}!
+	die "Too many arguments!"
+	    unless (@files == 0);
+
+	@files = split(" ", $arg);
+    }
+}
+
+die "Nobody to mail to"
+    unless (@mailto > 0);
+
+die "No files to process"
+    unless (@files > 1);
+
+# The repository directory
+$repdir = shift(@files);
+
+# break it appart...
+@path = split("/", $repdir);
+
+# Now we know the module name, if it wasn't explicitly set
+$modname = $path[0]
+    unless (defined($modname));
+
+# Figure out what our directory is
+if (@path == 1) {
+    $dir = ".";
+} else {
+    $dir = join("/", @path[1..$#path]);
+}
+
+# append a / to it...
+$dir .= "/";
+
+debug "module = $modname\n";
+debug "dir    = $dir\n";
+debug "path   = ", join(":", @path), "\n";
+debug "files  = ", join(":", @files), "\n";
+debug "tmpdir = $tmpdir\n";
+
+my (%fversions);
+
+# Unless its a new directory or imported sources, create file records
+unless (defined($files[1]) && defined($files[2]) &&
+	(($files[1] eq "New" && $files[2] eq "directory") ||
+	 ($files[1] eq "Imported" && $files[2] eq "sources"))) {
+
+    foreach my $fname (@files) {
+	# You *must* use %{sVv} in the call in loginfo!
+	die "Invalid filenames"
+	    unless ($fname =~ /^(.*),([0-9.]+|NONE),([0-9.]+|NONE)$/);
+
+	$fversions{$1} = {
+	    old => ($2 eq "NONE" ? "0" : $2),
+	    new => ($3 eq "NONE" ? "0" : $3),
+	};
+    }
+}
+
+# process log message
+my ($state, $tag) = (STATE_NONE, undef);
+
+my (@modified, @added, @removed, @log, @branch_tags) = ();
+
+while (<STDIN>) {
+    chomp;
+
+    debug "State $state, line:$_\n";
+
+    # Ignore empty space at the beginning of the log message
+    next
+	if ($state == STATE_LOG1 && /^\s*$/);
+
+    # We're done ignoring empty space
+    if ($state == STATE_LOG1) {
+	$state = STATE_LOG2;
+    }
+
+    if ($state == STATE_LOG2) {
+	# Don't modify the lines at all if we're processing the log message
+	push(@log, $_);
+	next;
+    } else {
+	# Strip out leading and trailing space
+	s/^\s*(.*?)\s*$/$1/;
+    }
+
+    if (/^Modified Files/) {
+	# Collect list of modified files
+	debug "State switching to STATE_MODIFIED\n";
+
+	$state = STATE_MODIFIED;
+	$tag = undef;
+
+	next;
+
+    } elsif (/^Added Files/) {
+	# Collect list of added files
+	debug "State switching to STATE_ADDED\n";
+
+	$state = STATE_ADDED;
+	$tag = undef;
+
+	next;
+
+    } elsif (/^Removed Files/) {
+	# Collect list of removed files
+	debug "State switching to STATE_REMOVED\n";
+
+	$state = STATE_REMOVED;
+	$tag = undef;
+
+	next;
+
+    } elsif (/^Log Message/) {
+	# Collect log message
+	debug "State switching to STATE_LOG1\n";
+
+	$state = STATE_LOG1;
+	$tag = undef;
+
+	next;
+
+    } elsif (/^Revision\/Branch/) {
+	# Parse old-style Revision/Branch field
+	debug "Found a branch tag\n";
+
+	/^[^:]+:\s*(.*)/;
+
+	push_once(@branch_tags, $1);
+
+	warn "Tag == $tag"
+	    if (defined($tag));
+
+	next;
+    }
+
+    # Ignore the stuff at the top of the commit report
+    next
+	if ($state == STATE_NONE);
+
+    if (/^Tag:\s*(.*)$/) {
+	# Remember the tag
+	debug "Setting tag to $1\n";
+	$tag = $1;
+	next;
+    }
+
+    my (@tfiles) = ();
+
+    # Find the file in our command line list of files
+    foreach my $file (split) {
+	die "Nothing known about file $file!"
+	    unless (exists($fversions{$file}));
+
+	push @tfiles, {
+	    file => $file,
+	    tag => $tag,
+	    old => $fversions{$file}{old},
+	    new => $fversions{$file}{new},
+	};
+    }
+
+    # Store the file list in the correct array
+    push(@modified, @tfiles)
+	if ($state == STATE_MODIFIED);
+
+    push(@added, @tfiles)
+	if ($state == STATE_ADDED);
+
+    push(@removed, @tfiles)
+	if ($state == STATE_REMOVED);
+}
+
+# Remove trailing blank lines from the log message
+while (@log > 0 && $log[$#log] =~ /^\s*$/) {
+    pop(@log);
+}
+
+# If a new directory was added, we're done...
+if (defined($files[1]) && defined($files[2]) &&
+    $files[1] eq "New" && $files[2] eq "directory") {
+
+    my (@text) = ();
+
+    # If there was a sticky tag for the directory, make it a branch tag
+    if ($log[$#log] =~ /^--> Using per-directory sticky tag \`(.*)\'$/) {
+	push_once(@branch_tags, $1);
+	pop(@log);
+    }
+
+    # Build the message...
+    push(@text, build_header($modname, "Module $modname: New directory $dir",
+	 \@mailto, @branch_tags));
+    push(@text, "Log message:", "", @log);
+
+    # and send it (synchronously)
+    send_mail(\@mailto, \@text);
+
+    # Clean up after ourselves and exit.
+    cleanup_dir($tmpdir);
+    exit(0);
+}
+
+# If an import was done, we're done...
+if (defined($files[1]) && defined($files[2]) &&
+    $files[1] eq "Imported" && $files[2] eq "sources") {
+
+    my (@text) = ();
+
+    # Build the message...
+    push(@text, build_header($modname, "Module $modname: Imported $dir",
+	\@mailto, @branch_tags));
+    push(@text, "Log message:", "", @log);
+
+    # and send it (synchronously)
+    send_mail(\@mailto, \@text);
+
+    # Clean up after ourselves and exit.
+    cleanup_dir($tmpdir);
+    exit(0);
+}
+
+debug "Searching for log file index...";
+
+my ($i);
+
+# Look for an empty log file or one that matches our current log message
+for ($i = 0; ; $i++) {
+    my (@text);
+
+    # found one that doesn't exist...
+    last
+	if (!-e "$tmpdir/logfile.$i");
+
+    # read in the log file
+    open(FILE, "<$tmpdir/logfile.$i");
+    while (<FILE>) {
+	chomp;
+	push(@text, $_);
+    }
+    close(FILE);
+
+    # If the log file was empty, use it
+    last
+	if (@text == 0);
+
+    # If the log messages are identical, use that
+    last
+	if (join(' ', @log) eq join(' ', @text));
+}
+
+debug "$tmpdir/logfile.$i\n";
+
+# Store modified, added, and removed file lists, along with the log message
+names_to_file("$tmpdir/modified.$i", $dir, @modified);
+names_to_file("$tmpdir/added.$i",    $dir, @added);
+names_to_file("$tmpdir/removed.$i",  $dir, @removed);
+write_log("$tmpdir/logfile.$i", @log);
+
+# Now check to see if we're at the end of our rope
+my ($lastdir) = (get_line("$tmpdir/lastdir"));
+
+debug "Checking $ENV{CVSROOT}/$repdir against lastdir $lastdir\n";
+
+# Nope, exit instead of sending a message
+exit(0)
+    if ($lastdir ne "$ENV{CVSROOT}/$repdir");
+
+debug "At last, we've reached the end\n";
+
+# We have to daemonize and sleep so that there isn't any lock hanging
+# around when we get to the cvs rdiff below...
+daemonize();
+sleep(10);
+
+# Build the mail message...
+my (@text) = ();
+@files = ();
+@branch_tags = ();
+
+for ($i = 0; ; $i++) {
+    # No more log files
+    last
+	if (!-e "$tmpdir/logfile.$i");
+
+    # read and insert the log message
+    open(FILE, "<$tmpdir/logfile.$i");
+    push(@text, "Log message:", "");
+    while (<FILE>) {
+	chomp;
+	push(@text, $_);
+    }
+    push(@text, "");
+    close(FILE);
+
+    # read modified list and list all modified files if non-empty
+    @modified = file_to_names(@branch_tags, "$tmpdir/modified.$i");
+    push(@text, "Modified files:", name_to_list(@branch_tags, @modified), "")
+	if (@modified > 0);
+
+    # read added list and list all added files if non-empty
+    @added = file_to_names(@branch_tags, "$tmpdir/added.$i");
+    push(@text, "Added files:", name_to_list(@branch_tags, @added), "")
+	if (@added > 0);
+
+    # read removed list and list all removed files if non-empty
+    @removed = file_to_names(@branch_tags, "$tmpdir/removed.$i");
+    push(@text, "Removed files:", name_to_list(@branch_tags, @removed), "")
+	if (@removed > 0);
+
+    # remember all the files we looked at
+    push(@files, @modified, @added, @removed);
+}
+
+# Now that name_to_list has rebuilt our list of branch tags, we can build the
+# header and prepend it to the message
+unshift(@text, build_header($modname, "Module $modname: Change committed",
+	\@mailto, @branch_tags));
+
+# sort the files out for our diff
+@files = sort { $a->{name} cmp $b->{name} } @files;
+
+my ($user, $filename);
+my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = gmtime(time());
+$user = getpwuid($<);
+
+$filename = sprintf("%s.%04d%02d%02d.%02d%02d%02d.%s.diff", $modname,
+	$year + 1900, $mon + 1, $mday, $hour, $min, $sec, $user);
+
+push(@text, "--$boundary");
+push(@text, "Content-Type: text/plain; name=\"$filename\"");
+push(@text, "Content-Disposition: attachment; filename=\"$filename\"");
+push(@text, "Content-Transfer-Encoding: 8bit");
+push(@text, "");
+
+foreach my $file (@files) {
+    debug "Diffing file $file->{name}...\n";
+
+    # Run cvs rdiff, extracting a diff between the old version and the new
+    open(DIFF, "$CVS -Q rdiff -u -r $file->{old} -r $file->{new} " .
+	 "$modname/$file->{name}|");
+    while (<DIFF>) {
+	chomp;
+	push(@text, $_);
+    }
+    close(DIFF);
+}
+
+# send the mail...
+send_mail(\@mailto, \@text);
+
+# and clean up after ourselves
+cleanup_dir($tmpdir);

CVSROOT/notify

@@ -0,0 +1,12 @@
+# The "notify" file controls where notifications from watches set by
+# "cvs watch add" or "cvs edit" are sent.  The first entry on a line is
+# a regular expression which is tested against the directory that the
+# change is being made to, relative to the $CVSROOT.  If it matches,
+# then the remainder of the line is a filter program that should contain
+# one occurrence of %s for the user to notify, and information on its
+# standard input.
+#
+# "ALL" or "DEFAULT" can be used in place of the regular expression.
+#
+# For example:
+#ALL mail %s -s "CVS notification"

CVSROOT/passwd

@@ -0,0 +1,9 @@
+drevil:f76FWdDTUBG5c:fs2source
+mysterial:f7nJUwoIhmSrg:fs2source
+wmcoolmon:f7JRB.js9Q1sE:fs2source
+inquisitor:f7BVkOvwjDlWk:fs2source
+penguin:Jh.dOjaiO2jHk:fs2source
+DTP:f7M92Z/6/uep.:fs2source
+unknownplayer:f79BgAn.IzJs6:fs2source
+phreak:f7WQyGiT/jzlM:fs2source
+anonymous:oIKtWP1q6GDt6:fs2source

CVSROOT/rcsinfo

@@ -0,0 +1,13 @@
+# The "rcsinfo" file is used to control templates with which the editor
+# is invoked on commit and import.
+#
+# The first entry on a line is a regular expression which is tested
+# against the directory that the change is being made to, relative to the
+# $CVSROOT.  For the first match that is found, then the remainder of the
+# line is the name of the file that contains the template.
+#
+# If the repository name does not match any of the regular expressions in this
+# file, the "DEFAULT" line is used, if it is specified.
+#
+# If the name "ALL" appears as a regular expression it is always used
+# in addition to the first matching regex or "DEFAULT".

CVSROOT/taginfo

@@ -0,0 +1,20 @@
+# The "taginfo" file is used to control pre-tag checks.
+# The filter on the right is invoked with the following arguments:
+#
+# $1 -- tagname
+# $2 -- operation "add" for tag, "mov" for tag -F, and "del" for tag -d
+# $3 -- repository
+# $4->  file revision [file revision ...]
+#
+# A non-zero exit of the filter program will cause the tag to be aborted.
+#
+# The first entry on a line is a regular expression which is tested
+# against the directory that the change is being committed to, relative
+# to the $CVSROOT.  For the first match that is found, then the remainder
+# of the line is the name of the filter to run.
+#
+# If the repository name does not match any of the regular expressions in this
+# file, the "DEFAULT" line is used, if it is specified.
+#
+# If the name "ALL" appears as a regular expression it is always used
+# in addition to the first matching regex or "DEFAULT".

CVSROOT/verifymsg

@@ -0,0 +1,21 @@
+# The "verifymsg" file is used to allow verification of logging
+# information.  It works best when a template (as specified in the
+# rcsinfo file) is provided for the logging procedure.  Given a
+# template with locations for, a bug-id number, a list of people who
+# reviewed the code before it can be checked in, and an external
+# process to catalog the differences that were code reviewed, the
+# following test can be applied to the code:
+#
+#   Making sure that the entered bug-id number is correct.
+#   Validating that the code that was reviewed is indeed the code being
+#       checked in (using the bug-id number or a seperate review
+#       number to identify this particular code set.).
+#
+# If any of the above test failed, then the commit would be aborted.
+#
+# Actions such as mailing a copy of the report to each reviewer are
+# better handled by an entry in the loginfo file.
+#
+# One thing that should be noted is the the ALL keyword is not
+# supported.  There can be only one entry that matches a given
+# repository.

CVSROOT/writers

@@ -0,0 +1,4 @@
+drevil
+inquisitor
+mysterial
+penguin

Copying.md

@@ -1,22 +0,0 @@
-Volition Copyright (applies to original FreeSpace2 source code
-developed and released by Volition):
-
->Copyright (C) Volition, Inc. 1999.  All rights reserved.
->
->All source code herein is the property of Volition, Inc. You may not
-sell or otherwise commercially exploit the source or things you
-created based on the source.
-
-
-Modifications by members of the FreeSpace Source Code Project are
-released under whatever terms the individual authors choose, but the
-above notice continues to apply to all fs2_open code.
-
-All modifications made on or after November 1, 2020, shall be released under 
-the terms within [Unlicense](Unlicense.md). Modifications made before said date are released 
-under the previous terms with the exception of modifications made by members 
-of the FreeSpace Source Code Project that opt-in to the terms of Unlicense. Additionally, 
-a list of contributors who have opted in to the Unlicense terms can be found 
-in [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing).
-
-See [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing) for more information.

Readme.md

@@ -1,11 +0,0 @@
-FreeSpace2 *S*ource *C*ode *P*roject
-==
-[![Travis-CI Build Status](https://travis-ci.org/scp-fs2open/fs2open.github.com.svg?branch=master)](https://travis-ci.org/scp-fs2open/fs2open.github.com)
-[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/scp-fs2open/fs2open.github.com?branch=master&svg=true)](https://ci.appveyor.com/project/SirKnightly/fs2open-github-com/branch/master)
-[![Coverity](https://img.shields.io/coverity/scan/870.svg)](https://scan.coverity.com/projects/870)
-
-Building
---
-Before you do anything, make sure you have updated your git submodules, either by running `git submodule update --init --recursive` or by cloning the repository with the `--recursive` flag.<br/>
-
-The main instructions for building can be found at our github wiki, on the [Building](https://github.com/scp-fs2open/fs2open.github.com/wiki/Building) page.

Unlicense.md

@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to [**Unlicense**](https://unlicense.org).

UpdatingDocumentation.md

@@ -1,18 +0,0 @@
-#Updating Documentation
-####The goal of this file is simply to offer a comprehensive checklist of things we must check when updating the documentation.
-
-1. Changelog: 
- - Is [Changelog.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Changelog.md) up-to-date with the latest release?
- - Is it in the proper [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format? 
-2. Build instructions:  
- - If a programmer who never built FSO before read the build instruction at [Readme.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Readme.md), would they manage to build FSO? 
- - Is the information in the file up-to-date regarding other matters (such as versions of tools mentioned, links to other guides, etc.)?
- - Is the information in the [Building](https://github.com/scp-fs2open/fs2open.github.com/wiki/Building) article, and its sub-articles, still up-to-date?
-3. Forums: 
- - Does the [Forum](https://www.hard-light.net/forums/index.php?board=50.0) contain enough clear information to help a new developer find their way into the up-to-date instructions?
- - Is there anything that might mislead a new developer to stumble onto old tools, dead links and/or old versions of the project?
-4. General documentation files: 
- - Is the information in the following files up-to-date? 
-   - [About.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/About.md) (Should contain general information about FS, FS2, HLP, FSO and FSU)
-   - [Authors.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Authors.md) (Should contain information about the original developers, a way to see FSO's contributors, and special thanks to Volition and Dave Baranec)
-   - [Copying.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Copying.md) (Should contain Volition's Copyright terms and a way to check FSO's Licensing info)

appveyor.yml

@@ -1,62 +0,0 @@
-version: 1.0.0.{build}
-image: Visual Studio 2015
-configuration:
-  - Debug
-  - Release
-clone_depth: 10
-environment:
-  matrix:
-    - BuildID: 0
-      CMAKE_GENERATOR: Visual Studio 14 2015
-      PlatformToolset: v140
-      QT_DIR: C:\Qt\5.9\msvc2015
-    - BuildID: 1
-      CMAKE_GENERATOR: Visual Studio 14 2015 Win64
-      PlatformToolset: v140
-      QT_DIR: C:\Qt\5.9\msvc2015_64
-before_build:
-  - git submodule update --init --recursive
-build_script:
-  - ps: . $Env:APPVEYOR_BUILD_FOLDER/ci/appveyor/build.ps1
-test_script:
-  - ps: . $Env:APPVEYOR_BUILD_FOLDER/ci/appveyor/test.ps1
-
-deploy:
-    - provider: GitHub
-      auth_token:
-          secure: h55Scpy+3vmo1Yb7WlSIGA4d9DRnsbzUYc2LYsQdByQHZHbqrqjBpicH0D2FFLEO
-      on:
-          ReleaseBuild: true        # deploy on release push only
-
-    - provider: FTP
-      protocol: sftp
-      host: scp.indiegames.us
-      username:
-        secure: SFivQZfatqWHXK1ijYK3GQ==
-      password:
-        secure: q6Zk/412o1ri+NEya1dl1Q==
-      folder: public_html/builds/nightly/$(VersionName)
-      on:
-          NightlyBuild: true        # deploy on nightly push only
-
-    - provider: FTP
-      protocol: sftp
-      host: porphyrion.feralhosting.com
-      username:
-        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
-      password:
-        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
-      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly/$(VersionName)
-      on:
-          NightlyBuild: true        # deploy on nightly push only
-
-    - provider: FTP
-      protocol: sftp
-      host: porphyrion.feralhosting.com
-      username:
-        secure: 36+bVD8eJgI0BVbi7TZ4zQ==
-      password:
-        secure: CrzmDVca8AGG08iWPA1gOD4Ge06+wJ3rcBagBGclwYQ=
-      folder: www/datacorder.porphyrion.feralhosting.com/public_html/builds/test/$(VersionName)
-      on:
-          TestBuild: true        # deploy on test build push only

ci/appveyor/build.ps1

@@ -1,164 +0,0 @@
-
-class BuildConfig {
-	[string]$Generator
-	[string]$PackageType
-	[string]$Toolset
-	[string]$SimdType
-	[string]$QtDir
-	[Bool]$SourcePackage
-}
-
-$NightlyConfigurations = @(
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015 Win64";
-#		PackageType="Win64";
-#		Toolset="v140";
-#		SimdType="SSE2";
-#		QtDir="C:\Qt\5.9\msvc2015_64";
-#		SourcePackage=$false;
-#	},
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015";
-#		PackageType="Win32";
-#		Toolset="v140";
-#		SimdType="SSE2";
-#		QtDir="C:\Qt\5.9\msvc2015";
-#		SourcePackage=$false;
-#	}
-)
-$ReleaseConfigurations = @(
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015";
-#		PackageType="Win32";
-#		Toolset="v140";
-#		SimdType="SSE2";
-#		QtDir="C:\Qt\5.9\msvc2015";
-#		SourcePackage=$true;
-#	}
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015";
-#		PackageType="Win32-AVX";
-#		Toolset="v140";
-#		SimdType="AVX";
-#		QtDir="C:\Qt\5.9\msvc2015";
-#		SourcePackage=$false;
-#	}
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015 Win64";
-#		PackageType="Win64";
-#		Toolset="v140";
-#		SimdType="SSE2";
-#		QtDir="C:\Qt\5.9\msvc2015_64";
-#		SourcePackage=$false;
-#	}
-#	[BuildConfig]@{
-#		Generator="Visual Studio 14 2015 Win64";
-#		PackageType="Win64-AVX";
-#		Toolset="v140";
-#		SimdType="AVX";
-#		QtDir="C:\Qt\5.9\msvc2015_64";
-#		SourcePackage=$false;
-#	}
-)
-
-$BuildConfigurations = $null
-
-# Default values
-$ReleaseBuild = $false
-$NightlyBuild = $false
-$TestBuild = $false
-
-# Set to true to test either the release or the nightly part of this script
-$ReleaseTest = $false
-$NightlyTest = $false
-$TestBuildTest = $false
-
-if ($ReleaseTest -Or ([System.Convert]::ToBoolean($env:APPVEYOR_REPO_TAG) -And ("$env:APPVEYOR_REPO_TAG_NAME" -match "^release_(.*)"))) {
-    # Tag matches
-    $ReleaseBuild = $true
-    $PackageName = "fs2_open_$($matches[1])"
-	$BuildConfigurations = $ReleaseConfigurations
-}
-
-if ($NightlyTest -Or ([System.Convert]::ToBoolean($env:APPVEYOR_REPO_TAG) -And ("$env:APPVEYOR_REPO_TAG_NAME" -match "^nightly_(.*)"))) {
-    # Tag matches
-    $NightlyBuild = $true
-    $PackageName = "nightly_$($matches[1])"
-	Set-AppveyorBuildVariable 'VersionName' "$($matches[1])"
-	$BuildConfigurations = $NightlyConfigurations
-}
-
-if ($TestBuildTest -Or ([System.Convert]::ToInt32($env:APPVEYOR_PULL_REQUEST_NUMBER) -le 0 -And ("$env:APPVEYOR_REPO_BRANCH" -match "^test\/(.*)"))) {
-    # Tag matches
-    $TestBuild = $true
-    $PackageName = "test_$($matches[1])"
-	Set-AppveyorBuildVariable 'VersionName' "$($matches[1])"
-	$BuildConfigurations = $NightlyConfigurations
-
-    # Override the revision string so that the builds are named correctly
-	[System.IO.File]::WriteAllLines("$env:APPVEYOR_BUILD_FOLDER/version_override.cmake", "set(FSO_VERSION_REVISION_STR $env:VersionName)")
-}
-
-# Multiply by 2 so that we can add 0 or 1 for debug or release Configs
-$buildID = [convert]::ToInt32($env:BuildID) * 2
-if ($Env:Configuration -eq "Release") {
-    $buildID = $buildID + 1
-}
-
-$DeployBuild = $false
-if ($ReleaseBuild -Or $NightlyBuild -Or $TestBuild) {
-    $DeployBuild = $true
-}
-
-Set-AppveyorBuildVariable 'ReleaseBuild' "$ReleaseBuild"
-Set-AppveyorBuildVariable 'NightlyBuild' "$NightlyBuild"
-Set-AppveyorBuildVariable 'TestBuild' "$TestBuild"
-
-New-Item build -type directory
-Set-Location -Path build
-
-if ($DeployBuild) {
-	# Release build
-	if ($buildID -ge $BuildConfigurations.Length) {
-		# Not needed
-        exit 0
-	}
-
-	$buildConfig = $BuildConfigurations[$buildID]
-
-	if ($buildConfig.SourcePackage -eq $True) {
-		7z a -xr'!.git' "$($PackageName)-source-Win.zip" "$env:APPVEYOR_BUILD_FOLDER"
-		Push-AppveyorArtifact "$($PackageName)-source-Win.zip"
-	}
-	
-	cmake -DCMAKE_INSTALL_PREFIX="$env:APPVEYOR_BUILD_FOLDER/../install" -DFSO_USE_SPEECH="ON" `
-		-DFSO_USE_VOICEREC="ON" -DMSVC_SIMD_INSTRUCTIONS="$($buildConfig.SimdType)" `
-		-DQT5_INSTALL_ROOT="$($buildConfig.QtDir)" -DFSO_BUILD_QTFRED=ON `
-		-DFSO_INSTALL_DEBUG_FILES="ON" `
-		-G "$($buildConfig.Generator)" -T "$($buildConfig.Toolset)" ..
-
-	$Configs = @("Release", "FastDebug")
-	foreach ($config in $Configs) {
-		cmake --build . --config "$config" --target INSTALL -- /verbosity:minimal
-		if (! ($?)) {
-			Add-AppveyorMessage "A release build failed!"
-			exit 1
-    	}
-	}
-
-    7z a -xr'!*.pdb' "$($PackageName)-builds-$($buildConfig.PackageType).zip" "$env:APPVEYOR_BUILD_FOLDER/../install/*"
-    Push-AppveyorArtifact "$($PackageName)-builds-$($buildConfig.PackageType).zip"
-
-	7z a "$($PackageName)-debug-$($buildConfig.PackageType).7z" "$env:APPVEYOR_BUILD_FOLDER/../install/*.pdb"
-	Push-AppveyorArtifact "$($PackageName)-debug-$($buildConfig.PackageType).7z"
-} else {
-	cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="ON" -DFSO_BUILD_TESTS="ON" -DMSVC_SIMD_INSTRUCTIONS=SSE2 `
-	-DFSO_BUILD_QTFRED=ON -DQT5_INSTALL_ROOT="$env:QT_DIR" -DFSO_BUILD_FRED2="ON" `
-	-G "$Env:CMAKE_GENERATOR" -T "$Env:PlatformToolset" ..
-
-    cmake --build . --config "$Env:CONFIGURATION" -- /verbosity:minimal
-
-    if (! ($?)) {
-        exit 1
-    }
-}

ci/appveyor/test.ps1

@@ -1,13 +0,0 @@
-
-if ([System.Convert]::ToBoolean($env:ReleaseBuild) -Or [System.Convert]::ToBoolean($env:NightlyBuild) -Or [System.Convert]::ToBoolean($env:TestBuild)) {
-    # Skip tests for deployment
-    exit 0
-} else {    
-    write "Running unit tests..."
-    # Run unit tests
-    &"$pwd\bin\$Env:CONFIGURATION\unittests.exe" --gtest_shuffle 2>&1
-
-    if (! ($?)) {
-        exit 1
-    }
-}

ci/bintray.template.json

@@ -1,19 +0,0 @@
-{
-    "package": {
-        "subject": "scp-fs2open",
-        "repo": "FSO",
-        "name": "nightly"
-    },
-
-    "version": {
-        "name": "$VERSION_NAME"
-    },
-
-    "files": [
-        {
-            "includePattern": "/tmp/builds/(.*)",
-            "uploadPattern": "$1"
-        }
-    ],
-    "publish": true
-}

ci/linux/clang-tidy-diff.py

@@ -1,268 +0,0 @@
-#!/usr/bin/env python3
-#
-#===- clang-tidy-diff.py - ClangTidy Diff Checker ------------*- python -*--===#
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#===------------------------------------------------------------------------===#
-
-r"""
-ClangTidy Diff Checker
-======================
-
-This script reads input from a unified diff, runs clang-tidy on all changed
-files and outputs clang-tidy warnings in changed lines only. This is useful to
-detect clang-tidy regressions in the lines touched by a specific patch.
-Example usage for git/svn users:
-
-  git diff -U0 HEAD^ | clang-tidy-diff.py -p1
-  svn diff --diff-cmd=diff -x-U0 | \
-      clang-tidy-diff.py -fix -checks=-*,modernize-use-override
-
-"""
-
-import argparse
-import glob
-import json
-import multiprocessing
-import os
-import re
-import shutil
-import subprocess
-import sys
-import tempfile
-import threading
-import traceback
-
-try:
-    import yaml
-except ImportError:
-    yaml = None
-
-is_py2 = sys.version[0] == '2'
-
-if is_py2:
-    import Queue as queue
-else:
-    import queue as queue
-
-
-def run_tidy(task_queue, lock, timeout):
-    watchdog = None
-    while True:
-        command = task_queue.get()
-        try:
-            proc = subprocess.Popen(command,
-                                    stdout=subprocess.PIPE,
-                                    stderr=subprocess.PIPE)
-
-            if timeout is not None:
-                watchdog = threading.Timer(timeout, proc.kill)
-                watchdog.start()
-
-            stdout, stderr = proc.communicate()
-
-            with lock:
-                sys.stdout.write(stdout.decode('utf-8'))
-                sys.stdout.flush()
-                if stderr:
-                    sys.stderr.write(stderr.decode('utf-8'))
-                    sys.stderr.flush()
-        except Exception as e:
-            with lock:
-                sys.stderr.write('Failed: ' + str(e) + ': '.join(command) + '\n')
-        finally:
-            with lock:
-                if (not timeout is None) and (not watchdog is None):
-                    if not watchdog.is_alive():
-                        sys.stderr.write('Terminated by timeout: ' +
-                                         ' '.join(command) + '\n')
-                    watchdog.cancel()
-            task_queue.task_done()
-
-
-def start_workers(max_tasks, tidy_caller, task_queue, lock, timeout):
-    for _ in range(max_tasks):
-        t = threading.Thread(target=tidy_caller, args=(task_queue, lock, timeout))
-        t.daemon = True
-        t.start()
-
-def merge_replacement_files(tmpdir, mergefile):
-    """Merge all replacement files in a directory into a single file"""
-    # The fixes suggested by clang-tidy >= 4.0.0 are given under
-    # the top level key 'Diagnostics' in the output yaml files
-    mergekey = "Diagnostics"
-    merged = []
-    for replacefile in glob.iglob(os.path.join(tmpdir, '*.yaml')):
-        content = yaml.safe_load(open(replacefile, 'r'))
-        if not content:
-            continue # Skip empty files.
-        merged.extend(content.get(mergekey, []))
-
-    if merged:
-        # MainSourceFile: The key is required by the definition inside
-        # include/clang/Tooling/ReplacementsYaml.h, but the value
-        # is actually never used inside clang-apply-replacements,
-        # so we set it to '' here.
-        output = { 'MainSourceFile': '', mergekey: merged }
-        with open(mergefile, 'w') as out:
-            yaml.safe_dump(output, out)
-    else:
-        # Empty the file:
-        open(mergefile, 'w').close()
-
-
-def main():
-    parser = argparse.ArgumentParser(description=
-                                     'Run clang-tidy against changed files, and '
-                                     'output diagnostics only for modified '
-                                     'lines.')
-    parser.add_argument('-clang-tidy-binary', metavar='PATH',
-                        default='clang-tidy',
-                        help='path to clang-tidy binary')
-    parser.add_argument('-p', metavar='NUM', default=0,
-                        help='strip the smallest prefix containing P slashes')
-    parser.add_argument('-regex', metavar='PATTERN', default=None,
-                        help='custom pattern selecting file paths to check '
-                             '(case sensitive, overrides -iregex)')
-    parser.add_argument('-iregex', metavar='PATTERN', default=
-    r'.*\.(cpp|cc|c\+\+|cxx|c|cl|h|hpp|m|mm|inc)',
-                        help='custom pattern selecting file paths to check '
-                             '(case insensitive, overridden by -regex)')
-    parser.add_argument('-j', type=int, default=1,
-                        help='number of tidy instances to be run in parallel.')
-    parser.add_argument('-timeout', type=int, default=None,
-                        help='timeout per each file in seconds.')
-    parser.add_argument('-fix', action='store_true', default=False,
-                        help='apply suggested fixes')
-    parser.add_argument('-checks',
-                        help='checks filter, when not specified, use clang-tidy '
-                             'default',
-                        default='')
-    parser.add_argument('-path', dest='build_path',
-                        help='Path used to read a compile command database.')
-    if yaml:
-        parser.add_argument('-export-fixes', metavar='FILE', dest='export_fixes',
-                            help='Create a yaml file to store suggested fixes in, '
-                                 'which can be applied with clang-apply-replacements.')
-    parser.add_argument('-extra-arg', dest='extra_arg',
-                        action='append', default=[],
-                        help='Additional argument to append to the compiler '
-                             'command line.')
-    parser.add_argument('-extra-arg-before', dest='extra_arg_before',
-                        action='append', default=[],
-                        help='Additional argument to prepend to the compiler '
-                             'command line.')
-    parser.add_argument('-quiet', action='store_true', default=False,
-                        help='Run clang-tidy in quiet mode')
-    clang_tidy_args = []
-    argv = sys.argv[1:]
-    if '--' in argv:
-        clang_tidy_args.extend(argv[argv.index('--'):])
-        argv = argv[:argv.index('--')]
-
-    args = parser.parse_args(argv)
-
-    # Extract changed lines for each file.
-    filename = None
-    lines_by_file = {}
-    for line in sys.stdin:
-        match = re.search('^\+\+\+\ \"?(.*?/){%s}([^ \t\n\"]*)' % args.p, line)
-        if match:
-            filename = match.group(2)
-        if filename is None:
-            continue
-
-        if args.regex is not None:
-            if not re.match('^%s$' % args.regex, filename):
-                continue
-        else:
-            if not re.match('^%s$' % args.iregex, filename, re.IGNORECASE):
-                continue
-
-        match = re.search('^@@.*\+(\d+)(,(\d+))?', line)
-        if match:
-            start_line = int(match.group(1))
-            line_count = 1
-            if match.group(3):
-                line_count = int(match.group(3))
-            if line_count == 0:
-                continue
-            end_line = start_line + line_count - 1
-            lines_by_file.setdefault(filename, []).append([start_line, end_line])
-
-    if not any(lines_by_file):
-        print("No relevant changes found.")
-        sys.exit(0)
-
-    max_task_count = args.j
-    if max_task_count == 0:
-        max_task_count = multiprocessing.cpu_count()
-    max_task_count = min(len(lines_by_file), max_task_count)
-
-    tmpdir = None
-    if yaml and args.export_fixes:
-        tmpdir = tempfile.mkdtemp()
-
-    # Tasks for clang-tidy.
-    task_queue = queue.Queue(max_task_count)
-    # A lock for console output.
-    lock = threading.Lock()
-
-    # Run a pool of clang-tidy workers.
-    start_workers(max_task_count, run_tidy, task_queue, lock, args.timeout)
-
-    # Form the common args list.
-    common_clang_tidy_args = []
-    if args.fix:
-        common_clang_tidy_args.append('-fix')
-    if args.checks != '':
-        common_clang_tidy_args.append('-checks=' + args.checks)
-    if args.quiet:
-        common_clang_tidy_args.append('-quiet')
-    if args.build_path is not None:
-        common_clang_tidy_args.append('-p=%s' % args.build_path)
-    for arg in args.extra_arg:
-        common_clang_tidy_args.append('-extra-arg=%s' % arg)
-    for arg in args.extra_arg_before:
-        common_clang_tidy_args.append('-extra-arg-before=%s' % arg)
-
-    for name in lines_by_file:
-        line_filter_json = json.dumps(
-            [{"name": name, "lines": lines_by_file[name]}],
-            separators=(',', ':'))
-
-        # Run clang-tidy on files containing changes.
-        command = [args.clang_tidy_binary]
-        command.append('-line-filter=' + line_filter_json)
-        if yaml and args.export_fixes:
-            # Get a temporary file. We immediately close the handle so clang-tidy can
-            # overwrite it.
-            (handle, tmp_name) = tempfile.mkstemp(suffix='.yaml', dir=tmpdir)
-            os.close(handle)
-            command.append('-export-fixes=' + tmp_name)
-        command.extend(common_clang_tidy_args)
-        command.append(name)
-        command.extend(clang_tidy_args)
-
-        task_queue.put(command)
-
-    # Wait for all threads to be done.
-    task_queue.join()
-
-    if yaml and args.export_fixes:
-        print('Writing fixes to ' + args.export_fixes + ' ...')
-        try:
-            merge_replacement_files(tmpdir, args.export_fixes)
-        except:
-            sys.stderr.write('Error exporting fixes.\n')
-            traceback.print_exc()
-
-    if tmpdir:
-        shutil.rmtree(tmpdir)
-
-
-if __name__ == '__main__':
-    main()

ci/linux/clang_tidy.sh

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-COMMIT_RANGE=$1..$2
-
-if ! git rev-list $COMMIT_RANGE 2>&1 >/dev/null; then
-    echo "\$COMMIT_RANGE ($COMMIT_RANGE) is not valid for this build (probably caused by a rebase)."
-    exit 0
-fi
-
-# In order to get a proper diff without irrelevant changes, we need to determine where we branched off from the base
-# branch
-BASE_COMMIT=$(git merge-base $1 $2)
-
-echo "Running clang-tidy on changed files"
-git diff -U0 --no-color "$BASE_COMMIT..$2" | \
-    $HERE/clang-tidy-diff.py -path "$(pwd)/build" -p1 \
-    -regex '(code(?!((\/graphics\/shaders\/compiled)|(\/globalincs\/windebug)))|freespace2|qtfred|test|build|tools)\/.*\.(cpp|h)' \
-    -clang-tidy-binary /usr/bin/clang-tidy-9 -j$(nproc) -export-fixes "$(pwd)/clang-fixes.yaml"

ci/linux/configure_cmake.sh

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-if [ "$COMPILER" = "gcc-5" ]; then
-    export CC=gcc-5
-    export CXX=g++-5
-fi
-if [ "$COMPILER" = "gcc-10" ]; then
-    export CC=gcc-10
-    export CXX=g++-10
-fi
-if [ "$COMPILER" = "clang-9" ]; then
-    # Work around bug in clang that uses the wrong installation directory: https://bugs.llvm.org/show_bug.cgi?id=47460
-    export CC=$(readlink -f $(which clang-9))
-    export CXX=$(readlink -f $(which clang++-9))
-fi
-
-LD_LIBRARY_PATH=$Qt5_DIR/lib:$LD_LIBRARY_PATH
-if [ "$RUNNER_OS" = "macOS" ]; then
-    CXXFLAGS="-mtune=generic -pipe -Wno-unknown-pragmas"
-    CFLAGS="-mtune=generic -pipe -Wno-unknown-pragmas"
-    PLATFORM_CMAKE_OPTIONS=""
-    export CMAKE_OSX_ARCHITECTURES="$ARCHITECTURE"
-else
-    CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-    CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-    PLATFORM_CMAKE_OPTIONS="-DFSO_BUILD_APPIMAGE=ON"
-fi
-
-CMAKE_OPTIONS="$JOB_CMAKE_OPTIONS"
-if [[ "$COMPILER" =~ ^clang.*$ ]]; then
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCLANG_USE_LIBCXX=ON"
-fi
-
-mkdir build
-cd build
-
-export CXXFLAGS
-export CFLAGS
-export LD_LIBRARY_PATH
-
-if [ "$RUNNER_OS" = "macOS" ]; then
-    brew install ninja
-fi
-cmake -G Ninja -DFSO_FATAL_WARNINGS=ON -DCMAKE_EXPORT_COMPILE_COMMANDS=ON $CMAKE_OPTIONS $PLATFORM_CMAKE_OPTIONS \
-    -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DCMAKE_BUILD_TYPE=$CONFIGURATION \
-    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON \
-    -DSHADERS_ENABLE_COMPILATION=ON ..

ci/linux/create_dist_pack.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-OS="$1"
-
-source $HERE/dist_functions.sh
-
-if [ "$OS" = "Linux" ]; then
-    tar -cvzf "$(get_package_name)-builds-Linux.tar.gz" *
-
-    echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-Linux.tar.gz"
-    echo "::set-output name=package_name::$(get_package_name)-builds-Linux.tar.gz"
-    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Linux.tar.gz")"
-elif [ "$OS" = "Windows" ]; then
-    7z a -xr'!*.pdb' "$(get_package_name)-builds-$ARCH-$SIMD.zip" "*"
-
-    echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip"
-    echo "::set-output name=package_name::$(get_package_name)-builds-$ARCH-$SIMD.zip"
-    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip")"
-
-    7z a "$(get_package_name)-debug-$ARCH-$SIMD.7z" "*.pdb"
-
-    echo "::set-output name=debug_path::$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z"
-    echo "::set-output name=debug_name::$(get_package_name)-debug-$ARCH-$SIMD.7z"
-    echo "::set-output name=debug_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z")"
-elif [ "$OS" = "Mac" ]; then
-    tar -cvzf "$(get_package_name)-builds-Mac.tar.gz" *
-
-    echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-Mac.tar.gz"
-    echo "::set-output name=package_name::$(get_package_name)-builds-Mac.tar.gz"
-    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Mac.tar.gz")"
-else
-    echo "Invalid OS: $OS"
-fi

ci/linux/dist_functions.sh

@@ -1,70 +0,0 @@
-function get_package_name() {
-  if git describe --match 'nightly_*' --exact-match 2>/dev/null >/dev/null; then
-    echo -n "$(git describe --match "nightly_*" --exact-match)"
-    return
-  fi
-
-  if git describe --match 'release_*' --exact-match 2>/dev/null >/dev/null; then
-    echo -n "$(git describe --match "release_*" --exact-match | sed 's/release_/fs2_open_/i')"
-    return
-  fi
-
-  if [[ "$(git branch --show-current)" =~ ^test\/(.*)$ ]]; then
-    echo -n "test_${BASH_REMATCH[1]}"
-    return
-  fi
-
-  echo "unknown_config"
-}
-
-function get_version_name() {
-  if git describe --match 'nightly_*' --exact-match 2>/dev/null >/dev/null; then
-    local tag_name=$(git describe --match "nightly_*" --exact-match)
-
-    # Use the bash regex matching for getting the relevant part of the tag name
-    [[ $tag_name =~ ^nightly_(.*)$ ]]
-
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  if git describe --match 'release_*' --exact-match 2>/dev/null >/dev/null; then
-    local tag_name=$(git describe --match "release_*" --exact-match)
-
-    # Use the bash regex matching for getting the relevant part of the tag name
-    [[ $tag_name =~ ^release_(.*)$ ]]
-
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  if [[ "$(git branch --show-current)" =~ ^test\/(.*)$ ]]; then
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  echo "unknown_config"
-}
-
-function upload_files_to_sftp() {
-  # We need empty glob patterns to "disappear" in the for loop below since this will be run for different configurations
-  # where it may be possible that some of the file patterns will not be present
-  shopt -s nullglob
-
-  echo "cd $2/" > sftp_batch
-  echo "mkdir $(get_version_name)" >> sftp_batch
-  # Create directory but do not cause an error if it already exists
-  sshpass -e sftp -oBatchMode=no -o "StrictHostKeyChecking no" -b sftp_batch $1 || true
-
-  echo "cd $2/$(get_version_name)/" > sftp_batch
-  for file in *.tar.gz *.7z *.zip; do
-    echo "put $file" >> sftp_batch
-  done
-
-  echo "bye" >> sftp_batch
-
-  sshpass -e sftp -oBatchMode=no -o "StrictHostKeyChecking no" -b sftp_batch $1
-
-  rm sftp_batch
-}
-

ci/linux/generate_appimage.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-INSTALL_FOLDER=$1
-
-# Install Freespace2 targets
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER -DCOMPONENT=Unspecified -P cmake_install.cmake
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER -DCOMPONENT=Freespace2 -P cmake_install.cmake
-
-# We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-FILENAME="$(find $INSTALL_FOLDER/bin -name 'fs2_open_*' -type f -printf "%f\n").AppImage"
-appimagetool -n $INSTALL_FOLDER "$INSTALL_FOLDER/$FILENAME"
-chmod +x "$INSTALL_FOLDER/$FILENAME"
-
-ls -al $INSTALL_FOLDER

ci/linux/run_tests.sh

@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-export LD_LIBRARY_PATH=$(pwd)/bin/lib:$LD_LIBRARY_PATH
-
-if [ "$CONFIGURATION" = "Debug"] && [[ "$RUNNER_OS" != "macOS" ]] ; then
-    valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
-        --suppressions="$HERE/valgrind.supp" ./bin/unittests --gtest_shuffle
-else
-    ./bin/unittests --gtest_shuffle
-fi

ci/linux/upload_dist_package.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-UPLOAD_TYPE=$1
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-source $HERE/dist_functions.sh
-
-if [ "$UPLOAD_TYPE" = "nightly" ]; then
-    SSHPASS=$INDIEGAMES_SSHPASS upload_files_to_sftp "$INDIEGAMES_USER@scp.indiegames.us" "public_html/builds/nightly"
-
-    SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@porphyrion.feralhosting.com" "www/datacorder.porphyrion.feralhosting.com/public_html/builds/nightly"
-elif [ "$UPLOAD_TYPE" = "test" ]; then
-    SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@porphyrion.feralhosting.com" "www/datacorder.porphyrion.feralhosting.com/public_html/builds/test"
-else
-    echo "Unknown upload type $UPLOAD_TYPE"
-    exit 1
-fi

ci/linux/valgrind.supp

@@ -1,163 +0,0 @@
-{
-   liblsan Invalid read
-   Memcheck:Addr8
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:*
-   obj:*
-   obj:*
-}
-{
-    Travis memleak
-    Memcheck:Leak
-    match-leak-kinds: definite
-    fun:malloc
-    fun:_dl_signal_error
-    fun:_dl_open
-    fun:dlopen_doit
-    fun:_dl_catch_error
-    fun:_dlerror_run
-    fun:dlopen@@GLIBC_2.2.5
-    obj:/usr/lib/x86_64-linux-gnu/libmirclient.so.7
-    fun:call_init.part.0
-    fun:call_init
-    fun:_dl_init
-    fun:dl_open_worker
-    fun:_dl_catch_error
-}
-{
-   CLang Lua unitialized value error
-   Memcheck:Cond
-   ...
-   fun:luaH_get
-   fun:lua_rawget
-   fun:_ZN12_GLOBAL__N_117ade_index_handlerEP9lua_State
-}
-{
-   False-positive uninitialized variable warning
-   Memcheck:Cond
-   fun:_Z23cf_check_location_flagsjj
-   fun:_Z29cf_create_default_path_stringPcjiPKcbj
-   ...
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initOSt10unique_ptrIN2os18GraphicsOperationsESt14default_deleteIS1_EEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing4Test3RunEv
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initOSt10unique_ptrIN2os18GraphicsOperationsESt14default_deleteIS1_EEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_dl_signal_error
-   fun:_dl_open
-   fun:dlopen_doit
-   fun:_dl_catch_error
-   fun:_dlerror_run
-   fun:dlopen@@GLIBC_2.2.5
-   obj:*
-   obj:*
-   fun:call_init.part.0
-   fun:call_init
-   fun:_dl_init
-   fun:dl_open_worker
-}
-{
-   dlopen leak
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_dl_exception_create
-   fun:_dl_signal_error
-   fun:_dl_map_object
-   fun:dl_open_worker
-   fun:_dl_catch_exception
-   fun:_dl_open
-   fun:dlopen_doit
-   fun:_dl_catch_exception
-   fun:_dl_catch_error
-   fun:_dlerror_run
-   fun:dlopen@@GLIBC_2.2.5
-}

ci/post/changelog.py

@@ -1,169 +0,0 @@
-# Retrives a log of commit messages and attempts to pretty them into a human-readbile format
-
-import argparse
-import os
-import re
-import requests
-import sys
-
-from datetime import datetime
-from subprocess import check_output
-
-MAX_PAGES = 100  # maximum number of PR pages to go through
-warnings = 0
-
-def get_last_page(response: requests.Response) -> int:
-    """
-    @brief Extract the last page number from the response header
-
-    @param[in] response The response from a GET call
-
-    @returns The page number of the last page, or MAX_PAGES
-    """
-
-    # The link header is a dictionary in string form, and for that matter the
-    # value is in front of the key.  It is of the form '<<url1>>; rel=<key1>, <url2>, <key2>'
-    link = response.headers['link']
-    link = link.split(',')
-    for x in link:
-        y = x.split(';')        # <url>; rel=<key>
-        if "last" not in y[1]:  # look for rel='last'
-            continue
-        # grab the page number from the URL
-        # group(0) is `page=123`, group(1) is `123`
-        last_page = int( re.search(r'page=(\d+)', y[0]).group(1) )
-        if not last_page:
-            print("Error: Could not find page number in url!  URL: %s", y[0])
-            sys.exit(1)
-
-        if last_page > MAX_PAGES:
-            return MAX_PAGES
-        else:
-            return last_page
-    
-
-def main():
-    parser = argparse.ArgumentParser(description="Retrieves a log of commit messages and attempts to pretty them into a human-readable format")
-    parser.add_argument("start_date",
-                        help="Day of the earliest commit to add to the log.")
-    parser.add_argument("-u", "--user", nargs=2, metavar=("NAME", "TOKEN"), default=["", ""],
-                        help="Github username and token/password")
-
-    args = parser.parse_args()
-
-    os.chdir(os.path.dirname(__file__))	# Change working directory to this file's directory
-    start_date = datetime.strptime(args.start_date, "%Y-%m-%d")
-
-    print("start_date: {}".format(start_date))
-
-    # Retrive the git log for master, since start date, order by date, in ascending order, use YYYY-MM-DD date format,
-    #   each line is of the form "<author short date> | <message>", only grab commits from master,
-    #   output to `fsofordigest.txt`,
-    
-    # check_output(("git log master", "--after=2021-09-15", "--date-order", "--reverse", "--date=short",
-    # "--pretty=\"%as | %s\"",  "--first-parent",
-    # "--output fsofordigest.txt"), text=True)
-
-    # The commit messages are either of the form "<body> (#<PR_number>)" or "Merge pull request #<PR_number> from <source_repo>"
-    # For our purposes, we want them be all of the form "<body> (#<PR_number>)"
-    # Typically, the second form does not have a usable body, so we'll have to pull the PR title from github
-
-    # Github's REST API allows us to retrieve PR's, but due to it being HTTP requests it has to page in the data.
-    # We can loop over the GET request and check for a merge date.
-    # The GET request doesn't have sorting by merge date, but does have sorting by the last time it was updated... which is usually
-    # also the merge date but not always.
-
-    # Key attributes within the PR JSON objects:
-    #   "merged_at: <date>"     # Date the PR was merged in
-    #   "merged: <bool>"        # If the PR was merged yet
-    #   "html_url: <string>"    # URL of the PR's HEAD commit, used by some clients to pull in the PR branch
-    #   "number: <int>"         # The PR id number
-    #   "title: <string>"       # Title of the PR
-    #   "body: <string>"        # The body paragraph detailing the PR
-    #   "labels: [label_object]"    # All labels attached to this PR
-
-    changelog = {}
-    url = "https://api.github.com/repos/scp-fs2open/fs2open.github.com/pulls"
-    page = 1
-    last_page = MAX_PAGES
-    while page <= last_page:
-        # GET <url>?base=master&sort=updated&direction=desc&state=closed&page=1
-        response = requests.get(url,
-        auth=(args.user[0], args.user[1]),
-        params={
-            "base": "master",
-            "direction": "desc",
-            "page": page,
-            "state": "closed",
-            "sort": "updated"
-        })
-
-        # Check if good response
-        if (response.status_code != 200) :
-            print("Error: ", response.status_code)
-            print(response.json()['message'])
-            sys.exit(1)
-        else:
-            print("Request successful: 200")
-            print("page={}".format(page))
-
-        # Update the last_page index at first iteration and possibly last iteration
-        # This should cover the edge case of a new PR being added to the database before this script is finished
-        if (page == 1) or (page == last_page):
-            last_page = get_last_page(response)
-            print("last_page={}".format(last_page))
-
-        # assume pulls are organized from newest to oldest
-        for pull in response.json():
-            if (pull['state'] != 'closed'):
-                # This pull is not merged, so ignore
-                print("Found irrelevant pull, skipping...")
-                print("state: {}; number: {}".format(pull['state'], pull['number']))
-                continue
-            
-            if (pull['merged_at'] == None):
-                # This pull wasn't merged, skip
-                print("Found closed pull #{} ({}), skipping...".format(pull['number'], pull['closed_at']))
-                continue
-
-            merge_date = datetime.strptime(pull['merged_at'], "%Y-%m-%dT%H:%M:%SZ")
-            updated_date = datetime.strptime(pull['updated_at'], "%Y-%m-%dT%H:%M:%SZ")
-            if (merge_date < start_date) and (updated_date >= start_date):
-                # This pull is too old, but was updated within our timeframe. skip
-                print("Found old pull #{} ({}), skipping...".format(pull['number'], pull['merged_at']))
-                continue
-
-            if (updated_date < start_date):
-                # This pull is too old
-                print("Found old pull #{} ({}), stopping loop...".format(pull['number'], pull['updated_at']))
-                page = last_page + 1
-                break
-
-            # Add the pull to the changelog, indexed by its pull.number
-            if pull['number'] not in changelog:
-                # only add if the key isn't there already
-                changelog[pull['number']] = {
-                    "date":     merge_date,
-                    "title":    pull['title'],
-                    "labels":   pull['labels'],
-                    "url":      pull['html_url']
-                }
-                print("Added pull #{} ({})".format(pull['number'], merge_date))
-            # Else, silently ignore duplicate (for now...)
-
-        page += 1 # iterate to next page
-
-
-    # Write the changelog to file
-    # 2021-09-28 | (#3661) Fix homing child weapons in niche circumstances 
-    print("Writing to change.log...")
-    str = ''
-    for key, value in changelog.items():
-        str += "{} | (#{}) {} \n".format(value['date'].strftime("%Y-%m-%d"), key, value['title'])
-    
-    with open("change.log", "w") as file:
-        file.write(str)
-
-    print("Done!")
-
-main()

ci/post/file_list.py

@@ -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

ci/post/forum.py

@@ -1,103 +0,0 @@
-from typing import List
-
-import requests
-import semantic_version
-from mako.template import Template
-
-from file_list import ReleaseFile
-
-
-class ForumAPI:
-    POST_SIZE_MAX = 50000
-    """!
-    Maximum number of characters allowed in a post, including BBCode (03/17/2022)
-
-    Check with HLP admins occasionally to verify this limit, they can set it in the forum's admin panel
-    """
-
-    def __init__(self, config):
-        self.config = config
-
-    def create_post(self, title, content, board):
-        """!
-        @brief Create a post on the forums
-
-        @param[in] title    Title of the post
-        @param[in] content  Body of the post
-        @param[in] board    Which board/forum to post to
-
-        @returns { "thread_url": <url_of_created_thread> }
-        """
-
-        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)
-        
-        return resp.json()
-
-    def post_nightly(self, date, revision, files, log, success):
-        """!
-        @brief Post a new Nightly topic on the forums using nightly.mako
-
-        @param[in] date         The date to use
-        @param[in] version      The build's version
-        @param[in] groups       dict[Any, file_list.FileGroup]; FileGroups of SSE2, AVX, etc.
-        @param[in] sources      URL's of builds on github or fs2net
-        """
-
-        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):
-        """!
-        @brief Post a new Release topic on the forums using release.mako.
-
-        @param[in] date         The date to use
-        @param[in] version      The build's version
-        @param[in] groups       dict[Any, file_list.FileGroup]; FileGroups of SSE2, AVX, etc.
-        @param[in] sources      URL's of builds on github or fs2net
-
-        @returns If Successful, the URL of the created post
-        """
-
-        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...")
-
-        json = self.create_post(title, rendered, self.config["release"]["hlp_board"])
-        return json["thread_url"]

ci/post/github.py

@@ -1,85 +0,0 @@
-# Class for use with interfacing with github via HTTP requests
-
-import requests
-
-from util import retry_multi, GLOBAL_TIMEOUT
-
-class GithubAPI:
-    headers = {
-        "Accept": "application/vnd.github.v3+json"
-    }
-    url_root = "https://api.github.com"
-
-    def __init__(self, config):
-        self.config = config
-
-    @retry_multi(5)
-    def get(self, 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
-        """
-        url = self.url_root + path
-
-        # GET https://api.github.com/<path> Accept: "application/vnd.github.v3+json"
-
-        response = requests.get(url, headers=self.headers, timeout=GLOBAL_TIMEOUT)
-
-        response.raise_for_status() # Raise a RequestException if we failed, and trigger retry
-
-        return response.json()
-    
-    def get_release(self, tag_name):
-        """!
-        @brief Retrieves the Github Release metadata as a JSON object
-        @see https://docs.github.com/en/rest/reference/releases#get-a-release-by-tag-name
-        """
-        return self.get("/repos/{}/releases/tags/{}".format(self.config["github"]["repo"], tag_name))
-
-
-    def patch(self, path, data):
-        """!
-        @brief Performs a PATCH request with the given path and body data (as dictionary)
-        @returns If successful, returns a .JSON object
-        """
-        url = self.url_root + path
-
-        response = requests.patch(url, headers=self.headers, timeout=GLOBAL_TIMEOUT, data=data)
-
-        response.raise_for_status()
-
-        return response.json()
-        
-    def update_release(self, release_id, tag_name="", name="", body="", draft=None, prerelease=None):
-        """!
-        @brief Updates a Github Release
-        @param[in] release_id   The id of the release, as obtained by get_release()
-        @param[in] tag_name     (optional) The git tag this release is associated with
-        @param[in] name         (optional) The name of the release
-        @param[in] body         (optional) Body text describing the release
-        @param[in] draft        (optional) If true, the release is marked as a "draft"
-        @param[in] prerelease   (optional) If true, the release is marked as a "prerelease"
-
-        @note If an optional argument is not provided, then its associated data is not changed
-        """
-        path = "/repos/{}/releases/{}".format(self.config["github"]["repo"], release_id)
-
-        # Add to the data JSON if options are specified
-        data = {}
-        if tag_name != "":
-            data["tag_name"] = tag_name
-        
-        if name != "":
-            data["name"] = name
-
-        if body != "":
-            data["body"] = body
-        
-        if draft != None:
-            data["draft"] = data
-
-        if prerelease != None:
-            data["prerelease"] = prerelease
-        
-        self.patch(path, data)
-

ci/post/installer.py

@@ -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")

ci/post/main.py

@@ -1,305 +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|set)\(FSO_VERSION_MAJOR (\d+)\)")
-MINOR_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_MINOR (\d+)\)")
-BUILD_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_BUILD (\d+)\)")
-REVISION_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_REVISION (\d+)\)")
-REVISION_STR_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_REVISION_STR (\w+)\)")
-
-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 _match_version_str(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 match.group(1)
-	
-
-def get_source_version(date_version: datetime, tag_name: str) -> semantic_version.Version:
-	"""! Retrieves the version string from version_override.cmake (and version.cmake)
-
-	@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: `FSO_VERSION_MAJOR.FSO_VERSION_MINOR.FSO_VERSION_BUILD`
-	@return If rc:      `FSO_VERSION_MAJOR.FSO_VERSION_MINOR.FSO_VERSION_BUILD-FSO_VERSION_REVISION_STR`
-	@return If nightly: `FSO_VERSION_MAJOR.FSO_VERSION_MINOR.FSO_VERSION_BUILD-FSO_VERSION_REVISION_STR` (uses both version_override.cmake and version.cmake)
-
-	@note This is the version used to identify in Nebula and the forums.  version_override.cmake is used for the builds
-	  made by CI tools and version.cmake is used for builds made by devs.
-	"""
-
-	with open(os.path.join("..", "..", "version_override.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)
-		# revision = _match_version_number(filetext, REVISION_VERSION_PATTERN)
-		revision_str = _match_version_str(filetext, REVISION_STR_VERSION_PATTERN)
-
-	print("Parsing version_override.cmake...")
-	if "rc" in tag_name.lower():
-		version = semantic_version.Version("{}.{}.{}-{}".format(major, minor, build, revision_str))
-
-	elif "release" in tag_name.lower():
-		version = semantic_version.Version("{}.{}.{}".format(major, minor, build))
-
-	elif "nightly" in tag_name.lower():
-		# Nightly's version_override.cmake only has FSO_VERSION_REVISION and FSO_VERSION_REVISION_STR set
-		# So, we have to pull the rest of the version string from version.cmake
-		print("Parsing version.cmake...")
-		with open(os.path.join("..", "..", "cmake", "version.cmake"), "r") as f:
-			major = _match_version_number(filetext, MAJOR_VERSION_PATTERN)
-			minor = _match_version_number(filetext, MINOR_VERSION_PATTERN)
-			build = _match_version_number(filetext, BUILD_VERSION_PATTERN)
-		version = semantic_version.Version("{}.{}.{}-{}".format(major, minor, build, revision_str))
-	
-	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)
-
-	linux_success = os.environ["LINUX_RESULT"] == "success"
-	windows_success = os.environ["WINDOWS_RESULT"] == "success"
-	if (sys.argv[1] == "release"):
-		if not (linux_success and windows_success):
-			# bail if this is a release and either build workflow failed
-			print("ERROR: One or more builds failed to publish! Cannot post release.")
-			sys.exit(1)
-	else:
-		if not (linux_success or windows_success):
-			# bail if this is a nightly build and both build workflows failed
-			print("ERROR: All builds failed to publish! Cannot post nightly.")
-			sys.exit(1)
-	
-	# bail if tag_name doesn't match with sys.argv[1]
-	tag_name = os.environ["RELEASE_TAG"]	##!< commit tag string
-	if (sys.argv[1] == "release") and (not tag_name.startswith("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)
-
-	if (sys.argv[1] == "nightly") and (not tag_name.startswith("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)
-
-	# bail if tag_name does not exist in the repo
-	if not check_output(("git", "show-ref", "--tags", "refs/tags/%s" % tag_name), text=True):
-		print("ERROR: Couldn't find tag %s in repo (git show-ref)!" % tag_name)
-		sys.exit(1)
-
-	# Populate version and date
-	date = datetime.now()	##!< current date
-	version = get_source_version(date.strftime(DATEFORMAT_VERSION), tag_name)	##!< form full version string
-	
-	# find the previous tag release (used by nightly)
-	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! (git for-each-ref)" % tag_name)
-		sys.exit(1)
-
-	if (sys.argv[1] == "nightly") and (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
-		print("Retrieving file list...")
-		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
-		print("Publishing 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
-		print("Publishing to Hard-light.net...")
-		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
-		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)
-
-		print("Publishing 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
-		print("Publishing to Hard-light.net...")
-		fapi = forum.ForumAPI(config)
-		fapi.post_nightly(date.strftime(DATEFORMAT_FORUM), os.environ["GITHUB_SHA"], files, log, (linux_success and windows_success))
-
-	print("Done!")
-
-
-if __name__ == "__main__":
-	main()

ci/post/nebula.py

@@ -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

ci/post/nightly.mako

@@ -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]

ci/post/release.mako

@@ -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]

ci/post/requirements.txt

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

ci/post/util.py

@@ -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"])

ci/travis/before_deploy.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env sh
-
-set -ex
-
-if [ "$NIGHTLY_BUILD" = true ]; then
-    echo "Generating bintray config..."
-    sed -e "s/\$VERSION_NAME/$VERSION_NAME/" ci/bintray.template.json > ci/bintray.json
-fi

ci/travis/before_install.sh

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

ci/travis/before_script.sh

@@ -1,50 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    mkdir -p /tmp/builds
-    if [ "$RELEASE_BUILD" = true ]; then
-        # Package the source code in release builds
-        PARENT_DIR="$(basename "$PWD")"
-        (cd .. && tar -czvf /tmp/builds/$PACKAGE_NAME-source-Unix.tar.gz --exclude-vcs "$PARENT_DIR")
-    fi
-fi
-
-mkdir -p build
-cd build
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-    CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-
-    export CXXFLAGS
-    export CFLAGS
-    CMAKE="cmake -G Ninja -DFSO_FATAL_WARNINGS=ON $CMAKE_OPTIONS"
-    if [ "$BUILD_DEPLOYMENT" = true ]; then
-        for config in $BUILD_CONFIGS
-        do
-            mkdir -p $config
-            cd $config
-            eval $CMAKE -DFSO_INSTALL_DEBUG_FILES=ON -DCMAKE_BUILD_TYPE=$config -DCMAKE_INSTALL_PREFIX="/tmp/release/$config" \
-                -DFSO_BUILD_APPIMAGE=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_QTFRED=OFF ../..
-            cd ..
-        done
-    else
-        eval $CMAKE -DCMAKE_BUILD_TYPE=$CONFIGURATION -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON ..
-    fi
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    if [ "$BUILD_DEPLOYMENT" = true ]; then
-        cmake -G "Xcode" -DFSO_FATAL_WARNINGS=ON -DFSO_INSTALL_DEBUG_FILES=ON -DCMAKE_INSTALL_PREFIX="/tmp/release" ..
-    else
-        cmake -G "Xcode" $CMAKE_OPTIONS ..
-    fi
-elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
-    if [ "$CMAKE_GENERATOR" = "Ninja" ]; then
-        cmake -DFSO_USE_SPEECH="OFF" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-            -DFSO_BUILD_FRED2="OFF" -G "$CMAKE_GENERATOR" ..
-    else
-        cmake -DFSO_USE_SPEECH="ON" -DFSO_FATAL_WARNINGS="ON" -DFSO_USE_VOICEREC="OFF" -DFSO_BUILD_TESTS="ON" \
-            -DMSVC_SIMD_INSTRUCTIONS=SSE2 -DFSO_BUILD_FRED2="ON" -G "$CMAKE_GENERATOR" -T "$CMAKE_TOOLSET" ..
-    fi
-fi

ci/travis/check_release.sh

@@ -1,74 +0,0 @@
-#!/usr/bin/env sh
-
-RELEASE_BUILD=false
-NIGHTLY_BUILD=false
-TEST_BUILD=false
-
-BUILD_DEPLOYMENT=false
-BUILD_CONFIGS="Release FastDebug"
-VERSION_NAME=""
-PACKAGE_NAME=""
-
-RELEASE_PATTERN="^release_(.*)$"
-NIGHTLY_PATTERN="^nightly_(.*)$"
-TEST_BUILD_PATTERN="^test\/(.*)$"
-
-# These are for testing
-NIGHTLY_TEST=false
-RELEASE_TEST=false
-TEST_BUILD_TEST=false
-
-if [ "$RELEASE_TEST" = true ] || [[ "$TRAVIS_TAG" =~ $RELEASE_PATTERN ]]; then
-    echo "This is a release tag!";
-    RELEASE_BUILD=true;
-	PACKAGE_NAME="fs2_open_${BASH_REMATCH[1]}";
-fi
-if [ "$NIGHTLY_TEST" = true ] || [[ "$TRAVIS_TAG" =~ $NIGHTLY_PATTERN ]]; then
-    echo "This is a nightly tag!";
-    NIGHTLY_BUILD=true;
-    VERSION_NAME="${BASH_REMATCH[1]}";
-	PACKAGE_NAME="nightly_${BASH_REMATCH[1]}";
-fi
-if [ "$TEST_BUILD_TEST" = true ] || [[ "$TRAVIS_PULL_REQUEST" == "false" && "$TRAVIS_BRANCH" =~ $TEST_BUILD_PATTERN ]]; then
-    echo "This is a test build branch!";
-    TEST_BUILD=true;
-    if [ "$TEST_BUILD_TEST" = true ]; then
-        VERSION_NAME="test";
-        PACKAGE_NAME="test_test";
-    else
-        VERSION_NAME="${BASH_REMATCH[1]}";
-        PACKAGE_NAME="test_${BASH_REMATCH[1]}";
-    fi
-
-    # Override the revision string so that the builds are named correctly
-    echo "set(FSO_VERSION_REVISION_STR $VERSION_NAME)" > "$TRAVIS_BUILD_DIR/version_override.cmake"
-fi
-
-if ([ "$RELEASE_BUILD" = true ] || [ "$NIGHTLY_BUILD" = true ] || [ "$TEST_BUILD" = true ]); then
-    BUILD_DEPLOYMENT=true;
-fi
-
-if [ "$BUILD_DEPLOYMENT" = true ]; then
-    if ([ "$TRAVIS_OS_NAME" = "linux" ] && (! [[ "$CC" =~ ^gcc-5.*$ ]])); then
-        echo "Skipping non-release compiler";
-        exit 0;
-    fi
-
-    if ([[ "$CONFIGURATION" == "Debug" ]]); then
-        echo "Skipping non-release configuration";
-        exit 0;
-    fi
-
-    if [ "$TRAVIS_OS_NAME" = "windows" ]; then
-        echo "Skipping non-release platform"
-        exit 0
-    fi
-fi
-
-export RELEASE_BUILD
-export NIGHTLY_BUILD
-export TEST_BUILD
-export BUILD_DEPLOYMENT
-export BUILD_CONFIGS
-export VERSION_NAME
-export PACKAGE_NAME

ci/travis/ftp_deploy.sh

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

ci/travis/install.sh

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-FILENAME=
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    export DEBIAN_FRONTEND=noninteractive
-
-    if [ ! -d "$HOME/cmake-3.8/bin" ]; then
-        # If the cache does not currently contain CMake then download and install it
-    	mkdir -p $HOME/cmake-3.8/
-
-    	wget -O /tmp/cmake.tar.gz --no-check-certificate https://cmake.org/files/v3.8/cmake-3.8.2-Linux-x86_64.tar.gz
-    	tar -xzf /tmp/cmake.tar.gz -C $HOME/cmake-3.8/ --strip-components=1
-    fi
-    export PATH=$HOME/cmake-3.8/bin:$PATH
-    
-    cd $HOME
-    
-    if [ "${BUILD_DEPLOYMENT}" = true ]; then
-        wget -O appimagetool -c "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage" # (64-bit)
-        chmod a+x ./appimagetool
-
-        wget -O linuxdeployqt -c "https://github.com/probonopd/linuxdeployqt/releases/download/continuous/linuxdeployqt-continuous-x86_64.AppImage" # (64-bit)
-        chmod a+x ./linuxdeployqt
-    fi
-
-    sudo apt-get -yq install valgrind
-
-    if [[ "$CC" = "clang-9" ]]; then
-      sudo apt-get -yq install clang-9 clang-tidy-9
-    fi
-
-    if [[ "$CC" = "clang-4.0" ]]; then
-      # Fix a header bug present in ubuntu...
-      sudo ln -s /usr/include/libcxxabi/__cxxabi_config.h /usr/include/c++/v1/__cxxabi_config.h
-    fi
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    gem install xcpretty
-    
-    brew update
-    brew outdated cmake || brew upgrade cmake
-elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
-    choco install mingw ninja
-fi
-
-cmake --version

ci/travis/release.sh

@@ -1,68 +0,0 @@
-#!/usr/bin/env sh
-
-set -ex
-mkdir -p /tmp/builds
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-	cd build
-    for config in $BUILD_CONFIGS
-    do
-        cd "$config"
-
-        # Compile all targets
-        ninja all
-
-        # Install Freespace2 targets
-        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/fso -DCOMPONENT=Unspecified -P cmake_install.cmake
-        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/fso -DCOMPONENT=Freespace2 -P cmake_install.cmake
-
-        # We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-        FILENAME="$(find /tmp/release/$config/fso/bin -name 'fs2_open_*' -type f -printf "%f\n").AppImage"
-        $HOME/appimagetool -n /tmp/release/$config/fso "/tmp/release/$config/fso/$FILENAME"
-
-: <<'END'
-        # Install qtFRED targets
-        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/qtfred/usr -DCOMPONENT=Unspecified -P cmake_install.cmake
-        cmake -DCMAKE_INSTALL_PREFIX=/tmp/release/$config/qtfred/usr -DCOMPONENT=qtFRED -P cmake_install.cmake
-
-        PREV="$(pwd)"
-        cd /tmp/release/$config/qtfred
-
-        unset QTDIR; unset QT_PLUGIN_PATH; unset LD_LIBRARY_PATH
-        $HOME/linuxdeployqt usr/qtfred.desktop -bundle-non-qt-libs
-        # Move our AppRun script to the right location
-        mv usr/AppRun AppRun
-
-        echo "Embed newer libstdc++ for distros that don't come with it (ubuntu 14.04)";
-        mkdir -p usr/optional/; mkdir -p usr/optional/libstdc++/;
-        cp /usr/lib/x86_64-linux-gnu/libstdc++.so.6 ./usr/optional/libstdc++/;
-
-        $HOME/appimagetool -n . "$(find /tmp/release/$config/qtfred/usr/bin -name 'qtfred_*' -type f -printf "%f\n").AppImage"
-
-        cd "$PREV"
-END
-
-        cd ..
-    done
-
-    cp `find /tmp/release -name '*.AppImage' -print` /tmp/release
-    (cd /tmp/release && tar -cvzf /tmp/builds/$PACKAGE_NAME-builds-Linux.tar.gz *.AppImage)
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    cd build
-    
-    for config in $BUILD_CONFIGS
-    do
-        cmake --build . --config "$config" --target install | tee build.log \
-            | xcpretty
-        XCODE_RET=${PIPESTATUS[0]}
-        if [ "$XCODE_RET" -ne "0" ]; then
-            tar -cvzf build.log.tar.gz build.log
-            curl --upload-file build.log.tar.gz "https://transfer.sh/build.log.tar.gz"
-            exit $XCODE_RET
-        fi
-    done
-
-    ls -al /tmp/release
-    
-    (cd /tmp/release && tar -cvzf /tmp/builds/$PACKAGE_NAME-builds-MacOSX.tar.gz *)
-fi

ci/travis/script.sh

@@ -1,30 +0,0 @@
-#!/usr/bin/env sh
-
-set -e
-
-cd build
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    ninja -k 20 all
-
-    if [ "$CONFIGURATION" = "Debug" ]; then
-        valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
-            --suppressions="$TRAVIS_BUILD_DIR/ci/travis/valgrind.supp" ./bin/unittests --gtest_shuffle
-    else
-        ./bin/unittests --gtest_shuffle
-    fi
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    cmake --build . --config "$CONFIGURATION" | tee build.log | xcpretty
-    XCODE_RET=${PIPESTATUS[0]}
-    if [ "$XCODE_RET" -ne "0" ]; then
-        tar -cvzf build.log.tar.gz build.log
-        curl --upload-file build.log.tar.gz "https://keep.sh"
-        exit $XCODE_RET
-    fi
-elif [ "$TRAVIS_OS_NAME" = "windows" ]; then
-    if [ "$CMAKE_GENERATOR" = "Ninja" ]; then
-        cmake --build . --config "$CONFIGURATION"
-    else
-        cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-    fi
-fi

cmake/AppImage.desktop.in

@@ -1,6 +0,0 @@
-[Desktop Entry]
-Type=Application
-Name=FreeSpace Open
-Exec=$<TARGET_FILE_NAME:Freespace2>
-Icon=app_icon
-Categories=Game;

cmake/AppRun.in

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

cmake/Cxx11.cmake

@@ -1,3 +0,0 @@
-
-set(CMAKE_CXX_STANDARD_REQUIRED 11)
-set(CMAKE_CXX_STANDARD 11)

cmake/appimage.cmake

@@ -1,21 +0,0 @@
-
-SET(BINARY_DESTINATION "bin")
-SET(LIBRAY_DESTINATION "lib")
-
-configure_file("${CMAKE_CURRENT_LIST_DIR}/AppRun.in" "${CMAKE_CURRENT_BINARY_DIR}/AppRun.gen" @ONLY)
-file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/AppRun-$<CONFIG>"
-    INPUT "${CMAKE_CURRENT_BINARY_DIR}/AppRun.gen")
-
-install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/AppRun-$<CONFIG>" DESTINATION "." RENAME "AppRun"
-        COMPONENT "Freespace2")
-
-
-configure_file("${CMAKE_CURRENT_LIST_DIR}/AppImage.desktop.in" "${CMAKE_CURRENT_BINARY_DIR}/AppImage.desktop.gen" @ONLY)
-file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/AppImage-$<CONFIG>.desktop"
-    INPUT "${CMAKE_CURRENT_BINARY_DIR}/AppImage.desktop.gen")
-
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/AppImage-$<CONFIG>.desktop" DESTINATION "." RENAME "fso.desktop"
-        COMPONENT "Freespace2")
-
-install(FILES "${CMAKE_SOURCE_DIR}/freespace2/resources/app_icon.png" DESTINATION "."
-        COMPONENT "Freespace2")

cmake/clang-tidy.cmake

@@ -1,37 +0,0 @@
-option(ENABLE_CLANG_TIDY "Enable source code checking using clang-tidy" OFF)
-
-find_program(
-    CLANG_TIDY_EXE
-    NAMES "clang-tidy"
-    DOC "Path to clang-tidy executable"
-)
-
-function(enable_clang_tidy target)
-    # Not enabled in this configuration
-endfunction()
-
-if(NOT ENABLE_CLANG_TIDY)
-    return()
-endif()
-
-if(NOT EXISTS "${CLANG_TIDY_EXE}")
-    message(SEND_ERROR "clang-tidy: Could not find clang-tidy executable (value of variable is \"${CLANG_TIDY_EXE}\".")
-    return()
-endif()
-
-if(CMAKE_VERSION VERSION_LESS "3.6.0")
-    message(SEND_ERROR "Clang-tidy support requires CMake 3.6")
-    return()
-endif()
-
-message(STATUS "clang-tidy: Using \"${CLANG_TIDY_EXE}\"")
-
-function(enable_clang_tidy target)
-    SET(TIDY_OPTIONS "${CLANG_TIDY_EXE}")
-    if(FSO_FATAL_WARNINGS)
-        set(TIDY_OPTIONS "${TIDY_OPTIONS};-warnings-as-errors=*")
-    endif()
-
-    set_target_properties(${target} PROPERTIES CXX_CLANG_TIDY "${TIDY_OPTIONS}")
-endfunction()
-

cmake/cpufeatures.cpp

@@ -1,59 +0,0 @@
-// Code snippet from http://stackoverflow.com/a/7495023
-#ifdef _WIN32
-#include <intrin.h>
-//  Windows
-#define cpuid    __cpuid
-
-#else
-
-//  GCC Inline Assembly
-void cpuid(int CPUInfo[4],int InfoType){
-    __asm__ __volatile__ (
-        "cpuid":
-        "=a" (CPUInfo[0]),
-        "=b" (CPUInfo[1]),
-        "=c" (CPUInfo[2]),
-        "=d" (CPUInfo[3]) :
-        "a" (InfoType)
-    );
-}
-
-#endif
-
-#include <iostream>
-
-int main( int argc, char* argv[] )
-{
-	int SSE     = false;
-	int SSE2    = false;
-	int AVX     = false;
-	int AVX2    = false;
-
-	int info[4];
-	cpuid(info, 0);
-	int nIds = info[0];
-
-	//  Detect Instruction Set
-	if (nIds >= 1){
-		cpuid(info,0x00000001);
-		SSE   = (info[3] & ((int)1 << 25)) != 0;
-		SSE2  = (info[3] & ((int)1 << 26)) != 0;
-
-		AVX   = (info[2] & ((int)1 << 28)) != 0;
-	}
-	if (nIds >= 7){
-		cpuid(info,0x00000007);
-		AVX2  = (info[1] & ((int)1 <<  5)) != 0;
-	}
-
-	if (AVX2)
-		std::cout << "AVX2";
-	else if(AVX)
-		std::cout << "AVX";
-	else if(SSE2)
-		std::cout << "SSE2";
-	else if(SSE)
-		std::cout << "SSE";
-
-	return 0;
-}

cmake/cross_compile/mingw64.cmake

@@ -1,26 +0,0 @@
-
-# Sample toolchain file for building for Windows from a Linux system.
-#
-# Typical usage:
-#    *) install cross compiler: `sudo apt-get install mingw-w64 g++-mingw-w64`
-#    *) cd build
-#    *) cmake -DCMAKE_TOOLCHAIN_FILE=~/Toolchain-Ubuntu-mingw64.cmake ..
-
-set(CMAKE_SYSTEM_NAME Windows)
-set(TOOLCHAIN_PREFIX x86_64-w64-mingw32)
-
-# cross compilers to use for C and C++
-set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
-set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
-set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
-
-# target environment on the build host system
-#   set 1st to dir with the cross compiler's C/C++ headers/libs
-set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
-
-# modify default behavior of FIND_XXX() commands to
-# search for headers/libs in the target environment and
-# don't search for programs in the build host environment
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

cmake/debug-vars.cmake

@@ -1,154 +0,0 @@
-# ------------------------- Begin Generic CMake Variable Logging ------------------
-
-# /*	C++ comment style not allowed	*/
-
-
-# if you are building in-source, this is the same as CMAKE_SOURCE_DIR, otherwise
-# this is the top level directory of your build tree
-MESSAGE( STATUS "CMAKE_BINARY_DIR:         " ${CMAKE_BINARY_DIR} )
-
-# if you are building in-source, this is the same as CMAKE_CURRENT_SOURCE_DIR, otherwise this
-# is the directory where the compiled or generated files from the current CMakeLists.txt will go to
-MESSAGE( STATUS "CMAKE_CURRENT_BINARY_DIR: " ${CMAKE_CURRENT_BINARY_DIR} )
-
-# this is the directory, from which cmake was started, i.e. the top level source directory
-MESSAGE( STATUS "CMAKE_SOURCE_DIR:         " ${CMAKE_SOURCE_DIR} )
-
-# this is the directory where the currently processed CMakeLists.txt is located in
-MESSAGE( STATUS "CMAKE_CURRENT_SOURCE_DIR: " ${CMAKE_CURRENT_SOURCE_DIR} )
-
-# contains the full path to the top level directory of your build tree
-MESSAGE( STATUS "PROJECT_BINARY_DIR: " ${PROJECT_BINARY_DIR} )
-
-MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} )
-
-# contains the full path to the root of your project source directory,
-# i.e. to the nearest directory where CMakeLists.txt contains the PROJECT() command
-MESSAGE( STATUS "PROJECT_SOURCE_DIR: " ${PROJECT_SOURCE_DIR} )
-
-# set this variable to specify a common place where CMake should put all executable files
-# (instead of CMAKE_CURRENT_BINARY_DIR)
-MESSAGE( STATUS "EXECUTABLE_OUTPUT_PATH: " ${EXECUTABLE_OUTPUT_PATH} )
-
-# set this variable to specify a common place where CMake should put all libraries
-# (instead of CMAKE_CURRENT_BINARY_DIR)
-MESSAGE( STATUS "LIBRARY_OUTPUT_PATH:     " ${LIBRARY_OUTPUT_PATH} )
-
-# tell CMake to search first in directories listed in CMAKE_MODULE_PATH
-# when you use FIND_PACKAGE() or INCLUDE()
-MESSAGE( STATUS "CMAKE_MODULE_PATH: " ${CMAKE_MODULE_PATH} )
-
-# this is the complete path of the cmake which runs currently (e.g. /usr/local/bin/cmake)
-MESSAGE( STATUS "CMAKE_COMMAND: " ${CMAKE_COMMAND} )
-
-# this is the CMake installation directory
-MESSAGE( STATUS "CMAKE_ROOT: " ${CMAKE_ROOT} )
-
-# this is the filename including the complete path of the file where this variable is used.
-MESSAGE( STATUS "CMAKE_CURRENT_LIST_FILE: " ${CMAKE_CURRENT_LIST_FILE} )
-
-# this is linenumber where the variable is used
-MESSAGE( STATUS "CMAKE_CURRENT_LIST_LINE: " ${CMAKE_CURRENT_LIST_LINE} )
-
-# this is used when searching for include files e.g. using the FIND_PATH() command.
-MESSAGE( STATUS "CMAKE_INCLUDE_PATH: " ${CMAKE_INCLUDE_PATH} )
-
-# this is used when searching for libraries e.g. using the FIND_LIBRARY() command.
-MESSAGE( STATUS "CMAKE_LIBRARY_PATH: " ${CMAKE_LIBRARY_PATH} )
-
-# the complete system name, e.g. "Linux-2.4.22", "FreeBSD-5.4-RELEASE" or "Windows 5.1"
-MESSAGE( STATUS "CMAKE_SYSTEM: " ${CMAKE_SYSTEM} )
-
-# the short system name, e.g. "Linux", "FreeBSD" or "Windows"
-MESSAGE( STATUS "CMAKE_SYSTEM_NAME: " ${CMAKE_SYSTEM_NAME} )
-
-# only the version part of CMAKE_SYSTEM
-MESSAGE( STATUS "CMAKE_SYSTEM_VERSION: " ${CMAKE_SYSTEM_VERSION} )
-
-# the processor name (e.g. "Intel(R) Pentium(R) M processor 2.00GHz")
-MESSAGE( STATUS "CMAKE_SYSTEM_PROCESSOR: " ${CMAKE_SYSTEM_PROCESSOR} )
-
-# is TRUE on all UNIX-like OS's, including Apple OS X and CygWin
-MESSAGE( STATUS "UNIX: " ${UNIX} )
-
-# is TRUE on Windows, including CygWin
-MESSAGE( STATUS "WIN32: " ${WIN32} )
-
-# is TRUE on Apple OS X
-MESSAGE( STATUS "APPLE: " ${APPLE} )
-
-# is TRUE when using the MinGW compiler in Windows
-MESSAGE( STATUS "MINGW: " ${MINGW} )
-
-# is TRUE on Windows when using the CygWin version of cmake
-MESSAGE( STATUS "CYGWIN: " ${CYGWIN} )
-
-# is TRUE on Windows when using a Borland compiler
-MESSAGE( STATUS "BORLAND: " ${BORLAND} )
-
-# Microsoft compiler
-MESSAGE( STATUS "MSVC: " ${MSVC} )
-MESSAGE( STATUS "MSVC_IDE: " ${MSVC_IDE} )
-MESSAGE( STATUS "MSVC60: " ${MSVC60} )
-MESSAGE( STATUS "MSVC70: " ${MSVC70} )
-MESSAGE( STATUS "MSVC71: " ${MSVC71} )
-MESSAGE( STATUS "MSVC80: " ${MSVC80} )
-MESSAGE( STATUS "CMAKE_COMPILER_2005: " ${CMAKE_COMPILER_2005} )
-
-
-# set this to true if you don't want to rebuild the object files if the rules have changed,
-# but not the actual source files or headers (e.g. if you changed the some compiler switches)
-MESSAGE( STATUS "CMAKE_SKIP_RULE_DEPENDENCY: " ${CMAKE_SKIP_RULE_DEPENDENCY} )
-
-# since CMake 2.1 the install rule depends on all, i.e. everything will be built before installing.
-# If you don't like this, set this one to true.
-MESSAGE( STATUS "CMAKE_SKIP_INSTALL_ALL_DEPENDENCY: " ${CMAKE_SKIP_INSTALL_ALL_DEPENDENCY} )
-
-# If set, runtime paths are not added when using shared libraries. Default it is set to OFF
-MESSAGE( STATUS "CMAKE_SKIP_RPATH: " ${CMAKE_SKIP_RPATH} )
-
-# set this to true if you are using makefiles and want to see the full compile and link
-# commands instead of only the shortened ones
-MESSAGE( STATUS "CMAKE_VERBOSE_MAKEFILE: " ${CMAKE_VERBOSE_MAKEFILE} )
-
-# this will cause CMake to not put in the rules that re-run CMake. This might be useful if
-# you want to use the generated build files on another machine.
-MESSAGE( STATUS "CMAKE_SUPPRESS_REGENERATION: " ${CMAKE_SUPPRESS_REGENERATION} )
-
-
-# A simple way to get switches to the compiler is to use ADD_DEFINITIONS().
-# But there are also two variables exactly for this purpose:
-
-# the compiler flags for compiling C sources
-MESSAGE( STATUS "CMAKE_C_FLAGS: " ${CMAKE_C_FLAGS} )
-
-# the compiler flags for compiling C++ sources
-MESSAGE( STATUS "CMAKE_CXX_FLAGS: " ${CMAKE_CXX_FLAGS} )
-
-
-# Choose the type of build.  Example: SET(CMAKE_BUILD_TYPE Debug)
-MESSAGE( STATUS "CMAKE_BUILD_TYPE: " ${CMAKE_BUILD_TYPE} )
-
-# if this is set to ON, then all libraries are built as shared libraries by default.
-MESSAGE( STATUS "BUILD_SHARED_LIBS: " ${BUILD_SHARED_LIBS} )
-
-# the compiler used for C files
-MESSAGE( STATUS "CMAKE_C_COMPILER: " ${CMAKE_C_COMPILER} )
-
-# the compiler used for C++ files
-MESSAGE( STATUS "CMAKE_CXX_COMPILER: " ${CMAKE_CXX_COMPILER} )
-
-# if the compiler is a variant of gcc, this should be set to 1
-MESSAGE( STATUS "CMAKE_COMPILER_IS_GNUCC: " ${CMAKE_COMPILER_IS_GNUCC} )
-
-# if the compiler is a variant of g++, this should be set to 1
-MESSAGE( STATUS "CMAKE_COMPILER_IS_GNUCXX : " ${CMAKE_COMPILER_IS_GNUCXX} )
-
-# the tools for creating libraries
-MESSAGE( STATUS "CMAKE_AR: " ${CMAKE_AR} )
-MESSAGE( STATUS "CMAKE_RANLIB: " ${CMAKE_RANLIB} )
-
-#
-#MESSAGE( STATUS ": " ${} )
-
-# ------------------------- End of Generic CMake Variable Logging ------------------

cmake/doxygen.cmake

@@ -1,37 +0,0 @@
-
-# add a target to generate API documentation with Doxygen
-find_package(Doxygen)
-if(DOXYGEN_FOUND)
-	SET(OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/documentation/doxygen")
-	FILE(MAKE_DIRECTORY "${OUTPUT_DIR}")
-	
-	FILE(TO_NATIVE_PATH ${OUTPUT_DIR} OUTPUT_DIR)
-	SET(OUTPUT_DIR \"${OUTPUT_DIR}\")
-	
-	SET(INPUTS "${CMAKE_CURRENT_SOURCE_DIR}/code" "${CMAKE_CURRENT_SOURCE_DIR}/freespace2" "${CMAKE_CURRENT_SOURCE_DIR}/fred2" "${CMAKE_CURRENT_SOURCE_DIR}/wxfred2" "${CMAKE_CURRENT_SOURCE_DIR}/qtfred")
-	
-	SET(INPUT_DIRS)
-	FOREACH(DIR IN LISTS INPUTS)
-		FILE(TO_NATIVE_PATH ${DIR} native_dir)
-		
-		LIST(APPEND INPUT_DIRS \"${native_dir}\")
-	ENDFOREACH(DIR)
-	STRING(REPLACE ";" " " INPUT_DIRS "${INPUT_DIRS}")
-	
-	CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/fs2open.Doxyfile.in
-					${CMAKE_CURRENT_BINARY_DIR}/fs2open.Doxyfile
-					@ONLY)
-	
-	add_custom_target(doxygen
-		${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/fs2open.Doxyfile
-		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-		COMMENT "Generating API documentation with Doxygen" VERBATIM
-	)
-	
-	set_target_properties(doxygen
-		PROPERTIES
-			FOLDER "Documentation"
-			EXCLUDE_FROM_ALL ON
-			EXCLUDE_FROM_DEFAULT_BUILD ON
-	)
-endif(DOXYGEN_FOUND)

cmake/embed_file.cmake

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

cmake/embedded_files.inc.in

@@ -1,7 +0,0 @@
-
-@INCLUDE_LIST@
-
-def_file Default_files[] =
-{
-@ARRAY_ELEMENTS@
-};

cmake/finder/FindSpeech.cmake

@@ -1,16 +0,0 @@
-
-include(CheckIncludeFile)
-
-add_library(speech INTERFACE)
-
-if (WIN32)
-	CHECK_INCLUDE_FILE_CXX("sapi.h" HAVE_SAPI_H)
-	
-	if (NOT HAVE_SAPI_H)
-		message(SEND_ERROR "sapi.h could not be found on your platform. Please disable speech support.")
-	endif()
-else()
-	message(SEND_ERROR "Text to Speech is not supported on this platform!")
-endif()
-
-target_compile_definitions(speech INTERFACE -DFS2_SPEECH)

cmake/fred_rc.h.in

@@ -1,9 +0,0 @@
-
-
-#ifndef __FREDRC_H
-#define __FREDRC_H
-
-#define ABOUT_LINE_1 "FRED2_OPEN - FreeSpace Editor, Version @FSO_PRODUCT_VERSION_STRING@ OpenGL"
-#define MAINFRAME_CONTENTS "FRED2_OPEN @FSO_PRODUCT_VERSION_STRING@ - FreeSpace2 Mission Editor\nUntitled\nFRED2\nFreeSpace2 Missions (*.fs2)\n.fs2\nFreeSpace2Mission\nFreeSpace2 Mission"
-
-#endif // __FREDRC_H

cmake/generateHeaders.cmake

@@ -1,7 +0,0 @@
-
-
-include(Cxx11)
-include(platformChecks)
-
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/project.h.in ${GENERATED_SOURCE_DIR}/project.h)
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/fred_rc.h.in ${GENERATED_SOURCE_DIR}/fred_rc.h)

cmake/globals.cmake

@@ -1,9 +0,0 @@
-
-SET(BINARY_DESTINATION ".")
-SET(LIBRAY_DESTINATION "${BINARY_DESTINATION}")
-
-if (CMAKE_SIZEOF_VOID_P EQUAL 8)
-    set(IS_64BIT TRUE)
-else()
-    set(IS_64BIT FALSE)
-endif()

cmake/headers.cmake

@@ -1,8 +0,0 @@
-
-SET(CODE_HEADERS ${CMAKE_SOURCE_DIR}/code)
-
-SET(FREESPACE_HEADERS ${CMAKE_SOURCE_DIR}/freespace2)
-
-SET(FRED_HEADERS ${CMAKE_SOURCE_DIR}/fred2)
-
-SET(WXFRED_HEADERS ${CMAKE_SOURCE_DIR}/wxfred2)

cmake/package.cmake

@@ -1,14 +0,0 @@
-
-SET(CPACK_PACKAGE_VERSION_MAJOR ${FSO_VERSION_MAJOR})
-SET(CPACK_PACKAGE_VERSION_MINOR ${FSO_VERSION_MINOR})
-SET(CPACK_PACKAGE_VERSION_PATCH ${FSO_VERSION_BUILD})
-
-SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY ${FSO_PROJECT_DESCRIPTION})
-
-IF(WIN32)
-	SET(CPACK_NSIS_MUI_ICON ${FSO_INSTALLER_ICON})
-	
-	set(CPACK_NSIS_MENU_LINKS "http://www.hard-light.net/" "FreeSpace Community")
-ENDIF(WIN32)
-
-include(CPack)

cmake/platform-darwin.cmake

@@ -1,34 +0,0 @@
-
-MESSAGE(STATUS "Doing Mac OSX specific things...")
-target_compile_definitions(platform INTERFACE APPLE_APP)
-SET(EXE_GUI_TYPE MACOSX_BUNDLE)
-
-FIND_LIBRARY(COCOA_LIBRARY Cocoa)
-
-if (NOT COCOA_LIBRARY)
-    message(FATAL_ERROR "Couldn't find Cocoa!")
-endif()
-
-target_link_libraries(platform INTERFACE ${COCOA_LIBRARY})
-
-SET(CMAKE_OSX_DEPLOYMENT_TARGET "10.9")
-
-SET(CMAKE_SKIP_RPATH FALSE)
-SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-SET(CMAKE_INSTALL_RPATH @loader_path/../Frameworks/)
-
-# Set the path where library dependencies are copied to
-SET(LIBRAY_DESTINATION "../Frameworks")
-
-set(PLATFORM_MAC TRUE CACHE INTERNAL "" FORCE)
-
-# Generate and don't strip debug symbols
-# These settings don't seem to generate debug symbols for code and Freespace2
-# so those settings are set manually in code and Freespace2's CMakeLists.txt files
-set(CMAKE_XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS "YES")
-set(CMAKE_XCODE_ATTRIBUTE_COPY_PHASE_STRIP "NO")
-set(CMAKE_XCODE_ATTRIBUTE_STRIP_INSTALLED_PRODUCT "NO")
-set(CMAKE_XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN "NO")
-
-# Generate .dSYM file
-set(CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT "dwarf-with-dsym")

cmake/platform-freebsd.cmake

@@ -1,10 +0,0 @@
-
-target_compile_definitions(platform INTERFACE SCP_BSD)
-
-find_library(EXECINFO_LIB execinfo)
-
-if (NOT EXECINFO_LIB)
-    message(FATAL_ERROR "Couldn't find libexecinfo! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${EXECINFO_LIB}")
-endif()

cmake/platform-solaris.cmake

@@ -1,18 +0,0 @@
-
-target_compile_definitions(platform INTERFACE SCP_SOLARIS)
-
-find_library(SOCKET_LIB socket)
-
-if (NOT SOCKET_LIB)
-    message(FATAL_ERROR "Couldn't find libsocket! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${SOCKET_LIB}")
-endif()
-
-find_library(NSL_LIB nsl)
-
-if (NOT NSL_LIB)
-    message(FATAL_ERROR "Couldn't find libnsl! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${NSL_LIB}")
-endif()

cmake/platform-unix.cmake

@@ -1,13 +0,0 @@
-
-INCLUDE(util)
-
-MESSAGE(STATUS "Configuring UNIX specific things and stuff...")
-
-target_compile_definitions(platform INTERFACE SCP_UNIX USE_OPENAL _REENTRANT)
-
-# Set RPATH
-set(CMAKE_SKIP_BUILD_RPATH TRUE)
-set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-set(CMAKE_INSTALL_RPATH "\$ORIGIN")
-
-set(PLATFORM_UNIX TRUE CACHE INTERNAL "" FORCE)

cmake/platform-win32.cmake

@@ -1,27 +0,0 @@
-
-MESSAGE(STATUS "Configuring Windows specific things and stuff...")
-
-SET(WIN32_LIBS
-	comctl32
-	msacm32
-	odbc32
-	odbccp32
-	vfw32
-	winmm
-	ws2_32
-	psapi
-)
-
-IF (MINGW)
-	SET(WIN32_LIBS ${WIN32_LIBS} mingw32)
-ENDIF (MINGW)
-
-target_link_libraries(platform INTERFACE ${WIN32_LIBS})
-
-target_compile_definitions(platform INTERFACE WIN32 USE_OPENAL _WINDOWS)
-
-# Specify minimum Windows version for the headers (currently this is Vista)
-target_compile_definitions(platform INTERFACE NTDDI_VERSION=0x06000000 _WIN32_WINNT=0x0600)
-
-SET(EXE_GUI_TYPE WIN32)
-set(PLATFORM_WINDOWS TRUE CACHE INTERNAL "" FORCE)

cmake/platformChecks.cmake

@@ -1,45 +0,0 @@
-
-include(CheckFunctionExists)
-include(CheckIncludeFiles)
-include(CheckIncludeFile)
-include(CheckIncludeFileCXX)
-include(CheckLibraryExists)
-include(CheckPrototypeDefinition)
-include(CheckStructHasMember)
-include(CheckSymbolExists)
-include(CheckCXXSymbolExists)
-include(CheckTypeSize)
-
-CHECK_INCLUDE_FILE("execinfo.h" SCP_HAVE_EXECINFO_H)
-CHECK_INCLUDE_FILE_CXX("cxxabi.h" SCP_HAVE_CXXAPI_H)
-
-CHECK_TYPE_SIZE("max_align_t" MAX_ALIGN_T)
-
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-    set(CMAKE_REQUIRED_FLAGS "-std=c++11") # required for g++ <= 5
-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)
-
-CHECK_TYPE_SIZE("char32_t" CHAR32_T LANGUAGE CXX)
-CHECK_TYPE_SIZE("U'b'" UNICODE_CHAR_LITERAL LANGUAGE CXX)
-
-set(CMAKE_REQUIRED_FLAGS)
-
-
-CHECK_FUNCTION_EXISTS(strcasecmp SCP_HAVE_STRCASECMP)
-CHECK_FUNCTION_EXISTS(strncasecmp SCP_HAVE_STRNCASECMP)
-
-CHECK_FUNCTION_EXISTS(_stricmp SCP_HAVE__STRICMP)
-CHECK_FUNCTION_EXISTS(_strnicmp SCP_HAVE__STRNICMP)
-
-CHECK_FUNCTION_EXISTS(strlwr SCP_HAVE_STRLWR)
-
-CHECK_INCLUDE_FILE("strings.h" SCP_HAVE_STRINGS_H)
-
-check_symbol_exists(snprintf "stdio.h" SCP_HAVE_SNPRINTF)
-
-set(PLATFORM_CHECK_HEADER "${GENERATED_SOURCE_DIR}/platformChecks.h")
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/platformChecks.h.in "${PLATFORM_CHECK_HEADER}")

cmake/platformChecks.h.in

@@ -1,28 +0,0 @@
-
-#ifndef __PLATFORM_CHECKS_H__
-#define __PLATFORM_CHECKS_H__
-#pragma once
-
-#cmakedefine SCP_HAVE_EXECINFO_H
-#cmakedefine SCP_HAVE_CXXAPI_H
-#cmakedefine SCP_HAVE_MAX_ALIGN_T
-#cmakedefine SCP_HAVE_STD_MAX_ALIGN_T
-
-#cmakedefine01 IS_64BIT
-
-#cmakedefine01 SCP_HAVE_STRCASECMP
-#cmakedefine01 SCP_HAVE_STRNCASECMP
-#cmakedefine01 SCP_HAVE__STRICMP
-#cmakedefine01 SCP_HAVE__STRNICMP
-
-#cmakedefine01 SCP_HAVE_STRLWR
-
-#cmakedefine01 SCP_HAVE_STRINGS_H
-
-#cmakedefine01 HAVE_CHAR32_T
-#cmakedefine01 HAVE_UNICODE_CHAR_LITERAL
-
-#cmakedefine01 SCP_HAVE_SNPRINTF
-#cmakedefine01 SCP_HAVE__SNPRINTF
-
-#endif // __PLATFORM_CHECKS_H__

cmake/platforms.cmake

@@ -1,29 +0,0 @@
-
-add_library(platform INTERFACE)
-
-IF(FSO_CMAKE_DEBUG)
-	INCLUDE(debug-vars)
-ENDIF(FSO_CMAKE_DEBUG)
-
-set(PLATFORM_WINDOWS FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_UNIX FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_LINUX FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_MAC FALSE CACHE INTERNAL "" FORCE)
-
-IF(WIN32)
-	INCLUDE(platform-win32)
-ELSEIF(UNIX)
-	INCLUDE(platform-unix)
-
-	IF(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
-		INCLUDE(platform-freebsd)
-	ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-		INCLUDE(platform-solaris)
-	ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-		include(platform-darwin)
-	elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-		set(PLATFORM_LINUX TRUE CACHE INTERNAL "" FORCE)
-	ENDIF()
-ELSE(WIN32)
-	MESSAGE(STATUS "This platform is not supported, good luck!")
-ENDIF(WIN32)