# SOCOM Unzipped -- redotcom, the web project (map viewer and reCOM mode)

> A browser recreation of SOCOM II (PS2, US): the multiplayer maps decoded from the user's own disc and drawn with
> three.js, a playable walk mode and a respawn multiplayer round, every value read from the game's data or its
> decompiled code. The repository ships no game data. This file is generated by `web/redotcom/tools/build-corpus.ts`.

Confidence in the records: `proven` = measured on the disc or a console frame and pinned by a test; `reading` =
read from the decompilation or reCOM, not yet measured on a console; `placeholder` = no source found, a named
constant (`*_PLACEHOLDER`) stands in. Code and test paths are relative to `web/redotcom/`. A source note `NN` is
`web/redotcom/docs/research/NN-*.md`; `repo/NN` is the repository's own `docs/research/NN-*.md`.

## Documents

- [README](../../README.md): what the viewer is, how to run it, the controls, what the picture is made of
- [Architecture](../ARCHITECTURE.md): the packages, their boundaries, what is SOCOM-specific, adapting it to another PS2 game
- [Data sources](../DATA_SOURCES.md): every kind of data, where it comes from, the tool that reads it, how it was verified
- [How it is built](../PROCESS.md): the stack and the development process, ground truth, rulings, agents
- [Contributing](../../CONTRIBUTING.md): conventions for the web project
- [records.jsonl](records.jsonl): the curated findings (schema in `web/redotcom/tools/corpus.ts`, `CorpusRecord`)
- [sections.jsonl](sections.jsonl): every numbered section of every research note, with the functions it cites

## Research notes

- [71](../research/71-browser-recreation-scoping.md): Browser recreation of SOCOM II: scoping, and the GPU-in-the-browser landscape (2026-09-20) (18 sections)
- [72](../research/72-mp-map-archive-anatomy.md): Multiplayer map archives at the byte level: what a browser viewer must implement (2026-09-20) (8 sections)
- [75](../research/75-aimaps-mps.md): `AIMAPS.MPS`: the AI map file read to its last byte, and the spawn slots in it (2026-09-28) (19 sections)
- [77](../research/77-motion-format.md): The skeletal motion format (`MOTION_S.ZAR`, `MOTION_P.ZAR`) and the zAnim command archives (12 sections)
- [78](../research/78-character-mesh-and-skeleton.md): The character mesh, its skeleton and its gear: `CMesh`/`CSubMesh`, `CLIB_GEO`, `character.rdr` (2026-09-28) (24 sections)
- [79](../research/79-weapon-table-and-fire-point.md): The weapon table, the M4A1 SD's model, the fire point and the recoil: what the bodies on hand show (2026-09-28) (16 sections)
- [80](../research/80-the-jump.md): The jump, the landings and the locomotion blend: how SOCOM II plays the SEAL's clips (2026-09-28) (19 sections)
- [81](../research/81-sounds.md): The walk's sounds: the 989snd banks on the disc, how the game names them, and when it plays a step, a round, a jump and a landing (2026-09-28) (14 sections)
- [82](../research/82-map-fidelity-audit.md): Map fidelity audit: the viewer against the console's own frames (2026-09-28) (15 sections)
- [83](../research/83-look-and-aim.md): The look and the aim: the pad's law, the body and the camera, the scope, the shake, the bob (8 sections)
- [84](../research/84-accuracy-and-recoil.md): Accuracy and recoil: the reticle's size, its climb, the cone, the fire modes, the zoom and the scope (2026-09-28) (19 sections)
- [85](../research/85-grenades.md): The frag grenade: the hold, the throw, the flight, the fuse and the explosion (2026-09-28) (30 sections)
- [86](../research/86-traversal.md): Traversal: the ladder, the climb, the peek, the water (40 sections)
- [87](../research/87-hud.md): SOCOM II's in-game HUD: every element, its bitmap, place, colour and driver (2026-09-28) (13 sections)
- [88](../research/88-feel-parity.md): Feel parity: the walk driven by script, number by number against the console (11 sections)
- [89](../research/89-effects.md): The gunplay's effects: the zAnim effect commands, the casing, the particles, the impacts and the marks (2026-09-28) (16 sections)
- [90](../research/90-playtest-2026-09-28.md): Playtest, 2026-09-28: the walk played as the owner plays it, on Frostfire, Desert Glory and Crossroads (15 sections)
- [91](../research/91-the-round.md): The round: damage, death, respawn, teams, score, names (web sprint 3, M1) (45 sections)
- [92](../research/92-doors.md): Doors: what the action button does to a door, and the viewer's (2026-09-29) (6 sections)
- [93](../research/93-data-hardening.md): Data hardening: what the parsers refuse in a dropped image, and why (2026-09-29) (4 sections)

