//! Horizon launcher: installs Horizon builds, prepares them from the player's own Minecraft, //! and starts the client or a dedicated server. mod agents_page; mod art; mod blocks; mod cli; mod cli_tools; mod collection; mod cull; mod game_tools; mod internet; mod markdown; mod mcp; mod modpacks_page; mod mods_page; mod mods_project; mod perf; mod scrollbar; mod servers_page; mod theme; use gpui::{ actions, div, ease_out_quint, prelude::*, px, relative, size, Animation, AnimationExt, AnyElement, App, Application, Bounds, ClickEvent, Context, Div, ElementId, FocusHandle, FontWeight, Hsla, KeyBinding, KeyDownEvent, Menu, MenuItem, PathPromptOptions, SharedString, Stateful, Subscription, TitlebarOptions, Window, WindowBounds, WindowOptions, }; use horizon_launcher::account::{self, Accounts, SignIn, SignInState}; use horizon_launcher::backend::{self, Job, Msg, Release, Running, Settings, Updates}; use horizon_launcher::telemetry; use scrollbar::Scrollbar; use std::borrow::Cow; use std::collections::VecDeque; use std::sync::atomic::Ordering; use std::sync::mpsc::{channel, Receiver, Sender}; use std::sync::Mutex; use std::time::{Duration, Instant}; use theme::Theme; #[derive(Clone, Copy, PartialEq)] enum Page { Play, Versions, /// Mods, resource packs and modpacks (imported ones and the browser's). Mods, Servers, Notes, Settings, } impl Page { /// `HORIZON_LAUNCHER_PAGE=mods` (or `modpacks`, `servers`, `versions`, `notes`, `settings`) /// opens on that page, for screenshots; Home otherwise. fn from_env() -> Page { match std::env::var("HORIZON_LAUNCHER_PAGE").as_deref() { Ok("mods" | "modpacks") => Page::Mods, Ok("servers") => Page::Servers, Ok("versions") => Page::Versions, Ok("notes") => Page::Notes, Ok("settings") => Page::Settings, _ => Page::Play, } } /// Every page, with its name and icon: the top bar shows all but Settings, which has its /// own button. const ALL: [(Page, &'static str, &'static str); 6] = [ (Page::Play, "Home", "home"), (Page::Mods, "Mods", "package"), (Page::Servers, "Servers", "server"), (Page::Versions, "Versions", "archive"), (Page::Notes, "Patch notes", "notes"), (Page::Settings, "Settings", "sliders"), ]; } /// The launcher's own update, as the footer and Settings show it. #[derive(Clone, PartialEq)] enum SelfUpdate { Idle, Downloading(String, f32), Ready(String), Failed(String), } /// The last game the launcher started ended badly: what it left behind. #[derive(Clone)] struct Crash { /// The crash report the run wrote, if it wrote one. report: Option, /// One line on what went wrong: the report's error, else how the process ended. summary: String, copied: bool, } /// The opening: the wordmark holds at least `OPENING_HOLD` (until the release /// list is in, at most `OPENING_MAX`), then the launcher appears over `OPENING_REVEAL`. const OPENING_HOLD: Duration = horizon_theme::OPENING_HOLD; const OPENING_MAX: Duration = horizon_theme::OPENING_MAX; const OPENING_REVEAL: Duration = horizon_theme::OPENING_REVEAL; /// The phase of the opening at one moment: how far the reveal has gone, 0 to 1. struct Opening { /// Set on the first frame, so a slow start does not eat into the hold. started: Option, reveal: Option, focus: FocusHandle, } fn ease_out_cubic(x: f32) -> f32 { horizon_theme::ease_out_cubic(x) } enum Load { Loading, Ready(T), Failed(String), } const LOG_LINES: usize = 2000; struct Launcher { theme: Theme, page: Page, /// How many times the page changed, for the page transition. switches: usize, content_scroll: Scrollbar, /// The rows of the page's long list (Versions, Patch notes) last drawn. long_list: cull::Cull, opening: Option, updates: Updates, checked: Option, update_error: Option, self_update: SelfUpdate, /// The Horizon version being installed as an update, and whether it becomes the selected one. update_install: Option<(String, bool)>, /// The install bar's previous and current fraction, so it moves rather than jumps. bar: (f32, f32), releases: Load>, installed: Vec, installing: Option<(String, f32)>, install_error: Option<(String, String)>, confirm_remove: Option, picker_open: bool, settings: Settings, /// The Discord, sponsor and website links: built in until links.json on main has been read. links: backend::Links, preparing: bool, prepare_log: VecDeque, prepare_error: Option, client: Option, client_error: Option, /// When the running client started, to tell its crash report from older ones. client_started: Option, /// The folder the running game keeps its settings in: the game home, or a modpack's. client_home: Option, crash: Option, /// The Servers page (`servers_page.rs`). servers: servers_page::Servers, /// Its Friends over the internet panel (`internet.rs`). internet: internet::Internet, /// The window's own focus, so Tab reaches the controls when nothing else has the keyboard. root_focus: FocusHandle, /// Microsoft accounts (accounts.json), the sign-in under way and what it last showed. accounts: Accounts, sign_in: Option, sign_in_state: Option, keychain: bool, /// The game is waiting for its session (a token renewal) before it starts. starting_client: Option, /// Join a friend: the code typed on the Play page, and the one the game /// starting now joins. friend_code: String, friend_focused: bool, friend_focus: FocusHandle, joining: Option, /// Settings' Game arguments field: the line, whether it has focus, and its focus handle. args_input: String, args_focused: bool, args_focus: FocusHandle, /// Opt-in data collection: the player's answer and Settings' section (`collection`). collection: collection::Collection, /// Settings' "Connect an AI agent" (`agents_page`). agents: agents_page::AgentsUi, /// How many play Horizon now, while the server answers ("N playing now" on the Play page). playing: Option, tx: Sender, rx: Receiver, _appearance: Subscription, /// The session's measurements (`perf.rs`), and when the steps they time began. perf: perf::Perf, install_started: Option, prepare_started: Option, play_pressed: Option, /// `horizon-launcher benchmark` started this window to measure it. bench: Option, /// The Modpacks page: the imported packs (read when the page first opens), the one shown, /// the report's filter, and the pipeline step running now with its log. packs: Vec, packs_loaded: Option, pack_open: Option, pack_filter: Option, pack_busy: bool, pack_log: VecDeque, pack_error: Option, /// The game starting now plays this pack's profile (its work folder). starting_pack: Option, /// The Mods page: the browser's search, installs and updates (`mods_page.rs`). mods: mods_page::Mods, /// The name the game made up for an offline player (`horizon-player.txt`), for the top bar. offline_name: Option, /// The player's servers, for the sidebar until the Servers page has read them. side_servers: Vec, /// The pixel art made for this window (`art.rs`), and pictures downloaded by URL. art: art::Art, /// The window's scale, as of its last frame, for art drawn outside `render`'s reach. scale: f32, } impl Launcher { fn new(window: &mut Window, cx: &mut Context) -> Self { let (tx, rx) = channel(); let appearance = cx.observe_window_appearance(window, |this, window, cx| { this.theme = Theme::for_appearance(this.settings.appearance, window.appearance()); cx.notify(); }); cx.spawn(async move |this, cx| loop { cx.background_executor() .timer(Duration::from_millis(80)) .await; if this.update(cx, |this, cx| this.drain(cx)).is_err() { break; } }) .detach(); let mut settings = Settings::load(); if settings.minecraft_dir.is_none() { settings.minecraft_dir = backend::default_minecraft_dir(); } // Release builds on Linux put their entry back in the applications menu when there is // none or it starts a program that is gone (a moved or deleted binary), never over one // that works; `HORIZON_LAUNCHER_DESKTOP_ENTRY=1` does it in a development build. if cfg!(target_os = "linux") && settings.desktop_entry() && (!cfg!(debug_assertions) || std::env::var_os("HORIZON_LAUNCHER_DESKTOP_ENTRY").is_some()) { std::thread::spawn(|| { let _ = horizon_launcher::desktop::repair(backend::exe_path()); }); } let installed = backend::installed(); if settings .selected .as_ref() .is_none_or(|s| !installed.contains(s)) { settings.selected = installed.first().cloned(); } let mut this = Self { theme: Theme::for_appearance(settings.appearance, window.appearance()), page: Page::from_env(), switches: 0, content_scroll: Scrollbar::default(), long_list: cull::Cull::default(), opening: (!settings.skip_opening).then(|| { let focus = cx.focus_handle(); window.focus(&focus); Opening { started: None, reveal: None, focus, } }), updates: Updates::default(), checked: None, update_error: None, self_update: SelfUpdate::Idle, update_install: None, bar: (0., 0.), releases: Load::Loading, installed, installing: None, install_error: None, confirm_remove: None, picker_open: false, args_input: settings.game_args.clone(), args_focused: false, args_focus: cx.focus_handle(), settings, links: backend::Links::default(), preparing: false, prepare_log: VecDeque::new(), prepare_error: None, client: None, client_error: None, client_started: None, client_home: None, crash: None, servers: servers_page::Servers::new(), internet: internet::Internet::new(), root_focus: cx.focus_handle(), accounts: Accounts::load(), sign_in: None, sign_in_state: None, keychain: true, starting_client: None, friend_code: String::new(), friend_focused: false, friend_focus: cx.focus_handle(), joining: None, collection: collection::Collection::load(), agents: agents_page::AgentsUi::default(), playing: None, tx, rx, _appearance: appearance, perf: perf::Perf::new("session"), install_started: None, prepare_started: None, play_pressed: None, bench: perf::Bench::from_env(), packs: Vec::new(), packs_loaded: None, pack_open: None, pack_filter: None, pack_busy: false, pack_log: VecDeque::new(), pack_error: None, starting_pack: None, mods: mods_page::Mods::new(cx), offline_name: offline_name(), side_servers: horizon_launcher::servers::list(), art: art::Art::default(), scale: window.scale_factor(), }; if this.bench.is_some() { this.perf.keep_local_log(false); } let tx = this.tx.clone(); let keychain_tx = this.tx.clone(); // Asking the keychain can block (D-Bus), so not on this thread. std::thread::spawn(move || { let _ = keychain_tx.send(Msg::Keychain(account::store().persistent())); }); std::thread::spawn(move || { let reused = backend::reuse_prepared_everywhere(); if !reused.is_empty() { let _ = tx.send(Msg::Reused(reused)); } }); this.fetch_startup_releases(); this.fetch_links(); // What the game and the launcher kept, if the player allows it and there is a server. telemetry::send_in_background(); telemetry::watch_playing(this.tx.clone()); this } fn go(&mut self, page: Page) { // The game may have made up a name since: read it again (a small file, once a switch). self.offline_name = offline_name(); if page != self.page { self.page = page; self.switches += 1; self.content_scroll = Scrollbar::default(); self.long_list = cull::Cull::default(); } self.picker_open = false; } fn check_updates(&mut self) { self.checked = Some(Instant::now()); let tx = self.tx.clone(); std::thread::spawn(move || { let _ = tx.send(Msg::Updates(backend::check_updates())); }); } fn update_launcher(&mut self, release: Release) { if !backend::self_update_allowed() || matches!( self.self_update, SelfUpdate::Downloading(..) | SelfUpdate::Ready(_) ) { return; } let version = backend::launcher_version(&release.tag) .unwrap_or_default() .to_string(); self.self_update = SelfUpdate::Downloading(version, 0.); let tx = self.tx.clone(); std::thread::spawn(move || { let progress = |p| { let _ = tx.send(Msg::LauncherProgress(p)); }; let _ = tx.send(Msg::LauncherUpdated(backend::self_update( &release, progress, ))); }); } /// Installs the Horizon version the last check found, keeping the player's choice of /// version unless they were on the newest one. fn install_update(&mut self) { let Some(release) = self.updates.horizon.clone() else { return; }; if self.installing.is_some() { return; } let select = backend::select_after_update(self.settings.selected.as_deref(), &self.installed); self.update_install = Some((release.tag.clone(), select)); self.install(&release); } fn fetch_releases(&mut self) { self.releases = Load::Loading; let tx = self.tx.clone(); std::thread::spawn(move || { let _ = tx.send(Msg::Releases(backend::releases())); }); } fn fetch_startup_releases(&mut self) { self.checked = Some(Instant::now()); let tx = self.tx.clone(); std::thread::spawn(move || { let updates = backend::releases_and_updates(|releases| { let _ = tx.send(Msg::Releases(releases)); }); let _ = tx.send(Msg::Updates(updates)); }); } fn fetch_links(&self) { let tx = self.tx.clone(); std::thread::spawn(move || { let _ = tx.send(Msg::Links(backend::links())); }); } fn drain(&mut self, cx: &mut Context) { let mut changed = false; self.perf.tick(); match self.bench.as_mut().map(|b| b.tick(&self.perf)) { Some(perf::Step::Go(page)) => { self.go(Page::ALL[page % Page::ALL.len()].0); changed = true; } Some(perf::Step::Scroll) => { self.go(Page::Versions); changed = true; } Some(perf::Step::Quit) => cx.quit(), Some(perf::Step::Wait) | None => {} } while let Ok(msg) = self.rx.try_recv() { changed = true; match msg { Msg::Releases(r) => { if let (Ok(_), Some(checked)) = (&r, self.checked) { self.perf.record_since("launcher.release_list_ms", checked); } self.releases = r.map_or_else(Load::Failed, Load::Ready) } Msg::Links(links) => self.links = links, // The page reads is_prepared when drawn; `changed` redraws it. Msg::Reused(_) => self.installed = backend::installed(), Msg::Keychain(persistent) => self.keychain = persistent, Msg::Playing(playing) => self.playing = playing, Msg::Session(session) => { if let Some(tag) = self.starting_client.take() { let mut cmd = backend::client_command(&tag); match session { Ok(Some(file)) => { cmd.arg("--session-file").arg(file); } Ok(None) => {} // Still play, offline, and say why. Err(e) => self.client_error = Some(format!("Playing offline: {e}")), } self.accounts = Accounts::load(); if let Some(work) = self.starting_pack.take() { if let Err(e) = horizon_launcher::modpacks::apply_profile(&mut cmd, &work) { self.client_error = Some(e); continue; } } if let Some(code) = self.joining.take() { if let Err(e) = backend::join_friend(&mut cmd, &code) { self.client_error = Some(e); } } backend::append_game_args(&mut cmd); self.client_home = cmd.get_current_dir().map(|d| d.to_path_buf()); match backend::spawn(Job::Client, cmd, self.tx.clone()) { Ok(r) => self.client = Some(r), Err(e) => self.client_error = Some(e), } } } Msg::Progress(tag, p) => { self.bar = (self.bar.1, p); self.installing = Some((tag, p)); } Msg::Installed(tag, result) => { self.installing = None; self.bar = (0., 0.); self.installed = backend::installed(); let as_update = self.update_install.take().filter(|(t, _)| *t == tag); if let (Ok(()), Some(started)) = (&result, self.install_started.take()) { let name = if as_update.is_some() { "launcher.update_ms" } else { "launcher.install_ms" }; self.perf.record_since(name, started); } match result { Ok(()) => { if self.updates.horizon.as_ref().is_some_and(|r| r.tag == tag) { self.updates.horizon = None; } if as_update.is_none_or(|(_, select)| select) { self.settings.selected = Some(tag); } self.settings.save(); } Err(e) => self.install_error = Some((tag, e)), } } Msg::Updates(Ok(updates)) => { self.update_error = None; self.updates = updates; if self.settings.auto_install() { self.install_update(); } if let Some(release) = self.updates.launcher.clone() { self.update_launcher(release); } } Msg::Updates(Err(e)) => self.update_error = Some(e), Msg::LauncherProgress(p) => { if let SelfUpdate::Downloading(_, f) = &mut self.self_update { *f = p; } } Msg::LauncherUpdated(result) => { let version = match &self.self_update { SelfUpdate::Downloading(v, _) => v.clone(), _ => String::new(), }; self.self_update = match result { Ok(()) => SelfUpdate::Ready(version), Err(e) => SelfUpdate::Failed(e), }; } Msg::PackLine(line) => { self.pack_log.push_back(line); if self.pack_log.len() > LOG_LINES { self.pack_log.pop_front(); } } Msg::PackDone(result) => self.pack_done(result), Msg::Line(job, line) => { if job == Job::Client && line.starts_with(perf::GAME_FIRST_FRAME) { if let Some(pressed) = self.play_pressed.take() { self.perf .record_since("launcher.play_to_game_frame_ms", pressed); } } // The MCP server keeps its own server's log; the launcher's are the preparer's // and the game's. if job != Job::Server { self.prepare_log.push_back(line); if self.prepare_log.len() > LOG_LINES { self.prepare_log.pop_front(); } } } Msg::Exit(job, result) => { let error = result.err(); match job { Job::Prepare => { self.preparing = false; if let (None, Some(started)) = (&error, self.prepare_started.take()) { self.perf.record_since("launcher.prepare_ms", started); } // A preparer process's exit status says little, so its last line // follows; the launcher's own errors are full sentences already. self.prepare_error = error.map(|e| { let tail = self .prepare_log .iter() .rev() .find(|l| !l.trim().is_empty()) .filter(|_| e.starts_with("Exited with")); tail.map_or(e.clone(), |t| format!("{e}: {t}")) }); } Job::Client => { self.client = None; let report = self .client_started .take() .and_then(backend::crash_report_since); if error.is_some() && report.is_none() && self.switched_to_dx12() { self.client_error = Some( "Horizon's Vulkan renderer crashed while starting on this \ graphics card, so the game now uses DirectX 12. Press Play \ to start it again. Video Settings > Graphics API switches \ back." .into(), ); } else if error.is_some() || report.is_some() { let summary = report .as_ref() .and_then(|p| std::fs::read_to_string(p).ok()) .and_then(|text| backend::crash_summary(&text)) .or_else(|| { let tail = self .prepare_log .iter() .rev() .find(|l| !l.trim().is_empty()); error.as_ref().map(|e| { tail.map_or(e.clone(), |t| format!("{e}: {t}")) }) }) .unwrap_or_default(); self.crash = Some(Crash { report, summary, copied: false, }); } } Job::Server => {} } } } } changed |= self.servers_tick(); changed |= self.mods_tick(); if let Some(sign_in) = &self.sign_in { let state = sign_in.state(); let changed_state = format!("{state:?}") != format!("{:?}", self.sign_in_state); if changed_state { if let SignInState::Done(Ok(_)) = state { self.accounts = Accounts::load(); } self.sign_in_state = Some(state); changed = true; } } if self .checked .is_some_and(|at| at.elapsed() > backend::CHECK_EVERY) { self.check_updates(); } if changed { cx.notify(); } } /// After a crash with no report: when the game's output ends while its Vulkan renderer /// started, a native crash in the graphics driver (#746), switches the game to DirectX 12 /// (Windows only; only where the player left the graphics API on Auto). True when it did. fn switched_to_dx12(&self) -> bool { if !cfg!(windows) || !backend::vulkan_start_crashed(&self.prepare_log) { return false; } // The GPU is the same for every profile: the game home's setting and the crashed run's. let home = backend::game_home(); let mut homes = vec![home.clone()]; homes.extend(self.client_home.clone().filter(|h| *h != home)); let mut switched = false; for home in homes { match backend::switch_to_dx12(&home) { Ok(changed) => switched |= changed, Err(e) => eprintln!("Horizon launcher: could not switch to DirectX 12: {e}"), } } switched } fn selected(&self) -> Option<&String> { self.settings .selected .as_ref() .filter(|s| self.installed.contains(s)) } fn install(&mut self, release: &Release) { if release.asset.is_none() { return; } let (release, tx) = (release.clone(), self.tx.clone()); let tag = release.tag.clone(); self.installing = Some((tag.clone(), 0.0)); self.install_started = Some(Instant::now()); self.bar = (0., 0.); self.install_error = None; std::thread::spawn(move || { let progress = |p| { let _ = tx.send(Msg::Progress(tag.clone(), p)); }; let result = backend::install(&release, progress); let _ = tx.send(Msg::Installed(tag, result)); }); } fn remove(&mut self, tag: &str) { if let Err(e) = backend::remove_version(tag) { self.install_error = Some((tag.to_string(), e)); } self.confirm_remove = None; self.installed = backend::installed(); self.settings.selected = Settings::load() .selected .or_else(|| self.installed.first().cloned()); } fn prepare(&mut self) { let Some(tag) = self.selected().cloned() else { return; }; let minecraft = self .settings .minecraft_dir .clone() .unwrap_or_else(|| horizon_prepare::artifacts::minecraft_dir(None)); self.prepare_log.clear(); self.prepare_error = None; self.prepare_log .push_back("Checking Java and your Minecraft install".into()); let tx = self.tx.clone(); // The checks may download the server jar, so they run on the thread too. std::thread::spawn(move || { let log = |line| { let _ = tx.send(Msg::Line(Job::Prepare, line)); }; let result = backend::preparer(&tag, &minecraft, &log) .inspect(|(_, minecraft)| backend::sounds(&tag, minecraft, &log)) .and_then(|(p, _)| match p { backend::Preparer::Process(cmd) => { backend::spawn(Job::Prepare, cmd, tx.clone()).map(|_running| false) } backend::Preparer::InProcess(options) => { backend::prepare_in_process(&options, &log).map(|_| true) } }); match result { // A process sends its own Exit when it ends. Ok(false) => {} Ok(true) => { let _ = tx.send(Msg::Exit(Job::Prepare, Ok(()))); } Err(e) => { let _ = tx.send(Msg::Exit(Job::Prepare, Err(e))); } } }); self.preparing = true; self.prepare_started = Some(Instant::now()); } fn play(&mut self) { let Some(tag) = self.selected().cloned() else { return; }; if self.client.is_some() || self.starting_client.is_some() { return; } self.starting_pack = None; self.start_client(tag); } /// Starts the game: the session first (a network round trip when the token needs /// renewing), then `drain` starts the process when it arrives. fn start_client(&mut self, tag: String) { self.client_error = None; self.crash = None; self.prepare_log.clear(); // A little earlier than the spawn: file times can be coarse. self.client_started = Some(std::time::SystemTime::now() - std::time::Duration::from_secs(2)); // The built-in packs the resources lack and the session (a network round trip when the // token needs renewing) come first; `drain` starts the game when the session arrives. self.starting_client = Some(tag.clone()); self.play_pressed = Some(Instant::now()); let tx = self.tx.clone(); std::thread::spawn(move || { backend::complete_packs(&tag); let session = (|| { let mut accounts = Accounts::load(); let Some((a, secrets)) = account::session_for_launch( &account::Endpoints::live(), account::store(), &mut accounts, )? else { return Ok(None); }; account::write_session_file(&backend::game_home().join("sessions"), &a, &secrets) .map(Some) })(); let _ = tx.send(Msg::Session(session)); }); } fn choose_folder(&mut self, cx: &mut Context) { let paths = cx.prompt_for_paths(PathPromptOptions { files: false, directories: true, multiple: false, prompt: Some("Choose".into()), }); cx.spawn(async move |this, cx| { if let Ok(Ok(Some(mut paths))) = paths.await { if let Some(path) = paths.pop() { let _ = this.update(cx, |this, cx| { this.settings.minecraft_dir = Some(path); this.settings.save(); cx.notify(); }); } } }) .detach(); } } // ----- Building blocks --------------------------------------------------------------------------- #[derive(Clone, Copy, PartialEq)] enum Kind { Primary, Secondary, Ghost, } /// The element under the pointer and the one it just left, with when that happened. Hover /// backgrounds ease in and out from these rather than snapping. struct HoverState { on: Option<(SharedString, Instant)>, off: Option<(SharedString, Instant)>, } static HOVER: Mutex = Mutex::new(HoverState { on: None, off: None, }); fn track_hover(el: Stateful
, id: SharedString) -> Stateful
{ el.on_hover(move |hovered, window, _| { let mut state = HOVER.lock().unwrap(); let is_on = state.on.as_ref().is_some_and(|(h, _)| *h == id); if *hovered && !is_on { state.off = state.on.take(); state.on = Some((id.clone(), Instant::now())); } else if !*hovered && is_on { state.off = Some((id.clone(), Instant::now())); state.on = None; } window.refresh(); }) } /// A layer under an element's content that fades `color` in while it is hovered. `bleed` lets /// it reach past the element on the left and right, as the hover plate of a list row does. fn hover_layer(id: &SharedString, color: Hsla, radius: f32, bleed: f32) -> AnyElement { let layer = div() .absolute() .top_0() .bottom_0() .left(px(-bleed)) .right(px(-bleed)) .rounded(px(radius)); let state = HOVER.lock().unwrap(); // Each transition gets its own animation id, from when it started, so it plays once. static START: std::sync::OnceLock = std::sync::OnceLock::new(); let start = *START.get_or_init(Instant::now); let key = |dir: &str, at: Instant| { ElementId::named_usize(format!("{id}-{dir}"), (at - start).as_micros() as usize) }; let ease = || Animation::new(theme::QUICK).with_easing(ease_out_quint()); if let Some((_, at)) = state.on.as_ref().filter(|(h, _)| h == id) { return layer .with_animation(key("in", *at), ease(), move |d, t| { d.bg(color.opacity(color.a * t)) }) .into_any_element(); } if let Some((_, at)) = state .off .as_ref() .filter(|(h, at)| h == id && at.elapsed() < theme::QUICK) { return layer .with_animation(key("out", *at), ease(), move |d, t| { d.bg(color.opacity(color.a * (1. - t))) }) .into_any_element(); } layer.into_any_element() } /// Text set in one step of the type scale: headings (heading, title, display) in the pixel face. fn text(step: theme::Step) -> Div { let d = div().text_size(px(step.px)).line_height(px(step.line_px())); let d = if step.mono { d.font_family(theme::MONO) } else if step.px >= theme::HEADING.px { d.font_family(theme::PIXEL) } else { d }; if step.weight >= 500 { d.font_weight(FontWeight::MEDIUM) } else { d } } /// A release's tag as a title: mono, so its digits read at a glance. fn version_tag(tag: &str) -> Div { div() .font_family(theme::MONO) .text_size(px(22.)) .line_height(px(28.)) .font_weight(FontWeight::MEDIUM) .child(tag.trim_start_matches('v').to_string()) } /// Horizon's mark: two stems, their reflection below, and the horizon across in the accent. fn mark(size: f32, t: &Theme) -> Div { let u = size / 16.; let stem = |x: f32, y: f32, color: Hsla| { div() .absolute() .left(px(x * u)) .top(px(y * u)) .w(px(2. * u)) .h(px(4. * u)) .bg(color) }; div() .relative() .flex_none() .size(px(size)) .child(stem(4., 3., t.ink)) .child(stem(10., 3., t.ink)) .child(stem(4., 8., t.ink.opacity(0.36))) .child(stem(10., 8., t.ink.opacity(0.36))) .child( div() .absolute() .left(px(u)) .top(px(7. * u)) .w(px(14. * u)) .h(px(u)) .bg(t.accent), ) } /// The last thing the player did was press Tab: focused controls show a ring (a click focuses them /// too, without one). static KEYBOARD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false); /// Makes a control reachable with Tab, pressed with Enter or Space, with a ring when the keyboard /// put it in focus. fn keyboard(el: Stateful
, t: &Theme) -> Stateful
{ let (ring, gap) = (t.accent, t.page); // A ring with a gap of page colour, so it shows around filled buttons too. GPUI draws nothing // for a shadow without blur: half a pixel keeps it crisp. let shadow = |color, spread: f32| gpui::BoxShadow { color, offset: gpui::point(px(0.), px(0.)), blur_radius: px(0.5), spread_radius: px(spread), }; el.tab_index(0).focus(move |s| { if KEYBOARD.load(Ordering::Relaxed) { s.shadow(vec![shadow(ring, 4.), shadow(gap, 1.5)]) } else { s } }) } /// A button: a block with a light bevel on top and a darker lip below, its label in the pixel /// face. Primary (the one main action) is the violet face; Secondary a raised block; Ghost only /// its label until the pointer is over it. fn button( id: impl Into, label: impl Into, kind: Kind, t: &Theme, ) -> Stateful
{ let id: SharedString = id.into(); let t = *t; let hover = match kind { Kind::Primary => t.on_face.opacity(0.10), Kind::Secondary => t.bevel.opacity(if t.dark { 0.10 } else { 0.35 }), Kind::Ghost => t.raised, }; let base = div() .id(id.clone()) .relative() .flex() .flex_none() .items_center() .justify_center() .h(px(theme::CONTROL)) .px(px(14.)) .font_family(theme::PIXEL) .text_size(px(15.)) .font_weight(FontWeight::MEDIUM) .cursor_pointer() .child(hover_layer(&id, hover, 0., 0.)); let base = match kind { Kind::Primary => base .border_2() .border_color(t.outline) .children(blocks::edges(t.face_bevel, t.face_lip, theme::LIP)) .bg(t.face) .text_color(t.on_face), Kind::Secondary => base .border_2() .border_color(t.outline) .children(blocks::edges(t.button_bevel, t.lip, theme::LIP)) .bg(t.button) .text_color(t.ink), Kind::Ghost => base.text_color(t.muted).hover(move |s| s.text_color(t.ink)), }; // The label sits on the block's face, above its lip; pressing pushes it down. let base = base.child( div() .relative() .flex() .items_center() .gap(px(8.)) .pb(px(if kind == Kind::Ghost { 0. } else { 2. })) .child(label.into()), ); keyboard(track_hover(base, id), &t).active(|s| s.opacity(theme::PRESSED).top(px(1.))) } /// An on/off switch: a square knob sliding in a sunk track that turns violet when on. fn switch(id: &'static str, on: bool, t: &Theme) -> Stateful
{ let t = *t; let knob = if on { t.on_face } else { t.muted }; keyboard(div().id(id), &t) .relative() .flex_none() .w(px(44.)) .h(px(24.)) .border_2() .border_color(t.outline) .cursor_pointer() .bg(if on { t.face } else { t.well }) .child( div() .absolute() .top(px(2.)) .size(px(16.)) .bg(knob) .child( div() .absolute() .bottom_0() .left_0() .right_0() .h(px(2.)) .bg(if on { t.face_lip } else { t.lip }), ) .with_animation( ElementId::named_usize(id, on as usize), Animation::new(theme::MOVE).with_easing(ease_out_quint()), move |d, p| d.left(px(if on { 2. + 20. * p } else { 22. - 20. * p })), ), ) } /// A section's title inside a page: a pixel icon in the accent and the name in the pixel face. fn section_title(label: &'static str, icon: &'static str, t: &Theme) -> Div { div() .flex() .items_center() .gap(px(10.)) .child(blocks::icon(icon, 20., t.accent)) .child( blocks::pixel(18., FontWeight::SEMIBOLD) .text_color(t.ink) .child(label), ) } /// A segmented control: a sunk track, the chosen segment a raised block. fn segments( id: &'static str, options: &[(T, &'static str)], current: T, t: &Theme, on_pick: impl Fn(T, &mut Window, &mut App) + Clone + 'static, ) -> Stateful
{ let t = *t; div() .id(id) .flex() .flex_none() .p(px(2.)) .gap(px(2.)) .border_2() .border_color(t.outline) .bg(t.well) .children(options.iter().map(|&(value, label)| { let active = current == value; let pick = on_pick.clone(); keyboard(div().id(SharedString::from(format!("{id}-{label}"))), &t) .relative() .flex() .items_center() .h(px(theme::SEGMENT)) .px(px(14.)) .pb(px(2.)) .font_family(theme::PIXEL) .text_size(px(14.)) .font_weight(FontWeight::MEDIUM) .cursor_pointer() .when(active, |d| { d.bg(t.button).text_color(t.ink).children(blocks::edges( t.button_bevel, t.lip, 3., )) }) .when(!active, |d| { d.text_color(t.muted).hover(move |s| s.text_color(t.ink)) }) .child(div().relative().child(label)) .on_click(move |_: &ClickEvent, window, cx| pick(value, window, cx)) })) } fn disabled(b: Stateful
) -> Stateful
{ b.opacity(theme::DISABLED).cursor_default().tab_stop(false) } /// A page's title in the pixel face and one line on what it is for. fn page_header(title: &str, description: &str, t: &Theme) -> Div { div() .flex() .flex_col() .gap(px(10.)) .child( blocks::pixel(36., FontWeight::SEMIBOLD) .text_color(t.ink) .child(title.to_string()), ) .child( text(theme::UI) .max_w(px(520.)) .text_color(t.muted) .child(description.to_string()), ) } /// One row of a list, as its own panel: a name in the pixel face with an optional detail under /// it, then a value or a control on the right. Rows were numbered in the quiet look; `_n` keeps /// the call sites as they are. fn index_row( _n: usize, name: impl IntoElement, detail: Option, right: Option, t: &Theme, ) -> Div { slot_row(None, name, detail, right, t) } /// A row with an icon slot (`blocks::slot`) on its left: a project in the Mods page's lists. fn slot_row( slot: Option
, name: impl IntoElement, detail: Option, right: Option, t: &Theme, ) -> Div { blocks::panel(t) .flex() .items_center() .gap(px(16.)) .min_h(px(theme::ROW)) .mb(px(8.)) .px(px(16.)) .py(px(12.)) .children(slot) .child( div() .flex() .flex_col() .flex_1() .min_w_0() .gap(px(2.)) .child( blocks::pixel(16., FontWeight::MEDIUM) .text_color(t.ink) .child(name), ) .children(detail.map(|d| { text(theme::CAPTION) .text_color(t.muted) .child(d) .into_any_element() })), ) .children(right) } /// A plate that stands apart from the page: notices, the console, the agents note. fn plate(t: &Theme) -> Div { blocks::panel(t) } /// Something went wrong: a dot in the danger colour, then what happened. fn notice(text_: String, t: &Theme) -> Div { plate(t) .flex() .gap(px(12.)) .p(px(16.)) .text_size(px(theme::UI.px)) .line_height(px(21.)) .text_color(t.ink) .border_l(px(6.)) .child( div() .absolute() .top(px(-2.)) .bottom(px(-2.)) .left(px(-6.)) .w(px(6.)) .bg(t.danger), ) .child(blocks::icon("info-box", 20., t.danger)) .child(div().flex_1().min_w_0().child(text_)) } /// An empty state: a short sentence, and the one thing to do about it. fn centered(text_: &str, t: &Theme) -> Div { div() .flex() .flex_col() .items_start() .gap(px(16.)) .py(px(48.)) .child(text(theme::UI).text_color(t.muted).child(text_.to_string())) } /// The name the game made up for a player without an account, once it has run. fn offline_name() -> Option { player_name(&std::fs::read_to_string(backend::game_home().join("horizon-player.txt")).ok()?) } /// The name in `horizon-player.txt`: the game writes `name:Player12345` (horizon-client's /// offline_name.rs). fn player_name(text: &str) -> Option { text.lines() .find_map(|line| line.trim().strip_prefix("name:")) .map(str::trim) .filter(|n| !n.is_empty()) .map(str::to_owned) } /// `1234` as `1,234`. fn thousands(n: u64) -> String { let digits = n.to_string(); let mut out = String::new(); for (i, c) in digits.chars().enumerate() { if i > 0 && (digits.len() - i).is_multiple_of(3) { out.push(','); } out.push(c); } out } /// A mono line in upper case: the status above a title, the footer's links. fn caps(s: impl AsRef) -> Div { text(theme::MICRO).child(s.as_ref().to_uppercase()) } fn short(path: &std::path::Path) -> String { let home = dirs::home_dir().unwrap_or_default(); match path.strip_prefix(&home) { Ok(rest) if !home.as_os_str().is_empty() => format!("~/{}", rest.display()), _ => path.display().to_string(), } } fn megabytes(bytes: u64) -> String { format!("{:.0} MB", bytes as f64 / 1_000_000.0) } // ----- Pages ------------------------------------------------------------------------------------- impl Launcher { /// The top bar: the mark and the name over the sidebar, the pages with their icons, then /// the account playing and the Settings button. fn topbar(&mut self, cx: &mut Context) -> Div { let t = self.theme; let mut nav = div().flex().h_full().gap(px(2.)); for (page, label, icon) in Page::ALL { if page == Page::Settings { continue; } let active = self.page == page; let id = SharedString::from(format!("nav-{label}")); let item = div() .id(id.clone()) .relative() .flex() .items_center() .gap(px(8.)) .px(px(14.)) .cursor_pointer() .when(active, |d| { d.bg(t.raised).child( div() .absolute() .left(px(8.)) .right(px(8.)) .bottom_0() .h(px(4.)) .bg(t.accent), ) }) .when(!active, |d| d.child(hover_layer(&id, t.raised, 0., 0.))) .child(div().relative().child(blocks::icon( icon, 18., if active { t.accent } else { t.muted }, ))) .child( blocks::pixel(16., FontWeight::MEDIUM) .relative() .text_color(if active { t.ink } else { t.muted }) .child(label), ) .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.go(page); cx.notify(); })); nav = nav.child(keyboard(track_hover(item, id), &t)); } // Only a signed-in account says "Microsoft account"; otherwise the name the game made up. let (name, how) = match self.accounts.selected() { Some(a) => (a.name.clone(), "Microsoft account"), None => ( self.offline_name.clone().unwrap_or_else(|| "Player".into()), "Offline", ), }; let account = keyboard(div().id("account"), &t) .relative() .flex() .items_center() .gap(px(10.)) .h(px(40.)) .pl(px(4.)) .pr(px(12.)) .bg(t.panel) .border_2() .border_color(t.outline) .cursor_pointer() .hover(move |s| s.bg(t.raised)) .child( div() .flex() .items_center() .justify_center() .size(px(30.)) .bg(t.well) .child(blocks::icon("user", 18., t.muted)), ) .child( div() .flex() .flex_col() .child( blocks::pixel(14., FontWeight::MEDIUM) .text_color(t.ink) .child(name), ) .child(text(theme::CAPTION).text_color(t.muted).child(how)), ) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.go(Page::Settings); cx.notify(); })); let settings_open = self.page == Page::Settings; let settings = keyboard(div().id("nav-Settings"), &t) .relative() .flex() .items_center() .justify_center() .size(px(40.)) .bg(if settings_open { t.raised } else { t.panel }) .border_2() .border_color(t.outline) .cursor_pointer() .hover(move |s| s.bg(t.raised)) .when(settings_open, |d| { d.child( div() .absolute() .left_0() .right_0() .bottom_0() .h(px(4.)) .bg(t.accent), ) }) .child(blocks::icon( "sliders", 20., if settings_open { t.accent } else { t.ink_soft }, )) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.go(Page::Settings); cx.notify(); })); div() .flex() .flex_none() .items_center() .h(px(theme::TOPBAR)) .pl(px(18.)) .pr(px(12.)) .bg(t.side) .border_b_2() .border_color(t.outline) .child( div() .flex() .flex_none() .items_center() .gap(px(10.)) .w(px(theme::SIDEBAR - 18.)) .child(mark(24., &t)) .child( blocks::pixel(20., FontWeight::SEMIBOLD) .text_color(t.ink) .child("HORIZON"), ), ) .child(nav) .child( div() .ml_auto() .flex() .items_center() .gap(px(8.)) .child(account) .child(settings), ) } /// The sidebar: Horizon and the imported modpacks, the player's servers, then the /// launcher's own update, the community links and its version. fn sidebar(&mut self, cx: &mut Context) -> Stateful
{ let t = self.theme; self.load_packs(); let heading = |label: &'static str| { div() .flex() .items_center() .justify_between() .px(px(6.)) .pt(px(10.)) .pb(px(6.)) .child( blocks::pixel(13., FontWeight::MEDIUM) .text_color(t.muted) .child(label), ) }; let sub = |s: String| text(theme::CAPTION).text_color(t.muted).truncate().child(s); let title = |s: String| { blocks::pixel(15., FontWeight::MEDIUM) .text_color(t.ink) .truncate() .child(s) }; let dot = |c: Hsla| { div() .absolute() .left(px(42.)) .top(px(42.)) .size(px(10.)) .bg(c) .border_2() .border_color(t.side) }; let add = keyboard(div().id("add-pack"), &t) .flex() .items_center() .justify_center() .size(px(24.)) .bg(t.panel) .border_2() .border_color(t.outline) .cursor_pointer() .hover(move |s| s.bg(t.raised)) .child(blocks::icon("plus", 14., t.ink_soft)) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.show_modpack(None); cx.notify(); })); let mut list = div() .flex() .flex_col() .gap(px(4.)) .child(heading("INSTANCES").child(add)); // Horizon itself, with a grass block from the player's own prepared files. let tag = self.selected().cloned(); let prepared = tag.as_deref().is_some_and(backend::is_prepared); let grass = self.vanilla_icon(); let on_play = self.page == Page::Play; list = list.child( blocks::side_item("side-horizon".into(), on_play, &t) .child(match grass { Some(g) => div() .flex() .items_center() .justify_center() .size(px(44.)) .child(gpui::img(g).size(px(40.))), None => blocks::slot(None, "Horizon", 44., &t), }) .child(dot(if prepared { t.success } else { t.warn })) .child( div() .flex() .flex_col() .min_w_0() .child(title("Horizon".into())) .child(sub(if tag.is_none() { "No version installed" } else if prepared { "Vanilla · ready" } else { "Needs preparing" } .into())), ) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.go(Page::Play); cx.notify(); })), ); let on_packs = self.page == Page::Mods && self.mods.on_modpacks(); for p in &self.packs { let slug = p.slug.clone(); let open = on_packs && self.pack_open.as_ref() == Some(&p.slug); list = list.child( blocks::side_item(format!("side-pack-{slug}").into(), open, &t) .child(blocks::slot(None, p.title(), 44., &t)) .child( div() .flex() .flex_col() .min_w_0() .child(title(p.title().to_string())) .child(sub(p.summary())), ) .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.show_modpack(Some(slug.clone())); cx.notify(); })), ); } let servers: Vec<_> = self .servers .sidebar_list() .map(<[_]>::to_vec) .unwrap_or_else(|| self.side_servers.clone()); if !servers.is_empty() { list = list.child(heading("SERVERS")); } for e in servers { let up = self.servers.is_up(&e.dir); let open = self.page == Page::Servers && self.servers.open.as_ref() == Some(&e.dir); let dir = e.dir.clone(); list = list.child( blocks::side_item(format!("side-server-{}", e.dir.display()).into(), open, &t) .child( div() .flex() .items_center() .justify_center() .size(px(44.)) .bg(t.well) .border_2() .border_color(t.outline) .child(blocks::icon("server", 22., t.ink_soft)), ) .child(dot(if up { t.success } else { t.muted })) .child( div() .flex() .flex_col() .min_w_0() .child(title(e.name.clone())) .child(sub(if up { "Running" } else { "Stopped" }.into())), ) .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.servers.open = Some(dir.clone()); this.go(Page::Servers); cx.notify(); })), ); } let link = |id: &'static str, label: &'static str, icon: &'static str, url: String| { div() .id(id) .flex() .items_center() .gap(px(10.)) .px(px(8.)) .py(px(6.)) .text_color(t.muted) .cursor_pointer() .hover(move |s| s.text_color(t.ink).bg(t.raised.opacity(0.6))) .child(blocks::icon(icon, 18., t.muted)) .child(blocks::pixel(14., FontWeight::MEDIUM).child(label)) .on_click(move |_, _, cx| cx.open_url(&url)) }; let mut foot = div().mt_auto().flex().flex_col().gap(px(2.)).pt(px(12.)); match &self.self_update { SelfUpdate::Downloading(version, f) => { foot = foot.child( blocks::panel(&t) .flex() .flex_col() .gap(px(8.)) .p(px(10.)) .mb(px(6.)) .child( blocks::pixel(13., FontWeight::MEDIUM) .text_color(t.ink) .child(format!("Launcher {version} {:.0}%", f * 100.)), ) .child(div().flex().child(progress_bar(Some((*f, *f)), &t))), ) } SelfUpdate::Ready(version) => { foot = foot.child( blocks::panel(&t) .flex() .flex_col() .gap(px(8.)) .p(px(10.)) .mb(px(6.)) .child( blocks::pixel(13., FontWeight::MEDIUM) .text_color(t.ink) .child(format!("Launcher updated to {version}")), ) .child(button("restart", "Restart", Kind::Primary, &t).on_click( cx.listener(|this, _: &ClickEvent, _, cx| { this.self_update = SelfUpdate::Failed(backend::restart()); cx.notify(); }), )), ) } _ => {} } if !self.links.discord.is_empty() { foot = foot.child(link( "discord", "Discord", "message", self.links.discord.clone(), )); } if !self.links.website.is_empty() { foot = foot.child(link( "website", "Website", "globe", self.links.website.clone(), )); } foot = foot.child( caps(format!("Launcher {}", backend::VERSION)) .px(px(8.)) .pt(px(6.)) .text_color(t.muted), ); div() .id("sidebar") .flex() .flex_col() .flex_none() .w(px(theme::SIDEBAR)) .h_full() .px(px(10.)) .pb(px(12.)) .bg(t.side) .border_r_2() .border_color(t.outline) .overflow_y_scroll() .child(list) .child(foot) } fn picker(&self, cx: &mut Context) -> Div { let t = self.theme; let label = self .selected() .cloned() .unwrap_or_else(|| "No version".into()); // A block as tall as Play: "VERSION" over the tag, and a chevron. let mut wrap = div().relative().child( keyboard(div().id("picker"), &t) .relative() .flex() .items_center() .gap(px(16.)) .h(px(60.)) .pl(px(14.)) .pr(px(12.)) .bg(t.panel) .border_2() .border_color(t.outline) .children(blocks::edges(t.bevel, t.lip, theme::BEVEL)) .cursor_pointer() .hover(move |s| s.bg(t.raised)) .child( div() .flex() .flex_col() .gap(px(4.)) .child( blocks::pixel(11., FontWeight::MEDIUM) .text_color(t.muted) .child("VERSION"), ) .child( div() .font_family(theme::MONO) .text_size(px(15.)) .text_color(t.ink) .child(label), ), ) .child(blocks::icon("chevron-down", 20., t.muted)) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.picker_open = !this.picker_open; cx.notify(); })), ); if self.picker_open { let mut menu = div() .absolute() .top(px(66.)) .right_0() .w(px(240.)) .p(px(6.)) .border_2() .border_color(t.outline) .bg(t.surface) .flex() .flex_col(); for tag in &self.installed { let selected = self.selected() == Some(tag); let tag = tag.clone(); menu = menu.child( div() .id(SharedString::from(format!("pick-{tag}"))) .flex() .items_center() .justify_between() .h(px(32.)) .px(px(10.)) .rounded(px(theme::RADIUS)) .font_family(theme::MONO) .text_size(px(theme::CAPTION.px)) .text_color(t.ink) .cursor_pointer() .hover(move |s| s.bg(t.plate_soft)) .child(tag.clone()) .when(selected, |d| { d.child(div().size(px(6.)).rounded_full().bg(t.accent)) }) .on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.settings.selected = Some(tag.clone()); this.settings.save(); this.picker_open = false; cx.notify(); })), ); } menu = menu.child(div().my(px(6.)).h(px(1.)).bg(t.rule)).child( div() .id("manage") .flex() .items_center() .h(px(32.)) .px(px(10.)) .rounded(px(theme::RADIUS)) .text_size(px(theme::LABEL.px)) .text_color(t.muted) .cursor_pointer() .hover(move |s| s.bg(t.plate_soft).text_color(t.ink)) .child("Manage versions") .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.go(Page::Versions); this.picker_open = false; cx.notify(); })), ); wrap = wrap.child(gpui::deferred(menu).with_priority(1)); } wrap } fn play_page(&mut self, cx: &mut Context) -> Div { let t = self.theme; let Some(tag) = self.selected().cloned() else { // No hero without a version: the page starts below the top bar like the others. return div() .flex() .flex_col() .gap(px(24.)) .pt(px(28.)) .child(page_header( "Play", "Start the game, or run a server for others to join.", &t, )) .child(centered("No version installed yet.", &t).child( button("go-versions", "Choose a version", Kind::Secondary, &t).on_click( cx.listener(|this, _: &ClickEvent, _, cx| { this.go(Page::Versions); cx.notify(); }), ), )); }; let prepared = backend::is_prepared(&tag); // Prepared without sounds (#1035): Prepare again is the fix, so it stands out. let silent = prepared && !backend::has_sounds(&tag); let version = backend::game_version(&tag); let hero = self.hero(&tag, &version, prepared, cx); let running = self.client.is_some() || self.starting_client.is_some(); let play_label = if running { "Running" } else { "Play" }; let mut play = button("play", play_label, Kind::Primary, &t) .min_w(px(200.)) .h(px(60.)) .px(px(28.)) .text_size(px(28.)) .font_weight(FontWeight::SEMIBOLD) .child( div() .absolute() .left(px(26.)) .top(px(17.)) .child(blocks::icon("play", 22., t.on_face)), ); if !prepared || self.preparing || running { play = disabled(play); } else { play = play.on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.picker_open = false; this.play(); cx.notify(); })); } let actions = div() .flex() .items_center() .justify_between() .child( button("host", "Host a server", Kind::Ghost, &t).on_click(cx.listener( |this, _: &ClickEvent, _, cx| { this.go(Page::Servers); cx.notify(); }, )), ) .child( div() .flex() .items_center() .gap(px(8.)) .child(self.picker(cx)) .child(play), ); let resources_value = if self.preparing { "Preparing…".to_string() } else { backend::resources_summary(prepared, !silent, &version) }; let mut prepare = button( "prepare", if prepared { "Prepare again" } else { "Prepare" }, if prepared && !silent { Kind::Ghost } else { Kind::Secondary }, &t, ); if self.preparing { prepare = disabled(prepare); } else { prepare = prepare.on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.prepare(); cx.notify(); })); } let minecraft = self.settings.minecraft_dir.as_deref().map_or_else( || { div() .child("Not found. Choose the folder where your launcher keeps Minecraft.") .into_any_element() }, |p| { div() .font_family(theme::MONO) .child(short(p)) .into_any_element() }, ); let mut rows = div() .flex() .flex_col() .child(section_title("Ready to play", "check", &t).mb(px(12.))) .child(index_row( 1, "Resources", Some(div().child(resources_value).into_any_element()), Some(prepare.into_any_element()), &t, )) .child(index_row( 2, "Minecraft folder", Some(minecraft), Some( button("choose-mc", "Choose…", Kind::Ghost, &t) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| this.choose_folder(cx))) .into_any_element(), ), &t, )); { rows = rows.child(self.join_friend_row(prepared && !running, cx)); // The top bar shows who plays; a row only when there is something to do about it: // offline, in a build that can sign in. if self.accounts.selected().is_none() && account::client_id().is_some() { rows = rows.child(index_row( 4, "Playing offline", Some( div() .child("Online servers need a Microsoft account.") .into_any_element(), ), Some( button("accounts", "Accounts…", Kind::Ghost, &t) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.go(Page::Settings); cx.notify(); })) .into_any_element(), ), &t, )); } } // The banner: Horizon's landscape (`art.rs`) under a veil of the page colour, the hero and // the Play row over it. It reaches the content's edges and the top bar. let scene = self.art.scene(t.dark, self.scale); let veil = |angle: f32, from: f32, to: f32, at: f32| { div() .absolute() .top_0() .left_0() .size_full() .bg(gpui::linear_gradient( angle, gpui::linear_color_stop(t.page.opacity(from), 0.), gpui::linear_color_stop(t.page.opacity(to), at), )) }; let (w, h) = art::SCENE_SIZE; let banner = div() .relative() .flex() .flex_col() .justify_end() .min_h(px(340.)) .mx(px(-32.)) .px(px(32.)) .pb(px(28.)) .gap(px(24.)) .overflow_hidden() .bg(gpui::rgb(art::sky_top(t.dark))) .border_b_2() .border_color(t.outline) .child( gpui::img(scene) .absolute() .bottom_0() .left_0() .w(px(w as f32 * art::SCENE_TEXEL)) .h(px(h as f32 * art::SCENE_TEXEL)), ) .child(veil(90., 0.82, 0., 0.62)) .child(veil(180., 0., 0.75, 1.)) .child(div().relative().child(hero)) .child(div().relative().child(actions)); let mut page = div().flex().flex_col().gap(px(28.)).child(banner); // The preparation's progress and error right under the buttons, where the player // looks after pressing Prepare, not below the fold (#666). if self.preparing { let last = self.prepare_log.back().cloned().unwrap_or_default(); page = page.child( div() .flex() .flex_col() .gap(px(10.)) .child(progress_bar(None, &t)) .child( text(theme::MICRO) .text_color(t.muted) .truncate() .child(last), ) .child( text(theme::CAPTION) .text_color(t.muted) .child("The first preparation takes a few minutes."), ), ); } if let Some(e) = self.prepare_error.clone() { page = page.child(notice(e, &t)); } page = page.child(rows); if let Some(e) = self.client_error.clone() { page = page.child(notice(e, &t)); } if let Some(crash) = self.crash.clone() { page = page.child(self.crash_notice(crash, cx)); } page } /// "Horizon crashed": the report and the logs, and where to report it. fn crash_notice(&self, crash: Crash, cx: &mut Context) -> Div { let t = self.theme; let mut actions = div().flex().flex_wrap().gap(px(8.)).mt(px(8.)); if let Some(report) = crash.report.clone() { let open = report.clone(); actions = actions .child( button("crash-open", "Open report", Kind::Secondary, &t) .bg(t.plate) .on_click(move |_, _, cx| cx.open_with_system(&open)), ) .child( button( "crash-copy", if crash.copied { "Copied" } else { "Copy report" }, Kind::Secondary, &t, ) .bg(t.plate) .on_click(cx.listener( move |this, _: &ClickEvent, _, cx| { if let Ok(text) = std::fs::read_to_string(&report) { cx.write_to_clipboard(gpui::ClipboardItem::new_string(text)); if let Some(c) = &mut this.crash { c.copied = true; } } cx.notify(); }, )), ); } actions = actions.child( button("crash-logs", "Open logs folder", Kind::Secondary, &t) .bg(t.plate) .on_click(|_, _, cx| { let dir = backend::logs_dir(); let _ = std::fs::create_dir_all(&dir); cx.open_with_system(&dir); }), ); let discord = self.links.discord.clone(); if !discord.is_empty() { actions = actions.child( button("crash-discord", "Report on Discord", Kind::Secondary, &t) .bg(t.plate) .on_click(move |_, _, cx| cx.open_url(&discord)), ); } actions = actions.child( button("crash-dismiss", "Dismiss", Kind::Ghost, &t).on_click(cx.listener( |this, _: &ClickEvent, _, cx| { this.crash = None; cx.notify(); }, )), ); let help = if crash.report.is_some() { "When you report it on Discord, attach the crash report file (or paste it with Copy report) and say what you were doing." } else { "The game ended without a crash report. When you report it on Discord, attach latest.log from the logs folder and say what you were doing." }; let mut body = div() .flex_1() .min_w_0() .flex() .flex_col() .gap(px(4.)) .child( text(theme::HEADING) .text_color(t.ink) .child("Horizon crashed"), ); if !crash.summary.is_empty() { body = body.child(div().text_color(t.ink_soft).child(crash.summary)); } if let Some(report) = &crash.report { body = body.child( text(theme::MICRO) .text_color(t.muted) .truncate() .child(short(report)), ); } body = body.child(actions).child( text(theme::CAPTION) .mt(px(4.)) .text_color(t.muted) .child(help), ); plate(&t) .flex() .gap(px(14.)) .p(px(24.)) .text_size(px(theme::UI.px)) .line_height(px(21.)) .text_color(t.ink) .child( div() .flex_none() .mt(px(11.)) .size(px(6.)) .rounded_full() .bg(t.danger), ) .child(body) } /// The Play page's focal point: what will start, and a line from its notes. fn hero(&self, tag: &str, version: &str, prepared: bool, cx: &mut Context) -> Div { let t = self.theme; let summary = match &self.releases { Load::Ready(list) => list .iter() .find(|r| r.tag == tag) .and_then(|r| backend::notes_summary(&r.body)), _ => None, }; let title = "Horizon"; // Never squeezed by the rows below: the ping notice can make it tall. let mut hero = div() .flex() .flex_none() .flex_col() .gap(px(12.)) .child( div() .flex() .child( div() .flex() .flex_none() .items_center() .gap(px(10.)) .px(px(10.)) .py(px(5.)) .bg(t.side.opacity(0.85)) .border_2() .border_color(t.outline) .child( div() .size(px(8.)) .bg(if prepared { t.success } else { t.warn }), ) .child(caps(format!("Minecraft {version}")).text_color(t.ink_soft)) .child(div().size(px(4.)).bg(t.muted)) .child( caps(if prepared { "Ready" } else { "Needs preparing" }) .text_color(if prepared { t.success } else { t.warn }), ), ) .children(self.playing.map(|n| { div() .flex() .items_center() .gap(px(10.)) .child(div().size(px(4.)).rounded_full().bg(t.rule)) .child( caps(format!("{} playing now", thousands(n))).text_color(t.muted), ) })), ) .child( blocks::pixel(60., FontWeight::BOLD) .line_height(px(62.)) .text_color(t.ink) .child(title), ) // The version is in the picker beside Play: here only what it brings. .children(summary.map(|line| { text(theme::BODY) .max_w(px(560.)) .text_color(t.ink_soft) .child(line) })); if let Some(release) = &self.updates.horizon { let installing = self.installing.as_ref().filter(|(t, _)| *t == release.tag); let line = div() .flex() .items_center() .gap(px(10.)) .text_size(px(theme::CAPTION.px)) .text_color(t.muted) .child(div().size(px(6.)).rounded_full().bg(t.accent)) .child(format!("{} available", release.tag)); hero = hero.child(match installing { Some((_, p)) => line .child( div() .w(px(120.)) .flex() .child(progress_bar(Some(self.bar), &t)), ) .child(format!("{:.0}%", p * 100.)), None => line.child( div() .id("install-update") .text_color(t.accent) .font_weight(FontWeight::MEDIUM) .cursor_pointer() .hover(|s| s.opacity(0.8)) .child("Install") .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.install_update(); cx.notify(); })), ), }); } // Players who answered the first-run question before the ping existed read about it // once here. if !self.settings.ping_notice_seen && !self.collection.consent.needs_asking() { hero = hero.child( plate(&t) .flex() .flex_none() .flex_col() .gap(px(8.)) .p(px(16.)) .w_full() .max_w(px(640.)) .child( text(theme::UI) .text_color(t.ink) .child(telemetry::PING_NAME), ) .child( text(theme::CAPTION) .text_color(t.muted) .child(telemetry::PING), ) .child( div() .id("ping-notice-ok") .text_size(px(theme::UI.px)) .text_color(t.accent) .font_weight(FontWeight::MEDIUM) .cursor_pointer() .hover(|s| s.opacity(0.8)) .child("Got it") .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.settings.ping_notice_seen = true; this.settings.save(); cx.notify(); })), ), ); } hero } fn settings_page(&mut self, cx: &mut Context) -> Div { let t = self.theme; let toggle = switch("auto-install", self.settings.auto_install(), &t).on_click( cx.listener(|this, _: &ClickEvent, _, cx| { this.settings.install_new_versions = Some(!this.settings.auto_install()); this.settings.save(); if this.settings.auto_install() { this.install_update(); } cx.notify(); }), ); let opening = switch("opening", !self.settings.skip_opening, &t).on_click(cx.listener( |this, _: &ClickEvent, _, cx| { this.settings.skip_opening = !this.settings.skip_opening; this.settings.save(); cx.notify(); }, )); // Linux: the launcher's entry in the applications menu (`horizon_launcher::desktop`). let menu_entry = switch("desktop-entry", self.settings.desktop_entry(), &t).on_click( cx.listener(|this, _: &ClickEvent, _, cx| { let on = !this.settings.desktop_entry(); this.settings.desktop_entry = Some(on); this.settings.save(); let _ = if on { horizon_launcher::desktop::install(backend::exe_path()).map(|_| ()) } else { horizon_launcher::desktop::remove() }; cx.notify(); }), ); let horizon = match (&self.updates.horizon, &self.update_error) { (Some(r), _) => format!("{} available", r.tag), (None, Some(e)) => e.clone(), (None, None) if self.checked.is_some() => "Up to date".to_string(), _ => "Checking…".to_string(), }; let horizon_action = self .updates .horizon .as_ref() .filter(|_| self.installing.is_none()) .map(|_| { button("settings-install", "Install", Kind::Secondary, &t) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.install_update(); cx.notify(); })) .into_any_element() }); let launcher = match &self.self_update { SelfUpdate::Downloading(v, p) => { format!("{} · downloading {v}, {:.0}%", backend::VERSION, p * 100.) } SelfUpdate::Ready(v) => format!("Updated to {v}. Restart the launcher to use it."), SelfUpdate::Failed(e) => format!("{} · the update failed: {e}", backend::VERSION), SelfUpdate::Idle => match &self.updates.launcher { Some(r) => format!( "{} · {} available", backend::VERSION, backend::launcher_version(&r.tag).unwrap_or_default() ), None if self.checked.is_some() && self.update_error.is_none() => { format!("{} · up to date", backend::VERSION) } None => backend::VERSION.to_string(), }, }; let launcher_action = match &self.self_update { SelfUpdate::Ready(_) => Some( button("restart-settings", "Restart", Kind::Secondary, &t) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.self_update = SelfUpdate::Failed(backend::restart()); cx.notify(); })) .into_any_element(), ), SelfUpdate::Downloading(..) => None, _ => Some( button("check", "Check now", Kind::Ghost, &t) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.check_updates(); cx.notify(); })) .into_any_element(), ), }; let mono = |s: String| div().font_family(theme::MONO).child(s).into_any_element(); let plain = |s: &str| div().child(s.to_string()).into_any_element(); let (accounts, n) = self.account_rows(cx); let appearance = segments( "appearance", &[ (backend::Appearance::Dark, "Dark"), (backend::Appearance::Light, "Light"), (backend::Appearance::System, "System"), ], self.settings.appearance, &t, { let this = cx.entity().downgrade(); move |choice, window, cx| { let _ = this.update(cx, |this, cx| { this.settings.appearance = choice; this.settings.save(); this.theme = Theme::for_appearance(choice, window.appearance()); cx.notify(); }); } }, ); let group = |label: &'static str, icon: &'static str| { section_title(label, icon, &t).mt(px(20.)).mb(px(12.)) }; div() .flex() .flex_col() .gap(px(32.)) .child(page_header( "Settings", "Accounts, updates, and the launcher itself.", &t, )) .child( div() .flex() .flex_col() .child(group("Account", "user").mt_0()) .child(accounts) .child(group("Updates", "reload")) .child(index_row( n + 1, "Install new versions automatically", Some(plain( "Your selected version only changes if you were playing the newest one.", )), Some(toggle.into_any_element()), &t, )) .child(group("Launcher", "monitor")) .child(index_row( n + 3, "Appearance", Some(plain("Dark by default. System follows your computer's light or dark.")), Some(appearance.into_any_element()), &t, )) .child(index_row( n + 3, "Show the opening", Some(plain("The wordmark, while the release list loads.")), Some(opening.into_any_element()), &t, )) .child(group("Game", "gamepad")) .child(self.game_args_row(n + 4, cx)) .child(group("AI", "terminal")) .child(self.no_ai_row(n + 4, cx)) .child(group("About", "info-box")) .child(index_row(n + 5, "Horizon", Some(plain(&horizon)), horizon_action, &t)) .child(index_row( n + 6, "Launcher", Some(plain(&launcher)), launcher_action, &t, )) .child(index_row( n + 7, "Data folder", Some(mono(short(&backend::data_dir()))), None, &t, )) .child(index_row( n + 8, "Logs", Some(mono(format!( "{} · crash reports beside it", short(&backend::logs_dir()) ))), Some( button("open-logs", "Open", Kind::Secondary, &t) .on_click(|_, _, cx| { let dir = backend::logs_dir(); let _ = std::fs::create_dir_all(&dir); cx.open_with_system(&dir); }) .into_any_element(), ), &t, )) .when(cfg!(target_os = "linux"), |d| { d.child(index_row( n + 9, "Applications menu", Some(plain(if self.settings.desktop_entry() { "Horizon and its icon are in your desktop's menu." } else { "Not in your desktop's menu." })), Some(menu_entry.into_any_element()), &t, )) }), ) .child(self.collection_section(cx)) .children(self.agents_section(cx)) } /// Settings' Game arguments row: the extra arguments the game starts with, kept in /// `settings.json` and appended to the launcher's own (quotes group a word with spaces). fn game_args_row(&self, n: usize, cx: &mut Context) -> Div { let t = self.theme; let focused = self.args_focused; let field = div() .id("game-args") .track_focus(&self.args_focus) .flex() .items_center() .w(px(300.)) .h(px(30.)) .px(px(12.)) .overflow_hidden() .border_2() .border_color(if focused { t.accent } else { t.outline }) .bg(t.well) .font_family(theme::MONO) .text_size(px(12.)) .cursor_text() .child(if self.args_input.is_empty() && !focused { div() .text_color(t.muted) .child("For example --server-thread") } else { // The end of a long line stays in view while typing. let chars: Vec = self.args_input.chars().collect(); let shown: String = chars[chars.len().saturating_sub(44)..].iter().collect(); div().text_color(t.ink).child(shown) }) .when(focused, |d| d.child(div().w(px(1.)).h(px(14.)).bg(t.ink))) .on_click(cx.listener(|this, _: &ClickEvent, window, cx| { window.focus(&this.args_focus); cx.notify(); })) .on_key_down(cx.listener(|this, ev: &KeyDownEvent, _, cx| { let k = &ev.keystroke; let paste = k.key == "v" && (k.modifiers.control || k.modifiers.platform); match k.key.as_str() { "backspace" => { this.args_input.pop(); } _ if paste => { if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) { this.args_input.push_str(text.trim()); } } _ if !k.modifiers.control && !k.modifiers.platform => { if let Some(ch) = &k.key_char { this.args_input.push_str(ch); } } _ => return, } this.args_input.truncate(1024); this.settings.game_args = this.args_input.clone(); this.settings.save(); cx.stop_propagation(); cx.notify(); })); index_row( n, "Game arguments", Some( div() .child("Extra arguments for the game, passed through as-is (quotes group a word with spaces). Applies the next time the game starts.") .into_any_element(), ), Some(field.into_any_element()), &t, ) } /// Settings' Microsoft accounts: who is signed in and plays, the sign-in with its code. The /// rows are numbered from 01; returns them and how many there are. fn account_rows(&mut self, cx: &mut Context) -> (Div, usize) { let t = self.theme; let mut rows = div().flex().flex_col(); let mut n = 0; let selected = self.accounts.selected.clone(); for (i, a) in self.accounts.accounts.clone().into_iter().enumerate() { let plays = selected.as_ref() == Some(&a.uuid); let uuid = a.uuid.clone(); let mut actions = div().flex().gap(px(4.)); if plays { actions = actions.child( button(format!("offline-{i}"), "Play offline", Kind::Ghost, &t).on_click( cx.listener(|this, _: &ClickEvent, _, cx| { this.accounts.selected = None; let _ = this.accounts.save(); cx.notify(); }), ), ); } else { let uuid = uuid.clone(); actions = actions.child( button(format!("select-{i}"), "Play as", Kind::Secondary, &t).on_click( cx.listener(move |this, _: &ClickEvent, _, cx| { this.accounts.selected = Some(uuid.clone()); let _ = this.accounts.save(); cx.notify(); }), ), ); } actions = actions.child( button(format!("sign-out-{i}"), "Sign out", Kind::Ghost, &t).on_click(cx.listener( move |this, _: &ClickEvent, _, cx| { let store = account::store(); if let Err(e) = this.accounts.remove(store, &uuid) { this.sign_in_state = Some(SignInState::Done(Err(e))); } let _ = this.accounts.save(); cx.notify(); }, )), ); n += 1; rows = rows.child(index_row( n, a.name.clone(), Some( div() .child(if plays { "Microsoft account · plays" } else { "Microsoft account · signed in" }) .into_any_element(), ), Some(actions.into_any_element()), &t, )); } let configured = account::client_id().is_some(); let busy = matches!( self.sign_in_state, Some(SignInState::Starting | SignInState::Code(_)) ); let detail = match &self.sign_in_state { _ if !configured => div().child(account::NOT_CONFIGURED), Some(SignInState::Starting) => div().child("Asking Microsoft…"), Some(SignInState::Code(code)) => div() .flex() .flex_col() .gap(px(6.)) .child(format!( "Open {} in your browser and enter this code:", code.verification_uri )) .child( text(theme::HEADING) .font_family(theme::MONO) .text_color(t.ink) .child(code.user_code.clone()), ), Some(SignInState::Done(Ok(a))) => div().child(format!("Signed in as {}.", a.name)), Some(SignInState::Done(Err(e))) => div().text_color(t.danger).child(e.clone()), None if self.accounts.accounts.is_empty() => div().child( "Sign in to play on online servers with your name and skin. Without an account the game plays offline.", ), None => div().child("Add another account."), }; let detail = if self.keychain || self.accounts.accounts.is_empty() { detail } else { div() .flex() .flex_col() .gap(px(4.)) .child(detail) .child(div().child(account::NO_KEYCHAIN)) }; let action = if !configured { // No client ID in this build: the button says what's coming and does nothing. Some(button("sign-in", "Coming soon", Kind::Ghost, &t).into_any_element()) } else if let Some(SignInState::Code(code)) = &self.sign_in_state { let (uri, user_code) = (code.verification_uri.clone(), code.user_code.clone()); Some( div() .flex() .gap(px(4.)) .child( button("sign-in-copy", "Copy code", Kind::Secondary, &t).on_click( move |_, _, cx| { cx.write_to_clipboard(gpui::ClipboardItem::new_string( user_code.clone(), )) }, ), ) .child( button("sign-in-open", "Open link", Kind::Secondary, &t) .on_click(move |_, _, cx| cx.open_url(&uri)), ) .child( button("sign-in-cancel", "Cancel", Kind::Ghost, &t).on_click(cx.listener( |this, _: &ClickEvent, _, cx| { if let Some(s) = this.sign_in.take() { s.cancel(); } this.sign_in_state = None; cx.notify(); }, )), ) .into_any_element(), ) } else if busy { None } else { Some( button("sign-in", "Sign in with Microsoft", Kind::Secondary, &t) .on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.sign_in = Some(SignIn::start()); this.sign_in_state = Some(SignInState::Starting); cx.notify(); })) .into_any_element(), ) }; n += 1; let title = if !configured { "Microsoft account (coming soon)" } else if self.accounts.accounts.is_empty() { "Microsoft account" } else { "Another account" }; rows = rows.child(index_row( n, title, Some(detail.into_any_element()), action, &t, )); (rows, n) } /// Join a friend: a code field and Join, which starts the game straight /// into the friend's world (errors show in the game). fn join_friend_row(&self, can_play: bool, cx: &mut Context) -> Div { let t = self.theme; let focused = self.friend_focused; let field = div() .id("friend-code") .track_focus(&self.friend_focus) .flex() .items_center() .w(px(260.)) .h(px(30.)) .px(px(12.)) .overflow_hidden() .border_2() .border_color(if focused { t.accent } else { t.outline }) .bg(t.well) .font_family(theme::MONO) .text_size(px(12.)) .cursor_text() .child(if self.friend_code.is_empty() && !focused { div().text_color(t.muted).child("Paste an invite code") } else { // The end of a long code stays in view while typing. let shown: String = { let chars: Vec = self.friend_code.chars().collect(); chars[chars.len().saturating_sub(30)..].iter().collect() }; div().text_color(t.ink).child(shown) }) .when(focused, |d| d.child(div().w(px(1.)).h(px(14.)).bg(t.ink))) .on_click(cx.listener(|this, _: &ClickEvent, window, cx| { window.focus(&this.friend_focus); cx.notify(); })) .on_key_down(cx.listener(|this, ev: &KeyDownEvent, _, cx| { let k = &ev.keystroke; let paste = k.key == "v" && (k.modifiers.control || k.modifiers.platform); match k.key.as_str() { "enter" => this.join_friend(), "backspace" => { this.friend_code.pop(); } _ if paste => { if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) { this.friend_code.push_str(text.trim()); } } _ if !k.modifiers.control && !k.modifiers.platform => { if let Some(ch) = &k.key_char { this.friend_code.push_str(ch); } } _ => return, } this.friend_code.truncate(256); cx.stop_propagation(); cx.notify(); })); let valid = horizon_friends::invite::parse(&self.friend_code).is_some(); let mut join = button("join-friend", "Join", Kind::Secondary, &t); if can_play && valid { join = join.on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.join_friend(); cx.notify(); })); } else { join = disabled(join); } index_row( 3, "Join a friend", Some( div() .child("Paste the code a friend shows when they invite you.") .into_any_element(), ), Some( div() .flex() .items_center() .gap(px(8.)) .child(field) .child(join) .into_any_element(), ), &t, ) } fn join_friend(&mut self) { if horizon_friends::invite::parse(&self.friend_code).is_none() { return; } self.joining = Some(self.friend_code.clone()); self.play(); if self.starting_client.is_none() { self.joining = None; } } fn versions_page(&mut self, cx: &mut Context) -> Div { let t = self.theme; let header = page_header( "Versions", "Builds from GitHub. Each one installs into its own folder.", &t, ); let page = div().flex().flex_col().gap(px(32.)).child(header); let releases = match &self.releases { Load::Loading => return page.child(centered("Loading releases…", &t)), Load::Failed(e) => { return page.child(centered(&format!("Couldn't load releases. {e}"), &t).child( button("retry", "Try again", Kind::Secondary, &t).on_click(cx.listener( |this, _: &ClickEvent, _, cx| { this.fetch_releases(); cx.notify(); }, )), )) } Load::Ready(r) if r.is_empty() => return page.child(centered("No releases yet.", &t)), Load::Ready(r) => r.clone(), }; // A hundred releases: only the rows near the screen are drawn. let keep = |i: usize| { let tag = &releases[i].tag; self.installing.as_ref().is_some_and(|(t, _)| t == tag) || self.install_error.as_ref().is_some_and(|(t, _)| t == tag) || self.confirm_remove.as_ref() == Some(tag) }; let list = self.long_list.clone().column( &self.content_scroll.handle, releases.len(), 8., keep, |i| { let release = releases[i].clone(); let tag = release.tag.clone(); let installed = self.installed.contains(&tag); let selected = self.selected() == Some(&tag); let mut meta = vec![release.date.clone()]; if let Some((_, size)) = release.asset { meta.push(megabytes(size)); } let summary = release .name .split_once(": ") .map(|(_, rest)| rest.to_string()) .unwrap_or_else(|| release.name.clone()); let right: gpui::AnyElement = if let Some((_, p)) = self.installing.as_ref().filter(|(t, _)| *t == tag) { div() .flex() .items_center() .gap(px(10.)) .w(px(180.)) .child(progress_bar(Some(self.bar), &t)) .child( text(theme::MICRO) .w(px(36.)) .text_color(t.muted) .child(format!("{:.0}%", p * 100.)), ) .into_any_element() } else if installed { let confirming = self.confirm_remove.as_ref() == Some(&tag); let (t1, t2) = (tag.clone(), tag.clone()); div() .flex() .items_center() .gap(px(4.)) .when(!selected && !confirming, |d| { d.child( button(format!("use-{tag}"), "Use", Kind::Ghost, &t).on_click( cx.listener(move |this, _: &ClickEvent, _, cx| { this.settings.selected = Some(t1.clone()); this.settings.save(); cx.notify(); }), ), ) }) .child( button( format!("remove-{tag}"), if confirming { "Remove for good" } else { "Remove" }, if confirming { Kind::Secondary } else { Kind::Ghost }, &t, ) .when(confirming, |b| b.text_color(t.danger)) .on_click(cx.listener( move |this, _: &ClickEvent, _, cx| { if this.confirm_remove.as_ref() == Some(&t2) { this.remove(&t2); } else { this.confirm_remove = Some(t2.clone()); } cx.notify(); }, )), ) .into_any_element() } else if release.asset.is_none() { text(theme::CAPTION) .text_color(t.muted) .child("No build for this platform") .into_any_element() } else { let mut b = button(format!("install-{tag}"), "Install", Kind::Secondary, &t); if self.installing.is_some() { b = disabled(b); } else { b = b.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| { this.install(&release); cx.notify(); })); } b.into_any_element() }; let status = if selected { Some(caps("In use").text_color(t.accent)) } else if installed { Some(caps("Installed").text_color(t.ink_soft)) } else { None }; let error = self .install_error .as_ref() .filter(|(t, _)| *t == tag) .map(|(_, e)| e.clone()); let id = SharedString::from(format!("release-{tag}")); let row = div() .id(id.clone()) .relative() .flex() .flex_col() .gap(px(10.)) .py(px(14.)) .px(px(16.)) .mb(px(8.)) .bg(t.panel) .border_2() .border_color(t.outline) .children(blocks::edges(t.bevel, t.lip, theme::BEVEL)) .child(hover_layer(&id, t.raised, 0., 0.)) .child( div() .relative() .flex() .items_center() .gap(px(16.)) .child( div() .flex() .flex_col() .flex_1() .min_w_0() .gap(px(4.)) .child(version_tag(&tag).text_color(t.ink)) .child( text(theme::UI) .text_color(t.muted) .truncate() .child(summary), ), ) .child( div() .flex() .flex_col() .items_end() .gap(px(2.)) .flex_none() .children(status) .child(caps(meta.join(" · ")).text_color(t.muted)), ) .child( div() .flex() .justify_end() .w(px(190.)) .flex_none() .child(right), ), ) .children(error.map(|e| notice(e, &t))); track_hover(row, id) }, ); page.child(list) } fn notes_page(&mut self, cx: &mut Context) -> Div { let t = self.theme; let sponsor = (!self.links.sponsor.is_empty()).then(|| { plate(&t) .flex() .items_center() .justify_between() .gap(px(16.)) .p(px(24.)) .child( div() .flex() .flex_col() .gap(px(4.)) .child( text(theme::HEADING) .text_color(t.ink) .child("Support the work below"), ) .child(text(theme::UI).text_color(t.muted).child( "Horizon is built in the open. Sponsors fund the next release.", )), ) .child( button("sponsor", "Sponsor on GitHub", Kind::Secondary, &t) .bg(t.plate) .on_click({ let url = self.links.sponsor.clone(); move |_: &ClickEvent, _, cx| cx.open_url(&url) }), ) }); let page = div() .flex() .flex_col() .gap(px(32.)) .child(page_header( "Patch notes", "What changed in each release, newest first.", &t, )) .children(sponsor); let releases = match &self.releases { Load::Loading => return page.child(centered("Loading patch notes…", &t)), Load::Failed(e) => { return page.child( centered(&format!("Couldn't load patch notes. {e}"), &t).child( button("retry-notes", "Try again", Kind::Secondary, &t).on_click( cx.listener(|this, _: &ClickEvent, _, cx| { this.fetch_releases(); cx.notify(); }), ), ), ) } Load::Ready(r) => r.clone(), }; let list = self.long_list.clone().column( &self.content_scroll.handle, releases.len(), 10., |_| false, |i| { let release = &releases[i]; let summary = release .name .split_once(": ") .map(|(_, rest)| rest.to_string()) .unwrap_or_default(); div() .flex() .flex_col() .relative() .gap(px(16.)) .p(px(20.)) .mb(px(10.)) .bg(t.panel) .border_2() .border_color(t.outline) .children(blocks::edges(t.bevel, t.lip, theme::BEVEL)) .child( div() .flex() .items_center() .gap(px(16.)) .child( div() .flex() .flex_col() .flex_1() .min_w_0() .gap(px(4.)) .child(version_tag(&release.tag).text_color(t.ink)) .when(!summary.is_empty(), |d| { d.child(text(theme::UI).text_color(t.muted).child(summary)) }), ) .child(caps(release.date.clone()).flex_none().text_color(t.muted)), ) .child( div() .max_w(px(640.)) .child(if release.body.trim().is_empty() { text(theme::UI) .text_color(t.muted) .child("No notes for this release.") .into_any_element() } else { markdown::render(&release.body, &t) }), ) }, ); page.child(list) } } /// A thin bar. A known fraction eases from its previous value; an unknown one shuttles slowly. /// Progress: a sunk track filling with the accent; work of unknown length shuttles a block. fn progress_bar(fraction: Option<(f32, f32)>, t: &Theme) -> Div { let bar = div() .absolute() .top_0() .bottom_0() .bg(t.accent) .border_b_2() .border_color(t.face_lip); let track = div() .relative() .flex_1() .h(px(12.)) .border_2() .border_color(t.outline) .bg(t.well) .overflow_hidden(); match fraction { Some((from, to)) => { let (from, to) = (from.clamp(0.02, 1.), to.clamp(0.02, 1.)); track.child(bar.left_0().with_animation( ElementId::named_usize("bar", (to * 1000.) as usize), Animation::new(theme::MOVE).with_easing(ease_out_quint()), move |d, p| d.w(relative(from + (to - from) * p)), )) } None => track.child( bar.w(relative(0.3)).with_animation( "shuttle", Animation::new(Duration::from_millis(1600)) .repeat() .with_easing(gpui::ease_in_out), |d, p| d.left(relative(-0.3 + 1.3 * p)), ), ), } } impl Render for Launcher { fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { let t = self.theme; self.scale = window.scale_factor(); self.perf.frame(); if self.bench.as_ref().is_some_and(perf::Bench::scrolling) { self.bench_scroll(window); } self.servers.note_focus(window); self.friend_focused = self.friend_focus.is_focused(window); self.mods.note_focus(window); self.args_focused = self.args_focus.is_focused(window); let content = match self.page { Page::Play => self.play_page(cx), Page::Versions => self.versions_page(cx), Page::Mods => self.mods_page(cx), Page::Servers => self.servers_page(cx), Page::Notes => self.notes_page(cx), Page::Settings => self.settings_page(cx), }; // The new page fades in and rises a few pixels. let content = div() .relative() .w_full() // Let the page shrink inside the padded flex row so long notices can wrap. .min_w_0() .max_w(px(1152.)) .child(content) .with_animation( ElementId::named_usize("page", self.switches), Animation::new(theme::ENTER).with_easing(ease_out_quint()), |d, p| d.opacity(p).top(px(theme::RISE * (1. - p))), ); let (reveal, held) = self.opening_phase(window); let ui = ease_out_cubic((reveal - 0.3) / 0.7); if self.opening.is_none() && window.focused(cx).is_none() { window.focus(&self.root_focus); } let size = window.viewport_size(); let stone = self.art.stone(t.page_rgb, t.dark, window.scale_factor()); let topbar = self.topbar(cx); let sidebar = self.sidebar(cx); let mut root = div() .id("root") .track_focus(&self.root_focus) .on_key_down(cx.listener(|this, ev: &KeyDownEvent, window, cx| { let k = &ev.keystroke; match k.key.as_str() { "tab" => { KEYBOARD.store(true, Ordering::Relaxed); if k.modifiers.shift { window.focus_prev(); } else { window.focus_next(); } } "escape" if this.servers_escape() => {} _ => return, } cx.stop_propagation(); cx.notify(); })) .capture_any_mouse_down(|_, _, _| KEYBOARD.store(false, Ordering::Relaxed)) .relative() .flex() .flex_col() .size_full() .bg(t.page) .font_family(theme::FONT) .text_color(t.ink) .overflow_hidden() .child(blocks::stone(stone, size.width.into(), size.height.into())) .child( div() .relative() .flex() .flex_col() .size_full() .opacity(ui) .top(px(theme::RISE * (1. - ui))) .child(topbar) .child( div().flex().flex_1().min_h_0().child(sidebar).child( self.content_scroll .wrap( div() .id("content") .relative() .flex_1() .min_h_0() .overflow_y_scroll() .child( div() .flex() .px(px(32.)) .pt(px(if self.page == Page::Play { 0. } else { 28. })) .pb(px(48.)) .child(content), ), &t, ) .flex_1() .min_w_0(), ), ), ); if self.page == Page::Servers { if let Some(dialog) = self.create_dialog(cx) { root = root.child(dialog); } } if self.asking_consent() { root = root.child(self.consent_screen(cx)); } if let Some(opening) = &self.opening { // The wordmark arrives letter by letter, then gives way to the launcher; a click or // a key skips ahead. let gone = 1. - ease_out_cubic(reveal / 0.6); let word = div() .flex() .font_family(theme::PIXEL) .text_size(px(theme::WORDMARK.px * 0.5)) .line_height(px(theme::WORDMARK.px * 0.5)) .font_weight(FontWeight::BOLD) .text_color(t.ink) .children("HORIZON".chars().enumerate().map(|(i, c)| { let at = held - i as f32 * theme::STAGGER.as_secs_f32() * 1.5; let p = ease_out_cubic(at / theme::ENTER.as_secs_f32()); div() .relative() .opacity(p) .top(px(theme::RISE * 2. * (1. - p))) .child(c.to_string()) })); root = root.child( div() .id("opening") .track_focus(&opening.focus) .absolute() .top_0() .left_0() .size_full() .flex() .items_center() .justify_center() .bg(t.page.opacity(gone)) .when(reveal == 0., |d| d.cursor_pointer()) .child( div() .relative() .top(px(-24. * (1. - gone))) .opacity(gone) .child(word), ) .when(reveal == 0., |d| { d.on_click(cx.listener(|this, _: &ClickEvent, _, cx| { this.skip_opening(); cx.notify(); })) .on_key_down(cx.listener( |this, _: &KeyDownEvent, _, cx| { this.skip_opening(); cx.notify(); }, )) }), ); } root } } impl Launcher { /// Where the opening is: the reveal's progress (1 when there is no opening) and how long /// the wordmark has been showing, in seconds. fn opening_phase(&mut self, window: &mut Window) -> (f32, f32) { let loaded = !matches!(self.releases, Load::Loading); let Some(opening) = &mut self.opening else { return (1., 10.); }; let held = opening.started.get_or_insert_with(Instant::now).elapsed(); if opening.reveal.is_none() && ((held >= OPENING_HOLD && loaded) || held >= OPENING_MAX) { opening.reveal = Some(Instant::now()); } let reveal = opening.reveal.map_or(0., |at| { at.elapsed().as_secs_f32() / OPENING_REVEAL.as_secs_f32() }); if reveal >= 1. { self.opening = None; return (1., 10.); } window.request_animation_frame(); (reveal, held.as_secs_f32()) } /// `horizon-launcher benchmark`: scroll the page a little on every frame, back to the top at /// the bottom, so the frame times measure scrolling. fn bench_scroll(&mut self, window: &mut Window) { let handle = &self.content_scroll.handle; let mut offset = handle.offset(); offset.y -= px(24.); if -offset.y > handle.max_offset().height { offset.y = px(0.); } handle.set_offset(offset); window.request_animation_frame(); } fn skip_opening(&mut self) { if let Some(opening) = &mut self.opening { opening.reveal.get_or_insert_with(Instant::now); } } } actions!(horizon_launcher, [Quit, CloseWindow]); /// What closing the last window does: stop the servers this launcher started, send the telemetry, /// exit. A game that is running keeps running. Cmd+Q goes through here too. fn shut_down(cx: &mut App) { servers_page::stop_on_quit(); telemetry::send_before_exit(); cx.quit() } /// The macOS shortcuts: Cmd+Q quits, Cmd+W closes the window. #[cfg(target_os = "macos")] fn key_bindings() -> Vec { vec![ KeyBinding::new("cmd-q", Quit, None), KeyBinding::new("cmd-w", CloseWindow, None), ] } #[cfg(not(target_os = "macos"))] fn key_bindings() -> Vec { Vec::new() } /// The menu bar on macOS, where "Quit" belongs to the app menu. fn menus() -> Vec { vec![ Menu { name: "Horizon Launcher".into(), items: vec![MenuItem::action("Quit Horizon Launcher", Quit)], }, Menu { name: "Window".into(), items: vec![MenuItem::action("Close Window", CloseWindow)], }, ] } fn main() { perf::process_started(); backend::exe_path(); if let Some(code) = cli::run() { std::process::exit(code); } Application::new() .with_assets(blocks::Assets) .run(|cx: &mut App| { cx.text_system() .add_fonts(vec![ Cow::Borrowed(horizon_theme::fonts::GEIST_REGULAR), Cow::Borrowed(horizon_theme::fonts::GEIST_MEDIUM), Cow::Borrowed(horizon_theme::fonts::GEIST_SEMIBOLD), Cow::Borrowed(horizon_theme::fonts::GEIST_MONO), Cow::Borrowed(horizon_theme::fonts::PIXEL_MEDIUM), Cow::Borrowed(horizon_theme::fonts::PIXEL_SEMIBOLD), Cow::Borrowed(horizon_theme::fonts::PIXEL_BOLD), ]) .expect("bundled fonts"); cx.bind_keys(key_bindings()); cx.on_action(|_: &Quit, cx| shut_down(cx)); // The key press is being handled inside the window, so the window can only be // removed once that update has finished. cx.on_action(|_: &CloseWindow, cx| { cx.defer(|cx| { for window in cx.windows() { let _ = window.update(cx, |_, window, _| window.remove_window()); } }) }); cx.set_menus(menus()); let bounds = Bounds::centered(None, size(px(1180.), px(760.)), cx); cx.open_window( WindowOptions { window_bounds: Some(WindowBounds::Windowed(bounds)), window_min_size: Some(size(px(960.), px(600.))), titlebar: Some(TitlebarOptions { title: Some("Horizon".into()), ..Default::default() }), app_id: Some("horizon-launcher".into()), ..Default::default() }, |window, cx| cx.new(|cx| Launcher::new(window, cx)), ) .expect("window"); cx.on_window_closed(shut_down).detach(); cx.activate(true); }); } #[cfg(test)] mod tests { #[cfg(target_os = "macos")] #[test] fn cmd_q_quits_and_cmd_w_closes_the_window() { use super::{key_bindings, CloseWindow, Quit}; use gpui::{Keymap, Keystroke}; let keymap = Keymap::new(key_bindings()); let key = |s: &str| [Keystroke::parse(s).unwrap()]; let (hit, _) = keymap.bindings_for_input(&key("cmd-q"), &[]); assert!(hit.iter().any(|b| b.action().partial_eq(&Quit))); let (hit, _) = keymap.bindings_for_input(&key("cmd-w"), &[]); assert!(hit.iter().any(|b| b.action().partial_eq(&CloseWindow))); } #[test] fn the_app_menu_has_quit() { let menus = super::menus(); assert_eq!(menus[0].name, "Horizon Launcher"); assert!(matches!( &menus[0].items[0], gpui::MenuItem::Action { name, .. } if name == "Quit Horizon Launcher" )); } #[test] fn the_offline_name_is_read_from_its_key() { use super::player_name; assert_eq!( player_name("name:Player63010\n").as_deref(), Some("Player63010") ); assert_eq!(player_name("name:Steve\r\n").as_deref(), Some("Steve")); assert_eq!(player_name("Player63010\n"), None); assert_eq!(player_name(""), None); } #[test] fn counts_get_thousands_separators() { let shown: Vec = [0, 7, 999, 1000, 12_300, 1_234_500] .into_iter() .map(super::thousands) .collect(); assert_eq!(shown, ["0", "7", "999", "1,000", "12,300", "1,234,500"]); } }