ludic/docs/language/control/kw-machine.md
Orkuncakilkaya 3c7ec9b016
All checks were successful
docs / build-and-deploy (push) Successful in 2s
docs(api): per-symbol pages, fuzzy search, deep token linking, hover cards
Rebuild the API Reference around one page per symbol and richer, verified content.

Pages & navigation
- One HTML page per symbol (kw-*, type-*, phase-*, screen-*, fn-*, annot-*, op-*)
  instead of a single scrolling page; namespace overview pages (ns-screen …
  ns-color) and a searchable index (api.html) with client-side fuzzy search.
- Sticky-header scroll offset (scroll-margin) so a jumped-to entry/param/color is
  never hidden, plus a flash highlight on the scrolled-to target.

Deep linking in every snippet & example
- Namespace members split: `Screen`→namespace page, `fill_rectangle`→method page;
  `Color`→palette page, `Charcoal`→its swatch — separately.
- Named arguments (`width:`) link to that parameter's anchor on the method page.
- Hover any token for a summary card built from the real API data (symbols.json).

Content & coverage
- Full authoritative surface documented from the compiler: every keyword, type,
  the 6 phases (Start/Input/FixedUpdate/Update/LateUpdate/Render, each its own
  page), all 22 annotations, namespace methods with parameter docs, builtins,
  the world_* reflection ABI, networking, operators — 155 symbols.
- Longer, clearer explanations; "model"/"model instance" terminology, not "entity";
  descriptive identifiers in every example (Position{column,row}, Velocity{delta_x,
  delta_y}, Health{current,maximum}, Player/Enemy) — no Pos/Seg/x/dx.
- Accuracy fixes from compiler ground-truth: world_count() takes no arg,
  world_query_next(property, cursor) arg order, event fields bind by name; dropped
  `when` and `module` (not in the self-hosted parser).

Tooling
- inventory.json + check.py: coverage guard (every symbol has a page), duplicate-
  token guard, and broken-link guard — fail CI so docs can't drift.
- validate.py: compiles every ```ludic example against bin/ludicc (158 compile).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-08-29 17:53:22 +03:00

1.5 KiB

id name category kind tokens sig tip order
kw-machine machine control keyword machine machine store { state Name { … } } An explicit state machine over an int var — dispatches on the store's value. 6

A machine turns an integer store into an explicit state machine, replacing brittle if phase == N chains. It reads the store — a named program-scope var is the modern choice — and dispatches to the matching state block; inside a state, become Name transitions to another state of the same machine. States number themselves by declaration order (the first is 0, the next 1, and so on), so you never write magic constants, though state Name = expr is accepted when a state needs a specific value. Because become compiles to a single store back into the var, the whole machine lowers to plain branches with no dispatch table. Place a machine inside a handler so it runs each frame.

program TurnOrder {
  enum Phase { KnightMenu, KnightResolve, EnemyTurn }
  var battle_phase: int = Phase.KnightMenu

  handler RunTurn phase Update {
    machine battle_phase {
      state KnightMenu {
        if Input.key() == ' ' { become KnightResolve }
      }
      state KnightResolve {
        become EnemyTurn
      }
      state EnemyTurn {
        become KnightMenu
      }
    }
  }

  handler DrawWorld phase Render {
    Screen.clear(Color.MidnightBlue)
    Screen.draw_number(x: 8, y: 8, value: battle_phase, color: Color.Gold, scale: 2)
    Screen.show()
  }
}