Merge pull request 'option-select-event' (#3) from option-select-event into master

Reviewed-on: #3

.gitea/workflows/build.yaml

@@ -0,0 +1,25 @@
+name: Build
+on: [push]
+
+jobs:
+  Build:
+    env:
+      RUNNER_TOOL_CACHE: /toolcache
+    container: rust:alpine
+    steps:
+      - name: Install node
+        run: apk add nodejs gcc libc-dev pkgconf libx11-dev alsa-lib-dev eudev-dev tar
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: Restore cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: Build
+        run: cargo build --release

.gitignore

@@ -1 +1,3 @@
-/target
+target
+.cargo/config.toml
+Cargo.lock

Cargo.toml

@@ -1,24 +1,34 @@
 [package]
 name = "bevy_terminal_dialog"
-version = "0.1.0"
+version = "0.2.2"
 edition = "2021"
 
+[profile.dev]
+opt-level = 1
+
+[profile.dev.package.'*']
+opt-level = 2
+
 [dependencies]
-bevy_terminal_display = "0.4"
-yarnspinner = "0.3"
 textwrap = "0.16"
 zalgo = "0.2"
 arbitrary-chunks = "0.4"
-unicode-segmentation = "1.11"
+unicode-segmentation = "1.12"
 anyhow = "1.0"
-downcast-rs = "1.2"
+downcast-rs = "2.0"
 lazy_static = "1.5"
 
+[dependencies.bevy_terminal_display]
+version = "0.7"
+
 [dependencies.bevy_basic_interaction]
-git = "https://github.com/exvacuum/bevy_basic_interaction.git"
+git = "https://git.soaos.dev/soaos/bevy_basic_interaction"
-tag = "v0.1.0"
+tag = "v0.2.0"
+
+[dependencies.yarnspinner]
+git = "https://github.com/YarnSpinnerTool/YarnSpinner-Rust"
 
 [dependencies.bevy]
-version = "0.14"
+version = "0.15"
 default-features = false
 

README.md

@@ -6,15 +6,16 @@
 
 | Crate Version | Bevy Version |
 |---            |---           |
+| 0.2           | 0.15         |
 | 0.1           | 0.14         |
 
 ## Installation
 
-If enough people (like literally 1 person) want this on crates.io I'll consider putting it up there, but for now just add the GitHub URL to your `Cargo.toml`:
+If enough people (like literally 1 person) want this on crates.io I'll consider putting it up there, but for now just add the Git URL to your `Cargo.toml`:
 
 ```toml
 [dependencies.bevy_terminal_dialog]
-git = "https://github.com/exvacuum/bevy_terminal_dialog"
+git = "https://git.exvacuum.dev/bevy_terminal_dialog"
 ```
 
 ## License

src/actor/components.rs

@@ -1,52 +0,0 @@
-//! Components related to actors
-
-use bevy::{prelude::*, utils::HashMap};
-use yarnspinner::{compiler::{Compiler, File}, core::{Library, LineId}, runtime::{Dialogue, MemoryVariableStorage, StringTableTextProvider}};
-
-/// Main actor component, holds state about dialogue along with the dialogue runner itself
-#[derive(Component)]
-pub struct Actor {
-    /// Whether this actor is currently conversing
-    pub active: bool,
-    /// Yarnspinner dialogue runner
-    pub dialogue: Dialogue,
-    /// Yarnspinner dialogue metadata
-    pub metadata: HashMap<LineId, Vec<String>>,
-}
-
-impl Actor {
-    /// Create a new actor from the given source code, starting on the given start node, and with
-    /// the given function library
-    pub fn new(file_name: &str, source: &[u8], start_node: &str, function_library: &Library) -> Self {
-        let compilation = Compiler::new()
-            .add_file(File {
-                source: String::from_utf8_lossy(source).into(),
-                file_name: file_name.into(),
-            })
-            .compile()
-            .unwrap();
-
-        let mut base_language_string_table = std::collections::HashMap::new();
-        let mut metadata = HashMap::new();
-
-        for (k, v) in compilation.string_table {
-            base_language_string_table.insert(k.clone(), v.text);
-            metadata.insert(k, v.metadata);
-        }
-
-        let mut text_provider = StringTableTextProvider::new();
-        text_provider.extend_base_language(base_language_string_table);
-
-        let mut dialogue = Dialogue::new(Box::new(MemoryVariableStorage::new()), Box::new(text_provider));
-        dialogue.library_mut().extend(function_library.clone());
-        dialogue.add_program(compilation.program.unwrap());
-        dialogue.set_node(start_node).unwrap();
-
-        Self {
-            active: false,
-            dialogue,
-            metadata,
-        }
-    }
-}
-

src/actor/events.rs

@@ -1,72 +0,0 @@
-//! Actor-related events
-
-use bevy::prelude::*;
-use yarnspinner::{core::LineId, runtime::{Command, DialogueOption, Line, OptionId}};
-
-/// Event called by user to progress dialogue
-#[derive(Debug, Event)]
-pub enum ContinueDialogueEvent {
-    /// Continue to next line of dialogue for given actor entity
-    Continue(Entity),
-    /// Submit option selection to given actor entity
-    SelectedOption { 
-        /// Target actor entity
-        actor: Entity,
-        /// Selected option ID
-        option: OptionId 
-    },
-}
-
-/// Event called by plugin in response to a corresponding yarnspinner dialogue events
-///
-/// The user should catch these events to update UI, and never call it directly.
-#[derive(Event)]
-pub enum DialogueEvent {
-    /// Recieved new line of dialogue
-    Line {
-        /// Actor entity
-        actor: Entity,
-        /// Line of dialogue received
-        line: Line,
-    },
-    /// Dialogue complete
-    DialogueComplete {
-        /// Actor entity
-        actor: Entity,
-    },
-    /// Encountered an option selection
-    Options {
-        /// Actor entity
-        actor: Entity,
-        /// Options to select from
-        options: Vec<DialogueOption>,
-    },
-    /// Triggered a yarnspinner command
-    Command {
-        /// Actor entity
-        actor: Entity,
-        /// Triggered command
-        command: Command,
-    },
-    /// Node started
-    NodeStart {
-        /// Actor entity
-        actor: Entity,
-        /// Name of started node
-        name: String,
-    },
-    /// Node complete
-    NodeComplete {
-        /// Actor entity
-        actor: Entity,
-        /// Name of completed node
-        name: String,
-    },
-    /// Received line hints
-    LineHints {
-        /// Actor entity
-        actor: Entity,
-        /// Lines affected
-        lines: Vec<LineId>,
-    },
-}

src/actor/mod.rs

@@ -1,95 +0,0 @@
-//! NPCs containing their own individual yarnspinner contexts
-// TODO: Split off into own crate?
-
-use std::sync::{Arc, Mutex};
-
-use bevy::{prelude::*, utils::HashMap};
-use lazy_static::lazy_static;
-use resources::FunctionLibrary;
-use yarnspinner::core::YarnValue;
-
-pub mod components;
-pub mod events;
-pub mod resources;
-mod systems;
-
-lazy_static! {
-    /// Custom yarnspinner variable storage
-    /// Stores variables as <instance>.<varname>
-    /// Global variables are stored in the "global" instance
-    pub static ref DIRWORLD_VARIABLE_STORAGE: Arc<Mutex<DirworldVariableStorage>> =
-        Arc::new(Mutex::new(DirworldVariableStorage::default()));
-}
-
-/// Plugin which controls the behavior of actors
-pub struct ActorPlugin;
-
-impl Plugin for ActorPlugin {
-    fn build(&self, app: &mut App) {
-        let mut function_library = FunctionLibrary::default();
-        function_library.add_function("get_string", get_string);
-        function_library.add_function("get_number", get_number);
-        function_library.add_function("get_bool", get_bool);
-
-        app.add_systems(
-            Update,
-            (systems::handle_dialog_initiation, systems::progress_dialog, systems::handle_variable_set_commands),
-        )
-        .insert_resource(function_library)
-        .add_event::<events::ContinueDialogueEvent>()
-        .add_event::<events::DialogueEvent>();
-    }
-}
-
-fn get_string(instance_name: &str, var_name: &str) -> String {
-    if let Some(YarnValue::String(value)) = DIRWORLD_VARIABLE_STORAGE
-        .lock()
-        .unwrap()
-        .get(instance_name, var_name)
-    {
-        value
-    } else {
-        "".into()
-    }
-}
-
-fn get_number(instance_name: &str, var_name: &str) -> f32 {
-    if let Some(YarnValue::Number(value)) = DIRWORLD_VARIABLE_STORAGE
-        .lock()
-        .unwrap()
-        .get(instance_name, var_name)
-    {
-        value
-    } else {
-        0.0
-    }
-}
-
-fn get_bool(instance_name: &str, var_name: &str) -> bool {
-    if let Some(YarnValue::Boolean(value)) = DIRWORLD_VARIABLE_STORAGE
-        .lock()
-        .unwrap()
-        .get(instance_name, var_name)
-    {
-        value
-    } else {
-        false
-    }
-}
-
-/// Variable Storage
-#[derive(Default, Debug)]
-pub struct DirworldVariableStorage(pub HashMap<String, YarnValue>);
-
-impl DirworldVariableStorage {
-    /// Set value of instance variable (use "global" for global)
-    pub fn set(&mut self, instance_name: &str, var_name: &str, value: YarnValue) {
-        self.0.insert(format!("{instance_name}.{var_name}"), value);
-    }
-
-    /// Get value of instance variable (use "global" for global)
-    pub fn get(&self, instance_name: &str, var_name: &str) -> Option<YarnValue> {
-        self.0.get(&format!("{instance_name}.{var_name}")).cloned()
-    }
-}
-

src/actor/resources.rs

@@ -1,8 +0,0 @@
-//! Actor-related resources
-
-use bevy::prelude::*;
-use yarnspinner::core::Library;
-
-/// Library of yarnspinner function callbacks
-#[derive(Resource, Deref, DerefMut, Default, Debug)]
-pub struct FunctionLibrary(pub Library);

src/actor/systems.rs

@@ -1,121 +0,0 @@
-use bevy::prelude::*;
-use bevy_basic_interaction::events::InteractionEvent;
-use yarnspinner::core::YarnValue;
-
-use super::{
-    components::Actor,
-    events::{ContinueDialogueEvent, DialogueEvent}, DIRWORLD_VARIABLE_STORAGE,
-};
-
-pub fn handle_dialog_initiation(
-    mut event_reader: EventReader<InteractionEvent>,
-    mut actor_query: Query<(Entity, &mut Actor)>,
-    mut event_writer: EventWriter<ContinueDialogueEvent>,
-) {
-    for InteractionEvent { interactable, .. } in event_reader.read() {
-        if let Ok((actor_entity, mut actor)) = actor_query.get_mut(*interactable) {
-            actor.active = true;
-            event_writer.send(ContinueDialogueEvent::Continue(actor_entity));
-        }
-    }
-}
-
-pub fn progress_dialog(
-    mut event_reader: EventReader<ContinueDialogueEvent>,
-    mut actor_query: Query<&mut Actor>,
-    mut event_writer: EventWriter<DialogueEvent>,
-) {
-    for event in event_reader.read() {
-        let actor_entity = match event {
-            ContinueDialogueEvent::Continue(actor) => actor,
-            ContinueDialogueEvent::SelectedOption { actor, .. } => actor,
-        };
-
-        if let Ok(mut actor) = actor_query.get_mut(*actor_entity) {
-            if let ContinueDialogueEvent::SelectedOption { option, .. } = event {
-                actor.dialogue.set_selected_option(*option).unwrap();
-            }
-            if actor.dialogue.current_node().is_none() {
-                actor.dialogue.set_node("Start").unwrap();
-            }
-            match actor.dialogue.continue_() {
-                Ok(events) => {
-                    info!("BATCH");
-                    for event in events {
-                        info!("Event: {:?}", event);
-                        match event {
-                            yarnspinner::prelude::DialogueEvent::Line(line) => {
-                                event_writer.send(DialogueEvent::Line {
-                                    actor: *actor_entity,
-                                    line,
-                                });
-                            }
-                            yarnspinner::prelude::DialogueEvent::DialogueComplete => {
-                                event_writer.send(DialogueEvent::DialogueComplete {
-                                    actor: *actor_entity,
-                                });
-                            }
-                            yarnspinner::prelude::DialogueEvent::Options(options) => {
-                                event_writer.send(DialogueEvent::Options {
-                                    actor: *actor_entity,
-                                    options,
-                                });
-                            }
-                            yarnspinner::runtime::DialogueEvent::Command(command) => {
-                                event_writer.send(DialogueEvent::Command {
-                                    actor: *actor_entity,
-                                    command,
-                                });
-                            }
-                            yarnspinner::runtime::DialogueEvent::NodeStart(name) => {
-                                event_writer.send(DialogueEvent::NodeStart {
-                                    actor: *actor_entity,
-                                    name,
-                                });
-                            }
-                            yarnspinner::runtime::DialogueEvent::NodeComplete(name) => {
-                                event_writer.send(DialogueEvent::NodeComplete {
-                                    actor: *actor_entity,
-                                    name,
-                                });
-                            }
-                            yarnspinner::runtime::DialogueEvent::LineHints(lines) => {
-                                event_writer.send(DialogueEvent::LineHints {
-                                    actor: *actor_entity,
-                                    lines,
-                                });
-                            }
-                        }
-                    }
-                }
-                Err(err) => error!("{:?}", err),
-            }
-        }
-    }
-}
-
-pub fn handle_variable_set_commands(
-    mut event_reader: EventReader<DialogueEvent>,
-    mut event_writer: EventWriter<ContinueDialogueEvent>,
-) {
-    for event in event_reader.read() {
-        if let DialogueEvent::Command { command, actor } = event {
-            if command.name != "set_var" {
-                continue;
-            }
-
-            event_writer.send(ContinueDialogueEvent::Continue(*actor));
-
-            if command.parameters.len() != 3 {
-                warn!("Incorrect number of parameters passed to set command: {}", command.parameters.len());
-                continue;
-            }
-
-            if let YarnValue::String(instance_name) = &command.parameters[0] {
-                if let YarnValue::String(var_name) = &command.parameters[1] {
-                    DIRWORLD_VARIABLE_STORAGE.lock().unwrap().set(instance_name, var_name, command.parameters[2].clone());
-                }
-            }
-        }
-    }
-}

src/events.rs

@@ -0,0 +1,6 @@
+use bevy::prelude::*;
+use yarnspinner::runtime::DialogueOption;
+
+/// Event called when a dialog option is selected
+#[derive(Event, Debug)]
+pub struct OptionSelectedEvent(pub DialogueOption);

src/lib.rs

@@ -8,14 +8,16 @@ use bevy::prelude::*;
 mod systems;
 pub mod widgets;
 pub mod util;
-pub mod actor;
+
+mod events;
+pub use events::*;
 
 /// Plugin which provides dialog functionality
 pub struct TerminalDialogPlugin;
 
 impl Plugin for TerminalDialogPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugins(actor::ActorPlugin)
+        app.add_systems(Startup, systems::setup).add_event::<OptionSelectedEvent>();
-            .add_systems(Startup, systems::setup);
     }
 }
