Rust Godot Visual Novel Engine

Advance the narrative runtime through a deterministic command-to-events transition.

Project the current narrative state into a presentation-only dialogue view model.

Test branching, conditional choices, and terminal dialogue nodes with table-driven unit tests.

Create Rust builder APIs for authoring dialogue, choices, conditions, and effects.

Create declarative Rust macros that reduce repetition in dialogue and choice definitions.

Register content from independent Rust modules through an explicit content registry.

Detect duplicate identifiers during content-registry construction.

Detect references to missing narrative, character, location, quest, and item definitions.

Report unreachable dialogue nodes and unintended non-terminating dialogue cycles.

Generate a deterministic content fingerprint from all registered definitions.

Fail an automated content-validation test with actionable diagnostics for malformed authored content.

Expose a Rust EngineHost GodotClass that owns the engine instance and presentation coordination.

Acquire required Control nodes from a Godot scene through typed Rust node references.

Connect Godot UI signals to Rust callbacks without GDScript.

Translate a UI callback into a queued engine command.

Render a dialogue view model into labels, portraits, and choice controls.

Resolve engine asset identifiers to Godot presentation resources without leaking resources into core state.

Acknowledge presentation events such as completed animations back to the Rust runtime.

Switch Godot presentation scenes in response to Rust-issued presentation events.

Represent calendar time and duration with deterministic serializable Rust types.

Define locations and traversable routes as compiled Rust content.

Define sandbox activities with availability conditions, durations, and effects.

Represent a character schedule as time- and condition-dependent location rules.

Advance world time while applying scheduled state transitions in a stable order.

Compute the currently available travel, conversation, and activity interactions.

Emit world events when time, location, or state thresholds are crossed.

Test a multi-day sandbox scenario with deterministic schedules and interaction availability.

Separate immutable CharacterDefinition content from mutable CharacterState data.

Define a registry of extensible character stat keys and their metadata.

Represent stat values with explicit supported types and type-safe accessors.

Validate character stat defaults, required fields, and numeric ranges at startup.

Apply a temporary or permanent stat modifier without mutating the base definition.

Evaluate a derived stat from declared dependencies without storing redundant state.

Route character-state changes through auditable engine commands and events.

Project selected core and custom stats into a presentation-neutral character view model.

Define compiled QuestDefinition data with prerequisites, objectives, and rewards.

Represent inactive, active, completed, and failed quest runtime states.

Model one quest objective as progress derived from domain events.

Evaluate quest prerequisites against the current world-state view.

Transition a quest through its lifecycle using explicit engine events.

Apply quest rewards through the common narrative-effect mechanism.

Project quest state into a localized journal view model.

Test concurrent quests that react differently to the same domain event.

Define compiled item content with stable identifiers, tags, localization keys, and effect specifications.

Represent stackable and individually unique item instances in inventory state.

Add and remove items through inventory transactions that preserve quantity invariants.

Enforce inventory capacity with a deterministic rejection result.

Query inventory contents by identifier, tag, and authored condition.

Execute an item-use command through the common narrative-effect mechanism.

Expose inventory rows and permitted actions through a presentation-neutral view model.

Test inventory transfers, rejected transactions, and item consumption with property-based invariants.

Represent locale identifiers and fallback chains independently of Godot resources.

Replace player-facing strings in authored definitions with stable localization keys.

Register localized message catalogs as compiled Rust content.

Resolve a localization key through locale fallback rules.

Interpolate named runtime values into a localized message.

Select plural and grammatical variants from typed localization arguments.

Map desktop or browser language preferences to a supported engine locale.

Detect missing keys, inconsistent placeholders, and incomplete locale coverage in automated tests.

Separate a serializable save snapshot from transient runtime and Godot presentation state.

Wrap each save snapshot in an envelope containing schema version, content fingerprint, timestamp, and slot metadata.

Select and configure a deterministic serialization format suitable for desktop and web builds.

Convert between validated runtime state and persistence data-transfer objects.

Migrate an older save schema through a sequential versioned migration chain.

Define a storage interface supporting named slots, listing, saving, loading, and deletion.

Implement crash-resistant desktop slot writes through the Rust-controlled Godot file API.

Implement and verify browser-persistent slots using the web build's user-storage mechanism.

Define a mini-game contract for configuration, input, update, output, completion, and cancellation.

Register compiled Rust mini-game implementations by stable type identifier.

Instantiate a mini-game through a registry without coupling the engine to its concrete type.

Constrain mini-game effects to validated result events applied by the main engine.

Bridge a mini-game's presentation model to a dedicated Godot scene without GDScript.

Route Godot input into the active mini-game through a presentation-independent input type.

Serialize and restore an in-progress mini-game through its extension contract.

Implement a small reference mini-game that verifies registration, presentation, completion, and reward flow.

Define an error taxonomy that distinguishes authored-content defects, invalid commands, persistence failures, and presentation failures.

Attach structured diagnostic context to engine errors without exposing internal state to player-facing UI.

Record engine commands and deterministic events in a replayable diagnostic trace.

Replay a recorded command sequence to reproduce the same final engine-state fingerprint.

Create a headless scenario test spanning dialogue, time advancement, quests, inventory, and a mini-game result.

Create a Godot integration test that verifies Rust-to-UI signal and rendering behavior.

Configure continuous integration to run formatting, linting, unit tests, content validation, and desktop/web build checks.

Create version-pinned desktop and web export presets and document the compatibility checks required before upgrading Godot or godot-rust.