Snatcher PSP

A native port of Snatcher (Konami, 1994, Sega CD, USA release) to the Sony PSP.

It is not an emulator: the game engine is rewritten in C for the PSP (script interpreter, scene / animation engine, VDP-style renderer, FM / PSG / PCM sound, shooting stages, saves), and the game's own data is converted from your own copy of the disc. The result plays the whole game on a PSP (or in PPSSPP) from the Memory Stick.

Read this first - what this repository is, and is not

• This repository contains no part of the game. No ROM, no disc image, no graphics, sound, music, voices, text, scripts or program code of Snatcher are included, and none may ever be added (see .gitignore).
• You need your own copy of Snatcher for the Sega CD (USA), as a disc you own, ripped by yourself to a BIN/CUE image. The tools in tools/ read that image and write the converted data to your own computer.
• The converted data, the files generated from the game's program code (src/spvm_table.h, src/gun_gen.c, src/fx_gen.c) and the finished game folder (EBOOT.PBP + data/) are derived from Konami's copyrighted work. Do not upload, share or redistribute them. Only the source code of this repository is free to use, and it is released into the public domain (see LICENSE: the Unlicense).
• This is an unofficial, non-commercial fan project. It is not affiliated with, authorised or endorsed by Konami, Sega or Sony. Snatcher, Konami and all related names, characters and artwork are the property of their respective owners.
• Nothing here is legal advice. Check what is allowed where you live.

What you need

The game	Snatcher (USA) for the Sega CD / Mega-CD as a BIN/CUE rip of your own disc: 1 data track (MODE1/2352) and the CD-audio tracks 2-21
A PSP with custom firmware (PRO, ARK-4 ...) that runs homebrew, or PPSSPP on PC / Android	tested on a PSP-3000 and in PPSSPP; the original PSP-1000 has not been tried (the game wants the extra RAM of the 2000 / 3000 models)
A Memory Stick	about 230 MB free
Linux or WSL2 (Ubuntu) on Windows	to run the build; the converters are Python
Python 3.9+	pip install -r requirements.txt (numpy, pillow, unicorn 2.x, capstone 5.x)
gcc	used for two small host tools (CD audio encoder, test renderer); on Windows it runs inside WSL
The PSP toolchain	pspdev (psp-cmake, psp-gcc, pack-pbp ...)

Step by step

1. Rip your disc

Make a BIN/CUE image of your own Snatcher disc with any CD ripper that can write the audio tracks (CUE sheet with one BIN or one file per track). The tools expect Snatcher (USA).cue and its data / audio tracks. For orientation, the data track of the USA disc has 56,014 sectors and there are 20 audio tracks (tracks 2 to 21).

2. Install the tools

# Python packages
pip install -r requirements.txt

# PSP toolchain: follow https://pspdev.github.io/installation.html, then
export PSPDEV=$HOME/pspdev            # wherever you installed it
export PATH=$PATH:$PSPDEV/bin

Windows (the route this was developed and tested on): install Python 3.9+ for Windows and the packages above, install WSL2 with Ubuntu and the PSP toolchain + gcc inside it. Run python tools/make_data.py ... from a normal Windows shell (the two small gcc helpers are called through wsl automatically) and bash tools/build.sh inside WSL (your drives appear as /mnt/c/...).

Linux: the same commands run natively (python3, gcc, psp-cmake); the host helpers then do not go through WSL. This route has not been tested by the author yet, please report problems.

3. Convert the game data

python tools/make_data.py "path/to/Snatcher (USA).cue"

This runs, in order: disc extraction -> script opcode table -> translation of two pieces of the game's own program code to C (shooting stages, scroll effects) -> scripts, font, speaker names -> scene graph and palette inheritance -> graphics / animation packs -> voice clips -> CD audio (ADPCM) -> capture of the original FM / PSG / PCM sound drivers (this is the slow step, about 1.5 hours; it runs the original sound code in a CPU emulator and records what it writes to the sound chips) -> start-up screens. python tools/make_data.py --list shows the steps; --only NAME runs one; --skip-sound-capture skips the capture for a quick test (then there is no music or effects).

Everything lands in extracted/, work/ and three generated files in src/. All of it is git-ignored.

4. Build

bash tools/build.sh

This compiles EBOOT.PBP and assembles the game folder dist/SnatcherPSP/ (EBOOT.PBP, README.txt, data/).

Optional: put your own ICON0.png (144x80), PIC1.png (480x272), PIC0.png, SND0.AT3 into pbp/ before building for the XMB icon and background. No artwork is included here, and the game's own art must not be committed.

5. Put it on the PSP

