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:
@@ -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(())
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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))],
|
||||
|
||||
@@ -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(¶ms.display_name);
|
||||
team.prefix = tag_to_json(¶ms.prefix);
|
||||
team.suffix = tag_to_json(¶ms.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>,
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user