Arcanum doesn't ask creators to build systems. It asks them to describe story intent — and converts that intent into a deterministic, testable, stateful experience automatically.
Every action a player can take originates from one of five templates. Each template hides an entire system behind a single narrative prompt. The creator chooses the template — the engine generates everything else.
The creator defines two or more options. The system creates one branch per option and generates placeholder destination nodes automatically. No dice. No stats. Pure narrative decision — the most accessible entry point.
The creator writes the action description and names the outcomes. The system applies hidden probability logic using a dice roll. The creator names the narrative outcomes — the engine determines how they resolve.
The creator picks a stat key and a difficulty level. The system binds the roll to the player's current stat value and evaluates against a difficulty class. The creator sets Easy / Medium / Hard — never the DC number.
The creator sets a difficulty level. The system creates Lose / Win / Critical branches and wires health effects automatically. Multi-outcome combat requires zero manual rule definition from the creator.
Full access to the rule system: custom dice definitions, multi-condition DSL expressions, manual effect groups, and priority ordering. Power features revealed only when explicitly accessed — invisible to all other templates.
Every playable action in Arcanum resolves through the same deterministic chain. Nothing is arbitrary. Every branch exists because a rule produced a named outcome — and every outcome wires to a named destination with optional conditions and effects.
When a player reaches a transition, the engine evaluates four checks in strict order. This prevents paywalls from appearing before structural or state eligibility is confirmed.
Does the transition have a valid target node? Is the source node reachable? Are all required fields populated?
Does the player's current state satisfy all items in the condition group? Logic mode: ALL conditions must pass, or ANY one condition must pass.
Is the transition marked as paid? If so — does the player own this transition? If not, show the locked state with purchase option.
If all checks pass: apply the effect group to player state, move to target node, record the State Snapshot.
Every player session carries a live state object — a map of all declared variables and their current values. Four types of state, each serving a distinct narrative and mechanical purpose.
Integer values. Bound to rule evaluation — skill check rolls add the relevant stat to the dice result. Modified by fight outcomes and effect groups.
Boolean story markers. Gate transitions and dialogue branches. Set by effect groups when significant story events occur. Never exposed to players unless creator marks them visible.
Item reference lists. Items added and removed via effect group operations. Item presence evaluated in condition groups to gate transitions.
Numeric progression markers. Incremented or decremented by effects. Enable tension systems, day tracking, resource management, and milestone detection.
The validation panel runs continuously as the story grows. Four categories of issues — each with severity levels and jump-to-node navigation. Click any issue to teleport directly to the source node.
| Category | Issue Type | Severity | Description |
|---|---|---|---|
| Structural | missing_start_node | Error | Story has no node marked as start. Cannot be published or entered by players. |
| Structural | dead_end_not_ending | Error | Node has no outgoing transitions and is not marked as an ending. Player is stranded. |
| Structural | unreachable_node | Warning | Node cannot be reached from the start node via any transition path. Orphaned content. |
| Structural | missing_target | Error | A transition references a target node that does not exist or has been deleted. |
| Logic | overlapping_outcome_ranges | Error | Two outcome bands share the same dice range. Result is ambiguous at resolution time. |
| Logic | undefined_state_key | Error | A condition or effect references a state key not declared in State Definitions. |
| Logic | impossible_condition | Warning | Condition can never be true given declared state type (e.g. boolean > 3). |
| Content | placeholder_unfinished | Warning | Node is still in placeholder status. Published stories cannot contain unfinished nodes. |
| Content | missing_media | Warning | Node content_type is image or video but no media URL is set. |
| Continuity | continuity_warning | Info | A visually-relevant state variable changed without a corresponding scene update detected downstream. |
Creators can play their story at any stage of production. Test sessions are fully isolated from live player sessions — no test data ever appears in player analytics or story statistics.
Override any rule resolution — force Failure, Success, or Critical on any action regardless of dice roll or stat value. Test every branch without grinding through probability.
Set any stat, flag, counter, or inventory item to any value mid-session. Test edge cases, conditional branches, and ending conditions without replaying the full story.
Teleport to any node in the graph without playing through it. Test deep branches in seconds, not minutes. Essential for large stories with 100+ nodes.
Return to any previous State Snapshot. Replay decision points without restarting the session. The full session history is preserved and browsable during testing.
Arcanum's data model has 12 core objects with clean separation between story structure, playable state, creator workflow state, and test state. Designed for validation, scale, and future versioning.
| Object | Role | Key Fields |
|---|---|---|
| Story | Root container for all nodes and logic | id, title, start_node_id, status, monetization_mode, visibility |
| Story Defaults | Initial state for a new player session | starting_stats, starting_inventory, starting_flags, starting_counters |
| Node | One scene, step, or narrative unit | node_type, status, content_type, placeholder_summary, position_x/y |
| Action | Something the player can attempt from a node | label, action_template_type, display_order, is_hidden |
| Rule | The resolution logic attached to an action | rule_type, dice_definition, difficulty_level, skill_key, custom_expression |
| Outcome | A named possible result of resolving a rule | label, min_value, max_value, priority |
| Transition | Movement from one node to another after an outcome | source_node_id, outcome_id, target_node_id, access_type, condition_group_id, effect_group_id |
| Condition Group | Conditions required for a transition to be available | logic_mode (all/any), condition items: state_key, operator, expected_value |
| Effect Group | State changes applied when a transition is taken | effect items: state_key, operation (set/increment/decrement/add_item/remove_item), value |
| State Definition | A declared state variable used in the story | key, state_type, value_type, default_value, visibility_mode, visual_relevance |
| State Snapshot | Resolved player state at a given moment | session_id, snapshot_data (map), current_node_id, created_at |
| Player Session | One player's run through a story | session_type (live/test), current_node_id, ending_node_id, ending_type |