Here is a comprehensive recap of the project architecture, followed by the
design and generation of the MVP web interface.
Project Architecture Recap: The Book-to-World Pipeline
The goal is to automatically ingest linear narrative text and output a
playable, synchronized multi-user game environment that supports both a
semantic MUD interface and a visual Rogue-like 2D grid.
Phase 1: Multi-Pass Semantic Extraction
Topology Pass: An LLM sliding window scans the text to extract distinct
locations and directional connections, resolving spatial paradoxes.
Entity Pass: A subsequent scan identifies items, artifacts, and actors,
binding their initial states to the extracted Room IDs.
Logic & Timeline Pass: Narrative events, conflicts, and dialogues are
extracted into conditional quests and a chronological event stream, keyed by
page number or story tick.
Phase 2: Unified Data Representation
The extracted data is structured into a unified JSON-Lisp AST formatted array:
["world", [zones], [entities], [timeline]].
This compact S-expression format is highly efficient for lock-free in-memory
indexing.
It serves as the immutable source of truth, easily serialized into AST-MD
snapshot files for persistence and map-editor handoffs.
Phase 3: Dual-Layer Spatial Resolution
The MUD Layer: Operates purely on the topological graph (AST zones and exits).
It handles non-Euclidean scene jumps effortlessly.
The Rogue Grid Layer: A Version 2 organizer script groups semantic rooms onto
a 2D plane, generates caverns based on the grid AST properties, and carves
walkable HTML5 canvas or WebGL tunnels between them.
Phase 4: Execution & Event Sourcing
The Timeline as a WAL: The event stream acts as a Write-Ahead Log. Instead of
static placement, entities are spawned and moved dynamically as the timeline
progresses.
Engine Integration: The JSON-Lisp nodes can be compiled into executable
virtual machine bytecodes or scripts. State mutations triggered by player
interactions are broadcast over a WebSocket relay for CRDT state
synchronization among connected clients.
The MVP Interface Design
To prototype this, the one-page HTML/JS application needs to serve as both the
ingestion tool and the execution client. The interface is divided into four
primary modules:
The Ingestion Deck: A raw text input area simulating the book feed.
The Pipeline Engine (Mocked): A trigger that simulates the multi-pass LLM
extraction, generating and displaying the resulting JSON-Lisp AST in
real-time.
The Temporal Controller: A timeline slider that allows you to manually scrub
through the "story ticks" (page numbers), dispatching events from the WAL
directly into the game state.
The MUD Viewport: A terminal-style REPL where you can type commands (look,
north, inventory) to navigate the topological graph and interact with the
entities spawned by the timeline.
I will generate this prototype now so you can interact with the data structure
and navigation flow.