Skip to content

Minecraft: Java Edition 26.3 rewritten from scratch in Rust, checked against vanilla with 281 differential harnesses. Get it with the Horizon launcher.

11.6 KB
Raw Blame
//! Home's Console tab: the game's output of this run as it comes, with a search, Follow (keep the
//! newest line in view), Copy, and Share log (`horizon_launcher::game_log`): an upload to mclo.gs
//! that happens only after the player confirms, without their home folder or names.
use super::servers_page::Field;
use super::*;
use gpui::{ClipboardItem, ScrollHandle};
use horizon_launcher::game_log::{self, Shared};

pub(super) struct Console {
    follow: bool,
    scroll: ScrollHandle,
    /// Lines and search at the last draw: a change means scroll down when following.
    seen: (usize, String),
    confirm_share: bool,
    sharing: bool,
    shared: Option<Result<Shared, String>>,
}

impl Default for Console {
    fn default() -> Self {
        Console {
            follow: true,
            scroll: ScrollHandle::new(),
            seen: (0, String::new()),
            confirm_share: false,
            sharing: false,
            shared: None,
        }
    }
}

impl Launcher {
    /// What Share log sends: this run's lines, else the selected instance's latest.log.
    fn log_to_share(&self) -> Result<(String, Vec<std::path::PathBuf>), String> {
        let home = self
            .client_home
            .clone()
            .or_else(|| self.selected_instance().map(|i| i.home.clone()))
            .unwrap_or_else(backend::game_home);
        let text = match self.prepare_log.is_empty() {
            false => {
                self.prepare_log
                    .iter()
                    .cloned()
                    .collect::<Vec<_>>()
                    .join("\n")
                    + "\n"
            }
            true => {
                let path = home.join("logs/latest.log");
                std::fs::read_to_string(&path)
                    .map_err(|_| tr("There is no log to share yet.").to_string())?
            }
        };
        Ok((text, vec![home, backend::game_home()]))
    }

    fn share_log(&mut self, cx: &mut Context<Self>) {
        let shared = match self.log_to_share() {
            Ok(log) => log,
            Err(e) => {
                self.console.shared = Some(Err(e));
                return;
            }
        };
        self.console.confirm_share = false;
        self.console.sharing = true;
        let task = cx.background_executor().spawn(async move {
            let (text, homes) = shared;
            let homes: Vec<&std::path::Path> = homes.iter().map(|h| h.as_path()).collect();
            let names = game_log::names(&homes);
            game_log::share(&game_log::private(
                &text,
                dirs::home_dir().as_deref(),
                &names,
            ))
        });
        cx.spawn(async move |this, cx| {
            let done = task.await;
            let _ = this.update(cx, |this, cx| {
                this.console.sharing = false;
                this.console.shared = Some(done);
                cx.notify();
            });
        })
        .detach();
    }

    fn unshare_log(&mut self, cx: &mut Context<Self>) {
        let Some(Ok(shared)) = self.console.shared.clone() else {
            return;
        };
        self.console.sharing = true;
        let task = cx
            .background_executor()
            .spawn(async move { game_log::unshare(&shared) });
        cx.spawn(async move |this, cx| {
            let done = task.await;
            let _ = this.update(cx, |this, cx| {
                this.console.sharing = false;
                this.console.shared = match done {
                    Ok(()) => None,
                    Err(e) => Some(Err(e)),
                };
                cx.notify();
            });
        })
        .detach();
    }

