Merge branch 'parity/tablist-border' into parity-base

# Conflicts:
#	README.md
#	crates/horizon-client/src/lib.rs
#	docs/rust-parity.md
This commit is contained in:
Ludovic Marie
2026-10-12 17:50:31 +02:00
22 changed files with 3208 additions and 65 deletions
+3 -3
View File
@@ -34,13 +34,13 @@ round-trip harness has not been rerun.
| Network protocol and multiplayer | 0.75 | Opens worlds to LAN, but hosting is not tested against a vanilla client; no dedicated server mode |
| Chunk storage and palettes | 1 | None: client and saves share paletted containers, identical to vanilla over 266 scenarios |
| Section meshing | 1 | None: 112 scenes and over a million quads identical to vanilla |
| Rendering | 0.75 | Entity models match over 150 layers; block entity renderers and HUD overlays not compared |
| Rendering | 0.75 | Entity models and the world border wall match vanilla; block entity renderers and most HUD overlays not compared |
| Lighting | 1 | None: saved and relit light matches vanilla, slabs and stairs included |
| World generation | 1 | None: 2,352 whole chunks over 225 structure sites, in all three dimensions, identical to vanilla |
| Region files and saves | 0.75 | Saves round-trip with vanilla, and worlds from 1.18.2 to 26.2 upgrade as vanilla's DataFixers do over 22 sample worlds; worlds older than 1.18.2 are not upgraded |
| Entities and physics | 0.75 | Attributes, dimensions, death loot, spawn rules and natural spawning (15,500 NaturalSpawner cases) match; AI not compared; drowned, villagers, traders and the wither unverified |
| Interaction and inventory | 1 | None: menu clicks match over 8,000 click sequences, the loom and the crafter included; recipe book placement (6,000 cases), its buttons (1,200), the saved book (1,500) and the loom and crafter screens (1,600) match vanilla |
| Menus, HUD and chat | 0.75 | Commands parse as vanilla over 39,685 inputs, but /item modify, /spectate, /waypoint and /dialog do not run; no tab list or world border rendering |
| Menus, HUD and chat | 0.75 | Commands parse as vanilla over 39,685 inputs, the player list matches over 844,758 draw calls and the world border renders as vanilla, but /item modify, /spectate, /waypoint and /dialog do not run; player list heads use default skins |
| Audio | 0.75 | Sound engine, music and ambience not compared with vanilla |
| Block behaviours and ticking | 0.75 | Block updates, random ticks, redstone, dispensers, crafters (4,000 crafts) and block entity removal (containers spill, 4,000 cases) match vanilla; the copper golem's chest-sorting AI is not compared |
@@ -50,7 +50,7 @@ round-trip harness has not been rerun.
2. Draw every item through the item model pipeline, and add the resource pack screen.
3. An audio harness: sound engine attenuation, weighted sound events, music and ambience.
4. A mob AI harness, and an oracle for drowned, villagers, traders and the wither.
5. The missing commands, the copper golem's brain (chest sorting) in the mob AI harness, the tab list and world border rendering.
5. The missing commands, the copper golem's brain (chest sorting) in the mob AI harness, and skins for player list heads.
6. Test LAN hosting with a vanilla client, and add a dedicated server mode.
```sh
@@ -0,0 +1,172 @@
//! Headless transport for the player list parity gate: builds each case's
//! scoreboard (teams, `list` objective, scores), listed players, header and
//! footer, replays its frames through `horizon_client::tab_list` and writes
//! the draw calls in vanilla's GuiGraphicsExtractor terms (text as styled
//! runs, faces as skin blits).
#![forbid(unsafe_code)]
use horizon_client::{
component,
hud::HudAtlas,
hud_layout::GuiDraw,
lang,
scoreboard::{NumberFormat, RenderType, Scoreboard},
tab_list::{self, TabInputs, TabList, TabPlayer},
text::Text,
};
use serde_json::{Value, json};
use std::{
fs,
io::{BufWriter, Write},
path::PathBuf,
};
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
fn text(v: &Value) -> Option<Text> {
(!v.is_null()).then(|| component::to_text(v, &mut |_| Text::empty()))
}
fn format(v: &Value) -> Option<NumberFormat> {
match v["type"].as_str()? {
"blank" => Some(NumberFormat::Blank),
"styled" => Some(NumberFormat::Styled(v["style"].clone())),
"fixed" => Some(NumberFormat::Fixed(v["value"].clone())),
_ => None,
}
}
fn runs(t: &Text) -> Value {
let mut out: Vec<(String, Value)> = Vec::new();
for (c, s) in t.chars() {
let key = json!([
s.color.map_or(-1, i64::from),
s.is_bold(),
s.is_italic(),
s.underlined == Some(true),
s.strikethrough == Some(true),
s.obfuscated == Some(true)
]);
match out.last_mut() {
Some((run, k)) if *k == key => run.push(c),
_ => out.push((c.to_string(), key)),
}
}
out.into_iter().map(|(r, k)| json!([r, k])).collect()
}
fn main() -> Result<()> {
let args: Vec<PathBuf> = std::env::args_os().skip(1).map(PathBuf::from).collect();
let [root, inputs, output] = args.as_slice() else {
return Err("usage: tab_list_fixture RESOURCES INPUTS OUTPUT".into());
};
let atlas = HudAtlas::build(root)?;
lang::set(lang::Language::load(&[root], "en_us"));
let font = &atlas.font;
let mut out = BufWriter::new(fs::File::create(output)?);
for line in fs::read_to_string(inputs)?
.lines()
.filter(|l| !l.is_empty())
{
let c: Value = serde_json::from_str(line)?;
let mut board = Scoreboard::default();
for t in c["teams"].as_array().into_iter().flatten() {
let name = t["name"].as_str().unwrap_or("");
let team = board.add_team(name);
team.color = t["color"].as_str().map(str::to_owned);
team.prefix = t["prefix"].clone();
team.suffix = t["suffix"].clone();
for m in t["members"].as_array().into_iter().flatten() {
board.add_to_team(m.as_str().unwrap_or(""), name);
}
}
let objective_name = c["objective"]["name"].as_str().map(str::to_owned);
if let Some(name) = &objective_name {
let hearts = c["objective"]["renderType"] == "hearts";
board.add_objective(
name,
"dummy",
Value::String("x".into()),
if hearts {
RenderType::Hearts
} else {
RenderType::Integer
},
false,
format(&c["objective"]["numberFormat"]),
);
}
let mut players = Vec::new();
let mut upside = Vec::new();
for p in c["players"].as_array().into_iter().flatten() {
let uuid =
u128::from_str_radix(&p["uuid"].as_str().unwrap_or("0").replace('-', ""), 16)?;
let name = p["name"].as_str().unwrap_or("").to_owned();
if p["inLevel"].as_bool().unwrap_or(false) && (name == "Dinnerbone" || name == "Grumm")
{
upside.push(uuid);
}
let mut player = TabPlayer::new(uuid, name);
player.game_mode = p["gameMode"].as_i64().unwrap_or(0) as i32;
player.latency = p["latency"].as_i64().unwrap_or(0) as i32;
player.display_name = (!p["displayName"].is_null()).then(|| p["displayName"].clone());
player.list_order = p["listOrder"].as_i64().unwrap_or(0) as i32;
player.show_hat = p["showHat"].as_bool().unwrap_or(true);
players.push(player);
}
let mut list = TabList::default();
list.header = text(&c["header"]);
list.footer = text(&c["footer"]);
let background = tab_list::row_background(
c["backgroundForChatOnly"].as_bool().unwrap_or(true),
c["opacity"].as_f64().unwrap_or(0.5),
);
let mut frames = Vec::new();
for f in c["frames"].as_array().into_iter().flatten() {
if let Some(obj) = &objective_name {
for (holder, v) in f["scores"].as_object().into_iter().flatten() {
let s = board.score_mut(holder, obj);
s.value = v["value"].as_i64().unwrap_or(0) as i32;
s.number_format = format(&v["format"]);
}
for r in f["reset"].as_array().into_iter().flatten() {
board.reset_one(r.as_str().unwrap_or(""), obj);
}
}
let visible = f["visible"].as_bool().unwrap_or(false);
list.set_visible(visible);
let mut draws = Vec::new();
if visible {
let up = |id: u128| upside.contains(&id);
let inputs = TabInputs {
players: &players,
board: &board,
objective: objective_name.as_deref().and_then(|n| board.objective(n)),
screen_width: c["width"].as_i64().unwrap_or(0) as i32,
online_mode: c["onlineMode"].as_bool().unwrap_or(false),
gui_ticks: f["tick"].as_i64().unwrap_or(0),
background,
upside_down: &up,
};
for d in list.layout(&inputs, font) {
draws.push(match d {
GuiDraw::Fill { x0, y0, x1, y1, color } => {
json!({"type": "fill", "x0": x0, "y0": y0, "x1": x1, "y1": y1, "color": color as i32})
}
GuiDraw::Sprite { sprite, x, y, w, h, .. } => {
json!({"type": "sprite", "sprite": sprite, "x": x, "y": y, "w": w, "h": h})
}
GuiDraw::Text { text, x, y, color, shadow } => json!({
"type": "text", "runs": runs(&text), "x": x, "y": y, "color": color as i32, "shadow": shadow
}),
GuiDraw::Blit { texture, x, y, w, h, uv, src, tex, color, .. } => {
let a = [x as f64, y as f64, f64::from(uv[0]), f64::from(uv[1]), w as f64, h as f64,
src[0] as f64, src[1] as f64, tex[0] as f64, tex[1] as f64];
json!({"type": "blit", "texture": texture, "args": a, "color": color as i32})
}
other => json!({"type": "unexpected", "draw": format!("{other:?}")}),
});
}
}
frames.push(Value::Array(draws));
}
writeln!(out, "{}", json!({ "frames": frames }))?;
}
Ok(())
}
@@ -0,0 +1,111 @@
//! Headless transport for the world border parity gate: replays each case's
//! border changes, ticks and frames through `horizon_client::worldborder`,
//! `border_render` and `hud_overlays::vignette`, and writes what the
//! vanilla renderer computes (bounds, fade, wall buffer, transforms, walls
//! drawn, vignette colour) with floats as raw bits.
#![forbid(unsafe_code)]
use horizon_client::{
border_render::{self, BorderRenderState, BorderRenderer},
hud_layout::GuiDraw,
hud_overlays,
worldborder::{BorderStatus, WorldBorder},
};
use serde_json::{Value, json};
use std::{
fs,
io::{BufWriter, Write},
};
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
fn floats(v: &[f32]) -> Value {
v.iter().map(|f| f.to_bits() as i32).collect()
}
fn doubles(v: &[f64]) -> Value {
v.iter().map(|f| f.to_bits() as i64).collect()
}
fn main() -> Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
let [inputs, output] = args.as_slice() else {
return Err("usage: world_border_render_fixture INPUTS OUTPUT".into());
};
let mut out = BufWriter::new(fs::File::create(output)?);
for line in fs::read_to_string(inputs)?
.lines()
.filter(|l| !l.is_empty())
{
let c: Value = serde_json::from_str(line)?;
let f = |v: &Value| v.as_f64().unwrap_or(0.0);
let mut border = WorldBorder::default();
border.warning_distance = c["warningBlocks"].as_i64().unwrap_or(0) as i32;
border.warning_time = c["warningTime"].as_i64().unwrap_or(0) as i32;
border.set_absolute_max_size(c["absoluteMaxSize"].as_i64().unwrap_or(0) as i32);
border.set_center([f(&c["centerX"]), f(&c["centerZ"])]);
border.set_size(f(&c["size"]));
let mut renderer = BorderRenderer::default();
let mut state = BorderRenderState::default();
let mut frames = Vec::new();
for op in c["ops"].as_array().into_iter().flatten() {
match op["op"].as_str().unwrap_or("") {
"tick" => (0..op["n"].as_i64().unwrap_or(0)).for_each(|_| border.tick()),
"lerp" => border.lerp_between(
f(&op["from"]),
f(&op["to"]),
op["ticks"].as_i64().unwrap_or(0),
),
"size" => border.set_size(f(&op["size"])),
"center" => border.set_center([f(&op["x"]), f(&op["z"])]),
"warning" => {
border.warning_distance = op["blocks"].as_i64().unwrap_or(0) as i32;
border.warning_time = op["time"].as_i64().unwrap_or(0) as i32;
}
"invalidate" => renderer.invalidate(),
"frame" => {
let partial = f(&op["partial"]) as f32;
let p = &op["camera"];
let camera = [f(&p[0]), f(&p[1]), f(&p[2])];
let distance = f(&op["renderDistance"]);
let millis = op["millis"].as_i64().unwrap_or(0);
let status = match border.status() {
BorderStatus::Growing => "GROWING",
BorderStatus::Shrinking => "SHRINKING",
BorderStatus::Stationary => "STATIONARY",
};
let mut frame = json!({
"bounds": doubles(&border.bounds_at(partial)),
"sizes": doubles(&[border.size(), border.target_size(), border.lerp_speed(), border.distance(camera[0], camera[2])]),
"lerpTime": border.remaining_ticks(),
"status": status,
});
border_render::extract(&border, partial, camera, distance, &mut state);
frame["alpha"] = doubles(&[state.alpha]);
frame["tint"] = json!(state.tint as i32);
let drawn =
renderer.prepare(&state, camera, distance, f(&op["depthFar"]) as f32);
frame["drawn"] = json!(drawn);
frame["rebuilt"] = json!(renderer.take_rebuilt());
if drawn {
frame["vertices"] = floats(&renderer.vertices.concat());
let t = renderer.transforms(&state, camera, millis);
frame["color"] = floats(&t.color);
frame["offset"] = floats(&t.model_offset);
frame["texture"] = floats(&[t.texture_offset, t.texture_offset]);
frame["sides"] = json!(BorderRenderer::sides(&state, camera, distance));
}
let warning = border.warning_strength(camera[0], camera[2]);
let vignette =
hud_overlays::vignette(427, 240, f(&op["vignette"]) as f32, warning);
let color = match vignette {
GuiDraw::Blit { color, .. } => color,
_ => 0,
};
frame["vignetteColor"] = json!(color as i32);
frames.push(frame);
}
other => return Err(format!("unknown op {other}").into()),
}
}
writeln!(out, "{}", json!({ "frames": frames }))?;
}
Ok(())
}
+32
View File
@@ -0,0 +1,32 @@
// The world border wall (core/world_border): camera-relative wall quads
// moved by the model offset, the forcefield texture scrolled by the texture
// offset and modulated by the status colour and fade.
struct Globals {
view_proj: mat4x4<f32>,
}
struct Border {
color: vec4<f32>,
// xyz: model offset, w: texture translation (u and v)
offset: vec4<f32>,
}
@group(0) @binding(0) var<uniform> globals: Globals;
@group(0) @binding(1) var forcefield: texture_2d<f32>;
@group(0) @binding(2) var forcefield_sampler: sampler;
@group(0) @binding(3) var<uniform> border: Border;
struct Out {
@builtin(position) clip: vec4<f32>,
@location(0) uv: vec2<f32>,
}
@vertex fn vs_border(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>) -> Out {
var out: Out;
out.clip = globals.view_proj * vec4(position + border.offset.xyz, 1.0);
out.uv = uv + vec2(border.offset.w);
return out;
}
@fragment fn fs_border(in: Out) -> @location(0) vec4<f32> {
let color = textureSample(forcefield, forcefield_sampler, in.uv);
if color.a == 0.0 {
discard;
}
return color * border.color;
}
+289
View File
@@ -0,0 +1,289 @@
//! The world border wall (`WorldBorderRenderer`, `WorldBorderRenderState`):
//! which border the camera is near, the wall's fade and status colour, the
//! cached vertex buffer of the four walls, the scrolling texture transform
//! and which walls are drawn. Kept free of GPU types so the parity fixture
//! can compare every value with vanilla's renderer.
use crate::worldborder::{WorldBorder, jclamp, jmax, jmin, status_color};
/// `WorldBorderRenderer.RENDERING_OFFSET`.
const OFFSET: f64 = 0.01;
/// `WorldBorderRenderState`.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct BorderRenderState {
pub min_x: f64,
pub max_x: f64,
pub min_z: f64,
pub max_z: f64,
/// `BorderStatus.getColor`, set only when the wall is visible.
pub tint: u32,
pub alpha: f64,
}
impl BorderRenderState {
/// `closestBorder`: the four walls by distance from (x, z), nearest
/// first (a stable sort of north, south, west, east), as
/// `Direction.get2DDataValue` side indices and distances.
pub fn closest_border(&self, x: f64, z: f64) -> [(usize, f64); 4] {
let mut sides = [
(2, z - self.min_z),
(0, self.max_z - z),
(1, x - self.min_x),
(3, self.max_x - x),
];
// Comparator.comparingDouble: Double.compare order, stable.
sides.sort_by(|a, b| java_double_compare(a.1, b.1));
sides
}
}
/// `Double.compare`.
fn java_double_compare(a: f64, b: f64) -> std::cmp::Ordering {
use std::cmp::Ordering::*;
if a < b {
Less
} else if a > b {
Greater
} else {
let bits = |v: f64| {
if v.is_nan() {
0x7ff8_0000_0000_0000u64 as i64
} else {
v.to_bits() as i64
}
};
bits(a).cmp(&bits(b))
}
}
/// `WorldBorderRenderer.extract`.
pub fn extract(
border: &WorldBorder,
partial: f32,
camera: [f64; 3],
render_distance: f64,
state: &mut BorderRenderState,
) {
let [min_x, min_z, max_x, max_z] = border.bounds_at(partial);
state.min_x = min_x;
state.max_x = max_x;
state.min_z = min_z;
state.max_z = max_z;
let (x, z) = (camera[0], camera[2]);
let deep_inside = x < max_x - render_distance
&& x > min_x + render_distance
&& z < max_z - render_distance
&& z > min_z + render_distance;
let far_outside = x < min_x - render_distance
|| x > max_x + render_distance
|| z < min_z - render_distance
|| z > max_z + render_distance;
if !deep_inside && !far_outside {
let alpha = 1.0 - border.distance(x, z) / render_distance;
state.alpha = jclamp(alpha.powf(4.0), 0.0, 1.0);
state.tint = status_color(border.status());
} else {
state.alpha = 0.0;
}
}
/// One `POSITION_TEX` vertex of the wall buffer: position relative to the
/// buffer origin and texture coordinates.
pub type BorderVertex = [f32; 5];
/// What `WorldBorderRenderer.prepareDynamicTransforms` writes: the colour
/// modulator, the model offset of the buffer origin from the camera and
/// the texture matrix translation (both u and v).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BorderTransforms {
pub color: [f32; 4],
pub model_offset: [f32; 3],
pub texture_offset: f32,
}
/// `WorldBorderRenderer`'s cached wall buffer.
#[derive(Clone, Debug)]
pub struct BorderRenderer {
needs_rebuild: bool,
/// Set when `prepare` rebuilt the buffer (cleared by [`Self::take_rebuilt`]).
rebuilt: bool,
last_min_x: f64,
last_min_z: f64,
last_border: [f64; 4],
/// Four quads: south, west, north, east (`get2DDataValue` order).
pub vertices: [BorderVertex; 16],
}
impl Default for BorderRenderer {
fn default() -> Self {
Self {
needs_rebuild: true,
rebuilt: false,
last_min_x: 0.0,
last_min_z: 0.0,
last_border: [0.0; 4],
vertices: [[0.0; 5]; 16],
}
}
}
/// `Mth.floor(double)`.
fn floor(v: f64) -> i32 {
let i = v as i32;
if v < f64::from(i) { i - 1 } else { i }
}
/// `Mth.ceil(double)`.
fn ceil(v: f64) -> i32 {
let i = v as i32;
if v > f64::from(i) { i + 1 } else { i }
}
/// `Mth.frac(double)`.
fn frac(v: f64) -> f64 {
v - v.floor()
}
impl BorderRenderer {
/// `invalidate`: rebuild on the next prepare (e.g. after a resource reload).
pub fn invalidate(&mut self) {
self.needs_rebuild = true;
}
/// `prepare`: rebuilds the buffer when the border moved; returns whether
/// the wall is drawn this frame.
pub fn prepare(
&mut self,
state: &BorderRenderState,
camera: [f64; 3],
render_distance: f64,
depth_far: f32,
) -> bool {
if state.alpha <= 0.0 {
return false;
}
let half_height = depth_far;
let v0 = (-frac(camera[1] * 0.5)) as f32;
let v1 = v0 + half_height;
let border = [state.min_x, state.min_z, state.max_x, state.max_z];
if self.needs_rebuild || border != self.last_border {
self.rebuild(
state,
render_distance,
camera[2],
camera[0],
half_height,
v1,
v0,
);
}
true
}
/// `rebuildWorldBorderBuffer`.
#[allow(clippy::too_many_arguments)]
fn rebuild(
&mut self,
state: &BorderRenderState,
render_distance: f64,
camera_z: f64,
camera_x: f64,
h: f32,
v1: f32,
v0: f32,
) {
let border_min_x = state.min_x + OFFSET;
let border_max_x = state.max_x - OFFSET;
let border_min_z = state.min_z + OFFSET;
let border_max_z = state.max_z - OFFSET;
let min_z = jmax(f64::from(floor(camera_z - render_distance)), border_min_z);
let max_z = jmin(f64::from(ceil(camera_z + render_distance)), border_max_z);
let u0z = (floor(min_z) & 1) as f32 * 0.5;
let u1z = (max_z - min_z) as f32 / 2.0;
let min_x = jmax(f64::from(floor(camera_x - render_distance)), border_min_x);
let max_x = jmin(f64::from(ceil(camera_x + render_distance)), border_max_x);
let u0x = (floor(min_x) & 1) as f32 * 0.5;
let u1x = (max_x - min_x) as f32 / 2.0;
let (dx, dz) = ((max_x - min_x) as f32, (max_z - min_z) as f32);
let south = (border_max_z - min_z) as f32;
let east = (border_max_x - min_x) as f32;
self.vertices = [
[0.0, -h, south, u0x, v1],
[dx, -h, south, u1x + u0x, v1],
[dx, h, south, u1x + u0x, v0],
[0.0, h, south, u0x, v0],
[0.0, -h, 0.0, u0z, v1],
[0.0, -h, dz, u1z + u0z, v1],
[0.0, h, dz, u1z + u0z, v0],
[0.0, h, 0.0, u0z, v0],
[dx, -h, 0.0, u0x, v1],
[0.0, -h, 0.0, u1x + u0x, v1],
[0.0, h, 0.0, u1x + u0x, v0],
[dx, h, 0.0, u0x, v0],
[east, -h, dz, u0z, v1],
[east, -h, 0.0, u1z + u0z, v1],
[east, h, 0.0, u1z + u0z, v0],
[east, h, dz, u0z, v0],
];
self.last_border = [state.min_x, state.min_z, state.max_x, state.max_z];
self.last_min_x = min_x;
self.last_min_z = min_z;
self.needs_rebuild = false;
self.rebuilt = true;
}
/// Whether the buffer was rebuilt since the last call (it must be
/// uploaded again).
pub fn take_rebuilt(&mut self) -> bool {
std::mem::take(&mut self.rebuilt)
}
/// `prepareDynamicTransforms` at `Util.getMillis()` = `millis`.
pub fn transforms(
&self,
state: &BorderRenderState,
camera: [f64; 3],
millis: i64,
) -> BorderTransforms {
let channel = |shift: u32| ((state.tint >> shift) & 0xFF) as f32 / 255.0;
let offset = (millis % 3000) as f32 / 3000.0;
BorderTransforms {
color: [channel(16), channel(8), channel(0), state.alpha as f32],
model_offset: [
(self.last_min_x - camera[0]) as f32,
(-camera[1]) as f32,
(self.last_min_z - camera[2]) as f32,
],
texture_offset: offset,
}
}
/// `draw`: the walls within the render distance, nearest first, as side
/// indices into [`Self::vertices`] (four vertices each).
pub fn sides(state: &BorderRenderState, camera: [f64; 3], render_distance: f64) -> Vec<usize> {
state
.closest_border(camera[0], camera[2])
.into_iter()
.filter(|&(_, d)| d < render_distance)
.map(|(side, _)| side)
.collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn near_wall_is_drawn_and_tinted() {
let mut border = WorldBorder::default();
border.set_size(100.0);
let mut state = BorderRenderState::default();
let camera = [40.0, 64.0, 0.0];
extract(&border, 0.0, camera, 128.0, &mut state);
assert!(state.alpha > 0.0);
assert_eq!(state.tint, 0x20A0FF);
let mut r = BorderRenderer::default();
assert!(r.prepare(&state, camera, 128.0, 512.0));
// East wall first (10 blocks away), then north and south, then west.
assert_eq!(
BorderRenderer::sides(&state, camera, 128.0),
vec![3, 2, 0, 1]
);
let t = r.transforms(&state, camera, 4500);
assert_eq!(t.texture_offset, 0.5);
// Far inside a huge border, nothing is drawn.
border.set_size(10_000.0);
extract(&border, 0.0, camera, 128.0, &mut state);
assert_eq!(state.alpha, 0.0);
assert!(!r.prepare(&state, camera, 128.0, 512.0));
}
}
+55
View File
@@ -536,6 +536,8 @@ pub struct Resources {
names: Names,
/// clouds.png: (width, height, filled cells).
clouds: (u32, u32, Vec<bool>),
/// misc/forcefield.png: (width, height, RGBA) for the world border wall.
forcefield: (u32, u32, Vec<u8>),
context: Arc<WorkerContext>,
threads: usize,
player_arm: Option<horizon_client::mobs::Part>,
@@ -786,6 +788,11 @@ struct Game<'a> {
exec: commands::execute::ExecState,
rand_sequences: horizon_client::random_sequences::RandomSequences,
border: horizon_client::worldborder::WorldBorder,
/// `WorldBorderRenderer` and its render state.
border_renderer: horizon_client::border_render::BorderRenderer,
border_state: horizon_client::border_render::BorderRenderState,
/// `Hud.tabList`: the player list's header, footer and heart states.
tab_list: horizon_client::tab_list::TabList,
subtitles: subtitle_hud::SubtitleState,
adv: advancements::AdvState,
stats_ui: stats_screen::StatsUi,
@@ -3146,6 +3153,7 @@ impl Game<'_> {
batch.text(atlas, text, (w - tw) / 2.0, h - 59.0, u32::MAX, true);
}
self.draw_chat(&mut batch);
self.draw_tab_list(&mut batch);
match self.screen {
Screen::Paused => self.draw_pause_menu(&mut batch),
Screen::Dead => self.draw_death_screen(&mut batch),
@@ -7189,6 +7197,9 @@ impl Game<'_> {
(c & 255) as f32 / 255.0,
]
};
let border = (!title)
.then(|| self.border_draw(camera.to_array(), alpha as f32))
.flatten();
let frame = Frame {
camera,
yaw,
@@ -7226,6 +7237,7 @@ impl Game<'_> {
celestial: &celestial,
hand: &hand,
screen: &screen,
border,
game_time: self.world.game_time as f32,
shader_game_time: ((self.world.game_time % 24000) as f32 + alpha as f32) / 24000.0,
end_portal_sprites: ["environment/end_sky", "entity/end_portal/end_portal"].map(|n| {
@@ -7242,6 +7254,39 @@ impl Game<'_> {
};
self.renderer.as_mut().ok_or("renderer")?.render(&frame)
}
/// `LevelExtractor` / `LevelRenderer`: the world border wall this frame.
fn border_draw(
&mut self,
camera: [f64; 3],
partial: f32,
) -> Option<horizon_client::gfx::BorderDraw> {
use horizon_client::border_render::{self, BorderRenderer};
let distance = f64::from(self.streaming.radius * 16);
border_render::extract(
&self.border,
partial,
camera,
distance,
&mut self.border_state,
);
// Camera.depthFar, as the renderer's far plane.
let depth_far = (distance as f32 * 4.0).max(1024.0);
if !self
.border_renderer
.prepare(&self.border_state, camera, distance, depth_far)
{
return None;
}
let millis = self.started.elapsed().as_millis() as i64;
Some(horizon_client::gfx::BorderDraw {
vertices: self.border_renderer.vertices,
rebuilt: self.border_renderer.take_rebuilt(),
transforms: self
.border_renderer
.transforms(&self.border_state, camera, millis),
sides: BorderRenderer::sides(&self.border_state, camera, distance),
})
}
/// A key press while a world is open (keyboard or control socket).
fn key_pressed(&mut self, key: KeyCode) -> Result<()> {
if self.remote.is_some() && self.remote_key(key)? {
@@ -7474,6 +7519,7 @@ impl ApplicationHandler for Game<'_> {
self.res.atlas.width,
self.res.atlas.height,
),
(&self.res.forcefield.2, self.res.forcefield.0),
)) {
Ok(r) => self.renderer = Some(r),
Err(e) => {
@@ -8088,6 +8134,12 @@ pub fn run() -> Result<()> {
)
})
.unwrap_or((1, 1, vec![false])),
forcefield: horizon_client::hud::decode(
&root.join("assets/minecraft/textures/misc/forcefield.png"),
)
.ok()
.filter(|(w, h, _)| w == h && w.is_power_of_two())
.unwrap_or((1, 1, vec![0; 4])),
mob_types: MobTypes::load(&root)?
.types
.into_iter()
@@ -8300,6 +8352,9 @@ pub fn run() -> Result<()> {
exec: Default::default(),
rand_sequences: Default::default(),
border: Default::default(),
border_renderer: Default::default(),
border_state: Default::default(),
tab_list: Default::default(),
subtitles: Default::default(),
adv: Default::default(),
stats_ui: Default::default(),
@@ -345,7 +345,7 @@ impl Game<'_> {
.position_arg(ctx, "pos")
.unwrap_or_else(|| self.source_position());
let (x, z) = (p[0], p[2]);
if self.border.center == [x, z] {
if self.border.center() == [x, z] {
return Err(err("commands.worldborder.center.failed", &[]));
}
if x.abs() > 2.999_998_4e7 || z.abs() > 2.999_998_4e7 {
@@ -354,7 +354,7 @@ impl Game<'_> {
&[&"2.9999984E7"],
));
}
self.border.center = [x, z];
self.border.set_center([x, z]);
self.feedback(Text::translate(
"commands.worldborder.center.success",
&[Text::literal(float2(x)), Text::literal(float2(z))],
+248 -1
View File
@@ -102,6 +102,16 @@ pub(super) struct Remote {
pub chat_input: Option<String>,
action_bar: Option<(String, Instant)>,
players: HashMap<u128, String>,
/// `ClientPacketListener.playerInfoMap` as player-list entries, and
/// which of them are listed.
tab_players: HashMap<u128, horizon_client::tab_list::TabPlayer>,
listed: std::collections::HashSet<u128>,
/// `ClientboundLoginPacket.onlineMode`: the player list shows heads.
online_mode: bool,
/// Player entities in the level: entity id to profile UUID.
level_players: HashMap<i32, u128>,
/// The local player's profile UUID (always in the level).
profile: u128,
destroying: Option<([i32; 3], u8, f32)>,
destroy_delay: u32,
placing: Option<([i32; 3], u64)>,
@@ -126,6 +136,16 @@ fn face_direction(face: [i32; 3]) -> u8 {
}
}
/// A protocol number format as the scoreboard's.
fn number_format(f: &play::NumberFormat) -> horizon_client::scoreboard::NumberFormat {
use horizon_client::scoreboard::{NumberFormat, tag_to_json};
match f {
play::NumberFormat::Blank => NumberFormat::Blank,
play::NumberFormat::Styled(t) => NumberFormat::Styled(tag_to_json(t)),
play::NumberFormat::Fixed(t) => NumberFormat::Fixed(tag_to_json(t)),
}
}
impl Game<'_> {
/// Leave the title for a server (ConnectScreen): an empty world fed by the connection.
pub(super) fn connect_server(&mut self, address: &str, name: &str) -> Result<()> {
@@ -213,6 +233,11 @@ impl Game<'_> {
chat_input: None,
action_bar: None,
players: HashMap::new(),
tab_players: HashMap::new(),
listed: Default::default(),
online_mode: false,
level_players: HashMap::new(),
profile: 0,
destroying: None,
destroy_delay: 0,
placing: None,
@@ -231,6 +256,8 @@ impl Game<'_> {
if let Some(mut r) = self.remote.take() {
r.session.disconnect();
}
self.tab_list.reset();
self.score.board = Default::default();
self.streaming = Streaming::new(Arc::new(NoTerrain), self.res.context.clone(), 1);
self.streaming.paused = true;
self.world = World::new(self.res.facts.air, 0);
@@ -238,6 +265,9 @@ impl Game<'_> {
self.mobs.clear();
self.dropped.clear();
self.particles.clear();
self.score.board = Default::default();
self.tab_list = Default::default();
self.border = Default::default();
self.screen = Screen::Playing;
self.container = None;
if let Some(r) = self.renderer.as_mut() {
@@ -323,11 +353,14 @@ impl Game<'_> {
}
}
Event::Joined {
registries, name, ..
registries,
name,
uuid,
} => {
self.set_registries(registries);
if let Some(r) = self.remote.as_mut() {
r.joined = true;
r.profile = uuid;
r.status = format!("Joined as {name}; loading terrain...");
}
}
@@ -662,6 +695,7 @@ impl Game<'_> {
match packet {
C::Login(p) => {
if let Some(r) = self.remote.as_mut() {
r.online_mode = p.online_mode;
r.entity_id = p.player_id;
r.view_distance = p.chunk_radius;
}
@@ -797,10 +831,20 @@ impl Game<'_> {
.unwrap_or_default();
let yaw = horizon_protocol::buf::unpack_degrees(p.yaw);
let head = horizon_protocol::buf::unpack_degrees(p.head_yaw);
if let Some(r) = self.remote.as_mut() {
if kind == "minecraft:player" {
r.level_players.insert(p.id, p.uuid);
} else {
r.level_players.remove(&p.id);
}
}
self.spawn_entity(p.id, &kind, p.position, yaw, head);
}
C::RemoveEntities(p) => {
for id in p.ids {
if let Some(r) = self.remote.as_mut() {
r.level_players.remove(&id);
}
self.remove_entity(id);
}
}
@@ -1068,7 +1112,45 @@ impl Game<'_> {
}
C::PlayerInfoUpdate(p) => {
if let Some(r) = self.remote.as_mut() {
// handlePlayerInfoUpdate: new entries first, then every
// action on every known entry.
if p.actions & 1 != 0 {
for e in &p.entries {
if let Some(name) = &e.name {
r.tab_players.entry(e.uuid).or_insert_with(|| {
horizon_client::tab_list::TabPlayer::new(e.uuid, name.clone())
});
}
}
}
for e in p.entries {
if let Some(t) = r.tab_players.get_mut(&e.uuid) {
if let Some(mode) = e.game_mode {
t.game_mode = mode;
}
if let Some(latency) = e.latency {
t.latency = latency;
}
if let Some(name) = &e.display_name {
t.display_name =
name.as_ref().map(horizon_client::scoreboard::tag_to_json);
}
if let Some(order) = e.list_order {
t.list_order = order;
}
if let Some(hat) = e.show_hat {
t.show_hat = hat;
}
match e.listed {
Some(true) => {
r.listed.insert(e.uuid);
}
Some(false) => {
r.listed.remove(&e.uuid);
}
None => {}
}
}
if let Some(name) = e.name {
r.players.insert(e.uuid, name);
}
@@ -1079,9 +1161,74 @@ impl Game<'_> {
if let Some(r) = self.remote.as_mut() {
for u in p.uuids {
r.players.remove(&u);
r.tab_players.remove(&u);
r.listed.remove(&u);
}
}
}
C::TabList(p) => {
// handleTabListCustomisation: empty text clears it.
let text = |t: &Tag| {
let json = horizon_client::scoreboard::tag_to_json(t);
let text = horizon_client::scoreboard::comp_text(&json);
(!text.plain().is_empty()).then_some(text)
};
self.tab_list.header = text(&p.header);
self.tab_list.footer = text(&p.footer);
}
C::InitializeBorder(p) => {
let b = &mut self.border;
b.set_center([p.center_x, p.center_z]);
if p.lerp_time > 0 {
b.lerp_between(p.old_size, p.new_size, p.lerp_time);
} else {
b.set_size(p.new_size);
}
b.set_absolute_max_size(p.absolute_max_size);
b.warning_distance = p.warning_blocks;
b.warning_time = p.warning_time;
}
C::SetBorderCenter(p) => self.border.set_center([p.x, p.z]),
C::SetBorderLerpSize(p) => {
self.border
.lerp_between(p.old_size, p.new_size, p.lerp_time)
}
C::SetBorderSize(p) => self.border.set_size(p.size),
C::SetBorderWarningDelay(p) => self.border.warning_time = p.delay,
C::SetBorderWarningDistance(p) => self.border.warning_distance = p.blocks,
C::SetObjective(p) => self.remote_objective(p),
C::SetDisplayObjective(p) => {
// DisplaySlot ids: list, sidebar, below_name, then the team sidebars.
let slot = match p.slot {
0 => "list".to_owned(),
2 => "below_name".to_owned(),
n @ 3..=18 => format!(
"sidebar.team.{}",
horizon_client::text::COLORS[(n - 3) as usize].1
),
_ => "sidebar".to_owned(),
};
let board = &mut self.score.board;
let objective = board.objective(&p.objective).map(|o| o.name.clone());
board.set_display_objective(&slot, objective.as_deref());
}
C::SetScore(p) => {
let board = &mut self.score.board;
if board.objective(&p.objective).is_some() {
let s = board.score_mut(&p.owner, &p.objective);
s.value = p.score;
s.display = p
.display
.as_ref()
.map(horizon_client::scoreboard::tag_to_json);
s.number_format = p.number_format.as_ref().map(number_format);
}
}
C::ResetScore(p) => match &p.objective {
Some(o) => self.score.board.reset_one(&p.owner, o),
None => self.score.board.reset_all(&p.owner),
},
C::SetPlayerTeam(p) => self.remote_team(p),
C::SetChunkCacheRadius(p) => {
self.streaming.radius = self.settings.render_distance.min(p.distance + 1).max(2);
if let Some(r) = self.remote.as_mut() {
@@ -1103,6 +1250,104 @@ impl Game<'_> {
}
Ok(())
}
/// `handleAddObjective`: add, remove or change an objective.
fn remote_objective(&mut self, p: play::SetObjective) {
use horizon_client::scoreboard::{RenderType, tag_to_json};
let board = &mut self.score.board;
match (p.method, p.display) {
(1, _) => board.remove_objective(&p.name),
(method, Some((name, render, format))) => {
let render = if render == 1 {
RenderType::Hearts
} else {
RenderType::Integer
};
let format = format.as_ref().map(number_format);
if method == 0 {
board.add_objective(
&p.name,
"dummy",
tag_to_json(&name),
render,
false,
format,
);
} else if let Some(o) = board.objective_mut(&p.name) {
o.display_name = tag_to_json(&name);
o.render_type = render;
o.number_format = format;
}
}
_ => {}
}
}
/// `handleSetPlayerTeamPacket`.
fn remote_team(&mut self, p: play::SetPlayerTeam) {
use horizon_client::scoreboard::{CollisionRule, Visibility, tag_to_json};
let board = &mut self.score.board;
if p.method == 1 {
board.remove_team(&p.name);
return;
}
if p.method == 0 {
board.add_team(&p.name);
}
if let Some(params) = &p.parameters
&& let Some(team) = board.team_mut(&p.name)
{
team.display_name = tag_to_json(&params.display_name);
team.prefix = tag_to_json(&params.prefix);
team.suffix = tag_to_json(&params.suffix);
team.color = params
.color
.and_then(|c| horizon_client::text::COLORS.get(c as usize))
.map(|c| c.1.to_owned());
team.allow_friendly_fire = params.options & 1 != 0;
team.see_friendly_invisibles = params.options & 2 != 0;
team.nametag_visibility = Visibility::ALL
.get(params.name_tag_visibility as usize)
.copied()
.unwrap_or(Visibility::Always);
team.collision_rule = CollisionRule::ALL
.get(params.collision_rule as usize)
.copied()
.unwrap_or(CollisionRule::Always);
}
match p.method {
0 | 3 => {
for player in &p.players {
board.add_to_team(player, &p.name);
}
}
4 => {
for player in &p.players {
board.remove_from_team(player);
}
}
_ => {}
}
}
/// The player list's view of the connection: the listed players, online
/// mode, and which players are in the level with an upside-down name.
pub(super) fn remote_tab_players(
&self,
) -> Option<(Vec<horizon_client::tab_list::TabPlayer>, bool, Vec<u128>)> {
let r = self.remote.as_ref()?;
let players: Vec<_> = r
.listed
.iter()
.filter_map(|u| r.tab_players.get(u).cloned())
.collect();
let upside_down = players
.iter()
.filter(|p| {
(p.name == "Dinnerbone" || p.name == "Grumm")
&& (p.uuid == r.profile || r.level_players.values().any(|u| *u == p.uuid))
})
.map(|p| p.uuid)
.collect();
Some((players, r.online_mode, upside_down))
}
/// ChatType decoration: `chat.translation_key` with sender/content parameters.
fn format_chat(&self, bound: &play::ChatTypeBound, content: &str) -> String {
let Some(r) = self.remote.as_ref() else {
@@ -1266,6 +1511,8 @@ impl Game<'_> {
if self.use_delay > 0 {
self.use_delay -= 1;
}
// ClientLevel.tick: the border's size change.
self.border.tick();
self.tick_remote_entities();
self.tick_hand();
self.tick_particles();
@@ -147,10 +147,10 @@ impl Game<'_> {
// drawn on the HUD by draw_spyglass.
let fx = &self.res.screen_fx;
let overlays = hud_overlays::CameraOverlays {
vignette: self
.settings
.vignette
.then_some((fx.vignette_brightness, 0.0)),
vignette: self.settings.vignette.then_some((
fx.vignette_brightness,
self.border.warning_strength(p.position.x, p.position.z),
)),
first_person: self.camera_type.first_person(),
scoping: self.scoping(),
game_time_delta: 0.0,
@@ -579,6 +579,62 @@ impl Game<'_> {
}
}
impl Game<'_> {
/// `Hud.extractTabList`: the player list while the player-list key is
/// held. A single-player world lists only its player, so it shows only
/// with a `list` objective.
pub(super) fn draw_tab_list(&mut self, batch: &mut HudBatch) {
use horizon_client::tab_list::{self, TabInputs, TabPlayer};
let chatting = self.remote.is_some() && self.remote_chat_open();
let key = self.screen == super::Screen::Playing
&& !chatting
&& self.keys.contains(&winit::keyboard::KeyCode::Tab);
let (players, online_mode, upside_down) = match self.remote_tab_players() {
Some(remote) => remote,
None => {
// The integrated server: the local player, online mode, no ping.
let uuid = self.level.player_uuid.map_or(0, |u| {
u.iter()
.fold(0u128, |a, &w| (a << 32) | u128::from(w as u32))
});
let mut me = TabPlayer::new(uuid, PLAYER_NAME);
me.game_mode = self.mode_id();
me.skin = "entity/player/wide/steve".into();
(vec![me], true, Vec::new())
}
};
let board = &self.score.board;
let objective = board.display_objective(sb::SLOT_LIST);
let shown = tab_list::visible(
key,
self.remote.is_none(),
players.len(),
objective.is_some(),
);
self.tab_list.set_visible(shown);
if !shown {
return;
}
let up = |id: u128| upside_down.contains(&id);
let inputs = TabInputs {
players: &players,
board,
objective,
screen_width: batch.width as i32,
online_mode,
gui_ticks: self.ticks as i64,
// Horizon has no "chat background only" option: vanilla's default (on).
background: tab_list::row_background(
true,
f64::from(self.settings.text_background_opacity),
),
upside_down: &up,
};
let draws = self.tab_list.layout(&inputs, &self.res.atlas.font);
horizon_client::hud_layout::paint(batch, &self.res.atlas, &draws);
}
}
/// The commands' view of the game.
struct GameEnv<'a, 'b> {
g: &'a mut Game<'b>,
+230
View File
@@ -80,6 +80,8 @@ pub struct Frame<'a> {
pub hand: &'a [Vertex],
/// Full-screen camera effects drawn over the world and hand, under the HUD.
pub screen: &'a [crate::screen_effects::ScreenQuad],
/// The world border wall, when near enough to be drawn.
pub border: Option<BorderDraw>,
pub game_time: f32,
/// `GlobalSettingsUniform` GameTime: (game time % 24000 + partial tick) / 24000.
pub shader_game_time: f32,
@@ -95,6 +97,22 @@ pub struct Frame<'a> {
/// Torch flicker added to the block light factor of 1.4.
pub block_flicker: f32,
}
/// One frame of the world border wall (`WorldBorderRenderer.render`).
#[derive(Clone, Debug)]
pub struct BorderDraw {
/// The cached wall buffer; uploaded only when `rebuilt`.
pub vertices: [crate::border_render::BorderVertex; 16],
pub rebuilt: bool,
pub transforms: crate::border_render::BorderTransforms,
/// Walls to draw (indices of four-vertex quads), nearest first.
pub sides: Vec<usize>,
}
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct BorderUniform {
color: [f32; 4],
offset: [f32; 4],
}
pub struct Renderer {
instance: wgpu::Instance,
surface: wgpu::Surface<'static>,
@@ -111,6 +129,11 @@ pub struct Renderer {
additive_pipeline: wgpu::RenderPipeline,
celestial_pipeline: wgpu::RenderPipeline,
celestial_buffer: wgpu::Buffer,
/// `RenderPipelines.WORLD_BORDER` and its buffers.
border_pipeline: wgpu::RenderPipeline,
border_group: wgpu::BindGroup,
border_uniform: wgpu::Buffer,
border_vertices: wgpu::Buffer,
/// Screen effects: alpha-blended and vignette (`dst * (1 - src)`) pipelines.
screen_pipelines: [wgpu::RenderPipeline; 2],
screen_buffer: wgpu::Buffer,
@@ -199,6 +222,7 @@ impl Renderer {
layers: u32,
animations: &[SpriteAnimation],
hud_atlas: (&[u8], u32, u32),
forcefield: (&[u8], u32),
) -> Result<Self> {
let instance =
wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env());
@@ -773,6 +797,175 @@ impl Renderer {
multiview_mask: None,
cache: None,
});
// WorldBorderRenderer: misc/forcefield.png as a MipmappedTexture
// (repeat, linear minification with mipmaps, nearest magnification).
let (forcefield_pixels, forcefield_size) = forcefield;
let (forcefield_mips, forcefield_levels) = mip_chain(forcefield_pixels, forcefield_size, 1);
let forcefield_texture = device.create_texture_with_data(
&queue,
&wgpu::TextureDescriptor {
label: Some("Forcefield"),
size: wgpu::Extent3d {
width: forcefield_size,
height: forcefield_size,
depth_or_array_layers: 1,
},
mip_level_count: forcefield_levels,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&forcefield_mips,
);
let forcefield_view = forcefield_texture.create_view(&Default::default());
let forcefield_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Forcefield"),
address_mode_u: wgpu::AddressMode::Repeat,
address_mode_v: wgpu::AddressMode::Repeat,
min_filter: wgpu::FilterMode::Linear,
mag_filter: wgpu::FilterMode::Nearest,
mipmap_filter: wgpu::MipmapFilterMode::Linear,
..Default::default()
});
let border_uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("World border"),
size: std::mem::size_of::<BorderUniform>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let border_vertices = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("World border vertices"),
size: 16 * std::mem::size_of::<crate::border_render::BorderVertex>() as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let border_bindings = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("World border bindings"),
entries: &[
entry(
0,
vf,
wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
),
entry(
1,
vf,
wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
),
entry(
2,
vf,
wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
),
entry(
3,
vf,
wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
),
],
});
let border_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("World border resources"),
layout: &border_bindings,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: globals.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&forcefield_view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&forcefield_sampler),
},
wgpu::BindGroupEntry {
binding: 3,
resource: border_uniform.as_entire_binding(),
},
],
});
let border_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("World border layout"),
bind_group_layouts: &[Some(&border_bindings)],
..Default::default()
});
let border_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Horizon world border"),
source: wgpu::ShaderSource::Wgsl(include_str!("border.wgsl").into()),
});
let border_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2];
// RenderPipelines.WORLD_BORDER: BlendFunction.OVERLAY, no culling,
// depth writes with a polygon offset of 3 towards the camera.
let border_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("World border"),
layout: Some(&border_layout),
vertex: wgpu::VertexState {
module: &border_shader,
entry_point: Some("vs_border"),
compilation_options: Default::default(),
buffers: &[Some(wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<crate::border_render::BorderVertex>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &border_attributes,
})],
},
primitive: wgpu::PrimitiveState {
cull_mode: None,
..Default::default()
},
depth_stencil: Some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: Some(true),
depth_compare: Some(wgpu::CompareFunction::LessEqual),
stencil: Default::default(),
bias: wgpu::DepthBiasState {
constant: -3,
slope_scale: -3.0,
clamp: 0.0,
},
}),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &border_shader,
entry_point: Some("fs_border"),
compilation_options: Default::default(),
targets: &[Some(wgpu::ColorTargetState {
format: config.format.remove_srgb_suffix(),
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::One,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::Zero,
operation: wgpu::BlendOperation::Add,
},
}),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
multiview_mask: None,
cache: None,
});
let screen_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Horizon screen effects"),
source: wgpu::ShaderSource::Wgsl(include_str!("screen.wgsl").into()),
@@ -864,6 +1057,10 @@ impl Renderer {
additive_pipeline,
celestial_pipeline,
celestial_buffer,
border_pipeline,
border_group,
border_uniform,
border_vertices,
screen_pipelines,
screen_buffer,
screen_capacity,
@@ -1432,6 +1629,27 @@ impl Renderer {
self.index_quads = (entity_quads + additive_quads + hand_quads).next_power_of_two();
self.indices = Self::quad_indices(&self.device, self.index_quads);
}
if let Some(b) = &frame.border {
if b.rebuilt {
self.queue.write_buffer(
&self.border_vertices,
0,
bytemuck::cast_slice(&b.vertices),
);
}
let t = &b.transforms;
let uniform = BorderUniform {
color: t.color,
offset: [
t.model_offset[0],
t.model_offset[1],
t.model_offset[2],
t.texture_offset,
],
};
self.queue
.write_buffer(&self.border_uniform, 0, bytemuck::bytes_of(&uniform));
}
let view_target = surface_frame
.texture
.create_view(&wgpu::TextureViewDescriptor {
@@ -1548,6 +1766,18 @@ impl Renderer {
i as u32..i as u32 + 1,
);
}
// LevelRenderer: the world border after translucent terrain and weather.
if let Some(b) = frame.border.as_ref().filter(|_| !frame.title) {
pass.set_pipeline(&self.border_pipeline);
pass.set_bind_group(0, &self.border_group, &[]);
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
pass.set_vertex_buffer(0, self.border_vertices.slice(..));
for &side in &b.sides {
let first = side as u32 * 6;
pass.draw_indexed(first..first + 6, 0, 0..1);
}
pass.set_bind_group(0, &self.group, &[]);
}
}
if hand_quads > 0 {
let attachments = [Some(wgpu::RenderPassColorAttachment {
+2
View File
@@ -17,6 +17,7 @@ pub mod block_entity_nbt;
pub mod block_entity_render;
pub mod block_transform;
pub mod blocks;
pub mod border_render;
pub mod bossbar;
pub mod brewing;
pub mod camera;
@@ -101,6 +102,7 @@ pub mod stations;
pub mod stopwatches;
pub mod streaming;
pub mod structure_blocks;
pub mod tab_list;
pub mod testgen;
pub mod text;
pub mod title;
+637
View File
@@ -0,0 +1,637 @@
//! The player list shown while the player-list key is held
//! (`PlayerTabOverlay`, `Hud.extractTabList`): listed players sorted by list
//! order, spectators last, team and name; columns of at most 20 rows; heads,
//! names (team prefix and colour, italic spectators), ping bars and the
//! `list` objective (integer scores in their number format, or hearts that
//! blink when they change); the header and footer. Laid out as draw calls so
//! the parity fixture can compare them with the vanilla client.
use crate::{
font::Font,
hud_layout::{Blend, GuiDraw, WHITE},
java_text::float_to_string,
scoreboard::{Comp, NumberFormat, Objective, RenderType, Scoreboard, comp_text},
text::Text,
};
use std::{borrow::Cow, cmp::Ordering, collections::HashMap};
/// `GameType.SPECTATOR` id.
pub const SPECTATOR: i32 = 3;
/// `PlayerTabOverlay.MAX_ROWS_PER_COL`.
pub const MAX_ROWS_PER_COL: i32 = 20;
/// One `PlayerInfo` the list can show.
#[derive(Clone, Debug, PartialEq)]
pub struct TabPlayer {
pub uuid: u128,
/// `GameProfile.name`: the score holder and team member name.
pub name: String,
/// `GameType` id (0 survival, 1 creative, 2 adventure, 3 spectator).
pub game_mode: i32,
/// Milliseconds; negative when unknown.
pub latency: i32,
/// `tabListDisplayName` as a component (its root style matters: a
/// spectator's name is made italic at the root).
pub display_name: Option<Comp>,
pub list_order: i32,
pub show_hat: bool,
/// Skin texture path, e.g. `entity/player/wide/steve`.
pub skin: String,
}
impl TabPlayer {
/// A player with the default skin for their UUID.
pub fn new(uuid: u128, name: impl Into<String>) -> Self {
Self {
uuid,
name: name.into(),
game_mode: 0,
latency: 0,
display_name: None,
list_order: 0,
show_hat: true,
skin: default_skin(uuid).to_owned(),
}
}
}
/// `DefaultPlayerSkin.get(UUID)`: the default skin by `UUID.hashCode`.
pub fn default_skin(uuid: u128) -> &'static str {
const SKINS: [&str; 18] = [
"entity/player/slim/alex",
"entity/player/slim/ari",
"entity/player/slim/efe",
"entity/player/slim/kai",
"entity/player/slim/makena",
"entity/player/slim/noor",
"entity/player/slim/steve",
"entity/player/slim/sunny",
"entity/player/slim/zuri",
"entity/player/wide/alex",
"entity/player/wide/ari",
"entity/player/wide/efe",
"entity/player/wide/kai",
"entity/player/wide/makena",
"entity/player/wide/noor",
"entity/player/wide/steve",
"entity/player/wide/sunny",
"entity/player/wide/zuri",
];
let hilo = ((uuid >> 64) as u64) ^ (uuid as u64);
let hash = ((hilo >> 32) as i32) ^ (hilo as i32);
SKINS[hash.rem_euclid(SKINS.len() as i32) as usize]
}
/// `blitSprite(sprite, x, y, w, h)`.
fn sprite(name: &'static str, x: i32, y: i32, w: i32, h: i32) -> GuiDraw {
GuiDraw::Sprite {
sprite: Cow::Borrowed(name),
x,
y,
w,
h,
region: None,
color: WHITE,
}
}
/// `PlayerFaceExtractor.extractRenderState`: the skin's face, then its hat
/// layer, upside down for Dinnerbone and Grumm.
fn face(out: &mut Vec<GuiDraw>, skin: &str, x: i32, y: i32, size: i32, hat: bool, flip: bool) {
let (v, height) = if flip { (16.0, -8) } else { (8.0, 8) };
for u in [8.0, 40.0].into_iter().take(if hat { 2 } else { 1 }) {
out.push(GuiDraw::Blit {
texture: Cow::Owned(skin.to_owned()),
blend: Blend::Textured,
x,
y,
w: size,
h: size,
uv: [u, v],
src: [8, height],
tex: [64, 64],
color: WHITE,
});
}
}
/// `Hud.extractTabList`: whether the list shows. A single-player world
/// shows it only with another listed player or a `list` objective.
pub fn visible(key_down: bool, local_server: bool, listed: usize, objective: bool) -> bool {
key_down && !(local_server && listed <= 1 && !objective)
}
/// `Options.getBackgroundColor(553648127)`: the row background.
pub fn row_background(background_for_chat_only: bool, text_background_opacity: f64) -> u32 {
if background_for_chat_only {
0x20FF_FFFF
} else {
((text_background_opacity as f32 * 255.0).floor() as i32 as u32 & 0xFF) << 24
}
}
/// `String.compareTo`: UTF-16 code unit order.
fn compare_utf16(a: &str, b: &str) -> Ordering {
a.encode_utf16().cmp(b.encode_utf16())
}
/// `String.compareToIgnoreCase` (per code point: upper then lower case).
fn compare_ignore_case(a: &str, b: &str) -> Ordering {
fn simple(c: char, upper: bool) -> char {
let mut it: Box<dyn Iterator<Item = char>> = if upper {
Box::new(c.to_uppercase())
} else {
Box::new(c.to_lowercase())
};
match (it.next(), it.next()) {
(Some(m), None) => m,
_ => c,
}
}
let (mut x, mut y) = (a.chars(), b.chars());
loop {
match (x.next(), y.next()) {
(Some(c1), Some(c2)) => {
if c1 != c2 {
let (u1, u2) = (simple(c1, true), simple(c2, true));
if u1 != u2 {
let (l1, l2) = (simple(u1, false), simple(u2, false));
if l1 != l2 {
return l1.cmp(&l2);
}
}
}
}
(None, None) => return Ordering::Equal,
(None, Some(_)) => return Ordering::Less,
(Some(_), None) => return Ordering::Greater,
}
}
}
/// `PlayerTabOverlay.getPlayerInfos`: `PLAYER_COMPARATOR` order (higher
/// list order first, spectators last, team name, profile name ignoring
/// case), at most 80 players.
pub fn sorted_players<'a>(players: &'a [TabPlayer], board: &Scoreboard) -> Vec<&'a TabPlayer> {
let team = |p: &TabPlayer| {
board
.players_team(&p.name)
.map_or("", |t| t.name.as_str())
.to_owned()
};
let mut out: Vec<&TabPlayer> = players.iter().collect();
out.sort_by(|a, b| {
a.list_order
.wrapping_neg()
.cmp(&b.list_order.wrapping_neg())
.then_with(|| (a.game_mode == SPECTATOR).cmp(&(b.game_mode == SPECTATOR)))
.then_with(|| compare_utf16(&team(a), &team(b)))
.then_with(|| compare_ignore_case(&a.name, &b.name))
});
out.truncate(80);
out
}
/// `MutableComponent.withStyle(ITALIC)` on a component's root.
fn italic_root(c: &Comp) -> Comp {
use serde_json::Value;
match c {
Value::Object(o) => {
let mut o = o.clone();
o.insert("italic".into(), Value::Bool(true));
Value::Object(o)
}
// A list is its first element with the rest as its siblings.
Value::Array(list) if !list.is_empty() => {
let mut list = list.clone();
list[0] = italic_root(&list[0]);
Value::Array(list)
}
Value::Array(_) => serde_json::json!({"text": "", "italic": true}),
other => {
let text = match other {
Value::String(s) => s.clone(),
Value::Null => String::new(),
v => v.to_string(),
};
serde_json::json!({"text": text, "italic": true})
}
}
}
/// `PlayerTabOverlay.getNameForDisplay`.
pub fn name_for_display(p: &TabPlayer, board: &Scoreboard) -> Text {
let spectator = p.game_mode == SPECTATOR;
let name = match &p.display_name {
Some(d) if spectator => return comp_text(&italic_root(d)),
Some(d) => return comp_text(d),
None => match board.players_team(&p.name) {
Some(team) => team.formatted_name(Text::literal(p.name.clone())),
None => Text::literal(p.name.clone()),
},
};
if spectator { name.italic() } else { name }
}
/// `PlayerTabOverlay.extractPingIcon`'s sprite.
pub fn ping_sprite(latency: i32) -> &'static str {
match latency {
i32::MIN..=-1 => "icon/ping_unknown",
0..150 => "icon/ping_5",
150..300 => "icon/ping_4",
300..600 => "icon/ping_3",
600..1000 => "icon/ping_2",
_ => "icon/ping_1",
}
}
/// `PlayerTabOverlay.HealthState`: the hearts of one player.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct HealthState {
last_value: i32,
displayed_value: i32,
last_update_tick: i64,
blink_until_tick: i64,
}
impl HealthState {
fn new(value: i32) -> Self {
Self {
last_value: value,
displayed_value: value,
last_update_tick: 0,
blink_until_tick: 0,
}
}
fn update(&mut self, value: i32, tick: i64) {
if value != self.last_value {
let duration = if value < self.last_value { 20 } else { 10 };
self.blink_until_tick = tick + duration;
self.last_value = value;
self.last_update_tick = tick;
}
if tick - self.last_update_tick > 20 {
self.displayed_value = value;
}
}
fn is_blinking(&self, tick: i64) -> bool {
self.blink_until_tick > tick && (self.blink_until_tick - tick) % 6 >= 3
}
}
/// What the list is drawn from this frame.
pub struct TabInputs<'a> {
/// The listed players (`getListedOnlinePlayers`), in any order.
pub players: &'a [TabPlayer],
pub board: &'a Scoreboard,
/// The objective in the `list` display slot.
pub objective: Option<&'a Objective>,
pub screen_width: i32,
/// `ClientPacketListener.onlineMode`: heads are shown.
pub online_mode: bool,
/// `Hud.getGuiTicks`.
pub gui_ticks: i64,
/// [`row_background`].
pub background: u32,
/// The player is in the level with an upside-down name
/// (`AvatarRenderer.isPlayerUpsideDown`).
pub upside_down: &'a dyn Fn(u128) -> bool,
}
/// `PlayerTabOverlay`: the header, footer, visibility and heart states.
#[derive(Clone, Debug, Default)]
pub struct TabList {
pub header: Option<Text>,
pub footer: Option<Text>,
visible: bool,
health: HashMap<u128, HealthState>,
}
struct Entry {
name: Text,
score: i32,
formatted: Option<Text>,
score_width: i32,
}
impl TabList {
/// `setVisible`: showing or hiding forgets the heart states.
pub fn set_visible(&mut self, visible: bool) {
if self.visible != visible {
self.health.clear();
self.visible = visible;
}
}
pub fn is_visible(&self) -> bool {
self.visible
}
/// `reset`.
pub fn reset(&mut self) {
self.header = None;
self.footer = None;
}
/// `extractRenderState`.
pub fn layout(&mut self, i: &TabInputs, font: &Font) -> Vec<GuiDraw> {
let width = |t: &Text| font.width_text(t) as i32;
let players = sorted_players(i.players, i.board);
let spacer = font.width(" ") as i32;
let mut max_name = 0;
let mut max_score = 0;
let mut entries = Vec::with_capacity(players.len());
for p in &players {
let name = name_for_display(p, i.board).resolve_legacy();
max_name = max_name.max(width(&name));
let mut entry = Entry {
name,
score: 0,
formatted: None,
score_width: 0,
};
if let Some(objective) = i.objective {
let info = i.board.score(&p.name, &objective.name);
if let Some(s) = info {
entry.score = s.value;
}
if objective.render_type != RenderType::Hearts {
if let Some(s) = info {
let default =
objective.format_or_default(NumberFormat::player_list_default());
let text = s
.number_format
.as_ref()
.unwrap_or(&default)
.format(s.value)
.resolve_legacy();
entry.score_width = width(&text);
entry.formatted = Some(text);
}
let w = if entry.score_width > 0 {
spacer + entry.score_width
} else {
0
};
max_score = max_score.max(w);
}
}
entries.push(entry);
}
if !self.health.is_empty() {
self.health
.retain(|id, _| players.iter().any(|p| p.uuid == *id));
}
let slots = players.len() as i32;
let mut rows = slots;
let mut cols = 1;
while rows > MAX_ROWS_PER_COL {
cols += 1;
rows = (slots + cols - 1) / cols;
}
let show_head = i.online_mode;
let width_for_score = match i.objective {
Some(o) if o.render_type == RenderType::Hearts => 90,
Some(_) => max_score,
None => 0,
};
let sw = i.screen_width;
let head = if show_head { 9 } else { 0 };
let slot_width = (cols * (head + max_name + width_for_score + 13)).min(sw - 50) / cols;
let xxo = sw / 2 - (slot_width * cols + (cols - 1) * 5) / 2;
let mut yyo = 10;
let mut max_line = slot_width * cols + (cols - 1) * 5;
let split = |t: &Option<Text>| {
t.as_ref().map(|t| {
font.split_lines(&t.resolve_legacy(), (sw - 50) as f32)
.into_iter()
.map(|(line, _)| line)
.collect::<Vec<_>>()
})
};
let header = split(&self.header);
let footer = split(&self.footer);
for line in header.iter().chain(footer.iter()).flatten() {
max_line = max_line.max(width(line));
}
let mut out = Vec::new();
let band = |y0: i32, y1: i32| GuiDraw::Fill {
x0: sw / 2 - max_line / 2 - 1,
y0,
x1: sw / 2 + max_line / 2 + 1,
y1,
color: 0x8000_0000,
};
if let Some(lines) = &header {
out.push(band(yyo - 1, yyo + lines.len() as i32 * 9));
for line in lines {
let w = width(line);
out.push(GuiDraw::Text {
text: line.clone(),
x: sw / 2 - w / 2,
y: yyo,
color: 0xFFFF_FFFF,
shadow: true,
});
yyo += 9;
}
yyo += 1;
}
out.push(band(yyo - 1, yyo + rows * 9));
for (n, (p, entry)) in players.iter().zip(&entries).enumerate() {
let n = n as i32;
let (col, row) = (n / rows, n % rows);
let mut xo = xxo + col * slot_width + col * 5;
let yo = yyo + row * 9;
out.push(GuiDraw::Fill {
x0: xo,
y0: yo,
x1: xo + slot_width,
y1: yo + 8,
color: i.background,
});
if show_head {
face(
&mut out,
&p.skin,
xo,
yo,
8,
p.show_hat,
(i.upside_down)(p.uuid),
);
xo += 9;
}
let spectator = p.game_mode == SPECTATOR;
out.push(GuiDraw::Text {
text: entry.name.clone(),
x: xo,
y: yo,
color: if spectator { 0x90FF_FFFF } else { 0xFFFF_FFFF },
shadow: true,
});
if let Some(objective) = i.objective.filter(|_| !spectator) {
let left = xo + max_name + 1;
let right = left + width_for_score;
if right - left > 5 {
if objective.render_type == RenderType::Hearts {
self.hearts(
yo,
left,
right,
p.uuid,
entry.score,
i.gui_ticks,
font,
&mut out,
);
} else if let Some(text) = &entry.formatted {
out.push(GuiDraw::Text {
text: text.clone(),
x: right - entry.score_width,
y: yo,
color: 0xFFFF_FFFF,
shadow: true,
});
}
}
}
out.push(sprite(
ping_sprite(p.latency),
xo - head + slot_width - 11,
yo,
10,
8,
));
}
if let Some(lines) = &footer {
yyo += rows * 9 + 1;
out.push(band(yyo - 1, yyo + lines.len() as i32 * 9));
for line in lines {
let w = width(line);
out.push(GuiDraw::Text {
text: line.clone(),
x: sw / 2 - w / 2,
y: yyo,
color: 0xFFFF_FFFF,
shadow: true,
});
yyo += 9;
}
}
out
}
/// `extractTablistHearts`.
#[allow(clippy::too_many_arguments)]
fn hearts(
&mut self,
yo: i32,
left: i32,
right: i32,
id: u128,
score: i32,
tick: i64,
font: &Font,
out: &mut Vec<GuiDraw>,
) {
let health = self
.health
.entry(id)
.or_insert_with(|| HealthState::new(score));
health.update(score, tick);
let displayed = health.displayed_value;
let blink = health.is_blinking(tick);
// Mth.positiveCeilDiv.
let full_hearts = -((-score.max(displayed)).div_euclid(2));
let to_render = score.max(displayed.max(20)) / 2;
if full_hearts <= 0 {
return;
}
let per_heart = ((right - left - 4) as f32 / to_render as f32)
.min(9.0)
.floor() as i32;
if per_heart <= 3 {
let pct = (score as f32 / 20.0).clamp(0.0, 1.0);
let color = (((1.0 - pct) * 255.0) as i32) << 16 | ((pct * 255.0) as i32) << 8;
let hearts = score as f32 / 2.0;
let hp = Text::translate(
"multiplayer.player.list.hp",
&[Text::literal(float_to_string(hearts))],
);
let text = if right - font.width_text(&hp) as i32 >= left {
hp
} else {
Text::literal(float_to_string(hearts))
};
let w = font.width_text(&text) as i32;
out.push(GuiDraw::Text {
text,
x: (right + left - w) / 2,
y: yo,
color: color as u32 | 0xFF00_0000,
shadow: true,
});
return;
}
let container = if blink {
"hud/heart/container_blinking"
} else {
"hud/heart/container"
};
let heart = |name: &'static str, n: i32| sprite(name, left + n * per_heart, yo, 9, 9);
for n in full_hearts..to_render {
out.push(heart(container, n));
}
for n in 0..full_hearts {
out.push(heart(container, n));
if blink {
if n * 2 + 1 < displayed {
out.push(heart("hud/heart/full_blinking", n));
}
if n * 2 + 1 == displayed {
out.push(heart("hud/heart/half_blinking", n));
}
}
if n * 2 + 1 < score {
out.push(heart(
if n >= 10 {
"hud/heart/absorbing_full_blinking"
} else {
"hud/heart/full"
},
n,
));
}
if n * 2 + 1 == score {
out.push(heart(
if n >= 10 {
"hud/heart/absorbing_half_blinking"
} else {
"hud/heart/half"
},
n,
));
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn order_ping_and_skins() {
let board = Scoreboard::default();
let mut a = TabPlayer::new(1, "bob");
let mut b = TabPlayer::new(2, "Alice");
let c = TabPlayer::new(3, "carl");
a.game_mode = SPECTATOR;
b.list_order = -1;
let players = [a, b, c];
let names: Vec<_> = sorted_players(&players, &board)
.iter()
.map(|p| p.name.as_str())
.collect();
assert_eq!(names, ["carl", "bob", "Alice"]);
assert_eq!(ping_sprite(-1), "icon/ping_unknown");
assert_eq!(ping_sprite(149), "icon/ping_5");
assert_eq!(ping_sprite(1000), "icon/ping_1");
// UUID.hashCode of 0 is 0: the first default skin.
assert_eq!(default_skin(0), "entity/player/slim/alex");
assert!(!visible(true, true, 1, false));
assert!(visible(true, true, 1, true));
assert!(visible(true, false, 1, false));
}
}
+63
View File
@@ -220,6 +220,69 @@ impl Text {
}
out
}
/// `StringDecomposer.iterateFormatted` on every span: legacy `§` codes
/// inside the span contents restyle what follows them (colour codes
/// clear the decorations, `§r` returns to the span's own style) and are
/// not drawn.
pub fn resolve_legacy(&self) -> Text {
if !self.spans.iter().any(|s| s.text.contains('§')) {
return self.clone();
}
let mut out = Text::default();
for span in &self.spans {
let mut style = span.style.clone();
let mut current = String::new();
let mut chars = span.text.chars();
while let Some(c) = chars.next() {
if c != '§' {
current.push(c);
continue;
}
let Some(code) = chars.next() else { break };
let code = code.to_ascii_lowercase();
let next = if let Some(c) = COLORS.iter().find(|c| c.0 == code) {
// Style.applyLegacyFormat: a colour clears the decorations.
Style {
color: Some(c.2),
bold: Some(false),
italic: Some(false),
underlined: Some(false),
strikethrough: Some(false),
obfuscated: Some(false),
..style.clone()
}
} else {
let mut s = style.clone();
match code {
'k' => s.obfuscated = Some(true),
'l' => s.bold = Some(true),
'm' => s.strikethrough = Some(true),
'n' => s.underlined = Some(true),
'o' => s.italic = Some(true),
'r' => s = span.style.clone(),
_ => {}
}
s
};
if next != style {
if !current.is_empty() {
out.spans.push(Span {
text: std::mem::take(&mut current),
style: style.clone(),
});
}
style = next;
}
}
if !current.is_empty() {
out.spans.push(Span {
text: current,
style,
});
}
}
out
}
/// Characters with their effective styles.
pub fn chars(&self) -> impl Iterator<Item = (char, &Style)> {
self.spans
+136 -54
View File
@@ -1,15 +1,55 @@
//! The world border (`WorldBorder`): its size lerp, centre, damage and
//! warning settings, and how far a point is from its edge.
//! The world border (`WorldBorder`): the extent geometry of
//! `horizon_core::geometry::border` (static or moving, with the previous size
//! for partial ticks) plus the damage and warning settings, and how strongly
//! the warning vignette shows.
use horizon_core::geometry::border::BorderGeometry;
pub use horizon_core::geometry::border::BorderStatus;
pub const MAX_SIZE: f64 = 5.999_996_8e7;
/// `WorldBorder.MAX_SIZE` (the float 5.999997E7 as a double).
pub const MAX_SIZE: f64 = 59_999_968.0;
pub const MAX_CENTER: f64 = 2.999_998_4e7;
#[derive(Clone, Debug, PartialEq)]
/// `BorderStatus.getColor`: the wall colour.
pub fn status_color(status: BorderStatus) -> u32 {
match status {
BorderStatus::Growing => 0x40FF80,
BorderStatus::Shrinking => 0xFF3030,
BorderStatus::Stationary => 0x20A0FF,
}
}
/// `Math.min(double, double)`, including the signed-zero rule.
pub(crate) fn jmin(a: f64, b: f64) -> f64 {
if a.is_nan() {
a
} else if a == 0.0 && b == 0.0 && b.is_sign_negative() {
b
} else if a <= b {
a
} else {
b
}
}
/// `Math.max(double, double)`, including the signed-zero rule.
pub(crate) fn jmax(a: f64, b: f64) -> f64 {
if a.is_nan() {
a
} else if a == 0.0 && b == 0.0 && a.is_sign_negative() {
b
} else if a >= b {
a
} else {
b
}
}
/// `Mth.clamp(double, double, double)`.
pub(crate) fn jclamp(v: f64, lo: f64, hi: f64) -> f64 {
if v < lo { lo } else { jmin(v, hi) }
}
#[derive(Clone, Debug)]
pub struct WorldBorder {
pub center: [f64; 2],
size: f64,
/// Size lerp: (from, to, ticks elapsed, ticks total).
lerp: Option<(f64, f64, i64, i64)>,
geometry: BorderGeometry,
pub damage_per_block: f64,
pub safe_zone: f64,
pub warning_distance: i32,
@@ -18,9 +58,8 @@ pub struct WorldBorder {
impl Default for WorldBorder {
fn default() -> Self {
Self {
center: [0.0, 0.0],
size: MAX_SIZE,
lerp: None,
geometry: BorderGeometry::new([0.0, 0.0], MAX_SIZE, 29_999_984)
.expect("default border"),
damage_per_block: 0.2,
safe_zone: 5.0,
warning_distance: 5,
@@ -28,62 +67,99 @@ impl Default for WorldBorder {
}
}
}
impl PartialEq for WorldBorder {
fn eq(&self, other: &Self) -> bool {
self.center() == other.center()
&& self.size() == other.size()
&& self.target_size() == other.target_size()
&& self.remaining_ticks() == other.remaining_ticks()
&& self.absolute_max_size() == other.absolute_max_size()
&& self.damage_per_block == other.damage_per_block
&& self.safe_zone == other.safe_zone
&& self.warning_distance == other.warning_distance
&& self.warning_time == other.warning_time
}
}
impl WorldBorder {
pub fn center(&self) -> [f64; 2] {
self.geometry.center()
}
/// `setCenter` (non-finite centres are ignored).
pub fn set_center(&mut self, center: [f64; 2]) {
let _ = self.geometry.set_center(center);
}
pub fn absolute_max_size(&self) -> i32 {
self.geometry.absolute_max()
}
/// `setAbsoluteMaxSize`.
pub fn set_absolute_max_size(&mut self, limit: i32) {
let _ = self.geometry.set_absolute_max(limit);
}
/// `getSize`.
pub fn size(&self) -> f64 {
match self.lerp {
Some((from, to, elapsed, total)) if total > 0 => {
from + (to - from) * elapsed as f64 / total as f64
}
_ => self.size,
}
self.geometry.size()
}
/// `getLerpTarget`.
pub fn target_size(&self) -> f64 {
self.lerp.map_or(self.size, |l| l.1)
self.geometry.lerp_target()
}
/// Ticks left in a size change (0 when none).
/// `getLerpTime`: ticks left in a size change (0 when none).
pub fn remaining_ticks(&self) -> i64 {
self.lerp.map_or(0, |(_, _, e, t)| t - e)
self.geometry.lerp_time()
}
/// `getLerpSpeed`: blocks per tick.
pub fn lerp_speed(&self) -> f64 {
self.geometry.lerp_speed()
}
/// `getStatus`.
pub fn status(&self) -> BorderStatus {
self.geometry.status()
}
pub fn set_size(&mut self, size: f64) {
self.size = size.clamp(1.0, MAX_SIZE);
self.lerp = None;
let _ = self.geometry.set_size(size.clamp(1.0, MAX_SIZE));
}
/// `lerpSizeBetween`.
/// `lerpSizeBetween(from, to, ticks)` (what the server and the border
/// packets do).
pub fn lerp_between(&mut self, from: f64, to: f64, ticks: i64) {
let _ = self.geometry.lerp_size_between(from, to, ticks);
}
/// A size change from the current size (`/worldborder set|add` with a time).
pub fn lerp_to(&mut self, to: f64, ticks: i64) {
let from = self.size();
if ticks <= 0 || (from - to).abs() < f64::EPSILON {
if ticks <= 0 {
self.set_size(to);
} else {
self.lerp = Some((from, to.clamp(1.0, MAX_SIZE), 0, ticks));
self.lerp_between(self.size(), to.clamp(1.0, MAX_SIZE), ticks);
}
}
/// `tick`.
pub fn tick(&mut self) {
if let Some((from, to, elapsed, total)) = self.lerp {
if elapsed + 1 >= total {
self.size = to;
self.lerp = None;
} else {
self.lerp = Some((from, to, elapsed + 1, total));
}
}
let _ = self.geometry.tick();
}
/// `getMinX(partial)`, `getMinZ`, `getMaxX`, `getMaxZ`.
pub fn bounds_at(&self, partial: f32) -> [f64; 4] {
self.geometry.bounds(partial)
}
/// `getMinX()` etc. (partial tick 0: the previous size while moving).
pub fn bounds(&self) -> [f64; 4] {
let half = self.size() / 2.0;
[
(self.center[0] - half).max(-MAX_CENTER),
(self.center[1] - half).max(-MAX_CENTER),
(self.center[0] + half).min(MAX_CENTER),
(self.center[1] + half).min(MAX_CENTER),
]
self.bounds_at(0.0)
}
/// `getDistanceToBorder(x, z)`: negative outside.
pub fn distance(&self, x: f64, z: f64) -> f64 {
let [min_x, min_z, max_x, max_z] = self.bounds();
(x - min_x).min(max_x - x).min(z - min_z).min(max_z - z)
self.geometry.distance_to_border(x, z)
}
pub fn contains(&self, x: f64, z: f64) -> bool {
let [min_x, min_z, max_x, max_z] = self.bounds();
x >= min_x && x < max_x && z >= min_z && z < max_z
self.geometry.is_within_bounds(x, z, 0.0)
}
/// `Hud.extractVignette`: how strongly the vignette turns red at
/// (x, z), 0 when outside the warning distance.
pub fn warning_strength(&self, x: f64, z: f64) -> f32 {
crate::hud_overlays::border_warning(
self.distance(x, z) as f32,
self.warning_distance,
self.warning_time,
self.lerp_speed(),
self.target_size() - self.size(),
)
}
/// Clamp a point so a body of half-width `half` stays inside.
pub fn clamp(&self, x: f64, z: f64, half: f64) -> [f64; 2] {
@@ -96,8 +172,8 @@ impl WorldBorder {
pub fn pack(&self) -> horizon_world::nbt::Tag {
use horizon_world::nbt::Tag;
Tag::compound([
("center_x", Tag::Double(self.center[0].to_bits())),
("center_z", Tag::Double(self.center[1].to_bits())),
("center_x", Tag::Double(self.center()[0].to_bits())),
("center_z", Tag::Double(self.center()[1].to_bits())),
("size", Tag::Double(self.size().to_bits())),
(
"damage_per_block",
@@ -120,20 +196,21 @@ impl WorldBorder {
Some(Tag::Int(v)) => *v,
_ => default,
};
let size = d("size", MAX_SIZE).clamp(1.0, MAX_SIZE);
let mut b = Self {
center: [d("center_x", 0.0), d("center_z", 0.0)],
size: d("size", MAX_SIZE).clamp(1.0, MAX_SIZE),
lerp: None,
damage_per_block: d("damage_per_block", 0.2),
safe_zone: d("safe_zone", 5.0),
warning_distance: i("warning_blocks", 5),
warning_time: i("warning_time", 300),
..Self::default()
};
b.set_center([d("center_x", 0.0), d("center_z", 0.0)]);
b.set_size(size);
if let Some(Tag::Long(t)) = tag.get("lerp_time")
&& *t > 0
{
let to = d("lerp_target", b.size);
b.lerp = Some((b.size, to.clamp(1.0, MAX_SIZE), 0, *t));
let to = d("lerp_target", size);
b.lerp_between(size, to.clamp(1.0, MAX_SIZE), *t);
}
b
}
@@ -152,11 +229,15 @@ mod tests {
assert!(b.contains(49.9, -49.9) && !b.contains(50.0, 0.0));
b.lerp_to(200.0, 10);
assert_eq!(b.size(), 100.0);
assert_eq!(b.status(), BorderStatus::Growing);
for _ in 0..5 {
b.tick();
}
assert_eq!(b.size(), 150.0);
assert_eq!(b.remaining_ticks(), 5);
// Bounds at partial tick 0 still use the previous tick's size.
assert_eq!(b.bounds()[2], 70.0);
assert_eq!(b.bounds_at(1.0)[2], 75.0);
for _ in 0..5 {
b.tick();
}
@@ -164,15 +245,16 @@ mod tests {
// An instant change and clamping a body inside.
b.lerp_to(10.0, 0);
assert_eq!(b.size(), 10.0);
assert_eq!(b.status(), BorderStatus::Stationary);
assert_eq!(b.clamp(100.0, -100.0, 0.3), [4.7, -4.7]);
b.center = [10.0, 0.0];
b.set_center([10.0, 0.0]);
assert_eq!(b.bounds(), [5.0, -5.0, 15.0, 5.0]);
}
#[test]
fn saved_form_round_trips() {
let mut b = WorldBorder::default();
b.set_size(500.0);
b.center = [3.5, -7.0];
b.set_center([3.5, -7.0]);
b.damage_per_block = 1.5;
b.warning_distance = 9;
let back = WorldBorder::unpack(&b.pack());
+5 -1
View File
@@ -24,7 +24,7 @@ pub enum BorderStatus {
Growing,
Shrinking,
}
#[derive(Clone)]
#[derive(Clone, Debug)]
enum Extent {
Static {
size: f64,
@@ -40,6 +40,7 @@ enum Extent {
previous: f64,
},
}
#[derive(Clone, Debug)]
pub struct BorderGeometry {
center: [f64; 2],
absolute_max: i32,
@@ -92,6 +93,9 @@ impl BorderGeometry {
pub fn center(&self) -> [f64; 2] {
self.center
}
pub fn absolute_max(&self) -> i32 {
self.absolute_max
}
pub fn set_center(&mut self, center: [f64; 2]) -> Result<(), BorderError> {
if !center.into_iter().all(f64::is_finite) {
return Err(BorderError::InvalidParameters);
+253
View File
@@ -582,6 +582,192 @@ packet!(
}
);
packet!(TabList { header: Tag => Nbt, footer: Tag => Nbt });
packet!(
/// ClientboundSetBorderCenterPacket.
SetBorderCenter { x: f64 => Double, z: f64 => Double }
);
packet!(
/// ClientboundSetBorderLerpSizePacket.
SetBorderLerpSize { old_size: f64 => Double, new_size: f64 => Double, lerp_time: i64 => VarLong }
);
packet!(
/// ClientboundSetBorderSizePacket.
SetBorderSize { size: f64 => Double }
);
packet!(
/// ClientboundSetBorderWarningDelayPacket (ticks).
SetBorderWarningDelay { delay: i32 => VarInt }
);
packet!(
/// ClientboundSetBorderWarningDistancePacket.
SetBorderWarningDistance { blocks: i32 => VarInt }
);
packet!(
/// ClientboundSetDisplayObjectivePacket: `DisplaySlot` id (0 list,
/// 1 sidebar, 2 below name, 3.. team sidebars) and the objective ("" clears).
SetDisplayObjective { slot: i32 => VarInt, objective: String => Str }
);
packet!(
/// ClientboundResetScorePacket: one objective, or all of them when absent.
ResetScore { owner: String => Str, objective: Option<String> => Opt<Str> }
);
/// `NumberFormatTypes.STREAM_CODEC`, by `number_format_type` registry id.
#[derive(Clone, Debug, PartialEq)]
pub enum NumberFormat {
/// 0: `minecraft:blank`.
Blank,
/// 1: `minecraft:styled`, a style compound.
Styled(Tag),
/// 2: `minecraft:fixed`, a component.
Fixed(Tag),
}
impl Codec<NumberFormat> for NumberFormat {
fn read(r: &mut Reader) -> Result<Self> {
Ok(match r.varint()? {
0 => NumberFormat::Blank,
1 => NumberFormat::Styled(r.nbt()?),
2 => NumberFormat::Fixed(r.nbt()?),
other => return Err(crate::Error::new(format!("unknown number format {other}"))),
})
}
fn write(v: &Self, w: &mut Writer) {
match v {
NumberFormat::Blank => w.varint(0),
NumberFormat::Styled(t) => {
w.varint(1);
w.nbt(t);
}
NumberFormat::Fixed(t) => {
w.varint(2);
w.nbt(t);
}
}
}
}
packet!(
/// ClientboundSetScorePacket.
SetScore {
owner: String => Str,
objective: String => Str,
score: i32 => VarInt,
display: Option<Tag> => Opt<Nbt>,
number_format: Option<NumberFormat> => Opt<NumberFormat>,
}
);
/// ClientboundSetObjectivePacket: method 0 adds, 1 removes, 2 changes;
/// adds and changes carry the display name, render type (0 integer,
/// 1 hearts) and number format.
#[derive(Clone, Debug, PartialEq)]
pub struct SetObjective {
pub name: String,
pub method: i8,
pub display: Option<(Tag, i32, Option<NumberFormat>)>,
}
impl Codec<SetObjective> for SetObjective {
fn read(r: &mut Reader) -> Result<Self> {
let name = r.string(32767)?;
let method = r.i8()?;
let display = if method == 0 || method == 2 {
Some((r.nbt()?, r.varint()?, <Opt<NumberFormat>>::read(r)?))
} else {
None
};
Ok(Self {
name,
method,
display,
})
}
fn write(v: &Self, w: &mut Writer) {
w.string(&v.name);
w.i8(v.method);
if v.method == 0 || v.method == 2 {
let (name, render, format) = v.display.clone().unwrap_or((Tag::End, 0, None));
w.nbt(&name);
w.varint(render);
<Opt<NumberFormat>>::write(&format, w);
}
}
}
/// `ClientboundSetPlayerTeamPacket.Parameters`.
#[derive(Clone, Debug, PartialEq)]
pub struct TeamParameters {
pub display_name: Tag,
pub prefix: Tag,
pub suffix: Tag,
/// `Team.Visibility` id.
pub name_tag_visibility: i32,
/// `Team.CollisionRule` id.
pub collision_rule: i32,
/// `TeamColor` id (0 black .. 15 white), absent for no colour.
pub color: Option<i32>,
/// 1: friendly fire, 2: see friendly invisibles.
pub options: i8,
}
/// ClientboundSetPlayerTeamPacket: method 0 adds (parameters and players),
/// 1 removes, 2 changes (parameters), 3 joins and 4 leaves (players).
#[derive(Clone, Debug, PartialEq)]
pub struct SetPlayerTeam {
pub name: String,
pub method: i8,
pub parameters: Option<TeamParameters>,
pub players: Vec<String>,
}
impl Codec<SetPlayerTeam> for SetPlayerTeam {
fn read(r: &mut Reader) -> Result<Self> {
let name = r.string(32767)?;
let method = r.i8()?;
let parameters = if method == 0 || method == 2 {
Some(TeamParameters {
display_name: r.nbt()?,
prefix: r.nbt()?,
suffix: r.nbt()?,
name_tag_visibility: r.varint()?,
collision_rule: r.varint()?,
color: <Opt<VarInt>>::read(r)?,
options: r.i8()?,
})
} else {
None
};
let players = if matches!(method, 0 | 3 | 4) {
<List<Str>>::read(r)?
} else {
Vec::new()
};
Ok(Self {
name,
method,
parameters,
players,
})
}
fn write(v: &Self, w: &mut Writer) {
w.string(&v.name);
w.i8(v.method);
if v.method == 0 || v.method == 2 {
let p = v.parameters.clone().unwrap_or(TeamParameters {
display_name: Tag::End,
prefix: Tag::End,
suffix: Tag::End,
name_tag_visibility: 0,
collision_rule: 0,
color: None,
options: 0,
});
w.nbt(&p.display_name);
w.nbt(&p.prefix);
w.nbt(&p.suffix);
w.varint(p.name_tag_visibility);
w.varint(p.collision_rule);
<Opt<VarInt>>::write(&p.color, w);
w.i8(p.options);
}
if matches!(v.method, 0 | 3 | 4) {
<List<Str>>::write(&v.players, w);
}
}
}
packet!(ServerData { motd: Tag => Nbt, icon: Option<Vec<u8>> => Opt<crate::buf::Bytes> });
packet!(
/// ClientboundUpdateMobEffectPacket; flags: 1 ambient, 2 visible, 4 icon, 8 blend.
@@ -746,23 +932,33 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
PlayerRotation(PlayerRotation) = PLAYER_ROTATION,
RemoveEntities(RemoveEntities) = REMOVE_ENTITIES,
RemoveMobEffect(RemoveMobEffect) = REMOVE_MOB_EFFECT,
ResetScore(ResetScore) = RESET_SCORE,
ResourcePackPush(ResourcePackPush) = RESOURCE_PACK_PUSH,
Respawn(Respawn) = RESPAWN,
RotateHead(RotateHead) = ROTATE_HEAD,
SectionBlocksUpdate(SectionBlocksUpdate) = SECTION_BLOCKS_UPDATE,
ServerData(ServerData) = SERVER_DATA,
SetActionBarText(Text) = SET_ACTION_BAR_TEXT,
SetBorderCenter(SetBorderCenter) = SET_BORDER_CENTER,
SetBorderLerpSize(SetBorderLerpSize) = SET_BORDER_LERP_SIZE,
SetBorderSize(SetBorderSize) = SET_BORDER_SIZE,
SetBorderWarningDelay(SetBorderWarningDelay) = SET_BORDER_WARNING_DELAY,
SetBorderWarningDistance(SetBorderWarningDistance) = SET_BORDER_WARNING_DISTANCE,
SetChunkCacheCenter(SetChunkCacheCenter) = SET_CHUNK_CACHE_CENTER,
SetChunkCacheRadius(Distance) = SET_CHUNK_CACHE_RADIUS,
SetCursorItem(SetCursorItem) = SET_CURSOR_ITEM,
SetDefaultSpawnPosition(SetDefaultSpawnPosition) = SET_DEFAULT_SPAWN_POSITION,
SetDisplayObjective(SetDisplayObjective) = SET_DISPLAY_OBJECTIVE,
SetEntityData(SetEntityData) = SET_ENTITY_DATA,
SetEntityMotion(SetEntityMotion) = SET_ENTITY_MOTION,
SetEquipment(SetEquipment) = SET_EQUIPMENT,
SetExperience(SetExperience) = SET_EXPERIENCE,
SetHealth(SetHealth) = SET_HEALTH,
SetHeldSlot(SetHeldSlot) = SET_HELD_SLOT,
SetObjective(SetObjective) = SET_OBJECTIVE,
SetPlayerInventory(SetPlayerInventory) = SET_PLAYER_INVENTORY,
SetPlayerTeam(SetPlayerTeam) = SET_PLAYER_TEAM,
SetScore(SetScore) = SET_SCORE,
SetSimulationDistance(Distance) = SET_SIMULATION_DISTANCE,
SetSubtitleText(Text) = SET_SUBTITLE_TEXT,
SetTime(SetTime) = SET_TIME,
@@ -948,6 +1144,63 @@ mod tests {
fn clientbound_round_trips() {
let packets = vec![
Clientbound::BundleDelimiter(Empty),
Clientbound::SetBorderCenter(SetBorderCenter { x: 1.5, z: -2.0 }),
Clientbound::SetBorderLerpSize(SetBorderLerpSize {
old_size: 10.0,
new_size: 200.0,
lerp_time: 1200,
}),
Clientbound::SetBorderSize(SetBorderSize { size: 30.0 }),
Clientbound::SetBorderWarningDelay(SetBorderWarningDelay { delay: 300 }),
Clientbound::SetBorderWarningDistance(SetBorderWarningDistance { blocks: 5 }),
Clientbound::SetDisplayObjective(SetDisplayObjective {
slot: 0,
objective: "kills".into(),
}),
Clientbound::ResetScore(ResetScore {
owner: "Steve".into(),
objective: Some("kills".into()),
}),
Clientbound::SetScore(SetScore {
owner: "Steve".into(),
objective: "kills".into(),
score: -3,
display: Some(Tag::String("S".into())),
number_format: Some(NumberFormat::Styled(Tag::compound([(
"color",
Tag::String("red".into()),
)]))),
}),
Clientbound::SetObjective(SetObjective {
name: "kills".into(),
method: 0,
display: Some((Tag::String("Kills".into()), 1, Some(NumberFormat::Blank))),
}),
Clientbound::SetObjective(SetObjective {
name: "kills".into(),
method: 1,
display: None,
}),
Clientbound::SetPlayerTeam(SetPlayerTeam {
name: "red".into(),
method: 0,
parameters: Some(TeamParameters {
display_name: Tag::String("Red".into()),
prefix: Tag::String("[R] ".into()),
suffix: Tag::String("".into()),
name_tag_visibility: 0,
collision_rule: 0,
color: Some(12),
options: 3,
}),
players: vec!["Steve".into(), "Alex".into()],
}),
Clientbound::SetPlayerTeam(SetPlayerTeam {
name: "red".into(),
method: 4,
parameters: None,
players: vec!["Alex".into()],
}),
Clientbound::AddEntity(AddEntity {
id: 5,
uuid: 9,
+43
View File
@@ -1423,3 +1423,46 @@ Not compared yet: the recipe book's own drawing (tabs, buttons, the overlay
and ghost slots) and its text search, the banner preview's 3D flag (drawn as
the flat front face), furnaces awarding their recipes and experience when
their output is taken, and the limited crafting game rule.
## Player list and world border rendering
`horizon_client::tab_list` lays out vanilla's `PlayerTabOverlay` as draw calls:
the listed players in `PLAYER_COMPARATOR` order (higher list order first,
spectators last, team name, profile name ignoring case), at most 80 of them in
columns of 20 rows; heads with the default skin for the UUID, flipped for
Dinnerbone and Grumm in the level, only in online mode; team prefix, suffix and
colour; italic, translucent spectator names (italic at the component root);
ping bars; the `list` objective as scores in their number format (the score's,
the objective's, or yellow) or as hearts with `HealthState`'s change blink and
the `hp` text when they no longer fit; and the header and footer wrapped by
`Font::split_lines`, which now follows `StringSplitter.splitLines`, with legacy
`§` codes applied by `Text::resolve_legacy`. `Hud.extractTabList`'s rule hides
the list in single player unless a `list` objective is set.
`tools/test_tab_list_parity.py` runs vanilla's own `extractRenderState` frame
after frame (`VanillaTabListOracle`: stand-in connection, level and options,
real `Scoreboard`) against `examples/tab_list_fixture` and compares every fill,
styled text run, sprite and face blit (as `hud_layout::GuiDraw` calls, painted
like the rest of the HUD): **1,000 cases, 3,476 frames and 844,758
calls match**. The game draws the same layout while the player-list key is
held, from the local player and scoreboard in single player and from
`PlayerInfoUpdate`, the tab list header and footer, `onlineMode` and the
objective, score, display-slot and team packets on a server (checked live
against the 26.3 server jar). Real skins are not downloaded: every head uses
its default skin. Horizon has no "chat background only" option, so the row
background is vanilla's default.
The client `WorldBorder` wraps `horizon_core::geometry::border` (checked by
`test_world_border_parity.py`) and `horizon_client::border_render` ports
`WorldBorderRenderer`: `extract`'s fade (`(1 - distance / render distance)^4`)
and status colour (growing, shrinking, stationary), the wall buffer that is only
rebuilt when the border moves, the model offset and the texture scroll of
`prepareDynamicTransforms`, and `draw`'s walls within the render distance,
nearest first. `WorldBorder::warning_strength` feeds `hud_overlays::vignette`
the border's warning strength at the camera. `tools/test_world_border_render_parity.py` drives vanilla's border,
renderer and vignette (`VanillaWorldBorderRenderOracle`, with a stand-in GPU
device, dynamic-uniform writer and render pass) against
`examples/world_border_render_fixture`: **1,500 cases and 16,859 frames match
bit for bit** (8,513 with the wall drawn). The game draws the wall with
`RenderPipelines.WORLD_BORDER`'s overlay blend and the mipmapped forcefield
texture, and follows the server's border packets. One border is kept for all
dimensions.
@@ -0,0 +1,283 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import com.mojang.authlib.GameProfile;
import com.mojang.renderpearl.api.pipeline.RenderPipeline;
import com.mojang.serialization.JsonOps;
import java.lang.reflect.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.client.Minecraft;
import net.minecraft.client.OptionInstance;
import net.minecraft.client.Options;
import net.minecraft.client.gui.Font;
import net.minecraft.client.gui.GuiGraphicsExtractor;
import net.minecraft.client.gui.Hud;
import net.minecraft.client.gui.components.PlayerTabOverlay;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.client.multiplayer.ClientPacketListener;
import net.minecraft.client.multiplayer.PlayerInfo;
import net.minecraft.client.player.LocalPlayer;
import net.minecraft.client.player.RemotePlayer;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.ComponentSerialization;
import net.minecraft.network.chat.Style;
import net.minecraft.network.chat.numbers.BlankFormat;
import net.minecraft.network.chat.numbers.FixedFormat;
import net.minecraft.network.chat.numbers.NumberFormat;
import net.minecraft.network.chat.numbers.StyledFormat;
import net.minecraft.resources.Identifier;
import net.minecraft.util.FormattedCharSequence;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.level.GameType;
import net.minecraft.world.scores.Objective;
import net.minecraft.world.scores.ScoreHolder;
import net.minecraft.world.scores.Scoreboard;
import net.minecraft.world.scores.TeamColor;
import net.minecraft.world.scores.criteria.ObjectiveCriteria;
/**
* Original oracle for the player list: runs vanilla's own
* PlayerTabOverlay.extractRenderState frame after frame on a stand-in client
* (Unsafe-allocated Minecraft, connection with the case's listed PlayerInfos
* and online mode, level with the case's players, real Scoreboard with the
* case's teams, list objective and scores, options and Hud ticks) and
* records every fill, text (as styled runs), sprite and face blit.
* Visibility changes clear the heart states as setVisible does (without
* the narration).
*
* Input lines: case JSON. Output lines: {case, frames:[[draws]...]} or {case, error}.
*/
public final class VanillaTabListOracle {
static Object unsafe;
static Method allocate;
static JsonArray draws;
static int width;
static Scoreboard board;
@SuppressWarnings("unchecked")
static <T> T alloc(Class<T> type) throws Exception {
return (T) allocate.invoke(unsafe, type);
}
static Field field(Class<?> type, String name) throws NoSuchFieldException {
for (Class<?> k = type; k != null; k = k.getSuperclass()) {
try {
Field f = k.getDeclaredField(name);
f.setAccessible(true);
return f;
} catch (NoSuchFieldException e) {
}
}
throw new NoSuchFieldException(name + " on " + type);
}
static void put(Object target, Class<?> owner, String name, Object value) throws Exception {
Field f = field(owner, name);
boolean isStatic = Modifier.isStatic(f.getModifiers());
long offset = isStatic
? (long) unsafe.getClass().getMethod("staticFieldOffset", Field.class).invoke(unsafe, f)
: (long) unsafe.getClass().getMethod("objectFieldOffset", Field.class).invoke(unsafe, f);
Object base = isStatic ? unsafe.getClass().getMethod("staticFieldBase", Field.class).invoke(unsafe, f) : target;
Class<?> t = f.getType();
String setter = t == int.class ? "putInt" : t == boolean.class ? "putBoolean" : t == float.class ? "putFloat"
: t == long.class ? "putLong" : t == double.class ? "putDouble" : "putObject";
Class<?> param = t.isPrimitive() ? t : Object.class;
unsafe.getClass().getMethod(setter, Object.class, long.class, param).invoke(unsafe, base, offset, value);
}
static Object get(Object target, Class<?> owner, String name) throws Exception {
return field(owner, name).get(target);
}
static Component component(JsonElement e) {
return ComponentSerialization.CODEC.parse(JsonOps.INSTANCE, e).getOrThrow();
}
static NumberFormat format(JsonElement e) {
if (e == null || e.isJsonNull()) return null;
var o = e.getAsJsonObject();
return switch (o.get("type").getAsString()) {
case "blank" -> BlankFormat.INSTANCE;
case "styled" -> new StyledFormat(Style.Serializer.CODEC.parse(JsonOps.INSTANCE, o.get("style")).getOrThrow());
case "fixed" -> new FixedFormat(component(o.get("value")));
default -> throw new IllegalArgumentException(o.toString());
};
}
/** Records GuiGraphicsExtractor calls. */
public static final class Capture extends GuiGraphicsExtractor {
private Capture() { super(null, null, 0, 0); }
@Override public int guiWidth() { return width; }
@Override public void nextStratum() { }
@Override public void fill(RenderPipeline p, int x0, int y0, int x1, int y1, int color) {
var o = new JsonObject();
o.addProperty("type", "fill");
o.addProperty("x0", x0); o.addProperty("y0", y0); o.addProperty("x1", x1); o.addProperty("y1", y1);
o.addProperty("color", color);
draws.add(o);
}
@Override public void blitSprite(RenderPipeline p, Identifier id, int x, int y, int w, int h, int color) {
var o = new JsonObject();
o.addProperty("type", "sprite");
o.addProperty("sprite", id.getPath());
o.addProperty("x", x); o.addProperty("y", y); o.addProperty("w", w); o.addProperty("h", h);
draws.add(o);
}
@Override public void blit(RenderPipeline p, Identifier texture, int x, int y, float u, float v, int w, int h, int sw, int sh, int tw, int th, int color) {
var o = new JsonObject();
o.addProperty("type", "blit");
String path = texture.getPath();
if (path.startsWith("textures/")) path = path.substring(9);
if (path.endsWith(".png")) path = path.substring(0, path.length() - 4);
o.addProperty("texture", path);
var a = new JsonArray();
for (float n : new float[] {x, y, u, v, w, h, sw, sh, tw, th}) a.add(n);
o.add("args", a);
o.addProperty("color", color);
draws.add(o);
}
@Override public void text(Font font, FormattedCharSequence str, int x, int y, int color, boolean shadow) {
var o = new JsonObject();
o.addProperty("type", "text");
var runs = new JsonArray();
str.accept((index, style, cp) -> {
var key = new JsonArray();
key.add(style.getColor() == null ? -1 : style.getColor().getValue());
key.add(style.isBold()); key.add(style.isItalic()); key.add(style.isUnderlined());
key.add(style.isStrikethrough()); key.add(style.isObfuscated());
var last = runs.isEmpty() ? null : runs.get(runs.size() - 1).getAsJsonArray();
if (last != null && last.get(1).equals(key)) {
last.set(0, new JsonPrimitive(last.get(0).getAsString() + new String(Character.toChars(cp))));
} else {
var run = new JsonArray();
run.add(new String(Character.toChars(cp)));
run.add(key);
runs.add(run);
}
return true;
});
o.add("runs", runs);
o.addProperty("x", x); o.addProperty("y", y); o.addProperty("color", color); o.addProperty("shadow", shadow);
draws.add(o);
}
}
public static void main(String[] args) throws Exception {
ParityData.init();
var unsafeField = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
unsafe = unsafeField.get(null);
allocate = unsafe.getClass().getMethod("allocateInstance", Class.class);
Font font = ParityFont.create(ParityFont.resources());
var gson = new Gson();
var out = new StringBuilder();
for (String line : Files.readAllLines(Path.of(args[0]))) {
if (line.isBlank()) continue;
JsonObject c = JsonParser.parseString(line).getAsJsonObject();
var result = new JsonObject();
result.add("case", c);
try {
width = c.get("width").getAsInt();
board = new Scoreboard();
for (var t : c.getAsJsonArray("teams")) {
var o = t.getAsJsonObject();
var team = board.addPlayerTeam(o.get("name").getAsString());
if (!o.get("color").isJsonNull()) team.setColor(Optional.of(TeamColor.byName(o.get("color").getAsString())));
team.setPlayerPrefix(component(o.get("prefix")));
team.setPlayerSuffix(component(o.get("suffix")));
for (var m : o.getAsJsonArray("members")) board.addPlayerToTeam(m.getAsString(), team);
}
Objective objective = null;
if (!c.get("objective").isJsonNull()) {
var o = c.getAsJsonObject("objective");
var type = o.get("renderType").getAsString().equals("hearts") ? ObjectiveCriteria.RenderType.HEARTS : ObjectiveCriteria.RenderType.INTEGER;
objective = board.addObjective(o.get("name").getAsString(), ObjectiveCriteria.DUMMY, Component.literal("x"), type, false, format(o.get("numberFormat")));
}
var mc = alloc(Minecraft.class);
put(null, Minecraft.class, "instance", mc);
var level = alloc(ClientLevel.class);
var levelPlayers = new ArrayList<net.minecraft.client.player.AbstractClientPlayer>();
put(level, ClientLevel.class, "players", levelPlayers);
put(mc, Minecraft.class, "level", level);
put(mc, Minecraft.class, "font", font);
var options = alloc(Options.class);
var chatOnly = alloc(OptionInstance.class);
put(chatOnly, OptionInstance.class, "value", c.get("backgroundForChatOnly").getAsBoolean());
put(options, Options.class, "backgroundForChatOnly", chatOnly);
var opacity = alloc(OptionInstance.class);
put(opacity, OptionInstance.class, "value", c.get("opacity").getAsDouble());
put(options, Options.class, "textBackgroundOpacity", opacity);
put(mc, Minecraft.class, "options", options);
var connection = alloc(ClientPacketListener.class);
put(connection, ClientPacketListener.class, "scoreboard", board);
put(level, ClientLevel.class, "connection", connection);
put(connection, ClientPacketListener.class, "onlineMode", c.get("onlineMode").getAsBoolean());
var listed = new LinkedHashSet<PlayerInfo>();
put(connection, ClientPacketListener.class, "listedPlayers", listed);
var player = alloc(LocalPlayer.class);
put(player, LocalPlayer.class, "connection", connection);
put(mc, Minecraft.class, "player", player);
for (var p : c.getAsJsonArray("players")) {
var o = p.getAsJsonObject();
var uuid = UUID.fromString(o.get("uuid").getAsString());
var profile = new GameProfile(uuid, o.get("name").getAsString());
var info = new PlayerInfo(profile, false);
put(info, PlayerInfo.class, "gameMode", GameType.byId(o.get("gameMode").getAsInt()));
put(info, PlayerInfo.class, "latency", o.get("latency").getAsInt());
if (!o.get("displayName").isJsonNull()) info.setTabListDisplayName(component(o.get("displayName")));
info.setTabListOrder(o.get("listOrder").getAsInt());
info.setShowHat(o.get("showHat").getAsBoolean());
var skin = net.minecraft.client.resources.DefaultPlayerSkin.get(uuid);
put(info, PlayerInfo.class, "skinLookup", (java.util.function.Supplier<?>) () -> skin);
listed.add(info);
if (o.get("inLevel").getAsBoolean()) {
var entity = alloc(RemotePlayer.class);
put(entity, Player.class, "gameProfile", profile);
put(entity, net.minecraft.world.entity.Entity.class, "uuid", uuid);
levelPlayers.add(entity);
}
}
var hud = alloc(Hud.class);
put(hud, Hud.class, "minecraft", mc);
var overlay = new PlayerTabOverlay(mc, hud);
if (!c.get("header").isJsonNull()) overlay.setHeader(component(c.get("header")));
if (!c.get("footer").isJsonNull()) overlay.setFooter(component(c.get("footer")));
@SuppressWarnings("unchecked")
var health = (Map<UUID, ?>) get(overlay, PlayerTabOverlay.class, "healthStates");
var capture = alloc(Capture.class);
var frames = new JsonArray();
for (var f : c.getAsJsonArray("frames")) {
var o = f.getAsJsonObject();
if (objective != null) {
for (var s : o.getAsJsonObject("scores").entrySet()) {
var v = s.getValue().getAsJsonObject();
var access = board.getOrCreatePlayerScore(ScoreHolder.forNameOnly(s.getKey()), objective);
access.set(v.get("value").getAsInt());
access.numberFormatOverride(format(v.get("format")));
}
for (var r : o.getAsJsonArray("reset")) board.resetSinglePlayerScore(ScoreHolder.forNameOnly(r.getAsString()), objective);
}
put(hud, Hud.class, "tickCount", o.get("tick").getAsInt());
boolean visible = o.get("visible").getAsBoolean();
if ((boolean) get(overlay, PlayerTabOverlay.class, "visible") != visible) {
health.clear();
put(overlay, PlayerTabOverlay.class, "visible", visible);
}
draws = new JsonArray();
if (visible) overlay.extractRenderState(capture, width, board, objective);
frames.add(draws);
}
result.add("frames", frames);
} catch (Throwable error) {
var cause = error instanceof InvocationTargetException && error.getCause() != null ? error.getCause() : error;
var sw = new java.io.StringWriter();
cause.printStackTrace(new java.io.PrintWriter(sw));
result.addProperty("error", sw.toString().lines().limit(10).reduce("", (x, y) -> x + y + " | "));
}
out.append(gson.toJson(result)).append('\n');
}
Files.writeString(Path.of(args[1]), out.toString(), StandardCharsets.UTF_8);
}
}
@@ -0,0 +1,262 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import com.mojang.blaze3d.systems.RenderSystem;
import com.mojang.renderpearl.api.buffers.GpuBuffer;
import com.mojang.renderpearl.api.commands.CommandEncoder;
import com.mojang.renderpearl.api.commands.RenderPass;
import com.mojang.renderpearl.api.device.GpuDevice;
import com.mojang.renderpearl.api.pipeline.RenderPipeline;
import java.lang.reflect.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.SharedConstants;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiGraphicsExtractor;
import net.minecraft.client.gui.Hud;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.client.renderer.DynamicGpuData;
import net.minecraft.client.renderer.WorldBorderRenderer;
import net.minecraft.client.renderer.state.level.WorldBorderRenderState;
import net.minecraft.client.renderer.texture.AbstractTexture;
import net.minecraft.client.renderer.texture.TextureManager;
import net.minecraft.resources.Identifier;
import net.minecraft.server.Bootstrap;
import net.minecraft.util.Util;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.level.border.WorldBorder;
import net.minecraft.world.phys.Vec3;
/**
* Original oracle for the world border as the client shows it: drives a
* vanilla WorldBorder through the case's size changes and ticks, then runs
* WorldBorderRenderer.extract, prepare (the wall vertex buffer, captured from
* a stand-in GPU device), prepareDynamicTransforms (captured from a
* stand-in DynamicGpuData, at a fixed Util.getMillis) and draw (the walls
* drawn, from a stand-in RenderPass), and Hud.extractVignette (the vignette
* colour) for every frame.
*
* Input lines: case JSON. Output lines: {case, frames:[...]} or {case, error}.
*/
public final class VanillaWorldBorderRenderOracle {
static Object unsafe;
static Method allocate;
static float[] lastVertices;
static boolean rebuilt;
static Object lastTransform;
static List<Integer> sides = new ArrayList<>();
static int vignetteColor;
static long millis;
@SuppressWarnings("unchecked")
static <T> T alloc(Class<T> type) throws Exception {
return (T) allocate.invoke(unsafe, type);
}
static Field field(Class<?> type, String name) throws NoSuchFieldException {
for (Class<?> k = type; k != null; k = k.getSuperclass()) {
try {
Field f = k.getDeclaredField(name);
f.setAccessible(true);
return f;
} catch (NoSuchFieldException e) {
}
}
throw new NoSuchFieldException(name + " on " + type);
}
static void put(Object target, Class<?> owner, String name, Object value) throws Exception {
Field f = field(owner, name);
boolean isStatic = Modifier.isStatic(f.getModifiers());
long offset = isStatic
? (long) unsafe.getClass().getMethod("staticFieldOffset", Field.class).invoke(unsafe, f)
: (long) unsafe.getClass().getMethod("objectFieldOffset", Field.class).invoke(unsafe, f);
Object base = isStatic ? unsafe.getClass().getMethod("staticFieldBase", Field.class).invoke(unsafe, f) : target;
Class<?> t = f.getType();
String setter = t == int.class ? "putInt" : t == boolean.class ? "putBoolean" : t == float.class ? "putFloat"
: t == long.class ? "putLong" : t == double.class ? "putDouble" : "putObject";
Class<?> param = t.isPrimitive() ? t : Object.class;
unsafe.getClass().getMethod(setter, Object.class, long.class, param).invoke(unsafe, base, offset, value);
}
static Object proxy(Class<?> type, InvocationHandler handler) {
return Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] {type}, handler);
}
static Object defaults(Object proxy, Method method, Object[] args) throws Throwable {
if (method.isDefault()) return InvocationHandler.invokeDefault(proxy, method, args);
Class<?> r = method.getReturnType();
if (r == boolean.class) return false;
if (r == int.class || r == long.class || r == short.class || r == byte.class) return r == long.class ? (Object) 0L : (Object) 0;
if (r == float.class) return 0f;
if (r == double.class) return 0.0;
return null;
}
/** Records the dynamic transform the renderer writes. */
public static final class Uniforms extends DynamicGpuData {
private Uniforms() { super(); }
@Override public com.mojang.renderpearl.api.buffers.GpuBufferSlice writeTransform(final DynamicGpuData.Transform transform) {
lastTransform = transform;
return null;
}
}
/** Records the vignette blit colour. */
public static final class Capture extends GuiGraphicsExtractor {
private Capture() { super(null, null, 0, 0); }
@Override public int guiWidth() { return 427; }
@Override public int guiHeight() { return 240; }
@Override public void blit(RenderPipeline p, Identifier texture, int x, int y, float u, float v, int w, int h, int sw, int sh, int tw, int th, int color) {
vignetteColor = color;
}
}
static JsonArray floats(float... values) {
var a = new JsonArray();
for (float v : values) a.add(Float.floatToRawIntBits(v));
return a;
}
static JsonArray doubles(double... values) {
var a = new JsonArray();
for (double v : values) a.add(Double.doubleToRawLongBits(v));
return a;
}
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();
Bootstrap.bootStrap();
var unsafeField = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
unsafe = unsafeField.get(null);
allocate = unsafe.getClass().getMethod("allocateInstance", Class.class);
RenderSystem.initRenderThread();
Util.setTimeSource(() -> millis * 1_000_000L);
CommandEncoder encoder = (CommandEncoder) proxy(CommandEncoder.class, (p, m, a) -> {
if (m.getName().equals("writeToBuffer")) {
ByteBuffer data = ((ByteBuffer) a[1]).duplicate().order(ByteOrder.nativeOrder());
float[] v = new float[data.remaining() / 4];
for (int n = 0; n < v.length; n++) v[n] = data.getFloat(data.position() + n * 4);
lastVertices = v;
rebuilt = true;
return null;
}
return defaults(p, m, a);
});
GpuDevice device = (GpuDevice) proxy(GpuDevice.class, (p, m, a) -> m.getName().equals("createCommandEncoder") ? encoder : defaults(p, m, a));
put(null, RenderSystem.class, "DEVICE", device);
put(null, RenderSystem.class, "dynamicGpuData", alloc(Uniforms.class));
GpuBuffer buffer = (GpuBuffer) proxy(GpuBuffer.class, (p, m, a) -> m.getName().equals("size") ? (Object) 1024L : defaults(p, m, a));
RenderPass pass = (RenderPass) proxy(RenderPass.class, (p, m, a) -> {
if (m.getName().equals("drawMultipleIndexed")) {
for (Object d : (Collection<?>) a[0]) sides.add(((RenderPass.Draw<?>) d).firstIndex() / 6);
return null;
}
return defaults(p, m, a);
});
Method prepareTransforms = WorldBorderRenderer.class.getDeclaredMethod("prepareDynamicTransforms", WorldBorderRenderState.class, Vec3.class);
Method draw = WorldBorderRenderer.class.getDeclaredMethod("draw", List.class, double.class, double.class, double.class, GpuBuffer.class, RenderPass.class);
Method vignette = Hud.class.getDeclaredMethod("extractVignette", GuiGraphicsExtractor.class, Entity.class);
for (Method m : new Method[] {prepareTransforms, draw, vignette}) m.setAccessible(true);
Class<?> indicesType = Class.forName("com.mojang.blaze3d.systems.RenderSystem$AutoStorageIndexBuffer");
var gson = new Gson();
var out = new StringBuilder();
for (String line : Files.readAllLines(Path.of(args[0]))) {
if (line.isBlank()) continue;
JsonObject c = JsonParser.parseString(line).getAsJsonObject();
var result = new JsonObject();
result.add("case", c);
try {
var border = new WorldBorder();
border.setAbsoluteMaxSize(c.get("absoluteMaxSize").getAsInt());
border.setCenter(c.get("centerX").getAsDouble(), c.get("centerZ").getAsDouble());
border.setWarningBlocks(c.get("warningBlocks").getAsInt());
border.setWarningTime(c.get("warningTime").getAsInt());
border.setSize(c.get("size").getAsDouble());
var renderer = alloc(WorldBorderRenderer.class);
put(renderer, WorldBorderRenderer.class, "needsRebuild", true);
put(renderer, WorldBorderRenderer.class, "worldBorderBuffer", buffer);
put(renderer, WorldBorderRenderer.class, "indices", alloc(indicesType));
var textures = alloc(TextureManager.class);
var byPath = new HashMap<Identifier, AbstractTexture>();
byPath.put(WorldBorderRenderer.FORCEFIELD_LOCATION, alloc(net.minecraft.client.renderer.texture.SimpleTexture.class));
put(textures, TextureManager.class, "byPath", byPath);
put(renderer, WorldBorderRenderer.class, "textureManager", textures);
var state = new WorldBorderRenderState();
var mc = alloc(Minecraft.class);
var level = alloc(ClientLevel.class);
put(level, ClientLevel.class, "worldBorder", border);
put(mc, Minecraft.class, "level", level);
var hud = alloc(Hud.class);
put(hud, Hud.class, "minecraft", mc);
var capture = alloc(Capture.class);
var camera = alloc(net.minecraft.world.entity.decoration.ArmorStand.class);
var frames = new JsonArray();
for (var element : c.getAsJsonArray("ops")) {
var op = element.getAsJsonObject();
switch (op.get("op").getAsString()) {
case "tick" -> { for (int n = op.get("n").getAsInt(); n > 0; n--) border.tick(); }
case "lerp" -> border.lerpSizeBetween(op.get("from").getAsDouble(), op.get("to").getAsDouble(), op.get("ticks").getAsLong(), 0L);
case "size" -> border.setSize(op.get("size").getAsDouble());
case "center" -> border.setCenter(op.get("x").getAsDouble(), op.get("z").getAsDouble());
case "warning" -> { border.setWarningBlocks(op.get("blocks").getAsInt()); border.setWarningTime(op.get("time").getAsInt()); }
case "invalidate" -> renderer.invalidate();
case "frame" -> {
float partial = op.get("partial").getAsFloat();
var p = op.getAsJsonArray("camera");
var cam = new Vec3(p.get(0).getAsDouble(), p.get(1).getAsDouble(), p.get(2).getAsDouble());
double distance = op.get("renderDistance").getAsDouble();
millis = op.get("millis").getAsLong();
var frame = new JsonObject();
frame.add("bounds", doubles(border.getMinX(partial), border.getMinZ(partial), border.getMaxX(partial), border.getMaxZ(partial)));
frame.add("sizes", doubles(border.getSize(), border.getLerpTarget(), border.getLerpSpeed(), border.getDistanceToBorder(cam.x, cam.z)));
frame.addProperty("lerpTime", border.getLerpTime());
frame.addProperty("status", border.getStatus().name());
renderer.extract(border, partial, cam, distance, state);
frame.add("alpha", doubles(state.alpha));
frame.addProperty("tint", state.tint);
rebuilt = false;
renderer.prepare(state, cam, distance, op.get("depthFar").getAsFloat());
boolean drawn = state.alpha > 0.0;
frame.addProperty("drawn", drawn);
frame.addProperty("rebuilt", rebuilt);
if (drawn) {
frame.add("vertices", floats(lastVertices));
lastTransform = null;
prepareTransforms.invoke(renderer, state, cam);
var t = (DynamicGpuData.Transform) lastTransform;
var m = new org.joml.Matrix4f(t.textureMatrix());
frame.add("color", floats(t.colorModulator().x(), t.colorModulator().y(), t.colorModulator().z(), t.colorModulator().w()));
frame.add("offset", floats(t.modelOffset().x(), t.modelOffset().y(), t.modelOffset().z()));
frame.add("texture", floats(m.m30(), m.m31()));
sides.clear();
draw.invoke(renderer, state.closestBorder(cam.x, cam.z), distance, cam.x, cam.z, null, pass);
var s = new JsonArray();
for (int side : sides) s.add(side);
frame.add("sides", s);
}
put(camera, Entity.class, "position", cam);
put(hud, Hud.class, "vignetteBrightness", op.get("vignette").getAsFloat());
vignette.invoke(hud, capture, camera);
frame.addProperty("vignetteColor", vignetteColor);
frames.add(frame);
}
default -> throw new IllegalArgumentException(op.toString());
}
}
result.add("frames", frames);
} catch (Throwable error) {
var cause = error instanceof InvocationTargetException && error.getCause() != null ? error.getCause() : error;
var sw = new java.io.StringWriter();
cause.printStackTrace(new java.io.PrintWriter(sw));
result.addProperty("error", sw.toString().lines().limit(10).reduce("", (x, y) -> x + y + " | "));
}
out.append(gson.toJson(result)).append('\n');
}
Files.writeString(Path.of(args[1]), out.toString(), StandardCharsets.UTF_8);
}
}
+184
View File
@@ -0,0 +1,184 @@
#!/usr/bin/env python3
"""Compare the player list (tab list) with the vanilla 26.3 client.
The Java oracle (VanillaTabListOracle) runs vanilla's own
PlayerTabOverlay.extractRenderState, frame after frame, on a stand-in client
whose connection lists the case's players (game mode, latency, display name,
list order, hat layer, online mode for heads), whose level holds some of
them (upside-down Dinnerbone and Grumm) and whose real Scoreboard has the
case's teams (colour, prefix, suffix), `list` objective (integer or hearts,
number formats) and scores, with the header, footer, row background option
and Hud ticks. It records every fill, text (as styled runs), sprite and
face blit. `examples/tab_list_fixture` lays out the same frames with
`horizon_client::tab_list`; the ordered call lists must agree.
test_tab_list_parity.py [--count N] [--detail N]
"""
import argparse
import json
import os
import random
import subprocess
import sys
import uuid
try:
from . import lab, test_rust_parity as base, test_model_baking_parity as baking
except ImportError:
import lab, test_rust_parity as base, test_model_baking_parity as baking
PARITY = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity'
COLORS = ['black', 'dark_blue', 'dark_green', 'dark_aqua', 'dark_red', 'dark_purple', 'gold', 'gray', 'dark_gray',
'blue', 'green', 'aqua', 'red', 'light_purple', 'yellow', 'white']
WORDS = ['Welcome', 'to', 'the', 'server', 'Horizon', 'players', 'online', 'mc.example.net', 'Have', 'fun!',
'Supercalifragilisticexpialidocious', 'a', 'é', 'Ünïcödé', '§aGreen', '§lBold', '[VIP]', '1234567890']
NAMES = ['Steve', 'Alex', 'Notch', 'jeb_', 'Dinnerbone', 'Grumm', 'xX_Pro_Xx', 'a', 'Zed', 'zebra', 'Émile', 'ÆON',
'bob', 'Carl', '_under', '123', 'MMMMMMMMMMMMMMMM', 'iiiiiiii', 'Wide_W', 'ßtraße', 'Ⅻ', 'Mix3d_Case']
def component(rng, words=3, depth=0):
text = ' '.join(rng.choice(WORDS) for _ in range(words))
kind = rng.random()
if kind < 0.3:
return text
c = {'text': text}
if rng.random() < 0.5:
c['color'] = rng.choice(COLORS + ['#12ABEF'])
for flag in ('bold', 'italic', 'underlined', 'strikethrough', 'obfuscated'):
if rng.random() < 0.15:
c[flag] = rng.random() < 0.8
if depth < 2 and rng.random() < 0.4:
c['extra'] = [component(rng, rng.randint(1, 3), depth + 1) for _ in range(rng.randint(1, 2))]
if rng.random() < 0.08:
c = {'translate': 'multiplayer.player.list.hp', 'with': [text], 'color': rng.choice(COLORS)}
return c
def number_format(rng):
kind = rng.random()
if kind < 0.4:
return None
if kind < 0.55:
return {'type': 'blank'}
if kind < 0.85:
style = {'color': rng.choice(COLORS)}
if rng.random() < 0.4:
style['bold'] = True
return {'type': 'styled', 'style': style}
return {'type': 'fixed', 'value': component(rng, 1)}
def cases(count):
rng = random.Random(0x544142)
out = []
for n in range(count):
size = rng.choice([1, 1, 2, 3, 5, 8, 12, 19, 20, 21, 25, 40, 41, 60, 79, 80, 85, 100])
names = []
while len(names) < size:
name = rng.choice(NAMES) if rng.random() < 0.5 else ''.join(
rng.choice('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_') for _ in range(rng.randint(1, 16)))
if name.lower() not in {x.lower() for x in names}:
names.append(name)
players = []
for name in names:
players.append({
'uuid': str(uuid.UUID(int=rng.getrandbits(128))), 'name': name,
'gameMode': rng.choice([0, 0, 0, 1, 2, 3]),
'latency': rng.choice([-1, 0, 1, 149, 150, 299, 300, 599, 600, 999, 1000, 5000, rng.randint(0, 2000)]),
'displayName': component(rng, rng.randint(1, 2)) if rng.random() < 0.2 else None,
'listOrder': rng.choice([0, 0, 0, 1, -1, 5, 2147483647, -2147483648]),
'showHat': rng.random() < 0.8, 'inLevel': rng.random() < 0.5,
})
teams = []
for t in range(rng.choice([0, 0, 1, 2, 4])):
members = [p['name'] for p in players if rng.random() < 0.3]
teams.append({'name': rng.choice(['red', 'Blue', 'team' + str(t), 'ä', 'z', 'A']) + str(t),
'color': rng.choice([None] + COLORS),
'prefix': rng.choice(['', '[R] ', {'text': '★ ', 'color': 'gold', 'bold': True}, component(rng, 1)]),
'suffix': rng.choice(['', ' ✔', {'text': ' (afk)', 'italic': True}]), 'members': members})
objective = None
if rng.random() < 0.7:
objective = {'name': 'obj', 'renderType': rng.choice(['integer', 'hearts', 'hearts']), 'numberFormat': number_format(rng)}
frames = []
tick = rng.randint(0, 100000)
values = {}
for f in range(rng.randint(1, 6)):
scores = {}
for p in players:
if objective and (f == 0 and rng.random() < 0.85 or rng.random() < 0.3):
v = rng.choice([0, 1, 2, 7, 19, 20, 21, 40, 99, 100, -3, 1234567, rng.randint(-50, 300)])
if p['name'] in values and rng.random() < 0.5:
v = values[p['name']] + rng.choice([-3, -1, 1, 2, 10])
values[p['name']] = v
scores[p['name']] = {'value': v, 'format': number_format(rng) if rng.random() < 0.2 else None}
reset = [p['name'] for p in players if objective and rng.random() < 0.03]
for r in reset:
values.pop(r, None)
tick += rng.choice([1, 1, 2, 3, 5, 10, 21, 40])
frames.append({'tick': tick, 'visible': rng.random() < 0.85, 'scores': scores, 'reset': reset})
header = footer = None
if rng.random() < 0.6:
header = rng.choice([component(rng, rng.randint(1, 30)), 'Line one\nLine two', '\n', 'trailing\n', ' two spaces ',
{'text': 'Header', 'extra': ['\n', component(rng, 12)]}])
if rng.random() < 0.5:
footer = rng.choice([component(rng, rng.randint(1, 30)), 'Footer', 'x\n\ny'])
out.append({'width': rng.choice([427, 320, 480, 640, 961, 160, 90, 300]), 'onlineMode': rng.random() < 0.7,
'backgroundForChatOnly': rng.random() < 0.8, 'opacity': rng.choice([0.5, 0.0, 1.0, 0.37]),
'header': header, 'footer': footer, 'teams': teams, 'objective': objective, 'players': players,
'frames': frames})
return out
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--count', type=int, default=1000)
parser.add_argument('--detail', type=int, default=3)
args = parser.parse_args()
lock, jars, _ = base.verify_artifacts()
libraries = baking.client_libraries()
build = lab.LOCAL / 'rust-tab-list-parity'; build.mkdir(parents=True, exist_ok=True)
resources = lab.LOCAL / 'horizon-client' / '26.3'
chosen = cases(args.count)
inputs = build / 'inputs.jsonl'; inputs.write_text(''.join(json.dumps(c) + '\n' for c in chosen))
classes = build / 'classes'; classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['client'], *libraries]))
def run(command, name):
with (build / (name + '.log')).open('w') as log:
result = subprocess.run(list(map(str, command)), cwd=lab.ROOT, timeout=3600, stdout=log, stderr=subprocess.STDOUT)
if result.returncode:
print((build / (name + '.log')).read_text()[-4000:]); sys.exit(f'{name} failed')
run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes,
*(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaTabListOracle'))], 'compile-java')
run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaTabListOracle',
inputs, build / 'vanilla.jsonl'], 'vanilla')
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'tab_list_fixture', '--',
resources, inputs, build / 'rust.jsonl'], 'rust')
vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()]
rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()]
assert len(vanilla) == len(rust)
errors, bad, frames, calls = [], [], 0, 0
for v, r in zip(vanilla, rust):
if 'error' in v:
errors.append(v['error']); continue
for i, (a, b) in enumerate(zip(v['frames'], r['frames'])):
frames += 1
calls += len(a)
if a != b:
first = next((k for k, (x, y) in enumerate(zip(a, b)) if x != y), min(len(a), len(b)))
bad.append((v['case'], i, first, a[first:first + 2], b[first:first + 2], len(a), len(b)))
break
for e in sorted(set(errors))[:5]:
print('ORACLE ERROR', e)
for case, i, k, a, b, la, lb in bad[:args.detail]:
print('MISMATCH', json.dumps(case)[:3000])
print(f' frame {i}, call {k} ({la} vanilla, {lb} Horizon calls)\n vanilla {a}\n horizon {b}')
print(f'{len(vanilla) - len(bad) - len(errors)}/{len(vanilla)} player lists match ({frames} frames, {calls} calls); '
f'{len(errors)} oracle errors')
if bad or errors:
sys.exit(1)
print('tab list parity ok')
if __name__ == '__main__':
main()
+138
View File
@@ -0,0 +1,138 @@
#!/usr/bin/env python3
"""Compare the world border as the client shows it with vanilla 26.3.
The Java oracle (VanillaWorldBorderRenderOracle) drives a vanilla WorldBorder
through each case's size changes (static, growing, shrinking), centre and
warning changes and ticks, and for every frame runs WorldBorderRenderer's
extract, prepare (the cached wall vertex buffer), prepareDynamicTransforms
(colour, model offset, scrolling texture) and draw (which walls), and
Hud.extractVignette (the red warning vignette colour). `examples/
world_border_render_fixture` replays the same cases with `horizon_client::
worldborder`, `border_render` and `hud_overlays::vignette`; every value must agree
bit for bit.
test_world_border_parity.py [--count N] [--detail N]
"""
import argparse
import json
import os
import random
import subprocess
import sys
try:
from . import lab, test_rust_parity as base, test_model_baking_parity as baking
except ImportError:
import lab, test_rust_parity as base, test_model_baking_parity as baking
PARITY = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity'
def cases(count):
rng = random.Random(0x424F52)
out = []
for n in range(count):
limit = rng.choice([29999984] * 6 + [1000, 50, 300000])
size = rng.choice([rng.uniform(1, 40), rng.uniform(40, 600), rng.uniform(600, 20000), 59999968.0, 1.0, 16.0, 200.0])
size = round(size, rng.choice([0, 1, 3, 9]))
far = rng.random() < 0.1
center = [rng.choice([0.0, 0.5, round(rng.uniform(-500, 500), 2), round(rng.uniform(-3e7, 3e7), 1) if far else 7.25])
for _ in range(2)]
case = {'absoluteMaxSize': limit, 'centerX': center[0], 'centerZ': center[1],
'warningBlocks': rng.choice([5, 5, 0, 1, 20, 100]), 'warningTime': rng.choice([300, 300, 15, 0, 1200]),
'size': size, 'ops': []}
current = size
for _ in range(rng.randint(1, 8)):
kind = rng.random()
if kind < 0.25:
to = min(59999968.0, round(max(1.0, current * rng.choice([0.25, 0.5, 2.0, 4.0]) + rng.uniform(-5, 5)), 2))
to = rng.choice([to, current]) if rng.random() < 0.1 else to
case['ops'].append({'op': 'lerp', 'from': current, 'to': to, 'ticks': rng.choice([1, 2, 20, 100, 1200, 72000])})
current = to
elif kind < 0.33:
current = round(rng.uniform(1, 300), 2)
case['ops'].append({'op': 'size', 'size': current})
elif kind < 0.38:
case['ops'].append({'op': 'center', 'x': round(rng.uniform(-100, 100), 2), 'z': round(rng.uniform(-100, 100), 2)})
elif kind < 0.42:
case['ops'].append({'op': 'warning', 'blocks': rng.choice([0, 5, 30]), 'time': rng.choice([0, 15, 300, 6000])})
elif kind < 0.45:
case['ops'].append({'op': 'invalidate'})
elif kind < 0.6:
case['ops'].append({'op': 'tick', 'n': rng.choice([1, 1, 2, 5, 19, 50, 600])})
for _ in range(rng.randint(1, 4)):
rd = 16 * rng.choice([2, 4, 8, 12, 16, 32])
half = min(current / 2, limit)
cx, cz = case['centerX'], case['centerZ']
if rng.random() < 0.8:
side = rng.randrange(4)
edge = rng.uniform(-1.5, 1.5) * rd
along = rng.uniform(-half - rd, half + rd)
x, z = [(cx + half + edge, cz + along), (cx - half - edge, cz + along),
(cx + along, cz + half + edge), (cx + along, cz - half - edge)][side]
else:
x, z = cx + rng.uniform(-3 * rd, 3 * rd), cz + rng.uniform(-3 * rd, 3 * rd)
y = rng.choice([64.0, 70.62, -60.3, 319.9, round(rng.uniform(-64, 320), 3)])
case['ops'].append({'op': 'frame', 'partial': rng.choice([0.0, 1.0, round(rng.random(), 4)]),
'camera': [round(x, rng.choice([1, 3, 7])), y, round(z, rng.choice([1, 3, 7]))],
'renderDistance': rd, 'depthFar': float(max(rd * 4, rng.choice([128, 256, 512]))),
'millis': rng.randint(0, 10 ** 12), 'vignette': rng.choice([0.0, 1.0, round(rng.random(), 4)])})
out.append(case)
return out
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--count', type=int, default=1500)
parser.add_argument('--detail', type=int, default=3)
args = parser.parse_args()
lock, jars, _ = base.verify_artifacts()
libraries = baking.client_libraries()
build = lab.LOCAL / 'rust-world-border-render-parity'; build.mkdir(parents=True, exist_ok=True)
chosen = cases(args.count)
inputs = build / 'inputs.jsonl'; inputs.write_text(''.join(json.dumps(c) + '\n' for c in chosen))
classes = build / 'classes'; classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['client'], *libraries]))
def run(command, name):
with (build / (name + '.log')).open('w') as log:
result = subprocess.run(list(map(str, command)), cwd=lab.ROOT, timeout=3600, stdout=log, stderr=subprocess.STDOUT)
if result.returncode:
print((build / (name + '.log')).read_text()[-4000:]); sys.exit(f'{name} failed')
run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes,
PARITY / 'VanillaWorldBorderRenderOracle.java'], 'compile-java')
run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaWorldBorderRenderOracle',
inputs, build / 'vanilla.jsonl'], 'vanilla')
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'world_border_render_fixture', '--',
inputs, build / 'rust.jsonl'], 'rust')
vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()]
rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()]
assert len(vanilla) == len(rust)
errors, bad, frames, drawn = [], [], 0, 0
for v, r in zip(vanilla, rust):
if 'error' in v:
errors.append(v['error']); continue
frames += len(v['frames'])
drawn += sum(f['drawn'] for f in v['frames'])
for i, (a, b) in enumerate(zip(v['frames'], r['frames'])):
if a != b:
keys = sorted(k for k in set(a) | set(b) if a.get(k) != b.get(k))
bad.append((v['case'], i, {k: (a.get(k), b.get(k)) for k in keys}))
break
else:
if len(v['frames']) != len(r['frames']):
bad.append((v['case'], len(r['frames']), 'frame count'))
for e in sorted(set(errors))[:5]:
print('ORACLE ERROR', e)
for case, i, diff in bad[:args.detail]:
print('MISMATCH', json.dumps(case))
print(f' at frame {i}: {json.dumps(diff)[:1500]}')
print(f'{len(vanilla) - len(bad) - len(errors)}/{len(vanilla)} border cases match '
f'({frames} frames, {drawn} with the wall drawn); {len(errors)} oracle errors')
if bad or errors:
sys.exit(1)
print('world border parity ok')
if __name__ == '__main__':
main()