Skip to content

An OpenMW mod that lets you play the whole Elder Scrolls III: Morrowind as a top-down isometric game — with full online co-op or MMO modes.

C++

Releases built by CI: merging an alpha-/beta- branch makes the Windows zip and Linux package

Alan Saunders2c6ebf00f048
diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
index 2910658..7ba04ed 100644
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -1,23 +1,95 @@
name: Linux
+# The Linux package for a release, put on the release beside the Windows zip. release.yml runs it for every release;
+# by hand (Actions > Linux > Run workflow, or gh workflow run linux.yml -f tag=TAG) it fills in one made before that,
+# building the release's tag, or another commit given as ref, whichever branch it is run from.
on:
- # Branches only: tags (like the bundled-mods release's) don't build
- push:
- branches: ['**']
workflow_dispatch:
-
-# A newer push replaces a run still going
-concurrency:
- group: ${{ github.workflow }}
- cancel-in-progress: true
+ inputs:
+ tag:
+ description: The release's tag
+ required: true
+ ref:
+ description: "The commit, branch or tag to build (blank: the release's tag)"
+ required: false
+ default: ''
+ version_hash:
+ description: >-
+ Multiplayer version hash to build in, when the release's Windows zip was built from other engine source than
+ this (line 2 of its engine/resources/version). Blank: the source's own
+ required: false
+ default: ''
+ attach:
+ description: Put the package on the release (unticked, it is this run's artifact for a week)
+ type: boolean
+ default: true
+ match_windows:
+ description: Stop if the release's Windows zip has another multiplayer version hash
+ type: boolean
+ default: true
+ workflow_call:
+ inputs:
+ tag:
+ type: string
+ required: true
+ ref:
+ type: string
+ default: ''
+ version_hash:
+ type: string
+ default: ''
+ attach:
+ type: boolean
+ default: true
+ # Whether to check the hash against the release's Windows zip (release.yml compares the two builds itself)
+ match_windows:
+ type: boolean
+ default: true
+ outputs:
+ hash:
+ description: The multiplayer version hash it was built with
+ value: ${{ jobs.build.outputs.hash }}
+ glibc:
+ description: The oldest glibc the package runs on (e.g. 2.39)
+ value: ${{ jobs.build.outputs.glibc }}
jobs:
build:
runs-on: ubuntu-24.04
+ # A newer run for the same release replaces one still going
+ concurrency:
+ group: linux-${{ inputs.tag }}
+ cancel-in-progress: true
+ # (to put the package on the release)
+ permissions:
+ contents: write
+ outputs:
+ hash: ${{ steps.hash.outputs.hash }}
+ glibc: ${{ steps.archive.outputs.glibc }}
env:
CCACHE_DIR: ${{ github.workspace }}/.ccache
+ TAG: ${{ inputs.tag }}
+ VERSION_HASH: ${{ inputs.version_hash }}
+ ATTACH: ${{ inputs.attach }}
+ MATCH_WINDOWS: ${{ inputs.match_windows }}
+ # The multiplayer's networking (TES3MP's CrabNet), at the commit the Windows build uses
+ CRABNET_COMMIT: 19e6619
steps:
- uses: actions/checkout@v4
+ with:
+ ref: ${{ inputs.ref || format('refs/tags/{0}', inputs.tag) }}
+ persist-credentials: false
+
+ # The hash given, in place of the one cmake/GitVersion.cmake makes from the engine's source. That script runs at
+ # build time, so changing it here is enough (the source patch in the package is the source's, unchanged)
+ - name: Version hash
+ if: inputs.version_hash != ''
+ run: |
+ printf '%s\n' "$VERSION_HASH" | grep -Eqx '[0-9a-f]{40}' \
+ || { echo "::error::version_hash isn't a 40-digit hash"; exit 1; }
+ sed -i "s/^string(SHA1 COMMITHASH .*/set(COMMITHASH \"$VERSION_HASH\")/" cmake/GitVersion.cmake
+ grep -qF "set(COMMITHASH \"$VERSION_HASH\")" cmake/GitVersion.cmake \
+ || { echo "::error::no hash line to replace in cmake/GitVersion.cmake"; exit 1; }
- name: Dependencies
run: sudo CI/install_debian_deps.sh gcc openmw-deps openmw-deps-dynamic
@@ -29,16 +101,15 @@ jobs:
key: linux-ccache-${{ github.run_id }}
restore-keys: linux-ccache-
- # The multiplayer's networking (TES3MP's CrabNet), at the commit the Windows build uses
- name: CrabNet
run: |
git clone https://github.com/TES3MP/CrabNet.git crabnet
- git -C crabnet checkout 19e6619
+ git -C crabnet checkout "$CRABNET_COMMIT"
# Newer compilers don't pull in <cstdint> for it
sed -i '1i #include <cstdint>' crabnet/Source/Utils/_FindFirst.h
cmake -S crabnet -B crabnet/build -DCMAKE_BUILD_TYPE=Release -DCRABNET_ENABLE_DLL=OFF \
-DCRABNET_ENABLE_SAMPLES=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON
- cmake --build crabnet/build -j$(nproc)
+ cmake --build crabnet/build -j"$(nproc)"
- name: Configure
run: |
@@ -47,13 +118,13 @@ jobs:
-DUSE_SYSTEM_TINYXML=ON -DOPENMW_USE_SYSTEM_RECASTNAVIGATION=ON \
-DBUILD_OPENCS=OFF -DBUILD_BSATOOL=OFF -DBUILD_ESMTOOL=OFF -DBUILD_ESSIMPORTER=OFF -DBUILD_NIFTEST=OFF \
-DBUILD_NAVMESHTOOL=OFF -DBUILD_BULLETOBJECTTOOL=OFF -DBUILD_LAUNCHER=OFF -DBUILD_WIZARD=OFF \
- -DRakNet_INCLUDES=$PWD/crabnet/include \
- -DRakNet_LIBRARY_RELEASE=$(find $PWD/crabnet/build -name 'libRakNetLibStatic.a' | head -1) \
- -DRakNet_LIBRARY_DEBUG=$(find $PWD/crabnet/build -name 'libRakNetLibStatic.a' | head -1)
+ -DRakNet_INCLUDES="$PWD/crabnet/include" \
+ -DRakNet_LIBRARY_RELEASE="$(find "$PWD/crabnet/build" -name 'libRakNetLibStatic.a' | head -1)" \
+ -DRakNet_LIBRARY_DEBUG="$(find "$PWD/crabnet/build" -name 'libRakNetLibStatic.a' | head -1)"
- name: Build
# -k: report every file that fails, not just the first
- run: cmake --build build -j$(nproc) -- -k
+ run: cmake --build build -j"$(nproc)" -- -k
- uses: actions/cache/save@v4
if: always()
@@ -61,18 +132,39 @@ jobs:
path: .ccache
key: linux-ccache-${{ github.run_id }}
- # The bundled mods (third-party, so not in git): bundled-mods.zip on this repository's "bundled-mods" release
- - name: Bundled mods
+ # A server lets in only players with its own hash: this build's has to be the one asked for, and the Windows
+ # zip's on the release, or the two wouldn't play together
+ - name: Check version hash
+ id: hash
env:
GH_TOKEN: ${{ github.token }}
+ GH_REPO: ${{ github.repository }}
run: |
- if gh release download bundled-mods -p bundled-mods.zip; then
- unzip -q bundled-mods.zip -d bundled-mods
- else
- echo "::warning::No bundled-mods release: the package goes without the bundled mods"
+ HASH=$(sed -n 2p build/resources/version)
+ echo "Version hash: $HASH"
+ for f in build/openmw build/tes3mp-server; do
+ grep -qaF "$HASH" "$f" || { echo "::error::$f wasn't built with $HASH"; exit 1; }
+ done
+ if [ -n "$VERSION_HASH" ] && [ "$HASH" != "$VERSION_HASH" ]; then
+ echo "::error::built with $HASH, not the $VERSION_HASH asked for"; exit 1
fi
+ if [ "$MATCH_WINDOWS" = true ] &&
+ gh release view "$TAG" --json assets --jq '.assets[].name' 2>/dev/null | grep -qx Isowind.zip; then
+ gh release download "$TAG" -p Isowind.zip -D "$RUNNER_TEMP/windows" --clobber
+ WINDOWS=$(unzip -p "$RUNNER_TEMP/windows/Isowind.zip" Isowind/engine/resources/version | sed -n 2p | tr -d '\r')
+ if [ "$HASH" != "$WINDOWS" ]; then
+ MESSAGE="the release's Windows zip has version hash $WINDOWS and this build $HASH, so they wouldn't play"
+ MESSAGE="$MESSAGE together. If the zip's engine is the tag's but for changes that don't touch the"
+ MESSAGE="$MESSAGE multiplayer, run again with version_hash $WINDOWS"
+ if [ "$ATTACH" = true ]; then echo "::error::$MESSAGE"; exit 1; fi
+ echo "::warning::$MESSAGE"
+ fi
+ fi
+ echo "hash=$HASH" >> "$GITHUB_OUTPUT"
+ echo "Multiplayer version hash: \`$HASH\`" >> "$GITHUB_STEP_SUMMARY"
- # Laid out like the Windows zip, with isowind.sh in place of Isowind.exe
+ # Laid out like the Windows zip, with isowind.sh in place of Isowind.exe, and like the released one without the
+ # bundled mods (their licences don't all allow passing them on)
- name: Package
env:
APPIMAGE_EXTRACT_AND_RUN: 1
@@ -80,10 +172,57 @@ jobs:
sudo wget -q -O /usr/local/bin/linuxdeploy \
https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
sudo chmod +x /usr/local/bin/linuxdeploy
- sh isowind/linux/package.sh build Isowind bundled-mods
+ sh isowind/linux/package.sh --no-mods build Isowind
+
+ # Source, as make_package.ps1 puts it in the Windows zip (OpenMW is GPL v3): the changes against OpenMW's
+ # openmw-0.51.0 tag, fetched on its own from OpenMW's GitLab, with the same folders left out (and android/, which
+ # tags from before its removal have and their Windows patch left out)
+ - name: Source
+ run: |
+ OPENMW_TAG=openmw-0.51.0
+ git fetch --depth 1 https://gitlab.com/OpenMW/openmw.git "refs/tags/$OPENMW_TAG:refs/tags/$OPENMW_TAG"
+ mkdir -p Isowind/source
+ git diff "$OPENMW_TAG" HEAD -- . ':!MSVC2022_64' ':!deps' ':!android' ':!isowind' ':!.github' \
+ > "Isowind/source/isowind-$OPENMW_TAG.patch"
+ cp isowind/tools/make_palettes.py isowind/tools/retro_textures.py Isowind/source/
+ cat > Isowind/source/README.txt <<EOF
+ Isowind source
+ ==============
+ isowind-$OPENMW_TAG.patch Changes to OpenMW: apply to https://gitlab.com/OpenMW/openmw at tag $OPENMW_TAG.
+ Includes the multiplayer port of TES3MP (https://github.com/TES3MP/TES3MP, GPL v3).
+ make_palettes.py Builds pixelart/textures/isowind/palettes.dds.
+ retro_textures.py Builds the pixel art look's textures (isowind.sh runs the copy in tools).
+ The top-down mod (Lua) and shaders are in the mod and pixelart folders as they are, and the launcher
+ (isowind.sh, isowind-launcher.py) beside this folder. All of Isowind at this version:
+ $GITHUB_SERVER_URL/$GITHUB_REPOSITORY/tree/$(git rev-parse HEAD)
+ The engine was built on Ubuntu 24.04 with CrabNet (https://github.com/TES3MP/CrabNet) at commit $CRABNET_COMMIT.
+ EOF
+ if [ -n "$VERSION_HASH" ]; then
+ printf '%s\n%s\n' "Its multiplayer version hash was set to the Windows build's, $VERSION_HASH," \
+ "in place of the one cmake/GitVersion.cmake makes from the source." >> Isowind/source/README.txt
+ fi
+
+ - name: Archive
+ id: archive
+ run: |
tar -czf isowind-linux-x86_64.tar.gz Isowind
+ # The oldest glibc it runs on, for the release notes: the newest its programs and libraries ask for
+ # (linuxdeploy leaves glibc to the system)
+ GLIBC=$({ find Isowind/engine/usr/bin -maxdepth 1 -type f; find Isowind/engine/usr/lib -type f; } |
+ xargs objdump -T 2>/dev/null | grep -o 'GLIBC_[0-9.]*' | sort -uV | tail -n 1)
+ echo "Needs ${GLIBC:-an unknown glibc} or newer" >> "$GITHUB_STEP_SUMMARY"
+ echo "glibc=${GLIBC#GLIBC_}" >> "$GITHUB_OUTPUT"
+
+ - name: Attach to the release
+ if: inputs.attach
+ env:
+ GH_TOKEN: ${{ github.token }}
+ GH_REPO: ${{ github.repository }}
+ run: gh release upload "$TAG" isowind-linux-x86_64.tar.gz --clobber
- uses: actions/upload-artifact@v4
+ if: ${{ !inputs.attach }}
with:
name: isowind-linux-x86_64
path: isowind-linux-x86_64.tar.gz
+ retention-days: 7
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..1617a87
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,152 @@
+name: Release
+
+# A release, made when a branch named for one is merged into main: alpha-v1.0.1a makes "Alpha v1.0.1a" (tag
+# alpha-v1.0.1a), beta-v2.0 makes "Beta v2.0". The name is alpha or beta, then the version, with or without a "-" or
+# "_" between and a v before it, in any case (AlphaV1.0.2 does too). The release is drafted, the Windows zip and the
+# Linux package are built from the merge and put on it, and it is published, making its tag, once both are there with
+# the same multiplayer version hash. Until then it is a draft only the repository's writers see; if a build fails, run
+# this by hand with the same version to try again.
+on:
+ pull_request:
+ types: [closed]
+ branches: [main]
+ workflow_dispatch:
+ inputs:
+ version:
+ description: The release, as its branch is named (e.g. alpha-v1.0.1a)
+ required: true
+ ref:
+ description: "The commit or branch to build (blank: main as it is now)"
+ required: false
+ default: ''
+
+jobs:
+ prepare:
+ # Merged (not only closed), from one of this repository's branches, named alpha... or beta... (checked properly
+ # below; these comparisons ignore case)
+ if: >-
+ github.event_name == 'workflow_dispatch' ||
+ (github.event.pull_request.merged &&
+ github.event.pull_request.head.repo.full_name == github.repository &&
+ (startsWith(github.head_ref, 'alpha') || startsWith(github.head_ref, 'beta')))
+ runs-on: ubuntu-24.04
+ permissions:
+ contents: write
+ outputs:
+ tag: ${{ steps.version.outputs.tag }}
+ title: ${{ steps.version.outputs.title }}
+ ref: ${{ steps.version.outputs.ref }}
+ env:
+ GH_TOKEN: ${{ github.token }}
+ GH_REPO: ${{ github.repository }}
+ steps:
+ # The release's tag and title from the branch's name; the commit both builds are made from
+ - name: Version
+ id: version
+ env:
+ BRANCH: ${{ inputs.version || github.head_ref }}
+ REF: ${{ inputs.ref || github.event.pull_request.merge_commit_sha || github.sha }}
+ run: |
+ shopt -s nocasematch
+ if [[ ! $BRANCH =~ ^(alpha|beta)[-_]?v?([0-9]+(\.[0-9]+)*[a-z0-9]*)$ ]]; then
+ if [ "$GITHUB_EVENT_NAME" = workflow_dispatch ]; then
+ echo "::error::$BRANCH isn't a release's name: alpha or beta, then the version, e.g. alpha-v1.0.1a"
+ exit 1
+ fi
+ echo "::notice::$BRANCH isn't named for a release (e.g. alpha-v1.0.1a), so none is made"
+ exit 0
+ fi
+ STAGE=${BASH_REMATCH[1],,}
+ VERSION=${BASH_REMATCH[2],,}
+ # (a branch given by hand is taken as it is now, so both builds have the same commit)
+ SHA=$(gh api "repos/$GH_REPO/commits/$REF" --jq .sha)
+ echo "Release ${STAGE^} v$VERSION (tag $STAGE-v$VERSION) from $SHA"
+ {
+ echo "tag=$STAGE-v$VERSION"
+ echo "title=${STAGE^} v$VERSION"
+ echo "ref=$SHA"
+ } >> "$GITHUB_OUTPUT"
+
+ # A draft to put the builds on: a new one, or the one an earlier try left, pointed at this commit
+ - name: Draft
+ if: steps.version.outputs.tag != ''
+ env:
+ TAG: ${{ steps.version.outputs.tag }}
+ TITLE: ${{ steps.version.outputs.title }}
+ REF: ${{ steps.version.outputs.ref }}
+ run: |
+ DRAFT=$(gh release view "$TAG" --json isDraft --jq .isDraft 2>/dev/null || true)
+ if [ "$DRAFT" = false ]; then
+ echo "::error::$TITLE is already released: name the branch for a new version"
+ exit 1
+ fi
+ if [ -z "$DRAFT" ] && gh api "repos/$GH_REPO/git/ref/tags/$TAG" > /dev/null 2>&1; then
+ echo "::error::there is already a tag $TAG without a release: delete it or name the branch for a new version"
+ exit 1
+ fi
+ if [ "$DRAFT" = true ]; then
+ gh release edit "$TAG" --target "$REF" --title "$TITLE"
+ else
+ gh release create "$TAG" --draft --target "$REF" --title "$TITLE" --notes "Being built from $REF."
+ fi
+
+ linux:
+ needs: prepare
+ if: needs.prepare.outputs.tag != ''
+ permissions:
+ contents: write
+ uses: ./.github/workflows/linux.yml
+ with:
+ tag: ${{ needs.prepare.outputs.tag }}
+ ref: ${{ needs.prepare.outputs.ref }}
+ # (publish compares the two builds; a zip on the draft may be an earlier try's)
+ match_windows: false
+
+ windows:
+ needs: prepare
+ if: needs.prepare.outputs.tag != ''
+ permissions:
+ contents: write
+ uses: ./.github/workflows/windows.yml
+ with:
+ tag: ${{ needs.prepare.outputs.tag }}
+ ref: ${{ needs.prepare.outputs.ref }}
+
+ publish:
+ needs: [prepare, linux, windows]
+ if: needs.prepare.outputs.tag != ''
+ runs-on: ubuntu-24.04
+ permissions:
+ contents: write
+ env:
+ GH_TOKEN: ${{ github.token }}
+ GH_REPO: ${{ github.repository }}
+ TAG: ${{ needs.prepare.outputs.tag }}
+ TITLE: ${{ needs.prepare.outputs.title }}
+ REF: ${{ needs.prepare.outputs.ref }}
+ LINUX_HASH: ${{ needs.linux.outputs.hash }}
+ WINDOWS_HASH: ${{ needs.windows.outputs.hash }}
+ GLIBC: ${{ needs.linux.outputs.glibc }}
+ steps:
+ # Windows and Linux players only play together with the same hash; built from one commit, they have it
+ - name: Publish
+ run: |
+ if [ -z "$LINUX_HASH" ] || [ "$LINUX_HASH" != "$WINDOWS_HASH" ]; then
+ echo "::error::the builds' version hashes differ (Linux ${LINUX_HASH:-none}, Windows ${WINDOWS_HASH:-none})"
+ exit 1
+ fi
+ README="$GITHUB_SERVER_URL/$GH_REPO/blob/$REF/README.md"
+ {
+ echo "Isowind $TITLE."
+ echo
+ echo "- **Windows:** \`Isowind.zip\`. Unzip the whole folder somewhere you can write to and run \`Isowind.exe\`."
+ echo "- **Linux** (64-bit${GLIBC:+, glibc $GLIBC or newer}): \`isowind-linux-x86_64.tar.gz\`. Unpack it and"
+ echo " run \`./isowind.sh gui\` in the \`Isowind\` folder."
+ echo
+ echo "You need your own Morrowind, Game of the Year edition; the [dependencies]($README#dependencies) list the"
+ echo "rest, and [first time setup]($README#first-time-setup) the steps."
+ echo
+ echo "Players can only join a server running the same release (multiplayer version \`${LINUX_HASH:0:10}\`)."
+ } > "$RUNNER_TEMP/notes.md"
+ gh release edit "$TAG" --draft=false --notes-file "$RUNNER_TEMP/notes.md"
+ echo "Published $TITLE: $GITHUB_SERVER_URL/$GH_REPO/releases/tag/$TAG" >> "$GITHUB_STEP_SUMMARY"
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
new file mode 100644
index 0000000..050a55d
--- /dev/null
+++ b/.github/workflows/windows.yml
@@ -0,0 +1,103 @@
+name: Windows
+
+# The Windows zip for a release, Isowind.zip as isowind/windows/build.ps1 -NoMods makes it, put on the release.
+# release.yml runs it for every release; by hand (Actions > Windows > Run workflow, or gh workflow run windows.yml
+# -f tag=TAG) it builds the release's tag, or another commit given as ref, whichever branch it is run from.
+on:
+ workflow_dispatch:
+ inputs:
+ tag:
+ description: The release's tag
+ required: true
+ ref:
+ description: "The commit, branch or tag to build (blank: the release's tag)"
+ required: false
+ default: ''
+ attach:
+ description: Put the zip on the release (unticked, it is this run's artifact for a week)
+ type: boolean
+ default: true
+ workflow_call:
+ inputs:
+ tag:
+ type: string
+ required: true
+ ref:
+ type: string
+ default: ''
+ attach:
+ type: boolean
+ default: true
+ outputs:
+ hash:
+ description: The multiplayer version hash it was built with
+ value: ${{ jobs.build.outputs.hash }}
+
+jobs:
+ build:
+ # (Visual Studio 2022, which build.ps1 builds with by default)
+ runs-on: windows-2022
+ # The whole engine with link-time optimisation and no compiler cache: a few hours on a hosted runner
+ timeout-minutes: 360
+ # A newer run for the same release replaces one still going
+ concurrency:
+ group: windows-${{ inputs.tag }}
+ cancel-in-progress: true
+ # (to put the zip on the release)
+ permissions:
+ contents: write
+ outputs:
+ hash: ${{ steps.hash.outputs.hash }}
+ defaults:
+ run:
+ shell: pwsh
+ env:
+ TAG: ${{ inputs.tag }}
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ ref: ${{ inputs.ref || format('refs/tags/{0}', inputs.tag) }}
+ persist-credentials: false
+
+ # (the dependency packs and the build are large: if the build runs out of room, this says where there was some)
+ - name: Disk space
+ run: Get-PSDrive -PSProvider FileSystem | Format-Table Name, @{ n = 'Free (GB)'; e = { [math]::Round($_.Free / 1GB) } }
+
+ # CrabNet, OpenMW's dependencies, the engine, Isowind.exe and the package without the bundled mods, as a release
+ # is made by hand. What isn't source goes beside the repository: crabnet, and the package in dist\nomods
+ - name: Build
+ run: ./isowind/windows/build.ps1 -NoMods
+
+ - name: Disk space after
+ if: always()
+ run: Get-PSDrive -PSProvider FileSystem | Format-Table Name, @{ n = 'Free (GB)'; e = { [math]::Round($_.Free / 1GB) } }
+
+ # A server lets in only players with its own hash, so release.yml checks the Linux build has the same
+ - name: Check version hash
+ id: hash
+ run: |
+ $dist = Join-Path (Split-Path -Parent $env:GITHUB_WORKSPACE) 'dist\nomods'
+ $hash = (Get-Content (Join-Path $dist 'Isowind\engine\resources\version'))[1].Trim()
+ Write-Host "Version hash: $hash"
+ foreach ($exe in 'openmw.exe', 'tes3mp-server.exe') {
+ $text = [Text.Encoding]::ASCII.GetString([IO.File]::ReadAllBytes((Join-Path $dist "Isowind\engine\$exe")))
+ if (-not $text.Contains($hash)) { throw "$exe wasn't built with $hash" }
+ }
+ "hash=$hash" >> $env:GITHUB_OUTPUT
+ "zip=$(Join-Path $dist 'Isowind.zip')" >> $env:GITHUB_OUTPUT
+ "Multiplayer version hash: ``$hash``" >> $env:GITHUB_STEP_SUMMARY
+
+ - name: Attach to the release
+ if: inputs.attach
+ env:
+ GH_TOKEN: ${{ github.token }}
+ GH_REPO: ${{ github.repository }}
+ ZIP: ${{ steps.hash.outputs.zip }}
+ run: gh release upload $env:TAG $env:ZIP --clobber
+
+ - uses: actions/upload-artifact@v4
+ if: ${{ !inputs.attach }}
+ with:
+ name: isowind-windows
+ path: ${{ steps.hash.outputs.zip }}
+ retention-days: 7
diff --git a/README.md b/README.md
index aebe882..fff88f4 100644
--- a/README.md
+++ b/README.md
@@ -40,11 +40,50 @@ Isowind is a fork of OpenMW 0.51, with these parts:
* **The launcher** (`Isowind.exe`, or `isowind.sh` on Linux) picks the look and the character, joins or hosts
servers, and runs the engine with the right profile.
+Dependencies
+------------
+
+**To play on Windows**
+
+* 64-bit Windows 10 or 11.
+* Morrowind, the Game of the Year edition (with Tribunal and Bloodmoon), from Steam or GOG. It doesn't need to have
+ been run, or to have mods installed.
+* The [Microsoft Visual C++ Redistributable](https://aka.ms/vs/17/release/vc_redist.x64.exe) (2015-2022, x64), which
+ the engine is built with. Most PCs have it already, as many games install it; if the game says `MSVCP140.dll` or
+ `VCRUNTIME140.dll` is missing, install it.
+* .NET Framework 4, for `Isowind.exe`. Windows 10 and 11 come with it.
+* Graphics drivers with OpenGL, as for any OpenMW.
+
+**To play on Linux**
+
+* 64-bit Linux, about as new as Ubuntu 24.04 or newer: the package is built there, and each release's notes give the
+ oldest glibc it runs on. The package carries the engine's own libraries (OpenSceneGraph, MyGUI, Bullet, SDL, Boost
+ and the rest) and uses the system's C and C++ runtimes, graphics, X11 and font libraries, which every desktop
+ distribution has.
+* Morrowind, the Game of the Year edition, from Steam or GOG. A Steam copy is found by itself, in any of your Steam
+ libraries; a GOG one is pointed to once.
+* Python 3, for the pixel art look. If Pillow isn't installed, `isowind.sh` fetches it into the package's own
+ folder, which on Debian and Ubuntu needs `python3-venv`.
+* Python's Tk, for the launcher window (`python3-tk` on Debian and Ubuntu, `tk` on Arch and Fedora). The terminal
+ commands (`./isowind.sh`, `./isowind.sh join ADDRESS` and the rest) work without it.
+* Graphics drivers with OpenGL (Mesa, or your graphics card maker's).
+
+**To play online**
+
+* Morrowind, Tribunal and Bloodmoon, with no other mods on: a server only lets in players whose game files match
+ its own.
+* The same Isowind release as the server. Windows and Linux players of one release play together; players on
+ different releases can't.
+* To host, UDP port 25565 (or the port you choose) forwarded to your computer by your router.
+
+**To build it** yourself, see [Building on Windows](#building-on-windows) and
+[Building on Linux](#building-on-linux), which list what each needs.
+
First time setup
----------------
-**You need** Morrowind (the Game of the Year edition, from Steam or GOG) installed, and 64-bit Windows 10 or 11 or
-64-bit Linux (the Steam Deck works too). Morrowind doesn't need to be run first, or have mods installed.
+**You need** your own Morrowind and a 64-bit Windows or Linux PC; [Dependencies](#dependencies) has the full list.
+Morrowind doesn't need to be run first, or have mods installed.
1. **Download** `Isowind.zip` from the [Releases](https://github.com/pw-tf/isowind/releases) page and unzip the whole folder somewhere you can
write to, such as your Desktop or `D:\Games\Isowind` (not Program Files).
@@ -69,10 +108,12 @@ First time setup
You can open the OpenMW launcher again at any time with the *OpenMW Launcher* button in `Isowind.exe`, to change
the Morrowind folder, mods or other options. Your saves are shared with any normal OpenMW you have.
-**On Linux**, unpack the folder and run `./isowind.sh` from a terminal (or `./isowind.sh gui` for a launcher
-window). It finds Morrowind in Steam's usual places and sets OpenMW up by itself. If it can't, run it as
-`MORROWIND=/path/to/Morrowind ./isowind.sh`, giving the folder with `Data Files` in it. The pixel art look needs
-Python 3.
+**On Linux**, download `isowind-linux-x86_64.tar.gz` from the same page instead, unpack it
+(`tar -xzf isowind-linux-x86_64.tar.gz`) and run `./isowind.sh` in the `Isowind` folder from a terminal (or
+`./isowind.sh gui` for a launcher window). It is built on Ubuntu 24.04, so it wants a distribution about as new or
+newer. It finds Morrowind in your Steam libraries, those on other drives and a Steam Deck's SD card too, and
+sets OpenMW up by itself. If it can't, run it as `MORROWIND=/path/to/Morrowind ./isowind.sh`, giving the folder
+with `Data Files` in it. The pixel art look needs Python 3.
**Playing online:** keep to Morrowind, Tribunal and Bloodmoon, with no other mods on in the OpenMW launcher, because
a server only lets in players whose game files match its own. Type the server's address under *Multiplayer* in
@@ -87,7 +128,8 @@ Building on Windows
-------------------
`isowind\windows\build.ps1` does the whole chain: CrabNet (the multiplayer networking), OpenMW's dependency
-pack, the engine, `Isowind.exe` and the package.
+pack, the engine, `Isowind.exe` and the package. A release's zip is built the same way, by
+`.github/workflows/windows.yml` (see [Releases](#releases)).
You need, on the PATH:
@@ -158,8 +200,9 @@ If something goes wrong:
Building on Linux
-----------------
-The same steps as `.github/workflows/linux.yml`, which builds every push on Ubuntu 24.04. Everything that isn't
-source goes in `build-deps/` and `build/` inside the clone (git ignores both).
+The same steps as `.github/workflows/linux.yml`, which makes a release's Linux package on Ubuntu 24.04 (see
+[Releases](#releases)). Everything that isn't source goes in `build-deps/` and `build/` inside the clone (git ignores
+both).
**1. The libraries and tools.**
@@ -205,8 +248,8 @@ package: [linuxdeploy](https://github.com/linuxdeploy/linuxdeploy/releases) on t
**5. Play:** `build-deps/Isowind/isowind.sh` (or `isowind.sh gui` for the launcher window; `isowind.sh normal`,
`isowind.sh join ADDRESS` and `isowind.sh host` are the others, and `--controller` or `--no-controller` among the
-arguments says whether the menus are made for a controller). The first time it looks for Morrowind in Steam's usual
-places; otherwise run it as `MORROWIND=/path/to/Morrowind build-deps/Isowind/isowind.sh`, the folder with
+arguments says whether the menus are made for a controller). The first time it looks for Morrowind in Steam's
+libraries; otherwise run it as `MORROWIND=/path/to/Morrowind build-deps/Isowind/isowind.sh`, the folder with
`Data Files` and `Morrowind.ini`.
After changes, `cmake --build build -j$(nproc)` and `package.sh` again. Packaging into the same folder again keeps its
@@ -221,6 +264,33 @@ engine's folders (`apps`, `components`, `files`, `extern`, `cmake`, `CMakeLists.
the build runs, so build again after committing or pulling engine changes, even when the code on disk was already
built. Isowind's mod and server scripts don't count.
+Releases
+--------
+
+A release is made by merging a branch named for it into `main`: `alpha-v1.0.1a` makes *Alpha v1.0.1a*, and
+`beta-v2.0` makes *Beta v2.0*. The name is `alpha` or `beta`, then the version (git branch names can't have spaces).
+Open a pull request from the branch and merge it, and `.github/workflows/release.yml`:
+
+1. drafts the release, with a tag named like the branch (`alpha-v1.0.1a`);
+2. builds the Windows zip (`windows.yml`: `build.ps1 -NoMods` on Windows Server 2022, which takes a few hours) and the
+ Linux package (`linux.yml`, on Ubuntu 24.04) from the merge, and puts them on it;
+3. checks that both have the same multiplayer version hash, and publishes it, with notes on what each needs.
+
+Both packages are without the bundled mods and have the `source` folder. Until it is published, the release is a
+draft that only the repository's writers can see. If a build fails, fix it and run the workflow again by hand with
+the same version: *Actions > Release > Run workflow*, or `gh workflow run release.yml -f version=alpha-v1.0.1a`
+(add `-f ref=COMMIT` to build something other than `main` as it is). A version that is already out is refused, so
+the next one needs a new branch. Pull requests from other branches make no release.
+
+A release made before this can get a missing build by running `linux.yml` or `windows.yml` by hand with its tag.
+Alpha v1.0's Windows zip was built before the tag's last engine change was committed, so it has an older version
+hash, and its Linux package has to be given that hash (line 2 of the zip's `engine/resources/version`) to play with
+it:
+
+ gh workflow run linux.yml -f tag=alpha -f version_hash=f121921aec71faa8d63c3a6739b97f9d36048f68
+
+Untick *attach* (`-f attach=false`) to try a build first: the package is then the run's artifact, for a week.
+
Controls
--------