use std::collections::HashMap;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
pub const POPUP_WIDTH: usize = 60;
const POPUP_INNER: usize = POPUP_WIDTH - 4;
pub const GHOST_PROCESS_TARGET: u32 = 5;
pub const ENV_MASTER_TARGET: u32 = 10;
pub const SPEED_RUNNER_MS: u32 = 5000;
pub const NIGHT_OWL_FROM_HOUR: u32 = 2;
pub const NIGHT_OWL_TO_HOUR: u32 = 5;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BadgeCondition {
FirstFixExecuted,
PerfectHealth { count: u32 },
PortWhisperer,
EnvMaster,
DependencyHero,
ArcadeWin { score: u32 },
SpeedRunner,
NightOwl,
}
impl BadgeCondition {
pub fn matches(&self, stats: &ArcadeStats) -> bool {
match *self {
BadgeCondition::FirstFixExecuted => stats.fixes_applied > 0,
BadgeCondition::PerfectHealth { count } => {
stats.perfect_health_streak >= count
}
BadgeCondition::PortWhisperer => stats.processes_killed >= GHOST_PROCESS_TARGET,
BadgeCondition::EnvMaster => stats.env_files_created >= ENV_MASTER_TARGET,
BadgeCondition::DependencyHero => false,
BadgeCondition::ArcadeWin { score } => stats.best_arcade_score > score,
BadgeCondition::SpeedRunner => stats
.last_diagnostic_time_ms
.is_some_and(|t| t < SPEED_RUNNER_MS),
BadgeCondition::NightOwl => stats.times_run.iter().any(|(&hour, &count)| {
count > 0 && (NIGHT_OWL_FROM_HOUR..=NIGHT_OWL_TO_HOUR).contains(&hour)
}),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Badge {
pub id: &'static str,
pub name: &'static str,
pub description: &'static str,
pub emoji: char,
pub unlock_condition: BadgeCondition,
}
pub const BADGES: &[Badge] = &[
Badge {
id: "port-whisperer",
name: "Port Whisperer",
description: "Kill 5 ghost processes.",
emoji: '\u{1F527}',
unlock_condition: BadgeCondition::PortWhisperer,
},
Badge {
id: "env-master",
name: "Env Master",
description: "Create 10 .env files.",
emoji: '\u{1F6E1}',
unlock_condition: BadgeCondition::EnvMaster,
},
Badge {
id: "speed-runner",
name: "Speed Runner",
description: "Finish a diagnostic scan in under 5 seconds.",
emoji: '\u{1F4A8}',
unlock_condition: BadgeCondition::SpeedRunner,
},
Badge {
id: "arcade-champion",
name: "Arcade Champion",
description: "Score over 500 in SyntaxBreaker.",
emoji: '\u{1F3AE}',
unlock_condition: BadgeCondition::ArcadeWin { score: 500 },
},
Badge {
id: "night-owl",
name: "Night Owl",
description: "Run Limitless between 2 AM and 5 AM.",
emoji: '\u{1F319}',
unlock_condition: BadgeCondition::NightOwl,
},
];
pub fn badge_by_id(id: &str) -> Option<&Badge> {
BADGES.iter().find(|b| b.id == id)
}
#[derive(Debug, Clone, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
pub struct ArcadeStats {
pub diagnostics_run: u32,
pub fixes_applied: u32,
pub perfect_health_streak: u32,
pub processes_killed: u32,
pub env_files_created: u32,
pub total_arcade_plays: u32,
pub best_arcade_score: u32,
pub last_diagnostic_time_ms: Option<u32>,
pub times_run: HashMap<u32, u32>,
}
impl ArcadeStats {
pub fn record_diagnostic(&mut self, duration_ms: u32) {
self.record_diagnostic_at(duration_ms, utc_hour_now());
}
pub fn record_diagnostic_at(&mut self, duration_ms: u32, hour: u32) {
self.diagnostics_run = self.diagnostics_run.saturating_add(1);
self.last_diagnostic_time_ms = Some(duration_ms);
let slot = self.times_run.entry(hour).or_insert(0);
*slot = slot.saturating_add(1);
}
pub fn record_perfect_health(&mut self) {
self.perfect_health_streak = self.perfect_health_streak.saturating_add(1);
}
pub fn reset_perfect_health(&mut self) {
self.perfect_health_streak = 0;
}
pub fn record_fix(&mut self) {
self.fixes_applied = self.fixes_applied.saturating_add(1);
}
pub fn record_process_killed(&mut self) {
self.processes_killed = self.processes_killed.saturating_add(1);
}
pub fn record_env_created(&mut self) {
self.env_files_created = self.env_files_created.saturating_add(1);
}
pub fn record_arcade_game(&mut self, score: u32) {
self.total_arcade_plays = self.total_arcade_plays.saturating_add(1);
self.best_arcade_score = self.best_arcade_score.max(score);
}
}
pub fn check_badges(stats: &ArcadeStats) -> Vec<String> {
BADGES
.iter()
.filter(|badge| badge.unlock_condition.matches(stats))
.map(|badge| badge.name.to_string())
.collect()
}
pub fn share_text(badge: &Badge) -> String {
format!("Share: \"I unlocked {} {} in Limitless\"", badge.emoji, badge.name)
}
fn popup_border(top: bool) -> String {
let (left, right) = if top { ('┌', '┐') } else { ('└', '┘') };
format!("{left}{}{right}", "─".repeat(POPUP_WIDTH - 2))
}
fn popup_row(content: &str) -> String {
format!("│ {} │", pad(content))
}
fn pad(content: &str) -> String {
let used = content.chars().count();
format!("{content}{}", " ".repeat(POPUP_INNER.saturating_sub(used)))
}
fn centered(content: &str) -> String {
let used = content.chars().count();
if used >= POPUP_INNER {
return content.to_string();
}
let total = POPUP_INNER - used;
let left = total / 2;
let right = total - left;
format!("{}{}{}", " ".repeat(left), content, " ".repeat(right))
}
pub fn render_badge_popup(badge: &Badge) -> String {
[
popup_border(true),
popup_row(¢ered("🎉 BADGE UNLOCKED!")),
popup_row(""),
popup_row(¢ered(&format!("{} {}", badge.emoji, badge.name))),
popup_row(¢ered(badge.description)),
popup_row(""),
popup_row(¢ered(&share_text(badge))),
popup_border(false),
]
.join("\n")
}
pub fn home_dir() -> Option<PathBuf> {
std::env::var_os("USERPROFILE")
.map(PathBuf::from)
.or_else(|| std::env::var_os("HOME").map(PathBuf::from))
}
pub fn progress_file_path() -> Option<PathBuf> {
home_dir().map(|home| home.join(".limitless").join("achievements.json"))
}
pub fn legacy_progress_path() -> Option<PathBuf> {
home_dir().map(|home| home.join(".limitless").join("stats.json"))
}
pub fn load_progress_migrated() -> AchievementProgress {
match home_dir() {
Some(home) => load_progress_at_home(&home),
None => AchievementProgress::default(),
}
}
fn load_progress_at_home(home: &Path) -> AchievementProgress {
let limitless = home.join(".limitless");
let path = limitless.join("achievements.json");
let progress = AchievementProgress::load(&path);
if !path.exists() {
if let Ok(raw) = fs::read_to_string(limitless.join("stats.json")) {
if let Ok(mut migrated) = serde_json::from_str::<AchievementProgress>(&raw) {
migrated.normalize();
let _ = migrated.save(&path);
return migrated;
}
}
}
progress
}
#[derive(Debug, Clone, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
pub struct AchievementProgress {
pub stats: ArcadeStats,
pub unlocked: Vec<String>,
}
impl AchievementProgress {
pub fn load(path: &Path) -> Self {
match fs::read_to_string(path) {
Ok(raw) => serde_json::from_str::<AchievementProgress>(&raw)
.map(|mut p| {
p.normalize();
p
})
.unwrap_or_default(),
Err(_) => Self::default(),
}
}
pub fn save(&self, path: &Path) -> io::Result<()> {
if let Some(parent) = path.parent() {
if !parent.as_os_str().is_empty() {
fs::create_dir_all(parent)?;
}
}
fs::write(path, serde_json::to_string_pretty(self)?)
}
pub fn normalize(&mut self) {
let mut seen = Vec::with_capacity(self.unlocked.len());
self.unlocked.retain(|name| {
if seen.contains(name) {
false
} else {
seen.push(name.clone());
true
}
});
}
pub fn satisfied(&self) -> Vec<String> {
check_badges(&self.stats)
.into_iter()
.filter(|name| !self.unlocked.contains(name))
.collect()
}
pub fn check_unlocked(&mut self) -> Vec<String> {
let new = self.satisfied();
self.unlocked.extend(new.iter().cloned());
new
}
}
fn utc_hour_now() -> u32 {
let secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
((secs / 3600) % 24) as u32
}
#[cfg(test)]
mod tests {
use super::*;
fn stats() -> ArcadeStats {
ArcadeStats::default()
}
struct TempDir(PathBuf);
impl TempDir {
fn new(tag: &str) -> Self {
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let path = std::env::temp_dir().join(format!(
"limitless_achievements_{}_{}_{}",
tag,
std::process::id(),
nanos
));
fs::create_dir_all(&path).expect("create temp dir");
Self(path)
}
fn path(&self) -> &Path {
&self.0
}
}
impl Drop for TempDir {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
#[test]
fn registry_has_all_five_badges_in_order() {
let ids: Vec<&str> = BADGES.iter().map(|b| b.id).collect();
assert_eq!(
ids,
vec![
"port-whisperer",
"env-master",
"speed-runner",
"arcade-champion",
"night-owl",
]
);
assert_eq!(BADGES.len(), 5);
assert!(BADGES[0].name.contains("Port"));
assert!(BADGES[4].name.contains("Night"));
}
#[test]
fn badge_emojis_are_single_unicode_scalars() {
for badge in BADGES {
assert_ne!(badge.emoji, '\0', "{}", badge.id);
assert!(!badge.emoji.is_ascii(), "{}", badge.id);
}
}
#[test]
fn badge_ids_are_unique() {
let mut ids: Vec<&str> = BADGES.iter().map(|b| b.id).collect();
ids.sort_unstable();
let mut dedup = ids.clone();
dedup.dedup();
assert_eq!(ids, dedup);
}
#[test]
fn badge_by_id_finds_known_and_misses_unknown() {
assert!(badge_by_id("night-owl").is_some());
assert_eq!(badge_by_id("night-owl").unwrap().emoji, '\u{1F319}');
assert!(badge_by_id("nope").is_none());
}
#[test]
fn port_whisperer_threshold() {
let mut s = stats();
assert!(!BadgeCondition::PortWhisperer.matches(&s));
s.processes_killed = GHOST_PROCESS_TARGET - 1;
assert!(!BadgeCondition::PortWhisperer.matches(&s));
s.processes_killed = GHOST_PROCESS_TARGET;
assert!(BadgeCondition::PortWhisperer.matches(&s));
s.processes_killed = 99;
assert!(BadgeCondition::PortWhisperer.matches(&s));
}
#[test]
fn env_master_threshold() {
let mut s = stats();
s.env_files_created = ENV_MASTER_TARGET - 1;
assert!(!BadgeCondition::EnvMaster.matches(&s));
s.env_files_created = ENV_MASTER_TARGET;
assert!(BadgeCondition::EnvMaster.matches(&s));
}
#[test]
fn speed_runner_threshold_is_strictly_below_once_scanned() {
let s = stats();
assert!(!BadgeCondition::SpeedRunner.matches(&s));
let mut s = s;
s.last_diagnostic_time_ms = Some(SPEED_RUNNER_MS);
assert!(!BadgeCondition::SpeedRunner.matches(&s));
s.last_diagnostic_time_ms = Some(SPEED_RUNNER_MS - 1);
assert!(BadgeCondition::SpeedRunner.matches(&s));
}
#[test]
fn arcade_win_threshold_is_strictly_above() {
let mut s = stats();
s.best_arcade_score = 500;
assert!(!BadgeCondition::ArcadeWin { score: 500 }.matches(&s));
s.best_arcade_score = 501;
assert!(BadgeCondition::ArcadeWin { score: 500 }.matches(&s));
}
#[test]
fn night_owl_only_matches_hours_2_to_5() {
let s = stats();
assert!(!BadgeCondition::NightOwl.matches(&s));
for hour in 0..=23 {
let mut probe = stats();
probe.times_run.insert(hour, 1);
assert_eq!(
BadgeCondition::NightOwl.matches(&probe),
(NIGHT_OWL_FROM_HOUR..=NIGHT_OWL_TO_HOUR).contains(&hour),
"hour {hour}"
);
}
}
#[test]
fn night_owl_requires_a_nonzero_count() {
let mut s = stats();
s.times_run.insert(3, 0);
assert!(!BadgeCondition::NightOwl.matches(&s));
s.times_run.insert(3, 1);
assert!(BadgeCondition::NightOwl.matches(&s));
}
#[test]
fn first_fix_and_perfect_health_match() {
let mut s = stats();
assert!(!BadgeCondition::FirstFixExecuted.matches(&s));
s.record_fix();
assert!(BadgeCondition::FirstFixExecuted.matches(&s));
assert!(!BadgeCondition::PerfectHealth { count: 3 }.matches(&s));
for _ in 0..3 {
s.record_perfect_health();
}
assert!(BadgeCondition::PerfectHealth { count: 3 }.matches(&s));
s.reset_perfect_health();
assert!(!BadgeCondition::PerfectHealth { count: 3 }.matches(&s));
}
#[test]
fn dependency_hero_is_reserved() {
let mut s = stats();
s.fixes_applied = 50;
s.processes_killed = 50;
s.env_files_created = 50;
s.best_arcade_score = 100_000;
s.perfect_health_streak = 50;
assert!(!BadgeCondition::DependencyHero.matches(&s));
}
#[test]
fn check_badges_empty_stats_is_empty() {
assert!(check_badges(&stats()).is_empty());
}
#[test]
fn check_badges_reports_only_satisfied_in_registry_order() {
let mut s = stats();
s.processes_killed = 5;
s.best_arcade_score = 501;
assert_eq!(check_badges(&s), vec!["Port Whisperer", "Arcade Champion"]);
}
#[test]
fn check_badges_speed_runner_and_night_owl() {
let mut s = stats();
s.last_diagnostic_time_ms = Some(4999);
s.times_run.insert(2, 1);
assert_eq!(check_badges(&s), vec!["Speed Runner", "Night Owl"]);
}
#[test]
fn share_text_matches_spec_format() {
let badge = badge_by_id("port-whisperer").unwrap();
assert_eq!(
share_text(badge),
"Share: \"I unlocked \u{1F527} Port Whisperer in Limitless\""
);
}
#[test]
fn popup_renders_header_name_and_share_line() {
let popup = render_badge_popup(badge_by_id("env-master").unwrap());
assert!(popup.contains("🎉 BADGE UNLOCKED!"));
assert!(popup.contains("Env Master"));
assert!(popup.contains("Create 10 .env files."));
assert!(popup.contains(&share_text(badge_by_id("env-master").unwrap())));
assert!(popup.lines().next().unwrap().starts_with('┌'));
assert!(popup.lines().last().unwrap().starts_with('└'));
}
#[test]
fn popup_rows_have_constant_width() {
for badge in BADGES {
for line in render_badge_popup(badge).lines() {
assert_eq!(line.chars().count(), POPUP_WIDTH, "{}", badge.id);
}
}
}
#[test]
fn popup_is_single_block_with_no_message_wrap() {
for badge in BADGES {
let popup = render_badge_popup(badge);
assert_eq!(popup.lines().count(), 8);
}
}
#[test]
fn stats_recording_helpers_bump_counters() {
let mut s = stats();
s.record_diagnostic_at(100, 4);
s.record_diagnostic_at(200, 4);
s.record_diagnostic_at(300, 10);
assert_eq!(s.diagnostics_run, 3);
assert_eq!(s.last_diagnostic_time_ms, Some(300));
assert_eq!(s.times_run.get(&4), Some(&2));
assert_eq!(s.times_run.get(&10), Some(&1));
assert_eq!(s.times_run.len(), 2);
s.record_fix();
s.record_process_killed();
s.record_env_created();
assert_eq!(s.fixes_applied, 1);
assert_eq!(s.processes_killed, 1);
assert_eq!(s.env_files_created, 1);
s.record_arcade_game(100);
s.record_arcade_game(900);
assert_eq!(s.total_arcade_plays, 2);
assert_eq!(s.best_arcade_score, 900);
}
#[test]
fn record_diagnostic_uses_a_valid_hour() {
let mut s = stats();
s.record_diagnostic(123);
assert_eq!(s.diagnostics_run, 1);
assert!(s.times_run.values().all(|&c| c == 1));
let (hour, _) = s.times_run.iter().next().unwrap();
assert!((0..24).contains(hour));
}
#[test]
fn progress_only_reports_newly_unlocked_once() {
let mut p = AchievementProgress::default();
p.stats.processes_killed = 5;
assert_eq!(p.check_unlocked(), vec!["Port Whisperer"]);
assert!(p.check_unlocked().is_empty());
assert_eq!(p.unlocked, vec!["Port Whisperer"]);
p.stats.best_arcade_score = 900;
assert_eq!(p.check_unlocked(), vec!["Arcade Champion"]);
}
#[test]
fn progress_normalize_deduplicates_keeping_order() {
let mut p = AchievementProgress {
unlocked: vec!["b".into(), "a".into(), "b".into(), "c".into()],
..Default::default()
};
p.normalize();
assert_eq!(p.unlocked, vec!["b", "a", "c"]);
}
#[test]
fn satisfied_excludes_already_unlocked() {
let mut p = AchievementProgress::default();
p.stats.processes_killed = 5;
p.unlocked = vec!["Port Whisperer".into()];
assert!(p.satisfied().is_empty());
}
#[test]
fn progress_round_trips_through_json() {
let mut p = AchievementProgress::default();
p.stats.diagnostics_run = 7;
p.stats.times_run.insert(3, 4);
assert_eq!(p.check_unlocked(), vec!["Night Owl"]);
p.stats.best_arcade_score = 800;
assert_eq!(p.check_unlocked(), vec!["Arcade Champion"]);
let json = serde_json::to_string(&p).unwrap();
let back: AchievementProgress = serde_json::from_str(&json).unwrap();
assert_eq!(back, p);
assert_eq!(back.unlocked, vec!["Night Owl", "Arcade Champion"]);
assert_eq!(back.stats.diagnostics_run, 7);
assert_eq!(back.stats.times_run.get(&3), Some(&4));
}
#[test]
fn refine_save_and_load_round_trip() {
let dir = TempDir::new("roundtrip");
let path = dir.path().join("stats.json");
let mut p = AchievementProgress::default();
p.stats.env_files_created = 10;
p.check_unlocked();
p.save(&path).unwrap();
assert!(path.exists());
let back = AchievementProgress::load(&path);
assert_eq!(back.unlocked, vec!["Env Master"]);
assert_eq!(back.stats.env_files_created, 10);
}
#[test]
fn load_missing_or_corrupt_file_yields_default() {
let dir = TempDir::new("missing");
let missing = AchievementProgress::load(&dir.path().join("nope.json"));
assert!(missing.stats.diagnostics_run == 0 && missing.unlocked.is_empty());
let path = dir.path().join("bad.json");
fs::write(&path, "not json").unwrap();
let corrupt = AchievementProgress::load(&path);
assert!(corrupt.stats.diagnostics_run == 0 && corrupt.unlocked.is_empty());
}
#[test]
fn progress_file_path_points_into_home_dir() {
let path = progress_file_path().expect("home dir should exist in tests");
assert_eq!(path.file_name().unwrap(), "achievements.json");
assert_eq!(path.parent().unwrap().file_name().unwrap(), ".limitless");
}
#[test]
fn load_progress_at_home_migrates_legacy_stats_file() {
let dir = TempDir::new("migrate");
fs::create_dir_all(dir.path().join(".limitless")).unwrap();
let mut from_the_past = AchievementProgress::default();
from_the_past.stats.record_fix();
from_the_past.stats.record_diagnostic(700);
from_the_past.unlocked.push("Env Master".into());
let legacy = dir.path().join(".limitless").join("stats.json");
fs::write(&legacy, serde_json::to_string_pretty(&from_the_past).unwrap()).unwrap();
let migrated = load_progress_at_home(dir.path());
assert_eq!(migrated, from_the_past);
assert!(dir.path().join(".limitless").join("achievements.json").is_file());
assert!(legacy.exists());
}
#[test]
fn load_progress_at_home_skips_migration_when_present() {
let dir = TempDir::new("skipmig");
fs::create_dir_all(dir.path().join(".limitless")).unwrap();
let mut current = AchievementProgress::default();
current.stats.record_diagnostic(900);
fs::write(
dir.path().join(".limitless").join("achievements.json"),
serde_json::to_string_pretty(¤t).unwrap(),
)
.unwrap();
let mut stale = AchievementProgress::default();
stale.stats.record_diagnostic(100);
fs::write(
dir.path().join(".limitless").join("stats.json"),
serde_json::to_string_pretty(&stale).unwrap(),
)
.unwrap();
assert_eq!(load_progress_at_home(dir.path()), current);
}
#[test]
fn test_badge_unlock_logic() {
assert_eq!(check_badges(&ArcadeStats::default()), Vec::<String>::new());
let near = ArcadeStats {
processes_killed: 4,
..ArcadeStats::default()
};
assert!(!check_badges(&near).contains(&"Port Whisperer".to_string()));
let port = ArcadeStats {
processes_killed: 5,
..ArcadeStats::default()
};
assert!(check_badges(&port).contains(&"Port Whisperer".to_string()));
let env = ArcadeStats {
env_files_created: 12,
..ArcadeStats::default()
};
assert!(check_badges(&env).contains(&"Env Master".to_string()));
let arcade = ArcadeStats {
best_arcade_score: 600,
..ArcadeStats::default()
};
assert!(check_badges(&arcade).contains(&"Arcade Champion".to_string()));
let owl = ArcadeStats {
times_run: {
let mut m = std::collections::HashMap::new();
m.insert(3, 1);
m
},
..ArcadeStats::default()
};
assert!(check_badges(&owl).contains(&"Night Owl".to_string()));
let day = ArcadeStats {
times_run: {
let mut m = std::collections::HashMap::new();
m.insert(14, 1);
m
},
..ArcadeStats::default()
};
assert!(!check_badges(&day).contains(&"Night Owl".to_string()));
let combined = ArcadeStats {
processes_killed: 5,
env_files_created: 12,
best_arcade_score: 600,
..ArcadeStats::default()
};
let unlocked = check_badges(&combined);
assert!(unlocked.contains(&"Port Whisperer".to_string()));
assert!(unlocked.contains(&"Env Master".to_string()));
assert!(unlocked.contains(&"Arcade Champion".to_string()));
assert_eq!(unlocked.len(), 3);
}
}