Struct DialogEngine 

pub struct DialogEngine<P: TextProvider> {
    pub provider: P,
    pub stream: Option<TextStream<P::Char>>,
    pub state: DialogState,
}

A general-purpose dialog engine that drives text display one character per frame.

P is the TextProvider implementation that supplies the game’s character encoding and rendering logic.

Usage

let provider = MyProvider::new();
let mut engine = DialogEngine::new(provider);
let mut buffer = TileBuffer::new(20, 18);

engine.open_dialog(&[0x48, 0x45, 0x4C, 0x4C, 0x4F]); // "HELLO"

while engine.is_active() {
    engine.update(&mut buffer); // one char per frame
}

engine.advance(); // close dialog

Fields

provider: P

The text provider (charmap, rendering, control codes).

stream: Option<TextStream<P::Char>>

Active character stream, or None if no dialog is open.

state: DialogState

Current dialog state.

Implementations

impl<P: TextProvider> DialogEngine<P>

pub fn new(provider: P) -> Self

Creates a new dialog engine with the given text provider.

Examples found in repository

examples/hello_dotzuki.rs (line 677)

fn demo_dialog() {
    println!("\n╔══ NPC DIALOG ═══════════════════════════╗");
    let provider = HelloConfig::new();
    let mut engine = DialogEngine::new(provider);
    let mut buffer = TileBuffer::new(20, 18);

    // "Greetings, young hero!" + DONE
    let text: &[u8] = b"Greetings, young hero!";
    let mut full = text.to_vec();
    full.push(0xFF); // DONE

    engine.open_dialog(&full);
    while engine.is_active() {
        engine.update(&mut buffer);
    }

    print!("║ Merlin: \"");
    for i in 0..20usize {
        let t = buffer.tiles[i].tile_id;
        if (0x20..=0x7E).contains(&t) {
            print!("{}", t as u8 as char);
        }
    }
    println!("\"");
    println!("╚══════════════════════════════════════════╝");
}

pub fn open_dialog(&mut self, text: &[u8])

Opens a dialog with the given raw byte text.

The bytes are decoded via the provider’s TextProvider::decode_stream and the state is reset to the initial typing mode.

Examples found in repository

examples/hello_dotzuki.rs (line 685)

fn demo_dialog() {
    println!("\n╔══ NPC DIALOG ═══════════════════════════╗");
    let provider = HelloConfig::new();
    let mut engine = DialogEngine::new(provider);
    let mut buffer = TileBuffer::new(20, 18);

    // "Greetings, young hero!" + DONE
    let text: &[u8] = b"Greetings, young hero!";
    let mut full = text.to_vec();
    full.push(0xFF); // DONE

    engine.open_dialog(&full);
    while engine.is_active() {
        engine.update(&mut buffer);
    }

    print!("║ Merlin: \"");
    for i in 0..20usize {
        let t = buffer.tiles[i].tile_id;
        if (0x20..=0x7E).contains(&t) {
            print!("{}", t as u8 as char);
        }
    }
    println!("\"");
    println!("╚══════════════════════════════════════════╝");
}

pub fn update(&mut self, buffer: &mut TileBuffer)

Processes one character from the current dialog stream.

Call this once per frame to achieve the classic typewriter effect. Control codes are dispatched to the provider’s TextProvider::process_control; printable characters are drawn via TextProvider::render_char.

If the engine is not in DialogMode::Typing, this call is a no-op. If the stream is exhausted or a Done control action is returned, the dialog state transitions to DialogMode::Done.

Examples found in repository

examples/hello_dotzuki.rs (line 687)

fn demo_dialog() {
    println!("\n╔══ NPC DIALOG ═══════════════════════════╗");
    let provider = HelloConfig::new();
    let mut engine = DialogEngine::new(provider);
    let mut buffer = TileBuffer::new(20, 18);

    // "Greetings, young hero!" + DONE
    let text: &[u8] = b"Greetings, young hero!";
    let mut full = text.to_vec();
    full.push(0xFF); // DONE

    engine.open_dialog(&full);
    while engine.is_active() {
        engine.update(&mut buffer);
    }

    print!("║ Merlin: \"");
    for i in 0..20usize {
        let t = buffer.tiles[i].tile_id;
        if (0x20..=0x7E).contains(&t) {
            print!("{}", t as u8 as char);
        }
    }
    println!("\"");
    println!("╚══════════════════════════════════════════╝");
}

pub fn advance(&mut self)

Advances the dialog past the current page or closes it.

• If paused, resumes typing.
• If waiting for input or scrolling, resumes typing.
• If the dialog is done, clears the stream and resets state (so [is_active] returns false).

Call this in response to the player pressing the A button.

pub fn is_active(&self) -> bool

Returns true if a dialog is currently active.

A dialog is active when a stream is loaded and the mode is not DialogMode::Done.

Examples found in repository

examples/hello_dotzuki.rs (line 686)

fn demo_dialog() {
    println!("\n╔══ NPC DIALOG ═══════════════════════════╗");
    let provider = HelloConfig::new();
    let mut engine = DialogEngine::new(provider);
    let mut buffer = TileBuffer::new(20, 18);

    // "Greetings, young hero!" + DONE
    let text: &[u8] = b"Greetings, young hero!";
    let mut full = text.to_vec();
    full.push(0xFF); // DONE

    engine.open_dialog(&full);
    while engine.is_active() {
        engine.update(&mut buffer);
    }

    print!("║ Merlin: \"");
    for i in 0..20usize {
        let t = buffer.tiles[i].tile_id;
        if (0x20..=0x7E).contains(&t) {
            print!("{}", t as u8 as char);
        }
    }
    println!("\"");
    println!("╚══════════════════════════════════════════╝");
}