Interpreter

Main interpreter class for Loreline scripts. This class is responsible for executing a parsed Loreline script, managing the runtime state, and interacting with the host application through handler functions.

Instance Members #

Starts script execution from the beginning or a specific beat.

Saves the current state of the interpreter. This includes all state variables, character states, and execution stack, allowing execution to be resumed later from the exact same point.

Restores the interpreter state from a SaveData object. This allows resuming execution from a previously saved state.

Resumes execution after restoring state. This should be called after restore() to continue execution.

Gets a character by name.

Gets a specific field of a character.

Sets a specific field on a character.

Creates a new Loreline script interpreter.

Private Members #

The script being executed.

User-defined dialogue handler, which takes care of displaying the dialogues.

User-defined choice handler, which takes care of displaying the choices and providing a response to the interpreter.

User-defined finish handler, which is called when the current execution has finished.

The top level state, which is shared across the whole script execution.

Top level characters can be referenced and their state can also be modified from anywhere in the script.

All the top level beats available, by beat name (their identifier in the script).

States associated to a specific node id. These are persistent, like the top level state, but are only available from where they have been declared and the sub-scopes. If some state fields already existed in a parent scope, the parent ones will be shadowed by the child ones.

Top level functions available by default in this script.

The current execution stack, which consists of scopes added on top of one another. Each scope can have its own local beats and temporary states.

The lens instance allowing to get more information about the AST.

Tells whether access is strict or not. If set to true, trying to read or write an undefined variable will throw an error.

Current scope associated with current execution state.

Current insertion associated with current scope or a parent scope, with current execution state.

The next scope id to assign when pushing a new scope. Every time we reset the stack, this counter is also reset.

The next insertion id to assign when creating a new insertion. Every time we reset the stack, this counter is also reset.

List of pending callbacks that should be run synchronously.

Internal flag to know if we are currently flushing sync callbacks (to prevent unexpected recursive flushes).

Keep track of which callback is the one that would trigger finish.

When loading saved data and failing to restore a full stack of scope, this contains the beat to resume as fallback. That beat will always be a top level beat.

A custom instanciator to create fields objects.

Serializes a scope to save data.

Serializes a state to save data.

Serializes all top-level characters to save data.

Serializes all node states to save data.

Serializes a beat reference for save data.

Serializes a node reference for save data.

Serializes a character for save data.

Serializes fields for save data. Only fields that have changed from their original values are included.

Serializes a value for save data. Handles recursive serialization of objects and arrays.

Core function that resumes execution from a given scope. Works by recreating the execution flow as if we had been running from the beginning.

Resumes execution of a node body.

Resumes execution of a beat.

Resumes execution of a choice option.

Resumes execution of a choice

Resumes execution of an if statement.

Resumes execution of a beat call.

Restores the execution stack from saved data.

Finds the top-level beat to resume from if stack restoration fails.

Restores a node from a saved reference.

Restores a beat from a saved reference.

Restores a state from saved data.

Restores characters from saved data.

Restores node states from saved data.

Restores a character from saved data.

Restores fields from saved data.

Restores a value from its saved form. Handles recursive restoration of objects and arrays.

Initializes top-level functions available to the script. This includes built-in functions and any user-provided functions.

Wraps a callback function to control whether it executes synchronously or asynchronously. This is crucial for managing the execution flow of the script.

Flushes all pending synchronous callbacks. This ensures that all pending operations are completed before continuing.

Pops the top scope from the execution stack.

Pushes a new scope onto the execution stack.

Initializes a top-level state declaration. Evaluates all fields and stores their values.

Initializes a top-level beat declaration. Registers the beat in the top-level beats map.

Initializes a top-level character declaration. Creates a new character state and evaluates all fields.

Initializes a state declaration within a scope. Evaluates all fields and stores their values.

Finishes script execution and calls the finish handler.

Transitions to a new beat, clearing the current execution stack.

Evaluates a node, dispatching to the appropriate handler based on node type.

Evaluates a beat declaration. Adds the beat to the current scope so it can be referenced by other nodes.

Evaluates a node body by creating a new scope and executing each node in sequence.

Evaluates a beat by executing its body.

Evaluates a state declaration. Initializes the state fields with their evaluated values.

Evaluates a text statement by evaluating the content and calling the dialogue handler.

Evaluates a dialogue statement by evaluating the content and calling the dialogue handler.

Evaluates a choice statement by evaluating the options and calling the choice handler.

Evaluates a choice option by executing its body.

Evaluates an if statement by evaluating the condition and executing the appropriate branch.

Evaluates an assignment by resolving the target, evaluating the value, and applying the assignment.

Determines whether an expression is an "original script expression" - meaning it only depends on values directly present in the script and not on runtime state.

Original script expressions can be evaluated at parse time and safely stored as default values, as they don't depend on dynamic context like variables or function calls that might change during runtime.

Determines if a node is a beat call. A beat call is a special function call that executes a beat instead of a normal function.

Resolves a call node to a beat declaration if the call references a beat. This allows handling beat calls differently from regular function calls.

Evaluates a call node. If the call references a beat, it executes the beat. Otherwise, it evaluates it as a regular function call.

Evaluates a transition node. Transitions cause execution to jump to a different beat, clearing the current execution stack.

Evaluates a string literal into text with tags. This handles interpolation and tag processing.

Evaluates a condition expression for an if statement or choice option. Converts the result to a boolean according to Loreline's rules.

Evaluates a function call in an expression context. If next is provided, the function may execute asynchronously. If next is null, the function must execute synchronously.

Evaluates an array literal to a runtime array. Each element is evaluated recursively.

Evaluates an object literal to a runtime object. Each field value is evaluated recursively.

Evaluates an expression to its runtime value. This is the core expression evaluation function that handles all expression types.

Reads the value from a runtime access. This handles field access, array access, character access, and function access.

Writes a value to a runtime access location. This handles field access and array access. Character and function access cannot be written to.

Resolves an assignment target to a runtime access. This is used to determine where to write a value in an assignment.

Resolves an access expression to a runtime access. This handles finding variables, character fields, and functions in the appropriate scopes.

Helper for getting human-readable type names in errors

Performs a binary operation on two values. Handles arithmetic, comparison, and logical operations.

Converts a value to its string representation. Used for string interpolation and output.

Metadata #