Damage Incorporated

Damage Incorporated's game data and modern Aleph One port live in this repository. The engine is under alephone/, with its upstream history through commit 4cd8346e retained. The Macintosh scenario is the port's runtime target.

The macOS arm64 game, app bundle, and headless regressions have been tested. The Windows x64 static ZIP has been built and run on Toriel, including desktop menus, settings, briefing, squad selection, gameplay, movement and map input. The Linux recipe has not yet been compiled or run on Linux. All three recipes use the software renderer and a C++17 compiler.

Gameplay fills standard and widescreen windows with proportional rendering. Wider viewports reveal more scenery horizontally while retaining the vertical field of view; the classic HUD stays centered and scales uniformly. Desktop fullscreen follows the active display, and hiding the HUD gives the world the entire viewport. Squad choices exclude teammates reserved for a later rendezvous.

Repository layout

• alephone/: engine source, DI compatibility code, build files, and tests.
• damage-original/Damage Incorporated/: canonical Macintosh game content.
• game-data-metadata/ and tools/game_data_metadata.py: resource forks, Finder metadata, hashes, and restoration of runtime data after cloning.
• alephone/damage-alephone/: scenario scripts, fonts, and the committed generated Physics Model; the data helper populates its retail files.
• windows-retail/: optional Windows comparison data, separate from the Macintosh scenario used by the port.
• ghidra-scripts/, tools/, and verification reports: extraction tools, reverse-engineering evidence, and regression results.
• alephone/local-sdl2/: genuine SDL 2.32.10 headers and prebuilt macOS arm64 libraries. The source-build recipe below rebuilds these for the local machine.

App bundles, object files, generated build caches, personal preferences and recordings, raw CD images, and Ghidra project databases are excluded.

Get the source and game data

Install the prerequisites in your platform section, then clone into a short path without spaces. Use your own Forgejo account when authentication is requested.

git clone https://forgejo.synchresis.net/quinn/DI.git
cd DI

The game content is included. Git does not preserve classic Mac resource forks, so run the data-restoration command in your platform section before starting the game. Native restoration on macOS recovers resource forks and Finder metadata. Portable restoration on Linux and Windows writes ordinary filename.rsrc sidecars beside the runtime data, including the resource-only Images and Dossiers files. Keep those sidecars and the Scripts directory together.

macOS

Setup

Install Apple's command-line developer tools with xcode-select --install, then install Homebrew. In Terminal:

brew install autoconf automake autoconf-archive pkgconf boost asio \
  sdl2_image sdl2_ttf zlib libpng libsndfile openal-soft \
  dylibbundler python imagemagick

Use genuine SDL2 for this port. SDL2-compat's SDL3 runtime caused Cocoa window lifecycle failures in the tested configuration. The following rebuilds the pinned SDL 2.32.10 release into the local dependency directory using SDL's supported command-line build. The verified Mac build used the included arm64 SDL2 library; this source-rebuild procedure has not yet been executed as part of the current validation. Run from the repository root:

di_root="$PWD"
di_engine="$di_root/alephone"
di_sdl_build="$(mktemp -d)"
curl -fL https://www.libsdl.org/release/SDL2-2.32.10.tar.gz \
  -o "$di_sdl_build/SDL2-2.32.10.tar.gz"
tar -xzf "$di_sdl_build/SDL2-2.32.10.tar.gz" -C "$di_sdl_build"
mkdir "$di_sdl_build/build"
cd "$di_sdl_build/build"
../SDL2-2.32.10/configure --prefix="$di_engine/local-sdl2" \
  --disable-static CC=clang CXX=clang++
make -j"$(sysctl -n hw.logicalcpu)"
make install
cd "$di_root"
python3 tools/game_data_metadata.py --restore
python3 tools/game_data_metadata.py --verify

Compile

Run in the same Terminal session. Always configure a fresh clone; copied Makefiles and config.status contain machine-specific paths.

cd "$di_engine"
autoreconf -fi
di_sdk="$(xcrun --sdk macosx --show-sdk-path)"
di_brew="$(brew --prefix)"
export PKG_CONFIG_PATH="$di_engine/local-sdl2/lib/pkgconfig:$(brew --prefix openal-soft)/lib/pkgconfig:$(brew --prefix zlib)/lib/pkgconfig:$di_brew/lib/pkgconfig"
export PKG_CONFIG="pkg-config --define-prefix"

