wasm: read and set the party position #483

Closed
opened 2026-11-02 21:45:19 +01:00 by jqueuniet · 2 comments
Owner

SaveFileFull::party_position and set_party_position exist; SaveGame exposes neither.

Wanted: SaveGame.partyPosition() → {map, x, y, dir} and SaveGame.setPartyPosition(map, x, y, dir), throwing on a cell the party cannot stand on (wall, closed door, pit…), so callers need no walkability rules of their own. The web editor moves the party by clicking a cell of the live map, on any level.

Facing caveat from set_party_position: a new dir does not rotate the rank layout as an in-game turn does. A facing picker needs the ranks rotated with it, or the binding should rotate them.

`SaveFileFull::party_position` and `set_party_position` exist; `SaveGame` exposes neither. Wanted: `SaveGame.partyPosition()` → `{map, x, y, dir}` and `SaveGame.setPartyPosition(map, x, y, dir)`, throwing on a cell the party cannot stand on (wall, closed door, pit…), so callers need no walkability rules of their own. The web editor moves the party by clicking a cell of the live map, on any level. Facing caveat from `set_party_position`: a new `dir` does not rotate the rank layout as an in-game turn does. A facing picker needs the ranks rotated with it, or the binding should rotate them.
Author
Owner

Design

Facing

The caveat on set_party_position is wrong. Each champion record holds its facing and its cell in the 2×2 layout: bytes 0x1c (absdir) and 0x1d (partypos), 2 bits each in the champion mask (DOS, Mac and Beta). An in-game turn adds the turn to both on every champion (skproject ROTATE_SQUAD, dm2mac champ_set_party_direction); writing player_dir alone left them unturned, hence the flipped formation the oracle showed.

set_party_position will rotate both bytes of each party member by (dir − player_dir) & 3. That fixes the CLI too. docs/formats/save-object-editability.md gets its caveat corrected.

Where the party may stand

