Sashité for Developers
  1. Sashité for Developers
  2. Specifications
  3. PMN
  4. 1.0.0

Portable Move Notation (PMN) Specification


Overview

Portable Move Notation (PMN) is a rule-agnostic, JSON-based format for describing the mechanical decomposition of moves in abstract strategy board games. PMN breaks down complex movements into sequences of atomic actions, revealing the underlying mechanics while remaining completely independent of specific game rules, validation logic, or gameplay concepts.

PMN provides a universal vocabulary for expressing how pieces physically move, interact, and transform during gameplay across any board game system, from traditional chaturanga to modern variants and hybrid games.


Terminology

For complete definitions of terms used in this document, see the Glossary.


Core Philosophy

Mechanical Decomposition

PMN treats every move as a sequence of atomic mechanical actions. Each action represents a single, indivisible transformation that occurs during move execution. Complex movements that appear as single “moves” in traditional notation are decomposed into their constituent mechanical steps.

Key principle: PMN describes what happens mechanically, not what is allowed or why it happens.

Atomic Actions

An atomic action is the smallest meaningful transformation in a game system:

Universal Applicability

PMN’s mechanical approach enables universal application across:


Dependencies

PMN builds upon three foundational Sashité specifications:

These specifications define the building blocks that PMN composes into action sequences.


Format Structure

Flat Array Representation

A PMN move is a flat JSON array containing the complete action sequence:

[<element-1>, <element-2>, <element-3>, <element-4>, <element-5>, <element-6>, ...]

Action Sequence Parsing

The array is parsed by grouping elements into action sequences:

  1. Process elements left-to-right sequentially
  2. Group into sets of 3 consecutive elements
  3. If the final group contains only 2 elements, the piece is omitted (inferred from context)
  4. Each group represents one atomic action

Array length requirements:

Action Sequence Format

Each action follows this pattern:

[<source>, <destination>, <piece>?]
Position Element Description
0 Source Origin location (CELL coordinate or HAND "*")
1 Destination Target location (CELL coordinate or HAND "*")
2 Piece Final piece state after the action (QPI format, optional)

Optional Piece Specification

When the piece is omitted, the game rules and position context must provide enough information to unambiguously determine:

This allows for concise representation when the context eliminates ambiguity.


Element Specification

Source Location

Destination Location

Piece State (Optional)

Constraint: Source and destination must be different in the same action (no self-referential transfers).


Mechanical Semantics

Execution Model

Actions execute sequentially in array order. Each action completes fully before the next begins, producing these deterministic effects:

  1. Source state change:
    • CELL location → becomes empty
    • HAND location ("*") → remove specified piece from reserve/hand
  2. Destination state change:
    • CELL location → contains the final piece state
    • HAND location ("*") → add specified piece to reserve/hand
  3. Piece transformation: Piece assumes its final state (specified or inferred)

  4. Atomic commitment: All changes occur atomically per action

State Dependencies

Later actions may reference locations modified by earlier actions, enabling complex movement patterns like exchanges or multi-step captures.


JSON Schema

Schema URL: https://sashite.dev/schemas/pmn/1.0.0/schema.json

The JSON Schema provides structural validation for PMN format compliance. Format validation (CELL/HAND/QPI conformity) and semantic validation (piece existence, inference, and QPI consistency) must be implemented by applications based on current game state and dependency specifications.


Examples

See PMN Examples for practical implementation guidance.

Reference Implementations

Ruby