./configure --disable-dependency-tracking --disable-opengl \
  CC=clang CXX=clang++ OBJCXX=clang++ \
  SDL_CFLAGS="$(sh local-sdl2/bin/sdl2-config --cflags)" \
  SDL_LIBS="$(sh local-sdl2/bin/sdl2-config --libs)" \
  CPPFLAGS="-isysroot $di_sdk -I$di_engine/local-sdl2/include -I$di_brew/include" \
  LDFLAGS="-isysroot $di_sdk -L$di_engine/local-sdl2/lib -L$di_brew/lib -Wl,-rpath,$di_engine/local-sdl2/lib" \
  CXXFLAGS="-std=c++17 -O2" OBJCXXFLAGS="-std=c++17 -O2" \
  LIBS="-framework Cocoa -framework CoreFoundation"
make -j"$(sysctl -n hw.logicalcpu)"
cd "$di_root"

Package on Apple Silicon

zsh "$di_engine/tools/package_damage_app.sh" "$di_root/Damage Incorporated.app"

The package contains all game data under Contents/Resources/DataFiles and non-system libraries under Contents/Frameworks. The script applies and checks an ad-hoc signature. It does not open the app.

The package script currently targets Apple Silicon with Homebrew under /opt/homebrew. The SDL and engine source-build commands also select the native architecture on Intel. Intel users can run the compiled engine directly as shown below; Intel app packaging needs the script's Homebrew search paths updated and has not been tested.

Run

Open Damage Incorporated.app in the repository root in Finder, or run:

open "$di_root/Damage Incorporated.app"

The self-contained bundle can be moved to Applications and run without the checkout or Homebrew installation.

For a development run on either Intel or Apple Silicon, use the compiled engine directly with the restored scenario directory. The scoped library path also directs SDL2_image and SDL2_ttf to genuine SDL2 in the local dependency directory, avoiding their Homebrew SDL2-compat/SDL3 dependencies:

DYLD_LIBRARY_PATH="$di_engine/local-sdl2/lib" \
  "$di_engine/Source_Files/alephone" "$di_engine/damage-alephone"

This direct run uses the local SDL2/Homebrew dependencies and the checkout's game data. Intel compilation and execution have not been verified on hardware.

Linux (Ubuntu 24.04 / Debian-style systems)

Setup

Install the development tools and libraries. The dependencies follow the upstream Aleph One build instructions and the repository's Linux CI setup.

sudo apt update
sudo apt install git build-essential autoconf automake autoconf-archive \
  pkg-config python3 libboost-all-dev libasio-dev libsdl2-dev \
  libsdl2-image-dev libsdl2-ttf-dev zlib1g-dev libpng-dev \
  libsndfile1-dev libopenal-dev libcurl4-gnutls-dev libzzip-dev \
  libminiupnpc-dev

Film export/video support can additionally use libvpx-dev libmatroska-dev libebml-dev libvorbis-dev libyuv-dev. GTK is not required by the basic SDL build; libgtk-3-dev and libdbus-1-dev are relevant if you separately build a GTK-based native-file-dialog backend. Optional libraries are detected by configure; see alephone/configure.ac for the available switches.

Prepare data, compile, and install

From the repository root, install into your own account without sudo make install:

di_root="$PWD"
python3 tools/game_data_metadata.py --restore --portable
python3 tools/game_data_metadata.py --verify --portable
cd alephone
autoreconf -fi
./configure --prefix="$HOME/.local" \
  --disable-dependency-tracking --disable-opengl \
  CC=gcc CXX=g++ CXXFLAGS="-std=c++17 -O2"
make -j"$(nproc)"
make install

Run

From a graphical desktop session:

"$HOME/.local/bin/alephone" "$di_root/alephone/damage-alephone"

The scenario argument selects DI directly. Keep the runtime data directory; make install installs the engine and its shared interface resources, not the retail game content.

Windows 10/11 x64 (MSYS2 UCRT64)

Setup

Install MSYS2 and use its UCRT64 terminal. UCRT64 is the currently recommended GCC environment; do not mix its libraries with another MSYS2 environment. See the official environment and Autotools documentation.