## Records

### accuracy

- `accuracy.bloom` (reading): How does the reticle open and close?
- `accuracy.recoil-cone` (reading): What is the recoil, and where does a round go?
- `accuracy.fire-modes` (reading): What are the fire modes?
- `accuracy.zoom` (reading): What views and zoom levels exist?
- `accuracy.magazines` (reading): How do magazines and reloads work?
- `accuracy.penetration` (reading): What does a round go through?

### archive

- `archive.zdb-zar` (proven): How are the disc's map archives laid out?
- `archive.rdr` (proven): What is a compiled .rdr and where does the port read them?
- `archive.iso` (reading): How does a player give the page their disc without uploading it?

### character

- `character.mesh` (proven): How is the SEAL's body stored and drawn?

### effects

- `effects.muzzle-casing` (proven): What does a round show at the rifle?
- `effects.impacts-marks` (proven): What does a round show where it lands?

### grenades

- `grenades.throw` (reading): How is a grenade thrown?
- `grenades.flight` (reading): How does a grenade fly, bounce and explode?
- `grenades.arc` (reading): What is the yellow throw arc?

### gs

- `maps.textures` (proven): How are textures and palettes decoded, and how is each texture's GS state known?

### hud

- `hud.layout` (proven): Where does the HUD's layout come from?
- `hud.scoreboard` (reading): How is the round's scoreboard laid out and sorted?
- `hud.tactical-map` (reading): What is the tactical map drawn from?

### look

- `look.stick` (proven): How does the look stick turn the SEAL?

### maps

- `maps.index` (proven): Which archives does the port read from the disc, and which tool copies them for development?
- `maps.shading` (proven): How is a map shaded to match the console?
- `maps.console-compare` (proven): How was the map picture checked against the console?
- `maps.fog-lod-detail` (proven): Where do fog, LOD and the detail textures come from?

### mesh

- `maps.mesh-vif` (proven): How is map geometry stored and decoded?

### motion

- `motion.clip-format` (proven): What is the skeletal motion format?
- `motion.zanim` (proven): What are the zAnim archives?

### net

- `net.sim-boundary` (proven): What code do the page and the server share?
- `net.transport` (proven): How do the page and the match talk?
- `net.authority` (reading): Who decided hits in the original, and who decides them in the port?

### platform

- `browser.feasibility` (reading): Why a reimplementation in TypeScript rather than the recompiled game in WebAssembly?

### process

- `process.ground-truth` (proven): What counts as ground truth for a value in the web port?
- `process.placeholders` (proven): How is a value with no source marked?
- `process.rulings` (proven): How do the owner's play-tests change the port?
- `process.release-sweep` (proven): How is a build checked across every map before release?
- `process.feel-parity` (proven): How is the walk's feel compared with the console number by number?

### round

- `round.health-armour` (reading): How much health and armour does a player have?
- `round.bullet-damage` (reading): How much damage does a bullet do?
- `round.explosions` (reading): How do explosions and falls damage a player?
- `round.respawn` (reading): When and where does a player respawn?
- `round.teams` (reading): How are teams assigned?
- `round.scoring` (reading): How is the score kept?
- `round.match` (reading): What is a match on the port's server?
- `round.names` (reading): What names may a player use?
- `round.vote-kick` (reading): Can players be removed?

### scene

- `maps.scene-graph` (proven): How are models placed in a map?
- `maps.collision` (proven): Where does collision come from and how is the floor found?
- `maps.grid` (proven): What is the engine's grid and what uses it?
- `maps.spawns` (proven): Where are the spawn points?

### sound

- `sound.banks` (proven): Where are the sounds and how are they decoded?
- `sound.footsteps` (reading): When is a footstep played, and which one?
- `sound.reverb` (reading): Where does the reverb come from?

### traversal

- `traversal.appflags` (proven): How does the game know a ladder or a climbable object?
- `traversal.water` (reading): What happens in water?
- `traversal.jump-slope` (reading): Why did a jump up a slope clip through the ground, and what fixed it?

### walk

- `walk.speeds` (reading): How fast does the SEAL move, and how does the stick ramp?
- `walk.jump` (reading): How does the jump work?
- `walk.locomotion` (reading): How are the locomotion clips picked and blended?
- `walk.camera` (proven): Where is the third-person camera?

### weapons

- `weapons.record` (proven): Where are the weapon numbers?
- `weapons.model-firepoint` (reading): How are weapon models drawn and where does a round leave?
