From 663f61c8c3f068423e048c32988c3e9d99d32e95 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Wed, 14 Oct 2026 18:40:56 +0200 Subject: [PATCH] Horizon extras: a minimap, off by default A corner map of the loaded chunks in vanilla's map colours with the map item's height and water shading: square or round, three sizes, four zooms, north up or turning with the player, with the player arrow. In the Nether, underground and under a roof it maps the floor at the player's height and cuts walls. Each loaded chunk keeps a 16x16 tile, filled nearest first within 0.3 ms a frame and rescanned after block changes; the image is recomposed only when the view or a tile changed and uploaded into its own atlas slot. Nothing runs while it is off. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/extras.rs | 120 +++- crates/horizon-client/src/extras_hud.rs | 56 +- crates/horizon-client/src/game/extras.rs | 108 +++- crates/horizon-client/src/hud.rs | 9 + crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/minimap.rs | 679 +++++++++++++++++++++++ 6 files changed, 961 insertions(+), 12 deletions(-) create mode 100644 crates/horizon-client/src/minimap.rs diff --git a/crates/horizon-client/src/extras.rs b/crates/horizon-client/src/extras.rs index e35f94cd2..33854e67d 100644 --- a/crates/horizon-client/src/extras.rs +++ b/crates/horizon-client/src/extras.rs @@ -15,6 +15,10 @@ pub const ZOOM_MAX: f32 = 10.0; /// Each wheel step multiplies the zoom by this. const ZOOM_STEP: f32 = 1.25; +/// The minimap's sizes in GUI pixels, and its zooms in blocks per pixel. +pub const MINIMAP_SIZES: [(u8, &str); 3] = [(64, "Small"), (96, "Medium"), (128, "Large")]; +pub const MINIMAP_ZOOMS: [f32; 4] = [0.5, 1.0, 2.0, 4.0]; + /// A screen corner for an overlay. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Corner { @@ -79,6 +83,15 @@ pub struct Extras { pub keystrokes_corner: Corner, /// Clicks per second under the mouse buttons. pub keystrokes_cps: bool, + pub minimap: bool, + pub minimap_corner: Corner, + /// Side in GUI pixels (`MINIMAP_SIZES`). + pub minimap_size: u8, + pub minimap_round: bool, + /// Blocks per pixel (`MINIMAP_ZOOMS`). + pub minimap_zoom: f32, + /// Turn with the player (forward up) instead of north up. + pub minimap_rotate: bool, } impl Default for Extras { fn default() -> Self { @@ -94,6 +107,12 @@ impl Default for Extras { keystrokes: false, keystrokes_corner: Corner::TopLeft, keystrokes_cps: true, + minimap: false, + minimap_corner: Corner::TopRight, + minimap_size: 96, + minimap_round: false, + minimap_zoom: 1.0, + minimap_rotate: false, } } } @@ -136,6 +155,20 @@ impl Extras { e.keystrokes_corner = Corner::parse(value, e.keystrokes_corner) } "keystrokesCps" => e.keystrokes_cps = flag(e.keystrokes_cps), + "minimap" => e.minimap = flag(e.minimap), + "minimapCorner" => e.minimap_corner = Corner::parse(value, e.minimap_corner), + "minimapSize" => { + if let Some(&(v, _)) = MINIMAP_SIZES.iter().find(|s| s.0.to_string() == value) { + e.minimap_size = v; + } + } + "minimapShape" => e.minimap_round = value == "round", + "minimapZoom" => { + if let Some(&z) = MINIMAP_ZOOMS.iter().find(|z| z.to_string() == value) { + e.minimap_zoom = z; + } + } + "minimapRotate" => e.minimap_rotate = flag(e.minimap_rotate), _ => {} } } @@ -143,7 +176,7 @@ impl Extras { } pub fn serialize(&self) -> String { format!( - "zoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\n", + "zoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\n", bool_text(self.zoom), self.zoom_key, self.zoom_level, @@ -155,6 +188,16 @@ impl Extras { bool_text(self.keystrokes), self.keystrokes_corner.name(), bool_text(self.keystrokes_cps), + bool_text(self.minimap), + self.minimap_corner.name(), + self.minimap_size, + if self.minimap_round { + "round" + } else { + "square" + }, + self.minimap_zoom, + bool_text(self.minimap_rotate), ) } /// Written only once something differs from the defaults, so a vanilla @@ -349,6 +392,12 @@ pub enum Item { Keystrokes, KeystrokesCorner, KeystrokesCps, + Minimap, + MinimapCorner, + MinimapSize, + MinimapShape, + MinimapZoom, + MinimapRotate, } /// The Extras page: headers and items. pub fn rows() -> Vec> { @@ -360,6 +409,13 @@ pub fn rows() -> Vec> { Ok(ZoomLevel), Ok(ZoomSmooth), Ok(ZoomSensitivity), + Err("Minimap"), + Ok(Minimap), + Ok(MinimapCorner), + Ok(MinimapSize), + Ok(MinimapShape), + Ok(MinimapZoom), + Ok(MinimapRotate), Err("FPS counter"), Ok(Fps), Ok(FpsCorner), @@ -370,6 +426,16 @@ pub fn rows() -> Vec> { Ok(KeystrokesCps), ] } +/// "1 block", "2 blocks", "½ block". +fn block_count(n: f32) -> String { + if n < 1.0 { + "½ block".into() + } else if n == 1.0 { + "1 block".into() + } else { + format!("{n} blocks") + } +} fn next(all: &[T], current: T, back: bool) -> T { let i = all.iter().position(|v| *v == current).unwrap_or(0); let n = all.len(); @@ -384,7 +450,12 @@ impl Item { Item::ZoomSmooth => "Smooth zoom", Item::ZoomSensitivity => "Lower sensitivity while zoomed", Item::Fps => "FPS counter", - Item::FpsCorner | Item::KeystrokesCorner => "Corner", + Item::FpsCorner | Item::KeystrokesCorner | Item::MinimapCorner => "Corner", + Item::Minimap => "Minimap", + Item::MinimapSize => "Size", + Item::MinimapShape => "Shape", + Item::MinimapZoom => "Zoom", + Item::MinimapRotate => "Turn with the player", Item::FpsLows => "Minimum and 1% low", Item::Keystrokes => "Keystrokes", Item::KeystrokesCps => "Clicks per second", @@ -399,7 +470,14 @@ impl Item { Item::ZoomSmooth => "Eases in and out like the spyglass.", Item::ZoomSensitivity => "Turns slower the more you zoom in.", Item::Fps => "Frames per second in a corner of the screen.", - Item::FpsCorner | Item::KeystrokesCorner => "Overlays in one corner stack.", + Item::FpsCorner | Item::KeystrokesCorner | Item::MinimapCorner => { + "Overlays in one corner stack." + } + Item::Minimap => "A map of the loaded terrain around you, in map colours.", + Item::MinimapSize => "How big the map is on screen.", + Item::MinimapShape => "Square or round.", + Item::MinimapZoom => "Blocks per pixel: smaller shows more detail, larger more land.", + Item::MinimapRotate => "Forward is up; off keeps north up.", Item::FpsLows => "The slowest frame and the 1% low of the last 5 seconds.", Item::Keystrokes => "Movement keys, jump and mouse buttons as you press them.", Item::KeystrokesCps => "Clicks in the last second under each mouse button.", @@ -410,6 +488,7 @@ impl Item { use crate::graphics_style::Cost; match self { Item::Zoom | Item::Fps | Item::Keystrokes => Some(Cost::None), + Item::Minimap => Some(Cost::Low), _ => None, } } @@ -423,6 +502,8 @@ impl Item { Item::FpsLows => e.fps_lows, Item::Keystrokes => e.keystrokes, Item::KeystrokesCps => e.keystrokes_cps, + Item::Minimap => e.minimap, + Item::MinimapRotate => e.minimap_rotate, _ => return None, }) } @@ -433,6 +514,14 @@ impl Item { Item::ZoomLevel => format!("{}x", e.zoom_level), Item::FpsCorner => e.fps_corner.label().into(), Item::KeystrokesCorner => e.keystrokes_corner.label().into(), + Item::MinimapCorner => e.minimap_corner.label().into(), + Item::MinimapSize => MINIMAP_SIZES + .iter() + .find(|s| s.0 == e.minimap_size) + .map_or("Medium", |s| s.1) + .into(), + Item::MinimapShape => if e.minimap_round { "Round" } else { "Square" }.into(), + Item::MinimapZoom => format!("{} per pixel", block_count(e.minimap_zoom)), other => match other.switch(e) { Some(true) => "On".into(), _ => "Off".into(), @@ -454,6 +543,15 @@ impl Item { Item::KeystrokesCorner => { e.keystrokes_corner = next(&Corner::ALL, e.keystrokes_corner, back) } + Item::Minimap => e.minimap = !e.minimap, + Item::MinimapRotate => e.minimap_rotate = !e.minimap_rotate, + Item::MinimapCorner => e.minimap_corner = next(&Corner::ALL, e.minimap_corner, back), + Item::MinimapSize => { + let sizes: Vec = MINIMAP_SIZES.iter().map(|s| s.0).collect(); + e.minimap_size = next(&sizes, e.minimap_size, back); + } + Item::MinimapShape => e.minimap_round = !e.minimap_round, + Item::MinimapZoom => e.minimap_zoom = next(&MINIMAP_ZOOMS, e.minimap_zoom, back), Item::ZoomKey => {} } } @@ -466,7 +564,7 @@ mod tests { #[test] fn everything_is_off_by_default_and_round_trips() { let d = Extras::default(); - assert!(!d.zoom && !d.fps && !d.keystrokes); + assert!(!d.zoom && !d.fps && !d.keystrokes && !d.minimap); assert_eq!(Extras::parse(""), d); assert_eq!(Extras::parse(&d.serialize()), d); let mut e = d.clone(); @@ -476,6 +574,12 @@ mod tests { e.fps_corner = Corner::BottomRight; e.keystrokes = true; e.keystrokes_cps = false; + e.minimap = true; + e.minimap_size = 128; + e.minimap_round = true; + e.minimap_zoom = 0.5; + e.minimap_rotate = true; + e.minimap_corner = Corner::BottomLeft; assert_eq!(Extras::parse(&e.serialize()), e); } @@ -661,6 +765,14 @@ mod tests { Item::Zoom.cycle(&mut e, false); assert_eq!(Item::Zoom.switch(&e), Some(true)); assert_eq!(Item::ZoomKey.value(&e), "Z"); + Item::MinimapZoom.cycle(&mut e, true); + assert_eq!(Item::MinimapZoom.value(&e), "½ block per pixel"); + Item::MinimapSize.cycle(&mut e, false); + assert_eq!(Item::MinimapSize.value(&e), "Large"); + assert_eq!( + Extras::parse("minimapSize:7\nminimapZoom:3").minimap_zoom, + 1.0 + ); for item in rows().into_iter().flatten() { assert!(!item.caption().is_empty() && !item.description().is_empty()); } diff --git a/crates/horizon-client/src/extras_hud.rs b/crates/horizon-client/src/extras_hud.rs index 6d015f5df..df23b533f 100644 --- a/crates/horizon-client/src/extras_hud.rs +++ b/crates/horizon-client/src/extras_hud.rs @@ -2,7 +2,7 @@ //! vanilla font, in GUI pixels, stacked per corner (`docs/extras.md`). use crate::{ extras::{Corner, FpsReading}, - hud::{HudAtlas, HudBatch, rgba}, + hud::{HudAtlas, HudBatch, Rect, rgba}, }; /// The gap between an overlay and the screen edge or the next overlay. @@ -45,6 +45,60 @@ impl Corners { } } +/// How the minimap shows: its corner and side in GUI pixels, its image (an +/// atlas rect), the player arrow (the map item's decoration sprite) turned +/// `arrow` degrees clockwise from up, and the rim's N toward `north` when the +/// map turns. +pub struct MinimapLook { + pub corner: Corner, + pub size: f32, + pub image: Rect, + pub arrow: f32, + pub north: Option<(f32, f32)>, +} +pub fn draw_minimap( + batch: &mut HudBatch, + atlas: &HudAtlas, + corners: &mut Corners, + look: &MinimapLook, +) { + let MinimapLook { + corner, + size, + image, + arrow, + north, + } = *look; + let (x, y) = corners.place(corner, size, size); + batch.rect_uv(x, y, size, size, image, u32::MAX); + let (cx, cy) = (x + size / 2.0, y + size / 2.0); + if let Some(r) = atlas.sprites.get("map/decorations/player").copied() { + // MapRenderer's decorations draw the sprite flipped: its arrow + // points down the texture, so up on screen is half a turn. + let (s, c) = (arrow + 180.0).to_radians().sin_cos(); + let p = |dx: f32, dy: f32| [cx + dx * c - dy * s, cy + dx * s + dy * c]; + let h = 4.0; + batch.quad( + [p(-h, h), p(h, h), p(h, -h), p(-h, -h)], + [[r.u0, r.v0], [r.u1, r.v0], [r.u1, r.v1], [r.u0, r.v1]], + u32::MAX, + ); + } + if let Some((nx, ny)) = north { + let reach = size / 2.0 - 6.0; + let tw = HudBatch::text_width(atlas, "N"); + let (tx, ty) = (cx + nx * reach - tw / 2.0, cy + ny * reach - 4.0); + batch.text( + atlas, + "N", + tx.round(), + ty.round(), + rgba(255, 255, 255, 255), + true, + ); + } +} + /// The FPS counter's text. pub fn fps_text(r: FpsReading, lows: bool) -> String { if lows { diff --git a/crates/horizon-client/src/game/extras.rs b/crates/horizon-client/src/game/extras.rs index 4f4e3061e..721dc0280 100644 --- a/crates/horizon-client/src/game/extras.rs +++ b/crates/horizon-client/src/game/extras.rs @@ -1,12 +1,14 @@ //! Horizon's extras in the game (`docs/extras.md`): the zoom key and wheel, -//! clicks for the keystroke overlay, frame times for the FPS counter, and -//! their HUD. Each hook does nothing while its extra is off. -use super::{Game, Screen}; +//! clicks for the keystroke overlay, frame times for the FPS counter, the +//! minimap's tiles and image, and their HUD. Each hook does nothing while its +//! extra is off. +use super::{Dim, Game, Screen}; use horizon_client::{ - extras::{Cps, FpsCounter, Zoom, fov_target, turn_scale}, + extras::{Corner, Cps, FpsCounter, Zoom, fov_target, turn_scale}, extras_hud::{self, Corners, Keystrokes}, - hud::HudBatch, + hud::{HudBatch, MINIMAP_SPRITE}, keybinds, + minimap::{self, Layer, Minimap, View}, }; use std::time::Duration; use winit::{event::MouseButton, keyboard::KeyCode}; @@ -18,7 +20,12 @@ pub(super) struct ExtrasState { /// Left and right mouse buttons: held, and their clicks. mouse: [bool; 2], cps: [Cps; 2], + minimap: Minimap, + /// The dimension the minimap's tiles belong to. + minimap_dim: Option, } +/// CPU time the minimap's tiles may take per frame. +const MINIMAP_BUDGET: Duration = Duration::from_micros(300); impl Game<'_> { fn extras_now(&self) -> f64 { @@ -70,6 +77,7 @@ impl Game<'_> { if !playing { self.extras.mouse = [false; 2]; } + self.update_minimap(); if self.settings.extras.fps { let now = self.extras_now(); self.extras.fps.record(now, elapsed.as_secs_f32() * 1000.0); @@ -77,6 +85,72 @@ impl Game<'_> { self.extras.fps.clear(); } } + /// The minimap's view of the player, if it shows. + fn minimap_view(&self) -> Option { + let e = &self.settings.extras; + let p = self.player.as_ref()?; + let shown = e.minimap && self.title.is_none() && !self.ui.hide_gui; + shown.then_some(View { + x: p.position.x, + z: p.position.z, + yaw: self.yaw, + rotate: e.minimap_rotate, + blocks_per_pixel: e.minimap_zoom, + round: e.minimap_round, + }) + } + /// Refresh the minimap's tiles within the frame budget, recompose its + /// image when the view or a tile changed, and queue the upload. + fn update_minimap(&mut self) { + let Some(view) = self.minimap_view() else { + if !self.settings.extras.minimap || self.player.is_none() { + self.extras.minimap.clear(); + self.extras.minimap_dim = None; + } + return; + }; + if self.extras.minimap_dim != Some(self.dim) { + self.extras.minimap.clear(); + self.extras.minimap_dim = Some(self.dim); + } + let Some(p) = self.player.as_ref() else { + return; + }; + let head = (p.position.y + f64::from(p.dimensions.eye_height)).floor() as i32; + let (bx, bz) = (view.x.floor() as i32, view.z.floor() as i32); + // Underground, under a roof or in the Nether: the floor around the player. + let covered = self.world.light(bx, head, bz) >> 4 == 0; + let layer = if self.dim == Dim::Nether || covered { + Layer::Below(head) + } else { + Layer::Surface + }; + // The chunks the image can reach (its corners when it turns). + let reach = minimap::SIZE as f32 / 2.0 * view.blocks_per_pixel * std::f32::consts::SQRT_2; + let radius = ((reach / 16.0).ceil() as i32 + 1).min(self.settings.render_distance.max(2)); + self.extras.minimap.update( + &self.world, + &self.res.facts, + (bx >> 4, bz >> 4), + radius, + layer, + MINIMAP_BUDGET, + ); + if !self.extras.minimap.compose(view) { + return; + } + let Some(rect) = self.res.atlas.sprites.get(MINIMAP_SPRITE).copied() else { + return; + }; + let (w, h) = (self.res.atlas.width as f32, self.res.atlas.height as f32); + self.map_patches.push(horizon_client::font::Patch { + x: (rect.u0 * w).round() as u32, + y: (rect.v0 * h).round() as u32, + width: minimap::SIZE as u32, + height: minimap::SIZE as u32, + rgba: self.extras.minimap.image.clone(), + }); + } /// The zoom in effect (1 unless the key is held). fn zoom_factor(&self) -> f32 { self.extras.zoom.factor(self.scoping()) @@ -105,14 +179,34 @@ impl Game<'_> { /// the caller). The top left corner gives way to the debug screen. pub(super) fn draw_extras(&mut self, batch: &mut HudBatch) { let e = &self.settings.extras; - if !e.fps && !e.keystrokes { + if !e.fps && !e.keystrokes && !e.minimap { return; } let (fps_on, fps_corner, lows) = (e.fps, e.fps_corner, e.fps_lows); let (keys_on, keys_corner, cps_on) = (e.keystrokes, e.keystrokes_corner, e.keystrokes_cps); - let visible = |corner| !(self.debug && corner == horizon_client::extras::Corner::TopLeft); + let (map_corner, map_size) = (e.minimap_corner, f32::from(e.minimap_size)); + let visible = |corner| !(self.debug && corner == Corner::TopLeft); let mut corners = Corners::new(batch.width, batch.height, self.effect_rows_height()); let atlas = &self.res.atlas; + if let Some(view) = self.minimap_view() + && visible(map_corner) + && !self.extras.minimap.image.is_empty() + && let Some(image) = atlas.sprites.get(MINIMAP_SPRITE).copied() + { + let (arrow, north) = if view.rotate { + (0.0, Some(view.north())) + } else { + (180.0 + view.yaw, None) + }; + let look = extras_hud::MinimapLook { + corner: map_corner, + size: map_size, + image, + arrow, + north, + }; + extras_hud::draw_minimap(batch, atlas, &mut corners, &look); + } if fps_on && visible(fps_corner) { let reading = self.extras.fps.reading(); extras_hud::draw_fps(batch, atlas, &mut corners, fps_corner, reading, lows); diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index 6161160dd..71db32199 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -31,6 +31,8 @@ pub struct HudAtlas { pub const GLYPH_ROWS: u32 = 512; /// 128x128 atlas slots for map textures. pub const MAP_SLOTS: usize = 16; +/// The atlas slot the minimap extra draws into. +pub const MINIMAP_SPRITE: &str = "horizon/minimap"; /// Atlas slots for downloaded player skins (`skins/`), 64x64 each. pub const SKIN_SLOTS: usize = 32; pub fn decode(path: &Path) -> Result<(u32, u32, Vec)> { @@ -200,6 +202,13 @@ impl HudAtlas { for i in 0..MAP_SLOTS { images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4])); } + // The minimap extra's image (game/extras.rs). + images.push(( + MINIMAP_SPRITE.into(), + crate::minimap::SIZE as u32, + crate::minimap::SIZE as u32, + vec![0; crate::minimap::SIZE * crate::minimap::SIZE * 4], + )); // Downloaded skins (game/scoreboard.rs) likewise. for i in 0..SKIN_SLOTS { images.push((format!("horizon/skin{i}"), 64, 64, vec![0; 64 * 64 * 4])); diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index f3b1db78d..5b21d45ae 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -86,6 +86,7 @@ pub mod logging; pub mod menu; pub mod merchant; pub mod mesher; +pub mod minimap; pub mod mobs; pub mod models; pub mod motion; diff --git a/crates/horizon-client/src/minimap.rs b/crates/horizon-client/src/minimap.rs new file mode 100644 index 000000000..8015e2ab2 --- /dev/null +++ b/crates/horizon-client/src/minimap.rs @@ -0,0 +1,679 @@ +//! The minimap extra (`docs/extras.md`): a 16x16 tile per loaded chunk with +//! each column's vanilla map colour (`MapColor`, as `MapItem.update` picks +//! it), height and water depth, and a 128x128 image composed from the tiles +//! around the player with the map item's height and water shading. +//! +//! Tiles are filled nearest first within a time budget and rescanned after +//! block changes; the image is recomposed only when the view moved or a tile +//! changed. +use crate::{ + blocks::{BlockFacts, Fluid, MAP_COLORS}, + chunk::{Chunk, MIN_Y, SECTIONS}, + fast_hash::FxHashMap, + world::World, +}; +use std::time::{Duration, Instant}; + +/// The image's side in texels. +pub const SIZE: usize = 128; +/// Marks a column the map cuts through (a wall at the player's height). +const WALL: u8 = 0x80; +/// Water's and lava's map colours (`MapColor.WATER`, `FIRE`). +const WATER: u8 = 12; +const LAVA: u8 = 4; +/// A tile whose chunk changed is rescanned at most this often. +const RESCAN: Duration = Duration::from_secs(1); + +/// What the map shows of each column. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Layer { + /// The top block, as map items show it. + Surface, + /// Underground, in the Nether or under a roof: the floor below this + /// height (the player's head), and walls cut at it. + Below(i32), +} + +/// What the scan needs of each block state. +pub struct Palette { + /// Map colour id, 0 for none. + color: Vec, + /// 0 none, 1 water, 2 lava; | 4 for air; | 8 when sturdy on top. + flags: Vec, +} +const FLUID: u8 = 3; +const AIR: u8 = 4; +const STURDY_TOP: u8 = 8; +impl Palette { + pub fn new(facts: &BlockFacts) -> Self { + let mut color = Vec::with_capacity(facts.states.len()); + let mut flags = Vec::with_capacity(facts.states.len()); + for (i, f) in facts.states.iter().enumerate() { + color.push(f.map_color); + let mut b = match f.fluid { + Fluid::None => 0, + Fluid::Water => 1, + Fluid::Lava => 2, + }; + if facts.is_air(horizon_world::registry::BlockStateId(i as u32)) { + b |= AIR; + } + // isFaceSturdy(UP, FULL): Direction.UP's ordinal is 1. + if f.sturdy_full >> 1 & 1 != 0 { + b |= STURDY_TOP; + } + flags.push(b); + } + Self { color, flags } + } + /// A palette from (colour, flags) per state id (tests). + #[cfg(test)] + fn from_parts(parts: &[(u8, u8)]) -> Self { + Self { + color: parts.iter().map(|p| p.0).collect(), + flags: parts.iter().map(|p| p.1).collect(), + } + } + #[inline] + fn get(&self, id: u16) -> (u8, u8) { + let i = usize::from(id); + ( + self.color.get(i).copied().unwrap_or(0), + self.flags.get(i).copied().unwrap_or(AIR), + ) + } +} + +#[derive(Clone)] +struct Tile { + /// Map colour id per column (`z * 16 + x`), `| WALL` for cut walls. + color: [u8; 256], + height: [i16; 256], + /// Water depth below the surface, for the map's water shading. + depth: [u8; 256], + revision: u64, + layer: Layer, + scanned: Instant, +} +/// `MapItem.update` for one column: the first block with a map colour +/// going down, the fluid's colour over a fluid unless the block is sturdy on +/// top (`getCorrectStateForFluidBlock`), and the fluid's depth. +fn scan_column( + chunk: &Chunk, + palette: &Palette, + x: i32, + z: i32, + top: i32, + layer: Layer, +) -> (u8, i16, u8) { + let mut y = top; + if let Layer::Below(head) = layer { + let (color, flags) = palette.get(chunk.get(x, head, z)); + if flags & AIR == 0 && color != 0 && flags & FLUID == 0 { + return (color | WALL, head as i16, 0); + } + } + while y > MIN_Y { + let (mut color, flags) = palette.get(chunk.get(x, y, z)); + if color == 0 { + y -= 1; + continue; + } + let mut depth = 0u8; + let fluid = flags & FLUID; + if fluid != 0 { + let mut below = y - 1; + while below > MIN_Y && palette.get(chunk.get(x, below, z)).1 & FLUID != 0 { + depth = depth.saturating_add(1); + below -= 1; + } + depth = depth.saturating_add(1); + if flags & STURDY_TOP == 0 { + color = if fluid == 2 { LAVA } else { WATER }; + } + } + return (color, y as i16, depth); + } + (0, MIN_Y as i16, 0) +} +/// The highest block of a chunk worth scanning from. +fn top_of(chunk: &Chunk, air: u16, layer: Layer) -> i32 { + let surface = (0..SECTIONS) + .rev() + .find(|&s| { + chunk + .sections + .get(s) + .is_some_and(|sec| !sec.is_uniform(air)) + }) + .map_or(MIN_Y, |s| MIN_Y + s as i32 * 16 + 15); + match layer { + Layer::Surface => surface, + Layer::Below(head) => surface.min(head), + } +} +fn scan_tile(chunk: &Chunk, palette: &Palette, air: u16, layer: Layer, revision: u64) -> Tile { + let top = top_of(chunk, air, layer); + let mut tile = Tile { + color: [0; 256], + height: [MIN_Y as i16; 256], + depth: [0; 256], + revision, + layer, + scanned: Instant::now(), + }; + for z in 0..16 { + for x in 0..16 { + let (c, h, d) = scan_column(chunk, palette, x, z, top, layer); + let i = (z * 16 + x) as usize; + tile.color[i] = c; + tile.height[i] = h; + tile.depth[i] = d; + } + } + tile +} + +/// Where the map looks from and how. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct View { + pub x: f64, + pub z: f64, + /// The player's yaw in degrees (0 faces south). + pub yaw: f32, + /// The map turns with the player (forward is up), or north is up. + pub rotate: bool, + pub blocks_per_pixel: f32, + pub round: bool, +} +impl View { + /// Whether the image for `self` would look different from `other`'s. + fn differs(&self, other: &View) -> bool { + let moved = ((self.x - other.x).abs().max((self.z - other.z).abs()) as f32) + >= self.blocks_per_pixel / 4.0; + let turned = self.rotate && (self.yaw - other.yaw).abs() >= 0.5; + moved + || turned + || self.rotate != other.rotate + || self.round != other.round + || self.blocks_per_pixel != other.blocks_per_pixel + } + /// The world's right and forward directions as the map's x and up. + fn axes(&self) -> ([f64; 2], [f64; 2]) { + if !self.rotate { + return ([1.0, 0.0], [0.0, -1.0]); + } + let (s, c) = f64::from(self.yaw).to_radians().sin_cos(); + ([-c, -s], [-s, c]) + } + /// Where north is on the map's rim, as a unit direction (x right, y down). + pub fn north(&self) -> (f32, f32) { + let (r, f) = self.axes(); + // The direction (0, -1) in the map's (right, -forward) basis. + (-r[1] as f32, f[1] as f32) + } +} + +/// `MapColor.getColorFromPackedId` as RGBA. +fn packed_rgba(id: u8, brightness: u8) -> [u8; 4] { + let id = usize::from(id); + if id == 0 || id >= MAP_COLORS.len() { + return [0; 4]; + } + let modifier = [180u32, 220, 255, 135][usize::from(brightness & 3)]; + let col = MAP_COLORS[id]; + let ch = |s: u32| ((col >> s & 255) * modifier / 255) as u8; + [ch(16), ch(8), ch(0), 255] +} +/// The map item's shading at scale 1: brighter facing a lower north +/// neighbour, darker facing a higher one, dithered; water by depth. +fn brightness(color: u8, height: i16, north: Option, depth: u8, parity: i32) -> u8 { + if color & WALL != 0 { + return 3; + } + let parity = f64::from(parity & 1); + if color == WATER { + let diff = f64::from(depth) * 0.1 + parity * 0.2; + return if diff < 0.5 { + 2 + } else if diff > 0.9 { + 0 + } else { + 1 + }; + } + let north = north.unwrap_or(height); + let diff = f64::from(height - north) * 4.0 / 5.0 + (parity - 0.5) * 0.4; + if diff > 0.6 { + 2 + } else if diff < -0.6 { + 0 + } else { + 1 + } +} +const UNKNOWN: [u8; 4] = [20, 20, 20, 200]; +const BORDER: [u8; 4] = [10, 10, 10, 230]; + +#[derive(Default)] +pub struct Minimap { + tiles: FxHashMap<(i32, i32), Tile>, + palette: Option, + composed: Option, + /// Tiles changed since the image was composed. + changed: bool, + /// The composed image, `SIZE` x `SIZE` RGBA. + pub image: Vec, +} +impl Minimap { + /// Forget everything (a new world or dimension, or the minimap turned off). + pub fn clear(&mut self) { + let palette = self.palette.take(); + *self = Self { + palette, + ..Self::default() + }; + } + /// Fill and refresh tiles around chunk `center` within `radius` chunks, + /// nearest first, until `budget` is spent. Returns the tiles scanned. + pub fn update( + &mut self, + world: &World, + facts: &BlockFacts, + center: (i32, i32), + radius: i32, + layer: Layer, + budget: Duration, + ) -> usize { + let palette = self.palette.get_or_insert_with(|| Palette::new(facts)); + let started = Instant::now(); + let air = world.air.0 as u16; + // Tiles of unloaded or distant chunks go. + self.tiles.retain(|k, _| { + (k.0 - center.0).abs() <= radius + 2 + && (k.1 - center.1).abs() <= radius + 2 + && world.chunks.contains_key(k) + }); + let mut scanned = 0; + for ring in 0..=radius { + for (dx, dz) in ring_offsets(ring) { + let key = (center.0 + dx, center.1 + dz); + let Some(chunk) = world.chunks.get(&key) else { + continue; + }; + let stale = match self.tiles.get(&key) { + None => true, + Some(t) if t.layer != layer => true, + Some(t) => t.revision != world.revision && t.scanned.elapsed() >= RESCAN, + }; + if !stale { + continue; + } + let tile = scan_tile(chunk, palette, air, layer, world.revision); + if self.tiles.get(&key).is_none_or(|t| { + t.color != tile.color || t.height != tile.height || t.depth != tile.depth + }) { + self.changed = true; + } + self.tiles.insert(key, tile); + scanned += 1; + if started.elapsed() >= budget { + return scanned; + } + } + } + scanned + } + /// Recompose the image if the view or the tiles changed; true when it did. + pub fn compose(&mut self, view: View) -> bool { + if !self.changed + && self.composed.is_some_and(|c| !view.differs(&c)) + && !self.image.is_empty() + { + return false; + } + self.changed = false; + self.composed = Some(view); + self.image.resize(SIZE * SIZE * 4, 0); + let (r, f) = view.axes(); + let bpp = f64::from(view.blocks_per_pixel); + let half = SIZE as f64 / 2.0; + let mut cached: Option<((i32, i32), &Tile)> = None; + let mut column = |x: i32, z: i32| -> Option<(u8, i16, u8)> { + let key = (x >> 4, z >> 4); + let tile = match cached { + Some((k, t)) if k == key => t, + _ => { + let t = self.tiles.get(&key)?; + cached = Some((key, t)); + t + } + }; + let i = ((z & 15) * 16 + (x & 15)) as usize; + Some((tile.color[i], tile.height[i], tile.depth[i])) + }; + for j in 0..SIZE { + for i in 0..SIZE { + let (u, v) = (i as f64 + 0.5 - half, j as f64 + 0.5 - half); + let o = (j * SIZE + i) * 4; + let edge = if view.round { + let d = (u * u + v * v).sqrt(); + if d > half { + self.image[o..o + 4].copy_from_slice(&[0; 4]); + continue; + } + d > half - 1.5 + } else { + i == 0 || j == 0 || i == SIZE - 1 || j == SIZE - 1 + }; + if edge { + self.image[o..o + 4].copy_from_slice(&BORDER); + continue; + } + let wx = view.x + bpp * (u * r[0] - v * f[0]); + let wz = view.z + bpp * (u * r[1] - v * f[1]); + let (x, z) = (wx.floor() as i32, wz.floor() as i32); + let rgba = match column(x, z) { + Some((color, height, depth)) if color & !WALL != 0 => { + let north = column(x, z - 1).filter(|c| c.0 & !WALL != 0).map(|c| c.1); + let b = brightness(color, height, north, depth, x + z); + packed_rgba(color & !WALL, b) + } + _ => UNKNOWN, + }; + self.image[o..o + 4].copy_from_slice(&rgba); + } + } + true + } + pub fn tile_count(&self) -> usize { + self.tiles.len() + } +} +/// Chunk offsets at Chebyshev distance `ring`. +fn ring_offsets(ring: i32) -> impl Iterator { + (-ring..=ring).flat_map(move |dz| { + (-ring..=ring) + .filter(move |&dx| dx.abs() == ring || dz.abs() == ring) + .map(move |dx| (dx, dz)) + }) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::sync::Arc; + + // States: 0 air, 1 grass (colour 1), 2 stone (11), 3 water, 4 glass (no + // colour), 5 waterlogged slab (sturdy on top? no), 6 lava. + fn palette() -> Palette { + Palette::from_parts(&[ + (0, AIR), + (1, STURDY_TOP), + (11, STURDY_TOP), + (WATER, 1), + (0, 0), + (11, 1), + (LAVA, 2), + ]) + } + fn chunk(columns: &[(i32, i32, &[(i32, u16)])]) -> Chunk { + let mut c = Chunk::empty(0, 0); + for &(x, z, blocks) in columns { + for &(y, id) in blocks { + c.set(x, y, z, id); + } + } + c + } + + #[test] + fn columns_take_the_first_coloured_block_and_fluids_over_it() { + let p = palette(); + let c = chunk(&[ + (0, 0, &[(60, 2), (61, 1)]), + // Glass has no map colour: the grass under it shows. + (1, 0, &[(61, 1), (62, 4)]), + // Three water over stone. + (2, 0, &[(60, 2), (61, 3), (62, 3), (63, 3)]), + (3, 0, &[(70, 6)]), + ]); + let top = top_of(&c, 0, Layer::Surface); + assert_eq!(top, 79); + assert_eq!(scan_column(&c, &p, 0, 0, top, Layer::Surface), (1, 61, 0)); + assert_eq!(scan_column(&c, &p, 1, 0, top, Layer::Surface), (1, 61, 0)); + assert_eq!( + scan_column(&c, &p, 2, 0, top, Layer::Surface), + (WATER, 63, 3) + ); + assert_eq!( + scan_column(&c, &p, 3, 0, top, Layer::Surface), + (LAVA, 70, 1) + ); + assert_eq!(scan_column(&c, &p, 4, 0, top, Layer::Surface).0, 0); + } + + #[test] + fn a_waterlogged_block_not_sturdy_on_top_shows_water() { + let p = palette(); + let c = chunk(&[(0, 0, &[(60, 2), (61, 5)])]); + assert_eq!( + scan_column(&c, &p, 0, 0, 70, Layer::Surface), + (WATER, 61, 1) + ); + } + + #[test] + fn below_a_height_shows_the_floor_and_cuts_walls() { + let p = palette(); + // A cave: stone everywhere from 0 to 20, air at 10 and 11 in column 0. + let mut blocks: Vec<(i32, u16)> = (0..=20).map(|y| (y, 2)).collect(); + let solid = blocks.clone(); + blocks.retain(|&(y, _)| y != 10 && y != 11); + let c = chunk(&[(0, 0, &blocks), (1, 0, &solid)]); + let layer = Layer::Below(11); + let top = top_of(&c, 0, layer); + assert_eq!(top, 11); + assert_eq!(scan_column(&c, &p, 0, 0, top, layer), (11, 9, 0)); + assert_eq!(scan_column(&c, &p, 1, 0, top, layer), (11 | WALL, 11, 0)); + // The surface view sees the roof. + assert_eq!(scan_column(&c, &p, 0, 0, 31, Layer::Surface), (11, 20, 0)); + } + + #[test] + fn shading_follows_the_map_item() { + // Higher than the north neighbour: bright; lower: dark; level: normal. + assert_eq!(brightness(1, 65, Some(64), 0, 0), 2); + assert_eq!(brightness(1, 63, Some(64), 0, 1), 0); + assert_eq!(brightness(1, 64, Some(64), 0, 0), 1); + assert_eq!(brightness(1, 64, Some(64), 0, 1), 1); + // Shallow water is bright, deep water dark. + assert_eq!(brightness(WATER, 62, None, 1, 0), 2); + assert_eq!(brightness(WATER, 62, None, 10, 0), 0); + assert_eq!(brightness(1 | WALL, 0, None, 0, 0), 3); + assert_eq!(packed_rgba(1, 2), [127, 178, 56, 255]); + assert_eq!(packed_rgba(0, 2), [0; 4]); + } + + fn world_with(chunks: Vec) -> World { + let mut w = World::new(horizon_world::registry::BlockStateId(0), 0); + for c in chunks { + w.chunks.insert((c.x, c.z), Arc::new(c)); + } + w + } + fn grass_chunk(x: i32, z: i32) -> Chunk { + let mut c = Chunk::empty(x, z); + for bz in 0..16 { + for bx in 0..16 { + c.set(bx, 64, bz, 1); + } + } + c + } + + #[test] + fn tiles_fill_nearest_first_and_follow_changes() { + let mut map = Minimap { + palette: Some(palette()), + ..Default::default() + }; + let facts = BlockFacts { + states: Vec::new(), + air: horizon_world::registry::BlockStateId(0), + }; + let mut world = world_with( + (-2..=2) + .flat_map(|x| (-2..=2).map(move |z| grass_chunk(x, z))) + .collect(), + ); + // A zero budget still scans one tile: the player's own chunk. + assert_eq!( + map.update(&world, &facts, (0, 0), 2, Layer::Surface, Duration::ZERO), + 1 + ); + assert!(map.tiles.contains_key(&(0, 0))); + let n = map.update( + &world, + &facts, + (0, 0), + 2, + Layer::Surface, + Duration::from_secs(1), + ); + assert_eq!(n, 24); + assert_eq!(map.tile_count(), 25); + // Nothing changed: nothing to scan. + assert_eq!( + map.update( + &world, + &facts, + (0, 0), + 2, + Layer::Surface, + Duration::from_secs(1) + ), + 0 + ); + // A changed world is rescanned once the tiles are old enough. + world + .set(0, 70, 0, horizon_world::registry::BlockStateId(2)) + .unwrap(); + assert_eq!( + map.update( + &world, + &facts, + (0, 0), + 2, + Layer::Surface, + Duration::from_secs(1) + ), + 0 + ); + for t in map.tiles.values_mut() { + t.scanned -= RESCAN; + } + assert_eq!( + map.update( + &world, + &facts, + (0, 0), + 2, + Layer::Surface, + Duration::from_secs(1) + ), + 25 + ); + assert_eq!(map.tiles[&(0, 0)].color[0], 11); + // A new layer rescans everything; unloaded chunks drop out. + world.chunks.remove(&(2, 2)); + let n = map.update( + &world, + &facts, + (0, 0), + 2, + Layer::Below(70), + Duration::from_secs(1), + ); + assert_eq!(n, 24); + assert!(!map.tiles.contains_key(&(2, 2))); + } + + #[test] + fn the_image_is_north_up_or_turns_with_the_player() { + let mut map = Minimap { + palette: Some(palette()), + ..Default::default() + }; + let facts = BlockFacts { + states: Vec::new(), + air: horizon_world::registry::BlockStateId(0), + }; + // Grass everywhere, one stone block 10 blocks north of the player. + let mut world = world_with( + (-4..=4) + .flat_map(|x| (-4..=4).map(move |z| grass_chunk(x, z))) + .collect(), + ); + world + .set(0, 64, -10, horizon_world::registry::BlockStateId(2)) + .unwrap(); + map.update( + &world, + &facts, + (0, 0), + 4, + Layer::Surface, + Duration::from_secs(1), + ); + let pixel = |map: &Minimap, i: usize, j: usize| { + let o = (j * SIZE + i) * 4; + [map.image[o], map.image[o + 1], map.image[o + 2]] + }; + let stone = [96, 96, 96]; + let mut view = View { + x: 0.0, + z: 0.0, + yaw: 0.0, + rotate: false, + blocks_per_pixel: 1.0, + round: false, + }; + assert!(map.compose(view)); + assert!(!map.compose(view), "the same view is not recomposed"); + // North up: the stone is 10 pixels above the centre. + assert_eq!(pixel(&map, 64, 54), stone); + // Turning with the player facing east (yaw -90): north is to the left. + view.rotate = true; + view.yaw = -90.0; + assert!(map.compose(view)); + assert_eq!(pixel(&map, 54, 63), stone); + let (nx, ny) = view.north(); + assert!((nx + 1.0).abs() < 1e-5 && ny.abs() < 1e-5, "{nx} {ny}"); + // Facing north, north is up. + view.yaw = 180.0; + map.compose(view); + assert_eq!(pixel(&map, 64, 54), stone); + // Round maps are transparent in the corners, framed at the edge. + view.round = true; + map.compose(view); + assert_eq!(map.image[3], 0); + assert_eq!(&map.image[(64 * SIZE) * 4..(64 * SIZE) * 4 + 4], &BORDER); + // A small move recomposes only once it is visible. + view.x += 0.1; + assert!(!map.compose(view)); + view.x += 0.2; + assert!(map.compose(view)); + } + + #[test] + fn rings_cover_each_offset_once() { + let mut seen = std::collections::HashSet::new(); + for r in 0..=3 { + for o in ring_offsets(r) { + assert!(seen.insert(o)); + } + } + assert_eq!(seen.len(), 49); + } +}