# Date A Live: Rinne Utopia / recompiled

Static recompilation of the PS3 title *デート・ア・ライブ 凜祢ユートピア* (BLJM61048) for
Windows and for macOS on Apple Silicon, built from your own copy of the game.

This repository contains no game data, executables, keys or decrypted binaries (see
[Licence and legal notice](#licence-and-legal-notice)). You supply your own `EBOOT.BIN` (see
[Game files](#game-files)).

## Status

The game boots, plays its intro movies with sound and reaches the title screen. NEW GAME plays the
opening movie and then the first story scenes, with their pictures, music and the message window
(speaker name and dialogue text). It can be played with the keyboard, an Xbox-family gamepad or a
DualShock 4. How far beyond these first scenes it works has not been checked. See
[Status](docs/status.md).

The macOS build runs the same code. It draws with Vulkan on top of Metal, plays sound through
CoreAudio and reads gamepads with GameController.framework.

## Requirements

### Windows (x64)

- Visual Studio 2026 with the Windows SDK
- LLVM (clang, clang++, lld)
- CMake 3.29 or newer
- Ninja
- Python 3.10 or newer
- git
- Vulkan SDK, and a GPU and driver with Vulkan 1.3
- PowerShell 7 with the `VSSetup` module

Put the LLVM `bin` directory on `PATH`, and install the PowerShell module with
`Install-Module VSSetup -Scope CurrentUser`. The Vulkan SDK installer sets the `VULKAN_SDK`
environment variable, which the build needs. FFmpeg and GameInput are fetched by scripts in
[Building](#building).

### macOS (Apple Silicon)

- Xcode Command Line Tools
- Homebrew LLVM
- CMake 3.29 or newer
- Ninja
- Python 3.10 or newer
- FFmpeg
- git
- LunarG Vulkan SDK for macOS

Install the Command Line Tools with `xcode-select --install`, then [Homebrew](https://brew.sh), then
the rest with `brew install llvm cmake ninja python ffmpeg`. Install the Vulkan SDK with its
"System Global Installation" component. Intel Macs are not supported.

### Game files

`EBOOT.BIN` from your own dump of BLJM61048, at `<game-dir>/PS3_GAME/USRDIR/EBOOT.BIN`. `<game-dir>`
is the directory that contains `PS3_GAME`. RPCS3 is not needed.

## Building

Run every command from the repository root.

### Windows

1. Initialise the submodules:

   ```powershell
   git submodule update --init
   ```

2. Fetch FFmpeg and GameInput, and install the GameInput runtime (as administrator):

   ```powershell
   pwsh -NoProfile -File tools/fetch-ffmpeg.ps1
   pwsh -NoProfile -File tools/fetch-gameinput.ps1
   msiexec /i generated\deps\gameinput\<version>\redist\GameInputRedist.msi
   ```

3. Decrypt `EBOOT.BIN` into `generated/inputs/EBOOT.elf`:

   ```powershell
   pwsh -NoProfile -File tools/build.ps1 -Preset release -EbootBin <game-dir>/PS3_GAME/USRDIR/EBOOT.BIN
   ```

4. Recompile the executable into C:

   ```powershell
   python tools/ps3tool.py emit generated/inputs/EBOOT.elf --out generated/ppu
   ```

5. Build the game:

   ```powershell
   pwsh -NoProfile -File tools/build.ps1 -Preset release -GeneratedDir generated/ppu -GameDir <game-dir>
   ```

The game is `build/release/bin/dal_game.exe`.

### macOS

1. Initialise the submodules:

   ```sh
   git submodule update --init
   ```

2. Decrypt `EBOOT.BIN` into `generated/inputs/EBOOT.elf`:

   ```sh
   tools/build.sh --preset macos-release --eboot-bin <game-dir>/PS3_GAME/USRDIR/EBOOT.BIN
   ```

3. Recompile the executable into C:

   ```sh
   python3 tools/ps3tool.py emit generated/inputs/EBOOT.elf --out generated/ppu
   ```

4. Build the game:

   ```sh
   tools/build.sh --preset macos-release --generated-dir generated/ppu --game-dir <game-dir>
   ```

The game is `build/macos-release/bin/dal_game`. It loads Homebrew's FFmpeg libraries from where they
are installed (see [Movies](docs/movies.md#ffmpeg-on-macos)).

### Notes

- **Network.** The first configuration with `-EbootBin` (`--eboot-bin`) downloads two RPCS3 source
  files that hold the decryption keys. To build offline, name the `rpcs3/Crypto` directory of a local
  RPCS3 checkout with `-Rpcs3CryptoDir` (`--rpcs3-crypto-dir`). See [Keys](docs/building.md#keys).
- **Checks.** `EBOOT.BIN` and the decrypted `EBOOT.elf` are checked against the SHA-256 in
  `config/target.json`, and the build log shows `matches the pin`. A file that does not match, such
  as a game update's `EBOOT.BIN`, is refused and nothing is written. The supported `EBOOT.elf` has
  the SHA-256 `8b4362daac30cad2e597fdd30e6540a3226da88760dbded4b7c14890f8a88348`.
- **Later builds.** The CMake cache keeps the build parameters, so the last step does not repeat
  `-EbootBin`.
- **GameInput runtime.** `<version>` is the directory under `generated/deps/gameinput`. Without the
  runtime, gamepads are disabled and the keyboard still works.
- **Python on macOS.** The `python3` of macOS (`/usr/bin/python3`) can be 3.9; check
  `python3 --version` and use Homebrew's if needed.
- **Compiler on macOS.** Apple's clang is refused; the build uses `$(brew --prefix llvm)`. Another
  LLVM install can be named with `--llvm-prefix`. The first line of the build output shows which
  clang is used.
- **Presets on macOS.** `tools/build.sh` defaults to `macos-debug`, which is slower; use
  `macos-release` to play.
- **Decrypted files.** `generated/inputs/` is git-ignored. Do not share its contents.

Every build parameter, the CMake variables and the test builds are in [Building](docs/building.md);
the macOS-specific parts are in [Building on macOS](docs/building.md#building-on-macos).

## Running the game

Windows:

```powershell
build/release/bin/dal_game.exe
```

macOS:

```sh
build/macos-release/bin/dal_game
```

The build writes `config.json` next to the executable with the game directory and the decrypted
executable, so no arguments are needed. Closing the window ends the run (macOS: also `Cmd+Q`).

Game data and saves are in `build/<preset>/hdd`. `-Clean` (`--clean`) deletes them with the rest of
the build directory.

Notes:

- **No `config.json`.** The file is written only by a build with `-GameDir`, and only when it does not
  exist yet. Without it, name the paths:
  `dal_game --game-dir <game-dir> --elf generated/inputs/EBOOT.elf`. Without `--elf`, the game looks
  for `<game-dir>/PS3_GAME/USRDIR/EBOOT.elf`.
- **Where `config.json` is read.** From the working directory, or when there is none, from the folder
  of the executable. `--config <file>` names another file and `--no-config` reads none. The command
  line wins over the file.
- **macOS.** Start the game from a logged-in session; the window needs the window server. Over SSH
  only `--no-window` works.

Every option of `dal_game` and the `config.json` format are in
[`dal_game` options](docs/runtime-options.md); `config/dal_game.example.json` is an example.

### Keyboard

The keyboard is the pad on port 0. The keys are physical key positions, so the layout stays in
place on AZERTY and QWERTZ keyboards:

| Keys | Pad |
| --- | --- |
| Arrow keys (not the numpad) | D-pad |
| `Z` / `X` / `S` / `D` | Cross / Circle / Square / Triangle |
| `W` / `E` / `R` / `U` | L1 / L2 / R1 / R2 |
| `1` / `3` (main row) | L3 / R3 |
| `V` / `C` | Start / Select |
| `F1` | Show or hide the debug overlay (not a pad button) |
| `Tab` (hold) | Run the game faster (not a pad button) |

- The game confirms with Circle (the `X` key), which also skips the notice screen and the intro
  movies.
- If keys do nothing, click the window to give it keyboard focus.
- On macOS, keys pressed with `Cmd` are system shortcuts and never pad input. Keys without a PC scan
  code (`Fn`, media keys, `Eisu`, `Kana`) do nothing.

The overlay is described in [Debug overlay](docs/runtime.md#debug-overlay).

### Gamepad

- **Windows.** Xbox-family gamepads and the DualShock 4 (second model) work through GameInput; they
  need the GameInput runtime from the build steps. Quit Steam, or turn off its PlayStation controller
  support, before using a DualShock 4.
- **macOS.** Controllers with an extended gamepad profile work through GameController.framework,
  with the same mapping, and vibrate through Core Haptics when they support it. Input reaches the
  game only while its window is the active one.

The mapping, the dead zone and troubleshooting are in [Input](docs/input.md).

## Documentation

Development material is under [`docs/`](docs/README.md): build and run parameters, tests, the
analysis tools, function recovery, the C emitter, runtime internals, the virtual file system,
rendering, movies, audio, gamepad input, the repository layout, and a guide for applying the method
to other PS3 games.

## Licence and legal notice

The code in this repository is licensed under 0BSD; see [LICENSE](LICENSE). Third-party components keep
their own licences; see [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).

This is an unofficial project. It is not affiliated with, authorised by or endorsed by any rights
holder of the game.

*デート・ア・ライブ*, *デート・ア・ライブ 凜祢ユートピア* and all related names and logos are
trademarks or registered trademarks of their respective owners. They are used here only to
identify the game and platform this project works with.

No game files, keys or other copyrighted game data are included in this repository, and none
will be provided. Please do not ask for them.