250c148e78
Title: the main menu labels follow the game language
1814 lines
67 KiB
Rust
1814 lines
67 KiB
Rust
//! Title, world selection and world creation screens (TitleScreen,
|
|
//! SelectWorldScreen, CreateWorldScreen layouts), drawn as HUD quads.
|
|
use crate::{
|
|
hud::{HudAtlas, HudBatch, rgba},
|
|
lang,
|
|
save::Level,
|
|
text::{Text, format_translation},
|
|
};
|
|
use std::path::{Path, PathBuf};
|
|
use std::{
|
|
cell::{Cell, RefCell},
|
|
sync::mpsc,
|
|
};
|
|
|
|
mod create_world;
|
|
#[cfg(test)]
|
|
mod tests;
|
|
pub mod world_management;
|
|
pub use create_world::{DIFFICULTIES, WorldOptions};
|
|
|
|
/// SelectWorldScreen's `HeaderAndFooterLayout(8 + 9 + 8 + 20 + 4, 60)`.
|
|
const LIST_TOP: f32 = 49.0;
|
|
const LIST_BOTTOM: f32 = 60.0;
|
|
const ROW_HEIGHT: f32 = 36.0;
|
|
const ROW_WIDTH: f32 = 270.0;
|
|
|
|
fn edit_top(h: f32) -> f32 {
|
|
((h.ceil() - 234.0) / 2.0).floor()
|
|
}
|
|
pub(crate) fn confirm_top(h: f32, lines: usize) -> f32 {
|
|
((h.ceil() - 61.0 - lines as f32 * 9.0) / 2.0).floor()
|
|
}
|
|
|
|
fn translate(key: &str, fallback: &str, args: &[&dyn std::fmt::Display]) -> String {
|
|
let args: Vec<Text> = args
|
|
.iter()
|
|
.map(|arg| Text::literal(arg.to_string()))
|
|
.collect();
|
|
format_translation(&lang::get_or(key, fallback), &args).plain()
|
|
}
|
|
|
|
enum BackupToast {
|
|
Created { folder: String, bytes: u64 },
|
|
Failed(String),
|
|
}
|
|
impl BackupToast {
|
|
fn text(&self) -> (String, String) {
|
|
match self {
|
|
Self::Created { folder, bytes } => (
|
|
translate("selectWorld.edit.backupCreated", "Backed up: %s", &[folder]),
|
|
translate(
|
|
"selectWorld.edit.backupSize",
|
|
"Size: %s MB",
|
|
&[&((*bytes as f64 / 1_048_576.0).ceil() as u64)],
|
|
),
|
|
),
|
|
Self::Failed(error) => (
|
|
lang::get_or("selectWorld.edit.backupFailed", "Backup failed"),
|
|
error.clone(),
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct WorldEntry {
|
|
pub folder: String,
|
|
pub name: String,
|
|
pub creative: bool,
|
|
pub modified: std::time::SystemTime,
|
|
pub commands: bool,
|
|
pub version: String,
|
|
}
|
|
#[derive(Clone, Debug)]
|
|
pub enum Mode {
|
|
Main,
|
|
Select {
|
|
worlds: Vec<WorldEntry>,
|
|
selected: Option<usize>,
|
|
},
|
|
Create {
|
|
name: String,
|
|
seed: String,
|
|
creative: bool,
|
|
focus: u8,
|
|
options: WorldOptions,
|
|
},
|
|
Edit {
|
|
world: WorldEntry,
|
|
name: String,
|
|
focused: bool,
|
|
},
|
|
Backup {
|
|
world: WorldEntry,
|
|
},
|
|
Delete {
|
|
world: WorldEntry,
|
|
},
|
|
Error {
|
|
message: String,
|
|
return_to: Box<Mode>,
|
|
},
|
|
Multiplayer(crate::multiplayer::Screen),
|
|
}
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum Action {
|
|
None,
|
|
Quit,
|
|
Options,
|
|
Accessibility,
|
|
Language,
|
|
Play {
|
|
folder: String,
|
|
},
|
|
Create {
|
|
folder: String,
|
|
name: String,
|
|
seed: Option<i64>,
|
|
creative: bool,
|
|
options: WorldOptions,
|
|
},
|
|
Connect {
|
|
address: String,
|
|
},
|
|
}
|
|
pub struct Title {
|
|
pub mode: Mode,
|
|
/// Direct Connection's address, synchronized with `options.txt`'s `lastServer`.
|
|
pub last_server: String,
|
|
pub saves: PathBuf,
|
|
pub started: std::time::Instant,
|
|
search: String,
|
|
search_focused: bool,
|
|
/// The focused text field's cursor, selection and scroll.
|
|
caret: RefCell<crate::ui::Caret>,
|
|
scroll: Cell<crate::ui::Scroll>,
|
|
create_return_to_main: bool,
|
|
message_lines: Cell<usize>,
|
|
backup: Option<mpsc::Receiver<Result<u64, String>>>,
|
|
backup_shown: Cell<bool>,
|
|
/// EditWorldScreen's `SystemToast` (`WORLD_BACKUP`) and its slide.
|
|
toast: Option<(crate::toasts::Slide, BackupToast)>,
|
|
icons: RefCell<std::collections::HashMap<PathBuf, (std::time::SystemTime, Option<Vec<u8>>)>>,
|
|
splash: Option<String>,
|
|
/// The saves listed for Home, re-read every couple of seconds.
|
|
recent: std::cell::RefCell<Option<(std::time::Instant, Vec<WorldEntry>)>>,
|
|
}
|
|
pub(crate) struct Button {
|
|
x: f32,
|
|
y: f32,
|
|
w: f32,
|
|
label: String,
|
|
enabled: bool,
|
|
id: u8,
|
|
icon: Option<(&'static str, f32)>,
|
|
}
|
|
/// Java String.hashCode for text seeds (WorldOptions.parseSeed).
|
|
pub fn parse_seed(text: &str) -> Option<i64> {
|
|
let t = text.trim();
|
|
if t.is_empty() {
|
|
return None;
|
|
}
|
|
Some(t.parse::<i64>().unwrap_or_else(|_| {
|
|
i64::from(
|
|
t.encode_utf16()
|
|
.fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(i32::from(c))),
|
|
)
|
|
}))
|
|
}
|
|
pub fn list_worlds(saves: &Path) -> Vec<WorldEntry> {
|
|
let mut worlds: Vec<WorldEntry> = std::fs::read_dir(saves)
|
|
.into_iter()
|
|
.flatten()
|
|
.flatten()
|
|
.filter_map(|e| {
|
|
let path = e.path();
|
|
let level = Level::read(&path)?;
|
|
let modified = std::fs::metadata(path.join("level.dat"))
|
|
.and_then(|m| m.modified())
|
|
.ok()?;
|
|
let data = crate::save::read_dat(&path.join("level.dat"))?;
|
|
let data = data.get("Data")?;
|
|
let modified = match data.get("LastPlayed") {
|
|
Some(horizon_world::nbt::Tag::Long(millis)) if *millis >= 0 => std::time::UNIX_EPOCH + std::time::Duration::from_millis(*millis as u64),
|
|
_ => modified,
|
|
};
|
|
Some(WorldEntry {
|
|
folder: e.file_name().to_string_lossy().into_owned(),
|
|
name: level.name,
|
|
creative: level.creative,
|
|
modified,
|
|
commands: matches!(data.get("allowCommands"), Some(horizon_world::nbt::Tag::Byte(v)) if *v != 0),
|
|
version: data.get("Version").and_then(|v| v.get("Name"))
|
|
.and_then(|v| match v { horizon_world::nbt::Tag::String(s) => Some(s.to_string_lossy()), _ => None })
|
|
.unwrap_or_else(|| "Unknown".into()),
|
|
})
|
|
})
|
|
.collect();
|
|
worlds.sort_by_key(|w| std::cmp::Reverse(w.modified));
|
|
worlds
|
|
}
|
|
fn choose_splash(text: &str, index: usize, date: (u32, u32)) -> Option<String> {
|
|
// SplashManager checks SpecialDates before the resource list (local date).
|
|
let special = match date {
|
|
(12, 24) => Some("Merry X-mas!"),
|
|
(1, 1) => Some("Happy new year!"),
|
|
(10, 31) => Some("OOoooOOOoooo! Spooky!"),
|
|
_ => None,
|
|
};
|
|
if let Some(special) = special {
|
|
return Some(special.to_owned());
|
|
}
|
|
let splashes: Vec<_> = text
|
|
.lines()
|
|
.map(str::trim)
|
|
// SplashManager.prepare keeps blank lines: only the hidden splash is dropped.
|
|
.filter(|s| horizon_core::random::java_string_hash(s.encode_utf16()) != 125780783)
|
|
.collect();
|
|
splashes
|
|
.get(index.checked_rem(splashes.len())?)
|
|
.map(|s| (*s).to_owned())
|
|
}
|
|
|
|
impl Title {
|
|
pub fn new(saves: PathBuf, resources: &Path) -> Self {
|
|
use chrono::Datelike;
|
|
let today = chrono::Local::now();
|
|
let mode = Mode::Main;
|
|
let now = std::time::Instant::now();
|
|
Self {
|
|
mode,
|
|
last_server: String::new(),
|
|
saves,
|
|
started: now,
|
|
search: String::new(),
|
|
search_focused: false,
|
|
caret: RefCell::default(),
|
|
scroll: Cell::default(),
|
|
create_return_to_main: false,
|
|
message_lines: Cell::new(1),
|
|
backup: None,
|
|
backup_shown: Cell::new(false),
|
|
toast: None,
|
|
icons: RefCell::new(std::collections::HashMap::new()),
|
|
splash: choose_splash(
|
|
&std::fs::read_to_string(resources.join("assets/minecraft/texts/splashes.txt"))
|
|
.unwrap_or_default(),
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap_or_default()
|
|
.subsec_nanos() as usize,
|
|
(today.month(), today.day()),
|
|
),
|
|
recent: std::cell::RefCell::new(None),
|
|
}
|
|
}
|
|
/// Vanilla bypasses the selector when there are no saves.
|
|
pub fn enter_singleplayer(&mut self) {
|
|
self.search.clear();
|
|
self.search_focused = true;
|
|
self.scroll.set(crate::ui::Scroll::default());
|
|
let worlds = list_worlds(&self.saves);
|
|
self.create_return_to_main = worlds.is_empty();
|
|
self.mode = if worlds.is_empty() {
|
|
Self::new_world()
|
|
} else {
|
|
Mode::Select {
|
|
worlds,
|
|
selected: None,
|
|
}
|
|
};
|
|
}
|
|
pub(crate) fn new_world() -> Mode {
|
|
Mode::Create {
|
|
name: "New World".into(),
|
|
seed: String::new(),
|
|
creative: false,
|
|
focus: 0,
|
|
options: WorldOptions::default(),
|
|
}
|
|
}
|
|
fn return_to_list(&mut self, folder: Option<&str>) {
|
|
let worlds = list_worlds(&self.saves);
|
|
let selected = folder.and_then(|folder| {
|
|
worlds
|
|
.iter()
|
|
.position(|w| w.folder == folder && self.matches_search(w))
|
|
});
|
|
self.mode = Mode::Select { worlds, selected };
|
|
*self.recent.borrow_mut() = None;
|
|
}
|
|
/// Deletes the world `Mode::Delete` asks about and goes back to the
|
|
/// refreshed list; a failure (the world is open elsewhere, say) shows the
|
|
/// error instead and leaves the world. Returns the deleted world's row in
|
|
/// the list before it went, for a layout that moves the selection there.
|
|
pub(crate) fn confirm_delete(&mut self) -> Option<usize> {
|
|
let Mode::Delete { world } = &self.mode else {
|
|
return None;
|
|
};
|
|
let folder = world.folder.clone();
|
|
let row = list_worlds(&self.saves)
|
|
.iter()
|
|
.position(|w| w.folder == folder);
|
|
if let Err(error) = world_management::delete(&self.saves, &folder) {
|
|
self.failed(error);
|
|
return None;
|
|
}
|
|
self.return_to_list(None);
|
|
self.icons.borrow_mut().clear();
|
|
row
|
|
}
|
|
fn cancel_create(&mut self) {
|
|
if self.create_return_to_main {
|
|
self.mode = Mode::Main;
|
|
} else {
|
|
self.return_to_list(None);
|
|
}
|
|
}
|
|
fn matches_search(&self, world: &WorldEntry) -> bool {
|
|
let filter = self.search.to_lowercase();
|
|
world.name.to_lowercase().contains(&filter) || world.folder.to_lowercase().contains(&filter)
|
|
}
|
|
fn visible_worlds<'a>(
|
|
&self,
|
|
worlds: &'a [WorldEntry],
|
|
) -> impl Iterator<Item = (usize, &'a WorldEntry)> {
|
|
worlds
|
|
.iter()
|
|
.enumerate()
|
|
.filter(|(_, w)| self.matches_search(w))
|
|
.collect::<Vec<_>>()
|
|
.into_iter()
|
|
}
|
|
/// The world list's top, bottom, rows' left edge and content height.
|
|
fn world_list(&self, worlds: &[WorldEntry], (w, h): (f32, f32)) -> (f32, f32, f32, f32) {
|
|
let (w, h) = (w.ceil(), h.ceil());
|
|
let content = self.visible_worlds(worlds).count() as f32 * ROW_HEIGHT + 4.0;
|
|
let left = (w / 2.0).floor() - ROW_WIDTH / 2.0;
|
|
(LIST_TOP, h - LIST_BOTTOM, left, content)
|
|
}
|
|
/// The visible row under the pointer and the pointer relative to its
|
|
/// content (`AbstractSelectionList.getEntryAtPosition`).
|
|
fn world_row_at(
|
|
&self,
|
|
worlds: &[WorldEntry],
|
|
(x, y): (f32, f32),
|
|
size: (f32, f32),
|
|
) -> Option<(usize, (f32, f32))> {
|
|
let (top, bottom, left, _) = self.world_list(worlds, size);
|
|
if y < top || y >= bottom || x < left || x >= left + ROW_WIDTH {
|
|
return None;
|
|
}
|
|
let offset = self.scroll.get().amount.trunc();
|
|
let row = ((y - top - 2.0 + offset) / ROW_HEIGHT).floor();
|
|
if row < 0.0 || row as usize >= self.visible_worlds(worlds).count() {
|
|
return None;
|
|
}
|
|
let content_y = top + 4.0 + row * ROW_HEIGHT - offset;
|
|
Some((row as usize, (x - left - 2.0, y - content_y)))
|
|
}
|
|
/// The pointer moved with the button held (`mouseDragged`).
|
|
pub fn drag(&mut self, cursor: (f32, f32), size: (f32, f32)) {
|
|
if let Mode::Multiplayer(screen) = &mut self.mode {
|
|
return screen.drag(cursor.1, size);
|
|
}
|
|
if let Mode::Select { worlds, .. } = &self.mode {
|
|
let (top, bottom, _, content) = self.world_list(worlds, size);
|
|
let mut scroll = self.scroll.get();
|
|
scroll.drag(cursor.1, top, bottom, content);
|
|
self.scroll.set(scroll);
|
|
}
|
|
}
|
|
/// The button was released (`onRelease`).
|
|
pub fn release(&mut self) {
|
|
if let Mode::Multiplayer(screen) = &mut self.mode {
|
|
screen.release();
|
|
}
|
|
self.scroll.get_mut().release();
|
|
}
|
|
/// Mouse wheel over the classic world and server lists.
|
|
pub fn scroll_worlds(&mut self, delta: f32, cursor: (f32, f32), size: (f32, f32)) {
|
|
if let Mode::Multiplayer(screen) = &mut self.mode {
|
|
screen.wheel(delta, cursor, size);
|
|
return;
|
|
}
|
|
let Mode::Select { worlds, .. } = &self.mode else {
|
|
return;
|
|
};
|
|
let (top, bottom, _, content) = self.world_list(worlds, size);
|
|
if cursor.1 < top || cursor.1 >= bottom {
|
|
return;
|
|
}
|
|
let mut scroll = self.scroll.get();
|
|
scroll.wheel(delta, ROW_HEIGHT / 2.0, top, bottom, content);
|
|
self.scroll.set(scroll);
|
|
}
|
|
pub fn failed(&mut self, error: impl std::fmt::Display) {
|
|
let return_to = Box::new(self.mode.clone());
|
|
self.mode = Mode::Error {
|
|
message: error.to_string(),
|
|
return_to,
|
|
};
|
|
}
|
|
/// Polling is done once per rendered frame so filesystem work never blocks drawing.
|
|
pub fn poll_backup(&mut self) {
|
|
if !self.backup_shown.get() {
|
|
return;
|
|
}
|
|
let Some(receiver) = &self.backup else {
|
|
return;
|
|
};
|
|
let result = match receiver.try_recv() {
|
|
Ok(result) => result,
|
|
Err(mpsc::TryRecvError::Empty) => return,
|
|
Err(mpsc::TryRecvError::Disconnected) => Err("Backup worker stopped".into()),
|
|
};
|
|
self.backup = None;
|
|
if let Mode::Backup { world } = &self.mode {
|
|
let folder = world.folder.clone();
|
|
self.return_to_list(Some(&folder));
|
|
let toast = match result {
|
|
Ok(bytes) => BackupToast::Created { folder, bytes },
|
|
Err(error) => BackupToast::Failed(error),
|
|
};
|
|
self.toast = Some((crate::toasts::Slide::default(), toast));
|
|
}
|
|
}
|
|
/// `ToastManager.update` for the system toast: slides it in, keeps it
|
|
/// for 5 s times the notification display time, slides it out. The
|
|
/// sound of a new visibility (`Toast.Visibility`), if any.
|
|
pub fn update_toast(&mut self, multiplier: f32) -> Option<&'static str> {
|
|
let (slide, _) = self.toast.as_mut()?;
|
|
// SystemToast.update: shown until displayTime (5000 ms) has passed.
|
|
let time = 5000.0 * f64::from(multiplier);
|
|
let (sound, finished) = slide.update_now(|fully| (fully as f64) < time);
|
|
if finished {
|
|
self.toast = None;
|
|
}
|
|
sound.map(|show| {
|
|
if show {
|
|
"minecraft:ui.toast.in"
|
|
} else {
|
|
"minecraft:ui.toast.out"
|
|
}
|
|
})
|
|
}
|
|
fn start_backup(&mut self, world: WorldEntry) {
|
|
let (send, receive) = mpsc::channel();
|
|
let saves = self.saves.clone();
|
|
let folder = world.folder.clone();
|
|
std::thread::spawn(move || {
|
|
let _ = send.send(world_management::backup(&saves, &folder).map_err(|e| e.to_string()));
|
|
});
|
|
self.backup_shown.set(false);
|
|
self.backup = Some(receive);
|
|
self.mode = Mode::Backup { world };
|
|
}
|
|
fn icon(
|
|
&self,
|
|
atlas: &HudAtlas,
|
|
batch: &mut HudBatch,
|
|
world: &WorldEntry,
|
|
slot: usize,
|
|
x: f32,
|
|
y: f32,
|
|
) {
|
|
let path = self.saves.join(&world.folder).join("icon.png");
|
|
let mut icons = self.icons.borrow_mut();
|
|
let pixels = if let Ok(modified) = std::fs::metadata(&path).and_then(|m| m.modified()) {
|
|
let cached = icons
|
|
.entry(path.clone())
|
|
.or_insert_with(|| (std::time::UNIX_EPOCH, None));
|
|
if cached.0 != modified {
|
|
*cached = (
|
|
modified,
|
|
crate::hud::decode(&path)
|
|
.ok()
|
|
.filter(|(w, h, _)| *w == 64 && *h == 64)
|
|
.map(|(_, _, p)| p),
|
|
);
|
|
}
|
|
cached.1.as_ref()
|
|
} else {
|
|
None
|
|
};
|
|
let sprite = format!("horizon/world-icon{slot}");
|
|
if let Some(pixels) = pixels
|
|
&& let Some(rect) = atlas.sprites.get(&sprite)
|
|
{
|
|
batch.patches.push(crate::font::Patch {
|
|
x: (rect.u0 * atlas.width as f32).round() as u32,
|
|
y: (rect.v0 * atlas.height as f32).round() as u32,
|
|
width: 64,
|
|
height: 64,
|
|
rgba: pixels.clone(),
|
|
});
|
|
batch.sprite_scaled(atlas, &sprite, x, y, 32.0, 32.0, u32::MAX);
|
|
} else {
|
|
batch.sprite_scaled(atlas, "misc/unknown_server", x, y, 32.0, 32.0, u32::MAX);
|
|
}
|
|
}
|
|
/// The worlds, newest first, cached for two seconds (drawn every frame).
|
|
/// Saves changed behind the screens' back (agent control renamed or deleted a world): the
|
|
/// list shows them again.
|
|
pub fn worlds_changed(&mut self) {
|
|
if matches!(self.mode, Mode::Select { .. }) {
|
|
self.return_to_list(None);
|
|
}
|
|
*self.recent.borrow_mut() = None;
|
|
}
|
|
pub fn recent_worlds(&self) -> Vec<WorldEntry> {
|
|
let mut recent = self.recent.borrow_mut();
|
|
match &*recent {
|
|
Some((at, worlds)) if at.elapsed().as_secs() < 2 => worlds.clone(),
|
|
_ => {
|
|
let worlds = list_worlds(&self.saves);
|
|
*recent = Some((std::time::Instant::now(), worlds.clone()));
|
|
worlds
|
|
}
|
|
}
|
|
}
|
|
/// Create New World: the folder name and options (FileUtil.findAvailableName).
|
|
pub fn create_action(&self) -> Action {
|
|
let Mode::Create {
|
|
name,
|
|
seed,
|
|
creative,
|
|
options,
|
|
..
|
|
} = &self.mode
|
|
else {
|
|
return Action::None;
|
|
};
|
|
Action::Create {
|
|
folder: self.target_folder(name),
|
|
name: name.clone(),
|
|
seed: parse_seed(seed),
|
|
creative: *creative,
|
|
options: options.clone(),
|
|
}
|
|
}
|
|
/// The folder a new world named `name` gets (`findResultFolder`).
|
|
fn target_folder(&self, name: &str) -> String {
|
|
let base: String = name
|
|
.chars()
|
|
.map(|c| {
|
|
if c.is_alphanumeric() || c == ' ' || c == '-' || c == '_' {
|
|
c
|
|
} else {
|
|
'_'
|
|
}
|
|
})
|
|
.collect();
|
|
let base = if base.trim().is_empty() {
|
|
"World".to_owned()
|
|
} else {
|
|
base.trim().to_owned()
|
|
};
|
|
// FileUtil.findAvailableName: append (n) until unused.
|
|
let mut folder = base.clone();
|
|
let mut n = 1;
|
|
while self.saves.join(&folder).exists() {
|
|
folder = format!("{base} ({n})");
|
|
n += 1;
|
|
}
|
|
folder
|
|
}
|
|
fn buttons(&self, w: f32, h: f32) -> Vec<Button> {
|
|
let (w, h) = (w.ceil(), h.ceil());
|
|
let b = |x: f32, y: f32, w: f32, label: &str, enabled: bool, id: u8| Button {
|
|
x,
|
|
y,
|
|
w,
|
|
label: label.into(),
|
|
enabled,
|
|
id,
|
|
icon: None,
|
|
};
|
|
match &self.mode {
|
|
Mode::Main => {
|
|
let cx = (w / 2.0).floor();
|
|
let y = (h / 4.0).floor() + 48.0;
|
|
let mut buttons = vec![
|
|
b(
|
|
cx - 100.0,
|
|
y,
|
|
200.0,
|
|
&lang::get_or("menu.singleplayer", "Singleplayer"),
|
|
true,
|
|
1,
|
|
),
|
|
b(
|
|
cx - 100.0,
|
|
y + 24.0,
|
|
200.0,
|
|
&lang::get_or("menu.multiplayer", "Multiplayer"),
|
|
true,
|
|
4,
|
|
),
|
|
b(
|
|
cx - 100.0,
|
|
y + 48.0,
|
|
200.0,
|
|
&lang::get_or("menu.online", "Minecraft Realms"),
|
|
false,
|
|
0,
|
|
),
|
|
b(
|
|
cx - 100.0,
|
|
y + 96.0,
|
|
98.0,
|
|
&lang::get_or("menu.options", "Options..."),
|
|
true,
|
|
3,
|
|
),
|
|
b(
|
|
cx + 2.0,
|
|
y + 96.0,
|
|
98.0,
|
|
&lang::get_or("menu.quit", "Quit Game"),
|
|
true,
|
|
2,
|
|
),
|
|
];
|
|
// CommonButtons' icon buttons; Horizon's Join a Friend (an
|
|
// invite code) sits behind vanilla's Friends button.
|
|
for (i, (key, plain, id, icon)) in [
|
|
("gui.friends.open", "Friends", 5, "friends/friends"),
|
|
("options.language", "Language...", 6, "icon/language"),
|
|
(
|
|
"options.accessibility",
|
|
"Accessibility Settings...",
|
|
7,
|
|
"icon/accessibility",
|
|
),
|
|
]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
let mut button = b(
|
|
cx - 34.0 + i as f32 * 24.0,
|
|
y + 72.0,
|
|
20.0,
|
|
&lang::get_or(key, plain),
|
|
true,
|
|
id,
|
|
);
|
|
button.icon = Some((icon, 15.0));
|
|
buttons.push(button);
|
|
}
|
|
buttons
|
|
}
|
|
Mode::Select { selected, .. } => vec![
|
|
b(
|
|
(w / 2.0).floor() - 154.0,
|
|
h - 52.0,
|
|
150.0,
|
|
&lang::get_or("selectWorld.select", "Play Selected World"),
|
|
selected.is_some(),
|
|
10,
|
|
),
|
|
b(
|
|
(w / 2.0).floor() + 4.0,
|
|
h - 52.0,
|
|
150.0,
|
|
&lang::get_or("selectWorld.create", "Create New World"),
|
|
true,
|
|
11,
|
|
),
|
|
b(
|
|
(w / 2.0).floor() - 154.0,
|
|
h - 28.0,
|
|
71.0,
|
|
&lang::get_or("selectWorld.edit", "Edit"),
|
|
selected.is_some(),
|
|
13,
|
|
),
|
|
b(
|
|
(w / 2.0).floor() - 75.0,
|
|
h - 28.0,
|
|
71.0,
|
|
&lang::get_or("selectWorld.delete", "Delete"),
|
|
selected.is_some(),
|
|
14,
|
|
),
|
|
b(
|
|
(w / 2.0).floor() + 4.0,
|
|
h - 28.0,
|
|
71.0,
|
|
&lang::get_or("selectWorld.recreate", "Re-Create"),
|
|
selected.is_some(),
|
|
15,
|
|
),
|
|
b(
|
|
(w / 2.0).floor() + 83.0,
|
|
h - 28.0,
|
|
71.0,
|
|
&lang::get_or("gui.back", "Back"),
|
|
true,
|
|
12,
|
|
),
|
|
],
|
|
Mode::Create {
|
|
creative, options, ..
|
|
} => create_world::buttons(w, h, *creative, options),
|
|
Mode::Edit { world, name, .. } => {
|
|
let x = (w / 2.0).floor() - 100.0;
|
|
let top = edit_top(h);
|
|
vec![
|
|
b(
|
|
x,
|
|
top + 64.0,
|
|
200.0,
|
|
&lang::get_or("selectWorld.edit.resetIcon", "Reset Icon"),
|
|
self.saves.join(&world.folder).join("icon.png").is_file(),
|
|
30,
|
|
),
|
|
b(
|
|
x,
|
|
top + 89.0,
|
|
200.0,
|
|
&lang::get_or("selectWorld.edit.openFolder", "Open World Folder"),
|
|
true,
|
|
31,
|
|
),
|
|
b(
|
|
x,
|
|
top + 114.0,
|
|
200.0,
|
|
&lang::get_or("selectWorld.edit.backup", "Make Backup"),
|
|
true,
|
|
32,
|
|
),
|
|
b(
|
|
x,
|
|
top + 139.0,
|
|
200.0,
|
|
&lang::get_or("selectWorld.edit.backupFolder", "Open Backups Folder"),
|
|
true,
|
|
33,
|
|
),
|
|
b(
|
|
x,
|
|
top + 164.0,
|
|
200.0,
|
|
&lang::get_or("selectWorld.edit.optimize", "Optimize World"),
|
|
false,
|
|
34,
|
|
),
|
|
b(
|
|
x,
|
|
top + 214.0,
|
|
98.0,
|
|
&lang::get_or("selectWorld.edit.save", "Save"),
|
|
!name.trim().is_empty(),
|
|
35,
|
|
),
|
|
b(
|
|
x + 102.0,
|
|
top + 214.0,
|
|
98.0,
|
|
&lang::get_or("gui.cancel", "Cancel"),
|
|
true,
|
|
36,
|
|
),
|
|
]
|
|
}
|
|
Mode::Delete { .. } => {
|
|
let y = confirm_top(h, self.message_lines.get())
|
|
+ 41.0
|
|
+ self.message_lines.get() as f32 * 9.0;
|
|
vec![
|
|
b(
|
|
(w / 2.0).floor() - 152.0,
|
|
y,
|
|
150.0,
|
|
&lang::get_or("selectWorld.deleteButton", "Delete"),
|
|
true,
|
|
37,
|
|
),
|
|
b(
|
|
(w / 2.0).floor() + 2.0,
|
|
y,
|
|
150.0,
|
|
&lang::get_or("gui.cancel", "Cancel"),
|
|
true,
|
|
38,
|
|
),
|
|
]
|
|
}
|
|
Mode::Error { .. } => vec![b(
|
|
(w / 2.0).floor() - 75.0,
|
|
confirm_top(h, self.message_lines.get())
|
|
+ 41.0
|
|
+ self.message_lines.get() as f32 * 9.0,
|
|
150.0,
|
|
&lang::get_or("gui.back", "Back"),
|
|
true,
|
|
39,
|
|
)],
|
|
Mode::Backup { .. } => Vec::new(),
|
|
Mode::Multiplayer(screen) => screen
|
|
.buttons(w, h)
|
|
.into_iter()
|
|
.map(|(x, y, bw, label, enabled, id)| b(x, y, bw, &label, enabled, id))
|
|
.collect(),
|
|
}
|
|
}
|
|
pub fn draw(
|
|
&self,
|
|
atlas: &HudAtlas,
|
|
batch: &mut HudBatch,
|
|
cursor: (f32, f32),
|
|
hide_splash: bool,
|
|
) {
|
|
let (w, h) = (batch.width.ceil(), batch.height.ceil());
|
|
match &self.mode {
|
|
Mode::Main => {
|
|
// LogoRenderer: the logo's top 44 of 64 rows, then the edition
|
|
// banner's top 14 of 16 rows overlapping its bottom by 7.
|
|
batch.sprite_region(
|
|
atlas,
|
|
"gui/title/minecraft",
|
|
[(w / 2.0).floor() - 128.0, 30.0, 256.0, 44.0],
|
|
256.0,
|
|
64.0,
|
|
);
|
|
batch.sprite_region(
|
|
atlas,
|
|
crate::title_edition::SPRITE,
|
|
[(w / 2.0).floor() - 64.0, 30.0 + 44.0 - 7.0, 128.0, 14.0],
|
|
128.0,
|
|
16.0,
|
|
);
|
|
if !hide_splash && let Some(splash) = self.splash.as_deref() {
|
|
let tw = HudBatch::text_width(atlas, splash);
|
|
let start = batch.vertices.len();
|
|
batch.text(
|
|
atlas,
|
|
splash,
|
|
-(tw / 2.0).floor(),
|
|
-8.0,
|
|
rgba(255, 255, 0, 255),
|
|
true,
|
|
);
|
|
let scale = (1.8
|
|
- (self.started.elapsed().as_secs_f32() * std::f32::consts::TAU)
|
|
.sin()
|
|
.abs()
|
|
* 0.1)
|
|
* 100.0
|
|
/ (tw + 32.0);
|
|
let (sin, cos) = (-20.0f32).to_radians().sin_cos();
|
|
for v in &mut batch.vertices[start..] {
|
|
let [x, y] = v.pos;
|
|
v.pos = [
|
|
w / 2.0 + 123.0 + scale * (x * cos - y * sin),
|
|
69.0 + scale * (x * sin + y * cos),
|
|
];
|
|
}
|
|
}
|
|
let version = format!("Horizon {} (Rust)", horizon_core::VANILLA_VERSION);
|
|
batch.text(atlas, &version, 2.0, h - 10.0, u32::MAX, true);
|
|
let notice = "Not affiliated with Mojang or Microsoft";
|
|
let tw = HudBatch::text_width(atlas, notice);
|
|
batch.text(atlas, notice, w - tw - 2.0, h - 10.0, u32::MAX, true);
|
|
}
|
|
Mode::Select { worlds, selected } => {
|
|
crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
|
|
centered(atlas, batch, "Select World", 8.0, u32::MAX);
|
|
self.caret.borrow_mut().draw(
|
|
batch,
|
|
atlas,
|
|
(SEARCH, &self.search, 50),
|
|
[(w / 2.0).floor() - 100.0, 21.0, 200.0, 20.0],
|
|
self.search_focused,
|
|
self.started,
|
|
);
|
|
if self.search.is_empty() && !self.search_focused {
|
|
batch.text_styled(
|
|
atlas,
|
|
&Text::literal(lang::get_or("gui.selectWorld.search", "Search..."))
|
|
.italic()
|
|
.with_color(crate::text::GRAY),
|
|
(w / 2.0).floor() - 96.0,
|
|
27.0,
|
|
u32::MAX,
|
|
true,
|
|
);
|
|
}
|
|
let (top, bottom, left, content) = self.world_list(worlds, (w, h));
|
|
let mut scroll = self.scroll.get();
|
|
scroll.clamp(top, bottom, content);
|
|
self.scroll.set(scroll);
|
|
let offset = scroll.amount.trunc();
|
|
// AbstractSelectionList: background, rows clipped to the
|
|
// list, separators, scrollbar.
|
|
crate::ui::list_background(batch, atlas, top, bottom, false);
|
|
let first = batch.vertices.len();
|
|
// Entry content sits 2 pixels inside its row.
|
|
let x = left + 2.0;
|
|
let mut slot = 0;
|
|
let hovered = self.world_row_at(worlds, cursor, (w, h));
|
|
for (row, (i, world)) in self.visible_worlds(worlds).enumerate() {
|
|
let y = top + 4.0 + row as f32 * ROW_HEIGHT - offset;
|
|
if y + 32.0 <= top || y >= bottom {
|
|
continue;
|
|
}
|
|
let mid = y - 2.0 + ROW_HEIGHT / 2.0;
|
|
if mid > top && mid < bottom {
|
|
let rect = [x - 2.0, y - 2.0, ROW_WIDTH, ROW_HEIGHT];
|
|
// The control socket's widget tree names the row.
|
|
crate::widgets::record_as(
|
|
&world.name,
|
|
rect,
|
|
true,
|
|
crate::widgets::Kind::Row,
|
|
);
|
|
crate::widgets::target_as(rect, crate::widgets::Kind::Row);
|
|
}
|
|
// extractSelection: white once the list has focus.
|
|
if *selected == Some(i) {
|
|
batch.fill(atlas, x - 2.0, y - 2.0, ROW_WIDTH, ROW_HEIGHT, u32::MAX);
|
|
batch.fill(
|
|
atlas,
|
|
x - 1.0,
|
|
y - 1.0,
|
|
ROW_WIDTH - 2.0,
|
|
ROW_HEIGHT - 2.0,
|
|
rgba(0, 0, 0, 255),
|
|
);
|
|
}
|
|
batch.text(atlas, &world.name, x + 35.0, y + 1.0, u32::MAX, true);
|
|
let date: chrono::DateTime<chrono::Local> = world.modified.into();
|
|
let line = format!("{} ({})", world.folder, date.format("%d/%m/%Y, %H:%M"));
|
|
batch.text(
|
|
atlas,
|
|
&line,
|
|
x + 35.0,
|
|
y + 12.0,
|
|
rgba(128, 128, 128, 255),
|
|
true,
|
|
);
|
|
let mode = if world.creative {
|
|
lang::get_or("gameMode.creative", "Creative Mode")
|
|
} else {
|
|
lang::get_or("gameMode.survival", "Survival Mode")
|
|
};
|
|
let commands = if world.commands {
|
|
format!(", {}", lang::get_or("selectWorld.commands", "Commands"))
|
|
} else {
|
|
String::new()
|
|
};
|
|
let details = format!(
|
|
"{mode}{commands}, {} {}",
|
|
lang::get_or("selectWorld.version", "Version:"),
|
|
world.version
|
|
);
|
|
batch.text(
|
|
atlas,
|
|
&details,
|
|
x + 35.0,
|
|
y + 21.0,
|
|
rgba(128, 128, 128, 255),
|
|
true,
|
|
);
|
|
self.icon(atlas, batch, world, slot, x, y);
|
|
slot = (slot + 1) % crate::hud::WORLD_ICON_SLOTS;
|
|
// WorldListEntry.extractContent: a hovered row dims its
|
|
// icon under the join arrow, lit under the pointer.
|
|
if let Some((_, (rx, ry))) = hovered.filter(|(r, _)| *r == row) {
|
|
batch.fill(atlas, x, y, 32.0, 32.0, 0xA0909090);
|
|
let on_icon = (0.0..32.0).contains(&rx) && (0.0..32.0).contains(&ry);
|
|
let sprite = if on_icon {
|
|
"gui/sprites/world_list/join_highlighted"
|
|
} else {
|
|
"gui/sprites/world_list/join"
|
|
};
|
|
batch.sprite_scaled(atlas, sprite, x, y, 32.0, 32.0, u32::MAX);
|
|
}
|
|
}
|
|
// Clip list quads, including their UVs, to the content area.
|
|
for quad in batch.vertices[first..].as_chunks_mut::<6>().0 {
|
|
let low = quad.iter().map(|v| v.pos[1]).fold(f32::INFINITY, f32::min);
|
|
let high = quad
|
|
.iter()
|
|
.map(|v| v.pos[1])
|
|
.fold(f32::NEG_INFINITY, f32::max);
|
|
let uv_top = quad.iter().map(|v| v.uv[1]).fold(f32::INFINITY, f32::min);
|
|
let uv_bot = quad
|
|
.iter()
|
|
.map(|v| v.uv[1])
|
|
.fold(f32::NEG_INFINITY, f32::max);
|
|
for v in quad {
|
|
v.pos[1] = v.pos[1].clamp(top, bottom);
|
|
if high > low {
|
|
v.uv[1] = uv_top + (uv_bot - uv_top) * (v.pos[1] - low) / (high - low);
|
|
}
|
|
}
|
|
}
|
|
crate::ui::separators(batch, atlas, top, bottom, false);
|
|
crate::ui::scrollbar(
|
|
batch,
|
|
atlas,
|
|
left + ROW_WIDTH + 8.0,
|
|
top,
|
|
bottom,
|
|
content,
|
|
scroll.amount,
|
|
);
|
|
}
|
|
Mode::Create {
|
|
name,
|
|
seed,
|
|
focus,
|
|
options,
|
|
..
|
|
} => self.draw_create(atlas, batch, cursor, name, seed, *focus, options),
|
|
Mode::Edit { name, focused, .. } => {
|
|
crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
|
|
centered(
|
|
atlas,
|
|
batch,
|
|
&lang::get_or("selectWorld.edit.title", "Edit World"),
|
|
15.0,
|
|
u32::MAX,
|
|
);
|
|
let top = edit_top(h);
|
|
batch.text(
|
|
atlas,
|
|
&lang::get_or("selectWorld.enterName", "World Name"),
|
|
(w / 2.0).floor() - 100.0,
|
|
top + 25.0,
|
|
rgba(160, 160, 160, 255),
|
|
true,
|
|
);
|
|
self.caret.borrow_mut().draw(
|
|
batch,
|
|
atlas,
|
|
(EDIT_NAME, name, 32),
|
|
[(w / 2.0).floor() - 100.0, top + 39.0, 200.0, 20.0],
|
|
*focused,
|
|
self.started,
|
|
);
|
|
}
|
|
Mode::Delete { world } => {
|
|
crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
|
|
let message = translate(
|
|
"selectWorld.deleteWarning",
|
|
"'%s' will be lost forever! (A long time!)",
|
|
&[&world.name],
|
|
);
|
|
let lines = wrapped(atlas, &message, w - 50.0);
|
|
self.message_lines.set(lines.len());
|
|
let top = confirm_top(h, lines.len());
|
|
centered(
|
|
atlas,
|
|
batch,
|
|
&lang::get_or(
|
|
"selectWorld.deleteQuestion",
|
|
"Are you sure you want to delete this world?",
|
|
),
|
|
top,
|
|
u32::MAX,
|
|
);
|
|
for (i, line) in lines.iter().enumerate() {
|
|
centered(atlas, batch, line, top + 17.0 + i as f32 * 9.0, u32::MAX);
|
|
}
|
|
}
|
|
Mode::Backup { .. } => {
|
|
self.backup_shown.set(true);
|
|
crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
|
|
centered(
|
|
atlas,
|
|
batch,
|
|
&lang::get_or("selectWorld.waitingForBackup.title", "Creating Backup"),
|
|
80.0,
|
|
u32::MAX,
|
|
);
|
|
let dots = ["O o o", "o O o", "o o O", "o O o"]
|
|
[(self.started.elapsed().as_millis() / 300 % 4) as usize];
|
|
centered(atlas, batch, dots, 120.0, rgba(128, 128, 128, 255));
|
|
let message = lang::get_or(
|
|
"selectWorld.waitingForBackup.message",
|
|
"Depending on the size of your world, this may take a while. Please do not close the game or shut off your device.",
|
|
);
|
|
for (i, line) in wrapped(atlas, &message, 360.0).iter().enumerate() {
|
|
centered(
|
|
atlas,
|
|
batch,
|
|
line,
|
|
132.0 + i as f32 * 9.0,
|
|
rgba(170, 170, 170, 255),
|
|
);
|
|
}
|
|
}
|
|
Mode::Error { message, .. } => {
|
|
crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
|
|
let lines = wrapped(atlas, message, w - 50.0);
|
|
self.message_lines.set(lines.len());
|
|
let top = confirm_top(h, lines.len());
|
|
centered(
|
|
atlas,
|
|
batch,
|
|
&lang::get_or("selectWorld.access_failure", "Failed to access world"),
|
|
top,
|
|
u32::MAX,
|
|
);
|
|
for (i, line) in lines.iter().enumerate() {
|
|
centered(atlas, batch, line, top + 17.0 + i as f32 * 9.0, u32::MAX);
|
|
}
|
|
}
|
|
Mode::Multiplayer(screen) => screen.draw(
|
|
atlas,
|
|
batch,
|
|
(self.started.elapsed().as_millis() / 300).is_multiple_of(2),
|
|
cursor,
|
|
),
|
|
}
|
|
for b in self.buttons(w, h) {
|
|
crate::widgets::record(&b.label, [b.x, b.y, b.w, 20.0], b.enabled);
|
|
let hover = b.enabled
|
|
&& cursor.0 >= b.x
|
|
&& cursor.0 < b.x + b.w
|
|
&& cursor.1 >= b.y
|
|
&& cursor.1 < b.y + 20.0;
|
|
let sprite = if !b.enabled {
|
|
"gui/sprites/widget/button_disabled"
|
|
} else if hover {
|
|
"gui/sprites/widget/button_highlighted"
|
|
} else {
|
|
"gui/sprites/widget/button"
|
|
};
|
|
// Nine-slice approximation: left and right halves of the 200-wide sprite.
|
|
if let Some(r) = atlas.sprites.get(sprite).copied() {
|
|
let half = b.w / 2.0;
|
|
let mut left = r;
|
|
left.u1 = r.u0 + (r.u1 - r.u0) * (half / r.w as f32);
|
|
batch.rect_uv(b.x, b.y, half, 20.0, left, u32::MAX);
|
|
let mut right = r;
|
|
right.u0 = r.u1 - (r.u1 - r.u0) * (half / r.w as f32);
|
|
batch.rect_uv(b.x + half, b.y, half, 20.0, right, u32::MAX);
|
|
}
|
|
let color = if b.enabled {
|
|
u32::MAX
|
|
} else {
|
|
rgba(160, 160, 160, 255)
|
|
};
|
|
if let Some((icon, size)) = b.icon {
|
|
// CenteredIcon divides the button and sprite sizes separately:
|
|
// a 15px icon in a 20px button starts at 10 - 7 = 3, not 2.
|
|
batch.sprite_scaled(
|
|
atlas,
|
|
&format!("gui/sprites/{icon}"),
|
|
b.x + (b.w / 2.0).floor() - (size / 2.0).floor(),
|
|
b.y + 10.0 - (size / 2.0).floor(),
|
|
size,
|
|
size,
|
|
u32::MAX,
|
|
);
|
|
continue;
|
|
}
|
|
let tw = HudBatch::text_width(atlas, &b.label);
|
|
batch.text(
|
|
atlas,
|
|
&b.label,
|
|
b.x + (b.w / 2.0).floor() - (tw.ceil() / 2.0).floor(),
|
|
b.y + 6.0,
|
|
color,
|
|
true,
|
|
);
|
|
}
|
|
if let Mode::Create {
|
|
name,
|
|
creative,
|
|
options,
|
|
..
|
|
} = &self.mode
|
|
{
|
|
self.create_tooltip(atlas, batch, cursor, name, *creative, options);
|
|
}
|
|
if let Mode::Multiplayer(screen) = &self.mode {
|
|
screen.draw_tooltip(atlas, batch, cursor);
|
|
}
|
|
if let Some((slide, toast)) = &self.toast {
|
|
let (title, message) = toast.text();
|
|
let width = HudBatch::text_width(atlas, &title)
|
|
.max(HudBatch::text_width(atlas, &message))
|
|
.ceil()
|
|
.max(160.0)
|
|
+ 30.0;
|
|
// Toast.xPos: in from the right edge by the visible portion.
|
|
let x = w - width * slide.portion;
|
|
crate::toasts::background(atlas, batch, x, 0.0, width);
|
|
batch.text(atlas, &title, x + 18.0, 7.0, rgba(255, 255, 0, 255), false);
|
|
batch.text(atlas, &message, x + 18.0, 19.0, u32::MAX, false);
|
|
}
|
|
}
|
|
/// The action and whether to play `AbstractWidget.playButtonClickSound`.
|
|
/// Navigation buttons can return `Action::None` while still sounding.
|
|
pub fn click(&mut self, x: f32, y: f32, size: (f32, f32)) -> (Action, bool) {
|
|
self.remember_direct_address();
|
|
let (w, h) = (size.0.ceil(), size.1.ceil());
|
|
// MenuTabBar: a new tab clears the focus and clicks.
|
|
if let Mode::Create { focus, options, .. } = &mut self.mode
|
|
&& let Some(tab) = create_world::tab_at(w, (x, y))
|
|
{
|
|
let changed = options.tab != tab;
|
|
if changed {
|
|
options.tab = tab;
|
|
*focus = 2;
|
|
}
|
|
return (Action::None, changed);
|
|
}
|
|
let hit = self
|
|
.buttons(w, h)
|
|
.into_iter()
|
|
.find(|b| b.enabled && x >= b.x && x < b.x + b.w && y >= b.y && y < b.y + 20.0)
|
|
.map(|b| b.id);
|
|
let action = self.click_action(x, y, (w, h), hit);
|
|
// World list selection is silent; launching its selected entry sounds.
|
|
let sound = hit.is_some() || matches!(action, Action::Play { .. });
|
|
(action, sound)
|
|
}
|
|
fn click_action(&mut self, x: f32, y: f32, (w, h): (f32, f32), hit: Option<u8>) -> Action {
|
|
match (&mut self.mode, hit) {
|
|
(Mode::Main, Some(1)) => {
|
|
self.enter_singleplayer();
|
|
Action::None
|
|
}
|
|
(Mode::Main, Some(2)) => Action::Quit,
|
|
(Mode::Main, Some(4)) => {
|
|
self.mode = Mode::Multiplayer(crate::multiplayer::Screen::list(&self.saves));
|
|
Action::None
|
|
}
|
|
(Mode::Multiplayer(_), hit) => match self.multiplayer_click(hit, x, y, (w, h)) {
|
|
crate::multiplayer::Outcome::Back => {
|
|
self.mode = Mode::Main;
|
|
Action::None
|
|
}
|
|
crate::multiplayer::Outcome::Connect(address) => Action::Connect { address },
|
|
crate::multiplayer::Outcome::None => Action::None,
|
|
},
|
|
(Mode::Main, Some(5)) => {
|
|
self.mode = Mode::Multiplayer(crate::multiplayer::Screen::friend());
|
|
Action::None
|
|
}
|
|
(Mode::Main, Some(3)) => Action::Options,
|
|
(Mode::Main, Some(7)) => Action::Accessibility,
|
|
(Mode::Main, Some(6)) => Action::Language,
|
|
(Mode::Select { worlds, selected }, Some(10)) => {
|
|
match selected.and_then(|i| worlds.get(i)) {
|
|
Some(world) => Action::Play {
|
|
folder: world.folder.clone(),
|
|
},
|
|
None => Action::None,
|
|
}
|
|
}
|
|
(Mode::Select { .. }, Some(11)) => {
|
|
self.create_return_to_main = false;
|
|
self.mode = Self::new_world();
|
|
Action::None
|
|
}
|
|
(Mode::Select { worlds, selected }, Some(id @ 13..=15)) => {
|
|
let Some(world) = selected.and_then(|i| worlds.get(i)).cloned() else {
|
|
return Action::None;
|
|
};
|
|
match id {
|
|
13 => {
|
|
self.mode = Mode::Edit {
|
|
name: world.name.clone(),
|
|
world,
|
|
focused: true,
|
|
}
|
|
}
|
|
14 => self.mode = Mode::Delete { world },
|
|
_ => {
|
|
if let Some(level) = Level::read(&self.saves.join(&world.folder)) {
|
|
self.create_return_to_main = false;
|
|
let options = WorldOptions::of_world(
|
|
&level,
|
|
world.commands,
|
|
&self.saves.join(&world.folder),
|
|
);
|
|
self.mode = Mode::Create {
|
|
name: level.name,
|
|
seed: level.seed.to_string(),
|
|
creative: level.creative,
|
|
focus: 0,
|
|
options,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
Action::None
|
|
}
|
|
(Mode::Select { .. }, Some(12)) => {
|
|
self.mode = Mode::Main;
|
|
Action::None
|
|
}
|
|
(Mode::Select { .. }, None) => {
|
|
self.search_focused =
|
|
(21.0..41.0).contains(&y) && (x - (w / 2.0).floor()).abs() < 100.0;
|
|
let Mode::Select { worlds, .. } = &self.mode else {
|
|
unreachable!()
|
|
};
|
|
let (top, bottom, left, content) = self.world_list(worlds, (w, h));
|
|
if self
|
|
.scroll
|
|
.get_mut()
|
|
.press((x, y), left + ROW_WIDTH + 8.0, top, bottom, content)
|
|
{
|
|
return Action::None;
|
|
}
|
|
let Mode::Select { worlds, selected } = &self.mode else {
|
|
unreachable!()
|
|
};
|
|
let chosen = self
|
|
.world_row_at(worlds, (x, y), (w, h))
|
|
.and_then(|(row, rel)| {
|
|
let (index, world) = self.visible_worlds(worlds).nth(row)?;
|
|
Some((index, world.folder.clone(), rel))
|
|
});
|
|
if let Some((index, folder, (rx, ry))) = chosen {
|
|
// WorldListEntry.mouseClicked: the icon joins at once.
|
|
let on_icon = (0.0..32.0).contains(&rx) && (0.0..32.0).contains(&ry);
|
|
if on_icon || *selected == Some(index) {
|
|
return Action::Play { folder };
|
|
}
|
|
if let Mode::Select { selected, .. } = &mut self.mode {
|
|
*selected = Some(index);
|
|
}
|
|
}
|
|
Action::None
|
|
}
|
|
(Mode::Edit { world, name, .. }, Some(id @ (30..=36))) => {
|
|
let world = world.clone();
|
|
let name = name.clone();
|
|
let result = match id {
|
|
30 => world_management::reset_icon(&self.saves, &world.folder),
|
|
31 => world_management::open_folder(&self.saves.join(&world.folder)),
|
|
32 => {
|
|
self.start_backup(world);
|
|
return Action::None;
|
|
}
|
|
33 => {
|
|
world_management::open_folder(&world_management::backups_path(&self.saves))
|
|
}
|
|
35 => world_management::rename(&self.saves, &world.folder, &name),
|
|
36 => {
|
|
self.return_to_list(Some(&world.folder));
|
|
return Action::None;
|
|
}
|
|
_ => return Action::None,
|
|
};
|
|
if let Err(error) = result {
|
|
self.failed(error);
|
|
} else if id == 35 {
|
|
self.return_to_list(Some(&world.folder));
|
|
} else if id == 30 {
|
|
self.icons.borrow_mut().clear();
|
|
}
|
|
Action::None
|
|
}
|
|
(Mode::Edit { focused, .. }, None) => {
|
|
*focused = y >= edit_top(h) + 39.0
|
|
&& y < edit_top(h) + 59.0
|
|
&& (x - (w / 2.0).floor()).abs() < 100.0;
|
|
Action::None
|
|
}
|
|
(Mode::Delete { .. }, Some(37)) => {
|
|
self.confirm_delete();
|
|
Action::None
|
|
}
|
|
(Mode::Delete { .. }, Some(38)) => {
|
|
self.escape();
|
|
Action::None
|
|
}
|
|
(Mode::Error { return_to, .. }, Some(39)) => {
|
|
self.mode = *return_to.clone();
|
|
Action::None
|
|
}
|
|
(
|
|
Mode::Create {
|
|
creative, options, ..
|
|
},
|
|
Some(id),
|
|
) if id != 21 && id != 22 => {
|
|
options.press(id, creative);
|
|
Action::None
|
|
}
|
|
(Mode::Create { .. }, Some(21)) => self.create_action(),
|
|
(Mode::Create { .. }, Some(22)) => {
|
|
self.cancel_create();
|
|
Action::None
|
|
}
|
|
(Mode::Create { focus, options, .. }, None) => {
|
|
*focus = create_world::field_at(w, h, options.tab, (x, y)).unwrap_or(2);
|
|
Action::None
|
|
}
|
|
_ => Action::None,
|
|
}
|
|
}
|
|
/// The focused text field, its id and maximum length (copy and paste).
|
|
pub fn focused_field(&mut self) -> Option<(crate::clipboard::FieldId, &mut String, usize)> {
|
|
match &mut self.mode {
|
|
Mode::Multiplayer(screen) => screen.focused_text(),
|
|
mode => caret_field(mode, self.search_focused, &mut self.search),
|
|
}
|
|
}
|
|
/// Whether the focused field edits at its cursor (every field but the
|
|
/// server screens', which still append).
|
|
pub fn has_caret_field(&mut self) -> bool {
|
|
caret_field(&mut self.mode, self.search_focused, &mut self.search).is_some()
|
|
}
|
|
/// Edit the focused field through its `EditBox`; false when there is none.
|
|
fn edit_field(&mut self, f: impl FnOnce(&mut crate::ui::EditBox)) -> bool {
|
|
let Some((id, value, max)) =
|
|
caret_field(&mut self.mode, self.search_focused, &mut self.search)
|
|
else {
|
|
return false;
|
|
};
|
|
let before = value.clone();
|
|
self.caret.get_mut().edit(id, value, max, f);
|
|
if *value != before {
|
|
self.search_changed();
|
|
}
|
|
true
|
|
}
|
|
/// EditBox.charTyped / insertText at the cursor.
|
|
pub fn type_text(&mut self, text: &str) {
|
|
if let Mode::Multiplayer(screen) = &mut self.mode {
|
|
return screen.type_text(text);
|
|
}
|
|
self.edit_field(|edit| edit.insert_text(text));
|
|
}
|
|
pub fn backspace(&mut self) {
|
|
if let Mode::Multiplayer(screen) = &mut self.mode {
|
|
return screen.backspace();
|
|
}
|
|
self.field_key(winit::keyboard::KeyCode::Backspace, false, false);
|
|
}
|
|
/// EditBox.keyPressed: moving and deleting in the focused field.
|
|
pub fn field_key(&mut self, key: winit::keyboard::KeyCode, ctrl: bool, shift: bool) -> bool {
|
|
let mut handled = false;
|
|
self.edit_field(|edit| handled = edit.key(key, ctrl, shift));
|
|
handled
|
|
}
|
|
/// Ctrl+A/C/V/X in the focused field.
|
|
pub fn field_shortcut(
|
|
&mut self,
|
|
shortcut: crate::clipboard::EditShortcut,
|
|
board: &mut dyn crate::clipboard::Clipboard,
|
|
) {
|
|
self.edit_field(|edit| {
|
|
edit.shortcut(shortcut, board);
|
|
});
|
|
}
|
|
/// The focused field's box on screen.
|
|
fn focused_rect(&self, (w, h): (f32, f32)) -> Option<[f32; 4]> {
|
|
let x = (w / 2.0).floor() - 100.0;
|
|
match &self.mode {
|
|
Mode::Select { .. } if self.search_focused => Some([x, 21.0, 200.0, 20.0]),
|
|
Mode::Edit { focused: true, .. } => Some([x, edit_top(h) + 39.0, 200.0, 20.0]),
|
|
Mode::Create { focus, options, .. } => create_world::field_rect(w, h, options.tab)
|
|
.filter(|(id, _)| id == focus)
|
|
.map(|(_, rect)| rect),
|
|
_ => None,
|
|
}
|
|
}
|
|
/// A left press after `click` focused a field: the cursor goes under the
|
|
/// pointer (`EditBox.onClick`).
|
|
pub fn press_field(
|
|
&mut self,
|
|
atlas: &HudAtlas,
|
|
(x, y): (f32, f32),
|
|
size: (f32, f32),
|
|
shift: bool,
|
|
) {
|
|
let (w, h) = (size.0.ceil(), size.1.ceil());
|
|
let Some(rect @ [fx, fy, fw, fh]) = self.focused_rect((w, h)) else {
|
|
return;
|
|
};
|
|
if !crate::ui::hovered((x, y), fx, fy, fw, fh) {
|
|
return;
|
|
}
|
|
if let Some(field) = caret_field(&mut self.mode, self.search_focused, &mut self.search) {
|
|
self.caret.get_mut().press(atlas, field, rect, x, shift);
|
|
}
|
|
}
|
|
/// The pointer moved with the button held (`EditBox.onDrag`).
|
|
pub fn drag_field(&mut self, atlas: &HudAtlas, x: f32) {
|
|
if let Some(field) = caret_field(&mut self.mode, self.search_focused, &mut self.search) {
|
|
self.caret.get_mut().drag(atlas, field, x);
|
|
}
|
|
}
|
|
/// The button was released: drags stop selecting.
|
|
pub fn release_field(&mut self) {
|
|
self.caret.get_mut().release();
|
|
}
|
|
/// Clipboard replacements also invalidate a selection in the filtered list.
|
|
pub fn search_changed(&mut self) {
|
|
if self.search_focused
|
|
&& let Mode::Select { selected, .. } = &mut self.mode
|
|
{
|
|
*selected = None;
|
|
self.scroll.set(crate::ui::Scroll::default());
|
|
}
|
|
}
|
|
pub fn confirm_edit(&mut self) {
|
|
let Mode::Edit {
|
|
world,
|
|
name,
|
|
focused: true,
|
|
} = &self.mode
|
|
else {
|
|
return;
|
|
};
|
|
if name.trim().is_empty() {
|
|
return;
|
|
}
|
|
let folder = world.folder.clone();
|
|
match world_management::rename(&self.saves, &folder, name) {
|
|
Ok(()) => self.return_to_list(Some(&folder)),
|
|
Err(error) => self.failed(error),
|
|
}
|
|
}
|
|
pub fn tab(&mut self) {
|
|
if let Mode::Edit { focused, .. } = &mut self.mode {
|
|
*focused = !*focused;
|
|
}
|
|
if matches!(self.mode, Mode::Select { .. }) {
|
|
self.search_focused = !self.search_focused;
|
|
}
|
|
if let Mode::Multiplayer(screen) = &mut self.mode {
|
|
screen.tab();
|
|
}
|
|
// The open tab's one text box, then nothing.
|
|
if let Mode::Create { focus, options, .. } = &mut self.mode {
|
|
let field = if options.tab == 1 { 1 } else { 0 };
|
|
*focus = if *focus == field || options.tab == 2 {
|
|
2
|
|
} else {
|
|
field
|
|
};
|
|
}
|
|
}
|
|
/// The server auto-reconnect retries now, once its countdown is over.
|
|
pub fn due_retry(&mut self) -> Option<crate::reconnect::Retry> {
|
|
match &mut self.mode {
|
|
Mode::Multiplayer(screen) => screen.due_retry(),
|
|
_ => None,
|
|
}
|
|
}
|
|
pub(crate) fn remember_direct_address(&mut self) {
|
|
if let Mode::Multiplayer(crate::multiplayer::Screen::Direct { address }) = &self.mode {
|
|
self.last_server.clone_from(address);
|
|
}
|
|
}
|
|
pub(crate) fn multiplayer_click(
|
|
&mut self,
|
|
hit: Option<u8>,
|
|
x: f32,
|
|
y: f32,
|
|
size: (f32, f32),
|
|
) -> crate::multiplayer::Outcome {
|
|
let Mode::Multiplayer(screen) = &mut self.mode else {
|
|
return crate::multiplayer::Outcome::None;
|
|
};
|
|
let outcome = screen.click(hit, x, y, size, &self.saves);
|
|
if hit == Some(41)
|
|
&& let crate::multiplayer::Screen::Direct { address } = screen
|
|
{
|
|
address.clone_from(&self.last_server);
|
|
}
|
|
outcome
|
|
}
|
|
pub fn escape(&mut self) {
|
|
self.remember_direct_address();
|
|
if let Mode::Multiplayer(screen) = &mut self.mode
|
|
&& !screen.escape(&self.saves)
|
|
{
|
|
return;
|
|
}
|
|
match &self.mode {
|
|
Mode::Backup { .. } => {}
|
|
Mode::Edit { world, .. } | Mode::Delete { world } => {
|
|
let folder = world.folder.clone();
|
|
self.return_to_list(Some(&folder));
|
|
}
|
|
Mode::Error { return_to, .. } => self.mode = *return_to.clone(),
|
|
Mode::Create { .. } => self.cancel_create(),
|
|
_ => self.mode = Mode::Main,
|
|
}
|
|
}
|
|
}
|
|
fn centered(atlas: &HudAtlas, batch: &mut HudBatch, text: &str, y: f32, color: u32) {
|
|
batch.text(
|
|
atlas,
|
|
text,
|
|
(batch.width.ceil() / 2.0).floor()
|
|
- (HudBatch::text_width(atlas, text).ceil() / 2.0).floor(),
|
|
y,
|
|
color,
|
|
true,
|
|
);
|
|
}
|
|
fn wrapped(atlas: &HudAtlas, text: &str, width: f32) -> Vec<String> {
|
|
atlas
|
|
.font
|
|
.split(&crate::text::Text::literal(text), width.max(1.0))
|
|
.iter()
|
|
.map(|t| t.plain())
|
|
.collect()
|
|
}
|
|
const SEARCH: crate::clipboard::FieldId = ("world.search", 0);
|
|
const EDIT_NAME: crate::clipboard::FieldId = ("world.edit-name", 0);
|
|
const WORLD_NAME: crate::clipboard::FieldId = ("world.name", 0);
|
|
const WORLD_SEED: crate::clipboard::FieldId = ("world.seed", 0);
|
|
/// The focused field of the world screens: the list's search, the world
|
|
/// name being edited, or Create New World's name or seed.
|
|
fn caret_field<'a>(
|
|
mode: &'a mut Mode,
|
|
search_focused: bool,
|
|
search: &'a mut String,
|
|
) -> Option<(crate::clipboard::FieldId, &'a mut String, usize)> {
|
|
match mode {
|
|
Mode::Select { .. } if search_focused => Some((SEARCH, search, 50)),
|
|
Mode::Edit {
|
|
name,
|
|
focused: true,
|
|
..
|
|
} => Some((EDIT_NAME, name, 32)),
|
|
Mode::Create {
|
|
name, seed, focus, ..
|
|
} => match focus {
|
|
0 => Some((WORLD_NAME, name, 32)),
|
|
1 => Some((WORLD_SEED, seed, 32)),
|
|
_ => None,
|
|
},
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod classic_tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn classic_main_menu_icons_route_language_and_accessibility() {
|
|
let mut title = Title::new(
|
|
PathBuf::new(),
|
|
Path::new("/nonexistent/horizon-test-resources"),
|
|
);
|
|
for (w, h) in [(960.0, 523.0), (480.0, 320.0), (427.0, 240.0)] {
|
|
let buttons = title.buttons(w, h);
|
|
let cx = (w / 2.0).floor();
|
|
let y = (h / 4.0).floor() + 48.0;
|
|
for (id, x, enabled, icon) in [
|
|
(5, cx - 34.0, true, "friends/friends"),
|
|
(6, cx - 10.0, true, "icon/language"),
|
|
(7, cx + 14.0, true, "icon/accessibility"),
|
|
] {
|
|
let b = buttons.iter().find(|b| b.id == id).unwrap();
|
|
assert_eq!(
|
|
(b.x, b.y, b.w, b.enabled, b.icon),
|
|
(x, y + 72.0, 20.0, enabled, Some((icon, 15.0)))
|
|
);
|
|
assert_eq!(
|
|
title.click(x + 10.0, y + 82.0, (w, h)),
|
|
match id {
|
|
6 => (Action::Language, true),
|
|
7 => (Action::Accessibility, true),
|
|
_ => (Action::None, true),
|
|
}
|
|
);
|
|
if id == 5 {
|
|
assert!(matches!(
|
|
title.mode,
|
|
Mode::Multiplayer(crate::multiplayer::Screen::Friend { .. })
|
|
));
|
|
title.mode = Mode::Main;
|
|
}
|
|
}
|
|
for id in [2, 3] {
|
|
assert_eq!(buttons.iter().find(|b| b.id == id).unwrap().y, y + 96.0);
|
|
}
|
|
// The four-pixel gaps around icons must not activate a button.
|
|
assert_eq!(
|
|
title.click(cx + 12.0, y + 82.0, (w, h)),
|
|
(Action::None, false)
|
|
);
|
|
assert_eq!(
|
|
title.click(cx + 24.0, y + 92.0, (w, h)),
|
|
(Action::None, false)
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn splash_selection_filters_the_forbidden_hash_and_has_no_fallback() {
|
|
let hidden = "This message will never appear on the splash screen, isn't that weird?";
|
|
assert_eq!(
|
|
horizon_core::random::java_string_hash(hidden.encode_utf16()),
|
|
125780783
|
|
);
|
|
let text = format!("\n First! \r\n{hidden}\nSecond!\n");
|
|
for index in 0..6 {
|
|
assert_eq!(
|
|
choose_splash(&text, index, (10, 15)).as_deref(),
|
|
Some(["", "First!", "Second!"][index % 3])
|
|
);
|
|
}
|
|
assert_eq!(choose_splash(" \r\n", 42, (10, 15)).as_deref(), Some(""));
|
|
for text in ["", hidden] {
|
|
assert_eq!(choose_splash(text, 42, (10, 15)), None);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn special_date_splashes_override_resources_even_when_the_list_is_empty() {
|
|
for (date, expected) in [
|
|
((12, 24), "Merry X-mas!"),
|
|
((1, 1), "Happy new year!"),
|
|
((10, 31), "OOoooOOOoooo! Spooky!"),
|
|
] {
|
|
for text in ["", "Ordinary splash!"] {
|
|
assert_eq!(choose_splash(text, 0, date).as_deref(), Some(expected));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn classic_logo_and_icon_geometry_matches_minecraft() {
|
|
let root = Path::new("/nonexistent/horizon-test-resources");
|
|
let mut atlas = HudAtlas::build(root).unwrap();
|
|
let r = crate::hud::Rect {
|
|
u0: 0.0,
|
|
v0: 0.0,
|
|
u1: 1.0,
|
|
v1: 1.0,
|
|
w: 1024,
|
|
h: 256,
|
|
};
|
|
atlas.sprites.insert("gui/title/minecraft".into(), r);
|
|
atlas.sprites.insert(
|
|
"gui/title/edition".into(),
|
|
crate::hud::Rect { w: 128, h: 16, ..r },
|
|
);
|
|
for (i, icon) in ["friends/friends", "icon/language", "icon/accessibility"]
|
|
.into_iter()
|
|
.enumerate()
|
|
{
|
|
atlas.sprites.insert(
|
|
format!("gui/sprites/{icon}"),
|
|
crate::hud::Rect {
|
|
u0: 0.25 + i as f32 * 0.125,
|
|
w: 15,
|
|
h: 15,
|
|
..r
|
|
},
|
|
);
|
|
}
|
|
let mut title = Title::new(PathBuf::new(), root);
|
|
title.splash = Some("Visible splash!".into());
|
|
let mut batch = HudBatch::new([1920, 1080]);
|
|
title.draw(&atlas, &mut batch, (0.0, 0.0), false);
|
|
let cx = (batch.width / 2.0).floor();
|
|
assert_eq!(batch.vertices[0].pos, [cx - 128.0, 30.0]);
|
|
assert_eq!(batch.vertices[2].pos, [cx + 128.0, 74.0]);
|
|
assert_eq!(batch.vertices[2].uv, [1.0, 44.0 / 64.0]);
|
|
assert_eq!(batch.vertices[6].pos, [cx - 64.0, 67.0]);
|
|
assert_eq!(batch.vertices[8].pos, [cx + 64.0, 81.0]);
|
|
assert_eq!(batch.vertices[8].uv, [1.0, 14.0 / 16.0]);
|
|
for i in 0..3 {
|
|
let quad = batch
|
|
.vertices
|
|
.as_chunks::<6>()
|
|
.0
|
|
.iter()
|
|
.find(|quad| quad[0].uv == [0.25 + i as f32 * 0.125, 0.0])
|
|
.unwrap();
|
|
let x = cx - 34.0 + i as f32 * 24.0 + 3.0;
|
|
let y = (batch.height / 4.0).floor() + 48.0 + 72.0 + 3.0;
|
|
assert_eq!(quad[0].pos, [x, y]);
|
|
assert_eq!(quad[2].pos, [x + 15.0, y + 15.0]);
|
|
assert!(quad.iter().all(|v| v.color == u32::MAX));
|
|
}
|
|
assert!(
|
|
batch.vertices[12..]
|
|
.iter()
|
|
.any(|v| v.color == rgba(255, 255, 0, 255))
|
|
);
|
|
let settings = crate::settings::Settings::parse("hideSplashTexts:true\n");
|
|
for (hide_splash, splash) in [
|
|
(
|
|
settings.file.bool("hideSplashTexts"),
|
|
Some("Hidden splash!".into()),
|
|
),
|
|
(false, None),
|
|
] {
|
|
title.splash = splash;
|
|
let mut hidden = HudBatch::new([1920, 1080]);
|
|
title.draw(&atlas, &mut hidden, (0.0, 0.0), hide_splash);
|
|
assert!(
|
|
!hidden
|
|
.vertices
|
|
.iter()
|
|
.any(|v| v.color == rgba(255, 255, 0, 255))
|
|
);
|
|
}
|
|
}
|
|
}
|