+

src/systems.rs

@@ -1,24 +1,21 @@
+use std::time::Duration;
+
 use bevy::prelude::*;
 use bevy_terminal_display::widgets::components::Widget;
 
-use super::widgets::{DialogBox, DialogBoxWidget, InteractTooltip, InteractTooltipWidget, OptionsBox, OptionsBoxWidget};
+use super::widgets::{DialogBox, DialogBoxWidget, OptionsBox, OptionsBoxWidget};
 
 pub fn setup(mut commands: Commands) {
-    commands.spawn((
-        InteractTooltip,
-        Widget {
-            enabled: false,
-            depth: 0,
-            widget: Box::new(InteractTooltipWidget),
-        },
-    ));
-
     commands.spawn((
         DialogBox,
         Widget {
             enabled: false,
             depth: 0,
-            widget: Box::<DialogBoxWidget>::default(),
+            widget: Box::new(DialogBoxWidget::new(
+                None,
+                vec![],
+                Duration::from_millis(25),
+            )),
         },
     ));
     commands.spawn((

src/util.rs

@@ -18,53 +18,50 @@ pub fn style_line(line: &yarnspinner::runtime::Line) -> Vec<(String, Style)> {
         Style::new(),
     ));
     for (i, attribute) in attributes.iter().enumerate() {
-        let mut attrib_text = line.text_for_attribute(&attribute).to_string();
+        let mut attrib_text = line.text_for_attribute(attribute).to_string();
         let mut style = Style::new();
-        match attribute.name.as_str() {
+        if attribute.name.as_str() == "style" {
-            "style" => {
+            for (property_name, property_value) in attribute.properties.iter() {
-                for (property_name, property_value) in attribute.properties.iter() {
+                match property_name.as_str() {
-                    match property_name.as_str() {
+                    "bold" => {
-                        "bold" => {
+                        if let MarkupValue::Bool(value) = property_value {
-                            if let MarkupValue::Bool(value) = property_value {
+                            if *value {
-                                if *value {
+                                style = style.bold();
-                                    style = style.bold();
-                                }
                             }
                         }
-                        "italic" => {
-                            if let MarkupValue::Bool(value) = property_value {
-                                if *value {
-                                    style = style.italic();
-                                }
-                            }
-                        }
-                        "color" => {
-                            if let MarkupValue::Integer(value) = property_value {
-                                style = style.fg(Color::Indexed(*value as u8))
-                            }
-                        }
-                        "zalgo" => {
-                            if let MarkupValue::Bool(value) = property_value {
-                                if *value {
-                                    let mut generator = Generator::new();
-                                    let mut out = String::new();
-                                    let args =
-                                        GeneratorArgs::new(true, true, true, ZalgoSize::Mini);
-                                    generator.gen(&attrib_text, &mut out, &args);
-                                    attrib_text = out;
-                                }
-                            }
-                        }
-                        "bg" => {
-                            if let MarkupValue::Integer(value) = property_value {
-                                style = style.bg(Color::Indexed(*value as u8))
-                            }
-                        }
-                        _ => (),
                     }
+                    "italic" => {
+                        if let MarkupValue::Bool(value) = property_value {
+                            if *value {
+                                style = style.italic();
+                            }
+                        }
+                    }
+                    "color" => {
+                        if let MarkupValue::Integer(value) = property_value {
+                            style = style.fg(Color::Indexed(*value as u8))
+                        }
+                    }
+                    "zalgo" => {
+                        if let MarkupValue::Bool(value) = property_value {
+                            if *value {
+                                let mut generator = Generator::new();
+                                let mut out = String::new();
+                                let args =
+                                    GeneratorArgs::new(true, true, true, ZalgoSize::Mini);
+                                generator.gen(&attrib_text, &mut out, &args);
+                                attrib_text = out;
+                            }
+                        }
+                    }
+                    "bg" => {
+                        if let MarkupValue::Integer(value) = property_value {
+                            style = style.bg(Color::Indexed(*value as u8))
+                        }
+                    }
+                    _ => (),
                 }
             }
-            _ => (),
         }
         if attribute.name != "character" {
             line_segments.push((attrib_text, style))

src/widgets.rs

@@ -1,54 +1,90 @@
 //! bevy_terminal_display widgets for dialog boxes
 
-use bevy::prelude::*;
+use std::time::{Duration, Instant};
-use bevy_terminal_display::{crossterm, ratatui::{layout::{Alignment, Constraint, Flex, Layout}, style::Style, text::{Line, Span}, widgets::{Block, Borders, Clear, HighlightSpacing, List, ListItem, ListState, Padding, Paragraph, Wrap}}, widgets::TerminalWidget};
+
-use yarnspinner::runtime::DialogueOption;
-use unicode_segmentation::UnicodeSegmentation as _;
 use arbitrary_chunks::ArbitraryChunks as _;
+use bevy::prelude::*;
+use bevy_terminal_display::{
+    crossterm::{
+        self,
+        event::{Event, KeyCode, KeyEvent, KeyEventKind},
+    },
+    input::events::TerminalInputEvent,
+    ratatui::{
+        layout::{Constraint, Flex, Layout},
+        style::{Style, Stylize},
+        text::{Line, Span},
+        widgets::{
+            Block, Borders, Clear, HighlightSpacing, List, ListItem, ListState, Padding, Paragraph,
+            Wrap,
+        },
+    },
+    widgets::TerminalWidget,
+};
+use unicode_segmentation::UnicodeSegmentation as _;
+use yarnspinner::runtime::DialogueOption;
 
-/// Interaction tooltip widget marker
+use crate::OptionSelectedEvent;
-// TODO: Move tooltip out of this crate?
-#[derive(Component)]
-pub struct InteractTooltip;
-
-/// Interaction tooltip widget
-pub struct InteractTooltipWidget;
-
-impl TerminalWidget for InteractTooltipWidget {
-    fn render(
-        &mut self,
-        frame: &mut bevy_terminal_display::ratatui::Frame,
-        rect: bevy_terminal_display::ratatui::prelude::Rect,
-    ) {
-        let text = Paragraph::new("E")
-            .block(
-                Block::new()
-                    .borders(Borders::ALL)
-                    .padding(Padding::horizontal(1)),
-            )
-            .alignment(Alignment::Center);
-        let [area] = Layout::horizontal([Constraint::Length(5)])
-            .flex(Flex::Center)
-            .areas(rect);
-        let [area] = Layout::vertical([Constraint::Length(3)])
-            .flex(Flex::Center)
-            .areas(area);
-        frame.render_widget(Clear, area);
-        frame.render_widget(text, area);
-    }
-}
 
 /// Dialog box widget marker
 #[derive(Component)]
 pub struct DialogBox;
 
 /// Dialog box widget
-#[derive(Default)]
 pub struct DialogBoxWidget {
     /// Name of speaking character
-    pub character: Option<String>,
+    character: Option<String>,
     /// Chunks of text and corresponding styles representing the currently spoken line
-    pub text: Vec<(String, Style)>,
+    text: Vec<(String, Style)>,
+    /// Index of last character to draw (for typewriter effect).
+    typewriter_index: usize,
+    /// Time last character was drawn.
+    last_character: Instant,
+    /// Speed of typewriter effect (time between characters).
+    speed: Duration,
+    /// Number of characters in the text
+    character_count: usize,
+}
+
+impl DialogBoxWidget {
+    /// Constructs a new dialog box widget
+    pub fn new(character: Option<String>, text: Vec<(String, Style)>, speed: Duration) -> Self {
+        Self {
+            character,
+            character_count: text.iter().fold(0, |count, (string, _)| {
+                count + string.graphemes(true).count()
+            }),
+            text,
+            speed,
+            typewriter_index: 0,
+            last_character: Instant::now(),
+        }
+    }
+
+    /// Sets the character speaking, or title of the dialog
+    pub fn set_character(&mut self, character: Option<String>) {
+        self.character = character
+    }
+
+    /// Sets the text contained inside the dialog box
+    pub fn set_text(&mut self, text: Vec<(String, Style)>) {
+        self.character_count = text.iter().fold(0, |count, (string, _)| {
+            count + string.graphemes(true).count()
+        });
+        self.text = text;
+        self.typewriter_index = 0;
+        self.last_character = Instant::now();
+    }
+
+    /// Gets whether all of this dialog box's text has been displayed yet
+    pub fn typewriter_complete(&self) -> bool {
+        self.character_count == 0 || self.typewriter_index >= self.character_count
+    }
+
+    /// Skips the typewriter effect, displaying all text in the dialog box
+    pub fn skip_typewriter(&mut self) {
+        self.typewriter_index = self.character_count;
+    }
 }
 
 impl TerminalWidget for DialogBoxWidget {
@@ -57,11 +93,16 @@ impl TerminalWidget for DialogBoxWidget {
         frame: &mut bevy_terminal_display::ratatui::Frame,
         rect: bevy_terminal_display::ratatui::prelude::Rect,
     ) {
-        let text = Paragraph::new(bevy_terminal_display::ratatui::text::Line::from(
+        let line = Line::from_iter(
             self.text
                 .iter()
-                .map(|(text, style)| Span::styled(text, *style))
+                .map(|(text, style)| Span::styled(text, *style)),
-                .collect::<Vec<_>>(),
+        );
+        let graphemes = line.styled_graphemes(Style::default());
+        let text = Paragraph::new(Line::from_iter(
+            graphemes
+                .take(self.typewriter_index)
+                .map(|g| Span::styled(g.symbol, g.style)),
         ))
         .wrap(Wrap { trim: true })
         .block({
@@ -69,7 +110,7 @@ impl TerminalWidget for DialogBoxWidget {
                 .borders(Borders::ALL)
                 .padding(Padding::horizontal(1));
             if let Some(character) = &self.character {
-                block = block.title(character.clone());
+                block = block.title(Line::from(character.clone()).bold().underlined());
             }
             block
         });
@@ -82,6 +123,16 @@ impl TerminalWidget for DialogBoxWidget {
         frame.render_widget(Clear, area);
         frame.render_widget(text, area);
     }
+
+    fn update(&mut self, _time: &Time, _commands: &mut Commands) {
+        if self.character_count > 0
+            && self.typewriter_index < self.character_count
+            && self.last_character.elapsed() >= self.speed
+        {
+            self.typewriter_index += 1;
+            self.last_character = Instant::now();
+        }
+    }
 }
 
 /// Option selection box widget marker
@@ -178,4 +229,25 @@ impl TerminalWidget for OptionsBoxWidget {
         frame.render_widget(Clear, area);
         frame.render_stateful_widget(list, area, &mut self.state);
     }
+
+    fn handle_events(&mut self, event: &TerminalInputEvent, commands: &mut Commands) {
+        if let TerminalInputEvent(Event::Key(KeyEvent { code, kind, .. })) = event {
+            if kind == &KeyEventKind::Press {
+                match code {
+                    KeyCode::Up => {
+                        self.state.select_previous();
+                    }
+                    KeyCode::Down => {
+                        self.state.select_next();
+                    }
+                    KeyCode::Char('e') => {
+                        commands.send_event(OptionSelectedEvent(
+                            self.options[self.state.selected().unwrap()].0.clone(),
+                        ));
+                    }
+                    _ => (),
+                }
+            }
+        }
+    }
 }