1. Copy the whole folder dist/SnatcherPSP to the Memory Stick as ms0:/PSP/GAME/SnatcherPSP (so that EBOOT.PBP and data/ are in that folder).
2. Start Snatcher PSP from Game -> Memory Stick in the XMB.
3. Saves, the settings file and a small timing log are written next to it (SnatcherPSP/saves/, settings.txt, perf.txt).

PPSSPP: copy the same folder to <PPSSPP memstick>/PSP/GAME/SnatcherPSP (PC: the memstick folder next to the program, or Documents/PPSSPP), or simply open EBOOT.PBP with File -> Load. The hardware renderer is fine for playing.

Controls

Button
D-pad up / down	choose in menus
CROSS	confirm, turn the page, hold = type fast
CIRCLE	confirm in dialogue, back / cancel in menus
START	skip the opening, confirm
R (hold)	fast-forward (dialogue, fades, cutscenes)
SELECT	picture size: 4:3 / pixel aspect / 1:1 / stretch (press and release it alone)
L	smooth / sharp picture (press and release it alone)
L + START	quick save (any time the story runs)
L + SELECT	quick load
Shooting stages	analog nub moves the crosshair (or the D-pad: OPTIONS > CONTROLS), SQUARE draws / holsters, CROSS fires
Title screen: L + TRIANGLE	chapter select (the game's own debug menu): jump to any act or section

OPTIONS (title screen > NEW GAME) has CONTROLS, SOUND MODE (stereo / mono) and AUDIO MIX (balanced / original / music low). Your choices are remembered. The game saves where the original does (the SAVE entries of the Metal Gear menu, 4 slots; CONTINUE on the title screen loads one).

How it works, in short

• Converters (tools/, Python) take the disc apart and write compact, PSP-friendly files: scene packs (.sgp: the game's compressed graphics, scene tables and animation scripts, kept as the original bytes), the script files, voice and PCM clips, the CD audio as IMA-ADPCM streams, and logs of what the original sound drivers write to the YM2612 / PSG / RF5C164 chips.
• Engine (src/, C for the PSP): spvm.c is the game's script interpreter, anim.c its object / animation engine, vdp.c a software renderer for Mega Drive style planes and sprites (drawn to the PSP's GE as a texture), snd.c / ym2612.c / psg.c / rf5c.c the sound chips, audio.c the PSP mixer, game.c the flow (title, opening, game, ending, menus, saves). gun.c and fx.c run two pieces of the original program code, translated to C by tools/m68k2c.py and tools/m68k2c_main.py (the shooting stages and the scroll / raster effects).
• Verification: tools/scdsim.py is a reverse-engineering harness that runs the original 68000 programs of your disc image under the unicorn CPU emulator. The port is checked against it: script interpreter statement by statement, scene entries pixel by pixel, the scroll engine scanline by scanline, the palette queue, the sound drivers. It is a tool for development, not part of the game.

See docs/TECHNICAL.md for more.

Testing (optional)

python tests/run_tests.py              # quick checks of the converters and the interpreter (needs the extracted disc)
python tests/run_tests.py --oracle     # + boots the original code for about a minute
python tools/game_check.py FRAMES DUMP_EVERY [PRESS_EVERY] [--start]   # runs the build headless in PPSSPP and dumps frames
python tools/sgp_check.py run --all    # compares the on-device renderer with the PC reference for every scene entry

game_check.py and sgp_check.py drive PPSSPP on Windows (PPSSPP_EXE and PPSSPP_MEMSTICK environment variables). They switch PPSSPP to the software renderer for the duration of a test and put your setting back afterwards.

Known limits

• Sound is a recreation of the original's FM / PSG / PCM chips and CD tracks, judged by ear; it is not bit exact.
• The ending's fades and a few animation phases are close to, but not exactly, the original's.
• Voiced lines play without text, as in the original (the game data has no transcripts of the clips).
• Not tested on the PSP-1000.
• The sound capture records what the original drivers write while they run a list of sounds one after the other; a few sound effects come out slightly different depending on what was played just before. tools/audiocap.py runs the full list in a fixed order, so your run is repeatable, but it need not match the author's byte for byte.

Contributing

Pull requests are welcome for the source code. Never commit anything derived from the game (data, screenshots of whole screens are fine in issues but not in the repository, dumps, disassembly listings, extracted text or sound). .gitignore already excludes the usual places; please check git status before every commit.

License

The source code in this repository is released into the public domain under the Unlicense: use it, change it, sell it, no attribution needed. That covers this code only, never the game or anything made from your copy of it.

Credits

Snatcher was created by Hideo Kojima and produced by Konami. This port is a fan project that needs, and respects, the original. Built with the pspdev toolchain; the analysis tools use unicorn and capstone. PPSSPP is used for testing.