pacman -Syu

If the update asks you to close the terminal, close it, reopen UCRT64, and run pacman -Syu again. Then install:

pacman -S --needed base-devel git autoconf-archive \
  mingw-w64-ucrt-x86_64-toolchain mingw-w64-ucrt-x86_64-autotools \
  mingw-w64-ucrt-x86_64-pkgconf mingw-w64-ucrt-x86_64-python \
  mingw-w64-ucrt-x86_64-boost mingw-w64-ucrt-x86_64-asio \
  mingw-w64-ucrt-x86_64-SDL2 mingw-w64-ucrt-x86_64-SDL2_image \
  mingw-w64-ucrt-x86_64-SDL2_ttf mingw-w64-ucrt-x86_64-zlib \
  mingw-w64-ucrt-x86_64-libpng mingw-w64-ucrt-x86_64-libsndfile \
  mingw-w64-ucrt-x86_64-openal

Select the actual mingw-w64-ucrt-x86_64-SDL2 package, not the sdl2-compat provider. Clone into a short path such as C:\src\DI (/c/src/DI in MSYS2).

This recipe uses the engine's native MinGW Autotools target, which includes DI's compatibility source. The inherited Visual Studio and Xcode project files do not currently list that source; their upstream recipes need project updates before they can build this DI port.

Prepare data and compile

From the repository root in UCRT64:

di_root="$PWD"
python tools/game_data_metadata.py --restore --portable
python tools/game_data_metadata.py --verify --portable
cd alephone
export ACLOCAL_PATH="/usr/share/aclocal:$MINGW_PREFIX/share/aclocal"
export PKG_CONFIG_PATH="$MINGW_PREFIX/lib/pkgconfig:$MINGW_PREFIX/share/pkgconfig"
autoreconf -fi
./configure --host=x86_64-w64-mingw32 \
  --disable-dependency-tracking --disable-opengl \
  --with-boost="$MINGW_PREFIX" --with-boost-filesystem=boost_filesystem-mt \
  CC=gcc CXX=g++ CXXFLAGS="-std=c++17 -O2" \
  CPPFLAGS="-I$MINGW_PREFIX/include" LDFLAGS="-L$MINGW_PREFIX/lib" \
  LIBS="-lws2_32 -lmswsock"
make -j"$(nproc)"

The native Windows executable is alephone/Source_Files/AlephOne.exe.

Static Windows release (Forgejo Actions)

The repository's Windows Release workflow uses the instance's windows-2022 runner. It runs on pushes to main, windows-v* tags, or a manual dispatch. Upstream workflows nested inside alephone/.github/ are reference material; Forgejo executes the root .forgejo/workflows/windows-release.yml.

In UCRT64 with the prerequisites above installed, run from the repository root:

bash alephone/tools/build_windows_release.sh
python alephone/tools/verify_windows_release.py \
  dist/Damage-Incorporated-Windows-x64.zip --output dist/runtime-verification

The build uses static third-party libraries and GCC runtimes. The package step rejects any PE import outside a Windows system DLL allowlist. The ZIP contains Damage Incorporated.exe, all canonical scenario data and portable resource sidecars, Physics Model, Fonts.rsrc, original UI resources, Scripts, UI artwork, a fallback theme, notices, and a SHA-256 file manifest. Extract the whole folder and double-click the executable. Data lookup uses the executable's directory, so launch does not depend on the working directory or an installed MSYS2.

CI extracts the ZIP into a new path containing spaces, removes MSYS2 from PATH, and checks all 24 campaign maps, all eight multiplayer maps, all 200 briefing pages, the complete original audio and picture catalogs, mission-objective boundaries, and the 24-map extraction/transition chain through the epilogue. It also checks preferences, controls, PNG decoding, the classic font, and non-silent PCM from the OpenAL mixer. The ZIP is uploaded only after all 39 cases pass. CI uses dummy video/audio devices; the campaign fixture completes objectives and stages extraction rather than fighting each mission. Desktop input and presentation are also checked on Toriel. Speaker output, a complete combat playthrough, and multiplayer sessions are not certified by these checks. See retail content audit for inventory and edition details. Optional film export, HTTP downloads, UPnP and ZIP-scenario loading are disabled in this build; the included game data is unpacked.

