# Mario Party 2: Recompiled

> **Made with AI.** Almost all of the code, documentation and tests in this repo were written by AI agents
> (Claude), directed and play-tested by a person. None of it is offered to the upstream projects it builds on, which
> don't take AI-written code.

A native PC port of the N64 *Mario Party 2* (USA), made by static recompilation
([N64Recomp](https://github.com/N64Recomp/N64Recomp) + [N64ModernRuntime](https://github.com/N64Recomp/N64ModernRuntime) +
[RT64](https://github.com/rt64/rt64), with [RecompFrontend](https://github.com/N64Recomp/RecompFrontend)'s launcher
and menus): the game's own MIPS code translated to C and run natively, with RT64 drawing it. The symbols come from the
[mariopartyrd/marioparty2](https://github.com/mariopartyrd/marioparty2) decompilation. It is not an emulator. It is built
the way [Mario Party: Recompiled](https://github.com/n64hub/mario-party-recomp) is, on the same engine work: Hudson's
process scheduler runs the same way, from the code the Mario Party recomps share
([mario-party-engine](https://github.com/n64hub/mario-party-engine)).

The repo holds no ROM, no asset from the game and no data extracted from it: you supply your own ROM, and nothing in
git or CI is made from one except the symbol names and addresses in `syms/`.

**Status:** plays its menus, its six boards and its minigames, on the desktop and in a browser, its boards
interpolated to the display's rate as its menus and minigames are, and drawn at the window's size and shape (RT64's
Framerate Display, Resolution Auto and Aspect Ratio Expand, with each board's view and background taken to the
window's edges and the players' panels at its corners). The game's process scheduler, which switches between dozens of small processes with its own
setjmp and longjmp, runs each process on a thread of its own, one at a time ([docs/processes.md](docs/processes.md)).
The browser's page is built from your ROM ([docs/web.md](docs/web.md)).

## The ROM

*Mario Party 2* (USA), as a big-endian `.z64` of 32 MiB with SHA-1 `166eda1c05670d337e2c3f15a5db528ae1e5d6e3`. Other
regions are not supported.

## Getting it

Releases for Windows (a zip: unzip it and run `MarioParty2Recompiled.exe` from that folder) and Linux on x86-64 (a
`.tar.gz`: extract it and run `MarioParty2Recompiled` in that folder) are on the
[Releases page](https://github.com/n64hub/mario-party-2-recomp/releases), without the ROM: pick yours with Load ROM.
The Linux build needs glibc 2.35 or newer (Ubuntu 22.04, Debian 12 or later), a Vulkan driver, and GTK 3 and FreeType,
which desktop distributions have; it brings its own SDL2. Or build it as below.

## Building

You need that ROM at `roms/marioparty2.us.z64`. On Windows: LLVM's clang-cl, CMake 3.31 and Ninja, and a clang with a
MIPS backend plus ld.lld for `patches/`. On Linux: `clang lld libsdl2-dev libgtk-3-dev libfreetype-dev`, CMake 3.31
and Ninja.

From the repo's root in a bash shell:

```sh
git -c core.longpaths=true submodule update --init --recursive   # paths past Windows' 260 characters
bash tools/recompile.sh -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl   # the game's code as C
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=RelWithDebInfo \
      -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl \
      -DPATCHES_C_COMPILER=<MIPS clang> -DPATCHES_LD=<ld.lld>
ninja -C build MarioParty2Recompiled
```

With [ccache](https://ccache.dev) on `PATH` every compile goes through it, so a new build dir or another checkout
of the same code compiles only what changed since the last build on that computer (CMakeLists.txt says how).

`tools/recompile.sh` builds N64Recomp from the submodule the first time, then translates the game. Run
`build/MarioParty2Recompiled.exe` from the repo's root, pick the ROM with Load ROM, then Start Game.

The symbols in `syms/` are made from the decomp's own build of the game (`tools/build_decomp.sh`, which needs the ROM
and Docker, then `tools/gen_syms.sh`). They only change when `lib/marioparty2` moves.

A release is built by `tools/release.sh`: `windows` (Git Bash) and `linux` (Linux with Docker) build and pack its two
archives into `out/` from the same commit of `main`, `boot windows` and `boot linux` boot each from a new folder, as a
player first runs it, and `publish` publishes them as the GitHub release `v<version_string>` (`src/main/main.cpp`)
with `releases/v<version>.md` as its notes, `--prerelease` marking it a prerelease (the script's header says more).

## Controls

A gamepad, or the keyboard.

Up to four people play four players, each with a pad of their own or the keyboard: each pad plays a player of its own
with no setup, in the order the pads were plugged in, and the keyboard plays player 1 beside the first pad. To choose
who plays which, open the menu (Esc), and on Controls press Assign players, then a button on each player's pad (or a
key) in the players' order, and Confirm; after, the keyboard stays player 1's unless a player was given it. As on a
console, a player without a pad is the computer's, and who else the computer plays is the game's own setting.

## Options

The menu (Esc) holds the settings, and its General tab ends with two for the boards, the same in each of the Mario
Party recomps. Each is Original by default, which plays as the console does:

- **Board Movement**, Fast: the players walk from space to space in half the time, as Mario Party 3's own Fast walking
  speed does, whatever the walking speed in a game's pause menu says.
- **Map Scrolling**, Fast: the view moves twice as fast when you look around a board's map.

## Mods

The desktop build loads N64Recomp mods (`.nrm`) made for it (`game_id = "marioparty2"`): in the launcher, before Start
Game, open Mods and press Install Mods, or drop the file onto the window, or put it in the `mods` folder
(`%LOCALAPPDATA%\MarioParty2Recompiled\mods` on Windows, `~/.config/MarioParty2Recompiled/mods` on Linux), and turn it
on in the Mods list. The page in a browser loads no mods. How to make one, and what a mod can change:
[mario-party-engine's docs/mods.md](https://github.com/n64hub/mario-party-engine/blob/main/docs/mods.md).

## License

GPL-3.0 (`LICENSE`), as the recompilations it follows. The decomp in `lib/marioparty2` is its own project.