Checked on the live dungeon (#482), so door states and creatures are current. Refused:

Tile Refused when
wall, map exit always
door state other than open (0), ¼ (1), broken (5)
trick wall neither open nor imaginary
pit open and not imaginary
stairs always: the next turn takes them
teleporter open: the engine never leaves the party on one
any a creature on the tile

The first four rows are the engine's step rule (dm2mac dungeon_square_blocks_movement, the pit fall test).

My call on creatures: the engine lets the party share a tile with a creature flagged not solid (0x8000 in the executable's creature table, reached through graphics.dat). dm2-tools has no copy of that table, so every creature refuses. This costs ghost-type tiles; porting the table can lift it later.

API

  • dm2-saves: SaveDump::party_position() -> (usize, u16, u16, Direction) and SaveDump::set_party_position(map_info, map, x, y, dir) -> Result<(), PartyEditError>: bounds, the tile rules, then the rotation and the position write. New PartyEditError::Unstandable { map, x, y, why }. SaveFileFull::set_party_position gains the rotation only; the tile rules need the live image, which works on a dump.
  • dm2-convert: SaveGame::party_position() → {"map","x","y","dir"} JSON, set_party_position(map, x, y, dir); full saves only.
  • Bindings: wasm partyPosition() / setPartyPosition(map, x, y, dir), FFI, Python.

Tests

  • Rotation: turn and turn back is byte-identical; one quarter turn moves each champion's cell and facing by one.
  • Refusals on DOS fixtures: wall, closed door, open pit, stairs, open teleporter, creature tile; an open floor tile succeeds and reads back.
  • Bindings: read, set, read back; a wall refusal.
## Design ### Facing The caveat on `set_party_position` is wrong. Each champion record holds its facing and its cell in the 2×2 layout: bytes `0x1c` (`absdir`) and `0x1d` (`partypos`), 2 bits each in the champion mask (DOS, Mac and Beta). An in-game turn adds the turn to both on every champion (skproject `ROTATE_SQUAD`, dm2mac `champ_set_party_direction`); writing `player_dir` alone left them unturned, hence the flipped formation the oracle showed. `set_party_position` will rotate both bytes of each party member by `(dir − player_dir) & 3`. That fixes the CLI too. `docs/formats/save-object-editability.md` gets its caveat corrected. ### Where the party may stand Checked on the live dungeon (#482), so door states and creatures are current. Refused: | Tile | Refused when | |---|---| | wall, map exit | always | | door | state other than open (0), ¼ (1), broken (5) | | trick wall | neither open nor imaginary | | pit | open and not imaginary | | stairs | always: the next turn takes them | | teleporter | open: the engine never leaves the party on one | | any | a creature on the tile | The first four rows are the engine's step rule (dm2mac `dungeon_square_blocks_movement`, the pit fall test). My call on creatures: the engine lets the party share a tile with a creature flagged not solid (`0x8000` in the executable's creature table, reached through graphics.dat). dm2-tools has no copy of that table, so every creature refuses. This costs ghost-type tiles; porting the table can lift it later. ### API - `dm2-saves`: `SaveDump::party_position() -> (usize, u16, u16, Direction)` and `SaveDump::set_party_position(map_info, map, x, y, dir) -> Result<(), PartyEditError>`: bounds, the tile rules, then the rotation and the position write. New `PartyEditError::Unstandable { map, x, y, why }`. `SaveFileFull::set_party_position` gains the rotation only; the tile rules need the live image, which works on a dump. - `dm2-convert`: `SaveGame::party_position()` → `{"map","x","y","dir"}` JSON, `set_party_position(map, x, y, dir)`; full saves only. - Bindings: wasm `partyPosition()` / `setPartyPosition(map, x, y, dir)`, FFI, Python. ### Tests - Rotation: turn and turn back is byte-identical; one quarter turn moves each champion's cell and facing by one. - Refusals on DOS fixtures: wall, closed door, open pit, stairs, open teleporter, creature tile; an open floor tile succeeds and reads back. - Bindings: read, set, read back; a wall refusal.
Author
Owner

Party position for SaveGame Implementation Plan

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: SaveGame.partyPosition() / setPartyPosition(map, x, y, dir), refusing tiles the party cannot stand on and turning the formation with the facing.

Architecture: dm2-saves owns the rules: a champion turn helper shared by SaveFileFull and SaveDump, and a standability check on the live dungeon image (SaveDump::live_dungeon, #482). dm2-convert wraps it on SaveGame; wasm, FFI and Python bind it.

Tech Stack: Rust workspace, wasm-bindgen, cbindgen header, Python ctypes.

Spec: issue #483 and its design comment (#483 (comment)), local copy scratch/483-party-position-design.md.

Global Constraints

  • Champion facing at byte 0x1c, cell at 0x1d, values 0..=3, same offsets for every ChampionLayout.
  • Turn = (dir − player_dir) & 3, added mod 4 to both bytes of every champion record.
  • Refused tiles: wall, map exit; door with state ∉ {0, 1, 5}; trick wall neither open nor imaginary; pit open and not imaginary; stairs; teleporter open; any tile whose chain holds a creature (type 4).
  • Position JSON: {"map":u8,"x":u16,"y":u16,"dir":u8}, dir 0 N, 1 E, 2 S, 3 W.
  • Full saves only; a limited SaveGame refuses as levelLayout does.
  • Whole suite: cargo t; music untouched, so cargo t-nomusic during tasks.

Review Focus

  • Turn back to the original facing restores the champion bytes exactly (no stray bits above 0x03).
  • Same-facing move leaves champion bytes untouched.
  • A creature dropped onto a tile by an edit (record stream, not raw) refuses that tile: live image, not raw map_data.
  • A door opened by set_door_state becomes standable.
  • Big-endian (Mac) dumps: the turn touches bytes, not words; Mac fixture covered.

Task 1: Champion turn

Files:

  • Modify: crates/dm2-saves/src/party_edit.rs (set_party_position, doc comment)
  • Modify: docs/formats/save-object-editability.md (§"Engine-behaviour caveats", first bullet)
  • Test: crates/dm2-saves/tests/party_position.rs (new)

Interfaces:

  • Produces: pub(crate) fn turn_champion(raw: &mut [u8], turn: u8) in party_edit.rs (adds turn mod 4 to raw[0x1c] and raw[0x1d], each kept in 0..=3). Needs a pub(crate) mutable byte accessor on Champion (as_bytes_mut) if none exists.

  • Step 1: Write the failing tests (DOS sksave0.dat, and Mac first save; skip when fixtures absent, fixture_bytes! style)

    • quarter_turn_rotates_formation: record (dir, cell) of each champion; set_party_position to the current tile facing (d + 1) & 3; each champion's bytes are (dir + 1) & 3, (cell + 1) & 3.
    • turn_back_is_identity: turn by 1 then back to the original facing; champion raw bytes equal the originals.
    • same_facing_keeps_champions: same tile and facing; champion bytes unchanged.
  • Step 2: cargo test --profile fast -p dm2-saves --test party_position — Expected: the first two FAIL (bytes unchanged).

  • Step 3: Implement turn_champion; call it on every champion in SaveFileFull::set_party_position before writing player_dir. Replace the doc comment's caveat with one line on the turn; rewrite the doc bullet: champion records keep facing and cell (0x1c, 0x1d), the setter turns them as an in-game turn does. Drop the "deferred" pointer.

  • Step 4: same command — Expected: PASS.

  • Step 5: commit fix(saves): party facing turns the formation.

Task 2: Standable tiles and SaveDump position

Files:

  • Modify: crates/dm2-saves/src/party_edit.rs
  • Test: crates/dm2-saves/tests/party_position.rs

Interfaces:

  • Consumes: turn_champion; SaveDump::live_dungeon(&DungeonMapInfo) -> Result<Vec<u8>, JsonError>; Dungeon::parse, map_bodies[m].tile_at(x, y), Tile::decoded() -> TileAttr, Dungeon::iter_objects_on_tile, Oid::category.

  • Produces:

    • PartyEditError::Unstandable { map: usize, x: u16, y: u16, why: &'static str } — "map {map} ({x},{y}): the party cannot stand on {why}"; why ∈ "a wall", "a map exit", "a closed door", "a closed trick wall", "an open pit", "stairs", "an open teleporter", "a creature".
    • PartyEditError::Dump(JsonError) (#[from]) for live-image failures.
    • impl SaveDump { pub fn party_position(&self) -> (usize, u16, u16, Direction); pub fn set_party_position(&mut self, map_info: &DungeonMapInfo, map: usize, x: u16, y: u16, dir: Direction) -> Result<(), PartyEditError> } — bounds as SaveFileFull, then the tile rules, then the turn on each gameplay.champions[i].raw (base64 decode, turn_champion, encode), then savegamebuffer fields. A refusal leaves the dump unchanged.
  • Step 1: Write the failing tests on the DOS sksave0 dump; each finds its tile by scanning the live image of the party's map (else any map) for the first tile matching the kind, skipping the test's assertion with a message if none exists:

    • refuses_wall, refuses_closed_door (state 4), refuses_open_pit, refuses_stairs, refuses_open_teleporter, refuses_creature_tile — each Err(Unstandable { why, .. }) with the expected why, and the dump's position and champions unchanged.
    • opened_door_is_standable: set_door_state open on a closed door (as tests/live_dungeon.rs::door_state_shows), then set_party_position there succeeds.
    • moves_to_floor: first empty floor tile; party_position() reads back (map, x, y, dir).
    • dump_turns_formation: same assertions as quarter_turn_rotates_formation, on the dump.
  • Step 2: cargo test --profile fast -p dm2-saves --test party_position — Expected: compile FAIL (no SaveDump::set_party_position).

  • Step 3: Implement. fn standable(dungeon: &Dungeon, map, x, y) -> Result<(), &'static str> private in party_edit.rs, one match on TileAttr plus the creature scan.

  • Step 4: same command — Expected: PASS.

  • Step 5: commit feat(saves): party position on a dump, refusing unstandable tiles.

Task 3: SaveGame party position

Files:

  • Modify: crates/dm2-convert/src/save.rs, crates/dm2-convert/src/error.rs
  • Test: crates/dm2-convert/tests/save_game.rs

Interfaces:

  • Consumes: Task 2's SaveDump methods.

  • Produces: SaveGame::party_position(&self, _: &PositionOptions) -> Result<String, ConvertError> (position JSON) and SaveGame::set_party_position(&mut self, map: u8, x: u16, y: u16, dir: u8, _: &PositionOptions) -> Result<(), ConvertError>; PositionOptions empty, as EditOptions. ConvertError::PartyEdit(#[from] PartyEditError). dir > 3 → ConvertError via PartyEditError (add BadDirection(u8)).

  • Step 1: Write the failing tests: party_position_round_trips (set to a floor tile, read back JSON, to_bytes then SaveGame::new again reads the same), party_position_refuses_wall, limited_save_refuses_party_position (both methods).

  • Step 2: cargo test --profile fast -p dm2-convert --test save_game party_position — Expected: compile FAIL.

  • Step 3: Implement; self.context()? first in both, as level_layout. Add to the module diagram line.

  • Step 4: same command — Expected: PASS.

  • Step 5: commit feat(convert): SaveGame party position.

Task 4: Bindings

Files:

  • Modify: crates/dm2-wasm/src/wasm.rs, crates/dm2-wasm/README.md, crates/dm2-ffi/src/lib.rs, crates/dm2-ffi/include/dm2_tools.h, crates/dm2-ffi/tests/abi.rs, bindings/python/… (same files as #482's level_layout), bindings/python/tests/test_roundtrip.py, CHANGELOG.md
  • Test: crates/dm2-ffi/tests/abi.rs, test_roundtrip.py

Interfaces:

  • Produces: wasm partyPosition(options?) -> string, setPartyPosition(map, x, y, dir, options?); FFI dm2_save_game_party_position(s, options, options_len) -> Dm2Buffer, dm2_save_game_set_party_position(s, map: u8, x: u16, y: u16, dir: u8, options, options_len) -> Dm2Buffer (empty on success, error buffer otherwise, as the existing setters); Python SaveGame.party_position() -> dict, set_party_position(map, x, y, dir).

  • Step 1: Write the failing tests: abi — read, set to the read position with dir turned, read back; wall refused; null s. Python — same read/set/read back and a Dm2Error on a wall.

  • Step 2: cargo test --profile fast -p dm2-ffi and uv run --no-project --with pytest pytest bindings/python (env DM2_FFI_LIB=target/release/libdm2_ffi.so PYTHONPATH=bindings/python) — Expected: FAIL.

  • Step 3: Implement; regenerate the header through tests/header.rs's cbindgen as in #482; README row; CHANGELOG Unreleased → Added SaveGame.partyPosition / setPartyPosition (#483) and Fixed: facing turns the formation.

  • Step 4: same commands, plus wasm32 cargo check, cargo clippy --workspace -- -D warnings, cargo doc — Expected: PASS / clean.

  • Step 5: commit feat(bindings): SaveGame.partyPosition and setPartyPosition.

# Party position for SaveGame Implementation Plan > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. **Goal:** `SaveGame.partyPosition()` / `setPartyPosition(map, x, y, dir)`, refusing tiles the party cannot stand on and turning the formation with the facing. **Architecture:** dm2-saves owns the rules: a champion turn helper shared by `SaveFileFull` and `SaveDump`, and a standability check on the live dungeon image (`SaveDump::live_dungeon`, #482). dm2-convert wraps it on `SaveGame`; wasm, FFI and Python bind it. **Tech Stack:** Rust workspace, wasm-bindgen, cbindgen header, Python ctypes. **Spec:** issue #483 and its design comment (https://git.lordran.net/jqueuniet/dm2-tools/issues/483#issuecomment-1454), local copy `scratch/483-party-position-design.md`. ## Global Constraints - Champion facing at byte `0x1c`, cell at `0x1d`, values `0..=3`, same offsets for every `ChampionLayout`. - Turn = `(dir − player_dir) & 3`, added mod 4 to both bytes of every champion record. - Refused tiles: wall, map exit; door with state ∉ {0, 1, 5}; trick wall neither open nor imaginary; pit open and not imaginary; stairs; teleporter open; any tile whose chain holds a creature (type 4). - Position JSON: `{"map":u8,"x":u16,"y":u16,"dir":u8}`, dir 0 N, 1 E, 2 S, 3 W. - Full saves only; a limited `SaveGame` refuses as `levelLayout` does. - Whole suite: `cargo t`; music untouched, so `cargo t-nomusic` during tasks. ## Review Focus - Turn back to the original facing restores the champion bytes exactly (no stray bits above `0x03`). - Same-facing move leaves champion bytes untouched. - A creature dropped onto a tile by an edit (record stream, not raw) refuses that tile: live image, not raw map_data. - A door opened by `set_door_state` becomes standable. - Big-endian (Mac) dumps: the turn touches bytes, not words; Mac fixture covered. --- ### Task 1: Champion turn **Files:** - Modify: `crates/dm2-saves/src/party_edit.rs` (`set_party_position`, doc comment) - Modify: `docs/formats/save-object-editability.md` (§"Engine-behaviour caveats", first bullet) - Test: `crates/dm2-saves/tests/party_position.rs` (new) **Interfaces:** - Produces: `pub(crate) fn turn_champion(raw: &mut [u8], turn: u8)` in `party_edit.rs` (adds `turn` mod 4 to `raw[0x1c]` and `raw[0x1d]`, each kept in `0..=3`). Needs a `pub(crate)` mutable byte accessor on `Champion` (`as_bytes_mut`) if none exists. - [ ] **Step 1: Write the failing tests** (DOS `sksave0.dat`, and Mac first save; skip when fixtures absent, `fixture_bytes!` style) - `quarter_turn_rotates_formation`: record `(dir, cell)` of each champion; `set_party_position` to the current tile facing `(d + 1) & 3`; each champion's bytes are `(dir + 1) & 3`, `(cell + 1) & 3`. - `turn_back_is_identity`: turn by 1 then back to the original facing; champion raw bytes equal the originals. - `same_facing_keeps_champions`: same tile and facing; champion bytes unchanged. - [ ] **Step 2:** `cargo test --profile fast -p dm2-saves --test party_position` — Expected: the first two FAIL (bytes unchanged). - [ ] **Step 3:** Implement `turn_champion`; call it on every champion in `SaveFileFull::set_party_position` before writing `player_dir`. Replace the doc comment's caveat with one line on the turn; rewrite the doc bullet: champion records keep facing and cell (`0x1c`, `0x1d`), the setter turns them as an in-game turn does. Drop the "deferred" pointer. - [ ] **Step 4:** same command — Expected: PASS. - [ ] **Step 5:** commit `fix(saves): party facing turns the formation`. ### Task 2: Standable tiles and `SaveDump` position **Files:** - Modify: `crates/dm2-saves/src/party_edit.rs` - Test: `crates/dm2-saves/tests/party_position.rs` **Interfaces:** - Consumes: `turn_champion`; `SaveDump::live_dungeon(&DungeonMapInfo) -> Result<Vec<u8>, JsonError>`; `Dungeon::parse`, `map_bodies[m].tile_at(x, y)`, `Tile::decoded() -> TileAttr`, `Dungeon::iter_objects_on_tile`, `Oid::category`. - Produces: - `PartyEditError::Unstandable { map: usize, x: u16, y: u16, why: &'static str }` — `"map {map} ({x},{y}): the party cannot stand on {why}"`; `why` ∈ `"a wall"`, `"a map exit"`, `"a closed door"`, `"a closed trick wall"`, `"an open pit"`, `"stairs"`, `"an open teleporter"`, `"a creature"`. - `PartyEditError::Dump(JsonError)` (`#[from]`) for live-image failures. - `impl SaveDump { pub fn party_position(&self) -> (usize, u16, u16, Direction); pub fn set_party_position(&mut self, map_info: &DungeonMapInfo, map: usize, x: u16, y: u16, dir: Direction) -> Result<(), PartyEditError> }` — bounds as `SaveFileFull`, then the tile rules, then the turn on each `gameplay.champions[i].raw` (base64 decode, `turn_champion`, encode), then `savegamebuffer` fields. A refusal leaves the dump unchanged. - [ ] **Step 1: Write the failing tests** on the DOS `sksave0` dump; each finds its tile by scanning the live image of the party's map (else any map) for the first tile matching the kind, skipping the test's assertion with a message if none exists: - `refuses_wall`, `refuses_closed_door` (state 4), `refuses_open_pit`, `refuses_stairs`, `refuses_open_teleporter`, `refuses_creature_tile` — each `Err(Unstandable { why, .. })` with the expected `why`, and the dump's position and champions unchanged. - `opened_door_is_standable`: `set_door_state` open on a closed door (as `tests/live_dungeon.rs::door_state_shows`), then `set_party_position` there succeeds. - `moves_to_floor`: first empty floor tile; `party_position()` reads back `(map, x, y, dir)`. - `dump_turns_formation`: same assertions as `quarter_turn_rotates_formation`, on the dump. - [ ] **Step 2:** `cargo test --profile fast -p dm2-saves --test party_position` — Expected: compile FAIL (no `SaveDump::set_party_position`). - [ ] **Step 3:** Implement. `fn standable(dungeon: &Dungeon, map, x, y) -> Result<(), &'static str>` private in `party_edit.rs`, one `match` on `TileAttr` plus the creature scan. - [ ] **Step 4:** same command — Expected: PASS. - [ ] **Step 5:** commit `feat(saves): party position on a dump, refusing unstandable tiles`. ### Task 3: `SaveGame` party position **Files:** - Modify: `crates/dm2-convert/src/save.rs`, `crates/dm2-convert/src/error.rs` - Test: `crates/dm2-convert/tests/save_game.rs` **Interfaces:** - Consumes: Task 2's `SaveDump` methods. - Produces: `SaveGame::party_position(&self, _: &PositionOptions) -> Result<String, ConvertError>` (position JSON) and `SaveGame::set_party_position(&mut self, map: u8, x: u16, y: u16, dir: u8, _: &PositionOptions) -> Result<(), ConvertError>`; `PositionOptions` empty, as `EditOptions`. `ConvertError::PartyEdit(#[from] PartyEditError)`. `dir > 3` → `ConvertError` via `PartyEditError` (add `BadDirection(u8)`). - [ ] **Step 1: Write the failing tests**: `party_position_round_trips` (set to a floor tile, read back JSON, `to_bytes` then `SaveGame::new` again reads the same), `party_position_refuses_wall`, `limited_save_refuses_party_position` (both methods). - [ ] **Step 2:** `cargo test --profile fast -p dm2-convert --test save_game party_position` — Expected: compile FAIL. - [ ] **Step 3:** Implement; `self.context()?` first in both, as `level_layout`. Add to the module diagram line. - [ ] **Step 4:** same command — Expected: PASS. - [ ] **Step 5:** commit `feat(convert): SaveGame party position`. ### Task 4: Bindings **Files:** - Modify: `crates/dm2-wasm/src/wasm.rs`, `crates/dm2-wasm/README.md`, `crates/dm2-ffi/src/lib.rs`, `crates/dm2-ffi/include/dm2_tools.h`, `crates/dm2-ffi/tests/abi.rs`, `bindings/python/…` (same files as #482's `level_layout`), `bindings/python/tests/test_roundtrip.py`, `CHANGELOG.md` - Test: `crates/dm2-ffi/tests/abi.rs`, `test_roundtrip.py` **Interfaces:** - Produces: wasm `partyPosition(options?) -> string`, `setPartyPosition(map, x, y, dir, options?)`; FFI `dm2_save_game_party_position(s, options, options_len) -> Dm2Buffer`, `dm2_save_game_set_party_position(s, map: u8, x: u16, y: u16, dir: u8, options, options_len) -> Dm2Buffer` (empty on success, error buffer otherwise, as the existing setters); Python `SaveGame.party_position() -> dict`, `set_party_position(map, x, y, dir)`. - [ ] **Step 1: Write the failing tests**: abi — read, set to the read position with `dir` turned, read back; wall refused; null `s`. Python — same read/set/read back and a `Dm2Error` on a wall. - [ ] **Step 2:** `cargo test --profile fast -p dm2-ffi` and `uv run --no-project --with pytest pytest bindings/python` (env `DM2_FFI_LIB=target/release/libdm2_ffi.so PYTHONPATH=bindings/python`) — Expected: FAIL. - [ ] **Step 3:** Implement; regenerate the header through `tests/header.rs`'s cbindgen as in #482; README row; CHANGELOG Unreleased → Added `SaveGame.partyPosition` / `setPartyPosition` (#483) and Fixed: facing turns the formation. - [ ] **Step 4:** same commands, plus wasm32 `cargo check`, `cargo clippy --workspace -- -D warnings`, `cargo doc` — Expected: PASS / clean. - [ ] **Step 5:** commit `feat(bindings): SaveGame.partyPosition and setPartyPosition`.
Sign in to join this conversation.
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
jqueuniet/dm2-tools#483
No description provided.