Toriel's runner was restored on 2026-10-16 after its Windows re-image. It runs at boot without requiring an interactive login. See Windows runner maintenance for installed tools, paths, logs and task operations. Native build and release results are available in Forgejo Actions. Tagged builds publish a release only after runtime verification and all asset uploads succeed; an interrupted upload leaves a draft.

For a development run of the non-static recipe above, use UCRT64 so its DLLs remain on PATH:

./Source_Files/AlephOne.exe "$(cygpath -w "$di_root/alephone/damage-alephone")"

Headless verification on macOS

The Python verifiers run an explicitly supplied app bundle using SDL dummy video/audio, software rendering, disabled sound, and isolated user-data folders. They capture screenshots and JSON results with the executable SHA-256. Use fresh output directories and inspect the PNGs as well as the test results.

The Breath, viewport, and audio verifiers also use Pillow and NumPy. Install the verification dependencies in a local virtual environment before running the checks; this keeps Homebrew Python’s managed environment intact.

From the repository root:

python3 -m venv .venv
. .venv/bin/activate
python -m pip install -r alephone/tools/requirements-headless.txt
di_checks="$(mktemp -d)"
python3 alephone/tools/verify_damage_weapon_swaps.py \
  --app "$PWD/Damage Incorporated.app" --output "$di_checks/swaps" --jobs 2
python3 alephone/tools/verify_damage_death_inventory.py \
  --app "$PWD/Damage Incorporated.app" --output "$di_checks/death-inventory" --jobs 2
python3 alephone/tools/verify_damage_squad_selection.py \
  --app "$PWD/Damage Incorporated.app" --output "$di_checks/squad-selection" --jobs 2
python3 alephone/tools/verify_damage_viewport.py \
  --app "$PWD/Damage Incorporated.app" --output "$di_checks/viewports" --jobs 2

To profile complete game frames at a fixed output resolution, run the render performance verifier separately from other builds or tests:

python3 alephone/tools/verify_damage_render_performance.py \
  --app "$PWD/Damage Incorporated.app" --output "$di_checks/render-performance" \
  --resolution 1920x1080

It records world, HUD, blit, and presentation timings after warmup, along with pixel hashes and actual upload/present counts. Use --compare with a previous results.json to compare identical settings and screenshots. These are headless software rendering measurements, not native desktop compositor FPS.

To check teammate mental-state eligibility against the original campaign maps:

python3 alephone/tools/verify_damage_mental_states.py \
  --app "$PWD/Damage Incorporated.app" --output "$di_checks/mental-states" --jobs 2

This covers personality and map restrictions, deployment thresholds, real enemy kills, level transfers, and save/load. The time-boundary fixtures advance the eligibility clock and retain each map's authored flags. Campaign save version 6 records levels served separately from combat kills; older saves retain their explicit mental states and use conservative deployment counts because previous versions did not record the original game's counter correctly.

Other alephone/tools/verify_damage_*.py tools cover weapon fire, ammo HUD, mouse wheel, Breath, dead controls/click respawn, squad sprite scale, swinging doors, and explosions. Each provides --help. These bundle-based regression drivers have been exercised on macOS; they are not Linux/Windows test claims.

Stock Marathon replay compatibility

This engine targets Damage Incorporated's shape format: 64 collection slots and 6-bit collection/7-bit shape descriptors. Stock Marathon scenarios use 32 slots and 5-bit/8-bit descriptors. The inherited Marathon replay suites currently fail when run on the DI engine; they are not DI acceptance tests. Generic Marathon compatibility would require explicit format selection. See the current headless acceptance report for the complete test results and remaining verification gaps.

Data generation and licenses

The generated alephone/damage-alephone/Physics Model is committed and ready to use. alephone/tools/build_damage_physics.rb checks hashes of four previously extracted retail tables before converting them. Those original /tmp table inputs are absent from this repository, so extraction and regeneration are not currently reproducible from a clone alone.

Aleph One engine source is distributed under GNU GPL version 3; see alephone/COPYING. Third-party library notices are under alephone/Resources/Library Licenses/. Original Damage Incorporated game data retains its original copyright and rights; the engine's GPL does not relicense those assets.