    /// Home's Console tab, once the game has said something (or is running): how many lines
    /// (beside the tabs) and the log.
    pub(super) fn console_section(&mut self, cx: &mut Context<Self>) -> Option<(Div, Div)> {
        let t = self.theme;
        if self.prepare_log.is_empty() && self.client.is_none() {
            return None;
        }
        let count = self.prepare_log.len();
        let header = text(theme::CAPTION)
            .text_color(t.muted)
            .child(match self.client {
                Some(_) => trf(
                    "{count} lines, the game is running",
                    &[("count", &count.to_string())],
                ),
                None => trf(
                    "{count} lines from the last run",
                    &[("count", &count.to_string())],
                ),
            });
        let mut section = div().flex().flex_col().gap(px(10.));
        let search = self.servers.value(Field::ConsoleSearch).trim().to_string();
        let lines: Vec<String> = self
            .prepare_log
            .iter()
            .filter(|l| game_log::matches(l, &search))
            .cloned()
            .collect();
        let now = (count, search);
        if self.console.follow && now != self.console.seen {
            self.console.scroll.scroll_to_bottom();
        }
        self.console.seen = now;
        let follow = div()
            .id("console-follow")
            .flex()
            .items_center()
            .gap(px(8.))
            .cursor_pointer()
            .child(switch("console-follow-switch", self.console.follow, &t))
            .child(
                text(theme::LABEL)
                    .text_color(t.ink_soft)
                    .child(tr("Follow")),
            )
            .on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
                this.console.follow = !this.console.follow;
                this.console.seen.0 = usize::MAX;
                cx.notify();
            }));
        let copied = lines.join("\n");
        let tools = div()
            .flex()
            .flex_wrap()
            .items_center()
            .gap(px(10.))
            .child(self.field(Field::ConsoleSearch, tr("Search the log"), 260., cx))
            .child(follow)
            .child(div().flex_1())
            .child(
                button("console-copy", "Copy", Kind::Ghost, &t).on_click(cx.listener(
                    move |this, _: &ClickEvent, _, cx| {
                        copy_to_clipboard(cx, ClipboardItem::new_string(copied.clone()));
                        this.console.shared = None;
                        cx.notify();
                    },
                )),
            )
            .child({
                let b = button("console-share", "Share log…", Kind::Ghost, &t);
                match self.console.sharing {
                    true => disabled(b),
                    false => b.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
                        this.console.confirm_share = true;
                        cx.notify();
                    })),
                }
            })
            .child({
                let logs = self
                    .client_home
                    .clone()
                    .or_else(|| self.selected_instance().map(|i| i.home.clone()))
                    .unwrap_or_else(backend::game_home)
                    .join("logs");
                button("console-folder", "Open logs folder", Kind::Ghost, &t).on_click(
                    move |_, _, cx| {
                        let _ = std::fs::create_dir_all(&logs);
                        cx.open_with_system(&logs);
                    },
                )
            });
        section = section.child(tools);
        if self.console.confirm_share {
            section = section.child(
                plate(&t)
                    .flex()
                    .items_center()
                    .gap(px(12.))
                    .px(px(14.))
                    .py(px(10.))
                    .child(div().flex_1().min_w_0().child(
                        text(theme::CAPTION).text_color(t.ink_soft).child(tr(
                            "Upload this log to mclo.gs, a paste service for Minecraft logs? \
                             Anyone with the link can read it, until it is deleted or unread \
                             for 90 days. Your home folder, user name and account names are \
                             taken out first.",
                        )),
                    ))
                    .child(
                        button("console-share-no", "Cancel", Kind::Ghost, &t).on_click(
                            cx.listener(|this, _: &ClickEvent, _, cx| {
                                this.console.confirm_share = false;
                                cx.notify();
                            }),
                        ),
                    )
                    .child(
                        button("console-share-yes", "Upload", Kind::Secondary, &t).on_click(
                            cx.listener(|this, _: &ClickEvent, _, cx| {
                                this.share_log(cx);
                                cx.notify();
                            }),
                        ),
                    ),
            );
        }
        match &self.console.shared {
            _ if self.console.sharing => {
                section = section.child(
                    text(theme::CAPTION)
                        .text_color(t.muted)
                        .child(tr("Sending…")),
                )
            }
            Some(Ok(shared)) => {
                let (url, open_url) = (shared.url.clone(), shared.url.clone());
                section = section.child(
                    div()
                        .flex()
                        .items_center()
                        .gap(px(10.))
                        .child(
                            text(theme::CAPTION)
                                .text_color(t.ink_soft)
                                .child(trf("Shared: {url}", &[("url", &url)])),
                        )
                        .child(
                            button("console-link-copy", "Copy link", Kind::Ghost, &t).on_click(
                                move |_, _, cx| {
                                    copy_to_clipboard(cx, ClipboardItem::new_string(url.clone()))
                                },
                            ),
                        )
                        .child(
                            button("console-link-open", "Open", Kind::Ghost, &t)
                                .on_click(move |_, _, cx| cx.open_url(&open_url)),
                        )
                        .child(
                            button("console-unshare", "Delete it", Kind::Ghost, &t).on_click(
                                cx.listener(|this, _: &ClickEvent, _, cx| {
                                    this.unshare_log(cx);
                                    cx.notify();
                                }),
                            ),
                        ),
                );
            }
            Some(Err(e)) => section = section.child(notice(e.clone(), &t)),
            None => {}
        }
        let shown = lines.len().saturating_sub(LOG_LINES);
        let body = div()
            .id("console-lines")
            .track_scroll(&self.console.scroll)
            .h(px(320.))
            .overflow_y_scroll()
            .p(px(10.))
            .border_2()
            .border_color(t.outline)
            .bg(t.well)
            .font_family(theme::MONO)
            .text_size(px(12.))
            .children(lines.into_iter().skip(shown).map(|line| {
                let color = if line.contains("/ERROR]") || line.contains("ERROR:") {
                    t.danger
                } else if line.contains("/WARN]") {
                    t.warn
                } else {
                    t.ink_soft
                };
                div().text_color(color).child(line)
            }));
        Some((header, section.child(body)))
    }
}