Merge main and retain Dolphin Grace and Weaving effect flags

This commit is contained in:
Cosmic
2026-10-14 11:25:55 -04:00
98 changed files with 8258 additions and 810 deletions
+5 -3
View File
@@ -1,6 +1,6 @@
name: release builds
# Started by hand: gh workflow run release.yml --ref <branch>
# Builds the Windows x64 and Linux x86_64 clients (with horizon-ctl) and uploads the playable folders
# Builds the Windows x64 and Linux x86_64 clients (with horizon-ctl and horizon-prepare) and uploads the playable folders
# as artifacts.
# macOS builds are made on the development machines. Linux is built here, on an older Ubuntu,
# so the binary uses the standard loader and runs on any recent distribution (and on NixOS
@@ -20,13 +20,14 @@ jobs:
# The C runtime linked in, so the game runs without the Visual C++ redistributable.
env:
RUSTFLAGS: -C target-feature=+crt-static
run: cargo +stable build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl
run: cargo +stable build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare
- name: Only system DLLs
# Vulkan and the rest are loaded at run time; a linked non-system DLL is a
# "DLL not found" dialog on some players' machines.
run: |
python tools/check_imports.py target/release/horizon-client.exe
python tools/check_imports.py target/release/horizon-ctl.exe
python tools/check_imports.py target/release/horizon-prepare.exe
- name: Package
shell: bash
run: packaging/package.sh target/release/horizon-client.exe dist/horizon-windows-x64
@@ -43,11 +44,12 @@ jobs:
- name: ALSA headers
run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev
- name: Build the client
run: cargo +stable build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl
run: cargo +stable build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare
- name: Standard loader and libraries only
run: |
python3 tools/check_imports.py target/release/horizon-client
python3 tools/check_imports.py target/release/horizon-ctl
python3 tools/check_imports.py target/release/horizon-prepare
- name: Package
run: packaging/package.sh target/release/horizon-client dist/horizon-linux-x86_64
- uses: actions/upload-artifact@v4
Generated
+315 -4
View File
@@ -37,6 +37,15 @@ dependencies = [
"zerocopy",
]
[[package]]
name = "aho-corasick"
version = "1.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
dependencies = [
"memchr",
]
[[package]]
name = "allocator-api2"
version = "0.2.21"
@@ -99,6 +108,33 @@ dependencies = [
"libc",
]
[[package]]
name = "arbitrary"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3bc62ac97cc33321f50863d514c3bc38a453947a8f9e781137e47c7401020aed"
dependencies = [
"derive_arbitrary",
]
[[package]]
name = "arboard"
version = "3.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
dependencies = [
"clipboard-win",
"log",
"objc2 0.6.5",
"objc2-app-kit 0.3.2",
"objc2-foundation 0.3.2",
"parking_lot",
"percent-encoding",
"windows-sys 0.59.0",
"wl-clipboard-rs",
"x11rb",
]
[[package]]
name = "arrayref"
version = "0.3.9"
@@ -165,6 +201,15 @@ version = "2.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
[[package]]
name = "block-buffer"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
dependencies = [
"generic-array",
]
[[package]]
name = "block2"
version = "0.5.1"
@@ -271,6 +316,15 @@ version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
[[package]]
name = "clipboard-win"
version = "5.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
dependencies = [
"error-code",
]
[[package]]
name = "codespan-reporting"
version = "0.13.1"
@@ -385,6 +439,15 @@ dependencies = [
"windows 0.54.0",
]
[[package]]
name = "cpufeatures"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
dependencies = [
"libc",
]
[[package]]
name = "crc32fast"
version = "1.5.2"
@@ -406,6 +469,16 @@ version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
[[package]]
name = "crypto-common"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
dependencies = [
"generic-array",
"typenum",
]
[[package]]
name = "cursor-icon"
version = "1.2.0"
@@ -418,6 +491,27 @@ version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
[[package]]
name = "derive_arbitrary"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b034bd7d5f032402a2479444dcc6f74e36a03f31854d41680fb240ef682a1ac"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.6",
]
[[package]]
name = "digest"
version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
dependencies = [
"block-buffer",
"crypto-common",
]
[[package]]
name = "dispatch"
version = "0.2.0"
@@ -434,6 +528,17 @@ dependencies = [
"objc2 0.6.5",
]
[[package]]
name = "displaydoc"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.6",
]
[[package]]
name = "dlib"
version = "0.5.3"
@@ -494,6 +599,12 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "error-code"
version = "3.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7"
[[package]]
name = "fdeflate"
version = "0.3.7"
@@ -509,6 +620,12 @@ version = "0.1.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
[[package]]
name = "fixedbitset"
version = "0.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
[[package]]
name = "flate2"
version = "1.1.10"
@@ -520,6 +637,12 @@ dependencies = [
"zlib-rs",
]
[[package]]
name = "foldhash"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
[[package]]
name = "foldhash"
version = "0.2.0"
@@ -577,6 +700,16 @@ dependencies = [
"slab",
]
[[package]]
name = "generic-array"
version = "0.14.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
dependencies = [
"typenum",
"version_check",
]
[[package]]
name = "gethostname"
version = "1.1.0"
@@ -641,6 +774,15 @@ dependencies = [
"zerocopy",
]
[[package]]
name = "hashbrown"
version = "0.15.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
dependencies = [
"foldhash 0.1.5",
]
[[package]]
name = "hashbrown"
version = "0.16.1"
@@ -649,7 +791,7 @@ checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
dependencies = [
"allocator-api2",
"equivalent",
"foldhash",
"foldhash 0.2.0",
]
[[package]]
@@ -658,7 +800,7 @@ version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
dependencies = [
"foldhash",
"foldhash 0.2.0",
]
[[package]]
@@ -682,6 +824,7 @@ name = "horizon-client"
version = "0.1.0"
dependencies = [
"ab_glyph",
"arboard",
"bytemuck",
"cpal",
"glam",
@@ -706,6 +849,16 @@ dependencies = [
"libm",
]
[[package]]
name = "horizon-prepare"
version = "0.1.0"
dependencies = [
"regex",
"sha1",
"sha2",
"zip",
]
[[package]]
name = "horizon-protocol"
version = "0.1.0"
@@ -1039,6 +1192,15 @@ dependencies = [
"jni-sys 0.3.1",
]
[[package]]
name = "nom"
version = "8.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
dependencies = [
"memchr",
]
[[package]]
name = "num-derive"
version = "0.4.2"
@@ -1123,6 +1285,18 @@ dependencies = [
"objc2-quartz-core 0.2.2",
]
[[package]]
name = "objc2-app-kit"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
dependencies = [
"bitflags 2.13.2",
"objc2 0.6.5",
"objc2-core-graphics",
"objc2-foundation 0.3.2",
]
[[package]]
name = "objc2-audio-toolbox"
version = "0.3.2"
@@ -1213,6 +1387,7 @@ version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
dependencies = [
"bitflags 2.13.2",
"dispatch2",
"objc2 0.6.5",
"objc2-core-foundation",
@@ -1292,7 +1467,7 @@ checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398"
dependencies = [
"block2 0.5.1",
"objc2 0.5.3",
"objc2-app-kit",
"objc2-app-kit 0.2.2",
"objc2-foundation 0.2.2",
]
@@ -1427,6 +1602,16 @@ dependencies = [
"num-traits",
]
[[package]]
name = "os_pipe"
version = "1.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
dependencies = [
"libc",
"windows-sys 0.61.2",
]
[[package]]
name = "owned_ttf_parser"
version = "0.25.1"
@@ -1465,6 +1650,17 @@ version = "2.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
[[package]]
name = "petgraph"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
dependencies = [
"fixedbitset",
"hashbrown 0.15.5",
"indexmap",
]
[[package]]
name = "pin-project"
version = "1.1.13"
@@ -1656,6 +1852,35 @@ dependencies = [
"bitflags 2.13.2",
]
[[package]]
name = "regex"
version = "1.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
dependencies = [
"aho-corasick",
"memchr",
"regex-automata",
"regex-syntax",
]
[[package]]
name = "regex-automata"
version = "0.4.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax",
]
[[package]]
name = "regex-syntax"
version = "0.8.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
[[package]]
name = "renderdoc-sys"
version = "1.1.0"
@@ -1791,6 +2016,28 @@ dependencies = [
"zmij",
]
[[package]]
name = "sha1"
version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
dependencies = [
"cfg-if",
"cpufeatures",
"digest",
]
[[package]]
name = "sha2"
version = "0.10.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
dependencies = [
"cfg-if",
"cpufeatures",
"digest",
]
[[package]]
name = "shlex"
version = "2.0.1"
@@ -2099,12 +2346,29 @@ version = "0.1.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
[[package]]
name = "tree_magic_mini"
version = "3.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
dependencies = [
"memchr",
"nom",
"petgraph",
]
[[package]]
name = "ttf-parser"
version = "0.25.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
[[package]]
name = "typenum"
version = "1.20.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
[[package]]
name = "unicode-ident"
version = "1.0.26"
@@ -2815,7 +3079,7 @@ dependencies = [
"memmap2",
"ndk",
"objc2 0.5.3",
"objc2-app-kit",
"objc2-app-kit 0.2.2",
"objc2-foundation 0.2.2",
"objc2-ui-kit",
"orbclient",
@@ -2858,6 +3122,24 @@ version = "0.57.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
[[package]]
name = "wl-clipboard-rs"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d7888ccd4896447b2d14d3a9350a85df2aeb6f181e2e7a31349d104ac46cac1"
dependencies = [
"libc",
"log",
"os_pipe",
"rustix 1.1.5",
"thiserror 2.0.21",
"tree_magic_mini",
"wayland-backend",
"wayland-client",
"wayland-protocols",
"wayland-protocols-wlr",
]
[[package]]
name = "x11-dl"
version = "2.21.0"
@@ -2941,6 +3223,23 @@ dependencies = [
"syn 2.0.119",
]
[[package]]
name = "zip"
version = "2.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
dependencies = [
"arbitrary",
"crc32fast",
"crossbeam-utils",
"displaydoc",
"flate2",
"indexmap",
"memchr",
"thiserror 2.0.21",
"zopfli",
]
[[package]]
name = "zlib-rs"
version = "0.6.8"
@@ -2952,3 +3251,15 @@ name = "zmij"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
[[package]]
name = "zopfli"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aaf7fc5d30c28483d93805c4a5e12b05bbb52407fa67c5f8bd552374cd01fb11"
dependencies = [
"bumpalo",
"crc32fast",
"log",
"simd-adler32",
]
+1 -1
View File
@@ -1,6 +1,6 @@
[workspace]
exclude = ["launcher"]
members = ["crates/horizon-core", "crates/horizon-world", "crates/voxel-kernels", "crates/horizon-client", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme"]
members = ["crates/horizon-core", "crates/horizon-world", "crates/voxel-kernels", "crates/horizon-client", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare"]
resolver = "2"
[workspace.package]
+1 -1
View File
@@ -140,7 +140,7 @@ Horizon contains no game files and never downloads them. It builds its resources
```sh
git clone https://github.com/ludovic111/horizon.git
cd horizon
python3 tools/prepare_native_client.py --prepare --server-jar ~/Downloads/server.jar # needs JDK 25
cargo run --release -p horizon-prepare -- --prepare --server-jar ~/Downloads/server.jar # needs JDK 25
python3 tools/fetch_sounds.py # optional: sounds from your launcher install
cargo run --release -p horizon-client
```
+1
View File
@@ -24,6 +24,7 @@ symphonia = { version = "0.5", default-features = false, features = ["ogg", "vor
miniz_oxide = "0.8"
ab_glyph = "0.2.32"
horizon-theme = { path = "../horizon-theme" }
arboard = { version = "3.6.1", default-features = false, features = ["wayland-data-control"] }
[features]
# Records the call sites of mob random draws (`mob_ai_probe` traces).
@@ -0,0 +1,74 @@
#![forbid(unsafe_code)]
//! Runs tools/test_emitter_particles_parity.py's emitters through
//! `particles::on_block_faces`, `particles::along_axis` and
//! `particles::item_use_particles`.
use horizon_client::{Result, particles};
use horizon_core::random::{LegacyRandom, RandomSource};
use serde_json::Value;
use std::{
fs::File,
io::{BufRead, BufReader, BufWriter, Write},
};
fn d(v: f64) -> String {
format!("{:016x}", v.to_bits())
}
fn main() -> Result<()> {
let args: Vec<String> = std::env::args().collect();
let mut out = BufWriter::new(File::create(&args[2])?);
for (n, line) in BufReader::new(File::open(&args[1])?).lines().enumerate() {
let c: Value = serde_json::from_str(&line?)?;
writeln!(out, "== {n}")?;
let mut random = LegacyRandom::new(c["seed"].as_i64().ok_or("seed")?);
let mut lines = Vec::new();
let record = |kind: &str| {
let kind = kind.to_owned();
move |p: [f64; 3], v: [f64; 3]| {
format!(
"+ {kind} {} {} {} {} {} {}",
d(p[0]),
d(p[1]),
d(p[2]),
d(v[0]),
d(v[1]),
d(v[2])
)
}
};
if c["kind"] == "item_use" {
let p: [f64; 3] = std::array::from_fn(|i| c["pos"][i].as_f64().unwrap_or(0.0));
let f = |k: &str| c[k].as_f64().unwrap_or(0.0) as f32;
let line = record("item");
particles::item_use_particles(
&mut random,
f("pitch"),
f("yaw"),
p,
p[1] + f64::from(f("eye")),
c["count"].as_u64().unwrap_or(0) as u32,
|p, v| lines.push(line(p, v)),
);
} else {
let p: [i32; 3] = std::array::from_fn(|i| c["pos"][i].as_i64().unwrap_or(0) as i32);
match c["axis"].as_i64() {
Some(axis @ 0..=2) => {
let line = record("electric_spark");
particles::along_axis(&mut random, axis as usize, p, |p, v| {
lines.push(line(p, v))
});
}
_ => {
let line = record("wax_on");
particles::on_block_faces(&mut random, p, |p, v| lines.push(line(p, v)));
}
}
}
for l in lines {
writeln!(out, "{l}")?;
}
writeln!(out, "next {}", random.next_long())?;
}
out.flush()?;
Ok(())
}
@@ -0,0 +1,51 @@
#![forbid(unsafe_code)]
//! Runs tools/test_entity_particles_parity.py's entity events through
//! `particles::entity_event_burst` and `particles::around_self`.
use horizon_client::{Result, particles};
use horizon_core::random::{LegacyRandom, RandomSource};
use serde_json::Value;
use std::{
fs::File,
io::{BufRead, BufReader, BufWriter, Write},
};
fn d(v: f64) -> String {
format!("{:016x}", v.to_bits())
}
fn main() -> Result<()> {
let args: Vec<String> = std::env::args().collect();
let mut out = BufWriter::new(File::create(&args[2])?);
for (n, line) in BufReader::new(File::open(&args[1])?).lines().enumerate() {
let c: Value = serde_json::from_str(&line?)?;
writeln!(out, "== {n}")?;
let mut random = LegacyRandom::new(c["seed"].as_i64().ok_or("seed")?);
let feet: [f64; 3] = std::array::from_fn(|i| c["feet"][i].as_f64().unwrap_or(0.0));
// EntityDimensions hold floats.
let width = f64::from(c["width"].as_f64().unwrap_or(0.0) as f32);
let height = f64::from(c["height"].as_f64().unwrap_or(0.0) as f32);
let entity = c["entity"].as_str().unwrap_or("");
if let Some((kind, burst)) =
particles::entity_event_burst(entity, c["event"].as_u64().unwrap_or(0) as u8)
{
let mut lines = Vec::new();
particles::around_self(&mut random, feet, width, height, burst, |p, v| {
lines.push(format!(
"+ {kind} {} {} {} {} {} {}",
d(p[0]),
d(p[1]),
d(p[2]),
d(v[0]),
d(v[1]),
d(v[2])
));
});
for l in lines {
writeln!(out, "{l}")?;
}
}
writeln!(out, "next {}", random.next_long())?;
}
out.flush()?;
Ok(())
}
@@ -46,9 +46,10 @@ fn options(case: &Value) -> Option<ParticleOptions> {
[r, g, b, ((c >> 24) & 255) as f32 / 255.0]
};
Some(match ty {
ParticleType::Block | ParticleType::BlockCrumble | ParticleType::DustPillar => {
ParticleOptions::block(ty, "terrain".into(), 0xFF_FFFF)
}
ParticleType::Block
| ParticleType::BlockCrumble
| ParticleType::DustPillar
| ParticleType::BlockMarker => ParticleOptions::block(ty, "terrain".into(), 0xFF_FFFF),
// Stone's map colour: FallingDustParticle.Provider's tint without a tint source.
ParticleType::FallingDust => ParticleOptions::block(ty, "terrain".into(), 0x70_7070),
ParticleType::Dust => ParticleOptions::dust(rgb(c), scale),
@@ -59,7 +60,15 @@ fn options(case: &Value) -> Option<ParticleOptions> {
scale,
..ParticleOptions::colored(ty, argb)
},
ParticleType::EntityEffect | ParticleType::TintedLeaves => {
// The oracle's item models: one layer whose sprite is named after the item.
ParticleType::Item => {
let item = o["item"].as_str()?;
ParticleOptions::item(vec![format!(
"item_{}",
item.strip_prefix("minecraft:").unwrap_or(item)
)])
}
ParticleType::EntityEffect | ParticleType::TintedLeaves | ParticleType::Flash => {
ParticleOptions::colored(ty, argb)
}
ParticleType::DragonBreath => ParticleOptions {
@@ -137,6 +146,13 @@ fn main() -> Result<()> {
world(&assets, &facts, true)?,
];
let mut engine = ParticleEngine::new(root, &HashMap::new());
for (ty, item) in [
(ParticleType::ItemSlime, "item_slime_ball"),
(ParticleType::ItemSnowball, "item_snowball"),
(ParticleType::ItemCobweb, "item_cobweb"),
] {
engine.item_sprites.insert(ty, vec![item.to_owned()]);
}
// The oracle's output: the seed line of each case.
let mut seeds = Vec::new();
for line in BufReader::new(File::open(&args[2])?).lines() {
@@ -442,6 +442,12 @@ fn main() -> Result<()> {
world.player.freeze_immune = boots;
}
"frozen" => world.player.ticks_frozen = op["value"].as_i64().unwrap() as i32,
"weaving" => world.player.status.weaving = op["value"].as_bool().unwrap(),
"flying" => {
let flying = op["value"].as_bool().unwrap();
world.player.may_fly = flying;
world.player.flying = flying;
}
"trigger" => world.player.jump_trigger_time = op["value"].as_i64().unwrap() as i32,
"delay" => world.player.no_jump_delay = op["value"].as_i64().unwrap() as i32,
"move" => world.move_self(vector(&op["value"]))?,
+12
View File
@@ -432,6 +432,18 @@ impl ChatScreen {
self.allow_suggestions = true;
self.update_command_info(m, c);
}
/// Ctrl+A/C/V/X in the input box.
pub fn shortcut(
&mut self,
m: &Measure,
c: &Commands,
shortcut: crate::clipboard::EditShortcut,
clipboard: &mut dyn crate::clipboard::Clipboard,
) {
if self.input.shortcut(m, shortcut, clipboard) {
self.edited(m, c);
}
}
/// Typed text (`charTyped` per character).
pub fn type_text(&mut self, m: &Measure, c: &Commands, text: &str) {
for ch in text.chars() {
+455
View File
@@ -0,0 +1,455 @@
//! The system clipboard and the text-editing shortcuts of 26.3:
//! `KeyboardHandler.getClipboard`/`setClipboard`, `InputWithModifiers.isSelectAll`,
//! `isCopy`, `isPaste` and `isCut`, `StringUtil.filterText` and
//! `ChatFormatting.stripFormatting`.
use winit::keyboard::{Key, KeyCode, PhysicalKey};
/// A text-editing shortcut (`InputWithModifiers.isSelectAll`, `isCopy`,
/// `isPaste`, `isCut`).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EditShortcut {
SelectAll,
Copy,
Paste,
Cut,
}
/// The letter a key stands for in shortcuts (`KeyEvent.shortcutKey`, SDL's
/// keycode): the layout's letter, or the key's US-layout letter when the
/// layout's is not a Latin one (SDL's default `latin_letters` keycode option).
pub fn shortcut_letter(logical: &Key, physical: PhysicalKey) -> Option<char> {
if let Key::Character(s) = logical {
let mut chars = s.chars();
if let (Some(c), None) = (chars.next(), chars.next())
&& c.is_ascii_alphabetic()
{
return Some(c.to_ascii_lowercase());
}
}
let PhysicalKey::Code(code) = physical else {
return None;
};
Some(match code {
KeyCode::KeyA => 'a',
KeyCode::KeyC => 'c',
KeyCode::KeyV => 'v',
KeyCode::KeyX => 'x',
_ => return None,
})
}
/// `InputWithModifiers.isSelectAll`/`isCopy`/`isPaste`/`isCut`: A, C, V or X
/// with the edit modifier (`InputQuirks.EDIT_SHORTCUT_KEY_MODIFIER`: Cmd on
/// macOS, Ctrl elsewhere) and neither Shift nor Alt.
pub fn edit_shortcut(
letter: Option<char>,
edit_modifier: bool,
shift: bool,
alt: bool,
) -> Option<EditShortcut> {
if !edit_modifier || shift || alt {
return None;
}
Some(match letter? {
'a' => EditShortcut::SelectAll,
'c' => EditShortcut::Copy,
'v' => EditShortcut::Paste,
'x' => EditShortcut::Cut,
_ => return None,
})
}
/// `StringUtil.isAllowedChatCharacter`.
pub fn is_allowed_chat_character(c: char) -> bool {
c != '§' && c >= ' ' && c != '\u{7f}'
}
/// `StringUtil.filterText`: the allowed characters, and line breaks where
/// the field takes several lines.
pub fn filter_text(input: &str, multiline: bool) -> String {
input
.chars()
.filter(|&c| is_allowed_chat_character(c) || (multiline && c == '\n'))
.collect()
}
/// `ChatFormatting.stripFormatting`: `§` followed by a format code removed.
pub fn strip_formatting(input: &str) -> String {
let mut out = String::with_capacity(input.len());
let mut chars = input.chars().peekable();
while let Some(c) = chars.next() {
if c == '§'
&& chars.peek().is_some_and(
|n| matches!(n.to_ascii_lowercase(), '0'..='9' | 'a'..='f' | 'k'..='o' | 'r'),
)
{
chars.next();
continue;
}
out.push(c);
}
out
}
/// `TextFieldHelper.getClipboardContents`: formatting and carriage returns
/// removed (signs).
pub fn helper_clipboard_contents(clipboard: &str) -> String {
strip_formatting(&clipboard.replace('\r', ""))
}
/// A clipboard: the system's, or an in-memory one in tests.
pub trait Clipboard {
/// `KeyboardHandler.getClipboard`: empty when there is no text.
fn get(&mut self) -> String;
/// `KeyboardHandler.setClipboard`: empty text is not copied.
fn set(&mut self, text: &str);
}
/// The system clipboard (`ClipboardManager`). On Wayland, arboard uses the
/// data-control protocol and falls back to X11 (XWayland) on compositors
/// without it. When no system clipboard can be reached, text copied in the
/// game can still be pasted in the game.
#[derive(Default)]
pub struct SystemClipboard {
system: Option<arboard::Clipboard>,
/// The text Horizon last copied (`horizon-ctl status`).
copied: Option<String>,
}
impl SystemClipboard {
/// The text last copied by the game.
pub fn copied(&self) -> Option<&str> {
self.copied.as_deref()
}
fn system(&mut self) -> Option<&mut arboard::Clipboard> {
if self.system.is_none() {
self.system = arboard::Clipboard::new().ok();
}
self.system.as_mut()
}
}
impl Clipboard for SystemClipboard {
fn get(&mut self) -> String {
let Some(system) = self.system() else {
return self.copied.clone().unwrap_or_default();
};
match system.get_text() {
Ok(text) => text,
Err(arboard::Error::ContentNotAvailable) => String::new(),
Err(_) => {
// A lost connection (a restarted compositor): reconnect next time.
self.system = None;
String::new()
}
}
}
fn set(&mut self, text: &str) {
if text.is_empty() {
return;
}
self.copied = Some(text.to_owned());
if let Some(system) = self.system()
&& system.set_text(text.to_owned()).is_err()
{
self.system = None;
}
}
}
/// A clipboard in memory.
#[derive(Default, Debug)]
pub struct MemoryClipboard(pub String);
impl Clipboard for MemoryClipboard {
fn get(&mut self) -> String {
self.0.clone()
}
fn set(&mut self, text: &str) {
if !text.is_empty() {
self.0 = text.to_owned();
}
}
}
/// A text field with a cursor and a selection (`EditBox`).
pub trait Editable {
/// Select All: the cursor at the end, the selection from the start.
fn select_all(&mut self);
/// `getHighlighted`.
fn selected_text(&self) -> String;
/// `insertText`, with the field's own filter and length limit. True when
/// the value changed.
fn insert(&mut self, text: &str) -> bool;
}
/// `EditBox.keyPressed`'s shortcuts. True when the value changed.
pub fn apply(
field: &mut dyn Editable,
shortcut: EditShortcut,
clipboard: &mut dyn Clipboard,
) -> bool {
match shortcut {
EditShortcut::SelectAll => {
field.select_all();
false
}
EditShortcut::Copy => {
clipboard.set(&field.selected_text());
false
}
EditShortcut::Paste => field.insert(&clipboard.get()),
EditShortcut::Cut => {
clipboard.set(&field.selected_text());
field.insert("")
}
}
}
/// Which append-only field a Select All covers: a name and an index (a
/// sign line, a book page).
pub type FieldId = (&'static str, usize);
/// The selection of Horizon's append-only fields, whose cursor stays at the
/// end: Select All selects the whole value, which the next copy, cut, paste,
/// typed text or backspace replaces. It is forgotten as soon as the field or
/// its value changes.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct AppendSelection(Option<(FieldId, String)>);
impl AppendSelection {
/// Whether `value` of field `id` is wholly selected.
pub fn covers(&self, id: FieldId, value: &str) -> bool {
self.0.as_ref().is_some_and(|(i, v)| *i == id && v == value)
}
/// Before typing or a backspace: an all-selected value is cleared (true).
pub fn take(&mut self, id: FieldId, value: &mut String) -> bool {
let covered = self.covers(id, value);
self.0 = None;
if covered {
value.clear();
}
covered
}
/// A shortcut in an append-only field. `insert` adds pasted text to a
/// value the field's own way and says whether it accepted it (a field
/// that rejects it keeps its value, as `TextFieldHelper.insertText`).
/// True when the value changed.
pub fn apply(
&mut self,
id: FieldId,
value: &mut String,
shortcut: EditShortcut,
clipboard: &mut dyn Clipboard,
insert: impl FnOnce(&mut String, &str) -> bool,
) -> bool {
let covered = self.covers(id, value);
match shortcut {
EditShortcut::SelectAll => {
self.0 = Some((id, value.clone()));
false
}
EditShortcut::Copy => {
if covered {
clipboard.set(value);
}
false
}
EditShortcut::Cut => {
self.0 = None;
if !covered {
return false;
}
clipboard.set(value);
let changed = !value.is_empty();
value.clear();
changed
}
EditShortcut::Paste => {
self.0 = None;
let text = clipboard.get();
let mut next = if covered {
String::new()
} else {
value.clone()
};
if !insert(&mut next, &text) || next == *value {
return false;
}
*value = next;
true
}
}
}
}
/// `EditBox.insertText` for a field without a cursor: the filtered text,
/// cut to the room left by `max_chars`.
pub fn append_limited(value: &mut String, text: &str, max_chars: usize) -> bool {
let room = max_chars.saturating_sub(value.chars().count());
if room == 0 {
return false;
}
value.extend(filter_text(text, false).chars().take(room));
true
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn shortcuts_need_the_edit_modifier_alone() {
let c = Some('c');
assert_eq!(
edit_shortcut(c, true, false, false),
Some(EditShortcut::Copy)
);
assert_eq!(
edit_shortcut(Some('v'), true, false, false),
Some(EditShortcut::Paste)
);
assert_eq!(
edit_shortcut(Some('x'), true, false, false),
Some(EditShortcut::Cut)
);
assert_eq!(
edit_shortcut(Some('a'), true, false, false),
Some(EditShortcut::SelectAll)
);
assert_eq!(edit_shortcut(c, false, false, false), None);
assert_eq!(edit_shortcut(c, true, true, false), None);
assert_eq!(edit_shortcut(c, true, false, true), None);
assert_eq!(edit_shortcut(Some('b'), true, false, false), None);
}
#[test]
fn the_layout_letter_decides_and_non_latin_layouts_use_the_position() {
let q = PhysicalKey::Code(KeyCode::KeyQ);
// AZERTY: the key at Q's position types an A.
assert_eq!(shortcut_letter(&Key::Character("a".into()), q), Some('a'));
// Russian: the key at C's position types с.
let c = PhysicalKey::Code(KeyCode::KeyC);
assert_eq!(shortcut_letter(&Key::Character("с".into()), c), Some('c'));
assert_eq!(shortcut_letter(&Key::Character("C".into()), q), Some('c'));
}
#[test]
fn filter_text_keeps_line_breaks_only_for_multiline_fields() {
let s = "a\u{7}b§c\nd\re\u{80}";
assert_eq!(filter_text(s, false), "abcde\u{80}");
assert_eq!(filter_text(s, true), "abc\nde\u{80}");
assert_eq!(strip_formatting("§aRed§r §zx§"), "Red §zx§");
assert_eq!(helper_clipboard_contents("§lone\r\ntwo"), "one\ntwo");
}
struct Field {
value: String,
cursor: usize,
highlight: usize,
}
impl Editable for Field {
fn select_all(&mut self) {
self.cursor = self.value.len();
self.highlight = 0;
}
fn selected_text(&self) -> String {
let (a, b) = (
self.cursor.min(self.highlight),
self.cursor.max(self.highlight),
);
self.value[a..b].to_owned()
}
fn insert(&mut self, text: &str) -> bool {
let (a, b) = (
self.cursor.min(self.highlight),
self.cursor.max(self.highlight),
);
self.value.replace_range(a..b, text);
self.cursor = a + text.len();
self.highlight = self.cursor;
true
}
}
#[test]
fn edit_box_shortcuts() {
let mut clip = MemoryClipboard("old".into());
let mut f = Field {
value: "hello".into(),
cursor: 5,
highlight: 5,
};
// Nothing selected: copying leaves the clipboard alone (setClipboard skips "").
apply(&mut f, EditShortcut::Copy, &mut clip);
assert_eq!(clip.0, "old");
apply(&mut f, EditShortcut::SelectAll, &mut clip);
apply(&mut f, EditShortcut::Copy, &mut clip);
assert_eq!(clip.0, "hello");
assert!(apply(&mut f, EditShortcut::Cut, &mut clip));
assert_eq!(f.value, "");
assert!(apply(&mut f, EditShortcut::Paste, &mut clip));
assert!(apply(&mut f, EditShortcut::Paste, &mut clip));
assert_eq!(f.value, "hellohello");
}
#[test]
fn append_only_fields_select_everything_or_nothing() {
let id = ("search", 0);
let mut clip = MemoryClipboard("stone".into());
let mut sel = AppendSelection::default();
let mut value = String::from("dirt");
let insert = |v: &mut String, t: &str| append_limited(v, t, 6);
// Without Select All, copy and cut do nothing and paste appends.
sel.apply(id, &mut value, EditShortcut::Copy, &mut clip, insert);
assert_eq!(clip.0, "stone");
assert!(!sel.apply(id, &mut value, EditShortcut::Cut, &mut clip, insert));
assert!(sel.apply(id, &mut value, EditShortcut::Paste, &mut clip, insert));
assert_eq!(value, "dirtst");
// Select All then paste replaces the value.
sel.apply(id, &mut value, EditShortcut::SelectAll, &mut clip, insert);
assert!(sel.apply(id, &mut value, EditShortcut::Paste, &mut clip, insert));
assert_eq!(value, "stone");
// Select All then cut empties it and copies it.
sel.apply(id, &mut value, EditShortcut::SelectAll, &mut clip, insert);
clip.0 = "x".into();
assert!(sel.apply(id, &mut value, EditShortcut::Cut, &mut clip, insert));
assert_eq!((value.as_str(), clip.0.as_str()), ("", "stone"));
// A selection is forgotten once the value changes or another field is used.
value = "ab".into();
sel.apply(id, &mut value, EditShortcut::SelectAll, &mut clip, insert);
assert!(!sel.covers(("other", 0), &value));
value.push('c');
assert!(!sel.take(id, &mut value));
assert_eq!(value, "abc");
sel.apply(id, &mut value, EditShortcut::SelectAll, &mut clip, insert);
assert!(sel.take(id, &mut value));
assert_eq!(value, "");
}
#[test]
fn a_rejected_paste_keeps_the_selected_value() {
// TextFieldHelper.insertText: a line too wide is not set at all.
let id = ("sign", 1);
let mut clip = MemoryClipboard("far too long".into());
let mut sel = AppendSelection::default();
let mut value = String::from("ok");
sel.apply(
id,
&mut value,
EditShortcut::SelectAll,
&mut clip,
|_, _| true,
);
let fits = |v: &mut String, t: &str| {
let next = format!("{v}{t}");
next.len() <= 5 && {
*v = next;
true
}
};
assert!(!sel.apply(id, &mut value, EditShortcut::Paste, &mut clip, fits));
assert_eq!(value, "ok");
}
}
+456
View File
@@ -0,0 +1,456 @@
//! The debug keys (26.3 `KeyboardHandler`): `key.debug.modifier` (F3) held
//! with another key runs a debug action (`handleDebugKeys`), released alone
//! it toggles the debug overlay (`key.debug.overlay`, F3 too by default);
//! with Escape it pauses without the menu; held with `key.debug.crash` (C)
//! for ten seconds it crashes the game (`tick`).
use crate::keybinds::KeyBinds;
/// A debug mapping's action, as `handleDebugKeys` tests them.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DebugAction {
ReloadChunks,
ShowHitboxes,
ClearChat,
ShowChunkBorders,
AdvancedTooltips,
CopyRecreateCommand,
Spectate,
SwitchGameMode,
DebugOptions,
FocusPause,
DumpDynamicTextures,
ReloadResourcePacks,
Profiling,
CopyLocation,
DumpVersion,
ProfilingChart,
FpsCharts,
NetworkCharts,
LightmapTexture,
ImprovedTransparency,
}
/// The mappings `handleDebugKeys` tests, in its order.
pub const ACTIONS: [(&str, DebugAction); 20] = [
("key.debug.reloadChunk", DebugAction::ReloadChunks),
("key.debug.showHitboxes", DebugAction::ShowHitboxes),
("key.debug.clearChat", DebugAction::ClearChat),
("key.debug.showChunkBorders", DebugAction::ShowChunkBorders),
(
"key.debug.showAdvancedTooltips",
DebugAction::AdvancedTooltips,
),
(
"key.debug.copyRecreateCommand",
DebugAction::CopyRecreateCommand,
),
("key.debug.spectate", DebugAction::Spectate),
("key.debug.switchGameMode", DebugAction::SwitchGameMode),
("key.debug.debugOptions", DebugAction::DebugOptions),
("key.debug.focusPause", DebugAction::FocusPause),
(
"key.debug.dumpDynamicTextures",
DebugAction::DumpDynamicTextures,
),
(
"key.debug.reloadResourcePacks",
DebugAction::ReloadResourcePacks,
),
("key.debug.profiling", DebugAction::Profiling),
("key.debug.copyLocation", DebugAction::CopyLocation),
("key.debug.dumpVersion", DebugAction::DumpVersion),
("key.debug.profilingChart", DebugAction::ProfilingChart),
("key.debug.fpsCharts", DebugAction::FpsCharts),
("key.debug.networkCharts", DebugAction::NetworkCharts),
("key.debug.lightmapTexture", DebugAction::LightmapTexture),
(
"key.debug.improvedTransparency",
DebugAction::ImprovedTransparency,
),
];
/// GLFW's key actions.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum KeyAction {
Release,
Press,
Repeat,
}
/// The screen open when a key reaches the game (after the screen itself
/// passed on it).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OpenScreen {
None,
/// `PauseScreen` without its menu (F3+Escape).
PauseWithoutMenu,
GameModeSwitcher,
Other,
}
/// What the game does for `KeyboardHandler.keyPress`.
pub trait DebugHost {
fn screen(&self) -> OpenScreen;
/// `DebugScreenEntries.toggleDebugOverlay`.
fn toggle_overlay(&mut self);
/// `Minecraft.pauseGame(suppressPauseMenu)`.
fn pause_game(&mut self, without_menu: bool);
/// One matching mapping of `handleDebugKeys`; whether its condition held
/// (vanilla's `debugAction = true`). `shift`: `event.hasShiftDown()`.
fn debug_action(&mut self, action: DebugAction, shift: bool) -> bool;
}
/// What `KeyboardHandler.tick` reports while the debug crash keys are held.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CrashNotice {
/// `debug.crash.message`, a second after the keys went down.
Message,
/// `debug.crash.warning` with the seconds left.
Warning(i32),
/// "Manually triggered debug crash".
Crash,
}
/// `KeyboardHandler`'s state, with the down state of `keyDebugModifier`.
#[derive(Clone, Debug, Default)]
pub struct DebugKeys {
pub used_debug_key_as_modifier: bool,
/// `debugCrashKeyTime`: when the crash keys went down (milliseconds),
/// 0 never, -1 released.
pub crash_key_time: i64,
pub crash_key_reported_time: i64,
pub crash_key_reported_count: i64,
/// `keyDebugModifier.isDown()`.
pub modifier_down: bool,
}
impl DebugKeys {
/// `keyPress` once the open screen (if any) did not take the key. `key`
/// is the physical key's name (`key.keyboard.f3`); `crash_key_down`
/// whether the crash mapping's key is held (`InputConstants.isKeyDown`).
/// Returns whether the key goes on to the game's key mappings
/// (`KeyMapping.set(key, true)` and `click`): only without a screen and
/// when it ran no debug action.
#[allow(clippy::too_many_arguments)]
pub fn key_press(
&mut self,
host: &mut impl DebugHost,
binds: &KeyBinds,
key: &str,
action: KeyAction,
shift: bool,
crash_key_down: bool,
now: i64,
) -> bool {
let modifier = binds.get("key.debug.modifier");
let overlay = binds.get("key.debug.overlay");
let same = modifier == overlay;
let modifier_down = self.modifier_down;
let crash = binds.get("key.debug.crash") != "key.keyboard.unknown" && crash_key_down;
if self.crash_key_time > 0 {
if !crash || !modifier_down {
self.crash_key_time = -1;
}
} else if crash && modifier_down {
self.used_debug_key_as_modifier = same;
self.crash_key_time = now;
self.crash_key_reported_time = now;
self.crash_key_reported_count = 0;
}
let screen = host.screen();
let handles_game = screen == OpenScreen::None;
let handles_global = handles_game
|| matches!(
screen,
OpenScreen::PauseWithoutMenu | OpenScreen::GameModeSwitcher
);
if same && key == modifier && action == KeyAction::Release {
if self.used_debug_key_as_modifier {
self.used_debug_key_as_modifier = false;
} else {
host.toggle_overlay();
}
} else if !same && key == overlay && action == KeyAction::Press {
host.toggle_overlay();
}
if action == KeyAction::Release {
// KeyMapping.set(key, false).
if key == modifier {
self.modifier_down = false;
}
return false;
}
let mut did = false;
if handles_global && key == "key.keyboard.escape" {
host.pause_game(modifier_down);
did = modifier_down;
} else if modifier_down {
did = self.handle_debug_keys(host, binds, key, shift, now);
}
if same {
self.used_debug_key_as_modifier |= did;
}
// KeyMapping.set(key, !did) for the game, setDown(!did) behind a screen.
if key == modifier {
self.modifier_down = !did;
}
handles_game && !did
}
/// `handleDebugKeys`: every debug mapping on this key, in order.
fn handle_debug_keys(
&mut self,
host: &mut impl DebugHost,
binds: &KeyBinds,
key: &str,
shift: bool,
now: i64,
) -> bool {
// Once the crash keys have been down a tenth of a second.
if self.crash_key_time > 0 && self.crash_key_time < now - 100 {
return true;
}
let mut did = false;
for (name, action) in ACTIONS {
if binds.get(name) == key {
did |= host.debug_action(action, shift);
}
}
did
}
/// `KeyboardHandler.tick`.
pub fn tick(&mut self, now: i64) -> Option<CrashNotice> {
if self.crash_key_time <= 0 {
return None;
}
let remaining = 10000 - (now - self.crash_key_time);
let reported = now - self.crash_key_reported_time;
if remaining < 0 {
return Some(CrashNotice::Crash);
}
if reported >= 1000 {
let notice = if self.crash_key_reported_count == 0 {
CrashNotice::Message
} else {
// Mth.ceil(remainingTime / 1000.0F).
CrashNotice::Warning((remaining as f32 / 1000.0).ceil() as i32)
};
self.crash_key_reported_time = now;
self.crash_key_reported_count += 1;
return Some(notice);
}
None
}
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Default)]
struct Host {
screen: Option<OpenScreen>,
overlay: u32,
paused: Vec<bool>,
actions: Vec<(DebugAction, bool)>,
/// Actions whose condition fails (no player, reduced debug info...).
refused: Vec<DebugAction>,
}
impl DebugHost for Host {
fn screen(&self) -> OpenScreen {
self.screen.unwrap_or(OpenScreen::None)
}
fn toggle_overlay(&mut self) {
self.overlay += 1;
}
fn pause_game(&mut self, without_menu: bool) {
self.paused.push(without_menu);
}
fn debug_action(&mut self, action: DebugAction, shift: bool) -> bool {
self.actions.push((action, shift));
!self.refused.contains(&action)
}
}
const F3: &str = "key.keyboard.f3";
fn press(k: &mut DebugKeys, h: &mut Host, b: &KeyBinds, key: &str, now: i64) -> bool {
k.key_press(h, b, key, KeyAction::Press, false, false, now)
}
fn release(k: &mut DebugKeys, h: &mut Host, b: &KeyBinds, key: &str) -> bool {
k.key_press(h, b, key, KeyAction::Release, false, false, 0)
}
#[test]
fn f3_alone_toggles_the_overlay_on_release() {
let (mut k, mut h, b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
// The F3 press goes to the game's mappings (key.debug.* are down now).
assert!(press(&mut k, &mut h, &b, F3, 0));
assert!(k.modifier_down);
assert_eq!(h.overlay, 0);
assert!(!release(&mut k, &mut h, &b, F3));
assert_eq!(h.overlay, 1);
assert!(!k.modifier_down);
}
#[test]
fn a_combination_runs_its_action_and_keeps_the_overlay() {
let (mut k, mut h, b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
press(&mut k, &mut h, &b, F3, 0);
// F3+G: the action, and G does not reach the game.
assert!(!press(&mut k, &mut h, &b, "key.keyboard.g", 10));
assert_eq!(h.actions, [(DebugAction::ShowChunkBorders, false)]);
release(&mut k, &mut h, &b, "key.keyboard.g");
release(&mut k, &mut h, &b, F3);
assert_eq!(h.overlay, 0);
// The next F3 alone toggles again.
press(&mut k, &mut h, &b, F3, 20);
release(&mut k, &mut h, &b, F3);
assert_eq!(h.overlay, 1);
}
#[test]
fn c_copies_the_location_and_both_c_mappings_share_the_key() {
let (mut k, mut h, b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
press(&mut k, &mut h, &b, F3, 0);
k.key_press(
&mut h,
&b,
"key.keyboard.c",
KeyAction::Press,
true,
true,
5,
);
assert_eq!(h.actions, [(DebugAction::CopyLocation, true)]);
// The crash keys are down: from a tenth of a second on, debug keys
// are swallowed.
assert_eq!(k.crash_key_time, 5);
k.key_press(
&mut h,
&b,
"key.keyboard.c",
KeyAction::Repeat,
false,
true,
50,
);
assert_eq!(h.actions.len(), 2);
assert!(!k.key_press(
&mut h,
&b,
"key.keyboard.c",
KeyAction::Repeat,
false,
true,
200
));
assert_eq!(h.actions.len(), 2);
}
#[test]
fn held_crash_keys_warn_every_second_then_crash() {
let (mut k, mut h, b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
press(&mut k, &mut h, &b, F3, 0);
k.key_press(
&mut h,
&b,
"key.keyboard.c",
KeyAction::Press,
false,
true,
1000,
);
assert_eq!(k.tick(1500), None);
assert_eq!(k.tick(2000), Some(CrashNotice::Message));
assert_eq!(k.tick(2999), None);
assert_eq!(k.tick(3000), Some(CrashNotice::Warning(8)));
assert_eq!(k.tick(4100), Some(CrashNotice::Warning(7)));
assert_eq!(k.tick(11_000), Some(CrashNotice::Warning(0)));
assert_eq!(k.tick(11_001), Some(CrashNotice::Crash));
// Releasing either key stops it on the next key event.
let mut k2 = DebugKeys::default();
press(&mut k2, &mut h, &b, F3, 0);
k2.key_press(
&mut h,
&b,
"key.keyboard.c",
KeyAction::Press,
false,
true,
1000,
);
k2.key_press(
&mut h,
&b,
"key.keyboard.c",
KeyAction::Release,
false,
false,
1200,
);
assert_eq!(k2.crash_key_time, -1);
assert_eq!(k2.tick(20_000), None);
// The crash used F3 as a modifier: its release does not toggle the overlay.
release(&mut k2, &mut h, &b, F3);
assert_eq!(h.overlay, 0);
}
#[test]
fn refused_actions_do_not_count() {
let (mut k, mut h, b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
h.refused.push(DebugAction::ShowHitboxes);
press(&mut k, &mut h, &b, F3, 0);
// F3+B without a player (or with reduced debug info): B reaches the
// game and F3's release still toggles the overlay.
assert!(press(&mut k, &mut h, &b, "key.keyboard.b", 1));
release(&mut k, &mut h, &b, F3);
assert_eq!(h.overlay, 1);
}
#[test]
fn escape_pauses_with_or_without_the_menu() {
let (mut k, mut h, b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
assert!(press(&mut k, &mut h, &b, "key.keyboard.escape", 0));
press(&mut k, &mut h, &b, F3, 1);
assert!(!press(&mut k, &mut h, &b, "key.keyboard.escape", 2));
assert_eq!(h.paused, [false, true]);
release(&mut k, &mut h, &b, F3);
assert_eq!(h.overlay, 0);
// Behind another screen, Escape is the screen's.
h.screen = Some(OpenScreen::Other);
press(&mut k, &mut h, &b, "key.keyboard.escape", 3);
assert_eq!(h.paused.len(), 2);
}
#[test]
fn behind_a_screen_combinations_work_but_keys_stay_with_the_screen() {
let (mut k, mut h, b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
h.screen = Some(OpenScreen::Other);
assert!(!press(&mut k, &mut h, &b, F3, 0));
assert!(k.modifier_down);
assert!(!press(&mut k, &mut h, &b, "key.keyboard.h", 1));
assert_eq!(h.actions, [(DebugAction::AdvancedTooltips, false)]);
release(&mut k, &mut h, &b, F3);
assert_eq!(h.overlay, 0);
}
#[test]
fn a_separate_overlay_key_toggles_on_press() {
let (mut k, mut h, mut b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
b.set("key.debug.overlay", "key.keyboard.f7");
press(&mut k, &mut h, &b, "key.keyboard.f7", 0);
assert_eq!(h.overlay, 1);
press(&mut k, &mut h, &b, F3, 1);
release(&mut k, &mut h, &b, F3);
assert_eq!(h.overlay, 1);
}
#[test]
fn rebound_mappings_follow_their_keys() {
let (mut k, mut h, mut b) = (DebugKeys::default(), Host::default(), KeyBinds::default());
b.set("key.debug.showChunkBorders", "key.keyboard.k");
press(&mut k, &mut h, &b, F3, 0);
assert!(press(&mut k, &mut h, &b, "key.keyboard.g", 1));
press(&mut k, &mut h, &b, "key.keyboard.k", 2);
assert_eq!(h.actions, [(DebugAction::ShowChunkBorders, false)]);
}
}
+3
View File
@@ -284,6 +284,7 @@ impl PlayerEffects {
resistance: self.amplifier("resistance"),
fire_resistance: self.get("fire_resistance").is_some(),
dolphins_grace: self.get("dolphins_grace").is_some(),
weaving: self.get("weaving").is_some(),
water_breathing: self.get("water_breathing").is_some()
|| self.get("conduit_power").is_some(),
protection: Vec::new(),
@@ -380,6 +381,8 @@ pub struct StatusFlags {
pub resistance: Option<i32>,
pub fire_resistance: bool,
pub dolphins_grace: bool,
/// Weaving: cobwebs hold half as much (`WebBlock.entityInside`).
pub weaving: bool,
pub water_breathing: bool,
/// Armor enchantment protection per damage type id (`EnchantmentHelper.getDamageProtection`).
pub protection: Vec<(String, f32)>,
+153 -63
View File
@@ -16,6 +16,7 @@ mod bossbars;
mod breezes;
mod cartography;
mod chat;
mod clipboard;
mod combat;
mod command_harness;
mod commands;
@@ -25,6 +26,7 @@ mod copper_golems;
mod creaking;
mod creatures;
mod crossbow;
mod debug_keys;
mod dedicated;
mod dispense_fixture;
mod dispenser;
@@ -44,12 +46,14 @@ mod golems;
mod growth;
mod hand;
mod item_draw;
mod item_particles;
mod jukebox;
mod lan;
mod lan_actions;
mod lan_screen;
mod lan_trading;
mod leads;
mod level_particles;
mod lightning;
mod llamas;
mod loom;
@@ -242,7 +246,7 @@ impl Options {
match arg.as_str() {
"--help" | "-h" => {
println!(
"Horizon — Minecraft Java Edition 26.3 in Rust\n\n --resources PATH Prepared resources (tools/prepare_native_client.py)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --smoke-report PATH Write a JSON report on exit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default Player)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause."
"Horizon — Minecraft Java Edition 26.3 in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --smoke-report PATH Write a JSON report on exit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default Player)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause."
);
return Ok(None);
}
@@ -623,6 +627,10 @@ struct Game<'a> {
cursor: (f32, f32),
captured: bool,
focused: bool,
/// The keyboard's modifier state (`KeyEvent.modifiers`).
modifiers: winit::keyboard::ModifiersState,
/// The window's fullscreen request and reported state.
fullscreen: horizon_client::window::FullscreenState,
/// MouseHandler's accumulated look and wheel state.
mouse: MouseLook,
/// `Options.smoothCamera` (cinematic camera), not persisted.
@@ -830,6 +838,19 @@ struct Game<'a> {
/// This world is open to the network (game/lan.rs).
lan: Option<lan::LanHost>,
world_options: Option<lan_screen::WorldOptions>,
/// KeyboardHandler's debug key state (game/debug_keys.rs), the physical
/// keys held, and the debug renderers F3+B and F3+G switch on.
debug_keys: horizon_client::debug_keys::DebugKeys,
show_hitboxes: bool,
show_chunk_borders: bool,
/// PauseScreen.showPauseMenu (false after F3+Escape).
pause_menu: bool,
/// MultiPlayerGameMode.previousLocalPlayerMode (F3+N goes back to it).
previous_mode: Option<horizon_client::command::args::GameMode>,
/// The system clipboard (`KeyboardHandler.clipboardManager`).
clipboard: horizon_client::clipboard::SystemClipboard,
/// Select All in the append-only text fields.
text_selection: horizon_client::clipboard::AppendSelection,
/// The world was saved for the application ending (`save_for_exit`).
saved_for_exit: bool,
/// The block a guest is acting on (game/lan_actions.rs).
@@ -1584,6 +1605,11 @@ impl Game<'_> {
data,
} => self.sculk_charge_event(pos, data),
LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos),
LevelEvent::LevelEvent {
id: id @ 3002..=3005,
pos,
data,
} => self.block_particle_event(id, pos, data),
LevelEvent::LevelEvent {
id: 1500,
pos,
@@ -2348,11 +2374,13 @@ impl Game<'_> {
return;
}
let duration = 32;
let ticks = ticks + 1;
// Consumable.shouldEmitParticlesAndSounds(useItemRemainingTicks), with
// the remaining ticks before this tick counts down: every 4 ticks once
// more than 21.875% of the time has passed (none on the last tick).
let remaining = duration - ticks.min(duration);
let ticks = ticks + 1;
let eye = self.eye_position().unwrap_or_default();
// Consumable.shouldEmitParticlesAndSounds: every 4 ticks in the last 25.
if remaining <= 25 && remaining % 4 == 0 {
if duration - remaining > (duration as f32 * 0.21875) as u32 && remaining % 4 == 0 {
let pitch =
(self.world.random.next_float() - self.world.random.next_float()) * 0.2 + 1.0;
self.audio.play(
@@ -2361,38 +2389,12 @@ impl Game<'_> {
0.5 + 0.5 * self.world.random.next_int_bound(2).unwrap_or(0) as f32,
pitch,
);
// `ItemParticleOption`: the particle material of a random layer of
// the stack resolved for the ground (`BreakingItemParticle`).
let state = self.resolve_item(
&stack,
horizon_assets::item_model::DisplayContext::Ground,
None,
0,
);
if let Some(sprite) = state.pick_particle(&mut self.world.random) {
let (yaw, pitch) = (
f64::from(self.yaw).to_radians(),
f64::from(self.pitch).to_radians(),
);
let at = [
eye[0] - yaw.sin() * pitch.cos() * 0.3,
eye[1] - 0.1,
eye[2] + yaw.cos() * pitch.cos() * 0.3,
];
for _ in 0..5 {
let v = [
(f64::from(self.world.random.next_float()) - 0.5) * 0.1,
0.1,
(f64::from(self.world.random.next_float()) - 0.5) * 0.1,
];
let p =
Particle::terrain(&mut self.world.random, at, v, sprite.clone(), 0xFFFFFF);
self.particles.push(p);
}
}
self.eat_particles(&stack, 5);
}
if ticks >= duration {
self.using = None;
// Consumable.onConsume: emitParticlesAndSounds(..., 16).
self.eat_particles(&stack, 16);
// Consumable.onConsume.
self.post_entity_event("minecraft:eat", horizon_client::mobs::Who::Player);
if let Some((nutrition, saturation)) = info.food
@@ -2673,6 +2675,7 @@ impl Game<'_> {
Ok(())
}
fn tick(&mut self) -> Result<()> {
self.tick_debug_keys()?;
if self.remote.is_some() {
return self.tick_remote();
}
@@ -3385,7 +3388,20 @@ impl Game<'_> {
self.draw_chat(&mut batch);
self.draw_tab_list(&mut batch);
match self.screen {
Screen::Paused => self.draw_pause_menu(&mut batch),
Screen::Paused if self.pause_menu => self.draw_pause_menu(&mut batch),
// PauseScreen(false): only its title, at the top.
Screen::Paused => {
let title = self.translate("menu.paused", "Game Paused");
let tw = HudBatch::text_width(&self.res.atlas, &title);
batch.text(
&self.res.atlas,
&title,
((batch.width / 2.0).floor() - (tw / 2.0).floor()).floor(),
10.0,
u32::MAX,
true,
);
}
Screen::Dead => self.draw_death_screen(&mut batch),
Screen::Stats => self.draw_stats(&mut batch),
Screen::Advancements => self.draw_advancements(&mut batch),
@@ -5727,7 +5743,7 @@ impl Game<'_> {
)
} else {
let inner = Arc::new(VanillaTerrain::for_dimension(&self.options.resources.join("worldgen"), res.assets.registry, &res.biomes, seed, dim.id()).map_err(|e| {
format!("{e}\nPrepare the worldgen bundle with: python3 tools/prepare_native_client.py")
format!("{e}\nPrepare the worldgen bundle with the launcher, or: horizon-prepare --prepare")
})?);
self.end.set_locator(Some(inner.clone()));
Streaming::new(
@@ -6403,7 +6419,7 @@ impl Game<'_> {
_ => "east",
};
let registry = self.res.assets.registry;
let (state, sound, loot, damage) = {
let (state, sound, loot, damage, particle) = {
let around = Column {
world: &self.world,
registry,
@@ -6416,12 +6432,25 @@ impl Game<'_> {
else {
return Ok(false);
};
(state, t.sound.clone(), t.loot.clone(), t.damage)
(
state,
t.sound.clone(),
t.loot.clone(),
t.damage,
t.particle.clone(),
)
};
let Ok(new) = registry.resolve(&state) else {
return Ok(false);
};
self.level_set(pos, new)?;
// BlockTransformer.TransformParticle.send.
match particle.as_str() {
"scrape" => self.level_event_at(3005, pos, 0),
"wax_on" => self.level_event_at(3003, pos, 0),
"wax_off" => self.level_event_at(3004, pos, 0),
_ => {}
}
if loot.as_deref() == Some("minecraft:till/rooted_dirt") {
self.pop_resource(
[pos[0] + face[0], pos[1] + face[1], pos[2] + face[2]],
@@ -6614,6 +6643,7 @@ impl Game<'_> {
&& let Ok(state) = registry.resolve(&waxed)
{
self.level_set(hit.pos, state)?;
self.level_event_at(3003, hit.pos, 0);
self.audio.play(
"minecraft:item.honeycomb.wax_on",
Some(at(hit.pos)),
@@ -7739,6 +7769,18 @@ impl Game<'_> {
sky.sky_color = [0.9, 0.9, 1.0];
sky.sky_light_factor = 1.0;
}
// DebugRenderer: chunk borders and hitboxes (F3+G, F3+B).
let (debug_lines, debug_lines_on_top) = if self.show_hitboxes || self.show_chunk_borders {
let g = self.debug_gizmos(alpha as f32);
let view = horizon_client::camera::view_matrix(view_yaw, view_pitch);
let at = camera.to_array();
(
horizon_client::gizmos::camera_relative(&g.lines, at, view),
horizon_client::gizmos::camera_relative(&g.on_top, at, view),
)
} else {
(Vec::new(), Vec::new())
};
// LevelRenderer.renderHitOutline: the outline shape's edges.
let outline = if self.screen == Screen::Playing && !self.spectator() {
self.pick()
@@ -7891,6 +7933,8 @@ impl Game<'_> {
}),
dark_disc: self.dark_disc(camera),
outline,
debug_lines: &debug_lines,
debug_lines_on_top: &debug_lines_on_top,
hud: &hud,
entities: &entities,
additive: &additive,
@@ -7981,6 +8025,7 @@ impl Game<'_> {
Screen::Options => self.options_key(KeyCode::Escape, None)?,
Screen::Playing => {
self.screen = Screen::Paused;
self.pause_menu = true;
self.capture(false);
}
Screen::Creative => {
@@ -7991,6 +8036,7 @@ impl Game<'_> {
Screen::Paused | Screen::Inventory => {
self.close_container();
self.screen = Screen::Playing;
self.pause_menu = true;
self.capture(true);
}
Screen::Dead => {}
@@ -8050,7 +8096,6 @@ impl Game<'_> {
}
_ => {}
},
KeyCode::F3 => self.debug = !self.debug,
// key.swapOffhand: ServerboundPlayerActionPacket SWAP_ITEM_WITH_OFFHAND.
KeyCode::KeyF if self.screen == Screen::Playing => {
std::mem::swap(&mut self.offhand, &mut self.inventory[self.selected]);
@@ -8224,10 +8269,14 @@ impl ApplicationHandler for Game<'_> {
if self.window.is_some() {
return;
}
// The Window constructor: created fullscreen when options.txt says so.
let fullscreen = self.settings.fullscreen;
self.fullscreen = horizon_client::window::FullscreenState::new(fullscreen);
let window = match event_loop.create_window(
Window::default_attributes()
.with_title("Horizon")
.with_inner_size(winit::dpi::LogicalSize::new(1280.0, 720.0)),
.with_inner_size(winit::dpi::LogicalSize::new(1280.0, 720.0))
.with_fullscreen(fullscreen.then_some(winit::window::Fullscreen::Borderless(None))),
) {
Ok(w) => Arc::new(w),
Err(e) => {
@@ -8263,6 +8312,26 @@ impl ApplicationHandler for Game<'_> {
if let WindowEvent::Focused(false) = &event {
self.physical_keys.clear();
}
if let WindowEvent::ModifiersChanged(m) = &event {
self.modifiers = m.state();
}
// KeyboardHandler.keyPress: the debug keys come before the game's.
if let WindowEvent::KeyboardInput {
event: key_event, ..
} = &event
&& let PhysicalKey::Code(key) = key_event.physical_key
&& self.title.is_none()
{
use horizon_client::debug_keys::KeyAction;
let action = match (key_event.state, key_event.repeat) {
(ElementState::Released, _) => KeyAction::Release,
(_, false) => KeyAction::Press,
(_, true) => KeyAction::Repeat,
};
if self.debug_key(key, action) {
return;
}
}
if matches!(
event,
WindowEvent::KeyboardInput { .. }
@@ -8291,6 +8360,7 @@ impl ApplicationHandler for Game<'_> {
if let Some(r) = &mut self.renderer {
r.resize(size.width, size.height);
}
self.observe_fullscreen();
}
WindowEvent::Focused(focused) => {
self.focused = focused;
@@ -8303,6 +8373,7 @@ impl ApplicationHandler for Game<'_> {
if self.screen == Screen::Playing
&& self.player.is_some()
&& !self.options.no_pause
&& self.settings.file.bool("pauseOnLostFocus")
&& self.book.is_none()
&& self.sign_edit.is_none()
{
@@ -8481,7 +8552,7 @@ impl ApplicationHandler for Game<'_> {
Screen::Creative if button == MouseButton::Left => {
self.creative_screen.release();
}
Screen::Paused if pressed => self.pause_click()?,
Screen::Paused if pressed && self.pause_menu => self.pause_click()?,
Screen::WorldOptions if pressed && button == MouseButton::Left => {
self.world_options_click()
}
@@ -8527,19 +8598,12 @@ impl ApplicationHandler for Game<'_> {
&& event.state == ElementState::Pressed
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
{
match event.physical_key {
PhysicalKey::Code(KeyCode::Backspace) => {
self.creative_screen.search.pop();
}
_ => {
if let Some(text) = &event.text {
self.creative_screen
.search
.extend(text.chars().filter(|c| !c.is_control()));
}
}
if let Some(shortcut) = self.edit_shortcut(&event) {
self.creative_search_shortcut(shortcut);
} else {
let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
self.creative_search_edit(event.text.as_deref(), backspace);
}
self.creative_screen.scroll = 0.0;
}
WindowEvent::KeyboardInput { event, .. }
if self.recipe_search_focused()
@@ -8555,8 +8619,12 @@ impl ApplicationHandler for Game<'_> {
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
{
// The anvil rename box takes every key but Escape (AnvilScreen.keyPressed).
let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
self.station_text(event.text.as_deref(), backspace);
if let Some(shortcut) = self.edit_shortcut(&event) {
self.station_shortcut(shortcut);
} else {
let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
self.station_text(event.text.as_deref(), backspace);
}
}
WindowEvent::KeyboardInput { event, .. } if self.remote_chat_open() => {
self.remote_chat_key(&event)
@@ -8565,6 +8633,11 @@ impl ApplicationHandler for Game<'_> {
self.world_options_key(&event)
}
WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::Options => {
if let Some(shortcut) = self.edit_shortcut(&event)
&& self.options_shortcut(shortcut)
{
return Ok(());
}
if event.state == ElementState::Pressed
&& let PhysicalKey::Code(key) = event.physical_key
{
@@ -8573,18 +8646,25 @@ impl ApplicationHandler for Game<'_> {
}
WindowEvent::KeyboardInput { event, .. } if self.title.is_some() => {
if event.state == ElementState::Pressed
&& let Some(title) = self.title.as_mut()
&& !title.skip_opening()
&& self.title.as_ref().is_some_and(|t| !t.skip_opening())
{
if let Some(shortcut) = self.edit_shortcut(&event) {
self.title_shortcut(shortcut);
return Ok(());
}
match event.physical_key {
PhysicalKey::Code(KeyCode::Backspace) => title.backspace(),
PhysicalKey::Code(KeyCode::Tab) => title.tab(),
PhysicalKey::Code(KeyCode::Escape) => title.escape(),
_ => {
if let Some(text) = &event.text {
title.type_text(text);
PhysicalKey::Code(KeyCode::Backspace) => self.title_edit(None, true),
PhysicalKey::Code(KeyCode::Tab) => {
if let Some(t) = self.title.as_mut() {
t.tab();
}
}
PhysicalKey::Code(KeyCode::Escape) => {
if let Some(t) = self.title.as_mut() {
t.escape();
}
}
_ => self.title_edit(event.text.as_deref(), false),
}
}
}
@@ -8644,6 +8724,7 @@ impl ApplicationHandler for Game<'_> {
self.key_pressed(key)?;
}
WindowEvent::RedrawRequested => {
self.observe_fullscreen();
let now = Instant::now();
let elapsed = now.duration_since(self.previous);
self.frame_ticks = elapsed.as_secs_f32() * 20.0;
@@ -8850,7 +8931,7 @@ pub fn run() -> Result<()> {
}
Err(e) => {
return Err(format!(
"{e}\nPrepare resources with: python3 tools/prepare_native_client.py --prepare"
"{e}\nPrepare resources with the launcher, or: horizon-prepare --prepare"
)
.into());
}
@@ -9031,6 +9112,8 @@ pub fn run() -> Result<()> {
cursor: (0.0, 0.0),
captured: false,
focused: true,
modifiers: winit::keyboard::ModifiersState::empty(),
fullscreen: horizon_client::window::FullscreenState::new(false),
mouse: MouseLook::default(),
smooth_camera: false,
toggles: Default::default(),
@@ -9184,6 +9267,13 @@ pub fn run() -> Result<()> {
remote: None,
lan: None,
world_options: None,
debug_keys: Default::default(),
show_hitboxes: false,
show_chunk_borders: false,
pause_menu: true,
previous_mode: None,
clipboard: Default::default(),
text_selection: Default::default(),
saved_for_exit: false,
forced_hit: None,
lan_events: Vec::new(),
+1 -1
View File
@@ -271,7 +271,7 @@ pub(super) enum Handled {
}
impl Game<'_> {
fn state_string(&self, state: BlockStateId) -> String {
pub(super) fn state_string(&self, state: BlockStateId) -> String {
let Some(s) = self.res.assets.registry.state(state) else {
return "?".into();
};
+3 -15
View File
@@ -139,21 +139,9 @@ impl Game<'_> {
{
c.extra.egg_time = 6000;
}
for _ in 0..3 {
let r = &mut self.world.random;
let p = [
at[0] + r.next_double() - 0.5,
at[1] + 0.5 + r.next_double() * 0.6,
at[2] + r.next_double() - 0.5,
];
if let Some(ty) = horizon_client::particles::ParticleType::from_name("heart") {
self.particles.add(
&horizon_client::particles::ParticleOptions::simple(ty),
p,
[0.0; 3],
);
}
}
// Allay.duplicateAllay: entity event 18, three spawnHeartParticle.
let id = self.mobs[index].id;
self.particles_around_mob(id, "heart", horizon_client::particles::Burst::ALLAY);
self.audio
.play("minecraft:block.amethyst_block.chime", Some(at), 2.0, 1.0);
self.consume_held();
+77 -5
View File
@@ -24,6 +24,8 @@ const BLACK: u32 = 0xFF00_0000;
const PAGE_CHARS: usize = 1024;
const MAX_PAGES: usize = 100;
const LINES: usize = 14;
/// `BookSignScreen`'s title box.
const BOOK_TITLE: horizon_client::clipboard::FieldId = ("book.title", 0);
pub(super) enum BookScreen {
Edit {
@@ -129,6 +131,10 @@ impl Game<'_> {
if event.state != ElementState::Pressed {
return;
}
if let Some(shortcut) = self.edit_shortcut(event) {
self.book_shortcut(shortcut);
return;
}
let key = match event.physical_key {
PhysicalKey::Code(k) => Some(k),
_ => None,
@@ -151,7 +157,9 @@ impl Game<'_> {
}
}
Some(KeyCode::Backspace) => {
title.pop();
if !self.text_selection.take(BOOK_TITLE, title) {
title.pop();
}
}
Some(KeyCode::Enter | KeyCode::NumpadEnter) => {
if !title.trim().is_empty() {
@@ -160,6 +168,7 @@ impl Game<'_> {
}
_ => {
if let Some(typed) = event.text.as_ref() {
self.text_selection.take(BOOK_TITLE, title);
for c in typed.chars().filter(|c| !c.is_control()) {
if title.chars().count() < 15 {
title.push(c);
@@ -172,13 +181,23 @@ impl Game<'_> {
Some(KeyCode::Escape) => self.save_book(false),
Some(KeyCode::PageUp) => self.turn_page(false),
Some(KeyCode::PageDown) => self.turn_page(true),
Some(KeyCode::Backspace) => self.edit_page(|p| {
p.pop();
}),
Some(KeyCode::Enter | KeyCode::NumpadEnter) => self.type_into_page("\n"),
Some(KeyCode::Backspace) => {
if !self.take_page_selection() {
self.edit_page(|p| {
p.pop();
})
}
}
Some(KeyCode::Enter | KeyCode::NumpadEnter) => {
self.take_page_selection();
self.type_into_page("\n")
}
_ => {
if let Some(typed) = event.text.as_ref().map(|t| t.to_string()) {
let typed: String = typed.chars().filter(|c| !c.is_control()).collect();
if !typed.is_empty() {
self.take_page_selection();
}
self.type_into_page(&typed);
}
}
@@ -205,6 +224,59 @@ impl Game<'_> {
_ => {}
}
}
/// Before typing on a page: Select All's selection is cleared (true).
fn take_page_selection(&mut self) -> bool {
match self.book.as_mut() {
Some(BookScreen::Edit { pages, page, .. }) => self
.text_selection
.take(("book.page", *page), &mut pages[*page]),
_ => false,
}
}
/// Ctrl+A/C/V/X: the title box (an `EditBox` of 15) while signing, else
/// the page (`MultilineTextField.insertText`: line breaks kept, cut to
/// the 1024 characters left, rejected when it overflows the 14 lines).
fn book_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
let font = &self.res.atlas.font;
match self.book.as_mut() {
Some(BookScreen::Edit {
signing: true,
title,
..
}) => {
Self::append_shortcut(
&mut self.text_selection,
&mut self.clipboard,
BOOK_TITLE,
title,
shortcut,
15,
);
}
Some(BookScreen::Edit { pages, page, .. }) => {
// truncateInsertionText counts the whole value, selection included.
let room = PAGE_CHARS.saturating_sub(pages[*page].chars().count());
self.text_selection.apply(
("book.page", *page),
&mut pages[*page],
shortcut,
&mut self.clipboard,
|value, pasted| {
let text: String = horizon_client::clipboard::filter_text(pasted, true)
.chars()
.take(room)
.collect();
let next = format!("{value}{text}");
font.split(&Text::literal(&next), 114.0).len() <= LINES && {
*value = next;
true
}
},
);
}
_ => {}
}
}
fn edit_page(&mut self, f: impl FnOnce(&mut String)) {
if let Some(BookScreen::Edit { pages, page, .. }) = self.book.as_mut() {
f(&mut pages[*page]);
+11
View File
@@ -418,6 +418,17 @@ impl Game<'_> {
}
/// Keys while the chat screen is open.
pub(super) fn chat_key(&mut self, event: &KeyEvent) {
if let Some(shortcut) = self.edit_shortcut(event) {
let m = Measure(&self.res.atlas.font);
let c = Commands {
dispatcher: vanilla::game_dispatcher(),
registries: &self.ui.registries,
};
if let Some(screen) = self.ui.chat_screen.as_mut() {
screen.shortcut(&m, &c, shortcut, &mut self.clipboard);
}
return;
}
let PhysicalKey::Code(key) = event.physical_key else {
return;
};
+106
View File
@@ -0,0 +1,106 @@
//! Copy and paste in the text fields: `KeyboardHandler`'s clipboard and the
//! shortcuts of `EditBox`, `MultiLineEditBox` and `TextFieldHelper`.
use super::*;
use horizon_client::clipboard::{self, EditShortcut};
use winit::event::KeyEvent;
impl Game<'_> {
/// `InputWithModifiers.isSelectAll`/`isCopy`/`isPaste`/`isCut` of a key
/// press (or repeat): the keyboard's modifier state, or a modifier key an
/// agent holds.
pub(super) fn edit_shortcut(&self, event: &KeyEvent) -> Option<EditShortcut> {
if event.state != ElementState::Pressed {
return None;
}
let m = self.modifiers;
let held = |keys: [KeyCode; 2]| keys.iter().any(|k| self.keys.contains(k));
// InputQuirks.EDIT_SHORTCUT_KEY_MODIFIER: Cmd on macOS, Ctrl elsewhere.
let edit = if cfg!(target_os = "macos") {
m.super_key() || held([KeyCode::SuperLeft, KeyCode::SuperRight])
} else {
m.control_key() || held([KeyCode::ControlLeft, KeyCode::ControlRight])
};
clipboard::edit_shortcut(
clipboard::shortcut_letter(&event.logical_key, event.physical_key),
edit,
m.shift_key() || held([KeyCode::ShiftLeft, KeyCode::ShiftRight]),
m.alt_key() || held([KeyCode::AltLeft, KeyCode::AltRight]),
)
}
/// A shortcut in an append-only field limited to `max_chars` characters
/// (an `EditBox` with `setMaxLength`). True when the value changed.
pub(super) fn append_shortcut(
selection: &mut clipboard::AppendSelection,
board: &mut clipboard::SystemClipboard,
id: clipboard::FieldId,
value: &mut String,
shortcut: EditShortcut,
max_chars: usize,
) -> bool {
selection.apply(id, value, shortcut, board, |v, t| {
clipboard::append_limited(v, t, max_chars)
})
}
/// Shortcuts on the title, world creation and server screens.
pub(super) fn title_shortcut(&mut self, shortcut: EditShortcut) {
let Some(title) = self.title.as_mut() else {
return;
};
if let Some((id, value, max)) = title.focused_field() {
Self::append_shortcut(
&mut self.text_selection,
&mut self.clipboard,
id,
value,
shortcut,
max,
);
}
}
/// Typing or a backspace in an append-only field of the title screens:
/// Select All's selection is replaced first.
pub(super) fn title_edit(&mut self, typed: Option<&str>, backspace: bool) {
let Some(title) = self.title.as_mut() else {
return;
};
let cleared = title
.focused_field()
.is_some_and(|(id, value, _)| self.text_selection.take(id, value));
if backspace {
if !cleared {
title.backspace();
}
} else if let Some(text) = typed {
title.type_text(text);
}
}
/// Shortcuts in the creative inventory's search box (an `EditBox` of 50).
pub(super) fn creative_search_shortcut(&mut self, shortcut: EditShortcut) {
if Self::append_shortcut(
&mut self.text_selection,
&mut self.clipboard,
("creative.search", 0),
&mut self.creative_screen.search,
shortcut,
CREATIVE_SEARCH_CHARS,
) {
self.creative_screen.scroll = 0.0;
}
}
/// Typing or a backspace in the creative search box.
pub(super) fn creative_search_edit(&mut self, typed: Option<&str>, backspace: bool) {
let search = &mut self.creative_screen.search;
let cleared = self.text_selection.take(("creative.search", 0), search);
if backspace {
if !cleared {
search.pop();
}
} else if let Some(text) = typed {
clipboard::append_limited(search, text, CREATIVE_SEARCH_CHARS);
}
self.creative_screen.scroll = 0.0;
}
}
/// `CreativeModeInventoryScreen`'s search box: `setMaxLength(50)`.
const CREATIVE_SEARCH_CHARS: usize = 50;
+1 -1
View File
@@ -705,7 +705,7 @@ impl Game<'_> {
_ => Ok(0),
}
}
fn set_game_mode(&mut self, mode: GameMode) -> bool {
pub(super) fn set_game_mode(&mut self, mode: GameMode) -> bool {
if self.mode == mode {
return false;
}
@@ -954,16 +954,11 @@ impl Game<'_> {
Ok(1)
}
/// `VersionCommand`: Horizon reports the version it implements.
pub(super) fn cmd_version(&mut self) -> R<i32> {
let send = |g: &mut Self, t: Text| {
if !g.command_source.is_some_and(|s| s.silent) {
g.system_message(t);
}
};
send(self, Text::translate("commands.version.header", &[]));
/// `VersionCommand.dumpVersion`'s lines: Horizon reports the version it
/// implements.
pub(in crate::game) fn version_lines(&self) -> Vec<Text> {
let protocol = horizon_protocol::PROTOCOL_VERSION;
for (key, args) in [
let mut lines: Vec<Text> = [
("commands.version.id", vec![Text::literal(VERSION_ID)]),
("commands.version.name", vec![Text::literal(VERSION_ID)]),
("commands.version.data", vec![num(DATA_VERSION)]),
@@ -981,20 +976,28 @@ impl Game<'_> {
vec![Text::literal("97.1")],
),
("commands.version.pack.data", vec![Text::literal("121.0")]),
] {
send(self, Text::translate(key, &args));
]
.into_iter()
.map(|(key, args)| Text::translate(key, &args))
.collect();
lines.push(Text::translate(
if STABLE {
"commands.version.stable.yes"
} else {
"commands.version.stable.no"
},
&[],
));
lines
}
/// `VersionCommand`.
pub(super) fn cmd_version(&mut self) -> R<i32> {
if !self.command_source.is_some_and(|s| s.silent) {
self.system_message(Text::translate("commands.version.header", &[]));
for line in self.version_lines() {
self.system_message(line);
}
}
send(
self,
Text::translate(
if STABLE {
"commands.version.stable.yes"
} else {
"commands.version.stable.no"
},
&[],
),
);
Ok(1)
}
}
@@ -418,7 +418,30 @@ impl Game<'_> {
.unwrap_or(1.0)
.clamp(0.01, 4.0),
),
ParticleType::Block | ParticleType::FallingDust | ParticleType::DustPillar => {
// ItemParticleOption: an item id, or a stack {id, ...}.
ParticleType::Item => {
let id = match field("item") {
Some(Tag::String(s)) => s.to_string_lossy(),
Some(Tag::Compound(c)) => {
c.get(&"id".into()).and_then(string).unwrap_or_default()
}
_ => String::new(),
};
let id = if id.contains(':') {
id
} else {
format!("minecraft:{id}")
};
self.item_particle(&horizon_client::items::ItemStack::new(&id, 1))
}
ParticleType::ItemSlime | ParticleType::ItemSnowball | ParticleType::ItemCobweb => {
self.ensure_item_particle_sprites();
ParticleOptions::simple(ty)
}
ParticleType::Block
| ParticleType::FallingDust
| ParticleType::DustPillar
| ParticleType::BlockMarker => {
// BlockParticleOption: a block id, or {Name, Properties}.
let text = match field("block_state") {
Some(Tag::String(s)) => s.to_string_lossy(),
+31 -1
View File
@@ -141,6 +141,26 @@ impl Game<'_> {
"key" => {
let key = key_code(arg(1)?).ok_or_else(|| format!("unknown key {}", words[1]))?;
self.require_world()?;
// KeyboardHandler.keyPress: the debug keys see the physical key first.
let physical = key;
{
use horizon_client::debug_keys::KeyAction;
let action = arg(2)?;
if action != "up" {
self.physical_keys.insert(key);
if self.debug_key(key, KeyAction::Press) {
if action == "tap" {
self.physical_keys.remove(&key);
self.debug_key(key, KeyAction::Release);
}
return ok();
}
}
if action == "up" {
self.physical_keys.remove(&key);
self.debug_key(key, KeyAction::Release);
}
}
// Physical key presses follow the key binds like the keyboard does.
let key = if matches!(self.screen, Screen::Chat | Screen::Options) {
key
@@ -171,7 +191,8 @@ impl Game<'_> {
"tap" => {
self.control_key_down(key)?;
self.keys.remove(&key);
self.physical_keys.remove(&key);
self.physical_keys.remove(&physical);
self.debug_key(physical, horizon_client::debug_keys::KeyAction::Release);
}
other => {
return Err(
@@ -561,6 +582,15 @@ impl Game<'_> {
});
json!({
"screen": self.screen_name(),
"debug": {
"overlay": self.debug,
"hitboxes": self.show_hitboxes,
"chunk_borders": self.show_chunk_borders,
"pause_menu": self.pause_menu,
"advanced_tooltips": self.settings.file.bool("advancedItemTooltips"),
"pause_on_lost_focus": self.settings.file.bool("pauseOnLostFocus"),
"clipboard": self.clipboard.copied(),
},
"dimension": self.dim.id(),
"creative": self.creative,
"player": player,
@@ -256,8 +256,13 @@ impl Game<'_> {
self.damage_held_tool();
return true;
}
let block = {
let p = self.mobs[index].position;
[p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]
};
if name == "minecraft:honeycomb" && !waxed {
self.mobs[index].extra.vector[0] = -2.0;
self.level_event_at(3003, block, 0);
self.audio
.play("minecraft:item.honeycomb.wax_on", Some(at), 1.0, 1.0);
self.consume_held();
@@ -267,6 +272,7 @@ impl Game<'_> {
self.mobs[index].extra.vector[0] = -1.0;
self.audio
.play("minecraft:item.axe.scrape", Some(at), 1.0, 1.0);
self.level_event_at(3004, block, 0);
self.damage_held_tool();
return true;
}
@@ -276,6 +282,7 @@ impl Game<'_> {
m.extra.variant = horizon_client::mobs::copper_golem::weather_previous(m.extra.variant);
self.audio
.play("minecraft:item.axe.scrape", Some(at), 1.0, 1.0);
self.level_event_at(3005, block, 0);
self.damage_held_tool();
return true;
}
+50 -33
View File
@@ -903,6 +903,9 @@ impl Game<'_> {
MobEvent::Particles { kind, at, count } => {
// Mob particle bursts (hearts, smoke, splashes) around a point.
if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) {
if kind.starts_with("item_") {
self.ensure_item_particle_sprites();
}
let options = horizon_client::particles::ParticleOptions::simple(ty);
// Count 0: one particle exactly there, at rest.
if count == 0 {
@@ -924,6 +927,19 @@ impl Game<'_> {
}
}
}
MobEvent::AroundSelf {
kind,
feet,
width,
height,
burst,
} => self.particles_around(kind, feet, [width, height], burst),
MobEvent::ParticleAt { kind, at, velocity } => {
if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) {
let options = horizon_client::particles::ParticleOptions::simple(ty);
self.particles.add(&options, at, velocity);
}
}
MobEvent::Experience { at, amount } => self.spawn_orbs(at, amount),
MobEvent::AxolotlSupportPlayer => {
let previous = self
@@ -1779,23 +1795,24 @@ impl Game<'_> {
}
Ok(())
}
/// Item break particles (snowballs, eggs).
/// `Snowball`/`ThrownEgg.handleEntityEvent(3)`: eight crumbs of the
/// thrown item where it broke, at rest for a snowball, scattered by the
/// client entity's random (the particle engine's here) for an egg.
fn item_burst(&mut self, at: [f64; 3], item: &str) {
let sprite = format!("item/{}", item.trim_start_matches("minecraft:"));
let options = self.item_particle(&horizon_client::items::ItemStack::new(item, 1));
let egg = item != "minecraft:snowball";
for _ in 0..8 {
let v = [
(self.world.random.next_double() - 0.5) * 0.08,
self.world.random.next_double() * 0.1,
(self.world.random.next_double() - 0.5) * 0.08,
];
let p = horizon_client::particles::Particle::terrain(
&mut self.world.random,
at,
v,
sprite.clone(),
0xFFFFFF,
);
self.particles.push(p);
let v = if egg {
let r = self.particles.random();
[
(f64::from(r.next_float()) - 0.5) * 0.08,
(f64::from(r.next_float()) - 0.5) * 0.08,
(f64::from(r.next_float()) - 0.5) * 0.08,
]
} else {
[0.0; 3]
};
self.particles.add(&options, at, v);
}
}
/// Right click on a mob (Mob.interact / mobInteract). Returns true when consumed.
@@ -2028,11 +2045,6 @@ impl Game<'_> {
&& !horizon_client::mobs::tame::angry(m) =>
{
consume = true;
let at = [
m.position.x,
m.position.y + f64::from(m.height()) * 0.5 + 0.5,
m.position.z,
];
let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0;
if tamed {
horizon_client::mobs::tame::set_tame(m, true);
@@ -2044,7 +2056,12 @@ impl Game<'_> {
}
// TamableAnimal.spawnTamingParticles.
let kind = if tamed { "heart" } else { "smoke" };
self.handle_mob_events(vec![MobEvent::Particles { kind, at, count: 7 }])?;
// TamableAnimal.spawnTamingParticles (entity event 7 or 6).
self.particles_around_mob(
self.mobs[index].id,
kind,
horizon_client::particles::Burst::TAMING,
);
if tamed {
let view = self.mob_entity(&self.mobs[index]);
self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -2104,11 +2121,6 @@ impl Game<'_> {
Species::Cat if !m.extra.tame && is_food => {
consume = true;
m.persistent = true;
let at = [
m.position.x,
m.position.y + f64::from(m.height()) * 0.5 + 0.5,
m.position.z,
];
let tamed = m.random.next_int_bound(3).unwrap_or(1) == 0;
if tamed {
m.extra.tame = true;
@@ -2117,7 +2129,12 @@ impl Game<'_> {
}
eat = eating_sound(m, &mut self.world.random);
let kind = if tamed { "heart" } else { "smoke" };
self.handle_mob_events(vec![MobEvent::Particles { kind, at, count: 7 }])?;
// TamableAnimal.spawnTamingParticles (entity event 7 or 6).
self.particles_around_mob(
self.mobs[index].id,
kind,
horizon_client::particles::Burst::TAMING,
);
if tamed {
let view = self.mob_entity(&self.mobs[index]);
self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -2149,18 +2166,18 @@ impl Game<'_> {
let pitch = 1.0 + (m.random.next_float() - m.random.next_float()) * 0.2;
eat = Some(("entity.parrot.eat", 1.0, pitch));
}
let at = [
m.position.x,
m.position.y + f64::from(m.height()) * 0.5 + 0.5,
m.position.z,
];
let tamed = m.random.next_int_bound(10).unwrap_or(1) == 0;
if tamed {
m.extra.tame = true;
m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1]));
}
let kind = if tamed { "heart" } else { "smoke" };
self.handle_mob_events(vec![MobEvent::Particles { kind, at, count: 7 }])?;
// TamableAnimal.spawnTamingParticles (entity event 7 or 6).
self.particles_around_mob(
self.mobs[index].id,
kind,
horizon_client::particles::Burst::TAMING,
);
if tamed {
let view = self.mob_entity(&self.mobs[index]);
self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -0,0 +1,495 @@
//! The debug keys in the game (26.3 `KeyboardHandler.keyPress`,
//! `handleDebugKeys` and `tick`): F3 combinations, F3+Escape, the held
//! debug-crash keys, and the debug renderers they switch on.
use super::{Game, Screen};
use horizon_client::{
Result,
command::args::GameMode,
debug_keys::{CrashNotice, DebugAction, DebugHost, KeyAction, OpenScreen},
gizmos::Gizmos,
keybinds,
text::Text,
};
use horizon_core::geometry::Axis;
use winit::keyboard::KeyCode;
/// `ChatFormatting.YELLOW` and `RED`.
const YELLOW: u32 = 0xFF_FF55;
const RED: u32 = 0xFF_5555;
/// The game as `KeyboardHandler` sees it while it runs one key event.
struct Host<'g, 'a> {
game: &'g mut Game<'a>,
}
impl DebugHost for Host<'_, '_> {
fn screen(&self) -> OpenScreen {
self.game.open_screen()
}
fn toggle_overlay(&mut self) {
self.game.debug = !self.game.debug;
}
fn pause_game(&mut self, without_menu: bool) {
// Gui.setPauseScreen: PauseScreen(false) only when the game really
// pauses (single player, not open to the network). Escape alone opens
// the menu as it always has (key_pressed).
let g = &mut *self.game;
if without_menu && g.screen == Screen::Playing {
g.pause_menu = !(g.remote.is_none() && g.lan.is_none());
g.screen = Screen::Paused;
g.capture(false);
g.mining = None;
}
}
fn debug_action(&mut self, action: DebugAction, shift: bool) -> bool {
self.game.run_debug_action(action, shift)
}
}
impl Game<'_> {
fn open_screen(&self) -> OpenScreen {
match self.screen {
Screen::Playing if self.book.is_none() && self.sign_edit.is_none() => OpenScreen::None,
Screen::Paused if !self.pause_menu => OpenScreen::PauseWithoutMenu,
_ => OpenScreen::Other,
}
}
/// A physical key event (already in `physical_keys`) before the game's
/// own handling. Returns true when it is used up (a debug combination,
/// F3 itself, F3+Escape).
pub(super) fn debug_key(&mut self, key: KeyCode, action: KeyAction) -> bool {
let Some(name) = keybinds::key_name(key) else {
return false;
};
let pressed = action != KeyAction::Release;
// Screens with a text box take every key press first
// (EditBox.keyPressed); releases still reach KeyboardHandler.
let typing = matches!(
self.screen,
Screen::Chat | Screen::Options | Screen::WorldOptions
) || self.sign_edit.is_some()
|| self.book.is_some()
|| (self.screen == Screen::Creative && self.creative_screen.tab().search)
|| self.recipe_search_focused()
|| self.station_typing()
|| self.remote_chat_open();
// Container screens use Escape, the inventory key and the hotbar and
// drop keys first; any other screen closes on Escape.
let screen_key = match self.screen {
Screen::Inventory | Screen::Creative => matches!(
key,
KeyCode::Escape
| KeyCode::KeyE
| KeyCode::KeyF
| KeyCode::KeyQ
| KeyCode::Digit1
| KeyCode::Digit2
| KeyCode::Digit3
| KeyCode::Digit4
| KeyCode::Digit5
| KeyCode::Digit6
| KeyCode::Digit7
| KeyCode::Digit8
| KeyCode::Digit9
),
Screen::Playing => false,
_ => key == KeyCode::Escape,
};
if pressed && (typing || screen_key) {
return false;
}
let crash_down = keybinds::key_code(self.settings.keys.get("key.debug.crash"))
.is_some_and(|k| self.physical_keys.contains(&k));
let shift = self.physical_keys.contains(&KeyCode::ShiftLeft)
|| self.physical_keys.contains(&KeyCode::ShiftRight);
let now = self.debug_millis();
let binds = self.settings.keys.clone();
let mut keys = std::mem::take(&mut self.debug_keys);
let modifier_was_down = keys.modifier_down;
let to_game = keys.key_press(
&mut Host { game: self },
&binds,
name,
action,
shift,
crash_down,
now,
);
self.debug_keys = keys;
if !pressed {
return false;
}
// The debug modifier does nothing else.
if name == binds.get("key.debug.modifier") || name == binds.get("key.debug.overlay") {
return true;
}
if self.open_screen() == OpenScreen::None {
!to_game
} else {
modifier_was_down
}
}
/// `Util.getMillis` (positive: KeyboardHandler treats 0 as unset).
fn debug_millis(&self) -> i64 {
self.started.elapsed().as_millis() as i64 + 1_000_000
}
/// `KeyboardHandler.tick`: the debug crash countdown.
pub(super) fn tick_debug_keys(&mut self) -> Result<()> {
let now = self.debug_millis();
match self.debug_keys.tick(now) {
None => {}
Some(CrashNotice::Message) => {
let args = [
self.key_text("key.debug.modifier"),
self.key_text("key.debug.crash"),
];
self.debug_feedback(Text::translate("debug.crash.message", &args));
}
Some(CrashNotice::Warning(seconds)) => self.debug_warning(Text::translate(
"debug.crash.warning",
&[Text::literal(seconds.to_string())],
)),
Some(CrashNotice::Crash) => {
// Minecraft.emergencySaveAndCrash: the world is saved, then the
// game stops with the report.
eprintln!(
"---- Minecraft Crash Report ----\n\nDescription: Manually triggered debug crash\n\njava.lang.Throwable: Manually triggered debug crash"
);
let _ = self.save_game();
return Err("Manually triggered debug crash".into());
}
}
Ok(())
}
/// `KeyMapping.getTranslatedKeyMessage`.
fn key_text(&self, mapping: &str) -> Text {
keybinds::display_name(self.settings.keys.get(mapping))
}
/// `KeyboardHandler.decorateDebugComponent`: `[Debug]:` in bold, a space,
/// the message, shown with `Minecraft.showDebugChat`.
fn debug_decorated(&mut self, color: u32, message: Text) {
let prefix = Text::translate("debug.prefix", &[])
.with_color(color)
.bold();
self.system_message(
Text::empty()
.append(prefix)
.append(Text::literal(" "))
.append(message),
);
}
fn debug_feedback(&mut self, message: Text) {
self.debug_decorated(YELLOW, message);
}
fn debug_warning(&mut self, message: Text) {
self.debug_decorated(RED, message);
}
fn debug_translated(&mut self, key: &str) {
self.debug_feedback(Text::translate(key, &[]));
}
/// `LocalPlayer.isReducedDebugInfo`: the server's rule or the option.
fn reduced_debug_info(&self) -> bool {
self.settings.reduced_debug_info || self.ui.rules.bool("reduced_debug_info")
}
/// `Permissions.COMMANDS_GAMEMASTER` (`GameModeCommand.PERMISSION_CHECK`).
fn gamemaster(&self) -> bool {
self.ui.registries.permission >= 2
}
fn toggle_option(&mut self, key: &str) -> bool {
let on = !self.settings.file.bool(key);
self.settings
.file
.set(key, horizon_client::options_file::V::Bool(on));
self.settings.save(&Self::options_path());
on
}
/// One matching mapping of `handleDebugKeys`; whether it counts.
fn run_debug_action(&mut self, action: DebugAction, shift: bool) -> bool {
let player = self.player.is_some() && !self.reduced_debug_info();
match action {
DebugAction::ReloadChunks => {
// LevelExtractor.allChanged: every section is rebuilt.
let keys: Vec<(i32, i32)> = self.world.chunks.keys().copied().collect();
for (x, z) in keys {
for sy in 0..horizon_client::chunk::HEIGHT / 16 {
self.world.dirty_sections.insert((x, sy, z));
}
}
self.debug_translated("debug.reload_chunks.message");
true
}
DebugAction::ShowHitboxes if player => {
self.show_hitboxes = !self.show_hitboxes;
self.debug_translated(if self.show_hitboxes {
"debug.show_hitboxes.on"
} else {
"debug.show_hitboxes.off"
});
true
}
DebugAction::ClearChat => {
// ChatComponent.clearMessages(false): sent history stays.
self.ui.chat.clear();
true
}
DebugAction::ShowChunkBorders if player => {
self.show_chunk_borders = !self.show_chunk_borders;
self.debug_translated(if self.show_chunk_borders {
"debug.chunk_boundaries.on"
} else {
"debug.chunk_boundaries.off"
});
true
}
DebugAction::AdvancedTooltips => {
// The message comes before Options.save here.
let on = !self.settings.file.bool("advancedItemTooltips");
self.debug_translated(if on {
"debug.advanced_tooltips.on"
} else {
"debug.advanced_tooltips.off"
});
self.toggle_option("advancedItemTooltips");
true
}
DebugAction::CopyRecreateCommand => {
if player {
self.copy_recreate_command(self.gamemaster(), !shift);
}
true
}
DebugAction::Spectate => {
if self.player.is_none() || !self.gamemaster() {
self.debug_translated("debug.creative_spectator.error");
} else if self.mode != GameMode::Spectator {
self.change_game_mode(GameMode::Spectator);
} else {
let back = self.previous_mode.unwrap_or(GameMode::Creative);
self.change_game_mode(back);
}
true
}
DebugAction::SwitchGameMode if self.open_screen() == OpenScreen::None => {
// Minecraft.canSwitchGameMode and the permission; the
// GameModeSwitcherScreen itself is not drawn yet.
if self.player.is_none() || !self.gamemaster() {
self.debug_translated("debug.gamemodes.error");
}
true
}
DebugAction::FocusPause => {
let on = self.toggle_option("pauseOnLostFocus");
self.debug_translated(if on {
"debug.pause_focus.on"
} else {
"debug.pause_focus.off"
});
true
}
DebugAction::ReloadResourcePacks => {
self.debug_translated("debug.reload_resourcepacks.message");
self.reload_packs();
true
}
DebugAction::CopyLocation if player => {
self.debug_translated("debug.copy_location.message");
if let Some(p) = &self.player {
use horizon_client::java_text::format_fixed2 as f2;
let command = format!(
"/execute in {} run tp @s {} {} {} {} {}",
self.dim.id(),
f2(p.position.x),
f2(p.position.y),
f2(p.position.z),
f2(f64::from(self.yaw)),
f2(f64::from(self.pitch)),
);
self.set_clipboard(&command);
}
true
}
DebugAction::DumpVersion => {
self.debug_translated("debug.version.header");
for line in self.version_lines() {
self.system_message(line);
}
true
}
DebugAction::ImprovedTransparency => {
self.settings.improved_transparency = !self.settings.improved_transparency;
self.settings.save(&Self::options_path());
self.apply_settings();
self.debug_translated(if self.settings.improved_transparency {
"debug.improvedTransparency.on"
} else {
"debug.improvedTransparency.off"
});
true
}
// Screens and overlays Horizon does not draw yet (the debug
// options screen, the profiler and its charts, the lightmap, the
// texture dump): the keys are used up as in vanilla.
DebugAction::DebugOptions
| DebugAction::DumpDynamicTextures
| DebugAction::Profiling
| DebugAction::ProfilingChart
| DebugAction::FpsCharts
| DebugAction::NetworkCharts
| DebugAction::LightmapTexture => true,
DebugAction::ShowHitboxes
| DebugAction::ShowChunkBorders
| DebugAction::SwitchGameMode
| DebugAction::CopyLocation => false,
}
}
/// `ServerboundChangeGameModePacket` handled by the integrated server:
/// `GameModeCommand.setGameMode` with its feedback.
pub(super) fn change_game_mode(&mut self, mode: GameMode) {
// On a server the packet decides; Horizon's client does not send it yet.
if self.remote.is_some() {
return;
}
if self.set_game_mode(mode) {
let name = Text::translate(&format!("gameMode.{}", mode.name()), &[]);
self.feedback(Text::translate("commands.gamemode.success.self", &[name]));
}
}
/// `KeyboardHandler.copyRecreateCommand`: the targeted block or mob as a
/// `/setblock` or `/summon` command. In a single-player world the
/// server's data (no Shift) is the game's own.
fn copy_recreate_command(&mut self, add_nbt: bool, from_server: bool) {
use horizon_client::java_text::format_fixed2 as f2;
let side = if add_nbt && from_server {
"server"
} else {
"client"
};
if self.entity_targeted()
&& let Some((index, _)) = self.mob_hit()
{
let (id, pos, mob) = {
let m = &self.mobs[index];
(m.kind.id.clone(), m.position, m.id)
};
let mut command = format!("/summon {id} {} {} {}", f2(pos.x), f2(pos.y), f2(pos.z));
if add_nbt && let Some(mut tag) = self.entity_nbt(super::commands::Target::Mob(mob)) {
if let horizon_world::nbt::Tag::Compound(c) = &mut tag {
for key in ["id", "UUID", "Pos"] {
c.remove(&key.into());
}
}
command.push(' ');
command.push_str(&horizon_client::snbt::pretty(&tag).plain());
}
self.set_clipboard(&command);
self.debug_translated(&format!("debug.inspect.{side}.entity"));
return;
}
let Some(hit) = self.pick() else {
return;
};
let p = hit.pos;
let mut description = self.state_string(self.world.block(p[0], p[1], p[2]));
if add_nbt && let Some(e) = self.world.block_entities.get(&(p[0], p[1], p[2])) {
// BlockEntity.saveWithoutMetadata: no id or position.
let name = self.data_block_name(p);
let mut tag = horizon_client::save::encode_block_entity((p[0], p[1], p[2]), e, &name);
if let horizon_world::nbt::Tag::Compound(c) = &mut tag {
for key in ["id", "x", "y", "z", "keepPacked"] {
c.remove(&key.into());
}
}
description.push_str(&horizon_client::snbt::to_snbt(&tag));
}
self.set_clipboard(&format!(
"/setblock {} {} {} {description}",
p[0], p[1], p[2]
));
self.debug_translated(&format!("debug.inspect.{side}.block"));
}
/// `KeyboardHandler.setClipboard`.
fn set_clipboard(&mut self, text: &str) {
use horizon_client::clipboard::Clipboard;
self.clipboard.set(text);
}
/// The debug renderers' gizmos for a frame (`DebugRenderer.emitGizmos`).
pub(super) fn debug_gizmos(&self, alpha: f32) -> Gizmos {
let mut g = Gizmos::default();
if self.show_chunk_borders
&& let Some(p) = &self.player
{
let block = [
p.position.x.floor() as i32,
p.position.y.floor() as i32,
p.position.z.floor() as i32,
];
let min_y = horizon_client::chunk::MIN_Y;
g.chunk_borders(block, min_y, min_y + horizon_client::chunk::HEIGHT - 1);
}
if !self.show_hitboxes {
return g;
}
let lerp = |a: f64, b: f64| a + f64::from(alpha) * (b - a);
let lerpf = |a: f32, b: f32| a + alpha * (b - a);
for m in &self.mobs {
if m.removed || m.has_effect("minecraft:invisibility") {
continue;
}
let pos = [
lerp(m.previous.x, m.position.x),
lerp(m.previous.y, m.position.y),
lerp(m.previous.z, m.position.z),
];
let view = (
lerpf(m.previous_head_pitch, m.head_pitch),
lerpf(m.previous_head_yaw, m.head_yaw),
);
g.hitbox(
pos,
(m.width(), m.height()),
m.eye_height() as f32,
true,
view,
);
}
for item in &self.dropped {
let pos = [
lerp(item.previous.x, item.position.x),
lerp(item.previous.y, item.position.y),
lerp(item.previous.z, item.position.z),
];
// EntityType.ITEM: 0.25 by 0.25, eyes at 0.2125.
g.hitbox(pos, (0.25, 0.25), 0.2125, false, (0.0, 0.0));
}
// The dragon's parts.
for (id, b) in self.special_targets() {
if (super::dragon::SPECIAL..super::dragon::SPECIAL + 8).contains(&id) {
g.cuboid(
[b.min(Axis::X), b.min(Axis::Y), b.min(Axis::Z)],
[b.max(Axis::X), b.max(Axis::Y), b.max(Axis::Z)],
horizon_client::gizmos::DRAGON_PART,
horizon_client::gizmos::STROKE_WIDTH,
);
}
}
// The player's own, unless the camera is in its head.
if !self.camera_type.first_person()
&& let Some(p) = &self.player
{
let d = p.dimensions;
let pos = [
lerp(self.previous_position.x, p.position.x),
lerp(self.previous_position.y, p.position.y),
lerp(self.previous_position.z, p.position.z),
];
g.hitbox(
pos,
(d.width, d.height),
d.eye_height,
true,
(self.pitch, self.yaw),
);
}
g
}
}
@@ -31,6 +31,10 @@ impl Game<'_> {
/// `ServerPlayer.setGameMode` and `GameType.updatePlayerAbilities`.
pub(super) fn set_mode(&mut self, mode: GameMode) {
let was_spectator = self.spectator();
// MultiPlayerGameMode.setLocalMode: the mode it leaves.
if mode != self.mode {
self.previous_mode = Some(self.mode);
}
self.mode = mode;
self.creative = mode == GameMode::Creative;
// GameType.updatePlayerAbilities applies at once.
+1 -1
View File
@@ -119,7 +119,7 @@ impl Game<'_> {
}
/// Whether an attack would hit an entity rather than the block behind
/// it: the crosshair's `EntityHitResult`.
fn entity_targeted(&self) -> bool {
pub(super) fn entity_targeted(&self) -> bool {
let before = |d: Option<f64>| d.is_some_and(|d| self.before_block(d));
before(self.painting_hit().map(|h| h.1))
|| before(self.frame_hit().map(|h| h.1))
@@ -0,0 +1,57 @@
//! The sprites of item particles: `BreakingItemParticle.ItemParticleProvider.getSprite`
//! resolves the stack's model for the ground and picks a layer's particle sprite.
use super::Game;
use horizon_assets::item_model::DisplayContext;
use horizon_client::{
items::ItemStack,
particles::{self, ParticleOptions, ParticleType},
};
impl Game<'_> {
/// `ItemParticleOption(ITEM, stack)`: the layer particle sprites of the
/// stack's model resolved for the ground, with seed 0.
pub(super) fn item_particle(&self, stack: &ItemStack) -> ParticleOptions {
let state = self.resolve_item(stack, DisplayContext::Ground, None, 0);
ParticleOptions::item(state.layers.iter().map(|l| l.particle.clone()).collect())
}
/// `LivingEntity.spawnItemParticles(stack, count)` for the local player,
/// drawing from the world random as its eating sounds do.
pub(super) fn eat_particles(&mut self, stack: &ItemStack, count: u32) {
let Some(p) = self.player.as_ref().map(|p| p.position) else {
return;
};
let eye_y = self.eye_position().map_or(p.y, |e| e[1]);
let options = self.item_particle(stack);
let mut spawned = Vec::new();
particles::item_use_particles(
&mut self.world.random,
self.pitch,
self.yaw,
[p.x, p.y, p.z],
eye_y,
count,
|p, v| spawned.push((p, v)),
);
for (p, v) in spawned {
self.particles.add(&options, p, v);
}
}
/// The slime ball, snowball and cobweb models behind `item_slime`,
/// `item_snowball` and `item_cobweb`, resolved on first use.
pub(super) fn ensure_item_particle_sprites(&mut self) {
if !self.particles.item_sprites.is_empty() {
return;
}
for (ty, item) in [
(ParticleType::ItemSlime, "minecraft:slime_ball"),
(ParticleType::ItemSnowball, "minecraft:snowball"),
(ParticleType::ItemCobweb, "minecraft:cobweb"),
] {
let sprites = self
.item_particle(&ItemStack::new(item, 1))
.item
.unwrap_or_default();
self.particles.item_sprites.insert(ty, sprites);
}
}
}
@@ -321,12 +321,17 @@ impl Game<'_> {
return;
};
let ctrl = self.keys.contains(&winit::keyboard::KeyCode::ControlLeft);
let shortcut = self.edit_shortcut(event);
let Some(o) = self.world_options.as_mut() else {
return;
};
if !o.port.focused {
return;
}
if let Some(shortcut) = shortcut {
o.port.shortcut(shortcut, &mut self.clipboard);
return;
}
if !o.port.key(key, ctrl, false)
&& !ctrl
&& let Some(text) = &event.text
@@ -0,0 +1,44 @@
//! Level events whose client handler (`LevelEventHandler`) spawns particles
//! on a block: electric sparks (3002), waxing (3003), wax off (3004) and
//! scraping (3005).
use super::Game;
use horizon_client::particles::{self, ParticleOptions, ParticleType};
use horizon_core::position::BlockPos;
use horizon_world::level::LevelEvent;
impl Game<'_> {
/// `LevelEventHandler.levelEvent` 3002 to 3005, drawing from the client
/// level's random.
pub(super) fn block_particle_event(&mut self, id: i32, pos: BlockPos, data: i32) {
let ty = match id {
3002 => ParticleType::ElectricSpark,
3003 => ParticleType::WaxOn,
3004 => ParticleType::WaxOff,
3005 => ParticleType::Scrape,
_ => return,
};
let p = [pos.x, pos.y, pos.z];
let mut spawned = Vec::new();
let random = self.particles.level_random();
// 3002 with an axis: a lightning rod; otherwise copper cleaned by lightning.
match usize::try_from(data) {
Ok(axis) if id == 3002 && axis < 3 => {
particles::along_axis(random, axis, p, |p, v| spawned.push((p, v)));
}
_ => particles::on_block_faces(random, p, |p, v| spawned.push((p, v))),
}
let options = ParticleOptions::simple(ty);
for (p, v) in spawned {
self.particles.add(&options, p, v);
}
}
/// Queue and play level event `id` at `pos` (`Level.levelEvent`).
pub(super) fn level_event_at(&mut self, id: i32, pos: [i32; 3], data: i32) {
self.level_events.push(LevelEvent::LevelEvent {
id,
pos: BlockPos::new(pos[0], pos[1], pos[2]),
data,
});
let _ = self.process_level_events();
}
}
@@ -246,6 +246,13 @@ impl Game<'_> {
// The rod's onPlace schedules the 8-tick unpowering.
let _ = self.level_set(p, powered);
}
// Level event 3002 with the rod's axis: sparks along it.
let axis = match s.properties.get("facing").map(String::as_str) {
Some("east" | "west") => 0,
Some("north" | "south") => 2,
_ => 1,
};
self.level_event_at(3002, p, axis);
}
}
/// `thunderHit` for entities within 3 blocks (up to 9 above).
+8 -7
View File
@@ -4,7 +4,7 @@
use super::Game;
use horizon_client::{
items::ItemStack,
mobs::{MobEvent, equine, llama},
mobs::{equine, llama},
};
use horizon_core::random::RandomSource;
@@ -45,13 +45,14 @@ impl Game<'_> {
m.extra.variant3 = (i32::from(m.extra.variant3) + temper).min(llama::MAX_TEMPER) as u8;
used = true;
}
let at = m.center();
if happy {
let _ = self.handle_mob_events(vec![MobEvent::Particles {
kind: "happy_villager",
at,
count: 1,
}]);
// AbstractHorse.handleEating: one at rest about the body.
let id = m.id;
self.particles_around_mob(
id,
"happy_villager",
horizon_client::particles::Burst::HORSE_EATING,
);
}
if !used {
return false;
+6 -10
View File
@@ -437,16 +437,12 @@ impl Game<'_> {
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) {
m.extra.owner = owner;
m.persistent = true;
let at = [
m.position.x,
m.position.y + f64::from(m.height()) * 0.5 + 0.5,
m.position.z,
];
let _ = self.handle_mob_events(vec![MobEvent::Particles {
kind: "heart",
at,
count: 7,
}]);
// AbstractHorse.tameWithName: entity event 7, spawnTamingParticles(true).
self.particles_around_mob(
mob,
"heart",
horizon_client::particles::Burst::TAMING,
);
}
}
MobEvent::Buck { mob } if self.riding == Some(mob) => self.dismount_mount(),
+7 -7
View File
@@ -4,7 +4,7 @@
use super::Game;
use horizon_client::{
items::ItemStack,
mobs::{MobEvent, Species, nautilus},
mobs::{Species, nautilus},
};
use horizon_core::random::RandomSource;
@@ -84,14 +84,14 @@ impl Game<'_> {
m.nav_stop();
m.ai.target = None;
}
let at = [
m.position.x,
m.position.y + f64::from(m.height()) * 0.5 + 0.5,
m.position.z,
];
let sound = nautilus::eat_sound(m);
let kind = if tamed { "heart" } else { "smoke" };
let _ = self.handle_mob_events(vec![MobEvent::Particles { kind, at, count: 7 }]);
// TamableAnimal.spawnTamingParticles (entity event 7 or 6).
self.particles_around_mob(
self.mobs[index].id,
kind,
horizon_client::particles::Burst::TAMING,
);
self.nautilus_sound(index, sound);
if tamed {
let view = self.mob_entity(&self.mobs[index]);
+28 -6
View File
@@ -11,7 +11,7 @@ use horizon_client::{
use winit::{event::MouseButton, keyboard::KeyCode, window::Fullscreen};
impl Game<'_> {
fn options_path() -> std::path::PathBuf {
pub(super) fn options_path() -> std::path::PathBuf {
std::env::current_dir()
.unwrap_or_default()
.join("options.txt")
@@ -81,6 +81,15 @@ impl Game<'_> {
self.ui.options = ui;
self.handle_option_events(events)
}
/// Ctrl+A/C/V/X in the options' search boxes; false when none has focus.
pub(super) fn options_shortcut(
&mut self,
shortcut: horizon_client::clipboard::EditShortcut,
) -> bool {
self.ui
.options
.shortcut(&self.res.atlas, shortcut, &mut self.clipboard)
}
pub(super) fn options_scroll(&mut self, amount: f32) {
self.ui.options.scroll_at(self.cursor, amount);
}
@@ -145,11 +154,13 @@ impl Game<'_> {
r.set_mipmap_levels(s.mipmap_levels.max(0) as u32);
r.set_world_post(s.horizon.resolution_scale as f32 / 100.0, s.horizon.fxaa);
}
if let Some(w) = &self.window {
let want = s.fullscreen;
if want != w.fullscreen().is_some() {
w.set_fullscreen(want.then_some(Fullscreen::Borderless(None)));
}
// Window.updateFullscreenIfChanged: only a changed option asks the
// window to change, so applying settings never undoes a fullscreen
// the compositor set up.
if let Some(w) = &self.window
&& let Some(want) = self.fullscreen.request(s.fullscreen)
{
w.set_fullscreen(want.then_some(Fullscreen::Borderless(None)));
}
let mut volumes = s.volumes;
volumes[0] = 1.0;
@@ -171,6 +182,17 @@ impl Game<'_> {
self.ui.chat.rescale(&self.res.atlas);
}
}
/// `Window.updateFullscreenState`: a fullscreen change made by the window
/// system is adopted by the option (`Minecraft.fullscreenStateChanged`).
pub(super) fn observe_fullscreen(&mut self) {
let Some(w) = &self.window else { return };
if let Some(now) = self.fullscreen.observe(w.fullscreen().is_some())
&& self.settings.fullscreen != now
{
self.settings.fullscreen = now;
self.settings.save(&Self::options_path());
}
}
/// F11 (key.fullscreen): Window.toggleFullScreen, remembered in options.txt.
pub(super) fn toggle_fullscreen(&mut self) {
self.settings.fullscreen = !self.settings.fullscreen;
@@ -165,9 +165,19 @@ impl Game<'_> {
search.insert_text(text);
}
}
/// Ctrl+A/C/V/X in the search box.
pub(super) fn recipe_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
if let Some(search) = self.recipe_ui.search.as_mut() {
search.shortcut(shortcut, &mut self.clipboard);
}
}
/// A key press while the search box has focus.
pub(super) fn recipe_key(&mut self, event: &winit::event::KeyEvent) {
use winit::keyboard::{KeyCode, PhysicalKey};
if let Some(shortcut) = self.edit_shortcut(event) {
self.recipe_shortcut(shortcut);
return;
}
let ctrl = self.keys.contains(&KeyCode::ControlLeft);
let shift = self.has_shift_down();
let Some(search) = self.recipe_ui.search.as_mut() else {
+19 -2
View File
@@ -154,7 +154,7 @@ impl Game<'_> {
let root = self.options.resources.clone();
let builtin = Builtin::find(&root)
.and_then(|p| Builtin::load(&p).ok())
.ok_or("registries.json not found next to the resources; run the data generator reports (tools/prepare_native_client.py)")?;
.ok_or("registries.json not found next to the resources; run the data generator reports (horizon-prepare)")?;
let lang = Arc::new(horizon_client::net::load_language(&root));
let view = self.settings.render_distance.clamp(2, 32) as i8;
let session = Session::connect(address, name, view, lang.clone());
@@ -2208,12 +2208,26 @@ impl Game<'_> {
if event.state != winit::event::ElementState::Pressed {
return;
}
let shortcut = self.edit_shortcut(event);
let Some(r) = self.remote.as_mut() else {
return;
};
let Some(input) = r.chat_input.as_mut() else {
return;
};
// ChatScreen's input: an EditBox of 256.
const INPUT: horizon_client::clipboard::FieldId = ("remote.chat", 0);
if let Some(shortcut) = shortcut {
Self::append_shortcut(
&mut self.text_selection,
&mut self.clipboard,
INPUT,
input,
shortcut,
256,
);
return;
}
// Logical keys: the text, not the scancode, decides (layouts, virtual keyboards).
match &event.logical_key {
Key::Named(NamedKey::Escape) => {
@@ -2221,7 +2235,9 @@ impl Game<'_> {
self.capture(true);
}
Key::Named(NamedKey::Backspace) => {
input.pop();
if !self.text_selection.take(INPUT, input) {
input.pop();
}
}
Key::Named(NamedKey::Enter) => {
let message = r.chat_input.take().unwrap_or_default();
@@ -2230,6 +2246,7 @@ impl Game<'_> {
}
_ => {
if let Some(text) = &event.text {
self.text_selection.take(INPUT, input);
for c in text.chars().filter(|c| !c.is_control()) {
if input.chars().count() < 256 {
input.push(c);
@@ -83,9 +83,21 @@ impl Game<'_> {
let count = num(8, 1.0)? as u32;
let options = match ty {
ParticleType::Dust => ParticleOptions::dust([1.0, 0.0, 0.0], 1.0),
ParticleType::Block | ParticleType::FallingDust | ParticleType::DustPillar => {
ParticleType::Block
| ParticleType::FallingDust
| ParticleType::DustPillar
| ParticleType::BlockMarker => {
ParticleOptions::block(ty, "block/stone".into(), 0x808080)
}
ParticleType::Item => self.item_particle(
&horizon_client::items::ItemStack::new("minecraft:apple", 1),
),
ParticleType::ItemSlime
| ParticleType::ItemSnowball
| ParticleType::ItemCobweb => {
self.ensure_item_particle_sprites();
ParticleOptions::simple(ty)
}
_ => ParticleOptions::simple(ty),
};
// ServerLevel.sendParticles: count 0 uses the delta as velocity.
+4 -1
View File
@@ -54,7 +54,10 @@ fn death_buttons(w: f32, h: f32) -> [(f32, f32, &'static str, u8); 2] {
impl Game<'_> {
/// Whether the pause menu is drawn in Horizon's style (over a blurred world).
pub(super) fn horizon_pause(&self) -> bool {
self.screen == Screen::Paused && self.title.is_none() && horizon_client::ui_theme::horizon()
self.screen == Screen::Paused
&& self.pause_menu
&& self.title.is_none()
&& horizon_client::ui_theme::horizon()
}
fn pause_labels(&self) -> (String, &'static str) {
let world = if self.remote.is_some() {
+53 -11
View File
@@ -5,7 +5,7 @@ use super::Game;
use horizon_client::{
containers::BlockEntity,
hud::{HudBatch, rgba},
signs::{SignData, wood_type},
signs::wood_type,
};
use std::time::Instant;
use winit::{
@@ -21,13 +21,6 @@ pub(super) struct SignEditor {
}
impl Game<'_> {
fn edited_sign(&mut self) -> Option<&mut SignData> {
let key = self.sign_edit.as_ref()?.pos;
match self.world.block_entities.get_mut(&key) {
Some(BlockEntity::Sign(sign)) => Some(sign),
_ => None,
}
}
/// `SignBlock.openTextEdit` for the front side after placement.
pub(super) fn open_sign_editor(&mut self, pos: (i32, i32, i32), front: bool) {
self.sign_edit = Some(SignEditor {
@@ -52,10 +45,15 @@ impl Game<'_> {
if event.state != ElementState::Pressed {
return;
}
if let Some(shortcut) = self.edit_shortcut(event) {
self.sign_shortcut(shortcut);
return;
}
let Some(edit) = self.sign_edit.as_mut() else {
return;
};
let front = edit.front;
let id = sign_line_id(front, edit.line);
match event.physical_key {
PhysicalKey::Code(KeyCode::Escape) => self.close_sign_editor(),
PhysicalKey::Code(KeyCode::ArrowUp) => edit.line = (edit.line + 3) & 3,
@@ -63,14 +61,17 @@ impl Game<'_> {
edit.line = (edit.line + 1) & 3
}
PhysicalKey::Code(KeyCode::Backspace) => {
let line = edit.line;
if let Some(sign) = self.edited_sign() {
let (line, key) = (edit.line, edit.pos);
if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&key) {
let text = if front {
&mut sign.front
} else {
&mut sign.back
};
text.lines[line].pop();
let value = &mut text.lines[line];
if !self.text_selection.take(id, value) {
value.pop();
}
}
}
_ => {
@@ -90,6 +91,7 @@ impl Game<'_> {
} else {
&mut sign.back
};
self.text_selection.take(id, &mut text.lines[line]);
for ch in typed.chars().filter(|c| !c.is_control()) {
let mut next = text.lines[line].clone();
next.push(ch);
@@ -102,6 +104,41 @@ impl Game<'_> {
}
}
}
/// `TextFieldHelper.keyPressed`'s shortcuts on the edited line: a paste
/// (formatting and carriage returns removed) is taken whole or not at
/// all, as the line must stay within the sign's width.
fn sign_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
let Some(edit) = self.sign_edit.as_ref() else {
return;
};
let (key, front, line) = (edit.pos, edit.front, edit.line);
let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&key) else {
return;
};
let max = sign.max_line_width();
let text = if front {
&mut sign.front
} else {
&mut sign.back
};
let atlas = &self.res.atlas;
self.text_selection.apply(
sign_line_id(front, line),
&mut text.lines[line],
shortcut,
&mut self.clipboard,
|value, pasted| {
let next = format!(
"{value}{}",
horizon_client::clipboard::helper_clipboard_contents(pasted)
);
HudBatch::text_width(atlas, &next) <= max && {
*value = next;
true
}
},
);
}
/// Done button (`this.width / 2 - 100, this.height / 4 + 144`, 200x20).
pub(super) fn sign_edit_click(&mut self, size: [u32; 2]) {
let b = HudBatch::new(size);
@@ -206,3 +243,8 @@ impl Game<'_> {
);
}
}
/// The sign line being edited, for Select All.
fn sign_line_id(front: bool, line: usize) -> horizon_client::clipboard::FieldId {
(if front { "sign.front" } else { "sign.back" }, line)
}
+32 -3
View File
@@ -1158,17 +1158,41 @@ impl Game<'_> {
let Some(s) = self.station.as_mut() else {
return;
};
let cleared = self.text_selection.take(ANVIL_NAME, &mut s.name);
if backspace {
s.name.pop();
if !cleared {
s.name.pop();
}
} else if let Some(t) = text {
for c in t.chars().filter(|c| !c.is_control()) {
if s.name.chars().count() < 50 {
if s.name.chars().count() < ANVIL_NAME_CHARS {
s.name.push(c);
}
}
}
self.station_changed();
}
/// Ctrl+A/C/V/X in the anvil's rename box (an `EditBox` of 50) or the
/// recipe book's search box.
pub(super) fn station_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
if self.recipe_search_focused() {
self.recipe_shortcut(shortcut);
return;
}
let Some(s) = self.station.as_mut() else {
return;
};
if Self::append_shortcut(
&mut self.text_selection,
&mut self.clipboard,
ANVIL_NAME,
&mut s.name,
shortcut,
ANVIL_NAME_CHARS,
) {
self.station_changed();
}
}
// ---------------------------------------------------------------- drawing
@@ -1928,8 +1952,9 @@ impl Game<'_> {
"selected": s.selected,
})
}
/// Options.advancedItemTooltips (F3+H).
fn options_advanced_tooltips(&self) -> bool {
false
self.settings.file.bool("advancedItemTooltips")
}
/// `TooltipRenderUtil`: dark box with the purple border, first line spaced.
pub(super) fn draw_tooltip_lines(
@@ -2062,3 +2087,7 @@ impl Game<'_> {
Ok(())
}
}
/// The anvil's rename box (`AnvilScreen`: `setMaxLength(50)`).
const ANVIL_NAME: horizon_client::clipboard::FieldId = ("anvil.name", 0);
const ANVIL_NAME_CHARS: usize = 50;
+55 -13
View File
@@ -176,9 +176,10 @@ impl Game<'_> {
villager::ext_mut(&mut self.mobs[ib]).eat_and_digest();
let from = self.mobs[ia].position;
let Some((bed, variant)) = child else {
for i in [ia, ib] {
let p = self.mobs[i].position;
self.particles_at("angry_villager", [p.x, p.y + 1.8, p.z]);
// VillagerMakeLove: entity event 13 for the partner, then the parent.
for i in [ib, ia] {
let id = self.mobs[i].id;
self.villager_particles(id, "angry_villager");
}
return;
};
@@ -202,12 +203,52 @@ impl Game<'_> {
child.extra.age = -24000;
child.extra.bed = Some(bed);
}
self.particles_at("heart", [from.x, from.y + 1.8, from.z]);
// VillagerMakeLove.giveBirth: entity event 12 for the child.
self.villager_particles(id, "heart");
}
fn particles_at(&mut self, kind: &'static str, at: [f64; 3]) {
if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) {
let options = horizon_client::particles::ParticleOptions::simple(ty);
self.particles.add(&options, at, [0.0; 3]);
/// `Villager.handleEntityEvent` 12, 13, 14 and 42:
/// `AbstractVillager.addParticlesAroundSelf`.
pub(super) fn villager_particles(&mut self, id: u32, kind: &'static str) {
self.particles_around_mob(id, kind, horizon_client::particles::Burst::VILLAGER);
}
/// `particles::around_self` about mob `id`.
pub(super) fn particles_around_mob(
&mut self,
id: u32,
kind: &'static str,
burst: horizon_client::particles::Burst,
) {
let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
return;
};
let feet = [m.position.x, m.position.y, m.position.z];
let size = [f64::from(m.width()), f64::from(m.height())];
self.particles_around(kind, feet, size, burst);
}
/// `particles::around_self` on the client: the particle engine's random
/// stands in for the client entity's, so no server draw moves.
pub(super) fn particles_around(
&mut self,
kind: &'static str,
feet: [f64; 3],
size: [f64; 2],
burst: horizon_client::particles::Burst,
) {
let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) else {
return;
};
let options = horizon_client::particles::ParticleOptions::simple(ty);
let mut spawned = Vec::new();
horizon_client::particles::around_self(
self.particles.random(),
feet,
size[0],
size[1],
burst,
|p, v| spawned.push((p, v)),
);
for (p, v) in spawned {
self.particles.add(&options, p, v);
}
}
@@ -281,7 +322,7 @@ impl Game<'_> {
}
let time = m.ai.last_hurt_by_time;
let alive = m.alive();
let at = m.position;
let at = m.id;
let e = villager::ext_mut(m);
if e.hurt_seen != time {
e.hurt_seen = time;
@@ -295,8 +336,9 @@ impl Game<'_> {
}
}
}
for at in angry {
self.particles_at("angry_villager", [at.x, at.y + 1.8, at.z]);
// Villager.setLastHurtByMob: entity event 13.
for id in angry {
self.villager_particles(id, "angry_villager");
}
}
/// `Villager.tellWitnessesThatIWasMurdered`: the villagers that saw a
@@ -350,8 +392,8 @@ impl Game<'_> {
GossipType::Trading,
gossip::REPUTATION_CHANGE_PER_TRADE,
);
let p = self.mobs[i].position;
self.particles_at("happy_villager", [p.x, p.y + 1.8, p.z]);
// Villager.customServerAiStep after a trade: entity event 14.
self.villager_particles(id, "happy_villager");
}
/// `Villager.getPlayerReputation` of the local player.
pub(super) fn villager_reputation(&self, id: u32) -> i32 {
+81
View File
@@ -144,6 +144,10 @@ pub struct Frame<'a> {
pub dark_disc: bool,
/// The hit block outline as line segments (from, to) in world space.
pub outline: Vec<[f64; 6]>,
/// Debug gizmo lines (`gizmos::camera_relative`): depth tested, then
/// drawn over everything.
pub debug_lines: &'a [[f32; 8]],
pub debug_lines_on_top: &'a [[f32; 8]],
pub hud: &'a HudBatch,
/// CardinalLighting.Type.NETHER, otherwise DEFAULT.
pub nether_lighting: bool,
@@ -222,6 +226,12 @@ pub struct Renderer {
sky: wgpu::RenderPipeline,
dark_disc: wgpu::RenderPipeline,
lines: wgpu::RenderPipeline,
/// Gizmo lines (`RenderTypes.linesTranslucentNoDepthWrite`) and the
/// always-on-top ones.
debug_lines: wgpu::RenderPipeline,
debug_lines_on_top: wgpu::RenderPipeline,
debug_line_buffer: wgpu::Buffer,
debug_line_capacity: u64,
entity_pipeline: wgpu::RenderPipeline,
crumbling_pipeline: wgpu::RenderPipeline,
cloud_pipeline: wgpu::RenderPipeline,
@@ -534,6 +544,13 @@ impl Renderer {
attributes: &line_attributes,
})];
let alpha_blend = wgpu::BlendState::ALPHA_BLENDING;
let debug_line_attributes =
wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x3,2=>Unorm8x4,3=>Float32];
let debug_line_buffers = [Some(wgpu::VertexBufferLayout {
array_stride: 32,
step_mode: wgpu::VertexStepMode::Instance,
attributes: &debug_line_attributes,
})];
let pipeline = |label: &str,
vertex: &str,
fragment: &str,
@@ -639,6 +656,28 @@ impl Renderer {
true,
Some(alpha_blend),
);
let debug_lines = pipeline(
"Debug lines",
"vs_debug_line",
"fs_debug_line",
&debug_line_buffers,
wgpu::PrimitiveTopology::TriangleStrip,
None,
false,
true,
Some(alpha_blend),
);
let debug_lines_on_top = pipeline(
"Debug lines on top",
"vs_debug_line",
"fs_debug_line",
&debug_line_buffers,
wgpu::PrimitiveTopology::TriangleStrip,
None,
false,
false,
Some(alpha_blend),
);
let globals = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Horizon globals"),
size: std::mem::size_of::<Globals>() as u64,
@@ -746,6 +785,12 @@ impl Renderer {
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let debug_line_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Debug lines"),
size: 32 * 4096,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let depth = Self::depth(&device, &config);
let (atlas_pixels, atlas_width, atlas_height) = hud_atlas;
let atlas = device.create_texture_with_data(
@@ -1300,6 +1345,10 @@ impl Renderer {
sky,
dark_disc,
lines,
debug_lines,
debug_lines_on_top,
debug_line_buffer,
debug_line_capacity: 4096,
entity_pipeline,
crumbling_pipeline,
cloud_pipeline,
@@ -1977,6 +2026,28 @@ impl Renderer {
self.queue
.write_buffer(&self.indirect, 0, bytemuck::cast_slice(&self.draws));
}
let debug_depth = frame.debug_lines.len() as u32;
let debug_top = frame.debug_lines_on_top.len() as u32;
if debug_depth + debug_top > 0 {
let needed = u64::from(debug_depth + debug_top);
if needed > self.debug_line_capacity {
self.debug_line_capacity = needed.next_power_of_two();
self.debug_line_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Debug lines"),
size: 32 * self.debug_line_capacity,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
}
let all: Vec<[f32; 8]> = frame
.debug_lines
.iter()
.chain(frame.debug_lines_on_top)
.copied()
.collect();
self.queue
.write_buffer(&self.debug_line_buffer, 0, bytemuck::cast_slice(&all));
}
let outline_edges = frame.outline.len().min(MAX_OUTLINE_EDGES as usize);
if outline_edges > 0 {
let lines = outline_vertices(&frame.outline[..outline_edges], camera);
@@ -2152,6 +2223,16 @@ impl Renderer {
pass.set_vertex_buffer(0, self.outline.slice(..));
pass.draw(0..4, 0..outline_edges as u32);
}
if debug_depth > 0 {
pass.set_pipeline(&self.debug_lines);
pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..));
pass.draw(0..4, 0..debug_depth);
}
if debug_top > 0 {
pass.set_pipeline(&self.debug_lines_on_top);
pass.set_vertex_buffer(0, self.debug_line_buffer.slice(..));
pass.draw(0..4, debug_depth..debug_depth + debug_top);
}
pass.set_pipeline(&self.translucent);
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
pass.set_vertex_buffer(1, self.instances.slice(..));
+347
View File
@@ -0,0 +1,347 @@
//! Debug gizmos (26.3 `net.minecraft.gizmos`): coloured lines with a width
//! in pixels, as `GizmoFeatureRenderer.buildLines` draws them, and the two
//! debug renderers the F3 keys switch on: `ChunkBorderRenderer` (F3+G) and
//! `EntityHitboxDebugRenderer` (F3+B).
/// A line: world-space ends, ARGB colour, width in pixels.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Line {
pub start: [f64; 3],
pub end: [f64; 3],
pub color: u32,
pub width: f32,
}
/// The gizmos of a frame: depth-tested lines, and lines drawn over
/// everything (`GizmoProperties.setAlwaysOnTop`).
#[derive(Clone, Debug, Default)]
pub struct Gizmos {
pub lines: Vec<Line>,
pub on_top: Vec<Line>,
}
/// `CommonColors`.
pub const WHITE: u32 = 0xFFFF_FFFF;
pub const RED: u32 = 0xFFFF_0000;
pub const BLUE: u32 = 0xFF00_00FF;
pub const YELLOW: u32 = 0xFFFF_FF00;
/// `ChunkBorderRenderer.CELL_BORDER`, `YELLOW`, `MAJOR_LINES` and the outer
/// columns' `ARGB.colorFromFloat(0.5F, 1.0F, 0.0F, 0.0F)`.
pub const CELL_BORDER: u32 = 0xFF00_9B9B;
pub const CHUNK_YELLOW: u32 = 0xFFFF_FF00;
pub const MAJOR_LINES: u32 = 0xFF3F_3FFF;
pub const OUTER_COLUMNS: u32 = 0x7FFF_0000;
/// `ARGB.colorFromFloat(1.0F, 0.25F, 1.0F, 0.0F)`: dragon parts.
pub const DRAGON_PART: u32 = 0xFF3F_FF00;
/// `GizmoStyle.stroke(argb)` and `Gizmos.arrow(start, end, argb)`.
pub const STROKE_WIDTH: f32 = 2.5;
impl Gizmos {
/// `Gizmos.line`.
pub fn line(&mut self, start: [f64; 3], end: [f64; 3], color: u32, width: f32) {
self.lines.push(Line {
start,
end,
color,
width,
});
}
/// `CuboidGizmo.emit` with a stroke style: the twelve edges in its order.
pub fn cuboid(&mut self, min: [f64; 3], max: [f64; 3], color: u32, width: f32) {
let edges = cuboid_edges(min, max);
self.lines.extend(edges.iter().map(|&(start, end)| Line {
start,
end,
color,
width,
}));
}
/// `ArrowGizmo.emit`: the shaft, then four tips around the end.
pub fn arrow(&mut self, start: [f64; 3], end: [f64; 3], color: u32, width: f32) {
self.line(start, end, color, width);
let d = glam::DVec3::from(end) - glam::DVec3::from(start);
let dir = d.as_vec3().normalize();
// Quaternionf.rotationTo((1, 0, 0), direction).
let rotation = glam::Quat::from_rotation_arc(glam::Vec3::X, dir);
// (float) Mth.clamp(distance * 0.1, 0.1, 1.0).
let len = (d.length() * f64::from(0.1f32)).clamp(f64::from(0.1f32), 1.0) as f32;
for tip in [
glam::Vec3::new(-len, len, 0.0),
glam::Vec3::new(-len, 0.0, len),
glam::Vec3::new(-len, -len, 0.0),
glam::Vec3::new(-len, 0.0, -len),
] {
let t = rotation * tip;
let from = [
end[0] + f64::from(t.x),
end[1] + f64::from(t.y),
end[2] + f64::from(t.z),
];
self.line(from, end, color, width);
}
}
/// `ChunkBorderRenderer.emitGizmos` around the camera entity's block.
pub fn chunk_borders(&mut self, camera_block: [i32; 3], min_y: i32, max_y: i32) {
let x0 = f64::from(camera_block[0] & !15);
let z0 = f64::from(camera_block[2] & !15);
let section_y = camera_block[1] & !15;
let (ymin, ymax) = (min_y as f32 as f64, (max_y + 1) as f32 as f64);
let column = |g: &mut Self, x: f64, z: f64, color: u32, width: f32| {
g.line([x, ymin, z], [x, ymax, z], color, width);
};
for x in (-16..=32).step_by(16) {
for z in (-16..=32).step_by(16) {
column(
self,
x0 + f64::from(x),
z0 + f64::from(z),
OUTER_COLUMNS,
4.0,
);
}
}
for x in (2..16).step_by(2) {
let color = if x % 4 == 0 {
CELL_BORDER
} else {
CHUNK_YELLOW
};
column(self, x0 + f64::from(x), z0, color, 1.0);
column(self, x0 + f64::from(x), z0 + 16.0, color, 1.0);
}
for z in (2..16).step_by(2) {
let color = if z % 4 == 0 {
CELL_BORDER
} else {
CHUNK_YELLOW
};
column(self, x0, z0 + f64::from(z), color, 1.0);
column(self, x0 + 16.0, z0 + f64::from(z), color, 1.0);
}
let ring = |g: &mut Self, y: f64, color: u32, width: f32| {
g.line([x0, y, z0], [x0, y, z0 + 16.0], color, width);
g.line([x0, y, z0 + 16.0], [x0 + 16.0, y, z0 + 16.0], color, width);
g.line([x0 + 16.0, y, z0 + 16.0], [x0 + 16.0, y, z0], color, width);
g.line([x0 + 16.0, y, z0], [x0, y, z0], color, width);
};
let mut y = min_y;
while y <= max_y + 1 {
let color = if y % 8 == 0 {
CELL_BORDER
} else {
CHUNK_YELLOW
};
ring(self, f64::from(y as f32), color, 1.0);
y += 2;
}
for x in [0.0, 16.0] {
for z in [0.0, 16.0] {
column(self, x0 + x, z0 + z, MAJOR_LINES, 4.0);
}
}
// The camera's section, always on top.
let min = [x0, f64::from(section_y), z0];
let max = [x0 + 16.0, f64::from(section_y + 16), z0 + 16.0];
self.on_top
.extend(cuboid_edges(min, max).iter().map(|&(start, end)| Line {
start,
end,
color: MAJOR_LINES,
width: 1.0,
}));
let mut y = min_y;
while y <= max_y + 1 {
ring(self, f64::from(y), MAJOR_LINES, 4.0);
y += 16;
}
}
/// `EntityHitboxDebugRenderer.showHitboxes` for a client entity:
/// `position` is the interpolated position, `size` (width, height).
/// `eye` is the eye height and view rotations (x, y) for living
/// entities; other entities still get the view arrow from `view`.
pub fn hitbox(
&mut self,
position: [f64; 3],
size: (f32, f32),
eye_height: f32,
living: bool,
view: (f32, f32),
) {
let half = f64::from(size.0) / 2.0;
let min = [position[0] - half, position[1], position[2] - half];
let max = [
position[0] + half,
position[1] + f64::from(size.1),
position[2] + half,
];
self.cuboid(min, max, WHITE, STROKE_WIDTH);
if living {
let eye = min[1] + f64::from(eye_height);
let d = 0.009999999776482582;
self.cuboid(
[min[0], eye - d, min[2]],
[max[0], eye + d, max[2]],
RED,
STROKE_WIDTH,
);
}
let eye = [
position[0],
position[1] + f64::from(eye_height),
position[2],
];
let v = view_vector(view.0, view.1);
let end = [
eye[0] + v[0] * 2.0,
eye[1] + v[1] * 2.0,
eye[2] + v[2] * 2.0,
];
self.arrow(eye, end, BLUE, STROKE_WIDTH);
}
}
/// The edges of `CuboidGizmo.emit`'s stroke, in order.
fn cuboid_edges(min: [f64; 3], max: [f64; 3]) -> [([f64; 3], [f64; 3]); 12] {
let [x0, y0, z0] = min;
let [x1, y1, z1] = max;
[
([x0, y0, z0], [x1, y0, z0]),
([x0, y0, z0], [x0, y1, z0]),
([x0, y0, z0], [x0, y0, z1]),
([x1, y0, z0], [x1, y1, z0]),
([x1, y1, z0], [x0, y1, z0]),
([x0, y1, z0], [x0, y1, z1]),
([x0, y1, z1], [x0, y0, z1]),
([x0, y0, z1], [x1, y0, z1]),
([x1, y0, z1], [x1, y0, z0]),
([x0, y1, z1], [x1, y1, z1]),
([x1, y0, z1], [x1, y1, z1]),
([x1, y1, z0], [x1, y1, z1]),
]
}
/// `Entity.calculateViewVector(xRot, yRot)`.
pub fn view_vector(x_rot: f32, y_rot: f32) -> [f64; 3] {
use horizon_core::geometry::trig::{cos, sin};
let x = f64::from(x_rot * (std::f32::consts::PI / 180.0));
let y = f64::from(-y_rot * (std::f32::consts::PI / 180.0));
let (yc, ys, xc, xs) = (cos(y), sin(y), cos(x), sin(x));
[f64::from(ys * xc), f64::from(-xs), f64::from(yc * xc)]
}
/// `GizmoFeatureRenderer.buildLines`: camera-relative ends, clipped at the
/// near plane in view space (z = -0.05), as (start, end, colour, width).
pub fn camera_relative(lines: &[Line], camera: [f64; 3], view: glam::Mat4) -> Vec<[f32; 8]> {
let mut out = Vec::with_capacity(lines.len());
for l in lines {
let rel = |p: [f64; 3]| {
glam::Vec3::new(
(p[0] - camera[0]) as f32,
(p[1] - camera[1]) as f32,
(p[2] - camera[2]) as f32,
)
};
let (mut start, mut end) = (rel(l.start), rel(l.end));
let (sv, ev) = (view.transform_point3(start), view.transform_point3(end));
let (start_behind, end_behind) = (sv.z > -0.05, ev.z > -0.05);
if start_behind && end_behind {
continue;
}
if start_behind || end_behind {
let denom = ev.z - sv.z;
if denom.abs() >= 1.0e-9 {
let t = ((-0.05 - sv.z) / denom).clamp(0.0, 1.0);
let cut = start.lerp(end, t);
if start_behind {
start = cut;
} else {
end = cut;
}
}
}
out.push([
start.x,
start.y,
start.z,
end.x,
end.y,
end.z,
f32::from_bits(l.color),
l.width,
]);
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn chunk_borders_match_the_renderer() {
let mut g = Gizmos::default();
g.chunk_borders([37, 70, -5], -64, 319);
// 4 * 4 outer columns, 2 * 7 + 2 * 7 inner columns, a ring every 2
// blocks, 4 major columns, a major ring every 16.
let rings = (-64..=320).step_by(2).count();
let majors = (-64..=320).step_by(16).count();
assert_eq!(g.lines.len(), 16 + 28 + rings * 4 + 4 + majors * 4);
assert_eq!(g.on_top.len(), 12);
let first = g.lines[0];
assert_eq!(first.start, [16.0, -64.0, -32.0]);
assert_eq!(first.end, [16.0, 320.0, -32.0]);
assert_eq!((first.color, first.width), (OUTER_COLUMNS, 4.0));
// The section box around y 70.
assert_eq!(g.on_top[0].start, [32.0, 64.0, -16.0]);
assert_eq!(g.on_top[11].end, [48.0, 80.0, 0.0]);
// y 0 and 8 are cell-coloured rings, y 2 yellow.
let ring_at = |y: f64| {
g.lines
.iter()
.find(|l| l.start[1] == y && l.end[1] == y)
.unwrap()
};
assert_eq!(ring_at(8.0).color, CELL_BORDER);
assert_eq!(ring_at(2.0).color, CHUNK_YELLOW);
}
#[test]
fn hitbox_box_eye_line_and_view_arrow() {
let mut g = Gizmos::default();
g.hitbox([0.5, 64.0, 0.5], (0.6, 1.8), 1.62, true, (0.0, 0.0));
assert_eq!(g.lines.len(), 12 + 12 + 5);
// EntityDimensions.makeBoundingBox: the float half width.
let corner = 0.5 - f64::from(0.6f32 / 2.0);
assert_eq!(g.lines[0].start, [corner, 64.0, corner]);
assert_eq!(g.lines[12].color, RED);
// Looking south (yRot 0): the arrow points +z.
let arrow = g.lines[24];
assert_eq!(arrow.color, BLUE);
assert!((arrow.end[2] - 2.5).abs() < 1e-6 && (arrow.end[0] - 0.5).abs() < 1e-6);
let mut g = Gizmos::default();
g.hitbox([0.0, 0.0, 0.0], (0.25, 0.25), 0.2125, false, (0.0, 0.0));
assert_eq!(g.lines.len(), 12 + 5);
}
#[test]
fn lines_behind_the_camera_are_clipped_at_the_near_plane() {
let view = glam::Mat4::IDENTITY; // looking down -z
let lines = [
Line {
start: [0.0, 0.0, -2.0],
end: [0.0, 0.0, 2.0],
color: WHITE,
width: 1.0,
},
Line {
start: [0.0, 0.0, 1.0],
end: [1.0, 0.0, 2.0],
color: WHITE,
width: 1.0,
},
];
let out = camera_relative(&lines, [0.0; 3], view);
assert_eq!(out.len(), 1);
assert!((out[0][5] + 0.05).abs() < 1e-6);
}
}
+5
View File
@@ -81,6 +81,8 @@ pub enum HealthEvent {
StarvationDamage(f32),
/// `LivingEntity.aiStep` hurting a fully frozen entity.
FreezeDamage(f32),
/// `SweetBerryBushBlock.entityInside` pricking a moving entity.
SweetBerryBushDamage(f32),
Updated {
id: u8,
value: f32,
@@ -106,6 +108,9 @@ impl HealthEvent {
match self {
Self::StarvationDamage(amount) => format!("damage starve {:08x}", amount.to_bits()),
Self::FreezeDamage(amount) => format!("damage freeze {:08x}", amount.to_bits()),
Self::SweetBerryBushDamage(amount) => {
format!("damage sweet_berry_bush {:08x}", amount.to_bits())
}
Self::Updated { id, value, dirty } => {
format!("updated {id} {:08x} {dirty}", value.to_bits())
}
+3
View File
@@ -25,6 +25,7 @@ pub mod camera;
pub mod cauldron;
pub mod chat;
pub mod chunk;
pub mod clipboard;
pub mod clock;
pub mod clouds;
pub mod collisions;
@@ -38,6 +39,7 @@ pub mod crafting;
pub mod creative;
pub mod data_cmd;
pub mod datapack;
pub mod debug_keys;
pub mod effects;
pub mod enchant;
pub mod entities;
@@ -53,6 +55,7 @@ pub mod font;
pub mod front;
pub mod gamerules;
pub mod gfx;
pub mod gizmos;
pub mod gossip;
pub mod graphics;
pub mod graphics_style;
+14
View File
@@ -939,6 +939,20 @@ pub enum MobEvent {
at: [f64; 3],
count: u32,
},
/// Client particles about a mob's box (`particles::around_self`).
AroundSelf {
kind: &'static str,
feet: [f64; 3],
width: f64,
height: f64,
burst: crate::particles::Burst,
},
/// One particle exactly at `at`, moving at `velocity`.
ParticleAt {
kind: &'static str,
at: [f64; 3],
velocity: [f64; 3],
},
Experience {
at: [f64; 3],
amount: u32,
+9 -6
View File
@@ -642,10 +642,11 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
let x = m.position.x + w * (2.0 * r.next_double() - 1.0);
let y = m.position.y + h * r.next_double() + 0.5;
let z = m.position.z + w * (2.0 * r.next_double() - 1.0);
// sendParticles(HAPPY_VILLAGER, x, y, z, 1, 0, 0, 0, 0): exactly there, at rest.
events.push(MobEvent::Particles {
kind: "happy_villager",
at: [x, y, z],
count: 1,
count: 0,
});
}
m.extra.forced_age_timer -= 1;
@@ -671,16 +672,18 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
// The heart's speed and getRandomX/Y/Z, drawn even on the server.
let (w, h) = (f64::from(m.width()), f64::from(m.height()));
let r = &mut m.random;
for _ in 0..3 {
let _ = r.next_gaussian();
}
let velocity = [
r.next_gaussian() * 0.02,
r.next_gaussian() * 0.02,
r.next_gaussian() * 0.02,
];
let x = m.position.x + w * (2.0 * r.next_double() - 1.0);
let y = m.position.y + h * r.next_double() + 0.5;
let z = m.position.z + w * (2.0 * r.next_double() - 1.0);
events.push(MobEvent::Particles {
events.push(MobEvent::ParticleAt {
kind: "heart",
at: [x, y, z],
count: 1,
velocity,
});
}
}
+29 -1
View File
@@ -7,7 +7,10 @@ use super::{
control::{MoveKind, Operation, rotlerp},
goals::{Cx, Goal, JUMP, LOOK, MOVE, NearestTarget, Prey, goal_clone, reduced},
};
use horizon_core::{geometry::Vec3, random::RandomSource};
use horizon_core::{
geometry::{Vec3, trig},
random::RandomSource,
};
// AnimState slots.
const SQUISH: usize = 0;
@@ -144,6 +147,31 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
v[SQUISH] += (v[TARGET_SQUISH] - v[SQUISH]) * 0.5;
let was = m.extra.flag2;
if m.on_ground && !was {
// The landing splash: drawn on the server too, where it spawns nothing.
let size = m.width() * 2.0;
let radius = size / 2.0;
let kind = match m.species() {
Species::MagmaCube => "flame",
Species::SulfurCube => "sulfur_cube_goo",
_ => "item_slime",
};
let mut i = 0;
while (i as f32) < size * 16.0 {
let dir = m.random.next_float() * std::f64::consts::TAU as f32;
let d = m.random.next_float() * 0.5 + 0.5;
let xd = trig::sin(f64::from(dir)) * radius * d;
let zd = trig::cos(f64::from(dir)) * radius * d;
events.push(MobEvent::Particles {
kind,
at: [
m.position.x + f64::from(xd),
m.position.y,
m.position.z + f64::from(zd),
],
count: 0,
});
i += 1;
}
let squish = match (m.species(), tiny(m)) {
(Species::SulfurCube, _) => super::sulfur_cube::squish_sound(m),
(Species::MagmaCube, true) => "entity.magma_cube.squish_small",
@@ -2925,15 +2925,21 @@ impl B {
child,
});
} else if m.random.next_int_bound(35).unwrap_or(1) == 0 {
let mut p = vec![m.position];
// Entity event 12 for the partner, then this villager:
// AbstractVillager.addParticlesAroundSelf(HEART).
let mut bodies = Vec::new();
if let Some(t) = cx.w.target_info(target) {
p.push(t.position);
let (min, max) = (t.bounds.min_position(), t.bounds.max_position());
bodies.push((t.position, max.x - min.x, max.y - min.y));
}
for at in p {
cx.events.push(MobEvent::Particles {
bodies.push((m.position, f64::from(m.width()), f64::from(m.height())));
for (feet, width, height) in bodies {
cx.events.push(MobEvent::AroundSelf {
kind: "heart",
at: [at.x, at.y + 1.8, at.z],
count: 1,
feet: [feet.x, feet.y, feet.z],
width,
height,
burst: crate::particles::Burst::VILLAGER,
});
}
}
@@ -3527,21 +3533,16 @@ fn pois_scan_order(_m: &Mob, found: &[(Poi, [i32; 3])]) -> Vec<usize> {
}
/// Entity event 14: the client shows happy particles (with its own random,
/// not the mob's).
/// Entity event 14 (`AcquirePoi`, `AssignProfessionFromJobSite`):
/// `AbstractVillager.addParticlesAroundSelf(HAPPY_VILLAGER)` on the client.
fn happy_particles(m: &Mob, cx: &mut Bx) {
let mut r = LegacyRandom::new(cx.now ^ i64::from(m.id));
let (w, h) = (f64::from(m.width()), f64::from(m.height()));
for _ in 0..5 {
let at = [
m.position.x + w * (2.0 * r.next_double() - 1.0),
m.position.y + h * r.next_double() + 1.0,
m.position.z + w * (2.0 * r.next_double() - 1.0),
];
cx.events.push(MobEvent::Particles {
kind: "happy_villager",
at,
count: 0,
});
}
cx.events.push(MobEvent::AroundSelf {
kind: "happy_villager",
feet: [m.position.x, m.position.y, m.position.z],
width: f64::from(m.width()),
height: f64::from(m.height()),
burst: crate::particles::Burst::VILLAGER,
});
}
/// `BehaviorUtils.findSectionClosestToVillage`.
fn closest_section(villages: &[[i32; 3]], center: [i32; 3], radius: i32) -> [i32; 3] {
+64 -7
View File
@@ -876,7 +876,7 @@ impl MotionWorld<'_, '_, '_> {
}
/// `Entity.applyEffectsFromBlocks` for the blocks Horizon's player reacts
/// to inside its movement path: powder snow (`PowderSnowBlock.entityInside`
/// and the FREEZE / EXTINGUISH effects). Pressure plates, tripwires and
/// and the FREEZE / EXTINGUISH effects), cobwebs and sweet berry bushes. Pressure plates, tripwires and
/// rails are the world tick's scan.
pub fn apply_effects_from_blocks(&mut self) -> Result<()> {
use horizon_world::entity_move::MovementRecord;
@@ -1056,9 +1056,14 @@ impl MotionWorld<'_, '_, '_> {
}
};
if inside && visited.insert(p.pack()) {
if powder_snow {
self.powder_snow_inside(p)?;
entered.push((step, p));
match name {
"minecraft:powder_snow" => {
self.powder_snow_inside(p)?;
entered.push((step, p));
}
"minecraft:cobweb" => self.web_inside(),
"minecraft:sweet_berry_bush" => self.sweet_berry_bush_inside(state)?,
_ => {}
}
// ServerPlayer.onInsideBlock
self.player.events.push(MotionEvent::EnterBlock { state });
@@ -1066,6 +1071,60 @@ impl MotionWorld<'_, '_, '_> {
}
Ok(iterations + 1)
}
/// `Player.makeStuckInBlock`: the next move is scaled by `multiplier`
/// (and the fall forgotten) unless flying; the impulse context resets
/// either way.
fn make_stuck_in_block(&mut self, multiplier: Vec3) {
if !self.player.flying {
self.player.fall_distance = 0.0;
self.player.stuck_multiplier = multiplier;
}
self.player.impulse.try_reset();
}
/// `WebBlock.entityInside`: stuck at a quarter of the speed, half with
/// the Weaving effect.
fn web_inside(&mut self) {
let multiplier = if self.player.status.weaving {
Vec3::new(0.5, 0.25, 0.5)
} else {
Vec3::new(0.25, f64::from(0.05_f32), 0.25)
};
self.make_stuck_in_block(multiplier);
}
/// `SweetBerryBushBlock.entityInside` for the player: slowed, and pricked
/// (`sweetBerryBush` damage, 1) by a grown bush while its known movement
/// is at least 0.003 on X or Z.
fn sweet_berry_bush_inside(&mut self, state: BlockStateId) -> Result<()> {
self.make_stuck_in_block(Vec3::new(f64::from(0.8_f32), 0.75, f64::from(0.8_f32)));
let age = self
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("age"))
.map_or("0", |a| a.as_str());
if age == "0" {
return Ok(());
}
// Player.isClientAuthoritative: ServerPlayer.getKnownMovement, this
// tick's movement.
let known = self.player.position.subtract(self.player.old_position);
if known.x * known.x + known.z * known.z > 0.0
&& (known.x.abs() >= f64::from(0.003_f32) || known.z.abs() >= f64::from(0.003_f32))
{
let id = self
.resources
.health
.damage
.id("minecraft:sweet_berry_bush")
.ok_or("missing sweet_berry_bush damage type")?;
self.player.events.push(MotionEvent::Health(
crate::health::HealthEvent::SweetBerryBushDamage(1.0),
));
let rules = self.scene.health_rules;
self.player.hurt(&self.resources.health, rules, id, 1.0)?;
}
Ok(())
}
/// `PowderSnowBlock.entityInside` for the player: stuck while the block
/// at its feet is powder snow, with a snowflake now and then (server).
fn powder_snow_inside(&mut self, p: BlockPos) -> Result<()> {
@@ -1078,9 +1137,7 @@ impl MotionWorld<'_, '_, '_> {
if !in_block {
return Ok(());
}
// Entity.makeStuckInBlock
EntityMoveWorld::reset_fall_distance(self)?;
self.player.stuck_multiplier = Vec3::new(f64::from(0.9_f32), 1.5, f64::from(0.9_f32));
self.make_stuck_in_block(Vec3::new(f64::from(0.9_f32), 1.5, f64::from(0.9_f32)));
// ServerPlayer.getKnownMovement: this tick's movement.
let known = self.player.position.subtract(self.player.old_position);
let random = &mut self.scene.random;
+10
View File
@@ -578,6 +578,16 @@ impl Screen {
_ => None,
}
}
/// The focused text field, its id and maximum length (copy and paste).
pub fn focused_text(&mut self) -> Option<(crate::clipboard::FieldId, &mut String, usize)> {
let id = match self {
Self::Edit { focus: 0, .. } => ("server.name", 0),
Self::Edit { .. } => ("server.address", 0),
Self::Direct { .. } => ("server.direct", 0),
_ => return None,
};
self.focused_field().map(|f| (id, f, 128))
}
pub fn type_text(&mut self, text: &str) {
if let Some(field) = self.focused_field() {
for c in text.chars().filter(|c| !c.is_control()) {
+25
View File
@@ -1642,6 +1642,31 @@ impl OptionsUi {
self.scroll = 0.0;
}
}
/// Ctrl+A/C/V/X in the language or pack search box; false when neither
/// is shown with the focus.
pub fn shortcut(
&mut self,
atlas: &HudAtlas,
shortcut: crate::clipboard::EditShortcut,
clipboard: &mut dyn crate::clipboard::Clipboard,
) -> bool {
if self.selected_key.is_some() {
return false;
}
if self.page() == Page::Packs
&& let Some(p) = &mut self.pack_screen
{
let m = crate::screen_draw::Measure(&atlas.font);
return p.shortcut(&m, shortcut, clipboard);
}
if self.page() == Page::Language {
if self.language_search.shortcut(shortcut, clipboard) {
self.scroll = 0.0;
}
return true;
}
false
}
/// Keys while the options are open. Returns events; `handled` false lets
/// Escape fall through.
pub fn key(
+15
View File
@@ -673,6 +673,21 @@ impl PackScreen {
self.filter(None);
}
}
/// Ctrl+A/C/V/X in the search box; false when it does not have the focus.
pub fn shortcut(
&mut self,
m: &Measure,
shortcut: crate::clipboard::EditShortcut,
clipboard: &mut dyn crate::clipboard::Clipboard,
) -> bool {
if !self.search_focused() {
return false;
}
if self.search.shortcut(m, shortcut, clipboard) {
self.filter(None);
}
true
}
/// Backspace in the search box.
pub fn erase(&mut self, m: &Measure, count: isize) {
if self.confirm.is_none()
+708 -12
View File
@@ -130,18 +130,69 @@ particle_types! {
Shriek = "shriek",
SonicBoom = "sonic_boom",
Vibration = "vibration",
SweepAttack = "sweep_attack",
Glow = "glow",
WaxOn = "wax_on",
WaxOff = "wax_off",
ElectricSpark = "electric_spark",
Scrape = "scrape",
SquidInk = "squid_ink",
GlowSquidInk = "glow_squid_ink",
Item = "item",
ItemSlime = "item_slime",
ItemSnowball = "item_snowball",
ItemCobweb = "item_cobweb",
SulfurCubeGoo = "sulfur_cube_goo",
Flash = "flash",
Firefly = "firefly",
TrialSpawnerDetection = "trial_spawner_detection",
TrialSpawnerDetectionOminous = "trial_spawner_detection_ominous",
TrialOmen = "trial_omen",
RaidOmen = "raid_omen",
OminousSpawning = "ominous_spawning",
Spit = "spit",
Fishing = "fishing",
DustPlume = "dust_plume",
RedPoplarLeaves = "red_poplar_leaves",
OrangePoplarLeaves = "orange_poplar_leaves",
YellowPoplarLeaves = "yellow_poplar_leaves",
PauseMobGrowth = "pause_mob_growth",
ResetMobGrowth = "reset_mob_growth",
BlockMarker = "block_marker",
}
impl ParticleType {
/// `ParticleType.getOverrideLimiter`: spawned regardless of distance.
/// `ParticleType.getOverrideLimiter` (`ParticleTypes.register(name, true)`):
/// spawned regardless of distance.
pub fn override_limiter(self) -> bool {
matches!(
self,
Self::DamageIndicator
Self::BlockMarker
| Self::DamageIndicator
| Self::ExplosionEmitter
| Self::Explosion
| Self::Poof
| Self::Gust
| Self::GustEmitterLarge
| Self::GustEmitterSmall
| Self::SonicBoom
| Self::SculkCharge
| Self::SculkChargePop
| Self::Vibration
| Self::Poof
| Self::Spit
| Self::SquidInk
| Self::SweepAttack
| Self::CampfireCosySmoke
| Self::CampfireSignalSmoke
| Self::GlowSquidInk
| Self::Glow
| Self::WaxOn
| Self::WaxOff
| Self::ElectricSpark
| Self::Scrape
| Self::TrialSpawnerDetection
| Self::TrialSpawnerDetectionOminous
| Self::VaultConnection
| Self::OminousSpawning
)
}
}
@@ -161,6 +212,9 @@ pub struct ParticleOptions {
pub to_color: [f32; 3],
/// `TrailParticleOption`: the point it flies to and how many ticks it takes.
pub trail: Option<([f64; 3], i32)>,
/// `ItemParticleOption`: the particle sprite of each layer of the item's
/// model as resolved for the ground.
pub item: Option<Vec<String>>,
}
impl ParticleOptions {
pub fn simple(ty: ParticleType) -> Self {
@@ -171,6 +225,14 @@ impl ParticleOptions {
scale: 1.0,
to_color: [1.0, 0.0, 0.0],
trail: None,
item: None,
}
}
/// `ItemParticleOption`: the stack's layer particle sprites (`BreakingItemParticle`).
pub fn item(layers: Vec<String>) -> Self {
Self {
item: Some(layers),
..Self::simple(ParticleType::Item)
}
}
/// `DustColorTransitionOptions`.
@@ -260,6 +322,8 @@ enum Size {
ReversePortal,
/// `ShriekParticle.getQuadSize`.
Shriek,
/// `FireworkParticles.OverlayParticle.getQuadSize`: a sine pulse.
Flash,
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum Light {
@@ -271,6 +335,8 @@ enum Light {
AgeEmission,
/// `addSmoothBlockEmission` with the age fraction to the fourth power.
AgeEmission4,
/// `FireflyParticle.getLightCoords`: block light fading in and out, no sky.
Firefly,
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum Behaviour {
@@ -359,6 +425,20 @@ enum Behaviour {
Trail {
target: [f64; 3],
},
/// `SquidInkParticle`: `SimpleAnimatedParticle`, sinking through air.
SquidInk,
/// `FireflyParticle`: wanders, fading in and out, gone inside blocks.
Firefly,
/// `WakeParticle` (fishing): grows and cycles four sprites.
Wake,
/// `DustPlumeParticle`: gravity and friction decay every tick.
DustPlume,
/// `FlyStraightTowardsParticle`: from its start along its motion back to
/// the start, the colour moving from one to the other.
FlyStraight {
start: [f64; 3],
colors: [u32; 2],
},
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum DripStage {
@@ -447,6 +527,115 @@ pub fn breaking_position(
Some(p)
}
/// A burst of particles about an entity's box (`around_self`).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Burst {
pub count: u32,
/// Scale of the Gaussian speeds; `None` spawns them at rest without drawing any.
pub speed: Option<f64>,
/// Added to `getRandomY()`.
pub y: f64,
}
impl Burst {
/// `AbstractVillager.addParticlesAroundSelf`.
pub const VILLAGER: Self = Self {
count: 5,
speed: Some(0.02),
y: 1.0,
};
/// `TamableAnimal`/`AbstractHorse.spawnTamingParticles`,
/// `Ocelot.spawnTrustingParticles`, `Animal`'s entity event 18.
pub const TAMING: Self = Self {
count: 7,
speed: Some(0.02),
y: 0.5,
};
/// `Allay`'s entity event 18: three `spawnHeartParticle`.
pub const ALLAY: Self = Self {
count: 3,
speed: Some(0.02),
y: 0.5,
};
/// `Dolphin.addParticlesAroundSelf`.
pub const DOLPHIN: Self = Self {
count: 7,
speed: Some(0.01),
y: 0.2,
};
/// `AbstractHorse.handleEating`'s growth particle.
pub const HORSE_EATING: Self = Self {
count: 1,
speed: None,
y: 0.5,
};
}
/// The particle bursts entity events show on the client: the particle and
/// burst of `handleEntityEvent(event)` for the entity type `entity`.
pub fn entity_event_burst(entity: &str, event: u8) -> Option<(&'static str, Burst)> {
let entity = entity.strip_prefix("minecraft:").unwrap_or(entity);
let tamable = matches!(
entity,
"wolf" | "cat" | "parrot" | "nautilus" | "zombie_nautilus"
);
let horse = matches!(
entity,
"horse"
| "donkey"
| "mule"
| "llama"
| "trader_llama"
| "camel"
| "camel_husk"
| "skeleton_horse"
| "zombie_horse"
);
Some(match (entity, event) {
("villager", 12) => ("heart", Burst::VILLAGER),
("villager", 13) => ("angry_villager", Burst::VILLAGER),
("villager", 14) => ("happy_villager", Burst::VILLAGER),
("villager", 42) => ("splash", Burst::VILLAGER),
("allay", 18) => ("heart", Burst::ALLAY),
("dolphin", 38) => ("happy_villager", Burst::DOLPHIN),
("ocelot", 41) => ("heart", Burst::TAMING),
("ocelot", 40) => ("smoke", Burst::TAMING),
(_, 7) if tamable || horse => ("heart", Burst::TAMING),
(_, 6) if tamable || horse => ("smoke", Burst::TAMING),
(_, 18) if !matches!(entity, "villager" | "allay") => ("heart", Burst::TAMING),
_ => return None,
})
}
/// Particles about an entity's box, as `AbstractVillager.addParticlesAroundSelf`,
/// `Animal`'s love hearts (entity event 18), `TamableAnimal` and
/// `AbstractHorse.spawnTamingParticles`, `Ocelot.spawnTrustingParticles`,
/// `Allay`'s hearts and `Dolphin.addParticlesAroundSelf` place them: `count`
/// times three Gaussian speeds scaled by `speed` (none drawn without one), then
/// `getRandomX(1.0)`, `getRandomY() + y` and `getRandomZ(1.0)`.
pub fn around_self(
random: &mut impl RandomSource,
feet: [f64; 3],
width: f64,
height: f64,
burst: Burst,
mut emit: impl FnMut([f64; 3], [f64; 3]),
) {
for _ in 0..burst.count {
let v = burst.speed.map_or([0.0; 3], |s| {
[
random.next_gaussian() * s,
random.next_gaussian() * s,
random.next_gaussian() * s,
]
});
let p = [
feet[0] + width * ((2.0 * random.next_double() - 1.0) * 1.0),
feet[1] + height * random.next_double() + burst.y,
feet[2] + width * ((2.0 * random.next_double() - 1.0) * 1.0),
];
emit(p, v);
}
}
/// ClientLevel.addDestroyBlockEffect placement and pre-constructor velocities.
pub fn destroy_positions(
pos: [i32; 3],
@@ -474,6 +663,110 @@ pub fn destroy_positions(
}
}
/// `LivingEntity.spawnItemParticles(stack, count)` (eating, drinking, an item
/// breaking): `count` crumbs in front of the eyes, thrown up and forwards,
/// both turned by the pitch and yaw in degrees.
pub fn item_use_particles(
random: &mut impl RandomSource,
pitch: f32,
yaw: f32,
position: [f64; 3],
eye_y: f64,
count: u32,
mut emit: impl FnMut([f64; 3], [f64; 3]),
) {
let (x_rot, y_rot) = (-pitch * trig::DEG_TO_RAD, -yaw * trig::DEG_TO_RAD);
for _ in 0..count {
let d = Vec3::new(
(f64::from(random.next_float()) - 0.5) * 0.1,
f64::from(random.next_float()) * 0.1 + 0.1,
0.0,
)
.rotate_x(x_rot)
.rotate_y(y_rot);
let y = f64::from(-random.next_float()) * 0.6 - 0.3;
let p = Vec3::new((f64::from(random.next_float()) - 0.5) * 0.3, y, 0.6)
.rotate_x(x_rot)
.rotate_y(y_rot);
emit(
[p.x + position[0], p.y + eye_y, p.z + position[2]],
[d.x, d.y + 0.05, d.z],
);
}
}
/// `Mth.nextDouble(random, min, max)`.
fn next_double_between(random: &mut impl RandomSource, min: f64, max: f64) -> f64 {
if min >= max {
min
} else {
random.next_double() * (max - min) + min
}
}
/// `ParticleUtils.spawnParticlesOnBlockFaces(level, pos, particle, UniformInt.of(3, 5))`
/// (level events 3002 without an axis, 3003 wax on, 3004 wax off, 3005 scrape):
/// three to five particles on each face, in `Direction.values()` order, moving
/// along the face at up to half a block a tick.
pub fn on_block_faces(
random: &mut impl RandomSource,
pos: [i32; 3],
mut emit: impl FnMut([f64; 3], [f64; 3]),
) {
const FACES: [[i32; 3]; 6] = [
[0, -1, 0],
[0, 1, 0],
[0, 0, -1],
[0, 0, 1],
[-1, 0, 0],
[1, 0, 0],
];
for face in FACES {
let count = random.next_int_bound(5 - 3 + 1).unwrap_or(0) + 3;
for _ in 0..count {
// getRandomSpeedRanges, then spawnParticleOnFace with step factor 0.55.
let speed: [f64; 3] = std::array::from_fn(|_| next_double_between(random, -0.5, 0.5));
let mut p = [0.0; 3];
let mut v = [0.0; 3];
for i in 0..3 {
let center = f64::from(pos[i]) + 0.5;
if face[i] == 0 {
p[i] = center + next_double_between(random, -0.5, 0.5);
v[i] = speed[i];
} else {
p[i] = center + f64::from(face[i]) * 0.55;
}
}
emit(p, v);
}
}
}
/// `ParticleUtils.spawnParticlesAlongAxis(axis, level, pos, 0.125, particle,
/// UniformInt.of(10, 19))` (level event 3002 on a lightning rod): sparks along
/// the rod, moving along it. `axis` is 0, 1, 2 for X, Y, Z.
pub fn along_axis(
random: &mut impl RandomSource,
axis: usize,
pos: [i32; 3],
mut emit: impl FnMut([f64; 3], [f64; 3]),
) {
let count = random.next_int_bound(19 - 10 + 1).unwrap_or(0) + 10;
for _ in 0..count {
let p: [f64; 3] = std::array::from_fn(|i| {
f64::from(pos[i])
+ 0.5
+ next_double_between(random, -1.0, 1.0) * if i == axis { 0.5 } else { 0.125 }
});
let v: [f64; 3] = std::array::from_fn(|i| {
if i == axis {
next_double_between(random, -1.0, 1.0)
} else {
0.0
}
});
emit(p, v);
}
}
impl Particle {
/// `Particle(level, x, y, z)` + `SingleQuadParticle` (no initial velocity).
fn at(random: &mut LegacyRandom, ty: ParticleType, p: [f64; 3]) -> Self {
@@ -692,6 +985,11 @@ impl Particle {
let b = (b * b) * (b * b);
(sky, (block + (b.clamp(0.0, 1.0) * 240.0) as u32).min(240))
}
Light::Firefly => (
0,
(255.0 * fade_amount(self.lifetime_progress(self.age as f32 + partial), 0.1, 0.3))
as u32,
),
}
}
fn quad_size(&self, a: f32) -> f32 {
@@ -709,8 +1007,27 @@ impl Particle {
self.size * (1.0 - (self.age as f32 + a) / (self.lifetime as f32 * 1.5))
}
Size::Shriek => self.size * (t * 0.75).clamp(0.0, 1.0),
Size::Flash => {
7.1 * trig::sin(f64::from(
(self.age as f32 + a - 1.0) * 0.25 * std::f64::consts::PI as f32,
))
}
}
}
/// `FireflyParticle.getLifetimeProgress`.
fn lifetime_progress(&self, age: f32) -> f32 {
(age / self.lifetime as f32).clamp(0.0, 1.0)
}
}
/// `FireflyParticle.getFadeAmount`.
fn fade_amount(progress: f32, fade_in: f32, fade_out: f32) -> f32 {
if progress >= 1.0 - fade_in {
(1.0 - progress) / fade_in
} else if progress <= fade_out {
progress / fade_out
} else {
1.0
}
}
/// A particle's fields as the parity probe reports them.
@@ -827,6 +1144,9 @@ pub struct ParticleEngine {
starters: Vec<Starter>,
/// Local sounds requested by particles (dripstone drips): (event, position, volume, pitch).
pub sounds: Vec<(&'static str, [f64; 3], f32, f32)>,
/// The item particles' sprites (`BreakingItemParticle`'s slime ball, snowball
/// and cobweb models, resolved for the ground), one per model layer.
pub item_sprites: HashMap<ParticleType, Vec<String>>,
}
/// `ParticleGroup.MAX_PARTICLES` (per render group; one group here).
const MAX_PARTICLES: usize = 16384;
@@ -849,6 +1169,7 @@ impl ParticleEngine {
starters: Vec::new(),
camera: [0.0; 3],
sounds: Vec::new(),
item_sprites: HashMap::new(),
};
let dir = root.join("assets/minecraft/particles");
for &ty in ParticleType::ALL {
@@ -925,6 +1246,10 @@ impl ParticleEngine {
pub fn random(&mut self) -> &mut LegacyRandom {
&mut self.random
}
/// `ClientLevel.random` as client effects use it (`LevelEventHandler`).
pub fn level_random(&mut self) -> &mut LegacyRandom {
&mut self.level_random
}
/// `ClientLevel.addParticle`: dropped beyond 32 blocks of the camera unless
/// the type overrides the limiter.
pub fn add(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
@@ -1227,12 +1552,22 @@ impl ParticleEngine {
q.set = set;
q
}
T::Smoke | T::LargeSmoke | T::WhiteSmoke | T::Ash | T::WhiteAsh => {
T::Smoke | T::LargeSmoke | T::WhiteSmoke | T::Ash | T::WhiteAsh | T::DustPlume => {
// BaseAshSmokeParticle(dir, xa, scale, colorRandom, maxLifetime, gravity, hasPhysics).
let (dir, scale, color_random, max_lifetime, gravity, physics, vel) = match ty {
T::Smoke | T::WhiteSmoke => ([0.1, 0.1, 0.1], 1.0, 0.3, 8, -0.1, true, v),
T::LargeSmoke => ([0.1, 0.1, 0.1], 2.5, 0.3, 8, -0.1, true, v),
T::Ash => ([0.1, -0.1, 0.1], 1.0, 0.5, 20, 0.1, false, [0.0; 3]),
// DustPlumeParticle: ya + 0.15F.
T::DustPlume => (
[0.7, 0.6, 0.7],
1.0,
0.5,
7,
0.5,
false,
[v[0], v[1] + f64::from(0.15f32), v[2]],
),
_ => {
// WhiteAshParticle.Provider draws the motion.
let pr = &mut self.random;
@@ -1267,6 +1602,15 @@ impl ParticleEngine {
}
q.size_curve = Size::GrowIn;
q.behaviour = Behaviour::Animated;
if ty == T::DustPlume {
let shift = r.next_float() * 0.2;
q.set_color(
186.0 / 255.0 - shift,
177.0 / 255.0 - shift,
194.0 / 255.0 - shift,
);
q.behaviour = Behaviour::DustPlume;
}
q.set = set;
q
}
@@ -1740,9 +2084,9 @@ impl ParticleEngine {
}
q
}
T::Poof | T::Snowflake => {
T::Poof | T::Snowflake | T::Spit => {
let mut q = Particle::at(r, ty, p);
if ty == T::Poof {
if ty != T::Snowflake {
q.gravity = -0.1;
q.friction = 0.9;
} else {
@@ -1752,7 +2096,7 @@ impl ParticleEngine {
for i in 0..3 {
q.velocity[i] = v[i] + f64::from((r.next_float() * 2.0 - 1.0) * 0.05);
}
if ty == T::Poof {
if ty != T::Snowflake {
let col = r.next_float() * 0.3 + 0.7;
q.set_color(col, col, col);
q.size = 0.1 * (r.next_float() * r.next_float() * 6.0 + 1.0);
@@ -1760,11 +2104,15 @@ impl ParticleEngine {
q.size = 0.1 * (r.next_float() * r.next_float() + 1.0);
}
q.lifetime = (16.0 / (f64::from(r.next_float()) * 0.8 + 0.2)) as i32 + 2;
q.behaviour = if ty == T::Poof {
Behaviour::Animated
} else {
q.behaviour = if ty == T::Snowflake {
Behaviour::Snowflake
} else {
Behaviour::Animated
};
// SpitParticle: ExplodeParticle falling at gravity 0.5.
if ty == T::Spit {
q.gravity = 0.5;
}
if ty == T::Snowflake {
q.set_color(0.923, 0.964, 0.999);
}
@@ -2005,7 +2353,12 @@ impl ParticleEngine {
q.set = set;
q
}
T::CherryLeaves | T::PaleOakLeaves | T::TintedLeaves => {
T::CherryLeaves
| T::PaleOakLeaves
| T::TintedLeaves
| T::RedPoplarLeaves
| T::OrangePoplarLeaves
| T::YellowPoplarLeaves => {
let (fall, side, swirl, flow, scale, start) = if ty == T::CherryLeaves {
(0.25f32, 2.0f32, false, true, 1.0f32, 0.0f32)
} else {
@@ -2041,7 +2394,13 @@ impl ParticleEngine {
};
q
}
T::Effect | T::InstantEffect | T::EntityEffect | T::Witch | T::Infested => {
T::Effect
| T::InstantEffect
| T::EntityEffect
| T::Witch
| T::Infested
| T::TrialOmen
| T::RaidOmen => {
// SpellParticle: x/z velocity from `SpellParticle.RANDOM`, y from the option.
let xa = 0.5 - self.spell_random.next_double();
let za = 0.5 - self.spell_random.next_double();
@@ -2117,6 +2476,239 @@ impl ParticleEngine {
q.set_power(o.scale);
q
}
// AttackSweepParticle: `xAux` shrinks it; still, bright, animated over 4 ticks.
T::SweepAttack => {
let mut q = Particle::moving(r, ty, p, [0.0; 3]);
q.lifetime = 4;
let col = r.next_float() * 0.6 + 0.4;
q.set_color(col, col, col);
q.size = 1.0 - v[0] as f32 * 0.5;
q.light = Light::FullBright;
q.behaviour = Behaviour::HugeExplosion;
q.set = set;
q
}
// GlowParticle and its providers.
T::Glow | T::WaxOn | T::WaxOff | T::ElectricSpark | T::Scrape => {
let pr = &mut self.random;
let start = if ty == T::Glow {
let xa = 0.5 - pr.next_double();
[xa, v[1], 0.5 - pr.next_double()]
} else {
[0.0; 3]
};
let mut q = Particle::moving(r, ty, p, start);
q.friction = 0.96;
q.speed_up_when_y_blocked = true;
q.size *= 0.75;
q.has_physics = false;
q.light = Light::AgeEmission;
q.behaviour = Behaviour::Animated;
q.set = set;
match ty {
T::ElectricSpark => {
q.set_color(1.0, 0.9, 1.0);
q.velocity = [v[0] * 0.25, v[1] * 0.25, v[2] * 0.25];
q.lifetime = pr.next_int_bound(2).unwrap_or(0) + 2;
}
T::Glow => {
if pr.next_boolean() {
q.set_color(0.6, 1.0, 0.8);
} else {
q.set_color(0.08, 0.4, 0.4);
}
q.velocity[1] *= f64::from(0.2f32);
if v[0] == 0.0 && v[2] == 0.0 {
q.velocity[0] *= f64::from(0.1f32);
q.velocity[2] *= f64::from(0.1f32);
}
q.lifetime = (8.0 / (pr.next_double() * 0.8 + 0.2)) as i32;
}
T::Scrape => {
if pr.next_boolean() {
q.set_color(0.29, 0.58, 0.51);
} else {
q.set_color(0.43, 0.77, 0.62);
}
q.velocity = [v[0] * 0.01, v[1] * 0.01, v[2] * 0.01];
q.lifetime = pr.next_int_bound(30).unwrap_or(0) + 10;
}
_ => {
if ty == T::WaxOn {
q.set_color(0.91, 0.55, 0.08);
} else {
q.set_color(1.0, 0.9, 1.0);
}
q.velocity = [v[0] * 0.01 / 2.0, v[1] * 0.01, v[2] * 0.01 / 2.0];
q.lifetime = pr.next_int_bound(30).unwrap_or(0) + 10;
}
}
q
}
// SquidInkParticle (SimpleAnimatedParticle, gravity 0).
T::SquidInk | T::GlowSquidInk => {
let mut q = Particle::at(r, ty, p);
q.friction = 0.92;
q.size = 0.5;
if ty == T::GlowSquidInk {
// ARGB.colorFromFloat(1, 0.2, 0.8, 0.6), back to floats.
q.set_color(51.0 / 255.0, 204.0 / 255.0, 153.0 / 255.0);
} else {
q.set_color(0.0, 0.0, 0.0);
}
q.lifetime = (q.size * 12.0 / (r.next_float() * 0.8 + 0.2)) as i32;
q.has_physics = false;
q.velocity = v;
q.light = Light::FullBright;
q.behaviour = Behaviour::SquidInk;
q.set = set;
q
}
// BreakingItemParticle: a crumb of the item's sprite.
T::Item | T::ItemSlime | T::ItemSnowball | T::ItemCobweb | T::SulfurCubeGoo => {
let sprite = if ty == T::SulfurCubeGoo {
self.first(ty)
} else {
// ItemStackRenderState.pickParticleMaterial.
let layers = match ty {
T::Item => o.item.clone().unwrap_or_default(),
_ => self.item_sprites.get(&ty).cloned().unwrap_or_default(),
};
if layers.is_empty() {
Sprite::Index(u32::MAX)
} else {
let i = self.random.next_int_bound(layers.len() as i32).unwrap_or(0);
Sprite::Named(layers[i as usize].clone())
}
};
let mut q = Particle::moving(r, ty, p, [0.0; 3]);
q.sprite = sprite;
q.gravity = 1.0;
q.size /= 2.0;
let uo = r.next_float() * 3.0;
let vo = r.next_float() * 3.0;
q.uv = [(uo + 1.0) / 4.0, vo / 4.0, uo / 4.0, (vo + 1.0) / 4.0];
if ty == T::Item {
for i in 0..3 {
q.velocity[i] = q.velocity[i] * f64::from(0.1f32) + v[i];
}
}
q
}
// FireworkParticles.OverlayParticle: the flash of an explosion.
T::Flash => {
let mut q = Particle::at(r, ty, p);
q.lifetime = 4;
q.set_color(o.color[0], o.color[1], o.color[2]);
q.rgba[3] = o.color[3];
q.size_curve = Size::Flash;
q
}
// FireflyParticle; the provider draws its motion, sprite and lifetime.
T::Firefly => {
let pr = &mut self.random;
let xa = 0.5 - pr.next_double();
let ya = if pr.next_boolean() { v[1] } else { -v[1] };
let za = 0.5 - pr.next_double();
let sprite = self.sprite_from_set(ty);
let mut q = Particle::moving(r, ty, p, [xa, ya, za]);
q.sprite = sprite;
q.speed_up_when_y_blocked = true;
q.friction = 0.96;
q.size *= 0.75;
q.velocity[1] *= f64::from(0.8f32);
q.velocity[0] *= f64::from(0.8f32);
q.velocity[2] *= f64::from(0.8f32);
q.lifetime = self
.random
.next_int_between_inclusive(200, 300)
.unwrap_or(200);
q.scale(1.5);
q.rgba[3] = 0.0;
q.light = Light::Firefly;
q.behaviour = Behaviour::Firefly;
q
}
// TrialSpawnerDetectionParticle (scale 1.5 from the provider).
T::TrialSpawnerDetection | T::TrialSpawnerDetectionOminous => {
let scale = 1.5f32;
let mut q = Particle::moving(r, ty, p, [0.0; 3]);
q.friction = 0.96;
q.gravity = -0.1;
q.speed_up_when_y_blocked = true;
q.velocity[0] *= 0.0;
q.velocity[1] *= 0.9;
q.velocity[2] *= 0.0;
for i in 0..3 {
q.velocity[i] += v[i];
}
q.size *= 0.75 * scale;
// Mth.randomBetween(random, 0.5, 1.0).
q.lifetime = ((8.0 / (r.next_float() * (1.0 - 0.5) + 0.5) * scale) as i32).max(1);
q.light = Light::Block15;
q.size_curve = Size::GrowIn;
q.behaviour = Behaviour::Animated;
q.set = set;
q
}
// FlyStraightTowardsParticle.OminousSpawnProvider.
T::OminousSpawning => {
let sprite = self.sprite_from_set(ty);
let mut q = Particle::at(r, ty, p);
q.sprite = sprite;
q.velocity = v;
let start = [p[0] + v[0], p[1] + v[1], p[2] + v[2]];
q.previous = start;
q.position = start;
q.size = 0.1 * (r.next_float() * 0.5 + 0.2);
q.has_physics = false;
q.free_move = true;
q.lifetime = (r.next_float() * 5.0) as i32 + 25;
q.light = Light::Block15;
q.behaviour = Behaviour::FlyStraight {
start: p,
colors: [0xFF45_AEFE, 0xFFFF_FFFF],
};
// Mth.randomBetween(level.getRandom(), 3, 5).
let s = self.level_random.next_float() * (5.0 - 3.0) + 3.0;
q.scale(s);
q
}
// WakeParticle.
T::Fishing => {
let mut q = Particle::moving(r, ty, p, [0.0; 3]);
q.velocity[0] *= f64::from(0.3f32);
q.velocity[1] = f64::from(r.next_float() * 0.2 + 0.1);
q.velocity[2] *= f64::from(0.3f32);
q.set_size(0.01, 0.01);
q.lifetime = (8.0 / (f64::from(r.next_float()) * 0.8 + 0.2)) as i32;
q.gravity = 0.0;
q.velocity = v;
q.behaviour = Behaviour::Wake;
q.set = set;
q
}
// SimpleVerticalParticle.
T::PauseMobGrowth | T::ResetMobGrowth => {
let mut q = Particle::moving(r, ty, p, v);
q.velocity = v;
q.gravity = 0.0;
q.velocity[1] += if ty == T::ResetMobGrowth { 0.03 } else { -0.03 };
q.size *= r.next_float() * 0.6 + 0.5;
q.lifetime = 8;
q
}
// BlockMarker: the block's particle sprite, half a block wide, 80 ticks.
T::BlockMarker => {
let (sprite, _) = o.block.clone()?;
let mut q = Particle::at(r, ty, p);
q.sprite = Sprite::Named(sprite);
q.gravity = 0.0;
q.lifetime = 80;
q.has_physics = false;
q.size = 0.5;
q
}
T::Trail => {
let (target, duration) = o.trail?;
let mut q = Particle::moving(r, ty, p, v);
@@ -2256,6 +2848,19 @@ impl ParticleEngine {
}
}
}
// The flash: ColorParticleOption.create(FLASH, first colour), alpha 0.
let c = colors[0];
let rgba = [
((c >> 16) & 255) as f32 / 255.0,
((c >> 8) & 255) as f32 / 255.0,
(c & 255) as f32 / 255.0,
((c >> 24) & 255) as f32 / 255.0,
];
self.create(
&ParticleOptions::colored(ParticleType::Flash, rgba),
s.at,
[0.0; 3],
);
}
s.life += 1;
if s.life > s.lifetime {
@@ -2886,6 +3491,93 @@ impl ParticleEngine {
p.velocity[1] -= f64::from(0.003f32);
p.velocity[1] = p.velocity[1].max(f64::from(-0.14f32));
}
Behaviour::SquidInk => {
// SimpleAnimatedParticle.tick, then SquidInkParticle's.
p.base_tick(level);
self.sprite_from_age(p);
let half = |p: &mut Particle| {
if p.age > p.lifetime / 2 {
p.rgba[3] =
1.0 - (p.age as f32 - (p.lifetime / 2) as f32) / p.lifetime as f32;
}
};
half(p);
if !p.removed {
self.sprite_from_age(p);
half(p);
let b = ParticleLevel::block_at(p.position);
if level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
p.velocity[1] -= f64::from(0.0074f32);
}
}
}
Behaviour::Firefly => {
p.base_tick(level);
let b = ParticleLevel::block_at(p.position);
if !level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
p.removed = true;
} else {
p.rgba[3] = fade_amount(p.lifetime_progress(p.age as f32), 0.3, 0.5);
if p.random.next_float() > 0.95 || p.age == 1 {
let r = &mut p.random;
let mut speed = || f64::from(-0.05f32 + 0.1 * r.next_float());
p.velocity = [speed(), speed(), speed()];
}
}
}
Behaviour::Wake => {
p.previous = p.position;
let life = 60 - p.lifetime;
let lifetime = p.lifetime;
p.lifetime -= 1;
if lifetime <= 0 {
p.removed = true;
return;
}
p.velocity[1] -= f64::from(p.gravity);
p.move_by(level, p.velocity);
for c in &mut p.velocity {
*c *= f64::from(0.98f32);
}
let size = life as f32 * 0.001;
p.set_size(size, size);
// SpriteSet.get(life % 4, 4).
if let Some(set) = p.set {
let sprites = &self.set_sprites[set as usize];
let index = (life % 4) as usize * (sprites.len() - 1) / 4;
p.sprite = Sprite::Index(sprites[index]);
}
}
Behaviour::DustPlume => {
p.gravity *= 0.88;
p.friction *= 0.92;
p.base_tick(level);
self.sprite_from_age(p);
}
Behaviour::FlyStraight { start, colors } => {
p.previous = p.position;
let age = p.age;
p.age += 1;
if age >= p.lifetime {
p.removed = true;
return;
}
let normalized = p.age as f32 / p.lifetime as f32;
let along = 1.0 - normalized;
for i in 0..3 {
p.position[i] = start[i] + p.velocity[i] * f64::from(along);
}
// ARGB.srgbLerp: Mth.lerpInt on each 8-bit channel.
let lerp = |shift: u32| {
let (a, b) = (
(colors[0] >> shift & 255) as i32,
(colors[1] >> shift & 255) as i32,
);
(a + (normalized * (b - a) as f32).floor() as i32) as f32 / 255.0
};
p.set_color(lerp(16), lerp(8), lerp(0));
p.rgba[3] = lerp(24);
}
Behaviour::DragonBreath { mut hit_ground } => {
p.previous = p.position;
let age = p.age;
@@ -2961,6 +3653,10 @@ impl ParticleEngine {
};
let size = p.quad_size(partial);
let mut alpha = p.rgba[3];
// OverlayParticle.extract: the flash fades as it pulses.
if p.ty == ParticleType::Flash {
alpha = 0.6 - (p.age as f32 + partial - 1.0) * 0.25 * 0.5;
}
if let Behaviour::FlyTowards { alpha: la, .. } = p.behaviour {
alpha = lifetime_alpha(la, p.age, p.lifetime, partial);
}
+34
View File
@@ -476,6 +476,23 @@ fn chars(s: &str) -> usize {
fn sub(s: &str, from: usize, to: usize) -> String {
s.chars().skip(from).take(to.saturating_sub(from)).collect()
}
/// A text field with the font that scrolls it.
struct MeasuredField<'a, 'm>(&'a mut TextField, &'a Measure<'m>);
impl crate::clipboard::Editable for MeasuredField<'_, '_> {
fn select_all(&mut self) {
let len = chars(&self.0.value);
self.0.move_cursor_to(self.1, len, false);
self.0.set_highlight(self.1, 0);
}
fn selected_text(&self) -> String {
self.0.selected_text()
}
fn insert(&mut self, text: &str) -> bool {
let before = self.0.value.clone();
self.0.insert_text(self.1, text);
self.0.value != before
}
}
impl TextField {
pub fn new(x: i32, y: i32, width: i32, height: i32) -> Self {
Self {
@@ -668,6 +685,23 @@ impl TextField {
}
Some(false)
}
/// Ctrl+A/C/V/X (`EditBox.keyPressed`). True when the value changed.
pub fn shortcut(
&mut self,
m: &Measure,
shortcut: crate::clipboard::EditShortcut,
clipboard: &mut dyn crate::clipboard::Clipboard,
) -> bool {
crate::clipboard::apply(&mut MeasuredField(self, m), shortcut, clipboard)
}
/// `getHighlighted`.
pub fn selected_text(&self) -> String {
sub(
&self.value,
self.cursor.min(self.highlight),
self.cursor.max(self.highlight),
)
}
/// `getScreenX`: where a character index is drawn, from the box's left.
pub fn screen_x(&self, m: &Measure, index: usize) -> i32 {
if index > chars(&self.value) {
+33
View File
@@ -209,3 +209,36 @@ struct LineOut {
@fragment fn fs_line(in: LineOut) -> @location(0) vec4<f32> {
return apply_fog(vec4(0.0, 0.0, 0.0, 0.4), in.spherical, in.cylindrical);
}
// Gizmo lines (rendertype_lines with a per-vertex colour and LineWidth in
// pixels; no layering transform).
struct DebugLineOut {
@builtin(position) clip: vec4<f32>,
@location(0) spherical: f32,
@location(1) cylindrical: f32,
@location(2) color: vec4<f32>,
}
@vertex fn vs_debug_line(@builtin(vertex_index) vertex: u32,
@location(0) start: vec3<f32>, @location(1) end: vec3<f32>,
@location(2) argb: vec4<f32>, @location(3) width: f32) -> DebugLineOut {
let position = select(start, end, vertex >= 2u);
let view_shrink = 1.0 - 1.0 / 256.0;
let line_start = globals.view_proj * vec4(position * view_shrink, 1.0);
let line_end = globals.view_proj * vec4((position + (end - start)) * view_shrink, 1.0);
let ndc1 = line_start.xyz / line_start.w;
let ndc2 = line_end.xyz / line_end.w;
let screen = globals.outline_params.xy;
let direction = normalize((ndc2.xy - ndc1.xy) * screen);
var offset = vec2(-direction.y, direction.x) * width / screen;
if offset.x < 0.0 { offset = -offset; }
if vertex % 2u != 0u { offset = -offset; }
var out: DebugLineOut;
out.clip = vec4((ndc1 + vec3(offset, 0.0)) * line_start.w, line_start.w);
out.spherical = length(position);
out.cylindrical = max(length(position.xz), abs(position.y));
// ARGB in a little-endian u32 reads as B, G, R, A.
out.color = argb.zyxw;
return out;
}
@fragment fn fs_debug_line(in: DebugLineOut) -> @location(0) vec4<f32> {
return apply_fog(in.color, in.spherical, in.cylindrical);
}
+14
View File
@@ -541,6 +541,20 @@ impl Title {
_ => Action::None,
}
}
/// The focused text field, its id and maximum length (copy and paste).
pub fn focused_field(&mut self) -> Option<(crate::clipboard::FieldId, &mut String, usize)> {
match &mut self.mode {
Mode::Multiplayer(screen) => screen.focused_text(),
Mode::Create {
name, seed, focus, ..
} => match focus {
0 => Some((("world.name", 0), name, 32)),
1 => Some((("world.seed", 0), seed, 32)),
_ => None,
},
_ => None,
}
}
pub fn type_text(&mut self, text: &str) {
if let Mode::Multiplayer(screen) = &mut self.mode {
screen.type_text(text);
+26 -4
View File
@@ -520,6 +520,20 @@ fn byte_index(s: &str, chars: usize) -> usize {
pub fn char_len(s: &str) -> usize {
s.chars().count()
}
impl crate::clipboard::Editable for EditBox {
fn select_all(&mut self) {
self.move_cursor_to_end(false);
self.highlight = 0;
}
fn selected_text(&self) -> String {
EditBox::selected_text(self)
}
fn insert(&mut self, text: &str) -> bool {
let before = self.value.clone();
self.insert_text(text);
self.value != before
}
}
impl EditBox {
pub fn new(x: f32, y: f32, width: f32, height: f32) -> Self {
Self {
@@ -576,10 +590,7 @@ impl EditBox {
/// EditBox.insertText: replace the selection, respecting the maximum length.
pub fn insert_text(&mut self, text: &str) {
let (a, b) = self.selected();
let filtered: String = text
.chars()
.filter(|c| !c.is_control() && *c != '§')
.collect();
let filtered = crate::clipboard::filter_text(text, false);
let room = self
.max_length
.saturating_sub(char_len(&self.value) - (b - a));
@@ -702,6 +713,17 @@ impl EditBox {
}
true
}
/// Ctrl+A/C/V/X (`EditBox.keyPressed`). True when the value changed.
pub fn shortcut(
&mut self,
shortcut: crate::clipboard::EditShortcut,
clipboard: &mut dyn crate::clipboard::Clipboard,
) -> bool {
let before = self.value.clone();
crate::clipboard::apply(self, shortcut, clipboard);
self.reset_blink();
self.value != before
}
/// The first shown character after scrolling to the cursor, and the
/// milliseconds since the field was focused (the cursor's blink).
pub fn view_state(&mut self, atlas: &HudAtlas) -> (usize, u64) {
+1 -1
View File
@@ -62,7 +62,7 @@ impl VanillaTerrain {
if !dir.join("blocks/block-properties.nbt").exists() {
eprintln!(
"Horizon: the worldgen bundle lacks the block behavior exports (worldgen/blocks/*.nbt); \
run python3 tools/prepare_native_client.py to add them"
prepare again (the launcher, or horizon-prepare --prepare) to add them"
);
}
}
+77 -1
View File
@@ -1,6 +1,7 @@
//! Window sizing and frame pacing of 26.3: `Window.calculateScale` and
//! `setGuiScale`, `MouseHandler`'s scaled positions, `FramerateLimitTracker`,
//! `FramerateLimiter` and the vsync present-mode choice.
//! `FramerateLimiter`, the vsync present-mode choice and the fullscreen
//! request/state pair.
/// `Window.calculateScale`: the largest scale that leaves at least 320x240
/// GUI pixels, capped by `max_scale` (0 = automatic); an odd result is bumped
@@ -263,10 +264,85 @@ impl FramerateLimiter {
}
}
/// blaze3d `Window`'s `fullscreenRequested` / `fullscreen` pair. The window
/// system has the last word: a change it makes on its own (a compositor
/// shortcut, a window rule) is adopted by the Fullscreen option
/// (`Window.updateFullscreenState` -> `Minecraft.fullscreenStateChanged`), and
/// the window is only asked to change when the option itself changes
/// (`Window.updateFullscreenIfChanged`), never re-forced to the option.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct FullscreenState {
/// The state the window system last reported (`Window.fullscreen`).
actual: bool,
/// The state last asked of the window system, or adopted from it.
requested: bool,
}
impl FullscreenState {
/// A window created windowed or, when `requested`, asked to be fullscreen.
pub fn new(requested: bool) -> Self {
Self {
actual: false,
requested,
}
}
/// `Window.updateFullscreenIfChanged`: the state to ask of the window
/// when the option `wanted` differs from what was last asked or adopted.
pub fn request(&mut self, wanted: bool) -> Option<bool> {
(wanted != self.requested).then(|| {
self.requested = wanted;
wanted
})
}
/// `Window.updateFullscreenState`: the window now reports `now`; returns
/// it when it changed, for the option to adopt.
pub fn observe(&mut self, now: bool) -> Option<bool> {
(now != self.actual).then(|| {
self.actual = now;
self.requested = now;
now
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn fullscreen_follows_the_option_only_when_it_changes() {
let mut f = FullscreenState::new(false);
// Settings applied again with nothing changed: the window is left alone.
assert_eq!(f.request(false), None);
// The compositor makes the window fullscreen on its own: the option adopts it,
// and applying the settings afterwards does not undo it.
assert_eq!(f.observe(true), Some(true));
assert_eq!(f.request(true), None);
assert_eq!(f.observe(true), None);
// F11: one request, not repeated while the compositor catches up.
assert_eq!(f.request(false), Some(false));
assert_eq!(f.request(false), None);
assert_eq!(f.observe(false), Some(false));
assert_eq!(f.request(false), None);
}
#[test]
fn fullscreen_requests_changed_before_the_compositor_answers() {
// Created fullscreen from options.txt.
let mut f = FullscreenState::new(true);
assert_eq!(f.request(true), None);
assert_eq!(f.observe(true), Some(true));
// Toggled twice before any configure: the second request cancels the first.
assert_eq!(f.request(false), Some(false));
assert_eq!(f.request(true), Some(true));
assert_eq!(f.observe(true), None);
// A compositor that refuses leaves the option where the player put it.
assert_eq!(f.request(false), Some(false));
assert_eq!(f.request(false), None);
}
struct Virtual {
now: i64,
oversleep: i64,
+19
View File
@@ -0,0 +1,19 @@
[package]
name = "horizon-prepare"
version = "0.1.0"
edition = "2021"
license = "MIT"
description = "Prepares Horizon's resources from the player's own Minecraft: imports and checks the pinned jars, runs the vanilla exporters, writes the resource folder"
[dependencies]
regex = { version = "1", default-features = false, features = ["std", "unicode-perl"] }
sha1 = "0.10"
sha2 = "0.10"
zip = { version = "2", default-features = false, features = ["deflate"] }
[build-dependencies]
sha2 = "0.10"
[[bin]]
name = "horizon-prepare"
path = "src/main.rs"
+38
View File
@@ -0,0 +1,38 @@
//! HORIZON_PREPARE_SOURCES_SHA256: a digest of this crate's sources, which the launcher compares
//! with a version folder's copy to know whether it may prepare that version in-process. Keep the
//! algorithm the same as `horizon_prepare::sources_sha256`.
use sha2::Digest;
use std::fs;
use std::path::Path;
fn main() {
let dir = Path::new(env!("CARGO_MANIFEST_DIR"));
let mut files = Vec::new();
for name in ["Cargo.toml", "build.rs"] {
println!("cargo:rerun-if-changed={name}");
files.push((name.to_string(), fs::read(dir.join(name)).unwrap()));
}
println!("cargo:rerun-if-changed=src");
let mut sources: Vec<String> = fs::read_dir(dir.join("src"))
.unwrap()
.map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
.filter(|n| n.ends_with(".rs"))
.collect();
sources.sort();
for name in sources {
println!("cargo:rerun-if-changed=src/{name}");
files.push((
format!("src/{name}"),
fs::read(dir.join("src").join(&name)).unwrap(),
));
}
let mut hash = sha2::Sha256::new();
for (name, data) in files {
let data: Vec<u8> = data.into_iter().filter(|b| *b != b'\r').collect();
hash.update(format!("{name}\0{}\0", data.len()));
hash.update(&data);
}
let hex: String = hash.finalize().iter().map(|b| format!("{b:02x}")).collect();
println!("cargo:rustc-env=HORIZON_PREPARE_SOURCES_SHA256={hex}");
}
+681
View File
@@ -0,0 +1,681 @@
//! The player's own game files: the pinned version JSON, client jar and libraries from their
//! official launcher install, and the server jar they downloaded, each checked against
//! research-lock.json before it is copied to `.local/minecraft/<version>` (tools/lab.py's
//! `prepare`, which the Python preparer ran first), then checked again on every run
//! (tools/test_rust_parity.py's `verify_artifacts`).
use crate::pyjson::{self, Value};
use crate::{digest, read_json, relative_display, write_json, Log};
use std::collections::HashMap;
use std::fs;
use std::path::{Component, Path, PathBuf};
const LAUNCHER_HINT: &str =
"Horizon does not download the game: install Minecraft Java Edition with the official \
launcher, play {version} once, then rerun. If the launcher uses another game directory, \
pass --minecraft-dir or set HORIZON_MINECRAFT_DIR.";
const SERVER_HINT: &str = "Horizon does not download the game: download the {version} server jar yourself (minecraft.net/download/server \
while {version} is the current release, otherwise the downloads.server.url in your launcher's \
versions/{version}/{version}.json), then pass --server-jar PATH or set HORIZON_SERVER_JAR.";
fn hint(text: &str, version: &str) -> String {
text.replace("{version}", version)
}
/// research-lock.json and the folder the pinned version's files go to.
pub struct Lock {
pub json: Value,
pub version: String,
pub java_major: i64,
pub directory: PathBuf,
}
impl Lock {
pub fn read(root: &Path) -> Result<Lock, String> {
let json = read_json(&root.join("research-lock.json"))?;
let game = json
.get("minecraft")
.ok_or("research-lock.json has no minecraft")?;
let version = game
.get("version")
.and_then(Value::as_str)
.ok_or("research-lock.json has no minecraft version")?
.to_string();
if version.is_empty()
|| !version
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"_.-".contains(&b))
|| version == "."
|| version == ".."
{
return Err("Unsafe version identifier in lock file".into());
}
let java_major = game
.get("java_major")
.and_then(Value::as_i64)
.ok_or("research-lock.json has no java_major")?;
let directory = root.join(".local/minecraft").join(&version);
Ok(Lock {
json,
version,
java_major,
directory,
})
}
fn pin(&self, key: &str) -> Result<&str, String> {
self.json
.get("minecraft")
.and_then(|m| m.get(key))
.and_then(Value::as_str)
.ok_or_else(|| format!("research-lock.json has no minecraft {key}"))
}
/// Mojang republishes a version JSON for asset-index changes; every known one is accepted.
fn manifest_accepted(&self, checksum: &str) -> bool {
let game = self.json.get("minecraft");
self.pin("manifest_sha1").is_ok_and(|pin| pin == checksum)
|| game
.and_then(|g| g.get("accepted_manifest_sha1"))
.and_then(Value::as_array)
.is_some_and(|list| list.iter().any(|v| v.as_str() == Some(checksum)))
}
}
fn home() -> PathBuf {
let var = if cfg!(windows) { "USERPROFILE" } else { "HOME" };
std::env::var_os(var)
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("."))
}
/// Python's `Path.expanduser` for the forms players type: `~` and `~/...`.
fn expand_user(path: &Path) -> PathBuf {
let mut components = path.components();
match components.next() {
Some(Component::Normal(first)) if first == "~" => home().join(components.as_path()),
_ => path.to_path_buf(),
}
}
/// The official launcher's game directory, which holds the player's own copy of the game.
pub fn minecraft_dir(chosen: Option<&Path>) -> PathBuf {
if let Some(dir) = chosen.filter(|d| !d.as_os_str().is_empty()) {
return expand_user(dir);
}
if let Some(dir) = std::env::var_os("HORIZON_MINECRAFT_DIR").filter(|d| !d.is_empty()) {
return expand_user(Path::new(&dir));
}
if cfg!(target_os = "macos") {
home().join("Library/Application Support/minecraft")
} else if cfg!(windows) {
std::env::var_os("APPDATA")
.map(PathBuf::from)
.unwrap_or_else(home)
.join(".minecraft")
} else {
home().join(".minecraft")
}
}
/// Copy one file from the player's install, checked like a download; an existing verified
/// copy is kept.
fn import_copy(
source: &Path,
destination: &Path,
checksum: &str,
algorithm: &str,
hint: &str,
) -> Result<PathBuf, String> {
fs::create_dir_all(destination.parent().unwrap()).map_err(|e| e.to_string())?;
if destination.exists() && digest(destination, algorithm)? == checksum {
return Ok(destination.to_path_buf());
}
if !source.is_file() {
return Err(format!("Missing {}. {hint}", source.display())
.trim()
.to_string());
}
let actual = digest(source, algorithm)?;
if actual != checksum {
return Err(format!(
"{} is not the pinned file: expected {algorithm} {checksum}, got {actual}",
source.display()
));
}
let temporary = destination.with_file_name(format!(
".{}.partial-{}",
destination.file_name().unwrap().to_string_lossy(),
std::process::id()
));
let copied = fs::copy(source, &temporary).and_then(|_| fs::rename(&temporary, destination));
let _ = fs::remove_file(&temporary);
copied.map_err(|e| format!("{}: {e}", destination.display()))?;
Ok(destination.to_path_buf())
}
/// The pinned version JSON from the launcher's versions/ directory. The launcher's copy wins
/// over the cached one so the manifest matches the asset index installed alongside it.
fn import_manifest(lock: &Lock, minecraft: &Path) -> Result<Value, String> {
let version = &lock.version;
let destination = lock.directory.join("manifest.json");
let source = minecraft
.join("versions")
.join(version)
.join(format!("{version}.json"));
if source.is_file() {
let manifest = read_json(&source)?;
let downloads = manifest.get("downloads");
let sha1 = |side: &str| {
downloads
.and_then(|d| d.get(side))
.and_then(|d| d.get("sha1"))
.and_then(Value::as_str)
};
if manifest.get("id").and_then(Value::as_str) != Some(version)
|| sha1("client") != Some(lock.pin("client_sha1")?)
|| sha1("server") != Some(lock.pin("server_sha1")?)
{
return Err(format!(
"{} does not describe the pinned {version} release",
source.display()
));
}
let checksum = digest(&source, "sha1")?;
if !lock.manifest_accepted(&checksum) {
return Err(format!(
"{} is a {version} version file Horizon does not know yet (sha1 {checksum}); \
Mojang may have republished it. Update Horizon, or report it if this is the latest release.",
source.display()
));
}
if !(destination.exists() && digest(&destination, "sha1")? == checksum) {
fs::create_dir_all(&lock.directory).map_err(|e| e.to_string())?;
fs::copy(&source, &destination).map_err(|e| e.to_string())?;
}
} else if !(destination.exists() && lock.manifest_accepted(&digest(&destination, "sha1")?)) {
return Err(format!(
"Missing {}. {}",
source.display(),
hint(LAUNCHER_HINT, version)
));
}
let manifest = read_json(&destination)?;
let java = manifest
.get("javaVersion")
.and_then(|j| j.get("majorVersion"))
.and_then(Value::as_i64);
if java != Some(lock.java_major) {
return Err("Manifest Java version does not match lock file".into());
}
Ok(manifest)
}
fn import_server(lock: &Lock, server_jar: Option<&Path>) -> Result<PathBuf, String> {
let version = &lock.version;
let destination = lock.directory.join("jars/server.jar");
let checksum = lock.pin("server_sha1")?;
let hint = hint(SERVER_HINT, version);
let source = server_jar
.map(Path::to_path_buf)
.or_else(|| std::env::var_os("HORIZON_SERVER_JAR").map(PathBuf::from));
let Some(source) = source else {
if destination.exists() && digest(&destination, "sha1")? == checksum {
return Ok(destination);
}
return Err(format!("No {version} server jar. {hint}"));
};
import_copy(&expand_user(&source), &destination, checksum, "sha1", &hint)
}
/// The launcher's `os.name` for this machine.
fn rule_system() -> &'static str {
if cfg!(target_os = "macos") {
"osx"
} else if cfg!(windows) {
"windows"
} else {
"linux"
}
}
/// This machine's architecture and its aliases, as Python's `platform.machine()` names them.
fn rule_architectures() -> Vec<&'static str> {
match std::env::consts::ARCH {
"x86_64" => vec!["x86_64", "amd64", "x64"],
"aarch64" => vec!["arm64", "aarch64"],
"x86" => vec!["i686"],
other => vec![other],
}
}
/// The kernel release Python's `platform.release()` reports (only old version JSONs ask).
fn os_release() -> String {
#[cfg(unix)]
{
if let Ok(out) = std::process::Command::new("uname").arg("-r").output() {
return String::from_utf8_lossy(&out.stdout).trim().to_string();
}
}
String::new()
}
/// The official launcher's rules: the last matching rule decides, no rules means allowed.
fn library_allowed(library: &Value) -> Result<bool, String> {
let system = rule_system();
let architectures = rule_architectures();
let rules = library
.get("rules")
.and_then(Value::as_array)
.unwrap_or(&[]);
let mut allowed = rules.is_empty();
for rule in rules {
let empty = Value::Object(Vec::new());
let os = rule.get("os").unwrap_or(&empty);
if os.get("name").and_then(Value::as_str).unwrap_or(system) != system {
continue;
}
if let Some(arch) = os.get("arch") {
let pattern = regex::Regex::new(&format!("^(?:{})$", arch.as_str().unwrap_or("")))
.map_err(|e| e.to_string())?;
if !architectures.iter().any(|name| pattern.is_match(name)) {
continue;
}
}
if let Some(version) = os.get("version") {
let pattern =
regex::Regex::new(version.as_str().unwrap_or("")).map_err(|e| e.to_string())?;
if !pattern.is_match(&os_release()) {
continue;
}
}
if rule.get("features").is_some_and(|f| match f {
Value::Object(o) => !o.is_empty(),
Value::Array(a) => !a.is_empty(),
Value::Null | Value::Bool(false) => false,
Value::Str(s) => !s.is_empty(),
_ => true,
}) {
continue;
}
allowed = rule.get("action").and_then(Value::as_str) == Some("allow");
}
Ok(allowed)
}
fn classifier_ends_with(classifier: &str, names: &[&str]) -> bool {
names.iter().any(|name| {
classifier == *name
|| classifier
.strip_suffix(name)
.is_some_and(|rest| rest.ends_with('-'))
})
}
/// Modern manifests list x64 and ARM natives with OS-only rules; keep this machine's. A plain
/// natives-<os> jar is the x64 build when the manifest also lists an ARM variant of it.
fn native_library_matches(library: &Value, names: &[&str]) -> bool {
let arm = rule_architectures().contains(&"arm64");
let name = library.get("name").and_then(Value::as_str).unwrap_or("");
let classifier = name.split(':').nth(3).unwrap_or("");
if classifier_ends_with(classifier, &["arm64", "aarch64", "aarch_64"]) {
return arm;
}
if classifier_ends_with(classifier, &["x86_64", "x64"]) {
return !arm;
}
if arm && classifier.starts_with("natives-") {
return !["arm64", "aarch64"]
.iter()
.any(|suffix| names.contains(&format!("{name}-{suffix}").as_str()));
}
true
}
/// The client libraries the official launcher installs on this OS and architecture.
fn client_library_artifacts(manifest: &Value) -> Result<Vec<&Value>, String> {
let libraries = manifest
.get("libraries")
.and_then(Value::as_array)
.ok_or("The version JSON has no libraries")?;
let names: Vec<&str> = libraries
.iter()
.filter_map(|l| l.get("name").and_then(Value::as_str))
.collect();
let mut artifacts = Vec::new();
for library in libraries {
let Some(artifact) = library.get("downloads").and_then(|d| d.get("artifact")) else {
continue;
};
if library_allowed(library)? && native_library_matches(library, &names) {
artifacts.push(artifact);
}
}
Ok(artifacts)
}
/// A relative path with only normal components and forward slashes, from a manifest or bundle.
fn safe_relative(path: &str) -> Option<PathBuf> {
if path.contains('\\') || path.starts_with('/') {
return None;
}
let parts: Vec<&str> = path
.split('/')
.filter(|p| !p.is_empty() && *p != ".")
.collect();
if parts.contains(&"..") || (cfg!(windows) && parts.first().is_some_and(|p| p.contains(':'))) {
return None;
}
Some(parts.iter().collect())
}
fn artifact_fields(artifact: &Value) -> Result<(&str, &str), String> {
let path = artifact.get("path").and_then(Value::as_str);
let sha1 = artifact.get("sha1").and_then(Value::as_str);
path.zip(sha1)
.ok_or_else(|| "A library in the version JSON has no path or sha1".to_string())
}
/// `(sha256, identifier, path)` lines of a server bundle's versions.list or libraries.list.
fn bundle_entries(
archive: &mut zip::ZipArchive<fs::File>,
name: &str,
) -> Result<Vec<(String, String, PathBuf, String)>, String> {
let text = crate::zip_text(archive, name)?;
let mut entries = Vec::new();
for line in crate::split_lines(&text) {
if line.trim().is_empty() {
continue;
}
let fields: Vec<&str> = line.split('\t').collect();
let [checksum, identifier, relative] = fields[..] else {
return Err(format!("Malformed line in {name}"));
};
let path =
safe_relative(relative).ok_or_else(|| format!("Unsafe bundled path: {relative}"))?;
// PurePosixPath's text: empty and `.` parts dropped.
let posix = relative
.split('/')
.filter(|p| !p.is_empty() && *p != ".")
.collect::<Vec<_>>()
.join("/");
entries.push((checksum.to_string(), identifier.to_string(), path, posix));
}
Ok(entries)
}
fn extract_verified(
archive: &mut zip::ZipArchive<fs::File>,
member: &str,
destination: &Path,
checksum: &str,
) -> Result<(), String> {
let data = crate::zip_bytes(archive, member)?;
if crate::sha256_hex(&data) != checksum {
return Err(format!("Bundled artifact checksum mismatch: {member}"));
}
fs::create_dir_all(destination.parent().unwrap()).map_err(|e| e.to_string())?;
fs::write(destination, data).map_err(|e| format!("{}: {e}", destination.display()))
}
/// Modern server downloads are launchers: the game jar and its libraries are inside.
fn unpack_server(
server: PathBuf,
directory: &Path,
version: &str,
) -> Result<(PathBuf, Vec<PathBuf>), String> {
let mut archive = crate::open_zip(&server)?;
if archive.index_for_name("META-INF/versions.list").is_none() {
return Ok((server, Vec::new()));
}
let versions = bundle_entries(&mut archive, "META-INF/versions.list")?;
if versions.len() != 1 || versions[0].1 != version {
return Err("Expected one bundled server matching the pinned version".into());
}
let (checksum, _, _, relative) = &versions[0];
let game = directory.join("jars/server-game.jar");
extract_verified(
&mut archive,
&format!("META-INF/versions/{relative}"),
&game,
checksum,
)?;
let mut libraries = Vec::new();
for (checksum, _, path, relative) in bundle_entries(&mut archive, "META-INF/libraries.list")? {
let destination = directory.join("libraries/server").join(path);
extract_verified(
&mut archive,
&format!("META-INF/libraries/{relative}"),
&destination,
checksum.as_str(),
)?;
libraries.push(destination);
}
Ok((game, libraries))
}
/// Imports the player's own pinned game files into `.local/minecraft/<version>` and writes the
/// class inventories and prepared.json (tools/lab.py `prepare`). The decompiler lab.py also
/// fetches is a development tool, not something preparing needs; `tools/lab.py prepare` gets it.
pub fn import(
root: &Path,
lock: &Lock,
minecraft: Option<&Path>,
server_jar: Option<&Path>,
log: Log,
) -> Result<(), String> {
let minecraft = minecraft_dir(minecraft);
let version = &lock.version;
let manifest = import_manifest(lock, &minecraft)?;
let client = import_copy(
&minecraft
.join("versions")
.join(version)
.join(format!("{version}.jar")),
&lock.directory.join("jars/client.jar"),
lock.pin("client_sha1")?,
"sha1",
&hint(LAUNCHER_HINT, version),
)?;
let downloads = manifest.get("downloads");
if downloads.and_then(|d| d.get("client_mappings")).is_some()
|| downloads.and_then(|d| d.get("server_mappings")).is_some()
{
return Err(
"This workflow targets unobfuscated releases. Older releases need a remapping stage."
.into(),
);
}
let id = manifest
.get("id")
.and_then(Value::as_str)
.ok_or("The version JSON has no id")?;
log(&format!(
"Imported client {id} from {}",
minecraft.display()
));
let server = import_server(lock, server_jar)?;
let (server, server_libraries) = unpack_server(server, &lock.directory, id)?;
let mut client_libraries = Vec::new();
for artifact in client_library_artifacts(&manifest)? {
let (path, sha1) = artifact_fields(artifact)?;
let relative = safe_relative(path).ok_or("Unsafe library path")?;
client_libraries.push(import_copy(
&minecraft.join("libraries").join(&relative),
&lock.directory.join("libraries/client").join(&relative),
sha1,
"sha1",
&hint(LAUNCHER_HINT, version),
)?);
}
for (side, jar) in [("client", &client), ("server", &server)] {
let data = crate::inventory::inventory(jar)?;
let count = |key| data.get(key).cloned().unwrap_or(Value::Null);
write_json(
&lock
.directory
.join(format!("reports/{side}-inventory.json")),
&data,
)?;
log(&format!(
"{side}: {} classes, {} methods",
pyjson::dumps(&count("class_count"), &pyjson::DEFAULT),
pyjson::dumps(&count("method_count"), &pyjson::DEFAULT)
));
}
let paths = |list: &[PathBuf]| -> Result<Value, String> {
Ok(Value::Array(
list.iter()
.map(|p| relative_display(p, root).map(Value::Str))
.collect::<Result<_, _>>()?,
))
};
write_json(
&lock.directory.join("prepared.json"),
&Value::Object(vec![
("version".into(), Value::str(id)),
(
"jars".into(),
Value::Object(vec![
(
"client".into(),
Value::Str(relative_display(&client, root)?),
),
(
"server".into(),
Value::Str(relative_display(&server, root)?),
),
]),
),
(
"libraries".into(),
Value::Object(vec![
("client".into(), paths(&client_libraries)?),
("server".into(), paths(&server_libraries)?),
]),
),
]),
)?;
log(&format!("Artifacts: {}", lock.directory.display()));
Ok(())
}
/// The checked jars (`client`, `server` = the bundle's inner game jar) and the server
/// libraries, authenticated against the lock and the bundle's own checksums on every run.
pub struct Artifacts {
pub manifest: Value,
pub jars: HashMap<&'static str, PathBuf>,
pub libraries: Vec<PathBuf>,
}
pub fn verify(lock: &Lock) -> Result<Artifacts, String> {
let manifest_path = lock.directory.join("manifest.json");
if !manifest_path.exists() {
return Err(format!(
"{} is missing: prepare with --prepare first",
manifest_path.display()
));
}
if !lock.manifest_accepted(&digest(&manifest_path, "sha1")?) {
return Err("Manifest checksum changed; prepare again with --prepare".into());
}
let manifest = read_json(&manifest_path)?;
let id = manifest.get("id").and_then(Value::as_str).unwrap_or("");
if id != lock.version {
return Err("Manifest version differs from the lock".into());
}
let mut jars = HashMap::new();
for side in ["client", "server"] {
let jar = lock.directory.join(format!("jars/{side}.jar"));
let pinned = manifest
.get("downloads")
.and_then(|d| d.get(side))
.and_then(|d| d.get("sha1"))
.and_then(Value::as_str);
if !jar.exists() || Some(digest(&jar, "sha1")?.as_str()) != pinned {
return Err(format!(
"{side} artifact checksum changed; prepare again with --prepare"
));
}
jars.insert(side, jar);
}
let mut archive = crate::open_zip(&jars["server"])?;
let versions = bundle_entries(&mut archive, "META-INF/versions.list")?;
if versions.len() != 1 || versions[0].1 != id {
return Err("Unexpected server bundle".into());
}
let game = lock.directory.join("jars/server-game.jar");
if !game.exists() || digest(&game, "sha256")? != versions[0].0 {
return Err("Inner server artifact checksum changed".into());
}
jars.insert("server", game);
let mut libraries = Vec::new();
for (checksum, _, path, relative) in bundle_entries(&mut archive, "META-INF/libraries.list")? {
let library = lock.directory.join("libraries/server").join(path);
if !library.exists() || digest(&library, "sha256")? != checksum {
return Err(format!("Dependency checksum changed: {relative}"));
}
libraries.push(library);
}
Ok(Artifacts {
manifest,
jars,
libraries,
})
}
/// The client libraries, checked against the version JSON (tools/test_model_baking_parity.py's
/// `client_libraries`); the client-side exporters compile against them.
pub fn client_libraries(lock: &Lock, manifest: &Value) -> Result<Vec<PathBuf>, String> {
let mut libraries = Vec::new();
for artifact in client_library_artifacts(manifest)? {
let (path, sha1) = artifact_fields(artifact)?;
let relative = safe_relative(path).ok_or("Unsafe client library path")?;
let library = lock.directory.join("libraries/client").join(&relative);
if !library.exists() || digest(&library, "sha1")? != sha1 {
return Err(format!("Client dependency checksum changed: {path}"));
}
libraries.push(library);
}
Ok(libraries)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn natives_follow_the_architecture() {
let names = ["a:b:1:natives-macos", "a:b:1:natives-macos-arm64"];
let lib = |name: &str| pyjson::loads(&format!("{{\"name\":\"{name}\"}}")).unwrap();
let arm = rule_architectures().contains(&"arm64");
assert_eq!(
native_library_matches(&lib("a:b:1:natives-macos-arm64"), &names),
arm
);
assert_eq!(
native_library_matches(&lib("x:y:1:linux-x86_64"), &names),
!arm
);
assert_eq!(
native_library_matches(&lib("x:y:1:linux-aarch_64"), &names),
arm
);
assert_eq!(
native_library_matches(&lib("a:b:1:natives-macos"), &names),
!arm
);
assert!(native_library_matches(&lib("a:b:1"), &names));
}
#[test]
fn unsafe_paths_are_refused() {
assert!(safe_relative("a/../b").is_none());
assert!(safe_relative("/a").is_none());
assert!(safe_relative("a\\b").is_none());
assert_eq!(
safe_relative("a/b.jar").unwrap(),
Path::new("a").join("b.jar")
);
}
}
+177
View File
@@ -0,0 +1,177 @@
//! Class inventories of the imported jars (tools/lab.py's `inventory` and `ClassReader`): each
//! class's SourceFile and method count, read from the bytecode; no Java text is published.
use crate::pyjson::Value;
use std::path::Path;
struct ClassReader<'a> {
data: &'a [u8],
offset: usize,
}
impl ClassReader<'_> {
fn take(&mut self, count: usize) -> Result<&[u8], String> {
let value = self
.data
.get(self.offset..self.offset + count)
.ok_or("Truncated class file")?;
self.offset += count;
Ok(value)
}
fn number(&mut self, count: usize) -> Result<usize, String> {
Ok(self
.take(count)?
.iter()
.fold(0usize, |n, b| (n << 8) | *b as usize))
}
fn attributes(&mut self) -> Result<Vec<(usize, Vec<u8>)>, String> {
let count = self.number(2)?;
let mut attributes = Vec::with_capacity(count);
for _ in 0..count {
let name = self.number(2)?;
let length = self.number(4)?;
attributes.push((name, self.take(length)?.to_vec()));
}
Ok(attributes)
}
/// `(SourceFile, method count)`.
fn metadata(&mut self) -> Result<(Option<String>, usize), String> {
if self.take(4)? != b"\xca\xfe\xba\xbe" {
return Err("Invalid class file magic".into());
}
self.take(4)?; // Minor and major version.
let mut pool: Vec<Option<String>> = vec![None; self.number(2)?];
let mut i = 1;
while i < pool.len() {
let tag = self.number(1)?;
if tag == 1 {
let length = self.number(2)?;
pool[i] = Some(String::from_utf8_lossy(self.take(length)?).into_owned());
} else {
let size = match tag {
3 | 4 | 9 | 10 | 11 | 12 | 17 | 18 => 4,
5 | 6 => 8,
7 | 8 | 16 | 19 | 20 => 2,
15 => 3,
_ => return Err(format!("Unknown constant pool tag: {tag}")),
};
self.take(size)?;
}
i += if tag == 5 || tag == 6 { 2 } else { 1 };
}
self.take(6)?; // Access, this class, super class.
let interfaces = self.number(2)?;
self.take(interfaces * 2)?;
for _ in 0..self.number(2)? {
self.take(6)?; // Fields.
self.attributes()?;
}
let methods = self.number(2)?;
for _ in 0..methods {
self.take(6)?;
self.attributes()?;
}
let mut source = None;
for (name, data) in self.attributes()? {
if pool.get(name).and_then(Option::as_deref) == Some("SourceFile") {
let [high, low] = data[..] else {
return Err("Malformed SourceFile attribute".into());
};
let index = ((high as usize) << 8) | low as usize;
source = Some(
pool.get(index)
.cloned()
.flatten()
.ok_or("SourceFile points outside the constant pool")?,
);
}
}
Ok((source, methods))
}
}
/// PurePosixPath(name).parent as text.
fn parent(name: &str) -> &str {
match name.trim_end_matches('/').rsplit_once('/') {
Some((parent, _)) if !parent.is_empty() => parent,
Some(_) => "/",
None => ".",
}
}
pub fn inventory(jar: &Path) -> Result<Value, String> {
let mut archive = crate::open_zip(jar)?;
let mut classes = Vec::new();
let mut packages: Vec<(String, usize)> = Vec::new();
let mut sources = std::collections::BTreeSet::new();
let mut method_count = 0;
for index in 0..archive.len() {
let mut item = archive.by_index(index).map_err(|e| e.to_string())?;
let name = item.name().to_string();
if !name.ends_with(".class") {
continue;
}
let size = item.size();
let mut data = Vec::with_capacity(size as usize);
std::io::Read::read_to_end(&mut item, &mut data).map_err(|e| e.to_string())?;
let (source, methods) = ClassReader {
data: &data,
offset: 0,
}
.metadata()
.map_err(|e| format!("{name}: {e}"))?;
let file = name.rsplit('/').next().unwrap();
let source = source.filter(|s| !s.is_empty()).unwrap_or_else(|| {
let stem = file.split('$').next().unwrap();
format!("{}.java", stem.strip_suffix(".class").unwrap_or(stem))
});
if source.contains('/') || source.contains('\\') || source == "." {
return Err(format!("Unsafe SourceFile attribute in {name}"));
}
let directory = parent(&name);
let source_path = if directory == "." {
source
} else {
format!("{directory}/{source}")
};
match packages.iter_mut().find(|(p, _)| p == directory) {
Some(entry) => entry.1 += 1,
None => packages.push((directory.to_string(), 1)),
}
sources.insert(source_path.clone());
method_count += methods;
classes.push(Value::Object(vec![
("class".into(), Value::Str(name)),
("source".into(), Value::Str(source_path)),
("bytecode_bytes".into(), Value::Int(size.to_string())),
("methods".into(), Value::Int(methods.to_string())),
]));
}
// Counter.most_common: by count, ties in first-seen order.
packages.sort_by_key(|(_, count)| std::cmp::Reverse(*count));
Ok(Value::Object(vec![
(
"jar_sha256".into(),
Value::Str(crate::digest(jar, "sha256")?),
),
("class_count".into(), Value::Int(classes.len().to_string())),
(
"expected_source_files".into(),
Value::Array(sources.into_iter().map(Value::Str).collect()),
),
("method_count".into(), Value::Int(method_count.to_string())),
(
"packages".into(),
Value::Object(
packages
.into_iter()
.map(|(p, n)| (p, Value::Int(n.to_string())))
.collect(),
),
),
("classes".into(), Value::Array(classes)),
]))
}
+179
View File
@@ -0,0 +1,179 @@
//! The JDK that compiles and runs the vanilla exporters. They call Mojang's own code, so they
//! stay Java; everything around them is here.
use std::fs;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
pub struct Jdk {
pub javac: PathBuf,
pub java: PathBuf,
}
const TIMEOUT: Duration = Duration::from_secs(3600);
fn executable(dir: &Path, name: &str) -> PathBuf {
dir.join(if cfg!(windows) {
format!("{name}.exe")
} else {
name.to_string()
})
}
fn on_path(name: &str) -> Option<PathBuf> {
std::env::split_paths(&std::env::var_os("PATH")?)
.map(|dir| executable(&dir, name))
.find(|p| p.is_file())
}
/// The major version `javac -version` reports ("javac 25.0.1" → 25; "javac 1.8.0" → 8).
fn javac_major(javac: &Path) -> Result<u32, String> {
let output = Command::new(javac)
.arg("-version")
.stdin(Stdio::null())
.output()
.map_err(|e| format!("{}: {e}", javac.display()))?;
let text = String::from_utf8_lossy(&output.stdout).into_owned()
+ &String::from_utf8_lossy(&output.stderr);
let version = text
.split_whitespace()
.skip_while(|w| *w != "javac")
.nth(1)
.ok_or_else(|| {
format!(
"{} -version printed no version: {}",
javac.display(),
text.trim()
)
})?;
let mut parts = version.split(['.', '-', '+', '_']);
let first: u32 = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0);
Ok(if first == 1 {
parts.next().and_then(|p| p.parse().ok()).unwrap_or(0)
} else {
first
})
}
/// Finds a JDK with `javac` of at least `major`, the version research-lock.json pins:
/// `JAVA_HOME` when it holds one, else `javac` and `java` on the PATH (as the Python preparer
/// ran them), else, on macOS, the JDK `/usr/libexec/java_home -v <major>` reports.
pub fn find(major: i64) -> Result<Jdk, String> {
let need = format!(
"Java {major} is needed (a JDK with javac, e.g. Eclipse Temurin {major}). \
Install it, or set JAVA_HOME to it, and try again."
);
let mut candidates = Vec::new();
if let Some(home) = std::env::var_os("JAVA_HOME").filter(|h| !h.is_empty()) {
let bin = Path::new(&home).join("bin");
candidates.push((
executable(&bin, "javac"),
executable(&bin, "java"),
"JAVA_HOME",
));
}
if let (Some(javac), Some(java)) = (on_path("javac"), on_path("java")) {
candidates.push((javac, java, "PATH"));
}
if cfg!(target_os = "macos") {
if let Ok(out) = Command::new("/usr/libexec/java_home")
.args(["-v", &major.to_string()])
.stderr(Stdio::null())
.output()
{
let home = String::from_utf8_lossy(&out.stdout).trim().to_string();
if out.status.success() && !home.is_empty() {
let bin = Path::new(&home).join("bin");
candidates.push((
executable(&bin, "javac"),
executable(&bin, "java"),
"/usr/libexec/java_home",
));
}
}
}
let mut problems = Vec::new();
for (javac, java, from) in candidates {
if !javac.is_file() || !java.is_file() {
problems.push(format!(
"{from} ({}) has no javac and java",
javac.parent().unwrap().display()
));
continue;
}
match javac_major(&javac) {
Ok(found) if i64::from(found) >= major => return Ok(Jdk { javac, java }),
Ok(found) => problems.push(format!("{from} has Java {found} ({})", javac.display())),
Err(e) => problems.push(e),
}
}
if problems.is_empty() {
Err(format!("{need} No javac was found."))
} else {
Err(format!("{need} Found: {}.", problems.join("; ")))
}
}
/// A classpath with the platform's separator.
pub fn classpath<'a>(paths: impl IntoIterator<Item = &'a Path>) -> String {
let separator = if cfg!(windows) { ";" } else { ":" };
paths
.into_iter()
.map(|p| p.to_string_lossy().into_owned())
.collect::<Vec<_>>()
.join(separator)
}
impl Jdk {
/// `javac --release <major> -proc:none` with Python's `subprocess.run(..., check=True,
/// stdout=log, stderr=STDOUT, timeout=3600)`.
pub fn javac(&self, major: i64, args: &[String], log: &fs::File) -> Result<(), String> {
let mut command = Command::new(&self.javac);
command
.args(["--release", &major.to_string(), "-proc:none"])
.args(args);
run(command, log)
}
pub fn java(&self, args: &[String], cwd: Option<&Path>, log: &fs::File) -> Result<(), String> {
let mut command = Command::new(&self.java);
command.args(args);
if let Some(dir) = cwd {
command.current_dir(dir);
}
run(command, log)
}
}
fn run(mut command: Command, log: &fs::File) -> Result<(), String> {
let out = log.try_clone().map_err(|e| e.to_string())?;
let err = log.try_clone().map_err(|e| e.to_string())?;
let program = Path::new(command.get_program())
.file_name()
.unwrap_or_default()
.to_string_lossy()
.into_owned();
let mut child = command
.stdin(Stdio::null())
.stdout(out)
.stderr(err)
.spawn()
.map_err(|e| format!("Cannot start {program}: {e}"))?;
let start = Instant::now();
loop {
if let Some(status) = child.try_wait().map_err(|e| e.to_string())? {
return if status.success() {
Ok(())
} else {
Err(format!("{program} failed ({status})"))
};
}
if start.elapsed() > TIMEOUT {
let _ = child.kill();
let _ = child.wait();
return Err(format!("{program} took over an hour and was stopped"));
}
std::thread::sleep(Duration::from_millis(50));
}
}
File diff suppressed because it is too large Load Diff
+109
View File
@@ -0,0 +1,109 @@
//! `horizon-prepare`: prepares Horizon's resources from your own Minecraft Java Edition.
//! Its flags are the ones tools/prepare_native_client.py took.
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::ExitCode;
const HELP: &str = "\
horizon-prepare: prepare Horizon's resources from your own Minecraft Java Edition
Usage: horizon-prepare [--prepare] [--server-jar PATH] [--minecraft-dir PATH] [--root PATH]
--prepare Import the pinned game files from your own copy first
--server-jar PATH The pinned server jar you downloaded yourself
(default: HORIZON_SERVER_JAR, or the copy imported before)
--minecraft-dir PATH The official launcher's game directory with your installed copy
(default: HORIZON_MINECRAFT_DIR, or the launcher's own)
--root PATH The Horizon folder to prepare (default: the folder this program is
in, else the nearest folder above the current one with research-lock.json)
Needs Minecraft played once from the official launcher, and Java (a JDK) of the version
research-lock.json pins: JAVA_HOME, else javac and java on the PATH.
The resources go to <root>/.local/horizon-client/<version>; pass that to horizon-client --resources.
";
/// The folder with research-lock.json: beside the executable in a release folder, else the
/// current folder or one above it (a checkout, with the binary in target/).
fn default_root() -> Option<PathBuf> {
let beside = std::env::current_exe()
.ok()
.and_then(|exe| exe.parent().map(Path::to_path_buf));
if let Some(dir) = beside.filter(|d| d.join("research-lock.json").is_file()) {
return Some(dir);
}
let cwd = std::env::current_dir().ok()?;
cwd.ancestors()
.find(|d| d.join("research-lock.json").is_file())
.map(Path::to_path_buf)
}
fn main() -> ExitCode {
let mut options = horizon_prepare::Options {
root: PathBuf::new(),
import: false,
minecraft_dir: None,
server_jar: None,
};
let mut root = None;
let mut args = std::env::args_os().skip(1);
while let Some(arg) = args.next() {
let text = arg.to_string_lossy().into_owned();
let (flag, inline) = match text.split_once('=') {
Some((flag, value)) if flag.starts_with("--") => {
(flag.to_string(), Some(value.to_string()))
}
_ => (text.clone(), None),
};
let mut value = |name: &str| -> Result<PathBuf, String> {
match &inline {
Some(v) => Ok(PathBuf::from(v)),
None => args
.next()
.map(PathBuf::from)
.ok_or_else(|| format!("{name} needs a path")),
}
};
let parsed = match flag.as_str() {
"--prepare" if inline.is_none() => {
options.import = true;
Ok(())
}
"--server-jar" => value("--server-jar").map(|v| options.server_jar = Some(v)),
"--minecraft-dir" => value("--minecraft-dir").map(|v| options.minecraft_dir = Some(v)),
"--root" => value("--root").map(|v| root = Some(v)),
"-h" | "--help" => {
print!("{HELP}");
return ExitCode::SUCCESS;
}
"-V" | "--version" => {
println!("horizon-prepare {}", env!("CARGO_PKG_VERSION"));
return ExitCode::SUCCESS;
}
_ => Err(format!("unrecognized argument: {text}")),
};
if let Err(e) = parsed {
eprintln!("horizon-prepare: error: {e}\n\n{HELP}");
return ExitCode::from(2);
}
}
let Some(root) = root.or_else(default_root) else {
eprintln!(
"horizon-prepare: error: no research-lock.json beside this program or above the current folder; pass --root"
);
return ExitCode::from(2);
};
options.root = root;
let log = |line: &str| {
let mut out = std::io::stdout().lock();
let _ = writeln!(out, "{line}");
let _ = out.flush();
};
match horizon_prepare::prepare(&options, &log) {
Ok(_) => ExitCode::SUCCESS,
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
+541
View File
@@ -0,0 +1,541 @@
//! JSON read and written exactly as Python's `json` module does, so the files this crate writes
//! are byte for byte the ones `tools/prepare_native_client.py` wrote: objects keep their key
//! order (a repeated key keeps its first place and its last value), integers keep every digit,
//! floats print as Python's `repr`, and strings are escaped as `ensure_ascii=True` escapes them.
use std::fmt::Write;
#[derive(Clone, Debug)]
pub enum Value {
Null,
Bool(bool),
/// A JSON integer, kept as its decimal digits (Python's integers have no size limit).
Int(String),
Float(f64),
Str(String),
Array(Vec<Value>),
Object(Vec<(String, Value)>),
}
impl Value {
pub fn str(s: impl Into<String>) -> Value {
Value::Str(s.into())
}
pub fn get(&self, key: &str) -> Option<&Value> {
match self {
Value::Object(fields) => fields.iter().find(|(k, _)| k == key).map(|(_, v)| v),
_ => None,
}
}
pub fn index(&self, i: usize) -> Option<&Value> {
match self {
Value::Array(items) => items.get(i),
_ => None,
}
}
pub fn as_str(&self) -> Option<&str> {
match self {
Value::Str(s) => Some(s),
_ => None,
}
}
pub fn as_array(&self) -> Option<&[Value]> {
match self {
Value::Array(items) => Some(items),
_ => None,
}
}
pub fn as_object(&self) -> Option<&[(String, Value)]> {
match self {
Value::Object(fields) => Some(fields),
_ => None,
}
}
pub fn as_i64(&self) -> Option<i64> {
match self {
Value::Int(digits) => digits.parse().ok(),
_ => None,
}
}
/// `dict[key] = value`: a new key goes last, an existing one keeps its place.
pub fn insert(&mut self, key: &str, value: Value) {
if let Value::Object(fields) = self {
match fields.iter_mut().find(|(k, _)| k == key) {
Some(field) => field.1 = value,
None => fields.push((key.to_string(), value)),
}
}
}
}
/// Python's `==`: objects compare without regard to key order, and 1 == 1.0.
impl PartialEq for Value {
fn eq(&self, other: &Value) -> bool {
match (self, other) {
(Value::Null, Value::Null) => true,
(Value::Bool(a), Value::Bool(b)) => a == b,
(Value::Int(a), Value::Int(b)) => a == b,
(Value::Float(a), Value::Float(b)) => a == b,
(Value::Int(a), Value::Float(b)) | (Value::Float(b), Value::Int(a)) => {
a.parse::<f64>().is_ok_and(|a| a == *b && b.fract() == 0.0)
}
(Value::Str(a), Value::Str(b)) => a == b,
(Value::Array(a), Value::Array(b)) => a == b,
(Value::Object(a), Value::Object(b)) => {
a.len() == b.len() && a.iter().all(|(k, v)| other.get(k) == Some(v))
}
_ => false,
}
}
}
pub fn loads(text: &str) -> Result<Value, String> {
let mut parser = Parser {
text: text.as_bytes(),
at: 0,
};
parser.space();
let value = parser.value()?;
parser.space();
if parser.at != parser.text.len() {
return Err(parser.error("Extra data"));
}
Ok(value)
}
struct Parser<'a> {
text: &'a [u8],
at: usize,
}
impl Parser<'_> {
fn error(&self, what: &str) -> String {
format!("{what} at byte {}", self.at)
}
fn space(&mut self) {
while matches!(self.text.get(self.at), Some(b' ' | b'\t' | b'\n' | b'\r')) {
self.at += 1;
}
}
fn literal(&mut self, word: &str) -> bool {
if self.text[self.at..].starts_with(word.as_bytes()) {
self.at += word.len();
true
} else {
false
}
}
fn value(&mut self) -> Result<Value, String> {
match self.text.get(self.at) {
Some(b'{') => {
self.at += 1;
let mut object = Value::Object(Vec::new());
self.space();
if self.text.get(self.at) == Some(&b'}') {
self.at += 1;
return Ok(object);
}
loop {
self.space();
if self.text.get(self.at) != Some(&b'"') {
return Err(self.error("Expecting property name enclosed in double quotes"));
}
let key = self.string()?;
self.space();
if self.text.get(self.at) != Some(&b':') {
return Err(self.error("Expecting ':' delimiter"));
}
self.at += 1;
self.space();
let value = self.value()?;
object.insert(&key, value);
self.space();
match self.text.get(self.at) {
Some(b',') => self.at += 1,
Some(b'}') => {
self.at += 1;
return Ok(object);
}
_ => return Err(self.error("Expecting ',' delimiter")),
}
}
}
Some(b'[') => {
self.at += 1;
let mut items = Vec::new();
self.space();
if self.text.get(self.at) == Some(&b']') {
self.at += 1;
return Ok(Value::Array(items));
}
loop {
self.space();
items.push(self.value()?);
self.space();
match self.text.get(self.at) {
Some(b',') => self.at += 1,
Some(b']') => {
self.at += 1;
return Ok(Value::Array(items));
}
_ => return Err(self.error("Expecting ',' delimiter")),
}
}
}
Some(b'"') => Ok(Value::Str(self.string()?)),
Some(b'n') if self.literal("null") => Ok(Value::Null),
Some(b't') if self.literal("true") => Ok(Value::Bool(true)),
Some(b'f') if self.literal("false") => Ok(Value::Bool(false)),
Some(b'N') if self.literal("NaN") => Ok(Value::Float(f64::NAN)),
Some(b'I') if self.literal("Infinity") => Ok(Value::Float(f64::INFINITY)),
Some(b'-') if self.literal("-Infinity") => Ok(Value::Float(f64::NEG_INFINITY)),
Some(b'-' | b'0'..=b'9') => self.number(),
_ => Err(self.error("Expecting value")),
}
}
/// Python's NUMBER_RE: `(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?`.
fn number(&mut self) -> Result<Value, String> {
let start = self.at;
let digits = |p: &mut Self| {
let from = p.at;
while p.text.get(p.at).is_some_and(u8::is_ascii_digit) {
p.at += 1;
}
p.at - from
};
if self.text.get(self.at) == Some(&b'-') {
self.at += 1;
}
if self.text.get(self.at) == Some(&b'0') {
self.at += 1;
} else if digits(self) == 0 {
self.at = start;
return Err(self.error("Expecting value"));
}
let integer_end = self.at;
let mut float = false;
if self.text.get(self.at) == Some(&b'.') {
let dot = self.at;
self.at += 1;
if digits(self) == 0 {
self.at = dot;
} else {
float = true;
}
}
if matches!(self.text.get(self.at), Some(b'e' | b'E')) {
let mark = self.at;
self.at += 1;
if matches!(self.text.get(self.at), Some(b'-' | b'+')) {
self.at += 1;
}
if digits(self) == 0 {
self.at = mark;
} else {
float = true;
}
}
let text = std::str::from_utf8(&self.text[start..self.at]).unwrap();
if float {
text.parse::<f64>()
.map(Value::Float)
.map_err(|e| e.to_string())
} else {
debug_assert_eq!(self.at, integer_end);
Ok(Value::Int(if text == "-0" {
"0".into()
} else {
text.into()
}))
}
}
fn hex4(&mut self) -> Result<u32, String> {
let digits = self
.text
.get(self.at..self.at + 4)
.and_then(|d| std::str::from_utf8(d).ok())
.filter(|d| d.bytes().all(|b| b.is_ascii_hexdigit()))
.ok_or_else(|| self.error("Invalid \\uXXXX escape"))?;
self.at += 4;
Ok(u32::from_str_radix(digits, 16).unwrap())
}
fn string(&mut self) -> Result<String, String> {
self.at += 1;
let mut out = String::new();
loop {
let run = self.at;
while self
.text
.get(self.at)
.is_some_and(|&b| b != b'"' && b != b'\\' && b >= 0x20)
{
self.at += 1;
}
out.push_str(std::str::from_utf8(&self.text[run..self.at]).map_err(|e| e.to_string())?);
match self.text.get(self.at) {
Some(b'"') => {
self.at += 1;
return Ok(out);
}
Some(b'\\') => {
self.at += 1;
let escape = *self
.text
.get(self.at)
.ok_or_else(|| self.error("Unterminated string"))?;
self.at += 1;
match escape {
b'"' => out.push('"'),
b'\\' => out.push('\\'),
b'/' => out.push('/'),
b'b' => out.push('\u{8}'),
b'f' => out.push('\u{c}'),
b'n' => out.push('\n'),
b'r' => out.push('\r'),
b't' => out.push('\t'),
b'u' => {
let mut code = self.hex4()?;
if (0xd800..0xdc00).contains(&code)
&& self.text[self.at..].starts_with(b"\\u")
{
let back = self.at;
self.at += 2;
let low = self.hex4()?;
if (0xdc00..0xe000).contains(&low) {
code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);
} else {
self.at = back;
}
}
out.push(char::from_u32(code).ok_or_else(|| {
self.error(
"Lone surrogate (Python keeps it; Horizon's files have none)",
)
})?);
}
_ => return Err(self.error("Invalid \\escape")),
}
}
_ => return Err(self.error("Unterminated string or control character")),
}
}
}
}
/// `json.dumps(value, indent=indent, separators=(item, key))` with `ensure_ascii=True`.
/// Python's defaults are `(", ", ": ")` without an indent and `(",", ": ")` with one.
pub struct Format {
pub indent: Option<usize>,
pub item: &'static str,
pub key: &'static str,
}
/// `json.dumps(value)`.
pub const DEFAULT: Format = Format {
indent: None,
item: ", ",
key: ": ",
};
/// `json.dumps(value, separators=(',', ':'))`.
pub const COMPACT: Format = Format {
indent: None,
item: ",",
key: ":",
};
/// `json.dumps(value, indent=2)`.
pub const INDENT2: Format = Format {
indent: Some(2),
item: ",",
key: ": ",
};
pub fn dumps(value: &Value, format: &Format) -> String {
let mut out = String::new();
write_value(&mut out, value, format, 0);
out
}
fn newline(out: &mut String, format: &Format, level: usize) {
if let Some(indent) = format.indent {
out.push('\n');
out.extend(std::iter::repeat_n(' ', indent * level));
}
}
fn write_value(out: &mut String, value: &Value, format: &Format, level: usize) {
match value {
Value::Null => out.push_str("null"),
Value::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
Value::Int(digits) => out.push_str(digits),
Value::Float(f) => out.push_str(&float_repr(*f)),
Value::Str(s) => write_string(out, s),
Value::Array(items) => {
if items.is_empty() {
out.push_str("[]");
return;
}
out.push('[');
for (i, item) in items.iter().enumerate() {
if i > 0 {
out.push_str(format.item);
}
newline(out, format, level + 1);
write_value(out, item, format, level + 1);
}
newline(out, format, level);
out.push(']');
}
Value::Object(fields) => {
if fields.is_empty() {
out.push_str("{}");
return;
}
out.push('{');
for (i, (key, item)) in fields.iter().enumerate() {
if i > 0 {
out.push_str(format.item);
}
newline(out, format, level + 1);
write_string(out, key);
out.push_str(format.key);
write_value(out, item, format, level + 1);
}
newline(out, format, level);
out.push('}');
}
}
}
/// Python's `py_encode_basestring_ascii`: every character outside space..`~` is escaped,
/// with lowercase hex and surrogate pairs above the BMP.
pub fn write_string(out: &mut String, s: &str) {
out.push('"');
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
'\u{8}' => out.push_str("\\b"),
'\u{c}' => out.push_str("\\f"),
' '..='~' => out.push(c),
_ => {
let mut units = [0u16; 2];
for unit in c.encode_utf16(&mut units) {
let _ = write!(out, "\\u{unit:04x}");
}
}
}
}
out.push('"');
}
/// Python's `repr(float)`: the shortest digits that read back the same, in fixed notation when
/// the decimal point falls between 10^-4 and 10^16, with `.0` on whole numbers.
pub fn float_repr(f: f64) -> String {
if f.is_nan() {
return "NaN".into();
}
if f.is_infinite() {
return if f > 0.0 { "Infinity" } else { "-Infinity" }.into();
}
// Rust's `{:e}` gives the same shortest round-trip digits: "d.ddde-x".
let scientific = format!("{:e}", f.abs());
let (mantissa, exponent) = scientific.split_once('e').unwrap();
let digits: String = mantissa.chars().filter(|c| *c != '.').collect();
let exponent: i32 = exponent.parse().unwrap();
let point = exponent + 1; // The value is 0.digits * 10^point.
let sign = if f.is_sign_negative() { "-" } else { "" };
let n = digits.len() as i32;
if f == 0.0 {
return format!("{sign}0.0");
}
if -4 < point && point <= 16 {
if point <= 0 {
format!("{sign}0.{}{digits}", "0".repeat((-point) as usize))
} else if point >= n {
format!("{sign}{digits}{}.0", "0".repeat((point - n) as usize))
} else {
let (whole, fraction) = digits.split_at(point as usize);
format!("{sign}{whole}.{fraction}")
}
} else {
let (first, rest) = digits.split_at(1);
let mantissa = if rest.is_empty() {
first.to_string()
} else {
format!("{first}.{rest}")
};
let e = point - 1;
format!(
"{sign}{mantissa}e{}{:02}",
if e < 0 { '-' } else { '+' },
e.abs()
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn floats_print_as_python_repr() {
for (f, repr) in [
(0.0, "0.0"),
(-0.0, "-0.0"),
(1.0, "1.0"),
(0.1, "0.1"),
(1.5e-5, "1.5e-05"),
(0.0001, "0.0001"),
(1e16, "1e+16"),
(1234567890123456.0, "1234567890123456.0"),
(12345678901234567.0, "1.2345678901234568e+16"),
(-2.5, "-2.5"),
(1e-310, "1e-310"),
(f64::MAX, "1.7976931348623157e+308"),
(100.0, "100.0"),
(0.30000000000000004, "0.30000000000000004"),
] {
assert_eq!(float_repr(f), repr, "{f}");
}
}
#[test]
fn strings_escape_as_ensure_ascii() {
let mut out = String::new();
write_string(&mut out, "a\"\\\n\u{7f}é\u{1F600}\u{1}");
assert_eq!(out, "\"a\\\"\\\\\\n\\u007f\\u00e9\\ud83d\\ude00\\u0001\"");
}
#[test]
fn objects_keep_first_place_and_last_value() {
let v = loads(r#"{"b": 1, "a": [1.0, -0, 1e2, true, null], "b": 2}"#).unwrap();
assert_eq!(
dumps(&v, &DEFAULT),
r#"{"b": 2, "a": [1.0, 0, 100.0, true, null]}"#
);
assert_eq!(
dumps(&v, &INDENT2),
"{\n \"b\": 2,\n \"a\": [\n 1.0,\n 0,\n 100.0,\n true,\n null\n ]\n}"
);
assert_eq!(
dumps(&loads("{\"x\":{},\"y\":[]}").unwrap(), &INDENT2),
"{\n \"x\": {},\n \"y\": []\n}"
);
}
}
+146
View File
@@ -0,0 +1,146 @@
//! Survival rules of the world generator's feature placement: each block's rule from the class
//! vanilla gives it and the class of its placement check (tools/test_block_survival_parity.py's
//! `bind_definitions` and its tables).
use crate::pyjson::Value;
const CLASS_RULES: &[(&str, &str)] = &[
("FireBlock", "Fire"),
("CactusBlock", "Cactus"),
("PathBlock", "Path"),
("MushroomBlock", "Mushroom"),
("MultifaceBlock", "Multiface"),
("VineBlock", "Vine"),
("HangingMossBlock", "HangingMoss"),
("SeaPickleBlock", "SeaPickle"),
("SnowLayerBlock", "SnowLayer"),
("BellBlock", "Bell"),
("ShelfMushroomBlock", "FullBehind"),
("GrowingPlantBlock", "GrowingPlant"),
("MangrovePropaguleBlock", "MangrovePropagule"),
("SpeleothemBlock", "Speleothem"),
("ScaffoldingBlock", "Scaffolding"),
("PistonHeadBlock", "PistonHead"),
("ChorusPlantBlock", "ChorusPlant"),
("ChorusFlowerBlock", "ChorusFlower"),
("PitcherCropBlock", "PitcherCrop"),
("BigDripleafBlock", "BigDripleaf"),
("BigDripleafStemBlock", "BigDripleafStem"),
("FarmlandBlock", "Farmland"),
("CocoaBlock", "Cocoa"),
("SugarCaneBlock", "SugarCane"),
("SporeBlossomBlock", "SporeBlossom"),
("FrogspawnBlock", "Frogspawn"),
("SmallDripleafBlock", "SmallDripleaf"),
("TallSeagrassBlock", "TallSeagrass"),
("DoorBlock", "Door"),
("BaseRailBlock", "RigidBelow"),
("LeafLitterBlock", "FullBelow"),
("WallSignBlock", "SolidBehind"),
("GrindstoneBlock", "Always"),
("RedstoneWallTorchBlock", "FullBehind"),
("BubbleColumnBlock", "BubbleColumn"),
("RedstoneWireBlock", "RedstoneWire"),
("SoulFireBlock", "TagBelow:minecraft:soul_fire_base_blocks"),
("BlockBehaviour", "Always"),
("CakeBlock", "SolidBelow"),
("CandleCakeBlock", "SolidBelow"),
("BannerBlock", "SolidBelow"),
("StandingSignBlock", "SolidBelow"),
("WallBannerBlock", "SolidBehind"),
("CarpetBlock", "NonAirBelow"),
("MossyCarpetBlock", "MossCarpet"),
("BaseTorchBlock", "CenterBelow"),
("CandleBlock", "CenterBelow"),
("LanternBlock", "Lantern"),
("HangingRootsBlock", "FullAbove"),
("LadderBlock", "FullBehind"),
("AmethystClusterBlock", "FullBehind"),
("TripWireHookBlock", "FullBehind"),
("BaseCoralWallFanBlock", "FullBehind"),
("WallTorchBlock", "FullBehind"),
("BasePressurePlateBlock", "RigidOrCenterBelow"),
("DiodeBlock", "RigidBelow"),
("BaseCoralPlantTypeBlock", "FullBelow"),
("CeilingHangingSignBlock", "CenterAbove"),
("FaceAttachedHorizontalDirectionalBlock", "FaceAttached"),
("BambooSaplingBlock", "SupportsBamboo"),
("BambooStalkBlock", "SupportsBamboo"),
];
const VEGETATION_RULES: &[(&str, &str)] = &[
("LilyPadBlock", "LilyPad"),
("VegetationBlock", "TagBelow:minecraft:supports_vegetation"),
("AzaleaBlock", "TagBelow:minecraft:supports_azalea"),
(
"DryVegetationBlock",
"TagBelow:minecraft:supports_dry_vegetation",
),
(
"NetherSproutsBlock",
"TagBelow:minecraft:supports_nether_sprouts",
),
("NetherWartBlock", "TagBelow:minecraft:supports_nether_wart"),
("WitherRoseBlock", "TagBelow:minecraft:supports_wither_rose"),
("CactusFlowerBlock", "CactusFlower"),
("SeagrassBlock", "Seagrass"),
];
fn lookup(table: &[(&str, &'static str)], key: &str) -> Option<&'static str> {
table.iter().find(|(k, _)| *k == key).map(|(_, v)| *v)
}
/// `{block: rule}` from the exporter's `{block: class}`, `{block: placement class}` and
/// `{block: {field: support tag}}`, in the order Python's dict built it.
pub fn bind_definitions(
classes: &Value,
placement: &Value,
support_tags: &Value,
) -> Result<Value, String> {
let classes = classes
.as_object()
.ok_or("survival-classes.json is not an object")?;
let mut definitions = Value::Object(Vec::new());
for (name, owner) in classes {
if let Some(rule) = owner.as_str().and_then(|o| lookup(CLASS_RULES, o)) {
definitions.insert(name, Value::str(rule));
}
}
for (name, owner) in classes {
let owner = owner.as_str().unwrap_or("");
let placed = placement.get(name).and_then(Value::as_str);
if owner == "CropBlock" && placed == Some("CropBlock") {
definitions.insert(name, Value::str("Crop"));
}
if owner == "DoublePlantBlock" && placed == Some("VegetationBlock") {
definitions.insert(name, Value::str("DoublePlant"));
}
if owner != "VegetationBlock" {
continue;
}
let method = placed.ok_or_else(|| format!("No placement class for {name}"))?;
if let Some(rule) = lookup(VEGETATION_RULES, method) {
definitions.insert(name, Value::str(rule));
} else if [
"AttachedStemBlock",
"StemBlock",
"NetherFungusBlock",
"NetherRootsBlock",
]
.contains(&method)
{
let field = if method == "StemBlock" {
"stemSupportBlocks"
} else {
"supportBlocks"
};
let tag = support_tags
.get(name)
.and_then(|t| t.get(field))
.and_then(Value::as_str)
.ok_or_else(|| format!("No {field} support tag for {name}"))?;
definitions.insert(name, Value::Str(format!("TagBelow:{tag}")));
}
}
Ok(definitions)
}
+1 -1
View File
@@ -8,7 +8,7 @@
//! [`Behaviours`] holds immutable tables loaded once from the pinned client
//! resources (`block-behaviours.json`, `gameplay-facts.json`,
//! `block-tags.json`, `cached-collision.nbt`; see
//! `tools/prepare_native_client.py`).
//! `crates/horizon-prepare`).
//!
//! # Driving a level
//!
@@ -1,6 +1,6 @@
//! Optional block-behavior registries used by feature placement: physical
//! properties, face support, collision and survival rules. Loaded from the
//! bundle's `blocks/` directory (Java-exported, see prepare_native_client.py).
//! bundle's `blocks/` directory (Java-exported, see crates/horizon-prepare).
use super::generator::GeneratorError;
use crate::{
block_collision::BlockCollisionRegistry,
+9 -4
View File
@@ -14,7 +14,8 @@ missing; [Rust rewrite status](rust-parity.md) has the details.
## Run from a checkout
Use current stable Rust (1.90+), Python 3.10+ and JDK 25. Horizon never
Use current stable Rust (1.90+) and JDK 25 (Python 3.10+ for the sounds and the
development harnesses). Horizon never
downloads the game: resource preparation imports **your own copy** (the 26.3
client from your official launcher install, and the 26.3 server jar you
downloaded yourself; see [Build from source](../README.md#build-from-source)),
@@ -23,8 +24,12 @@ exporters against those jars, and extracts the jar's assets and data into ignore
`.local/horizon-client/26.3/`. Sounds (about 380 MB) are copied from your
launcher's asset store. Prepared resources are private; never commit them.
Preparation is `horizon-prepare` (`crates/horizon-prepare`, Rust): it needs no Python, only
the JDK, for the small exporters that call Mojang's own code. Release folders ship it beside
`horizon-client`, and the launcher prepares with it.
```sh
python3 tools/prepare_native_client.py --prepare --server-jar ~/Downloads/server.jar
cargo run --release -p horizon-prepare -- --prepare --server-jar ~/Downloads/server.jar
python3 tools/fetch_sounds.py
cargo run --release -p horizon-client -- --render-distance 12
```
@@ -205,7 +210,7 @@ attribute. Sneaking invokes ledge backoff before collision resolution. The
complete authoritative player tick remains unfinished.
```sh
python3 tools/prepare_native_client.py
cargo run --release -p horizon-prepare
python3 tools/test_native_scene_collision.py
```
@@ -264,7 +269,7 @@ The [renderer startup check](../benchmarks/rust-native-walking-2026-10-07/startu
also passes after the movement integration.
```sh
python3 tools/prepare_native_client.py
cargo run --release -p horizon-prepare
python3 tools/test_native_scene_motion.py
python3 tools/test_local_input_parity.py
```
+1 -1
View File
@@ -82,7 +82,7 @@ python3 tools/test_section_mesh_parity.py --only fluids
```
It needs the pinned jars (`tools/lab.py prepare`) and prepared client resources
(`tools/prepare_native_client.py --prepare`). Outputs, logs and
(`cargo run --release -p horizon-prepare -- --prepare`). Outputs, logs and
`report.json` go to `target/section-mesh-parity/`; nothing is written under
`.local/`. The fixture is built with `--profile fast` and reports its
meshing time.
+22
View File
@@ -2571,6 +2571,7 @@ dependencies = [
"dirs 5.0.1",
"flate2",
"gpui",
"horizon-prepare",
"horizon-theme",
"image",
"pulldown-cmark",
@@ -2582,6 +2583,16 @@ dependencies = [
"zip",
]
[[package]]
name = "horizon-prepare"
version = "0.1.0"
dependencies = [
"regex",
"sha1",
"sha2 0.10.9",
"zip",
]
[[package]]
name = "horizon-theme"
version = "0.1.0"
@@ -4964,6 +4975,17 @@ dependencies = [
"serde",
]
[[package]]
name = "sha1"
version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
dependencies = [
"cfg-if",
"cpufeatures 0.2.17",
"digest 0.10.7",
]
[[package]]
name = "sha1_smol"
version = "1.0.1"
+1
View File
@@ -21,6 +21,7 @@ self-replace = "1"
image = { version = "0.25", default-features = false, features = ["jpeg"] }
clap = { version = "4", features = ["derive"] }
horizon-theme = { path = "../crates/horizon-theme" }
horizon-prepare = { path = "../crates/horizon-prepare" }
[profile.release]
strip = true
+5 -2
View File
@@ -15,8 +15,11 @@ The opening, then Play ([clip](docs/opening.webm)):
- **Versions**: lists the published releases of ludovic111/horizon, installs the build for
this platform into its own folder, and removes it again.
- **Play**: prepares resources as `PLAY.txt` describes (your launcher's 26.3 install, the
26.3 server jar from that version's own json, Python 3.10+ and Java 25), then starts the
client, or a server (`--dedicated --nogui`) in a folder you choose, with a live console.
26.3 server jar from that version's own json, and Java 25), then starts the client, or a
server (`--dedicated --nogui`) in a folder you choose, with a live console. Preparing is
horizon-prepare: linked into the launcher, used in-process when a version ships the same
preparer sources, else that version's own `horizon-prepare`; versions released before it
still prepare with their Python script and need Python 3.10+.
- **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Join Discord" and "Website" links sit in the sidebar footer.
Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
+291 -38
View File
@@ -380,12 +380,15 @@ pub fn is_prepared(tag: &str) -> bool {
/// Whether the resources `from` prepared are the ones preparing `to` would make. The output
/// depends on the Horizon version, not only on Minecraft's: the manifest records the hashes of
/// the vanilla exporters it was made with (mods/horizon/src/test/java/.../parity), and
/// prepare_native_client.py writes every file and the manifest's `schema`. So both need the
/// same pinned Minecraft jars (research-lock.json), the same prepare_native_client.py and the
/// same exporter sources. The helpers it imports (lab.py and the test_*_parity.py modules)
/// change between releases in how they find and check the player's files, which the output
/// does not depend on; they are not compared.
/// the vanilla exporters it was made with (mods/horizon/src/test/java/.../parity), and the
/// preparer writes every file and the manifest's `schema`. So both need the same pinned
/// Minecraft jars (research-lock.json), the same preparer and the same exporter sources. The
/// preparer is crates/horizon-prepare (its sources ship in the release folder beside the
/// binary) and tools/prepare_native_client.py (the Python preparer of older versions, a wrapper
/// of the binary since); a file only one of the two versions has is a different preparer. The
/// helpers the Python preparer imported (lab.py and the test_*_parity.py modules) change
/// between releases in how they find and check the player's files, which the output does not
/// depend on; they are not compared.
fn resources_compatible(from: &Path, to: &Path, manifest: &serde_json::Value) -> bool {
let pins = |dir: &Path| {
read_json(&dir.join("research-lock.json")).map(|lock| {
@@ -401,8 +404,21 @@ fn resources_compatible(from: &Path, to: &Path, manifest: &serde_json::Value) ->
let Some(fields) = manifest.as_object() else {
return false;
};
let mut preparer = vec![PathBuf::from("tools/prepare_native_client.py")];
for dir in [from, to] {
preparer.extend(files_under(dir, Path::new(PREPARER_CRATE)));
}
let same_or_absent = |path: &Path| match (fs::read(from.join(path)), fs::read(to.join(path))) {
(Ok(a), Ok(b)) => a == b,
(Err(a), Err(b)) => {
a.kind() == std::io::ErrorKind::NotFound && b.kind() == std::io::ErrorKind::NotFound
}
_ => false,
};
if !preparer.iter().all(|p| same_or_absent(p)) {
return false;
}
let mut sources = vec![
"tools/prepare_native_client.py".to_string(),
"mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeightmapOracle.java".to_string(),
];
for (_, value) in fields
@@ -425,6 +441,26 @@ fn resources_compatible(from: &Path, to: &Path, manifest: &serde_json::Value) ->
sources.iter().all(|s| same(s))
}
/// Where a version folder keeps the preparer's sources (packaging/package.sh copies them).
const PREPARER_CRATE: &str = "crates/horizon-prepare";
/// The files under `dir/relative`, as paths relative to `dir`.
fn files_under(dir: &Path, relative: &Path) -> Vec<PathBuf> {
let Ok(entries) = fs::read_dir(dir.join(relative)) else {
return Vec::new();
};
let mut files = Vec::new();
for entry in entries.flatten() {
let path = relative.join(entry.file_name());
match entry.file_type() {
Ok(t) if t.is_dir() => files.extend(files_under(dir, &path)),
Ok(_) => files.push(path),
Err(_) => {}
}
}
files
}
fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
fs::create_dir_all(to)?;
for entry in fs::read_dir(from)? {
@@ -500,7 +536,7 @@ fn reuse_prepared_in(versions: &Path) -> Vec<(String, String)> {
.collect()
}
/// The official launcher's game directory, where prepare_native_client.py looks by default.
/// The official launcher's game directory, where horizon-prepare looks by default.
pub fn default_minecraft_dir() -> Option<PathBuf> {
let home = dirs::home_dir()?;
let dir = if cfg!(target_os = "macos") {
@@ -531,13 +567,29 @@ fn python() -> Option<&'static str> {
candidates.iter().copied().find(|p| found(p, "--version"))
}
/// Checks what the preparation needs and builds its command. PLAY.txt describes the same steps:
/// the player's own launcher install, the server jar from that version's own json, Java and Python.
pub fn prepare_command(
tag: &str,
minecraft: &Path,
log: &dyn Fn(String),
) -> Result<Command, String> {
/// How a version's resources are prepared.
pub enum Preparer {
/// horizon-prepare, linked into the launcher: the version ships the same preparer sources.
InProcess(horizon_prepare::Options),
/// The version's own preparer: its horizon-prepare binary when its sources differ from the
/// launcher's (a newer or older release), or the Python script of versions made before it.
Process(Command),
}
/// The version's horizon-prepare binary, when it ships one.
fn preparer_binary(dir: &Path) -> Option<PathBuf> {
let binary = dir.join(if cfg!(windows) {
"horizon-prepare.exe"
} else {
"horizon-prepare"
});
binary.is_file().then_some(binary)
}
/// Checks what the preparation needs and picks how to run it. PLAY.txt describes the same
/// steps: the player's own launcher install, the server jar from that version's own json, and
/// Java (and Python, for versions before horizon-prepare).
pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result<Preparer, String> {
let version = game_version(tag);
let manifest = minecraft
.join("versions")
@@ -549,12 +601,27 @@ pub fn prepare_command(
minecraft.display()
));
}
let python = python().ok_or("Python 3.10 or newer is needed. Install it and try again.")?;
if !found("java", "-version") {
return Err(
"Java 25 is needed (a JDK, e.g. Eclipse Temurin 25). Install it and try again.".into(),
);
}
let dir = version_dir(tag);
let binary = preparer_binary(&dir);
let python = if binary.is_some() {
// The JDK the version pins, found as horizon-prepare finds it, so a missing one is
// reported before the server jar is downloaded.
let major = read_json(&dir.join("research-lock.json"))
.and_then(|lock| lock["minecraft"]["java_major"].as_i64())
.ok_or("The version's research-lock.json has no java_major")?;
horizon_prepare::java::find(major)?;
None
} else {
let python = python()
.ok_or("This version prepares with Python: Python 3.10 or newer is needed. Install it, or pick a newer version.")?;
if !found("java", "-version") {
return Err(
"Java 25 is needed (a JDK, e.g. Eclipse Temurin 25). Install it and try again."
.into(),
);
}
Some(python)
};
let jar = data_dir()
.join("server-jars")
.join(format!("{version}.jar"));
@@ -577,8 +644,29 @@ pub fn prepare_command(
.and_then(|_| fs::rename(&partial, &jar))
.map_err(|e| e.to_string())?;
}
let mut cmd = Command::new(python);
cmd.current_dir(version_dir(tag))
if let Some(binary) = binary {
if horizon_prepare::sources_sha256(&dir.join(PREPARER_CRATE)).as_deref()
== Some(horizon_prepare::SOURCES_SHA256)
{
return Ok(Preparer::InProcess(horizon_prepare::Options {
root: dir,
import: true,
minecraft_dir: Some(minecraft.to_path_buf()),
server_jar: Some(jar),
}));
}
let mut cmd = Command::new(binary);
cmd.current_dir(&dir)
.arg("--root")
.arg(&dir)
.args(["--prepare", "--server-jar"])
.arg(&jar)
.arg("--minecraft-dir")
.arg(minecraft);
return Ok(Preparer::Process(cmd));
}
let mut cmd = Command::new(python.unwrap());
cmd.current_dir(&dir)
.args([
"-u",
"tools/prepare_native_client.py",
@@ -588,7 +676,20 @@ pub fn prepare_command(
.arg(&jar)
.arg("--minecraft-dir")
.arg(minecraft);
Ok(cmd)
Ok(Preparer::Process(cmd))
}
/// Runs `Preparer::InProcess` on this thread, each progress line to `log`. A panic is an
/// error like any other, so the window never waits on a preparation that died.
pub fn prepare_in_process(
options: &horizon_prepare::Options,
log: &dyn Fn(String),
) -> Result<(), String> {
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
horizon_prepare::prepare(options, &|line| log(line.to_string()))
}))
.unwrap_or_else(|_| Err("The preparation stopped unexpectedly".into()))
.map(|_| ())
}
/// Where the game keeps saves and options.txt: `HORIZON_HOME`, else `horizon` in the platform's
@@ -945,13 +1046,74 @@ pub fn self_update_allowed() -> bool {
!cfg!(debug_assertions) && std::env::var_os("HORIZON_LAUNCHER_NO_SELF_UPDATE").is_none()
}
/// The version in `horizon-launcher --version`'s output (`horizon-launcher 0.1.5`).
fn parse_version_output(out: &str) -> Option<&str> {
out.trim()
.strip_prefix("horizon-launcher ")
.map(str::trim)
.filter(|v| !v.is_empty())
}
/// The version of the launcher binary now at `path`, which is not this process's once another
/// update (the command line, another window) has replaced the file.
fn installed_launcher_version(path: &Path) -> Option<String> {
let mut cmd = Command::new(path);
cmd.arg("--version")
.stdin(Stdio::null())
.stderr(Stdio::null());
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
cmd.creation_flags(CREATE_NO_WINDOW);
}
let out = cmd.output().ok()?;
parse_version_output(&String::from_utf8_lossy(&out.stdout)).map(String::from)
}
/// Puts `new` at `exe`, the path this launcher started from. The running process keeps its
/// file (unlinked) and works on. Unix only: `self_replace` asks the system where the running
/// binary is, and Linux answers "<path> (deleted)" once the file has been replaced, so a second
/// update in the same run failed with "No such file or directory". Windows keeps a running
/// binary locked, so there `self_replace` moves it aside first.
#[cfg(unix)]
fn replace_binary(new: &Path, exe: &Path) -> std::io::Result<()> {
use std::os::unix::fs::PermissionsExt;
let dir = exe.parent().ok_or_else(|| {
std::io::Error::new(std::io::ErrorKind::NotFound, "the launcher has no folder")
})?;
let name = exe.file_name().unwrap_or_default().to_string_lossy();
let temp = dir.join(format!(".{name}.update-{}", std::process::id()));
let mode = fs::metadata(exe).map_or(0o755, |m| m.permissions().mode() | 0o111);
let result = fs::copy(new, &temp)
.and_then(|_| fs::set_permissions(&temp, fs::Permissions::from_mode(mode)))
.and_then(|_| fs::rename(&temp, exe));
if result.is_err() {
let _ = fs::remove_file(&temp);
}
result
}
#[cfg(not(unix))]
fn replace_binary(new: &Path, _exe: &Path) -> std::io::Result<()> {
self_replace::self_replace(new)
}
/// Downloads a launcher release and puts its binary in place of this one. The running process
/// keeps working; `restart` starts the new one.
/// keeps working; `restart` starts the new one. When the file there already is that release or
/// a newer one (updated from the command line or another window), there is nothing to do.
pub fn self_update(release: &Release, progress: impl Fn(f32)) -> Result<(), String> {
let (url, size) = release
.asset
.clone()
.ok_or("This launcher release has no build for this platform.")?;
let target = launcher_version(&release.tag).unwrap_or("0");
if installed_launcher_version(exe_path())
.is_some_and(|v| v != VERSION && compare_versions(&v, target).is_ge())
{
progress(1.0);
return Ok(());
}
let work = data_dir().join(".launcher-update");
let _ = fs::remove_dir_all(&work);
fs::create_dir_all(&work).map_err(|e| e.to_string())?;
@@ -961,13 +1123,12 @@ pub fn self_update(release: &Release, progress: impl Fn(f32)) -> Result<(), Stri
unpack(&archive, &url, &unpacked)?;
let binary =
find_file(&unpacked, LAUNCHER_BINARY).ok_or("The download has no launcher binary.")?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let _ = fs::set_permissions(&binary, fs::Permissions::from_mode(0o755));
}
self_replace::self_replace(&binary)
.map_err(|e| format!("Could not replace the launcher: {e}"))?;
replace_binary(&binary, exe_path()).map_err(|e| {
format!(
"Could not replace the launcher at {}: {e}",
exe_path().display()
)
})?;
let _ = fs::remove_dir_all(&work);
progress(1.0);
Ok(())
@@ -987,12 +1148,26 @@ fn find_file(dir: &Path, name: &str) -> Option<PathBuf> {
None
}
/// Starts the launcher again (the updated binary) with the same arguments, and exits.
pub fn restart() -> ! {
let _ = Command::new(exe_path())
.args(std::env::args_os().skip(1))
.spawn();
std::process::exit(0)
/// Starts the launcher again (the updated binary) with the same arguments in place of this one:
/// on Unix the process becomes the new binary (exec), on Windows the new one starts and this one
/// exits. Returns only when the new binary could not start.
pub fn restart() -> String {
let mut cmd = Command::new(exe_path());
cmd.args(std::env::args_os().skip(1));
#[cfg(unix)]
let error = {
use std::os::unix::process::CommandExt;
cmd.exec()
};
#[cfg(not(unix))]
let error = match cmd.spawn() {
Ok(_) => std::process::exit(0),
Err(e) => e,
};
format!(
"Could not start {}: {error}. Close the launcher and open it again.",
exe_path().display()
)
}
/// Plain text from markdown, for terminals: headings on their own lines, bullets as "- ",
@@ -1430,9 +1605,87 @@ mod tests {
assert!(is_prepared("v2026.10.17"));
assert!(!is_prepared("v2026.10.15") && !is_prepared("v2026.10.16"));
assert!(reuse_prepared_in(&versions).is_empty());
// Versions with horizon-prepare: its sources are the preparer, so the same sources
// reuse each other's resources, and a change or a version without them prepares again.
let crate_file = "crates/horizon-prepare/src/lib.rs";
release("v2026.10.18", "26.3");
write("v2026.10.18", crate_file, "rust preparer");
assert_eq!(reuse_prepared(&versions, "v2026.10.18"), None);
prepared("v2026.10.18", "26.3");
release("v2026.10.19", "26.3");
write("v2026.10.19", crate_file, "rust preparer");
assert_eq!(
reuse_prepared(&versions, "v2026.10.19"),
Some("v2026.10.18".into())
);
release("v2026.10.20", "26.3");
write("v2026.10.20", crate_file, "rust preparer, changed");
assert_eq!(reuse_prepared(&versions, "v2026.10.20"), None);
let _ = fs::remove_dir_all(&versions);
}
#[test]
fn launcher_versions_read_from_the_binary() {
assert_eq!(
parse_version_output("horizon-launcher 0.1.5\n"),
Some("0.1.5")
);
assert_eq!(parse_version_output("something else"), None);
assert_eq!(parse_version_output(""), None);
// This test binary is not a launcher: no version, so an update goes ahead.
assert_eq!(
installed_launcher_version(&std::env::current_exe().unwrap()),
None
);
assert_eq!(
installed_launcher_version(Path::new("/nonexistent/horizon-launcher")),
None
);
}
/// The launcher's file was replaced while it ran (an update from the command line, or an
/// earlier one): the next replacement still lands at the path it started from.
#[cfg(unix)]
#[test]
fn a_replaced_binary_is_replaced_again_at_its_path() {
use std::os::unix::fs::PermissionsExt;
let dir =
std::env::temp_dir().join(format!("horizon-launcher-replace-{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).unwrap();
let exe = dir.join("horizon-launcher");
fs::write(&exe, "old").unwrap();
// Another update swaps the file under the running launcher.
fs::write(dir.join("other"), "other update").unwrap();
fs::rename(dir.join("other"), &exe).unwrap();
fs::write(dir.join("new"), "new").unwrap();
replace_binary(&dir.join("new"), &exe).unwrap();
assert_eq!(fs::read_to_string(&exe).unwrap(), "new");
// The file there keeps its mode, made executable (the swapped-in one was 0644).
assert_eq!(
fs::metadata(&exe).unwrap().permissions().mode() & 0o777,
0o755
);
// Gone altogether: it is put back, executable.
fs::remove_file(&exe).unwrap();
replace_binary(&dir.join("new"), &exe).unwrap();
assert_eq!(fs::read_to_string(&exe).unwrap(), "new");
assert_eq!(
fs::metadata(&exe).unwrap().permissions().mode() & 0o777,
0o755
);
// No temporary file is left beside it.
let mut names: Vec<String> = fs::read_dir(&dir)
.unwrap()
.flatten()
.map(|e| e.file_name().to_string_lossy().into_owned())
.collect();
names.sort();
assert_eq!(names, ["horizon-launcher", "new"]);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn plain_notes() {
let text = markdown_to_text(
+7 -3
View File
@@ -205,8 +205,12 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
Cmd::Prepare { minecraft, version } => {
let tag = backend::resolve_version(version.as_deref())?;
let minecraft = backend::minecraft_dir(minecraft)?;
let cmd = backend::prepare_command(&tag, &minecraft, &|line| eprintln!("{line}"))?;
attached(cmd)?;
match backend::preparer(&tag, &minecraft, &|line| eprintln!("{line}"))? {
backend::Preparer::Process(cmd) => attached(cmd)?,
backend::Preparer::InProcess(options) => {
backend::prepare_in_process(&options, &|line| println!("{line}"))?
}
}
println!("{tag} is prepared.");
}
Cmd::Play { version } => attached(backend::client(&backend::resolve_version(
@@ -301,7 +305,7 @@ fn update(check: bool, as_json: bool) -> Result<(), String> {
println!("Launcher: {version} is available; this build does not replace itself.");
} else {
backend::self_update(r, progress(format!("Updating the launcher to {version}")))?;
println!("Launcher: updated to {version}; the next start uses it.");
println!("Launcher: updated to {version}. Restart the launcher to use it.");
}
}
}
+27 -12
View File
@@ -472,17 +472,27 @@ impl Launcher {
self.prepare_log.clear();
self.prepare_error = None;
self.prepare_log
.push_back("Checking Java, Python and your Minecraft install".into());
.push_back("Checking Java and your Minecraft install".into());
let tx = self.tx.clone();
// The checks may download the server jar, so they run on the thread too.
std::thread::spawn(move || {
let log = |line| {
let _ = tx.send(Msg::Line(Job::Prepare, line));
};
let result = backend::prepare_command(&tag, &minecraft, &log)
.and_then(|cmd| backend::spawn(Job::Prepare, cmd, tx.clone()));
let result = backend::preparer(&tag, &minecraft, &log).and_then(|p| match p {
backend::Preparer::Process(cmd) => {
backend::spawn(Job::Prepare, cmd, tx.clone()).map(|_running| false)
}
backend::Preparer::InProcess(options) => {
backend::prepare_in_process(&options, &log).map(|_| true)
}
});
match result {
Ok(_running) => {}
// A process sends its own Exit when it ends.
Ok(false) => {}
Ok(true) => {
let _ = tx.send(Msg::Exit(Job::Prepare, Ok(())));
}
Err(e) => {
let _ = tx.send(Msg::Exit(Job::Prepare, Err(e)));
}
@@ -882,7 +892,7 @@ impl Launcher {
.flex()
.flex_col()
.gap(px(2.))
.child(div().child(format!("Launcher {} → {version}", backend::VERSION)))
.child(div().child(format!("Launcher updated to {version}")))
.child(
div()
.id("restart")
@@ -890,8 +900,11 @@ impl Launcher {
.font_weight(FontWeight::MEDIUM)
.cursor_pointer()
.hover(|s| s.opacity(0.8))
.child("Restart to update")
.on_click(|_, _, _| backend::restart()),
.child("Restart the launcher")
.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
this.self_update = SelfUpdate::Failed(backend::restart());
cx.notify();
})),
),
_ => div().child(format!("Launcher {}", backend::VERSION)),
};
@@ -1513,9 +1526,7 @@ impl Launcher {
SelfUpdate::Downloading(v, p) => {
format!("{} · downloading {v}, {:.0}%", backend::VERSION, p * 100.)
}
SelfUpdate::Ready(v) => {
format!("{} · {v} is ready, restart to use it", backend::VERSION)
}
SelfUpdate::Ready(v) => format!("Updated to {v}. Restart the launcher to use it."),
SelfUpdate::Failed(e) => format!("{} · the update failed: {e}", backend::VERSION),
SelfUpdate::Idle => match &self.updates.launcher {
Some(r) => format!(
@@ -1531,8 +1542,12 @@ impl Launcher {
};
let launcher_action = match &self.self_update {
SelfUpdate::Ready(_) => Some(
button("restart-settings", "Restart", Kind::Secondary, &t)
.on_click(|_, _, _| backend::restart()),
button("restart-settings", "Restart", Kind::Secondary, &t).on_click(cx.listener(
|this, _: &ClickEvent, _, cx| {
this.self_update = SelfUpdate::Failed(backend::restart());
cx.notify();
},
)),
),
SelfUpdate::Downloading(..) => None,
_ => Some(
+24 -5
View File
@@ -24,7 +24,7 @@ fn tools() -> Value {
"inputSchema": { "type": "object", "properties": { "tag": { "type": "string", "description": "A release tag such as v2026.10.13, or \"latest\"." } }, "required": ["tag"] } },
{ "name": "remove_version", "description": "Remove an installed Horizon version and its prepared resources.",
"inputSchema": { "type": "object", "properties": { "tag": { "type": "string" } }, "required": ["tag"] } },
{ "name": "prepare_resources", "description": "Prepare a version's resources from the player's own Minecraft install (needs Minecraft 26.3 played once in the official launcher, Java 25 and Python 3.10+). Can take several minutes; returns the end of the log.",
{ "name": "prepare_resources", "description": "Prepare a version's resources from the player's own Minecraft install (needs Minecraft 26.3 played once in the official launcher and Java 25; versions before horizon-prepare also need Python 3.10+). Can take several minutes; returns the end of the log.",
"inputSchema": { "type": "object", "properties": { "version": version, "minecraft_dir": { "type": "string", "description": "The official launcher's game folder. Default: the launcher's setting, else the platform default." } } } },
{ "name": "launch_client", "description": "Start the Horizon client (a game window on the player's screen). Returns once it has started.",
"inputSchema": { "type": "object", "properties": { "version": version } } },
@@ -95,10 +95,29 @@ impl Session {
let tag = backend::resolve_version(arg_str(args, "version"))?;
let minecraft =
backend::minecraft_dir(arg_str(args, "minecraft_dir").map(PathBuf::from))?;
let cmd = backend::prepare_command(&tag, &minecraft, &|_| {})?;
let run = Logged::start(Job::Prepare, cmd)?;
let result = run.wait();
let tail = run.tail(20).join("\n");
let (result, tail) = match backend::preparer(&tag, &minecraft, &|_| {})? {
backend::Preparer::Process(cmd) => {
let run = Logged::start(Job::Prepare, cmd)?;
let result = run.wait();
(result, run.tail(20).join("\n"))
}
backend::Preparer::InProcess(options) => {
let lines = std::cell::RefCell::new(std::collections::VecDeque::new());
let result = backend::prepare_in_process(&options, &|line| {
let mut lines = lines.borrow_mut();
lines.push_back(line);
if lines.len() > 20 {
lines.pop_front();
}
});
let tail = lines
.into_inner()
.into_iter()
.collect::<Vec<_>>()
.join("\n");
(result, tail)
}
};
result
.map(|_| format!("{tag} is prepared.\n{tail}"))
.map_err(|e| format!("{e}\n{tail}"))
@@ -0,0 +1,82 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.lang.reflect.*;
import java.nio.file.*;
import java.util.*;
import net.minecraft.SharedConstants;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.particles.ParticleOptions;
import net.minecraft.core.particles.ParticleTypes;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.Identifier;
import net.minecraft.server.Bootstrap;
import net.minecraft.util.ParticleUtils;
import net.minecraft.util.RandomSource;
import net.minecraft.util.valueproviders.UniformInt;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.animal.cow.Cow;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.phys.Vec3;
/** Runs the real particle emitters of level events 3002 to 3005 (ParticleUtils
* spawnParticlesOnBlockFaces and spawnParticlesAlongAxis, as LevelEventHandler
* calls them) and LivingEntity.spawnItemParticles (eating, drinking, breaking)
* against a stand-in level that records what they spawn. */
public final class VanillaEmitterParticlesOracle {
static String d(double v) { return String.format("%016x", Double.doubleToRawLongBits(v)); }
static Field field(Class<?> type, String name) throws Exception {
var f = type.getDeclaredField(name); f.setAccessible(true); return f;
}
static final class Level0 extends ClientLevel {
List<String> events;
Level0() { super(null, null, null, null, 0, 0, null, false, 0L, 0); }
@Override public void addParticle(ParticleOptions o, double x, double y, double z, double xd, double yd, double zd) {
events.add("+ " + BuiltInRegistries.PARTICLE_TYPE.getKey(o.getType()).getPath() + " " + d(x) + " " + d(y) + " " + d(z)
+ " " + d(xd) + " " + d(yd) + " " + d(zd));
}
}
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion(); Bootstrap.bootStrap(); ParityData.init();
var u = Class.forName("sun.misc.Unsafe"); var unsafe = field(u, "theUnsafe").get(null);
var allocate = u.getMethod("allocateInstance", Class.class);
var level = (Level0) allocate.invoke(unsafe, Level0.class); level.events = new ArrayList<>();
Field levelRandom = field(Level.class, "random");
Field levelField = field(Entity.class, "level"), position = field(Entity.class, "position"), random = field(Entity.class, "random"),
xRot = field(Entity.class, "xRot"), yRot = field(Entity.class, "yRot"), eyeHeight = field(Entity.class, "eyeHeight");
try (var output = Files.newBufferedWriter(Path.of(args[1]))) {
int n = 0;
for (String line : Files.readAllLines(Path.of(args[0]))) {
var c = JsonParser.parseString(line).getAsJsonObject();
output.write("== " + n++); output.newLine();
level.events.clear();
var r = RandomSource.create(c.get("seed").getAsLong());
var p = c.getAsJsonArray("pos");
var kind = c.get("kind").getAsString();
if (kind.equals("item_use")) {
var entity = (Cow) allocate.invoke(unsafe, Cow.class);
levelField.set(entity, level);
position.set(entity, new Vec3(p.get(0).getAsDouble(), p.get(1).getAsDouble(), p.get(2).getAsDouble()));
random.set(entity, r);
xRot.setFloat(entity, c.get("pitch").getAsFloat());
yRot.setFloat(entity, c.get("yaw").getAsFloat());
eyeHeight.setFloat(entity, c.get("eye").getAsFloat());
var item = BuiltInRegistries.ITEM.getValue(Identifier.parse(c.get("item").getAsString()));
entity.spawnItemParticles(new ItemStack(item), c.get("count").getAsInt());
} else {
levelRandom.set(level, r);
var pos = new BlockPos(p.get(0).getAsInt(), p.get(1).getAsInt(), p.get(2).getAsInt());
int axis = c.get("axis").getAsInt();
if (axis >= 0) ParticleUtils.spawnParticlesAlongAxis(Direction.Axis.VALUES[axis], level, pos, 0.125, ParticleTypes.ELECTRIC_SPARK, UniformInt.of(10, 19));
else ParticleUtils.spawnParticlesOnBlockFaces(level, pos, ParticleTypes.WAX_ON, UniformInt.of(3, 5));
}
for (var e : level.events) { output.write(e); output.newLine(); }
output.write("next " + r.nextLong()); output.newLine();
}
}
}
}
@@ -0,0 +1,78 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.lang.reflect.*;
import java.nio.file.*;
import java.util.*;
import net.minecraft.SharedConstants;
import net.minecraft.client.multiplayer.ClientLevel;
import net.minecraft.core.particles.ParticleOptions;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.server.Bootstrap;
import net.minecraft.util.RandomSource;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityDimensions;
import net.minecraft.world.entity.animal.allay.Allay;
import net.minecraft.world.entity.animal.camel.Camel;
import net.minecraft.world.entity.animal.cow.Cow;
import net.minecraft.world.entity.animal.dolphin.Dolphin;
import net.minecraft.world.entity.animal.equine.Horse;
import net.minecraft.world.entity.animal.equine.Llama;
import net.minecraft.world.entity.animal.feline.Cat;
import net.minecraft.world.entity.animal.feline.Ocelot;
import net.minecraft.world.entity.animal.nautilus.Nautilus;
import net.minecraft.world.entity.animal.parrot.Parrot;
import net.minecraft.world.entity.animal.wolf.Wolf;
import net.minecraft.world.entity.npc.villager.Villager;
import net.minecraft.world.phys.Vec3;
/** Calls the real client handleEntityEvent of entities whose events are particle
* bursts about their body, and records what they ask the level to spawn. The
* entities are allocated without constructors and given only a level stand-in,
* a position, dimensions and their random, which is all those handlers read. */
public final class VanillaEntityParticlesOracle {
static String d(double v) { return String.format("%016x", Double.doubleToRawLongBits(v)); }
static Field field(Class<?> type, String name) throws Exception {
var f = type.getDeclaredField(name); f.setAccessible(true); return f;
}
static final class Level0 extends ClientLevel {
List<String> events;
Level0() { super(null, null, null, null, 0, 0, null, false, 0L, 0); }
@Override public void addParticle(ParticleOptions o, double x, double y, double z, double xd, double yd, double zd) {
events.add("+ " + BuiltInRegistries.PARTICLE_TYPE.getKey(o.getType()).getPath() + " " + d(x) + " " + d(y) + " " + d(z)
+ " " + d(xd) + " " + d(yd) + " " + d(zd));
}
}
static final Map<String, Class<? extends Entity>> TYPES = Map.ofEntries(
Map.entry("villager", Villager.class), Map.entry("cow", Cow.class), Map.entry("wolf", Wolf.class),
Map.entry("cat", Cat.class), Map.entry("parrot", Parrot.class), Map.entry("horse", Horse.class),
Map.entry("llama", Llama.class), Map.entry("camel", Camel.class), Map.entry("ocelot", Ocelot.class),
Map.entry("dolphin", Dolphin.class), Map.entry("allay", Allay.class), Map.entry("nautilus", Nautilus.class));
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion(); Bootstrap.bootStrap();
var u = Class.forName("sun.misc.Unsafe"); var unsafe = field(u, "theUnsafe").get(null);
var allocate = u.getMethod("allocateInstance", Class.class);
var level = (Level0) allocate.invoke(unsafe, Level0.class); level.events = new ArrayList<>();
Field levelField = field(Entity.class, "level"), position = field(Entity.class, "position"),
dimensions = field(Entity.class, "dimensions"), random = field(Entity.class, "random");
try (var output = Files.newBufferedWriter(Path.of(args[1]))) {
int n = 0;
for (String line : Files.readAllLines(Path.of(args[0]))) {
var c = JsonParser.parseString(line).getAsJsonObject();
output.write("== " + n++); output.newLine();
var entity = (Entity) allocate.invoke(unsafe, TYPES.get(c.get("entity").getAsString()));
var feet = c.getAsJsonArray("feet");
levelField.set(entity, level);
position.set(entity, new Vec3(feet.get(0).getAsDouble(), feet.get(1).getAsDouble(), feet.get(2).getAsDouble()));
dimensions.set(entity, EntityDimensions.scalable(c.get("width").getAsFloat(), c.get("height").getAsFloat()));
var r = RandomSource.create(c.get("seed").getAsLong());
random.set(entity, r);
level.events.clear();
entity.handleEntityEvent((byte) c.get("event").getAsInt());
for (var e : level.events) { output.write(e); output.newLine(); }
output.write("next " + r.nextLong()); output.newLine();
}
}
}
}
@@ -198,6 +198,7 @@ public final class VanillaParticleProvidersOracle {
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion(); Bootstrap.bootStrap();
ParityData.init(); // item components, for the item particle providers' stacks
var u = Class.forName("sun.misc.Unsafe"); unsafe = field(u, "theUnsafe").get(null); allocate = u.getMethod("allocateInstance", Class.class);
var mc = make(Minecraft.class); field(Minecraft.class, "instance").set(null, mc);
var manager = make(ModelManager.class); field(ModelManager.class, "blockStateModelSet").set(manager, new Models());
@@ -74,8 +74,9 @@ public final class VanillaSceneMotionOracle {
return VanillaBlockLandingOracle.sound(s);
}
static final class Sources extends DamageSources {
DamageSource fall,stalagmite,starve,freeze;Sources(){super(null);}
DamageSource fall,stalagmite,starve,freeze,sweetBerryBush;Sources(){super(null);}
@Override public DamageSource freeze(){return freeze;}
@Override public DamageSource sweetBerryBush(){return sweetBerryBush;}
@Override public DamageSource starve(){return starve;}
@Override public DamageSource fall(){return fall;}
@Override public DamageSource stalagmite(){return stalagmite;}
@@ -188,7 +189,9 @@ public final class VanillaSceneMotionOracle {
@Override public boolean isAutoSpinAttack(){return false;}
@Override public boolean isSpectator(){return false;}
@Override public boolean isNoGravity(){return false;}
@Override public boolean hasEffect(Holder<MobEffect> effect){return false;}
// No effects but Weaving (WebBlock.entityInside), set without the effect's callbacks.
boolean weaving;
@Override public boolean hasEffect(Holder<MobEffect> effect){return weaving&&effect==net.minecraft.world.effect.MobEffects.WEAVING;}
@Override public MobEffectInstance getEffect(Holder<MobEffect> effect){return null;}
@Override public MoveSimulationType getMoveSimulationType(){return MoveSimulationType.SERVER_AND_CLIENT;}
@Override public boolean isClientAuthoritative(){return false;}
@@ -205,7 +208,7 @@ public final class VanillaSceneMotionOracle {
String name=stat==net.minecraft.stats.Stats.DAMAGE_ABSORBED?"absorbed":stat==net.minecraft.stats.Stats.DAMAGE_TAKEN?"taken":stat==net.minecraft.stats.Stats.DAMAGE_RESISTED?"resisted":null;
if(name==null){name=stat.getPath();if(!Set.of("swim_one_cm","walk_under_water_one_cm","walk_on_water_one_cm","climb_one_cm","sprint_one_cm","crouch_one_cm","walk_one_cm","aviate_one_cm","fly_one_cm").contains(name))throw new AssertionError(stat);}events.add("health-stat "+name+" "+value);
}
@Override public boolean hurtServer(net.minecraft.server.level.ServerLevel level,DamageSource source,float damage){var sources=((Level)level).sources;events.add(String.format("damage %s %08x",source==sources.fall?"fall":source==sources.stalagmite?"stalagmite":source==sources.starve?"starve":source==sources.freeze?"freeze":"unknown",Float.floatToIntBits(damage)));return super.hurtServer(level,source,damage);}
@Override public boolean hurtServer(net.minecraft.server.level.ServerLevel level,DamageSource source,float damage){var sources=((Level)level).sources;events.add(String.format("damage %s %08x",source==sources.fall?"fall":source==sources.stalagmite?"stalagmite":source==sources.starve?"starve":source==sources.freeze?"freeze":source==sources.sweetBerryBush?"sweet_berry_bush":"unknown",Float.floatToIntBits(damage)));return super.hurtServer(level,source,damage);}
@Override public void teleportRelative(double x,double y,double z){setPos(getX()+x,getY()+y,getZ()+z);}
@Override protected void playStepSound(BlockPos p,BlockState state){}
@Override public void gameEvent(Holder<GameEvent> event,Entity source){}
@@ -283,7 +286,7 @@ public final class VanillaSceneMotionOracle {
var trace=new Trace();trace.out=new PrintWriter(OutputStream.nullOutputStream());trace.fail=-1;
var level=(Level)allocate.invoke(unsafe,Level.class);level.chunks=VanillaSceneCollisionOracle.scene(description,trace);level.border=new Border();
level.rng=net.minecraft.util.RandomSource.create(0);level.sources=(Sources)allocate.invoke(unsafe,Sources.class);
level.sources.fall=damageSources.get("minecraft:fall");level.sources.stalagmite=damageSources.get("minecraft:stalagmite");level.sources.starve=damageSources.get("minecraft:starve");level.sources.freeze=damageSources.get("minecraft:freeze");
level.sources.fall=damageSources.get("minecraft:fall");level.sources.stalagmite=damageSources.get("minecraft:stalagmite");level.sources.starve=damageSources.get("minecraft:starve");level.sources.freeze=damageSources.get("minecraft:freeze");level.sources.sweetBerryBush=damageSources.get("minecraft:sweet_berry_bush");
level.waypoints=(Waypoints)allocate.invoke(unsafe,Waypoints.class);level.waypoints.level=level;
level.rules=new Rules();level.difficulty=net.minecraft.world.Difficulty.NORMAL;
var server=(VanillaBlockLandingOracle.Server)allocate.invoke(unsafe,VanillaBlockLandingOracle.Server.class);
@@ -370,6 +373,8 @@ public final class VanillaSceneMotionOracle {
((EntityEquipment)field(LivingEntity.class,"equipment").get(p)).set(net.minecraft.world.entity.EquipmentSlot.FEET,stack);
}
case "frozen"->p.frozen=op.get("value").getAsInt();
case "weaving"->p.weaving=op.get("value").getAsBoolean();
case "flying"->{var a=p.getAbilities();a.mayfly=a.flying=op.get("value").getAsBoolean();}
case "trigger"->trigger.setInt(p,op.get("value").getAsInt());
case "delay"->delay.setInt(p,op.get("value").getAsInt());
case "ack_attributes"->{p.attrs.getAttributesToUpdate().clear();p.attrs.getAttributesToSync().clear();}
+4 -5
View File
@@ -17,11 +17,10 @@ Downloaded this archive directly?
More about Horizon: https://playhorizon.dev
To prepare this folder by hand you need Minecraft Java Edition 26.3, played
once from the official launcher, Python 3.10+ and Java 25 (a JDK). Then,
in this folder:
python3 tools/prepare_native_client.py --prepare --server-jar PATH/TO/server.jar
python3 tools/fetch_sounds.py (optional, for sound)
(Windows: py instead of python3.) The 26.3 server jar is the
once from the official launcher, and Java 25 (a JDK). Then, in this folder:
./horizon-prepare --prepare --server-jar PATH/TO/server.jar
python3 tools/fetch_sounds.py (optional, for sound; needs Python 3.10+)
(Windows: horizon-prepare.exe, and py instead of python3.) The 26.3 server jar is the
downloads.server.url in your launcher's versions/26.3/26.3.json. Add
--minecraft-dir PATH if your launcher keeps the game elsewhere. Then run
./horizon-client (horizon-client.exe on Windows; on macOS the first time:
+16 -11
View File
@@ -1,7 +1,8 @@
#!/usr/bin/env bash
# packaging/package.sh BINARY OUTDIR: a playable Horizon folder with the game
# binary, horizon-ctl (built beside it: cargo build --release -p horizon-client --bins),
# the resource preparation tool and what it compiles, and PLAY.txt.
# binary, horizon-ctl and horizon-prepare (built beside it: cargo build --release
# -p horizon-client --bins -p horizon-prepare), the exporters horizon-prepare compiles,
# its sources (the launcher compares them to its own), and PLAY.txt.
# It holds none of Minecraft's files: players prepare those from their own copy.
set -euo pipefail
bin=$1
@@ -9,14 +10,18 @@ out=$2
repo=$(git -C "$(dirname "$0")" rev-parse --show-toplevel)
rm -rf "$out"
mkdir -p "$out"
git -C "$repo" archive HEAD tools mods/horizon/src/test/java research-lock.json LICENSE | tar -x -C "$out"
git -C "$repo" archive HEAD tools mods/horizon/src/test/java crates/horizon-prepare research-lock.json LICENSE \
| tar -x -C "$out"
cp "$bin" "$out/"
# horizon-ctl, the command line and MCP server that play the game, sits beside the client.
ctl="$(dirname "$bin")/horizon-ctl"
case "$bin" in *.exe) ctl="$ctl.exe" ;; esac
if [ ! -f "$ctl" ]; then
echo "package.sh: $ctl is missing; build it too: cargo build --release -p horizon-client --bins" >&2
exit 1
fi
cp "$ctl" "$out/"
# horizon-ctl, the command line and MCP server that play the game, and horizon-prepare, which
# prepares the resources from the player's own Minecraft, sit beside the client.
for tool in horizon-ctl horizon-prepare; do
path="$(dirname "$bin")/$tool"
case "$bin" in *.exe) path="$path.exe" ;; esac
if [ ! -f "$path" ]; then
echo "package.sh: $path is missing; build it too: cargo build --release -p horizon-client --bins -p horizon-prepare" >&2
exit 1
fi
cp "$path" "$out/"
done
cp "$repo/packaging/PLAY.txt" "$out/PLAY.txt"
+156
View File
@@ -0,0 +1,156 @@
#!/usr/bin/env python3
"""Check that horizon-prepare (Rust) writes what the Python preparer wrote.
Prepares the same jars three times in fresh folders made from the same tree (research-lock.json
and the vanilla exporters of --python-ref): twice with that ref's tools/prepare_native_client.py
and once with horizon-prepare. Every file under .local/ is compared by sha256:
- identical: the same bytes in all three runs;
- exporter noise: differs between the two Python runs too, so the vanilla Java exporter itself
writes it differently each run (lambda addresses, hash-set order), not the preparer;
- port differences: identical between the Python runs but not in the Rust run. There must be none.
The manifest (horizon-resources.json) is compared field by field: only the recorded hashes of
exporter-noise files may differ, and each must be the hash of its own run's file.
Then each preparer runs again over the other's output (Rust over a Python tree, Python over the
Rust tree): the manifests are read the same way, so nothing is exported again and no resource
changes. Development tool: it needs Python 3.11+, Java and git. Report: <work>/report.json.
"""
import argparse
import hashlib
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import time
ROOT = Path(__file__).resolve().parents[1]
# The last commit whose tools/prepare_native_client.py is the Python preparer itself.
PYTHON_REF = '66ce394d2d6dc19ed5f5c53a97b650741af9be76'
# Written by tools the comparison is not about: the decompiler only lab.py fetches, logs with
# times in them, compiled classes, and the data generator's own dated cache.
IGNORED_PARTS = {'classes', 'client-classes', 'logs', '.cache'}
def tree(ref, destination, archive=None):
"""The preparer's inputs at `ref`: research-lock.json, the exporters and the Python preparer."""
destination.mkdir(parents=True)
if archive is None:
archive = subprocess.run(['git', '-C', str(ROOT), 'archive', ref, 'tools', 'mods/horizon/src/test/java',
'research-lock.json'], check=True, capture_output=True).stdout
else:
archive = archive.read_bytes()
subprocess.run(['tar', '-x', '-C', str(destination)], input=archive, check=True)
def hashes(folder):
local = folder / '.local'
result = {}
for path in sorted(local.rglob('*')):
relative = path.relative_to(local)
if path.is_file() and not (set(relative.parts) & IGNORED_PARTS) and path.suffix != '.log':
result[relative.as_posix()] = hashlib.sha256(path.read_bytes()).hexdigest()
return result
def run(name, command, cwd, log):
started = time.monotonic()
with log.open('w') as stream:
subprocess.run(command, cwd=cwd, check=True, stdout=stream, stderr=subprocess.STDOUT)
seconds = round(time.monotonic() - started, 1)
print(f'{name}: {seconds} s', flush=True)
return seconds
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--server-jar', type=Path, required=True)
parser.add_argument('--minecraft-dir', type=Path, required=True)
parser.add_argument('--python-ref', default=PYTHON_REF)
parser.add_argument('--python-tree', type=Path,
help='a tar of that tree instead of git (git archive REF tools mods/horizon/src/test/java '
'research-lock.json), for a machine without the repository')
parser.add_argument('--binary', type=Path, help='horizon-prepare to test (default: cargo build --release)')
parser.add_argument('--work', type=Path, default=ROOT / '.local/compare-prepare')
parser.add_argument('--keep', action='store_true', help='keep the prepared folders')
args = parser.parse_args()
binary = args.binary
if binary is None:
subprocess.run(['cargo', 'build', '--release', '-p', 'horizon-prepare'], cwd=ROOT, check=True)
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
cwd=ROOT, text=True))
binary = Path(metadata['target_directory']) / 'release' / (
'horizon-prepare.exe' if os.name == 'nt' else 'horizon-prepare')
binary = binary.resolve()
work = args.work.resolve()
shutil.rmtree(work, ignore_errors=True)
work.mkdir(parents=True)
game = ['--prepare', '--server-jar', str(args.server_jar.resolve()),
'--minecraft-dir', str(args.minecraft_dir.resolve())]
python = [sys.executable, '-u', 'tools/prepare_native_client.py', *game]
folders = {name: work / name for name in ['python-1', 'python-2', 'rust']}
times = {}
for name, folder in folders.items():
tree(args.python_ref, folder, args.python_tree)
command = [str(binary), '--root', str(folder), *game] if name == 'rust' else python
times[name] = run(name, command, folder, work / f'{name}.log')
first, second, rust = (hashes(folders[n]) for n in ['python-1', 'python-2', 'rust'])
names = sorted(first.keys() | second.keys() | rust.keys())
identical = [n for n in names if first.get(n) == second.get(n) == rust.get(n) is not None]
noise = [n for n in names if first.get(n) != second.get(n)]
port = [n for n in names if n not in identical and n not in noise]
# Only lab.py fetches the decompiler; preparing does not need it.
port = [n for n in port if not (n.startswith('tools/vineflower-') and n not in rust)]
manifest = 'horizon-client/' + json.loads((folders['rust'] / 'research-lock.json').read_text())[
'minecraft']['version'] + '/horizon-resources.json'
noisy = {n.rsplit('/', 1)[-1] for n in noise if n.startswith(manifest.rsplit('/', 1)[0] + '/')}
manifests = {n: json.loads((folders[n] / '.local' / manifest).read_text()) for n in folders}
manifest_differences = []
def walk(python, candidate, path):
if isinstance(python, dict) and isinstance(candidate, dict) and list(python) == list(candidate):
for key in python:
walk(python[key], candidate[key], path + [key])
elif python != candidate:
name = path[-1]
expected = hashlib.sha256((folders['rust'] / '.local' / manifest).with_name(name).read_bytes()).hexdigest() \
if name in noisy else None
if not (name in noisy and candidate == expected):
manifest_differences.append('.'.join(path))
walk(manifests['python-1'], manifests['rust'], [])
if manifest in port and not manifest_differences:
port.remove(manifest)
# Each preparer over the other's output: nothing to export again, no resource changes.
resources = 'horizon-client/'
before = {'python-2': second, 'rust': rust}
times['rust over python'] = run('rust over python', [str(binary), '--root', str(folders['python-2']), *game],
folders['python-2'], work / 'rust-over-python.log')
times['python over rust'] = run('python over rust', python, folders['rust'], work / 'python-over-rust.log')
rerun_changes = {}
for name in before:
after = hashes(folders[name])
changed = [n for n in sorted(before[name].keys() | after.keys())
if n.startswith(resources) and before[name].get(n) != after.get(n)]
rerun_changes[name] = changed
exported_again = {name: [line.strip() for line in (work / log).read_text().splitlines() if 'Exporting' in line]
for name, log in [('rust over python', 'rust-over-python.log')]}
report = {'python_ref': args.python_ref, 'binary': str(binary), 'seconds': times,
'files': len(names), 'identical': len(identical), 'exporter_noise': noise,
'port_differences': port, 'manifest_differences': manifest_differences,
'rerun_resource_changes': rerun_changes, 'exported_again': exported_again}
(work / 'report.json').write_text(json.dumps(report, indent=2) + '\n')
print(json.dumps(report, indent=2))
if not args.keep:
for folder in folders.values():
shutil.rmtree(folder, ignore_errors=True)
ok = not port and not manifest_differences
print('identical output' if ok else 'DIFFERENT OUTPUT', flush=True)
return 0 if ok else 1
if __name__ == '__main__':
sys.exit(main())
+1 -1
View File
@@ -85,7 +85,7 @@ def main():
if not args.binary.is_file():
raise SystemExit(f'missing {args.binary}: run cargo build --release -p horizon-client')
if not (args.resources / 'horizon-resources.json').is_file():
raise SystemExit(f'missing prepared resources in {args.resources}: run tools/prepare_native_client.py --prepare')
raise SystemExit(f'missing prepared resources in {args.resources}: run horizon-prepare --prepare (cargo run --release -p horizon-prepare -- --prepare)')
if not (args.resources / 'assets/minecraft/sounds.json').is_file():
print('warning: no sound assets; run tools/fetch_sounds.py for audio')
+17 -446
View File
@@ -1,457 +1,28 @@
#!/usr/bin/env python3
"""Prepare private pinned resources for Horizon's native development client."""
import argparse
import json
"""Prepare private pinned resources for Horizon's native development client.
The preparation itself is horizon-prepare (crates/horizon-prepare), the Rust port of what this
script did; this wrapper keeps its command line for the development tools that call it. It runs
the horizon-prepare beside this folder (a release folder), else builds it with cargo. Arguments
are passed through: --prepare, --server-jar PATH, --minecraft-dir PATH.
"""
import os
from pathlib import Path
import subprocess
import zipfile
try:
from . import lab, test_rust_parity as base, test_worldgen_parity as worldgen, test_model_baking_parity as baking
except ImportError:
import lab
import test_rust_parity as base
import test_worldgen_parity as worldgen
import test_model_baking_parity as baking
import sys
WORLDGEN_BUNDLES = {
'noises': 'worldgen/noise', 'densities': 'worldgen/density_function', 'rules': 'worldgen/material_rule',
'conditions': 'worldgen/material_condition', 'settings': 'worldgen/noise_settings', 'carvers': 'worldgen/carver',
'biomes': 'worldgen/biome', 'world_presets': 'worldgen/world_preset', 'features': 'worldgen/feature',
'placed_features': 'worldgen/placed_feature', 'state_providers': 'worldgen/block_state_provider',
'biome_tags': 'tags/worldgen/biome', 'feature_tags': 'tags/worldgen/feature', 'block_tags': 'tags/block',
'fluid_tags': 'tags/fluid', 'processor_lists': 'worldgen/processor_list',
'template_pools': 'worldgen/template_pool', 'structures': 'worldgen/structure',
'structure_sets': 'worldgen/structure_set'}
def export_structure_blocks(target, jars, libraries):
"""Run the vanilla exporter of per-state rotate/mirror results and template flags."""
lock = json.loads((lab.ROOT/'research-lock.json').read_text())
source = lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStructureBlockExporter.java'
export = lab.LOCAL/'horizon-client-structures'
classes = export/'classes'
classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (export/'export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-cp', dependencies,
'-d', str(classes), str(source)], check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.VanillaStructureBlockExporter', str(target)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
BLOCK_BEHAVIOR_FILES = ['block-properties.nbt', 'cached-collision.nbt', 'cached-support.nbt', 'survival-rules.json',
'survival-extra-definitions.json', 'placement-definitions.json']
def export_block_behavior(export, jars, libraries):
"""Run the vanilla exporters of block properties, support, collision and survival definitions.
Feature placement needs them: without these files the generator skips every placed feature
whose blocks are checked for survival or support (trees, flowers, grass, kelp, ...)."""
try:
from . import test_block_survival_parity as survival
except ImportError:
import test_block_survival_parity as survival
lock = json.loads((lab.ROOT/'research-lock.json').read_text())
tests = lab.ROOT/'mods/horizon/src/test/java'
classes = export/'classes'
classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (export/'export.log').open('w') as log:
# The oracle's helper classes are compiled on demand from the source path.
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-cp', dependencies,
'-sourcepath', str(tests), '-d', str(classes),
str(tests/'dev/horizonlab/parity/VanillaSimpleBlockOracle.java')],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.VanillaSimpleBlockOracle', 'export', str(export)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
rules = survival.bind_definitions(*[json.loads((export/name).read_text()) for name in
['survival-classes.json', 'survival-placement-classes.json',
'survival-support-tags.json']])
(export/'survival-rules.json').write_text(json.dumps(rules, separators=(',', ':')))
def prepare_worldgen(root, jars, local, libraries=None):
"""Write the chunk generator's resource bundle to root/worldgen (see GeneratorData::load)."""
out = root / 'worldgen'
out.mkdir(exist_ok=True)
# Structure templates: gzip NBT files under structure/<namespace>/<path>.nbt.
with zipfile.ZipFile(jars['server']) as server:
prefix = 'data/minecraft/structure/'
for name in server.namelist():
if name.startswith(prefix) and name.endswith('.nbt'):
relative = Path(name[len(prefix):])
if relative.is_absolute() or '..' in relative.parts:
raise ValueError('Invalid structure path')
target = out/'structure'/'minecraft'/relative
data = server.read(name)
if not target.exists() or target.read_bytes() != data:
target.parent.mkdir(parents=True, exist_ok=True)
target.write_bytes(data)
with zipfile.ZipFile(jars['server']) as server, zipfile.ZipFile(jars['client']) as client:
for name, path in WORLDGEN_BUNDLES.items():
prefix = f'data/minecraft/{path}/'
def extract(archive):
return {'minecraft:'+n[len(prefix):-5]: archive.read(n).decode('utf-8')
for n in sorted(archive.namelist()) if n.startswith(prefix) and n.endswith('.json')}
resources = extract(server)
if not resources or resources != extract(client):
raise ValueError('Reference worldgen resources disagree: '+path)
(out/(name+'.json')).write_text(json.dumps(resources, separators=(',', ':')), encoding='utf-8')
facts = json.loads((root/'facts.json').read_text())
(out/'block_flags.json').write_text(json.dumps([[s[1], s[2]] for s in facts['states']], separators=(',', ':')))
reports = out/'biome_parameters'
reports.mkdir(exist_ok=True)
presets = reports
for source in [root/'biome-parameters', local/'datagen/out/reports/biome_parameters/minecraft']:
if (source/'overworld.json').exists():
for report in sorted(source.glob('*.json')):
(reports/report.name).write_bytes(report.read_bytes())
break
else:
presets = None
# Block behavior used by feature placement checks (survival, support, collision).
# These come from the Java exporters of the simple-block parity run, or a direct export.
behavior = local/'rust-simple-block-parity'
blocks = out/'blocks'
names = BLOCK_BEHAVIOR_FILES
if libraries is not None and not all((behavior/name).exists() for name in names):
behavior = local/'horizon-client-block-behavior'
export_block_behavior(behavior, jars, libraries)
if all((behavior/name).exists() for name in names):
blocks.mkdir(exist_ok=True)
for name in names:
(blocks/name).write_bytes((behavior/name).read_bytes())
if libraries is not None:
blocks.mkdir(exist_ok=True)
export_structure_blocks(blocks/'structure-blocks.json', jars, libraries)
else:
print('Feature block behavior exports missing; run tools/test_simple_block_parity.py for full decoration')
if presets is None:
# Fall back to the Java-exported quantized tables from the material-stage parity run.
presets = local/'rust-material-stage-parity/presets.json'
if not presets.exists():
raise FileNotFoundError('No multi-noise biome parameter tables; run the data generator reports')
(out/'presets.json').write_bytes(presets.read_bytes())
ROOT = Path(__file__).resolve().parents[1]
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--prepare', action='store_true',
help='Import the pinned game files from your own copy first')
lab.add_game_arguments(parser)
args = parser.parse_args()
if args.prepare:
lab.prepare(args.minecraft_dir, args.server_jar)
lock, jars, libraries = base.verify_artifacts()
root = lab.LOCAL / 'horizon-client' / lock['minecraft']['version']
root.mkdir(parents=True, exist_ok=True)
facts = root / 'facts.json'
manifest = root / 'horizon-resources.json'
oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeightmapOracle.java'
origin = {'minecraft': lock['minecraft']['version'],
'client_sha256': lab.digest(jars['client'], 'sha256'),
'server_sha256': lab.digest(jars['server'], 'sha256'),
'exporter_sha256': lab.digest(oracle, 'sha256')}
previous = json.loads(manifest.read_text()) if manifest.exists() else {}
if not (all(previous.get(k) == v for k, v in origin.items()) and facts.exists()
and previous.get('facts_sha256') == lab.digest(facts, 'sha256')):
classes = root / 'classes'
classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (root / 'export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(oracle)], check=True,
stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx512M', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaHeightmapOracle', 'export', str(facts)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
binding = oracle.with_name('VanillaBlockStateBindingOracle.java')
helper = oracle.with_name('VanillaCuboidModelOracle.java')
binding_sources = base.source_hashes([binding, helper])
model_states = root / 'model-states.json'
if not (previous.get('model_state_exporters_sha256') == binding_sources
and previous.get('client_sha256') == origin['client_sha256']
and model_states.exists()
and previous.get('model_states_sha256') == lab.digest(model_states, 'sha256')):
classes = root / 'client-classes'; classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['client'], *baking.client_libraries()]))
with (root / 'model-state-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(binding), str(helper)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx512M', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaBlockStateBindingOracle', 'export', str(model_states)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
tags = worldgen.tag_resources(jars['server'])
if tags != worldgen.tag_resources(jars['client']):
raise ValueError('Reference block tags disagree')
lab.write_json(root / 'block-tags.json', tags)
visibility = oracle.with_name('VanillaFaceVisibilityOracle.java')
collision = oracle.with_name('VanillaCollisionOracle.java')
collision_sources = base.source_hashes([collision])
movement = oracle.with_name('VanillaMovementRegistryOracle.java')
attributes = oracle.with_name('VanillaEntityAttributeOracle.java')
landing = oracle.with_name('VanillaBlockLandingOracle.java')
motion_sources = base.source_hashes([movement, attributes, oracle, landing, collision])
motion_files = ['movement-properties.nbt', 'attributes.json', 'landing-definitions.json']
if not (previous.get('motion_exporters_sha256') == motion_sources
and previous.get('server_sha256') == origin['server_sha256']
and previous.get('block_tags_sha256') == lab.digest(root/'block-tags.json', 'sha256')
and all((root/name).exists() and previous.get('motion_files_sha256', {}).get(name)
== lab.digest(root/name, 'sha256') for name in motion_files)):
export = lab.LOCAL/'horizon-client-motion'; export.mkdir(exist_ok=True)
lab.write_json(export/'tags.json', tags)
classes = export/'classes'; classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (export/'export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(movement), str(attributes), str(oracle), str(landing), str(collision)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
for name in ['VanillaBlockLandingOracle', 'VanillaEntityAttributeOracle']:
subprocess.run(['java', '-Xmx768M', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.'+name, 'export', str(export)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
(root/'movement-properties.nbt').write_bytes((export/'movement-properties.nbt').read_bytes())
(root/'attributes.json').write_bytes((export/'catalog.json').read_bytes())
(root/'landing-definitions.json').write_bytes((export/'landing-definitions.json').read_bytes())
damage = oracle.with_name('VanillaDamageSourceOracle.java')
health = oracle.with_name('VanillaPlayerHealthOracle.java')
health_sources = base.source_hashes([damage, health, attributes])
health_files = ['damage-types.json', 'damage-tags.json', 'damage-catalog.json', 'player-float-ids.json']
if not (previous.get('health_exporters_sha256') == health_sources
and previous.get('server_sha256') == origin['server_sha256']
and all((root/name).exists() and previous.get('health_files_sha256', {}).get(name)
== lab.digest(root/name, 'sha256') for name in health_files)):
export = lab.LOCAL/'horizon-client-health'; export.mkdir(exist_ok=True)
with zipfile.ZipFile(jars['server']) as archive, zipfile.ZipFile(jars['client']) as client_archive:
for file, prefix in [('types.json', 'data/minecraft/damage_type/'), ('tags.json', 'data/minecraft/tags/damage_type/')]:
def extract(source):
return {'minecraft:'+n[len(prefix):-5]: source.read(n).decode('utf-8')
for n in sorted(source.namelist()) if n.startswith(prefix) and n.endswith('.json')}
resources = extract(archive)
if resources != extract(client_archive): raise ValueError('Reference damage resources disagree')
lab.write_json(export/file, resources)
classes = export/'classes'; classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (export/'export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(damage), str(health), str(attributes)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
for name in ['VanillaPlayerHealthOracle', 'VanillaDamageSourceOracle']:
subprocess.run(['java', '-Xmx768M', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.'+name, 'export', str(export)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
for source, target in [('types.json','damage-types.json'), ('tags.json','damage-tags.json'),
('catalog.json','damage-catalog.json'), ('ids.json','player-float-ids.json')]:
(root/target).write_bytes((export/source).read_bytes())
collision_file = root / 'cached-collision.nbt'
if not (previous.get('collision_exporters_sha256') == collision_sources
and previous.get('server_sha256') == origin['server_sha256']
and collision_file.exists()
and previous.get('collision_sha256') == lab.digest(collision_file, 'sha256')):
export = lab.LOCAL/'horizon-client-collision'; export.mkdir(exist_ok=True)
classes = export/'classes'; classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (export/'export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(collision)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx768M', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.VanillaCollisionOracle', 'generate', str(export)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
collision_file.write_bytes((export/'cached-collision.nbt').read_bytes())
render_sources = base.source_hashes([visibility, collision, oracle])
render_files = ['render-definitions.json', 'occlusion.nbt']
tag_hash = lab.digest(root/'block-tags.json', 'sha256')
if not (previous.get('render_exporters_sha256') == render_sources
and previous.get('server_sha256') == origin['server_sha256']
and previous.get('block_tags_sha256') == tag_hash
and all((root/name).exists() and previous.get('render_files_sha256', {}).get(name)
== lab.digest(root/name, 'sha256') for name in render_files)):
export = lab.LOCAL/'horizon-client-render'; export.mkdir(exist_ok=True)
lab.write_json(export/'tags.json', tags)
classes = export/'classes'; classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (export/'export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(visibility), str(collision), str(oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx768M', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.VanillaFaceVisibilityOracle', 'export', str(export)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
(root/'render-definitions.json').write_bytes((export/'definitions.json').read_bytes())
(root/'occlusion.nbt').write_bytes((export/'occlusion.nbt').read_bytes())
count = 0
# The playable client needs every client asset (textures, models, fonts, GUI)
# and every data-pack resource (worldgen, recipes, loot tables, tags).
prefixes = ('assets/', 'data/')
with zipfile.ZipFile(jars['client']) as archive:
version = json.loads(archive.read('version.json'))
for name in archive.namelist():
if not name.startswith(prefixes) or name.endswith('/'):
continue
relative = Path(name)
if relative.is_absolute() or '..' in relative.parts:
raise ValueError('Invalid resource path')
target = root / relative
data = archive.read(name)
if not target.exists() or target.read_bytes() != data:
target.parent.mkdir(parents=True, exist_ok=True)
target.write_bytes(data)
count += 1
gameplay = root / 'gameplay-facts.json'
gameplay_oracle = oracle.with_name('VanillaGameplayFactsExporter.java')
gameplay_sources = base.source_hashes([gameplay_oracle])
if not (previous.get('gameplay_exporters_sha256') == gameplay_sources and gameplay.exists()
and previous.get('server_sha256') == origin['server_sha256']):
classes = lab.LOCAL / 'gameplay-facts' / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (root / 'gameplay-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(gameplay_oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaGameplayFactsExporter', str(gameplay)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
# Entity dimensions, categories and default attributes for the client's mobs.
entity_types = root / 'entity-types.json'
entity_types_oracle = oracle.with_name('VanillaEntityTypesExporter.java')
entity_types_sources = base.source_hashes([entity_types_oracle])
if not (previous.get('entity_types_exporters_sha256') == entity_types_sources and entity_types.exists()
and previous.get('server_sha256') == origin['server_sha256']):
classes = lab.LOCAL / 'entity-types' / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (root / 'entity-types-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(entity_types_oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaEntityTypesExporter', str(entity_types)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
# Block classes, instance configuration and per-state support/signal/fluid
# facts for horizon-world's level behaviour (level::Behaviours::load).
behaviours = root / 'block-behaviours.json'
behaviour_oracle = oracle.with_name('VanillaBlockBehaviourExporter.java')
behaviour_sources = base.source_hashes([behaviour_oracle])
if not (previous.get('behaviour_exporters_sha256') == behaviour_sources and behaviours.exists()
and previous.get('server_sha256') == origin['server_sha256']):
classes = lab.LOCAL / 'block-behaviours' / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (root / 'behaviour-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(behaviour_oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaBlockBehaviourExporter', str(behaviours)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
items = root / 'items.json'
if not items.exists() or previous.get('server_sha256') != origin['server_sha256']:
# Vanilla's own data generator reports every item's default components.
datagen = lab.LOCAL / 'datagen'; datagen.mkdir(exist_ok=True)
with (datagen / 'datagen.log').open('w') as log:
subprocess.run(['java', '-DbundlerMainClass=net.minecraft.data.Main', '-jar',
str(jars['server'].with_name('server.jar')), '--reports', '--output', 'out'],
cwd=datagen, check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
reports = datagen / 'out' / 'reports'
components = {f'minecraft:{f.stem}': json.loads(f.read_text())['components']
for f in sorted((reports / 'minecraft' / 'components' / 'item').glob('*.json'))}
items.write_text(json.dumps(components))
(root / 'biome-parameters').mkdir(exist_ok=True)
for f in (reports / 'biome_parameters' / 'minecraft').glob('*.json'):
(root / 'biome-parameters' / f.name).write_bytes(f.read_bytes())
# Biome parameter tables come from the data generator reports above.
prepare_worldgen(root, jars, lab.LOCAL, libraries)
entity_models = root / 'entity-models.json'
entity_oracle = oracle.with_name('VanillaEntityModelExporter.java')
entity_sources = base.source_hashes([entity_oracle])
if not (previous.get('entity_model_exporters_sha256') == entity_sources and entity_models.exists()
and previous.get('client_sha256') == origin['client_sha256']):
classes = lab.LOCAL / 'entity-models' / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['client'], *baking.client_libraries()]))
with (root / 'entity-model-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(entity_oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaEntityModelExporter', str(entity_models)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
# Mob AI and animation facts: per-state path types, spawn placements and the
# client's keyframe animation definitions (needs the client jar).
mob_data = root / 'mob-data.json'
mob_oracle = oracle.with_name('VanillaMobDataExporter.java')
mob_sources = base.source_hashes([mob_oracle])
if not (previous.get('mob_data_exporters_sha256') == mob_sources and mob_data.exists()
and previous.get('client_sha256') == origin['client_sha256']):
classes = lab.LOCAL / 'mob-data' / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['client'], *baking.client_libraries()]))
with (root / 'mob-data-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(mob_oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaMobDataExporter', str(mob_data), str(jars['client'])],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
# Vanilla's built-in registries for in-game command parsing (mob effects,
# data component types, dialogs, block entity and tag members).
command_registries = root / 'command-registries.json'
command_oracle = oracle.with_name('VanillaCommandParseOracle.java')
command_sources = base.source_hashes([command_oracle])
if not (previous.get('command_registries_exporters_sha256') == command_sources and command_registries.exists()
and previous.get('server_sha256') == origin['server_sha256']):
export = lab.LOCAL / 'command-registries'; classes = export / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (root / 'command-registries-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), str(command_oracle)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaCommandParseOracle', 'registries', str(export)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
command_registries.write_bytes((export / 'registries.json').read_bytes())
# The creative inventory (creative-inventory.json): every tab built by vanilla's
# CreativeModeTabs over the vanilla data pack's registries, with the search
# tab's tooltip lines and tags.
creative = root / 'creative-inventory.json'
creative_oracles = [oracle.with_name('VanillaCreativeTabsExporter.java'), oracle.with_name('ParityData.java')]
creative_sources = base.source_hashes(creative_oracles)
if not (previous.get('creative_exporters_sha256') == creative_sources and creative.exists()
and previous.get('server_sha256') == origin['server_sha256']):
classes = lab.LOCAL / 'creative-inventory' / 'classes'; classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
with (root / 'creative-export.log').open('w') as log:
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none',
'-cp', dependencies, '-d', str(classes), *map(str, creative_oracles)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
subprocess.run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaCreativeTabsExporter', str(creative)],
check=True, stdout=log, stderr=subprocess.STDOUT, timeout=3600)
lab.write_json(manifest, {'schema': 7, **origin,
'health_exporters_sha256': health_sources,
'health_files_sha256': {name: lab.digest(root/name, 'sha256') for name in health_files},
'motion_exporters_sha256': motion_sources,
'motion_files_sha256': {name: lab.digest(root/name, 'sha256') for name in motion_files},
'collision_exporters_sha256': collision_sources,
'collision_sha256': lab.digest(collision_file, 'sha256'),
'render_exporters_sha256': render_sources,
'render_files_sha256': {name: lab.digest(root/name, 'sha256') for name in render_files},
'model_state_exporters_sha256': binding_sources,
'gameplay_exporters_sha256': gameplay_sources,
'entity_model_exporters_sha256': entity_sources,
'creative_exporters_sha256': creative_sources,
'mob_data_exporters_sha256': mob_sources,
'entity_types_exporters_sha256': entity_types_sources,
'behaviour_exporters_sha256': behaviour_sources,
'command_registries_exporters_sha256': command_sources,
'model_states_sha256': lab.digest(model_states, 'sha256'), 'data_version': version['world_version'],
'facts_sha256': lab.digest(facts, 'sha256'),
'block_tags_sha256': lab.digest(root / 'block-tags.json', 'sha256'), 'resource_files': count})
print(f'Prepared Horizon native-client resources: {root}')
arguments = ['--root', str(ROOT), *sys.argv[1:]]
beside = ROOT / ('horizon-prepare.exe' if os.name == 'nt' else 'horizon-prepare')
if beside.is_file():
command = [str(beside), *arguments]
else:
command = ['cargo', 'run', '--quiet', '--release', '-p', 'horizon-prepare', '--', *arguments]
return subprocess.call(command, cwd=ROOT)
if __name__ == '__main__':
main()
sys.exit(main())
+1 -1
View File
@@ -45,7 +45,7 @@ def target(game_dir, name):
"""REA admits JADX targets by their .apk name; JADX reads the class files either way."""
source = game_dir / "jars" / f"{name}.jar"
if not source.exists():
raise SystemExit(f"{source} is missing; run python3 tools/prepare_native_client.py --prepare")
raise SystemExit(f"{source} is missing; run cargo run --release -p horizon-prepare -- --prepare")
copy = lab.LOCAL / "rea" / f"{name}-{lab.digest(source, 'sha256')[:16]}.apk"
if not copy.exists():
copy.parent.mkdir(parents=True, exist_ok=True)
+1 -1
View File
@@ -2,7 +2,7 @@
"""Compare the creative inventory's tabs and search with the vanilla client's.
The Java oracle (VanillaCreativeSearchOracle) writes the creative-inventory.json
that tools/prepare_native_client.py exports (VanillaCreativeTabsExporter: every
that horizon-prepare exports (VanillaCreativeTabsExporter: every
tab built by vanilla's CreativeModeTabs over the vanilla data pack's
registries), then what the vanilla client shows: every tab's display items
and, for each search query, CreativeModeInventoryScreen.refreshSearchResults'
+53
View File
@@ -0,0 +1,53 @@
#!/usr/bin/env python3
"""Compare particle emitters with the real vanilla ones: ParticleUtils
spawnParticlesOnBlockFaces and spawnParticlesAlongAxis as LevelEventHandler
calls them for level events 3002 (electric sparks), 3003 (wax on), 3004 (wax
off) and 3005 (scrape), and LivingEntity.spawnItemParticles (eating, drinking):
particle, count, positions, motion and every random draw."""
import json
import random
try:
from . import lab, oracle_harness as harness
except ImportError:
import lab, oracle_harness as harness
def cases(rng):
for _ in range(600):
pos = [rng.randrange(-30000, 30000), rng.randrange(-64, 320), rng.randrange(-30000, 30000)]
yield dict(kind='block', pos=pos, axis=rng.choice([-1, -1, 0, 1, 2]), seed=rng.randrange(-2**63, 2**63))
angles = [0.0, 90.0, -90.0, 45.0, -45.0, 180.0, -180.0, 12.5, 359.75, -721.5]
for _ in range(900):
# Dyadic values: serde_json's decimal parsing may round others a unit off.
pos = [rng.randrange(-2**20, 2**20) / 64 for _ in range(3)]
yield dict(kind='item_use', pos=pos, pitch=rng.choice(angles + [rng.randrange(-5760, 5760) / 64]),
yaw=rng.choice(angles + [rng.randrange(-23040, 23040) / 64]),
eye=rng.choice([1.62, 1.27, 0.4, 1.74]), count=rng.choice([5, 16, 1, 0]),
item=rng.choice(['minecraft:apple', 'minecraft:cooked_beef', 'minecraft:potion', 'minecraft:honey_bottle']),
seed=rng.randrange(-2**63, 2**63))
def make_cases(build):
path = build / 'cases.jsonl'
count = 0
with path.open('w') as out:
for case in cases(random.Random(0x454d4954)):
out.write(json.dumps(case, separators=(',', ':')) + '\n')
count += 1
return path, count
def main():
scope = ('The real ParticleUtils.spawnParticlesOnBlockFaces (UniformInt 3..5 per face) and spawnParticlesAlongAxis '
'(radius 0.125, UniformInt 10..19) on a stand-in level with a seeded random, as LevelEventHandler runs '
'them for level events 3002-3005, and the real LivingEntity.spawnItemParticles on an entity given a '
'position, rotation, eye height and seeded random. Which code sends those events, and the particles '
'once spawned, are covered elsewhere.')
harness.differential(
'rust-emitter-particles-parity', 'VanillaEmitterParticlesOracle', 'emitter_particles_probe', make_cases, scope,
sources=[lab.ROOT / 'crates/horizon-client/src/particles.rs'])
if __name__ == '__main__':
main()
+112
View File
@@ -0,0 +1,112 @@
#!/usr/bin/env python3
"""Compare the particle bursts entity events show on the client (villagers'
hearts, anger and happiness, love hearts, taming and trusting hearts and smoke,
the allay's and dolphin's) with the real handleEntityEvent of each entity:
particle, count, positions about the body, motion and every random draw."""
import json
import platform
import random
import struct
import subprocess
try:
from . import lab, oracle_harness as harness, test_rust_parity as base, test_model_baking_parity as baking
except ImportError:
import lab, oracle_harness as harness, test_rust_parity as base, test_model_baking_parity as baking
EVENTS = {
'villager': [12, 13, 14, 42],
'cow': [18], 'wolf': [6, 7, 18], 'cat': [6, 7, 18], 'parrot': [6, 7], 'nautilus': [6, 7, 18],
'horse': [6, 7, 18], 'llama': [6, 7, 18], 'camel': [6, 7, 18],
'ocelot': [40, 41, 18], 'dolphin': [38], 'allay': [18],
}
# Dyadic sizes and positions: serde_json's decimal parsing may round others a unit off.
SIZES = [(0.6, 1.95), (0.9, 1.4), (0.3, 0.85), (1.3964844, 1.6), (0.35, 0.6), (0.875, 0.9375)]
def cases(rng):
for entity, events in EVENTS.items():
for event in events:
for _ in range(40):
w, h = rng.choice(SIZES)
feet = [rng.randrange(-4096, 4096) / 64 for _ in range(3)]
yield dict(entity=entity, event=event, feet=feet, width=w, height=h,
seed=rng.randrange(-2**63, 2**63))
def make_cases(build):
path = build / 'cases.jsonl'
count = 0
with path.open('w') as out:
for case in cases(random.Random(0x454e5450)):
out.write(json.dumps(case, separators=(',', ':')) + '\n')
count += 1
return path, count
def close(a, b):
"""Lines equal but for doubles within 1e-12 relative error. The motion is
Gaussian, and MarsagliaPolarGaussian calls Math.log, which HotSpot's x86-64
intrinsic rounds a unit apart from the platform libm horizon_core::jmath
uses for a small fraction of arguments."""
ta, tb = a.split(), b.split()
if len(ta) != len(tb):
return False
for x, y in zip(ta, tb):
if x == y:
continue
if len(x) != 16 or len(y) != 16:
return False
fx, fy = (struct.unpack('>d', bytes.fromhex(t))[0] for t in (x, y))
if not abs(fx - fy) <= 1e-12 * max(1.0, abs(fx)):
return False
return True
def main():
lock, jars, _ = base.verify_artifacts()
name, oracle, probe = 'rust-entity-particles-parity', 'VanillaEntityParticlesOracle', 'entity_particles_probe'
build = lab.LOCAL / name
build.mkdir(exist_ok=True)
report = build / 'report.json'
report.unlink(missing_ok=True)
sources = [lab.ROOT / p for p in [
'tools/test_entity_particles_parity.py', 'tools/oracle_harness.py', 'tools/test_rust_parity.py', 'tools/lab.py',
f'mods/horizon/src/test/java/dev/horizonlab/parity/{oracle}.java', 'Cargo.toml', 'Cargo.lock',
'crates/horizon-client/Cargo.toml', 'crates/horizon-client/src/particles.rs',
f'crates/horizon-client/examples/{probe}.rs', 'crates/horizon-core/src/random.rs']]
tested = base.source_hashes(sources)
cases_path, units = make_cases(build)
classes, dependencies, _ = harness.compile_oracle(build, oracle, jars, baking.client_libraries(),
lock['minecraft']['java_major'])
binary = harness.build_probe(build, probe)
harness.run_logged([binary, cases_path, build / 'rust.txt'], build, 'rust')
harness.java_run(build, classes, dependencies, oracle, [cases_path, build / 'client.txt'], 'client')
vanilla = (build / 'client.txt').read_text().splitlines()
rust = (build / 'rust.txt').read_text().splitlines()
assert len(vanilla) == len(rust), f'{len(vanilla)} vanilla lines, {len(rust)} Rust lines'
tolerated = 0
for line, (a, b) in enumerate(zip(vanilla, rust), 1):
if a != b:
assert close(a, b), f'Parity mismatch at output line {line}: vanilla={a!r}, Rust={b!r}'
tolerated += 1
particles = sum(line.startswith('+ ') for line in vanilla)
assert particles > units, 'too few particles to establish parity'
base.ensure_sources_unchanged(sources, tested)
lab.write_json(report, dict(
schema=1, minecraft=lock['minecraft']['version'], platform=platform.platform(),
rustc=subprocess.check_output(['rustc', '--version'], text=True).strip(), units=units,
sources_sha256=tested, input_sha256=lab.digest(cases_path, 'sha256'),
client_jar_sha256=lab.digest(jars['client'], 'sha256'), matched_output_lines=len(vanilla),
libm_tolerated_lines=tolerated, output_sha256=lab.digest(build / 'rust.txt', 'sha256'),
scope=('The real client handleEntityEvent of Villager (12, 13, 14, 42), Animal (18, love hearts), TamableAnimal '
'and AbstractHorse (6, 7, taming), Ocelot (40, 41, trusting), Dolphin (38) and Allay (18), on entities '
'allocated with a stand-in level, a position, dimensions and a seeded random: the particle type, '
'count, positions, motion and draws on the entity random. Which server code fires each event, and '
'the particles themselves once spawned, are covered elsewhere.')))
print(f'{units:,} entity events, {particles:,} particles match the pinned client ({tolerated} lines within the '
f'Math.log tolerance): {report}', flush=True)
if __name__ == '__main__':
main()
File diff suppressed because one or more lines are too long
+14 -4
View File
@@ -31,11 +31,15 @@ falling_lava falling_nectar falling_obsidian_tear falling_spore_blossom falling_
gust gust_emitter_large gust_emitter_small happy_villager heart infested landing_honey landing_lava
landing_obsidian_tear large_smoke lava mycelium nautilus note pale_oak_leaves poof portal rain reverse_portal
sculk_charge_pop sculk_soul smoke small_flame small_gust sneeze snowflake sonic_boom soul soul_fire_flame splash
spore_blossom_air totem_of_undying underwater vault_connection warped_spore white_ash white_smoke witch""".split()
spore_blossom_air totem_of_undying underwater vault_connection warped_spore white_ash white_smoke witch
sweep_attack glow wax_on wax_off electric_spark scrape squid_ink glow_squid_ink item_slime item_snowball item_cobweb
sulfur_cube_goo firefly trial_spawner_detection trial_spawner_detection_ominous trial_omen raid_omen ominous_spawning
spit fishing dust_plume red_poplar_leaves orange_poplar_leaves yellow_poplar_leaves pause_mob_growth
reset_mob_growth""".split()
def options(kind, rng):
if kind in ('block', 'block_crumble', 'dust_pillar', 'falling_dust'):
if kind in ('block', 'block_crumble', 'dust_pillar', 'falling_dust', 'block_marker'):
return dict(state=STONE)
if kind == 'dust':
return dict(color=rng.choice([0xFF0000, 0x3A9E2C, 0xFFFFFF]), scale=rng.choice([1.0, 0.5, 2.0]))
@@ -47,6 +51,10 @@ def options(kind, rng):
return dict(color=rng.choice([0xFF3366CC, 0x26AA00FF]))
if kind == 'tinted_leaves':
return dict(color=0xFF48B518)
if kind == 'flash':
return dict(color=rng.choice([0xFF3366CC, 0x00FFAA00]))
if kind == 'item':
return dict(item=rng.choice(['minecraft:apple', 'minecraft:cooked_beef', 'minecraft:egg']))
if kind == 'dragon_breath':
return dict(scale=rng.choice([1.0, 0.25]))
if kind == 'sculk_charge':
@@ -60,7 +68,8 @@ def options(kind, rng):
def cases(rng):
kinds = SIMPLE + ['block', 'block_crumble', 'dust_pillar', 'falling_dust', 'dust', 'dust_color_transition', 'effect',
'instant_effect', 'entity_effect', 'tinted_leaves', 'dragon_breath', 'sculk_charge', 'shriek', 'trail']
'instant_effect', 'entity_effect', 'tinted_leaves', 'dragon_breath', 'sculk_charge', 'shriek', 'trail',
'block_marker', 'flash', 'item']
# Dyadic values: serde_json's decimal parsing may round others a unit off.
starts = [([0.3125, 66.6875, -0.40625], False), ([0.3125, 64.046875, -0.40625], True), ([-5.75, 64.59375, 3.125], True)]
velocities = [[0.0, 0.0, 0.0], [0.078125, 0.125, -0.046875], [0.0, -0.296875, 0.0], [0.5, 0.0, 0.25]]
@@ -99,7 +108,8 @@ def decode(token):
# (Intel's libm) round a fraction of a percent of arguments a unit apart from
# the platform libm horizon_core::jmath uses, so their motion is compared to
# 1e-12 relative error; everything else about them, and every other type, exactly.
LIBM = {'cherry_leaves', 'pale_oak_leaves', 'tinted_leaves'}
LIBM = {'cherry_leaves', 'pale_oak_leaves', 'tinted_leaves', 'red_poplar_leaves', 'orange_poplar_leaves',
'yellow_poplar_leaves'}
def sections(path):
+1
View File
@@ -583,6 +583,7 @@ code {
margin: 24px 0 -0.24em; text-align: center; white-space: nowrap;
font: 400 27vw/0.9 var(--display); letter-spacing: -0.045em;
color: transparent; -webkit-text-stroke: 1px #24242a;
pointer-events: none;
user-select: none;
}