outfly/src/chat.rs

extern crate yaml_rust;
use bevy::prelude::*;
use yaml_rust::{Yaml, YamlLoader};
use crate::{audio};

pub const CHATS: &[&str] = &[
    include_str!("chats/serenity.yaml"),
    include_str!("chats/startrans.yaml"),
];

pub const TOKEN_CHAT: &str = "chat";

pub struct ChatPlugin;
impl Plugin for ChatPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, load_chats);
        app.add_systems(Update, (
            handle_new_conversations,
        ));
        app.add_event::<StartConversationEvent>();
        app.insert_resource(ChatDB(Vec::new()));
    }
}

#[derive(Resource)]
pub struct ChatDB(Vec<Yaml>);
impl ChatDB {
    pub fn get_chat_by_id(&self, id: &String) -> Result<u32, String> {
        let mut found: Option<u32> = None;
        for (index, object_yaml) in self.0.iter().enumerate() {
            if let Some(object_vec) = object_yaml.as_vec() {
                if object_vec.len() == 0 {
                    continue;
                }
                let first_item = &object_vec[0];
                if let Some(hash) = first_item.as_hash() {
                    if let Some(chat_id_yaml) = hash.get(&Yaml::String(TOKEN_CHAT.to_string())) {
                        if let Some(chat_id) = chat_id_yaml.as_str() {
                            if chat_id != id {
                                continue;
                            }
                            if found.is_some() {
                                return Err("Found multiple chats with the same id!".to_string());
                            }
                            found = Some(index as u32);
                        }
                    }
                }
            } else {
                warn!("Non-list YAML object found while processing chat specs");
            }
        }
        if let Some(result) = found {
            return Ok(result);
        }
        return Err(format!("No chat with the conversation ID `{id}` was found."));
    }
}

#[derive(Component)]
#[derive(Clone)]
pub struct Talker {
    pub conv_id: String,
    pub name: Option<String>,
    pub pronoun: Option<String>,
}

#[derive(Event)]
pub struct StartConversationEvent {
    pub talker: Talker,
}

pub fn load_chats(mut chatdb: ResMut<ChatDB>) {
    for chat_yaml in CHATS {
        if let Ok(mut yaml_data) = YamlLoader::load_from_str(chat_yaml) {
            chatdb.0.append(&mut yaml_data);
        } else {
            error!("Could not load chat definitions.  Validate files in `src/chats/` path.");
        }
    }
}

pub fn handle_new_conversations(
    //mut commands: Commands,
    mut er_conv: EventReader<StartConversationEvent>,
    mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
    chatdb: Res<ChatDB>,
    //time: Res<Time>,
) {
    for event in er_conv.read() {
        match (*chatdb).get_chat_by_id(&event.talker.conv_id) {
            Ok(chat_id) => {
                ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Ping));
                dbg!(chat_id);
            }
            Err(error) => {
                error!("Error while looking for chat ID: {error}");
            }
        }
    }
}