Prepare v0.0.2 pre-release

src/config.rs

@@ -12,6 +12,7 @@ pub const APP_DIRECTORY: &str = "mudmouth";
 pub struct Config {
     pub kokoro_url: String,
     pub log_path: Option<PathBuf>,
+    pub game_directory: Option<PathBuf>,
     pub volume: f32,
     pub max_queue_length: usize,
     pub repeat_window_seconds: u64,
@@ -32,6 +33,7 @@ impl Default for Config {
         Self {
             kokoro_url: "http://127.0.0.1:8880".into(),
             log_path: None,
+            game_directory: None,
             volume: 0.85,
             max_queue_length: 10,
             repeat_window_seconds: 15,

src/eq_discovery.rs

@@ -0,0 +1,208 @@
+use std::{
+    collections::BTreeSet,
+    env, fs,
+    path::{Path, PathBuf},
+};
+
+const STEAM_GAME_FOLDERS: &[&str] = &["Everquest F2P", "EverQuest"];
+const DAYBREAK_GAME_FOLDERS: &[&str] = &["EverQuest", "Everquest", "EverQuest Legends"];
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CharacterLog {
+    pub character: String,
+    pub server: Option<String>,
+    pub path: PathBuf,
+    pub game_directory: PathBuf,
+}
+
+impl CharacterLog {
+    pub fn display_name(&self) -> String {
+        self.server.as_ref().map_or_else(
+            || self.character.clone(),
+            |server| format!("{} — {server}", self.character),
+        )
+    }
+}
+
+pub fn discover_character_logs(configured_game_directory: Option<&Path>) -> Vec<CharacterLog> {
+    let mut game_directories = BTreeSet::new();
+    if let Some(directory) = configured_game_directory {
+        game_directories.insert(directory.to_path_buf());
+    }
+    game_directories.extend(default_game_directories());
+
+    let mut logs = game_directories
+        .into_iter()
+        .flat_map(|directory| logs_in_game_directory(&directory))
+        .collect::<Vec<_>>();
+    logs.sort_by_key(|log| log.display_name());
+    logs.dedup_by(|left, right| left.path == right.path);
+    logs
+}
+
+pub fn logs_in_game_directory(game_directory: &Path) -> Vec<CharacterLog> {
+    [game_directory.to_path_buf(), game_directory.join("Logs")]
+        .into_iter()
+        .flat_map(|directory| logs_in_directory(&directory, game_directory))
+        .collect()
+}
+
+fn logs_in_directory(directory: &Path, game_directory: &Path) -> Vec<CharacterLog> {
+    let Ok(entries) = fs::read_dir(directory) else {
+        return Vec::new();
+    };
+    entries
+        .filter_map(Result::ok)
+        .filter_map(|entry| {
+            let path = entry.path();
+            path.is_file()
+                .then(|| character_log_from_path(path, game_directory.to_path_buf()))
+                .flatten()
+        })
+        .collect()
+}
+
+fn character_log_from_path(path: PathBuf, game_directory: PathBuf) -> Option<CharacterLog> {
+    let file_name = path.file_name()?.to_string_lossy().into_owned();
+    let stem = file_name.strip_suffix(".txt")?;
+    let stem = stem
+        .strip_prefix("eqlog_")
+        .or_else(|| stem.strip_prefix("EQLOG_"))?;
+    if stem.is_empty() {
+        return None;
+    }
+    let (character, server) = stem
+        .split_once('_')
+        .map_or((stem, None), |(character, server)| {
+            (character, Some(server))
+        });
+    (!character.is_empty()).then(|| CharacterLog {
+        character: character.to_owned(),
+        server: server
+            .filter(|server| !server.is_empty())
+            .map(str::to_owned),
+        path,
+        game_directory,
+    })
+}
+
+fn default_game_directories() -> BTreeSet<PathBuf> {
+    let mut directories = BTreeSet::new();
+    for steam_library in steam_libraries() {
+        for game_folder in STEAM_GAME_FOLDERS {
+            directories.insert(steam_library.join("steamapps/common").join(game_folder));
+        }
+    }
+
+    if cfg!(target_os = "windows") {
+        for public_directory in windows_public_directories() {
+            for game_folder in DAYBREAK_GAME_FOLDERS {
+                directories.insert(
+                    public_directory
+                        .join("Daybreak Game Company/Installed Games")
+                        .join(game_folder),
+                );
+            }
+        }
+        directories.insert(PathBuf::from(r"C:\EverQuest"));
+        directories.insert(PathBuf::from(r"C:\Program Files\EverQuest"));
+        directories.insert(PathBuf::from(r"C:\Program Files (x86)\EverQuest"));
+        for game_folder in DAYBREAK_GAME_FOLDERS {
+            directories.insert(
+                PathBuf::from(r"C:\Users\Public\Daybreak Game Company\Installed Games")
+                    .join(game_folder),
+            );
+        }
+    }
+    directories
+}
+
+fn windows_public_directories() -> Vec<PathBuf> {
+    let mut directories = vec![PathBuf::from(r"C:\Users\Public")];
+    if let Some(directory) = env::var_os("PUBLIC") {
+        directories.push(PathBuf::from(directory));
+    }
+    directories
+}
+
+fn steam_libraries() -> BTreeSet<PathBuf> {
+    let mut libraries = BTreeSet::new();
+    let mut steam_roots = BTreeSet::new();
+
+    for variable in ["PROGRAMFILES(X86)", "PROGRAMFILES", "USERPROFILE"] {
+        if let Some(value) = env::var_os(variable) {
+            steam_roots.insert(PathBuf::from(value).join("Steam"));
+        }
+    }
+    if let Some(home) = dirs::home_dir() {
+        steam_roots.extend([
+            home.join(".steam/steam"),
+            home.join(".local/share/Steam"),
+            home.join(".var/app/com.valvesoftware.Steam/.local/share/Steam"),
+        ]);
+    }
+    if cfg!(target_os = "windows") {
+        steam_roots.extend([
+            PathBuf::from(r"C:\Program Files (x86)\Steam"),
+            PathBuf::from(r"C:\Program Files\Steam"),
+        ]);
+    }
+
+    for steam_root in steam_roots {
+        libraries.insert(steam_root.clone());
+        if let Ok(contents) = fs::read_to_string(steam_root.join("steamapps/libraryfolders.vdf")) {
+            libraries.extend(steam_library_paths_from_vdf(&contents));
+        }
+    }
+    libraries
+}
+
+fn steam_library_paths_from_vdf(contents: &str) -> Vec<PathBuf> {
+    contents
+        .lines()
+        .filter_map(|line| {
+            let quoted = line.split('"').skip(1).step_by(2).collect::<Vec<_>>();
+            (quoted.first() == Some(&"path") && quoted.get(1).is_some())
+                .then(|| PathBuf::from(quoted[1].replace(r"\\", r"\")))
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn finds_character_logs_in_the_game_logs_directory() {
+        let temporary = tempdir().unwrap();
+        let game_directory = temporary.path().join("EverQuest");
+        let logs_directory = game_directory.join("Logs");
+        fs::create_dir_all(&logs_directory).unwrap();
+        fs::write(logs_directory.join("eqlog_Pleb_oggok.txt"), "").unwrap();
+        fs::write(game_directory.join("eqlog_Lucy_tunare.txt"), "").unwrap();
+        fs::write(game_directory.join("notes.txt"), "").unwrap();
+
+        let logs = logs_in_game_directory(&game_directory);
+        assert_eq!(logs.len(), 2);
+        assert!(logs.iter().any(|log| log.display_name() == "Pleb — oggok"));
+        assert!(logs.iter().any(|log| log.display_name() == "Lucy — tunare"));
+    }
+
+    #[test]
+    fn reads_steam_library_paths() {
+        let contents = r#"
+"libraryfolders"
+{
+    "0"
+    {
+        "path" "D:\\SteamLibrary"
+    }
+}
+"#;
+        assert_eq!(
+            steam_library_paths_from_vdf(contents),
+            vec![PathBuf::from(r"D:\SteamLibrary")]
+        );
+    }
+}

src/main.rs

@@ -1,4 +1,5 @@
 mod config;
+mod eq_discovery;
 mod events;
 mod kokoro;
 mod speakers;
@@ -76,15 +77,12 @@ async fn main() -> Result<()> {
     );
 
     let tailer_generation = Arc::new(AtomicUsize::new(0));
-    if let Some(path) = config.log_path.clone() {
+    if config.log_path.as_ref().is_some_and(|path| path.is_file()) {
+        let path = config.log_path.clone().expect("log path was checked");
         spawn_log_tailer(path, worker_sender.clone(), tailer_generation.clone(), 0);
     }
 
     let mut app = App::new(config, speakers);
-    if app.config.log_path.is_none() {
-        app.activity
-            .push_front("First run: press [s] and configure your EverQuest log path.".into());
-    }
     let channels = RuntimeChannels {
         worker_receiver,
         worker_sender,
@@ -128,7 +126,7 @@ async fn run_loop(
                         .audio_control
                         .send(AudioCommand::SetVolume(app.config.volume));
                     let generation = channels.tailer_generation.fetch_add(1, Ordering::Relaxed) + 1;
-                    if let Some(path) = app.config.log_path.clone() {
+                    if let Some(path) = app.config.log_path.clone().filter(|path| path.is_file()) {
                         spawn_log_tailer(
                             path,
                             channels.worker_sender.clone(),

src/tui.rs

@@ -1,5 +1,6 @@
 use crate::{
     config::Config,
+    eq_discovery::{CharacterLog, discover_character_logs},
     speakers::SpeakerStore,
     workers::{KokoroStatus, WorkerEvent},
 };
@@ -22,6 +23,7 @@ const LOGO: &str = r#"
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Screen {
     Dashboard,
+    Setup,
     Settings,
     Speakers,
     Help,
@@ -44,8 +46,10 @@ pub struct App {
     pub activity: VecDeque<String>,
     pub selected_speaker: usize,
     pub selected_voice: usize,
+    pub selected_character_log: usize,
     pub settings_cursor: usize,
     pub speaker_filter: String,
+    pub character_logs: Vec<CharacterLog>,
     pub splash_until: std::time::Instant,
     pub input: Option<Input>,
 }
@@ -53,27 +57,52 @@ pub struct App {
 #[derive(Debug)]
 pub enum Input {
     Endpoint(String),
+    GameDirectory(String),
     LogPath(String),
     SpeakerSearch(String),
 }
 
 impl App {
     pub fn new(config: Config, speakers: SpeakerStore) -> Self {
+        let character_logs = discover_character_logs(config.game_directory.as_deref());
+        let log_is_configured = config.log_path.as_ref().is_some_and(|path| path.is_file());
+        let setup_input = (!log_is_configured && character_logs.is_empty()).then(|| {
+            Input::GameDirectory(
+                config
+                    .game_directory
+                    .as_ref()
+                    .map_or_else(String::new, |path| path.display().to_string()),
+            )
+        });
+        let mut activity = VecDeque::from(["The tavern is quiet. Waiting for log lines…".into()]);
+        if !log_is_configured {
+            activity.push_front(if character_logs.is_empty() {
+                "No EverQuest logs found. Enter your EverQuest game folder.".into()
+            } else {
+                format!("Found {} EverQuest character log(s).", character_logs.len())
+            });
+        }
         Self {
             config,
             speakers,
-            screen: Screen::Dashboard,
+            screen: if log_is_configured {
+                Screen::Dashboard
+            } else {
+                Screen::Setup
+            },
             kokoro_status: KokoroStatus::Checking,
             voices: Vec::new(),
             current_zone: None,
             queue_depth: 0,
-            activity: VecDeque::from(["The tavern is quiet. Waiting for log lines…".into()]),
+            activity,
             selected_speaker: 0,
             selected_voice: 0,
+            selected_character_log: 0,
             settings_cursor: 0,
             speaker_filter: String::new(),
+            character_logs,
             splash_until: std::time::Instant::now() + std::time::Duration::from_millis(1700),
-            input: None,
+            input: setup_input,
         }
     }
 
@@ -124,6 +153,7 @@ impl App {
                 None
             }
             _ => match self.screen {
+                Screen::Setup => self.handle_setup_key(key),
                 Screen::Settings => self.handle_settings_key(key),
                 Screen::Speakers => self.handle_speakers_key(key),
                 _ => None,
@@ -142,6 +172,12 @@ impl App {
                         self.config.kokoro_url = value.trim().trim_end_matches('/').to_string();
                         true
                     }
+                    Input::GameDirectory(value) => {
+                        self.config.game_directory = (!value.trim().is_empty())
+                            .then(|| std::path::PathBuf::from(value.trim()));
+                        self.refresh_character_logs();
+                        true
+                    }
                     Input::LogPath(value) => {
                         self.config.log_path = (!value.trim().is_empty())
                             .then(|| std::path::PathBuf::from(value.trim()));
@@ -162,12 +198,18 @@ impl App {
                 }
             }
             KeyCode::Backspace => match &mut input {
-                Input::Endpoint(value) | Input::LogPath(value) | Input::SpeakerSearch(value) => {
+                Input::Endpoint(value)
+                | Input::GameDirectory(value)
+                | Input::LogPath(value)
+                | Input::SpeakerSearch(value) => {
                     value.pop();
                 }
             },
             KeyCode::Char(character) => match &mut input {
-                Input::Endpoint(value) | Input::LogPath(value) | Input::SpeakerSearch(value) => {
+                Input::Endpoint(value)
+                | Input::GameDirectory(value)
+                | Input::LogPath(value)
+                | Input::SpeakerSearch(value) => {
                     value.push(character);
                 }
             },
@@ -218,6 +260,53 @@ impl App {
         None
     }
 
+    fn handle_setup_key(&mut self, key: KeyEvent) -> Option<UiAction> {
+        match key.code {
+            KeyCode::Up | KeyCode::Char('k') => {
+                self.selected_character_log = self.selected_character_log.saturating_sub(1)
+            }
+            KeyCode::Down | KeyCode::Char('j') => {
+                self.selected_character_log = (self.selected_character_log + 1)
+                    .min(self.character_logs.len().saturating_sub(1))
+            }
+            KeyCode::Enter => {
+                if let Some(log) = self.character_logs.get(self.selected_character_log) {
+                    self.config.log_path = Some(log.path.clone());
+                    self.config.game_directory = Some(log.game_directory.clone());
+                    self.screen = Screen::Dashboard;
+                    self.activity
+                        .push_front(format!("Following {}", log.display_name()));
+                    return Some(UiAction::ConfigChanged);
+                }
+            }
+            KeyCode::Char('p') => {
+                self.input = Some(Input::GameDirectory(
+                    self.config
+                        .game_directory
+                        .as_ref()
+                        .map_or_else(String::new, |path| path.display().to_string()),
+                ));
+            }
+            KeyCode::Char('r') => self.refresh_character_logs(),
+            _ => {}
+        }
+        None
+    }
+
+    fn refresh_character_logs(&mut self) {
+        self.character_logs = discover_character_logs(self.config.game_directory.as_deref());
+        self.selected_character_log = 0;
+        self.activity.push_front(if self.character_logs.is_empty() {
+            "No character logs found. In EverQuest, enable logging with /log on, then press [r]."
+                .into()
+        } else {
+            format!(
+                "Found {} EverQuest character log(s).",
+                self.character_logs.len()
+            )
+        });
+    }
+
     fn handle_speakers_key(&mut self, key: KeyEvent) -> Option<UiAction> {
         let keys = self.speaker_keys();
         match key.code {
@@ -291,6 +380,7 @@ pub fn draw(frame: &mut Frame, app: &App) {
     draw_header(frame, app, sections[0]);
     match app.screen {
         Screen::Dashboard => draw_dashboard(frame, app, sections[1]),
+        Screen::Setup => draw_setup(frame, app, sections[1]),
         Screen::Settings => draw_settings(frame, app, sections[1]),
         Screen::Speakers => draw_speakers(frame, app, sections[1]),
         Screen::Help => draw_help(frame, sections[1]),
@@ -305,6 +395,45 @@ pub fn draw(frame: &mut Frame, app: &App) {
     }
 }
 
+fn draw_setup(frame: &mut Frame, app: &App, area: Rect) {
+    let logs = app
+        .character_logs
+        .iter()
+        .enumerate()
+        .map(|(index, log)| {
+            ListItem::new(format!("{}  {}", log.display_name(), log.path.display())).style(
+                if index == app.selected_character_log {
+                    Style::default().fg(Color::Yellow).bold()
+                } else {
+                    Style::default()
+                },
+            )
+        })
+        .collect::<Vec<_>>();
+    let title = if logs.is_empty() {
+        " FIRST-TIME SETUP — [p] folder [r] rescan "
+    } else {
+        " FIRST-TIME SETUP — ↑↓ select character, Enter continue; [p] folder [r] rescan "
+    };
+    let empty = "No character logs found yet. Enter your EverQuest game folder.\n\n\
+                 After logging into a character, use /log on and press [r] here.";
+    frame.render_widget(
+        List::new(logs).block(Block::default().title(title).borders(Borders::ALL)),
+        area,
+    );
+    if app.character_logs.is_empty() {
+        frame.render_widget(
+            Paragraph::new(empty)
+                .style(Style::default().fg(Color::Gray))
+                .wrap(Wrap { trim: true }),
+            area.inner(Margin {
+                vertical: 1,
+                horizontal: 2,
+            }),
+        );
+    }
+}
+
 fn draw_splash(frame: &mut Frame) {
     let layout = Layout::vertical([
         Constraint::Percentage(25),
@@ -518,6 +647,7 @@ fn draw_input(frame: &mut Frame, input: &Input) {
     let area = centered_rect(80, 20, frame.area());
     let (label, value) = match input {
         Input::Endpoint(value) => ("Kokoro endpoint", value),
+        Input::GameDirectory(value) => ("EverQuest game folder", value),
         Input::LogPath(value) => ("EverQuest log path", value),
         Input::SpeakerSearch(value) => ("Search NPC", value),
     };