Merge pull request #1197 from ludovic111/feat/locator-bar
🤖 Agent: merged after verify passed and the wave-3 integration on the desktop by integ-w3: main + 17 PRs, fmt, clippy 0, 1929 workspace tests, parity --changed (only known flakes failed, and those passed on rerun), lan_e2e in both modes, and the perf numbers back to back against main posted on each PR.
This commit is contained in:
@@ -84,6 +84,7 @@ mod level_particles;
|
||||
mod levels;
|
||||
mod lightning;
|
||||
mod llamas;
|
||||
mod locator_bar;
|
||||
mod loom;
|
||||
mod mace;
|
||||
mod machines;
|
||||
@@ -1375,6 +1376,14 @@ struct Game<'a> {
|
||||
/// Entities of types Horizon does not simulate.
|
||||
others: Vec<commands::OtherEntity>,
|
||||
armor_stand_assets: armor_stands::ArmorStandAssets,
|
||||
/// `WaypointStyleManager`.
|
||||
waypoint_styles: horizon_client::locator_bar::WaypointStyles,
|
||||
/// `ClientWaypointManager`: the locator bar's waypoints.
|
||||
waypoints: horizon_client::locator_bar::ClientWaypoints,
|
||||
/// The camera the last frame drew from (position, yaw, pitch, fov), for the locator bar.
|
||||
locator_camera: Option<([f64; 3], f32, f32, f32)>,
|
||||
/// `LocalPlayer.experienceDisplayStartTick`: (last progress, seen a change, tick).
|
||||
experience_display: (f32, bool, u64),
|
||||
boats: Vec<boats::Boat>,
|
||||
boat_models: boats::BoatModels,
|
||||
/// EndCrystalModel's baked layer.
|
||||
@@ -3916,6 +3925,7 @@ impl Game<'_> {
|
||||
None => 0.0,
|
||||
};
|
||||
self.ticks += 1;
|
||||
self.track_experience_display();
|
||||
// `/tick freeze` stops the world but not the player.
|
||||
let running = self.clock.world_runs();
|
||||
if running {
|
||||
@@ -4770,12 +4780,41 @@ impl Game<'_> {
|
||||
self.draw_extras(&mut batch);
|
||||
}
|
||||
if show_hud {
|
||||
// The mount's hearts (and the jump bar that replaces the experience bar).
|
||||
let (vehicle_hearts, jump_bar) = if spectator {
|
||||
(0, false)
|
||||
// Hud.nextContextualInfoState: the jump bar, the experience bar or
|
||||
// the locator bar above the hotbar.
|
||||
let has_experience = !self.creative && !spectator;
|
||||
let contextual = horizon_client::locator_bar::ContextualBar::next(
|
||||
self.waypoints.has_waypoints(),
|
||||
!spectator && self.jumpable_mount(),
|
||||
self.mount_jumping(),
|
||||
has_experience,
|
||||
self.experience_recent(),
|
||||
);
|
||||
use horizon_client::locator_bar::ContextualBar;
|
||||
// The mount's hearts (and the jump bar).
|
||||
let vehicle_hearts = if spectator {
|
||||
0
|
||||
} else {
|
||||
self.draw_mount_hud(&mut batch, wi, hi)
|
||||
self.draw_mount_hud(
|
||||
&mut batch,
|
||||
wi,
|
||||
hi,
|
||||
contextual == ContextualBar::JumpableVehicle,
|
||||
)
|
||||
};
|
||||
if contextual == ContextualBar::Locator {
|
||||
let (sprite, [x, y, w, h]) = horizon_client::locator_bar::background(wi, hi);
|
||||
horizon_client::ui::nine_slice(
|
||||
&mut batch,
|
||||
&self.gui.atlas,
|
||||
sprite,
|
||||
x as f32,
|
||||
y as f32,
|
||||
w as f32,
|
||||
h as f32,
|
||||
u32::MAX,
|
||||
);
|
||||
}
|
||||
if !self.creative
|
||||
&& !spectator
|
||||
&& let Some(p) = &mut self.player
|
||||
@@ -4787,7 +4826,7 @@ impl Game<'_> {
|
||||
hi,
|
||||
self.experience.progress,
|
||||
self.experience.level,
|
||||
!jump_bar,
|
||||
contextual == ContextualBar::Experience,
|
||||
&width,
|
||||
);
|
||||
hud_layout::paint(&mut batch, atlas, &draws);
|
||||
@@ -4837,6 +4876,10 @@ impl Game<'_> {
|
||||
let draws = self.health_hud.layout(&inputs, wi, hi);
|
||||
hud_layout::paint(&mut batch, atlas, &draws);
|
||||
}
|
||||
if contextual == ContextualBar::Locator {
|
||||
let draws = self.locator_bar_draws(wi, hi);
|
||||
hud_layout::paint(&mut batch, &self.gui.atlas, &draws);
|
||||
}
|
||||
if !spectator {
|
||||
self.draw_selected_name(&mut batch, !self.creative);
|
||||
}
|
||||
@@ -7771,6 +7814,7 @@ impl Game<'_> {
|
||||
Ok(())
|
||||
}
|
||||
fn close_world(&mut self) -> Result<()> {
|
||||
self.clear_waypoints();
|
||||
self.begin_closing_save(false)
|
||||
}
|
||||
fn finish_close_world(&mut self) -> Result<()> {
|
||||
@@ -9789,6 +9833,8 @@ impl Game<'_> {
|
||||
} else {
|
||||
self.fov_degrees(camera_alpha as f32, camera.to_array())
|
||||
};
|
||||
self.locator_camera =
|
||||
(!title).then_some((camera.to_array(), view_yaw, view_pitch, fov_degrees));
|
||||
let bob = if title {
|
||||
glam::Mat4::IDENTITY
|
||||
} else {
|
||||
@@ -11631,6 +11677,10 @@ impl<'a> Game<'a> {
|
||||
armor_stands: Vec::new(),
|
||||
others: Vec::new(),
|
||||
armor_stand_assets: prepared.armor_stand_assets,
|
||||
waypoint_styles: prepared.waypoint_styles,
|
||||
waypoints: Default::default(),
|
||||
locator_camera: None,
|
||||
experience_display: Default::default(),
|
||||
boats: Vec::new(),
|
||||
boat_models: prepared.boat_models,
|
||||
crystal_model: prepared.crystal_model,
|
||||
@@ -11758,6 +11808,7 @@ struct GameCpuResources {
|
||||
map_frame_model: frames::FrameModel,
|
||||
glow_map_frame_model: frames::FrameModel,
|
||||
armor_stand_assets: armor_stands::ArmorStandAssets,
|
||||
waypoint_styles: horizon_client::locator_bar::WaypointStyles,
|
||||
boat_models: boats::BoatModels,
|
||||
cart_models: minecarts::CartModels,
|
||||
crystal_model: Option<horizon_client::mobs::Part>,
|
||||
@@ -11777,6 +11828,7 @@ impl GameCpuResources {
|
||||
map_frame_model: frames::bake_frame(root, "item_frame_map"),
|
||||
glow_map_frame_model: frames::bake_frame(root, "glow_item_frame_map"),
|
||||
armor_stand_assets: armor_stands::ArmorStandAssets::load(root, document.as_ref()),
|
||||
waypoint_styles: horizon_client::locator_bar::WaypointStyles::load(root),
|
||||
boat_models: boats::BoatModels::load(document.as_ref()),
|
||||
cart_models: minecarts::CartModels::load(document.as_ref()),
|
||||
crystal_model: model("minecraft:end_crystal#main"),
|
||||
|
||||
@@ -9,6 +9,10 @@ use horizon_client::{
|
||||
},
|
||||
};
|
||||
|
||||
/// The host player's connection id in the waypoint managers: its packets
|
||||
/// go to this client's locator bar rather than to a guest.
|
||||
const HOST_CONN: u32 = u32::MAX;
|
||||
|
||||
/// `waypoint_transmit_range`: hidden by crouching, invisibility or a head worn.
|
||||
fn transmit_range(crouching: bool, invisible: bool, head: Option<&ItemStack>) -> f64 {
|
||||
let hiding_head = head.is_some_and(|s| HIDING_HEADS.contains(&&*s.item));
|
||||
@@ -47,7 +51,7 @@ impl Game<'_> {
|
||||
self.dim.id(),
|
||||
waypoints::Player {
|
||||
uuid: h.uuid,
|
||||
conn: None,
|
||||
conn: Some(HOST_CONN),
|
||||
position: h.position,
|
||||
spectator: self.spectator(),
|
||||
transmit_range: transmit_range(
|
||||
@@ -123,7 +127,12 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
for (conn, packet) in out {
|
||||
if let Some(g) = host.hub.guest(conn) {
|
||||
if conn == HOST_CONN {
|
||||
// The host's own connection: its locator bar.
|
||||
if let horizon_protocol::packets::play::Clientbound::TrackedWaypoint(w) = &packet {
|
||||
self.handle_waypoint(w);
|
||||
}
|
||||
} else if let Some(g) = host.hub.guest(conn) {
|
||||
g.send(&packet);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
//! The locator bar on this client (horizon_client::locator_bar): the
|
||||
//! waypoints a server tracks for the player (`handleWaypoint`; on a served
|
||||
//! world the host's own connection in lan/waypoints.rs), the experience
|
||||
//! bar's priority after a change, and the dots drawn from the last frame's
|
||||
//! camera.
|
||||
use super::Game;
|
||||
use horizon_client::{
|
||||
hud_layout::GuiDraw,
|
||||
locator_bar::{ClientWaypoints, View},
|
||||
};
|
||||
use horizon_protocol::packets::play::TrackedWaypoint;
|
||||
|
||||
/// `Player.getEyeHeight` while standing.
|
||||
const PLAYER_EYES: f64 = 1.62;
|
||||
|
||||
fn uuid(ints: [i32; 4]) -> u128 {
|
||||
ints.iter()
|
||||
.fold(0u128, |acc, &i| acc << 32 | u128::from(i as u32))
|
||||
}
|
||||
|
||||
impl Game<'_> {
|
||||
/// `ClientPacketListener.handleWaypoint`.
|
||||
pub(super) fn handle_waypoint(&mut self, packet: &TrackedWaypoint) {
|
||||
self.waypoints.apply(packet);
|
||||
}
|
||||
/// A new connection or world starts with no waypoints.
|
||||
pub(super) fn clear_waypoints(&mut self) {
|
||||
self.waypoints = ClientWaypoints::default();
|
||||
}
|
||||
/// `LocalPlayer.setExperienceValues`: a change of progress shows the
|
||||
/// experience bar for 100 ticks, except the first one
|
||||
/// (`experienceDisplayStartTick` starts at `Integer.MIN_VALUE`).
|
||||
pub(super) fn track_experience_display(&mut self) {
|
||||
let progress = self.experience.progress;
|
||||
let (last, seen, _) = &mut self.experience_display;
|
||||
if progress != *last {
|
||||
*last = progress;
|
||||
if *seen {
|
||||
self.experience_display.2 = self.ticks;
|
||||
} else {
|
||||
*seen = true;
|
||||
}
|
||||
}
|
||||
// EnchantmentScreen and AnvilScreen.containerTick keep it up.
|
||||
if self.station.as_ref().is_some_and(|s| {
|
||||
matches!(
|
||||
s.kind,
|
||||
super::stations::Kind::Enchanting | super::stations::Kind::Anvil
|
||||
)
|
||||
}) {
|
||||
self.experience_display.2 = self.ticks;
|
||||
}
|
||||
}
|
||||
/// `Hud.willPrioritizeExperienceInfo`.
|
||||
pub(super) fn experience_recent(&self) -> bool {
|
||||
let (_, _, start) = self.experience_display;
|
||||
start != 0 && start + 100 > self.ticks
|
||||
}
|
||||
/// The local player's UUID, as servers know it.
|
||||
fn own_uuid(&self) -> u128 {
|
||||
match &self.remote {
|
||||
Some(r) => r.profile(),
|
||||
None => self.level.player_uuid.map_or(0, uuid),
|
||||
}
|
||||
}
|
||||
/// An entity's block position and (interpolated) eyes, by UUID.
|
||||
fn waypoint_entity(&self, id: u128, alpha: f64) -> Option<([i32; 3], [f64; 3])> {
|
||||
let at = |p: [f64; 3], q: [f64; 3], eyes: f64| {
|
||||
let pos: [f64; 3] = std::array::from_fn(|i| q[i] + (p[i] - q[i]) * alpha);
|
||||
(p.map(|c| c.floor() as i32), [pos[0], pos[1] + eyes, pos[2]])
|
||||
};
|
||||
if let Some(r) = &self.remote {
|
||||
let entity = r.player_entity(id)?;
|
||||
let m = self.mobs.iter().find(|m| m.id == entity)?;
|
||||
let v = |v: horizon_core::geometry::Vec3| [v.x, v.y, v.z];
|
||||
return Some(at(v(m.position), v(m.previous), m.eye_height()));
|
||||
}
|
||||
let host = self.lan.as_ref()?;
|
||||
let g = host.hub.guests.iter().find(|g| g.uuid == id && g.placed)?;
|
||||
Some(at(g.position, g.previous_position, PLAYER_EYES))
|
||||
}
|
||||
/// `LocatorBar.extractRenderState` from the last frame's camera.
|
||||
pub(super) fn locator_bar_draws(&self, gui_width: i32, gui_height: i32) -> Vec<GuiDraw> {
|
||||
let (Some((camera_pos, yaw, pitch, fov)), Some(p)) = (self.locator_camera, &self.player)
|
||||
else {
|
||||
return Vec::new();
|
||||
};
|
||||
let alpha = self.clock.camera_fraction();
|
||||
// Camera.getViewRotationProjectionMatrix, through view space: the
|
||||
// depth along the look direction and the height on screen.
|
||||
let (sy, cy) = (
|
||||
f64::from(yaw.to_radians()).sin(),
|
||||
f64::from(yaw.to_radians()).cos(),
|
||||
);
|
||||
let (sp, cp) = (
|
||||
f64::from(pitch.to_radians()).sin(),
|
||||
f64::from(pitch.to_radians()).cos(),
|
||||
);
|
||||
let forward = [-sy * cp, -sp, cy * cp];
|
||||
let up = [-sy * sp, cp, cy * sp];
|
||||
let focal = 1.0 / f64::from((fov / 2.0).to_radians()).tan();
|
||||
let project = |o: [f64; 3]| {
|
||||
let dot = |a: [f64; 3]| a[0] * o[0] + a[1] * o[1] + a[2] * o[2];
|
||||
let depth = dot(forward);
|
||||
let y = dot(up) * focal / depth;
|
||||
// Points behind the camera land past the far plane (z > 1).
|
||||
[0.0, y, if depth < 0.0 { 2.0 } else { 0.5 }]
|
||||
};
|
||||
let entity = |id: u128| self.waypoint_entity(id, alpha);
|
||||
let view = View {
|
||||
gui_width,
|
||||
gui_height,
|
||||
camera_uuid: self.own_uuid(),
|
||||
camera_entity_pos: [p.position.x, p.position.y, p.position.z],
|
||||
camera_pos,
|
||||
yaw,
|
||||
pitch,
|
||||
fov,
|
||||
project: &project,
|
||||
entity: &entity,
|
||||
styles: &self.waypoint_styles,
|
||||
tick: self.ticks,
|
||||
};
|
||||
self.waypoints.draw(&view)
|
||||
}
|
||||
}
|
||||
@@ -463,25 +463,40 @@ impl Game<'_> {
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
/// `Hud.extractVehicleHealth` and the jump bar that replaces the
|
||||
/// experience bar on a saddled jumper. Returns the mount's heart count
|
||||
/// (`getVehicleMaxHearts`) and whether the jump bar shows.
|
||||
pub(super) fn draw_mount_hud(&self, batch: &mut HudBatch, w: i32, h: i32) -> (i32, bool) {
|
||||
/// `Player.jumpableVehicle`: a saddled mount that jumps.
|
||||
pub(super) fn jumpable_mount(&self) -> bool {
|
||||
self.mount_index()
|
||||
.is_some_and(|i| self.mobs[i].extra.saddled)
|
||||
}
|
||||
/// `willPrioritizeJumpInfo`: charging a jump or recharging.
|
||||
pub(super) fn mount_jumping(&self) -> bool {
|
||||
self.mount.jump_scale > 0.0 || self.mount.jump_ticks < 0
|
||||
}
|
||||
/// `Hud.extractVehicleHealth`, and the jump bar when it is the
|
||||
/// contextual bar (`jump_bar`). Returns the mount's heart count
|
||||
/// (`getVehicleMaxHearts`).
|
||||
pub(super) fn draw_mount_hud(
|
||||
&self,
|
||||
batch: &mut HudBatch,
|
||||
w: i32,
|
||||
h: i32,
|
||||
jump_bar: bool,
|
||||
) -> i32 {
|
||||
let Some(i) = self.mount_index() else {
|
||||
return (0, false);
|
||||
return 0;
|
||||
};
|
||||
let m = &self.mobs[i];
|
||||
let atlas = &self.gui.atlas;
|
||||
let hearts = horizon_client::hud_layout::vehicle_max_hearts(m.attrs.max_health);
|
||||
let draws = horizon_client::hud_layout::vehicle_health(w, h, hearts, m.health);
|
||||
horizon_client::hud_layout::paint(batch, atlas, &draws);
|
||||
if m.extra.saddled {
|
||||
if jump_bar {
|
||||
// JumpableVehicleBar: the cooldown shows while the jump recharges.
|
||||
let cooldown = i32::from(self.mount.jump_ticks < 0);
|
||||
let draws =
|
||||
horizon_client::hud_overlays::jump_bar(w, h, cooldown, self.mount.jump_scale);
|
||||
horizon_client::hud_layout::paint(batch, atlas, &draws);
|
||||
}
|
||||
(hearts, m.extra.saddled)
|
||||
hearts
|
||||
}
|
||||
}
|
||||
|
||||
@@ -171,6 +171,7 @@ impl Game<'_> {
|
||||
}
|
||||
};
|
||||
// Everything loaded: switch over.
|
||||
self.waypoint_styles = horizon_client::locator_bar::WaypointStyles::load(root);
|
||||
self.armor_stand_assets.reload_trims(root);
|
||||
self.random_tick_sections.clear();
|
||||
self.portals.sections.clear();
|
||||
|
||||
@@ -351,6 +351,7 @@ impl Game<'_> {
|
||||
r.clear_sections();
|
||||
}
|
||||
self.apply_settings();
|
||||
self.clear_waypoints();
|
||||
self.remote = Some(Remote {
|
||||
session,
|
||||
brand: "unknown".into(),
|
||||
@@ -429,6 +430,7 @@ impl Game<'_> {
|
||||
// Leaving on purpose: nothing for auto-reconnect to retry.
|
||||
self.extras_left();
|
||||
}
|
||||
self.clear_waypoints();
|
||||
if let Some(mut r) = self.remote.take() {
|
||||
r.session.disconnect();
|
||||
}
|
||||
@@ -2061,6 +2063,7 @@ impl Game<'_> {
|
||||
self.capture(false);
|
||||
}
|
||||
}
|
||||
C::TrackedWaypoint(p) => self.handle_waypoint(&p),
|
||||
C::SetExperience(p) => {
|
||||
self.experience = Experience {
|
||||
level: p.level,
|
||||
@@ -2884,6 +2887,7 @@ impl Game<'_> {
|
||||
|
||||
fn tick_remote_level(&mut self) -> Result<()> {
|
||||
self.ticks += 1;
|
||||
self.track_experience_display();
|
||||
// Options.broadcastOptions: a changed render distance is sent again.
|
||||
let view = client_view_distance(self.settings.render_distance);
|
||||
if let Some(r) = self.remote.as_mut()
|
||||
@@ -5023,6 +5027,20 @@ impl horizon_client::interaction_input::InteractionWorld for RemoteInputWorld<'_
|
||||
}
|
||||
}
|
||||
|
||||
impl Remote {
|
||||
/// The local player's profile UUID.
|
||||
pub(super) fn profile(&self) -> u128 {
|
||||
self.profile
|
||||
}
|
||||
/// The entity id of a player in the level, by profile UUID.
|
||||
pub(super) fn player_entity(&self, uuid: u128) -> Option<u32> {
|
||||
self.level_players
|
||||
.iter()
|
||||
.find(|(_, u)| **u == uuid)
|
||||
.map(|(id, _)| *id as u32)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::Game;
|
||||
|
||||
@@ -104,6 +104,7 @@ pub mod landing;
|
||||
pub mod lang;
|
||||
pub mod level_loading;
|
||||
pub mod light;
|
||||
pub mod locator_bar;
|
||||
pub mod lod;
|
||||
pub mod logging;
|
||||
pub mod menu;
|
||||
|
||||
@@ -0,0 +1,742 @@
|
||||
//! The locator bar: `ClientWaypointManager` (the waypoints the server
|
||||
//! tracks for this player, from `ClientboundTrackedWaypointPacket`),
|
||||
//! `WaypointStyleManager` (`waypoint_style/*.json`: near and far distances
|
||||
//! and the dot sprites between them) and `LocatorBar`, the contextual bar
|
||||
//! that draws a dot per waypoint within 60 degrees of the view, with an
|
||||
//! arrow when it is above or below the screen.
|
||||
use crate::hud_layout::{Blend, GuiDraw};
|
||||
use horizon_assets::animation::{AnimationClip, AnimationMetadata};
|
||||
use horizon_core::geometry::trig;
|
||||
use horizon_protocol::packets::play::{
|
||||
TrackedWaypoint, WaypointId, WaypointTarget, waypoint_operation,
|
||||
};
|
||||
use std::{borrow::Cow, collections::HashMap, fs, path::Path};
|
||||
|
||||
/// `WaypointStyle`: the sprites (under `hud/locator_bar_dot/`) from near to far.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct WaypointStyle {
|
||||
pub near_distance: i32,
|
||||
pub far_distance: i32,
|
||||
pub sprites: Vec<String>,
|
||||
}
|
||||
impl WaypointStyle {
|
||||
/// `WaypointStyleManager.MISSING`.
|
||||
fn missing() -> Self {
|
||||
Self {
|
||||
near_distance: 0,
|
||||
far_distance: 1,
|
||||
sprites: vec!["hud/locator_bar_dot/missingno".into()],
|
||||
}
|
||||
}
|
||||
/// `WaypointStyle.CODEC` and `validate`: None when the file is invalid.
|
||||
pub fn parse(json: &str) -> Option<Self> {
|
||||
let v: serde_json::Value = serde_json::from_str(json).ok()?;
|
||||
let distance = |key: &str, default: i32| match v.get(key) {
|
||||
None => Some(default),
|
||||
Some(d) => d
|
||||
.as_i64()
|
||||
.filter(|d| (0..=60_000_000).contains(d))
|
||||
.map(|d| d as i32),
|
||||
};
|
||||
let near_distance = distance("near_distance", 128)?;
|
||||
let far_distance = distance("far_distance", 332)?;
|
||||
let sprites = v
|
||||
.get("sprites")?
|
||||
.as_array()?
|
||||
.iter()
|
||||
.map(|s| {
|
||||
let id = s.as_str()?;
|
||||
let (namespace, path) = id.split_once(':').unwrap_or(("minecraft", id));
|
||||
// Sprites of the gui atlas are named by path (minecraft only).
|
||||
(namespace == "minecraft").then(|| format!("hud/locator_bar_dot/{path}"))
|
||||
})
|
||||
.collect::<Option<Vec<_>>>()?;
|
||||
(!sprites.is_empty() && near_distance > 0 && near_distance < far_distance).then_some(Self {
|
||||
near_distance,
|
||||
far_distance,
|
||||
sprites,
|
||||
})
|
||||
}
|
||||
/// `WaypointStyle.sprite`.
|
||||
pub fn sprite(&self, distance: f32) -> &str {
|
||||
let (first, last) = (&self.sprites[0], &self.sprites[self.sprites.len() - 1]);
|
||||
if distance < self.near_distance as f32 {
|
||||
return first;
|
||||
}
|
||||
if distance >= self.far_distance as f32 {
|
||||
return last;
|
||||
}
|
||||
match self.sprites.len() {
|
||||
1 => first,
|
||||
3 => &self.sprites[1],
|
||||
n => {
|
||||
let t = (distance - self.near_distance as f32)
|
||||
/ (self.far_distance - self.near_distance) as f32;
|
||||
// Mth.lerpInt(t, 1, n - 1).
|
||||
&self.sprites[(1 + (t * (n as f32 - 2.0)).floor() as i32) as usize]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An animated GUI sprite (`.png.mcmeta` animation, ticked with the GUI
|
||||
/// atlas): its image and frame sizes and the frame sequence.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SpriteFrames {
|
||||
image: [i32; 2],
|
||||
frame: [i32; 2],
|
||||
clip: AnimationClip,
|
||||
}
|
||||
impl SpriteFrames {
|
||||
/// None for a still sprite or invalid metadata.
|
||||
fn load(png: &Path) -> Option<Self> {
|
||||
let text = fs::read_to_string(png.with_extension("png.mcmeta")).ok()?;
|
||||
let meta: HashMap<String, Box<serde_json::value::RawValue>> =
|
||||
serde_json::from_str(&text).ok()?;
|
||||
let animation = AnimationMetadata::from_json(meta.get("animation")?.get()).ok()?;
|
||||
// The PNG header: width and height at bytes 16..24 of IHDR.
|
||||
let mut header = [0u8; 24];
|
||||
std::io::Read::read_exact(&mut fs::File::open(png).ok()?, &mut header).ok()?;
|
||||
let dim = |at: usize| i32::from_be_bytes(header[at..at + 4].try_into().unwrap_or_default());
|
||||
let image = [dim(16), dim(20)];
|
||||
let frame = animation.frame_size(image[0], image[1]);
|
||||
if frame[0] <= 0 || frame[1] <= 0 || image[0] % frame[0] != 0 || image[1] % frame[1] != 0 {
|
||||
return None;
|
||||
}
|
||||
let count = (image[0] / frame[0]) * (image[1] / frame[1]);
|
||||
let clip = animation.clip(count as u32).ok()??;
|
||||
Some(Self { image, frame, clip })
|
||||
}
|
||||
/// The `region` (image width, height, u, v) of the frame shown at `tick`.
|
||||
fn region(&self, tick: u64) -> [i32; 4] {
|
||||
let index = self.clip.sample(tick).frame as i32;
|
||||
let columns = self.image[0] / self.frame[0];
|
||||
[
|
||||
self.image[0],
|
||||
self.image[1],
|
||||
index % columns * self.frame[0],
|
||||
index / columns * self.frame[1],
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
/// `WaypointStyleManager`: every `assets/<namespace>/waypoint_style/*.json`,
|
||||
/// plus the animations of the bar's own sprites (the arrows blink).
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct WaypointStyles(
|
||||
HashMap<String, WaypointStyle>,
|
||||
HashMap<String, SpriteFrames>,
|
||||
);
|
||||
impl WaypointStyles {
|
||||
pub fn load(root: &Path) -> Self {
|
||||
let mut frames = HashMap::new();
|
||||
let hud = root.join("assets/minecraft/textures/gui/sprites/hud");
|
||||
let dots = fs::read_dir(hud.join("locator_bar_dot"))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.map(|e| e.path());
|
||||
let arrows = ["locator_bar_arrow_up", "locator_bar_arrow_down"]
|
||||
.map(|a| hud.join(format!("{a}.png")));
|
||||
for png in arrows.into_iter().chain(dots) {
|
||||
if png.extension().is_none_or(|e| e != "png") {
|
||||
continue;
|
||||
}
|
||||
let Some(f) = SpriteFrames::load(&png) else {
|
||||
continue;
|
||||
};
|
||||
let name = png
|
||||
.strip_prefix(hud.parent().unwrap_or(&hud))
|
||||
.map(|r| r.with_extension("").to_string_lossy().replace('\\', "/"))
|
||||
.unwrap_or_default();
|
||||
frames.insert(name, f);
|
||||
}
|
||||
let mut out = HashMap::new();
|
||||
for ns in fs::read_dir(root.join("assets"))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
{
|
||||
let namespace = ns.file_name().to_string_lossy().into_owned();
|
||||
for f in fs::read_dir(ns.path().join("waypoint_style"))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
{
|
||||
let path = f.path();
|
||||
if path.extension().is_none_or(|e| e != "json") {
|
||||
continue;
|
||||
}
|
||||
let name = path.file_stem().unwrap_or_default().to_string_lossy();
|
||||
if let Some(style) = fs::read_to_string(&path)
|
||||
.ok()
|
||||
.and_then(|t| WaypointStyle::parse(&t))
|
||||
{
|
||||
out.insert(format!("{namespace}:{name}"), style);
|
||||
} else {
|
||||
log::warn!("Horizon: invalid waypoint style {}", path.display());
|
||||
}
|
||||
}
|
||||
}
|
||||
Self(out, frames)
|
||||
}
|
||||
/// The sprite at `tick`, with its animation frame when it has one.
|
||||
fn sprite(&self, name: &str, x: i32, y: i32, w: i32, h: i32, color: u32, tick: u64) -> GuiDraw {
|
||||
let mut d = sprite(name, x, y, w, h, color);
|
||||
if let (Some(f), GuiDraw::Sprite { region, .. }) = (self.1.get(name), &mut d) {
|
||||
*region = Some(f.region(tick));
|
||||
}
|
||||
d
|
||||
}
|
||||
/// `get`: the style, or the missing one.
|
||||
pub fn get(&self, id: &str) -> Cow<'_, WaypointStyle> {
|
||||
let id = if id.contains(':') {
|
||||
Cow::Borrowed(id)
|
||||
} else {
|
||||
Cow::Owned(format!("minecraft:{id}"))
|
||||
};
|
||||
self.0
|
||||
.get(&*id)
|
||||
.map_or_else(|| Cow::Owned(WaypointStyle::missing()), Cow::Borrowed)
|
||||
}
|
||||
}
|
||||
|
||||
/// `ClientWaypointManager`: the tracked waypoints by identifier.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct ClientWaypoints {
|
||||
waypoints: Vec<TrackedWaypoint>,
|
||||
}
|
||||
impl ClientWaypoints {
|
||||
/// `ClientboundTrackedWaypointPacket.apply`.
|
||||
pub fn apply(&mut self, packet: &TrackedWaypoint) {
|
||||
let at = self.waypoints.iter().position(|w| w.id == packet.id);
|
||||
match packet.operation {
|
||||
waypoint_operation::TRACK => match at {
|
||||
Some(i) => self.waypoints[i] = packet.clone(),
|
||||
None => self.waypoints.push(packet.clone()),
|
||||
},
|
||||
waypoint_operation::UNTRACK => {
|
||||
if let Some(i) = at {
|
||||
self.waypoints.remove(i);
|
||||
}
|
||||
}
|
||||
// `TrackedWaypoint.update`: only the same kind of waypoint moves.
|
||||
_ => {
|
||||
if let Some(w) = at.map(|i| &mut self.waypoints[i]) {
|
||||
use WaypointTarget as T;
|
||||
if matches!(
|
||||
(w.target, packet.target),
|
||||
(T::Block(_), T::Block(_))
|
||||
| (T::Chunk(_), T::Chunk(_))
|
||||
| (T::Azimuth(_), T::Azimuth(_))
|
||||
) {
|
||||
w.target = packet.target;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn has_waypoints(&self) -> bool {
|
||||
!self.waypoints.is_empty()
|
||||
}
|
||||
pub fn clear(&mut self) {
|
||||
self.waypoints.clear();
|
||||
}
|
||||
}
|
||||
|
||||
/// What the locator bar needs of the camera and the world this frame.
|
||||
pub struct View<'a> {
|
||||
pub gui_width: i32,
|
||||
pub gui_height: i32,
|
||||
/// The camera entity's UUID, its block position and its position.
|
||||
pub camera_uuid: u128,
|
||||
pub camera_entity_pos: [f64; 3],
|
||||
/// `Camera.position()` and `yRot()`, `xRot()`, `getFov()` in degrees.
|
||||
pub camera_pos: [f64; 3],
|
||||
pub yaw: f32,
|
||||
pub pitch: f32,
|
||||
pub fov: f32,
|
||||
/// `Camera.getViewRotationProjectionMatrix`, applied to a point
|
||||
/// relative to the camera: normalised device coordinates.
|
||||
pub project: &'a dyn Fn([f64; 3]) -> [f64; 3],
|
||||
/// An entity with this UUID in the level: (block position, eye position).
|
||||
pub entity: &'a dyn Fn(u128) -> Option<([i32; 3], [f64; 3])>,
|
||||
pub styles: &'a WaypointStyles,
|
||||
/// Client ticks, for animated sprites.
|
||||
pub tick: u64,
|
||||
}
|
||||
|
||||
/// `TrackedWaypoint.PitchDirection`.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Pitch {
|
||||
None,
|
||||
Up,
|
||||
Down,
|
||||
}
|
||||
|
||||
/// `UUID.hashCode`.
|
||||
fn uuid_hash(uuid: u128) -> i32 {
|
||||
let hilo = (uuid >> 64) as u64 ^ uuid as u64;
|
||||
((hilo >> 32) as i32) ^ (hilo as i32)
|
||||
}
|
||||
/// `String.hashCode`.
|
||||
fn string_hash(s: &str) -> i32 {
|
||||
s.encode_utf16()
|
||||
.fold(0i32, |h, c| h.wrapping_mul(31).wrapping_add(i32::from(c)))
|
||||
}
|
||||
|
||||
/// `ARGB.setBrightness`.
|
||||
pub fn set_brightness(color: u32, brightness: f32) -> u32 {
|
||||
let [alpha, r, g, b] = color.to_be_bytes().map(i32::from);
|
||||
let max = r.max(g).max(b);
|
||||
let min = r.min(g).min(b);
|
||||
let range = (max - min) as f32;
|
||||
let saturation = if max != 0 { range / max as f32 } else { 0.0 };
|
||||
let argb =
|
||||
|r: i32, g: i32, b: i32| u32::from_be_bytes([alpha as u8, r as u8, g as u8, b as u8]);
|
||||
let round = |v: f32| (v * 255.0).round() as i32;
|
||||
if saturation == 0.0 {
|
||||
let v = round(brightness);
|
||||
return argb(v, v, v);
|
||||
}
|
||||
let (cr, cg, cb) = (
|
||||
(max - r) as f32 / range,
|
||||
(max - g) as f32 / range,
|
||||
(max - b) as f32 / range,
|
||||
);
|
||||
let mut hue = if r == max {
|
||||
cb - cg
|
||||
} else if g == max {
|
||||
2.0 + cr - cb
|
||||
} else {
|
||||
4.0 + cg - cr
|
||||
} / 6.0;
|
||||
if hue < 0.0 {
|
||||
hue += 1.0;
|
||||
}
|
||||
let segment = (hue - hue.floor()) * 6.0;
|
||||
let offset = segment - segment.floor();
|
||||
let primary = brightness * (1.0 - saturation);
|
||||
let secondary = brightness * (1.0 - saturation * offset);
|
||||
let tertiary = brightness * (1.0 - saturation * (1.0 - offset));
|
||||
let full = round(brightness);
|
||||
match segment as i32 {
|
||||
0 => argb(full, round(tertiary), round(primary)),
|
||||
1 => argb(round(secondary), full, round(primary)),
|
||||
2 => argb(round(primary), full, round(tertiary)),
|
||||
3 => argb(round(primary), round(secondary), full),
|
||||
4 => argb(round(tertiary), round(primary), full),
|
||||
5 => argb(full, round(primary), round(secondary)),
|
||||
_ => argb(r, g, b),
|
||||
}
|
||||
}
|
||||
|
||||
/// `Mth.wrapDegrees`.
|
||||
fn wrap_degrees(angle: f32) -> f32 {
|
||||
let mut a = angle % 360.0;
|
||||
if a >= 180.0 {
|
||||
a -= 360.0;
|
||||
}
|
||||
if a < -180.0 {
|
||||
a += 360.0;
|
||||
}
|
||||
a
|
||||
}
|
||||
|
||||
fn centre(v: [i32; 3]) -> [f64; 3] {
|
||||
v.map(|c| f64::from(c) + 0.5)
|
||||
}
|
||||
|
||||
impl View<'_> {
|
||||
/// `Vec3iWaypoint.position`: the tracked entity's eyes when it is within
|
||||
/// 3 blocks (Manhattan) of the waypoint, else the block's centre.
|
||||
fn block_position(&self, w: &TrackedWaypoint, v: [i32; 3]) -> [f64; 3] {
|
||||
if let WaypointId::Uuid(uuid) = w.id
|
||||
&& let Some((block, eyes)) = (self.entity)(uuid)
|
||||
{
|
||||
let manhattan: i32 = (0..3).map(|i| (block[i] - v[i]).abs()).sum();
|
||||
if manhattan <= 3 {
|
||||
return eyes;
|
||||
}
|
||||
}
|
||||
centre(v)
|
||||
}
|
||||
/// `yawAngleToCamera` of a point: `degreesDifference(camera yaw, the
|
||||
/// angle of camera - point turned clockwise by 90 degrees)`.
|
||||
fn yaw_to(&self, p: [f64; 3]) -> f64 {
|
||||
let c = self.camera_pos;
|
||||
// Vec3.rotateClockwise90: (-z, y, x).
|
||||
let (x, z) = (-(c[2] - p[2]), c[0] - p[0]);
|
||||
let angle = trig::atan2(z, x) as f32 * (180.0 / std::f32::consts::PI);
|
||||
f64::from(wrap_degrees(angle - self.yaw))
|
||||
}
|
||||
/// `ChunkPos.getMiddleBlockPosition(y)`'s centre.
|
||||
fn chunk_middle(chunk: [i32; 2], y: i32) -> [f64; 3] {
|
||||
centre([chunk[0] * 16 + 8, y, chunk[1] * 16 + 8])
|
||||
}
|
||||
fn yaw_angle(&self, w: &TrackedWaypoint) -> f64 {
|
||||
match w.target {
|
||||
WaypointTarget::Empty => f64::NAN,
|
||||
WaypointTarget::Block(v) => self.yaw_to(self.block_position(w, v)),
|
||||
WaypointTarget::Chunk(c) => {
|
||||
self.yaw_to(Self::chunk_middle(c, self.camera_pos[1] as i32))
|
||||
}
|
||||
WaypointTarget::Azimuth(a) => {
|
||||
f64::from(wrap_degrees(a * (180.0 / std::f32::consts::PI) - self.yaw))
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `GameRenderer.projectHorizonToScreen`.
|
||||
fn horizon(&self) -> f64 {
|
||||
if self.pitch <= -90.0 {
|
||||
return f64::NEG_INFINITY;
|
||||
}
|
||||
if self.pitch >= 90.0 {
|
||||
return f64::INFINITY;
|
||||
}
|
||||
// Math.tan of the float products, in double.
|
||||
let rad = std::f32::consts::PI / 180.0;
|
||||
f64::from(self.pitch * rad).tan() / f64::from(self.fov / 2.0 * rad).tan()
|
||||
}
|
||||
fn pitch_direction(&self, w: &TrackedWaypoint) -> Pitch {
|
||||
let by = |y: f64| {
|
||||
if y < -1.0 {
|
||||
Pitch::Down
|
||||
} else if y > 1.0 {
|
||||
Pitch::Up
|
||||
} else {
|
||||
Pitch::None
|
||||
}
|
||||
};
|
||||
match w.target {
|
||||
WaypointTarget::Empty => Pitch::None,
|
||||
WaypointTarget::Chunk(_) | WaypointTarget::Azimuth(_) => by(self.horizon()),
|
||||
WaypointTarget::Block(v) => {
|
||||
let p = self.block_position(w, v);
|
||||
let c = self.camera_pos;
|
||||
let s = (self.project)([p[0] - c[0], p[1] - c[1], p[2] - c[2]]);
|
||||
let behind = s[2] > 1.0;
|
||||
match by(if behind { -s[1] } else { s[1] }) {
|
||||
Pitch::None if behind && s[1] > 0.0 => Pitch::Up,
|
||||
Pitch::None if behind && s[1] < 0.0 => Pitch::Down,
|
||||
p => p,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `distanceSquared` from the camera entity.
|
||||
fn distance_sq(&self, w: &TrackedWaypoint) -> f64 {
|
||||
let e = self.camera_entity_pos;
|
||||
let d = |p: [f64; 3]| (0..3).map(|i| (p[i] - e[i]).powi(2)).sum::<f64>();
|
||||
match w.target {
|
||||
WaypointTarget::Block(v) => d(centre(v)),
|
||||
WaypointTarget::Chunk(c) => d(Self::chunk_middle(c, e[1].floor() as i32)),
|
||||
WaypointTarget::Empty | WaypointTarget::Azimuth(_) => f64::INFINITY,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `LocatorBar.extractBackground`: the nine-sliced sprite and its rectangle.
|
||||
pub fn background(gui_width: i32, gui_height: i32) -> (&'static str, [i32; 4]) {
|
||||
(
|
||||
"gui/sprites/hud/locator_bar_background",
|
||||
[gui_width / 2 - 91, gui_height - 32 + 3, 182, 5],
|
||||
)
|
||||
}
|
||||
|
||||
fn sprite(name: &str, x: i32, y: i32, w: i32, h: i32, color: u32) -> GuiDraw {
|
||||
GuiDraw::Sprite {
|
||||
sprite: Cow::Owned(name.to_owned()),
|
||||
x,
|
||||
y,
|
||||
w,
|
||||
h,
|
||||
region: None,
|
||||
color,
|
||||
blend: Blend::Textured,
|
||||
}
|
||||
}
|
||||
|
||||
impl ClientWaypoints {
|
||||
/// `LocatorBar.extractRenderState`: the farthest waypoint first.
|
||||
pub fn draw(&self, view: &View) -> Vec<GuiDraw> {
|
||||
let top = view.gui_height - 32 + 3;
|
||||
let mut sorted: Vec<(f64, &TrackedWaypoint)> = self
|
||||
.waypoints
|
||||
.iter()
|
||||
.map(|w| (view.distance_sq(w), w))
|
||||
.collect();
|
||||
sorted.sort_by(|a, b| b.0.total_cmp(&a.0));
|
||||
let mut out = Vec::new();
|
||||
for (distance_sq, w) in sorted {
|
||||
if w.id == WaypointId::Uuid(view.camera_uuid) {
|
||||
continue;
|
||||
}
|
||||
let angle = view.yaw_angle(w);
|
||||
// `!(angle <= -60) && !(angle > 60)`: NaN draws, at the centre.
|
||||
if angle <= -60.0 || angle > 60.0 {
|
||||
continue;
|
||||
}
|
||||
let middle = ((view.gui_width - 9) as f32 / 2.0).ceil() as i32;
|
||||
let style = view.styles.get(&w.style);
|
||||
let distance = (distance_sq as f32).sqrt();
|
||||
let color = w.color.map_or_else(
|
||||
|| {
|
||||
let hash = match &w.id {
|
||||
WaypointId::Uuid(u) => uuid_hash(*u),
|
||||
WaypointId::Name(n) => string_hash(n),
|
||||
};
|
||||
set_brightness(0xFF00_0000 | hash as u32, 0.9)
|
||||
},
|
||||
|c| c as u32,
|
||||
);
|
||||
let dot = (angle * 173.0 / 2.0 / 60.0).floor() as i32;
|
||||
out.push(view.styles.sprite(
|
||||
style.sprite(distance),
|
||||
middle + dot,
|
||||
top - 2,
|
||||
9,
|
||||
9,
|
||||
color,
|
||||
view.tick,
|
||||
));
|
||||
let arrow = match view.pitch_direction(w) {
|
||||
Pitch::None => continue,
|
||||
Pitch::Down => (6, "hud/locator_bar_arrow_down"),
|
||||
Pitch::Up => (-6, "hud/locator_bar_arrow_up"),
|
||||
};
|
||||
out.push(view.styles.sprite(
|
||||
arrow.1,
|
||||
middle + dot + 1,
|
||||
top + arrow.0,
|
||||
7,
|
||||
5,
|
||||
u32::MAX,
|
||||
view.tick,
|
||||
));
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
/// `Hud.ContextualInfo`: which bar sits above the hotbar.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum ContextualBar {
|
||||
Empty,
|
||||
Experience,
|
||||
Locator,
|
||||
JumpableVehicle,
|
||||
}
|
||||
impl ContextualBar {
|
||||
/// `Hud.nextContextualInfoState`: `recent_experience` is
|
||||
/// `willPrioritizeExperienceInfo` (experience changed in the last 100
|
||||
/// ticks), `jumping` is `willPrioritizeJumpInfo`.
|
||||
pub fn next(
|
||||
waypoints: bool,
|
||||
jumpable_vehicle: bool,
|
||||
jumping: bool,
|
||||
has_experience: bool,
|
||||
recent_experience: bool,
|
||||
) -> Self {
|
||||
if waypoints {
|
||||
if jumpable_vehicle && jumping {
|
||||
Self::JumpableVehicle
|
||||
} else if has_experience && recent_experience {
|
||||
Self::Experience
|
||||
} else {
|
||||
Self::Locator
|
||||
}
|
||||
} else if jumpable_vehicle {
|
||||
Self::JumpableVehicle
|
||||
} else if has_experience {
|
||||
Self::Experience
|
||||
} else {
|
||||
Self::Empty
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn tracked(operation: i32, id: u128, target: WaypointTarget) -> TrackedWaypoint {
|
||||
TrackedWaypoint {
|
||||
operation,
|
||||
id: WaypointId::Uuid(id),
|
||||
style: "minecraft:default".into(),
|
||||
color: None,
|
||||
target,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn styles_pick_sprites_by_distance() {
|
||||
let default = WaypointStyle::parse(
|
||||
r#"{"sprites":["minecraft:default_0","minecraft:default_1","minecraft:default_2","minecraft:default_3"]}"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!((default.near_distance, default.far_distance), (128, 332));
|
||||
assert_eq!(default.sprite(10.0), "hud/locator_bar_dot/default_0");
|
||||
assert_eq!(default.sprite(128.0), "hud/locator_bar_dot/default_1");
|
||||
// lerpInt((d - 128) / 204, 1, 3): halfway is the third sprite.
|
||||
assert_eq!(default.sprite(229.0), "hud/locator_bar_dot/default_1");
|
||||
assert_eq!(default.sprite(230.0), "hud/locator_bar_dot/default_2");
|
||||
assert_eq!(default.sprite(332.0), "hud/locator_bar_dot/default_3");
|
||||
let bowtie = WaypointStyle::parse(
|
||||
r#"{"near_distance":64,"sprites":["minecraft:bowtie","minecraft:default_0","minecraft:default_1","minecraft:default_2","minecraft:default_3"]}"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(bowtie.sprite(63.0), "hud/locator_bar_dot/bowtie");
|
||||
// lerpInt((d - 64) / 268, 1, 4).
|
||||
assert_eq!(bowtie.sprite(64.0), "hud/locator_bar_dot/default_0");
|
||||
assert_eq!(bowtie.sprite(200.0), "hud/locator_bar_dot/default_1");
|
||||
assert_eq!(bowtie.sprite(300.0), "hud/locator_bar_dot/default_2");
|
||||
// Three sprites: the middle one between near and far.
|
||||
let three = WaypointStyle::parse(r#"{"sprites":["a","b","c"]}"#).unwrap();
|
||||
assert_eq!(three.sprite(200.0), "hud/locator_bar_dot/b");
|
||||
// validate: sprites, near > 0, far > near.
|
||||
assert!(WaypointStyle::parse(r#"{"sprites":[]}"#).is_none());
|
||||
assert!(WaypointStyle::parse(r#"{"near_distance":0,"sprites":["a"]}"#).is_none());
|
||||
assert!(WaypointStyle::parse(r#"{"near_distance":400,"sprites":["a"]}"#).is_none());
|
||||
assert_eq!(
|
||||
WaypointStyles::default().get("minecraft:none").sprite(5.0),
|
||||
"hud/locator_bar_dot/missingno"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn packets_track_update_and_untrack() {
|
||||
let mut w = ClientWaypoints::default();
|
||||
w.apply(&tracked(
|
||||
waypoint_operation::TRACK,
|
||||
1,
|
||||
WaypointTarget::Block([1, 2, 3]),
|
||||
));
|
||||
assert!(w.has_waypoints());
|
||||
w.apply(&tracked(
|
||||
waypoint_operation::UPDATE,
|
||||
1,
|
||||
WaypointTarget::Block([4, 5, 6]),
|
||||
));
|
||||
assert_eq!(w.waypoints[0].target, WaypointTarget::Block([4, 5, 6]));
|
||||
// Another kind of waypoint doesn't update it.
|
||||
w.apply(&tracked(
|
||||
waypoint_operation::UPDATE,
|
||||
1,
|
||||
WaypointTarget::Azimuth(1.0),
|
||||
));
|
||||
assert_eq!(w.waypoints[0].target, WaypointTarget::Block([4, 5, 6]));
|
||||
w.apply(&tracked(
|
||||
waypoint_operation::UNTRACK,
|
||||
1,
|
||||
WaypointTarget::Empty,
|
||||
));
|
||||
assert!(!w.has_waypoints());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn brightness_like_argb() {
|
||||
// Pure red at 0.9: Math.round(0.9 * 255) = 230.
|
||||
assert_eq!(set_brightness(0xFFFF_0000, 0.9), 0xFFE6_0000);
|
||||
assert_eq!(set_brightness(0xFF80_8080, 0.9), 0xFFE6_E6E6);
|
||||
assert_eq!(uuid_hash(0x0000_0001_0000_0000_0000_0000_0000_0002), 3);
|
||||
assert_eq!(string_hash("ab"), 97 * 31 + 98);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn arrows_blink_through_their_frames() {
|
||||
// locator_bar_arrow_up.png.mcmeta: 7x10, two 5-pixel frames.
|
||||
let meta = r#"{"frames":[{"index":0,"time":10},{"index":1,"time":4}],"height":5}"#;
|
||||
let animation = AnimationMetadata::from_json(meta).unwrap();
|
||||
let frames = SpriteFrames {
|
||||
image: [7, 10],
|
||||
frame: animation.frame_size(7, 10),
|
||||
clip: animation.clip(2).unwrap().unwrap(),
|
||||
};
|
||||
assert_eq!(frames.region(0), [7, 10, 0, 0]);
|
||||
assert_eq!(frames.region(9), [7, 10, 0, 0]);
|
||||
assert_eq!(frames.region(10), [7, 10, 0, 5]);
|
||||
assert_eq!(frames.region(14), [7, 10, 0, 0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dots_sit_on_the_bar_by_angle() {
|
||||
let styles = WaypointStyles(
|
||||
[(
|
||||
"minecraft:default".to_owned(),
|
||||
WaypointStyle {
|
||||
near_distance: 128,
|
||||
far_distance: 332,
|
||||
sprites: vec!["hud/locator_bar_dot/default_0".into()],
|
||||
},
|
||||
)]
|
||||
.into(),
|
||||
HashMap::new(),
|
||||
);
|
||||
let project = |p: [f64; 3]| [p[0], p[1], 0.5];
|
||||
let entity = |_: u128| None;
|
||||
let view = View {
|
||||
gui_width: 427,
|
||||
gui_height: 240,
|
||||
camera_uuid: 9,
|
||||
camera_entity_pos: [0.5, 64.0, 0.5],
|
||||
camera_pos: [0.5, 65.62, 0.5],
|
||||
yaw: 0.0,
|
||||
pitch: 0.0,
|
||||
fov: 70.0,
|
||||
project: &project,
|
||||
entity: &entity,
|
||||
styles: &styles,
|
||||
tick: 0,
|
||||
};
|
||||
let mut w = ClientWaypoints::default();
|
||||
// Yaw 0 looks towards +z: a waypoint straight ahead sits in the middle.
|
||||
w.apply(&tracked(
|
||||
waypoint_operation::TRACK,
|
||||
1,
|
||||
WaypointTarget::Block([0, 65, 40]),
|
||||
));
|
||||
// One behind the camera and the camera's own waypoint are not drawn.
|
||||
w.apply(&tracked(
|
||||
waypoint_operation::TRACK,
|
||||
2,
|
||||
WaypointTarget::Block([0, 65, -40]),
|
||||
));
|
||||
w.apply(&tracked(
|
||||
waypoint_operation::TRACK,
|
||||
9,
|
||||
WaypointTarget::Block([0, 65, 40]),
|
||||
));
|
||||
let draws = w.draw(&view);
|
||||
assert_eq!(draws.len(), 1);
|
||||
let GuiDraw::Sprite { x, y, .. } = draws[0] else {
|
||||
panic!("{draws:?}");
|
||||
};
|
||||
assert_eq!((x, y), (209, 209));
|
||||
// 30 degrees to the right: floor(30 * 173 / 120) = 43 pixels.
|
||||
let east = ClientWaypoints {
|
||||
waypoints: vec![tracked(
|
||||
waypoint_operation::TRACK,
|
||||
3,
|
||||
WaypointTarget::Azimuth(30f32.to_radians()),
|
||||
)],
|
||||
};
|
||||
let GuiDraw::Sprite { x, .. } = east.draw(&view)[0] else {
|
||||
panic!();
|
||||
};
|
||||
assert_eq!(x, 209 + 43);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn contextual_bar_priorities() {
|
||||
use ContextualBar as B;
|
||||
assert_eq!(B::next(true, false, false, true, false), B::Locator);
|
||||
assert_eq!(B::next(true, false, false, true, true), B::Experience);
|
||||
assert_eq!(B::next(true, true, true, true, true), B::JumpableVehicle);
|
||||
assert_eq!(B::next(false, false, false, true, true), B::Experience);
|
||||
assert_eq!(B::next(false, false, false, false, false), B::Empty);
|
||||
// Creative players see the bar too.
|
||||
assert_eq!(B::next(true, false, false, false, false), B::Locator);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user