horizon-rust/horizon
1
0 Fork 0
mirror of https://github.com/horizon-rust/horizon.git synced 2026-11-07 11:06:11 -10:00
Code Issues Packages Projects Releases 1 Wiki Activity

Merge #11117 (with main) into #11118

Browse Source 
Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
Horizon agentandClaude Opus 5.5 committed 2026-11-07 10:00:02 +01:00
2 parents 8c13c07e40 b00d753c62
commit 9d1c979e91
488 files changed
+33291 -2251
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.github/workflows/ci.yml
+8 -7
View File
@@ -234,14 +234,15 @@ jobs:
run: python ../tools/check_pe_arch.py arm64 target/aarch64-pc-windows-msvc/release/horizon-launcher.exe
- name: Check launcher DLL imports and command-line startup
working-directory: launcher
shell: pwsh
# bash, as launcher.yml's check on the same runner: the launcher is a GUI-subsystem program, and a pwsh
# `$output = & launcher --version` read no output from it (run 42217014588).
shell: bash
run: |
$ErrorActionPreference = 'Stop'
$launcher = 'target/aarch64-pc-windows-msvc/release/horizon-launcher.exe'
python ../tools/check_imports.py $launcher
$output = & $launcher --version 2>&1
if ($LASTEXITCODE -ne 0 -or -not $output) { throw 'horizon-launcher --version failed' }
Write-Output ($output -join "`n")
launcher=target/aarch64-pc-windows-msvc/release/horizon-launcher.exe
python ../tools/check_imports.py "$launcher"
out=$("$launcher" --version)
echo "$out"
[[ "$out" == "horizon-launcher "* ]] || { echo "::error::horizon-launcher --version printed '$out'"; exit 1; }
- name: Build a native-mod game with the launcher's managed toolchain
working-directory: launcher
shell: pwsh
Cargo.lock
Generated
+199 -3
View File
@@ -153,6 +153,12 @@ version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"
[[package]]
name = "arraydeque"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236"
[[package]]
name = "arrayref"
version = "0.3.9"
@@ -485,6 +491,7 @@ checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
dependencies = [
"iana-time-zone",
"num-traits",
"serde",
"windows-link",
]
@@ -540,6 +547,12 @@ dependencies = [
"unicode-width",
]
[[package]]
name = "color_quant"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
[[package]]
name = "combine"
version = "4.6.8"
@@ -946,6 +959,18 @@ version = "3.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7"
[[package]]
name = "fallible-iterator"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
[[package]]
name = "fallible-streaming-iterator"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
[[package]]
name = "fdeflate"
version = "0.3.7"
@@ -1105,8 +1130,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
dependencies = [
"cfg-if",
"js-sys",
"libc",
"wasi",
"wasm-bindgen",
]
[[package]]
@@ -1135,6 +1162,16 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "gif"
version = "0.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159"
dependencies = [
"color_quant",
"weezl",
]
[[package]]
name = "gilrs"
version = "0.11.2"
@@ -1264,6 +1301,15 @@ dependencies = [
"serde_core",
]
[[package]]
name = "hashlink"
version = "0.12.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a596f1b20ed2cc5ecac41a164aaebc7258057060f06c0cf7a2ba3991ee7990fb"
dependencies = [
"hashbrown 0.17.1",
]
[[package]]
name = "heck"
version = "0.5.0"
@@ -1660,10 +1706,15 @@ dependencies = [
name = "horizon-mod-deps"
version = "0.1.0"
dependencies = [
"gif",
"mysql",
"quinn",
"redis",
"rusqlite",
"rusty-opus",
"snap",
"tungstenite",
"yaml-rust2",
]
[[package]]
@@ -2268,6 +2319,17 @@ dependencies = [
"redox_syscall 0.9.4",
]
[[package]]
name = "libsqlite3-sys"
version = "0.39.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14a5f01b87b92705d07b433c06f96cbc764637d81a0bffb5734ce17cf0f9a2b3"
dependencies = [
"cc",
"pkg-config",
"vcpkg",
]
[[package]]
name = "libudev-sys"
version = "0.1.4"
@@ -2323,6 +2385,12 @@ version = "0.16.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39"
[[package]]
name = "lru-slab"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4050469837a6ff301cd14c1f8f24f88549e6d548f24f64e2148eb0f72cebc51f"
[[package]]
name = "lz4_flex"
version = "0.14.0"
@@ -2450,6 +2518,7 @@ dependencies = [
"btoi",
"byteorder",
"bytes",
"chrono",
"crc32fast",
"flate2",
"getrandom 0.3.4",
@@ -2484,7 +2553,7 @@ dependencies = [
"num-traits",
"once_cell",
"pp-rs",
"rustc-hash",
"rustc-hash 1.1.0",
"spirv",
"thiserror 2.0.21",
"unicode-ident",
@@ -2498,7 +2567,7 @@ checksum = "590afbf58a6f4f62873cd5cff4468061844bafa1cdf399cc954537c22d768d49"
dependencies = [
"hashbrown 0.17.1",
"indexmap",
"rustc-hash",
"rustc-hash 1.1.0",
"thiserror 2.0.21",
]
@@ -3354,6 +3423,62 @@ dependencies = [
"memchr",
]
[[package]]
name = "quinn"
version = "0.11.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4051e23e9185c255a7e33ef59cdbca87a22d359052eecd22fc6b901fb37d9d11"
dependencies = [
"bytes",
"cfg_aliases",
"pin-project-lite",
"quinn-proto",
"quinn-udp",
"rustc-hash 2.1.3",
"rustls",
"socket2 0.6.5",
"thiserror 2.0.21",
"tokio",
"tracing",
"web-time",
]
[[package]]
name = "quinn-proto"
version = "0.11.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe"
dependencies = [
"bytes",
"getrandom 0.4.3",
"lru-slab",
"rand",
"rand_pcg",
"ring",
"rustc-hash 2.1.3",
"rustls",
"rustls-pki-types",
"slab",
"thiserror 2.0.21",
"tinyvec",
"tracing",
"web-time",
]
[[package]]
name = "quinn-udp"
version = "0.5.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af66907df18639dcf4db56ca65490cabc4b27a97dbadd96f2926cca73298f016"
dependencies = [
"cfg_aliases",
"libc",
"once_cell",
"socket2 0.6.5",
"tracing",
"windows-sys 0.61.2",
]
[[package]]
name = "quote"
version = "1.0.47"
@@ -3401,6 +3526,15 @@ version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
[[package]]
name = "rand_pcg"
version = "0.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
dependencies = [
"rand_core 0.10.1",
]
[[package]]
name = "range-alloc"
version = "0.1.5"
@@ -3539,12 +3673,32 @@ dependencies = [
"windows-sys 0.52.0",
]
[[package]]
name = "rusqlite"
version = "0.41.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da9bba6f3506135e120a6586df05be18b48d18896600646a4bec8f993d91a594"
dependencies = [
"bitflags 2.13.2",
"fallible-iterator",
"fallible-streaming-iterator",
"hashlink",
"libsqlite3-sys",
"smallvec",
]
[[package]]
name = "rustc-hash"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
[[package]]
name = "rustc-hash"
version = "2.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
[[package]]
name = "rustc_version"
version = "0.4.1"
@@ -3619,6 +3773,7 @@ version = "1.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
dependencies = [
"web-time",
"zeroize",
]
@@ -3883,6 +4038,12 @@ dependencies = [
"serde",
]
[[package]]
name = "snap"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "199905e6153d6405f9728fe44daace35f8f837bbf830bb6e85fbd5828709a886"
[[package]]
name = "socket2"
version = "0.5.10"
@@ -4198,13 +4359,23 @@ dependencies = [
"zerovec",
]
[[package]]
name = "tinyvec"
version = "1.13.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee"
[[package]]
name = "tokio"
version = "1.53.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044"
dependencies = [
"libc",
"mio",
"pin-project-lite",
"socket2 0.6.5",
"windows-sys 0.61.2",
]
[[package]]
@@ -4274,6 +4445,9 @@ name = "tracing-core"
version = "0.1.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
dependencies = [
"once_cell",
]
[[package]]
name = "tree_magic_mini"
@@ -4412,6 +4586,12 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "vcpkg"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
[[package]]
name = "vec_map"
version = "0.8.2"
@@ -4675,6 +4855,12 @@ dependencies = [
"rustls-pki-types",
]
[[package]]
name = "weezl"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
[[package]]
name = "wgpu"
version = "30.0.1"
@@ -4728,7 +4914,7 @@ dependencies = [
"portable-atomic",
"profiling",
"raw-window-handle",
"rustc-hash",
"rustc-hash 1.1.0",
"smallvec",
"thiserror 2.0.21",
"wgpu-core-deps-apple",
@@ -5471,6 +5657,16 @@ version = "0.8.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"
[[package]]
name = "yaml-rust2"
version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57e5b818a27a4cd30884ea380857a5e56f7ec3ba24a3990a3cc0b95af3238e18"
dependencies = [
"arraydeque",
"hashlink",
]
[[package]]
name = "yasna"
version = "0.6.0"
ROADMAP.md
-10
View File
@@ -410,16 +410,6 @@ The panel's later features (bans, worlds, server.properties import, logs and cra
</details>
#### Ely.by and other sign-in providers
Sign in with other account providers, such as Ely.by or any Yggdrasil-compatible one, beside Microsoft.
<details><summary>Technical</summary>
Issue [#1270](https://github.com/horizon-rust/horizon/issues/1270) asks for Ely.by and Yggdrasil-compatible servers with an account selector in the launcher. It builds on the Microsoft sign-in ([docs/microsoft-account.md](docs/microsoft-account.md)).
</details>
#### Join servers on older versions
Join servers that run older Minecraft versions, such as 1.21 or 1.8 PvP servers, from Horizon.
crates/horizon-bots/src/main.rs
+136 -12
View File
@@ -90,6 +90,9 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
--seed N default 12345
--explore-speed B blocks a second an explore bot flies; default 22 (as fast as chunks come)
--pvp B fight bots also attack each other (true or false); default true
--crits fight bots swing at a sword's full strength (every 13 ticks) and jump into every
other swing, landing it while falling: a critical hit, then a sweep from the
ground (give them swords); for PvP benches (crit and sweep particles)
--name PREFIX bot names: PREFIX0, PREFIX1...; default Bot
--brand B the client brand sent in configuration (minecraft:brand); default none
--height H blocks above spawn the bots fly at (walk, explore, idle); default 24
@@ -165,6 +168,8 @@ struct Options {
attack_after: f64,
attack_rounds: u32,
no_swing: bool,
/// --crits: fight bots alternate jumped critical hits and sweeps at a sword's cooldown.
crits: bool,
flood: usize,
no_read: bool,
no_loaded: bool,
@@ -202,6 +207,7 @@ fn options() -> Result<Options, String> {
attack_after: 5.0,
attack_rounds: u32::MAX,
no_swing: false,
crits: false,
flood: 100,
no_read: false,
no_loaded: false,
@@ -230,6 +236,10 @@ fn options() -> Result<Options, String> {
o.no_swing = true;
continue;
}
if arg == "--crits" {
o.crits = true;
continue;
}
if arg == "--no-loaded" {
o.no_loaded = true;
continue;
@@ -532,11 +542,84 @@ fn distance(a: [f64; 3], b: [f64; 3]) -> f64 {
((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2) + (a[2] - b[2]).powi(2)).sqrt()
}
/// A sword's attack speed is 1.6 a second: full strength 20 / 1.6 = 12.5 ticks after a swing.
const SWORD_COOLDOWN_TICKS: u32 = 13;
/// `LivingEntity.getJumpPower`: a jump's first upward motion, in blocks a tick.
const JUMP_POWER: f64 = 0.42;
/// `--crits`: a fight bot that swings at a sword's full strength and jumps into every other swing, so
/// it lands while falling (`Player.attack`'s critical hit: falling, not on the ground, full strength),
/// and the next one from the ground (a sweep: on the ground, full strength, a sword).
#[derive(Default)]
struct Crits {
/// Vertical motion while in the air (`LivingEntity.travel`: minus 0.08 a tick, times 0.98).
jump: Option<f64>,
ground: f64,
/// The next swing is the jumped one.
crit_next: bool,
}
impl Crits {
fn airborne(&self) -> bool {
self.jump.is_some()
}
/// One tick: walk up to the target and, with a full cooldown, strike; jump ahead of a crit's swing.
fn tick(
&mut self,
pos: &mut [f64; 3],
target: (i32, [f64; 3]),
since: &mut u32,
) -> Option<i32> {
if let Some(v) = self.jump {
pos[1] += v;
if pos[1] <= self.ground {
pos[1] = self.ground;
self.jump = None;
} else {
self.jump = Some((v - 0.08) * 0.98);
}
} else {
self.ground = pos[1];
// A jump takes 6 ticks to its top: start it so the cooldown ends on the way down.
if self.crit_next && *since + 8 >= SWORD_COOLDOWN_TICKS {
self.jump = Some(JUMP_POWER);
}
}
let falling = self.jump.is_some_and(|v| v < 0.0);
if self.crit_next && !falling {
*since = since.saturating_add(1);
fight_step(pos, target.1);
return None;
}
let hit = fight_tick(pos, target, since, SWORD_COOLDOWN_TICKS);
if hit.is_some() {
self.crit_next = !self.crit_next;
}
hit
}
}
/// One tick of a fighting bot with a target: walk up to it, and strike once the cooldown is over.
/// Returns the entity to attack. `since_attack` counts ticks since the last swing.
fn fight_tick(pos: &mut [f64; 3], target: (i32, [f64; 3]), since_attack: &mut u32) -> Option<i32> {
fn fight_tick(
pos: &mut [f64; 3],
target: (i32, [f64; 3]),
since_attack: &mut u32,
cooldown: u32,
) -> Option<i32> {
*since_attack = since_attack.saturating_add(1);
let (id, at) = target;
fight_step(pos, at);
if *since_attack >= cooldown && distance(*pos, at) <= ATTACK_REACH {
*since_attack = 0;
return Some(id);
}
None
}
/// Walk toward `at`, stopping `CLOSE_IN` short of it.
fn fight_step(pos: &mut [f64; 3], at: [f64; 3]) {
let (dx, dz) = (at[0] - pos[0], at[2] - pos[2]);
let horizontal = dx.hypot(dz);
if horizontal > CLOSE_IN {
@@ -544,11 +627,6 @@ fn fight_tick(pos: &mut [f64; 3], target: (i32, [f64; 3]), since_attack: &mut u3
pos[0] += dx / horizontal * step;
pos[2] += dz / horizontal * step;
}
if *since_attack >= ATTACK_COOLDOWN_TICKS && distance(*pos, at) <= ATTACK_REACH {
*since_attack = 0;
return Some(id);
}
None
}
/// One tick of walking to random points around the spawn, at sprint speed (5.6 blocks a second).
@@ -1124,6 +1202,7 @@ fn run_bot(
spawn[1] + o.height
};
let mut since_attack = ATTACK_COOLDOWN_TICKS;
let mut crits = Crits::default();
let heading = random.unit() * std::f64::consts::TAU;
let mut target = pos;
let mut next = Instant::now();
@@ -1181,11 +1260,16 @@ fn run_bot(
Behaviour::Fight => {
let near = lock(&bot.entities).nearest(pos, o.pvp, &bots);
if let Some(near) = near {
if let Some(victim) = fight_tick(&mut pos, near, &mut since_attack) {
let hit = if o.crits {
crits.tick(&mut pos, near, &mut since_attack)
} else {
fight_tick(&mut pos, near, &mut since_attack, ATTACK_COOLDOWN_TICKS)
};
if let Some(victim) = hit {
// The client sends the attack, then swings the arm.
let sent = send(
play::Serverbound::Attack(play::Attack { id: victim }).encode(),
) && send(raw(sb::PUNCH, |w| w.varint(0)));
) && send(play::Serverbound::Punch(Empty).encode());
if sent {
bot.attacks.fetch_add(1, Ordering::Relaxed);
}
@@ -1300,9 +1384,10 @@ fn run_bot(
x: pos[0],
y: pos[1],
z: pos[2],
// Fight bots stand on the ground; the others fly.
// Fight bots stand on the ground (but in a --crits jump); the others fly.
flags: u8::from(
matches!(behaviour, Behaviour::Fight | Behaviour::Stand) || o.ground,
(matches!(behaviour, Behaviour::Fight | Behaviour::Stand) && !crits.airborne())
|| o.ground,
),
})
.encode(),
@@ -1600,7 +1685,9 @@ mod tests {
let target = (3, [1.0, 64.0, 0.0]);
let mut since = ATTACK_COOLDOWN_TICKS;
let hits: Vec<u32> = (0..40)
.filter_map(|tick| fight_tick(&mut pos, target, &mut since).map(|_| tick))
.filter_map(|tick| {
fight_tick(&mut pos, target, &mut since, ATTACK_COOLDOWN_TICKS).map(|_| tick)
})
.collect();
assert_eq!(hits[0], 0, "a bot in reach strikes at once");
assert!(
@@ -1617,7 +1704,7 @@ mod tests {
let mut since = ATTACK_COOLDOWN_TICKS;
let mut first = None;
for tick in 0..100 {
if fight_tick(&mut pos, target, &mut since).is_some() {
if fight_tick(&mut pos, target, &mut since, ATTACK_COOLDOWN_TICKS).is_some() {
first = Some(tick);
break;
}
@@ -1627,6 +1714,43 @@ mod tests {
assert!(pos[0] < 10.0 - CLOSE_IN + 1e-9);
}
#[test]
fn crits_alternate_a_falling_swing_and_a_grounded_one() {
let mut pos = [0.0, 64.0, 0.0];
let target = (3, [1.0, 64.0, 0.0]);
let (mut since, mut crits) = (SWORD_COOLDOWN_TICKS, Crits::default());
let mut last_y = pos[1];
let mut hits = Vec::new();
for tick in 0..120u32 {
let hit = crits.tick(&mut pos, target, &mut since);
if hit.is_some() {
hits.push((tick, crits_state(pos[1], last_y)));
}
last_y = pos[1];
}
assert!(hits.len() >= 6, "{hits:?}");
for (i, w) in hits.windows(2).enumerate() {
assert!(
w[1].0 - w[0].0 >= SWORD_COOLDOWN_TICKS,
"full strength each time: {hits:?}"
);
assert_ne!(w[0].1, w[1].1, "swing {i} and the next alternate: {hits:?}");
}
// A crit lands in the air, on the way down; a sweep from the ground.
assert!(hits.iter().any(|h| h.1 == "falling") && hits.iter().any(|h| h.1 == "ground"));
assert!(pos[1] >= 64.0);
}
fn crits_state(y: f64, before: f64) -> &'static str {
if y == 64.0 {
"ground"
} else if y < before {
"falling"
} else {
"rising"
}
}
#[test]
fn percentiles_use_nearest_rank() {
assert_eq!(percentile(&[], 50), 0);
crates/horizon-client-input/src/window.rs
+38 -31
View File
@@ -393,38 +393,17 @@ impl FullscreenState {
let reapply = self.set_exclusive(exclusive);
self.set_preferred_mode(preferred);
let mode_change = !in_video_screen && self.take_mode_change();
if wanted && window.is_maximized() {
window.set_maximized(false);
window.set_fullscreen(Some(fullscreen_request(
match request {
Some(false) => window.set_fullscreen(None),
Some(true) => enter_fullscreen(
window,
exclusive,
preferred.as_ref(),
)));
} else {
match request {
Some(false) => window.set_fullscreen(None),
Some(true) => {
if window.is_maximized() {
window.set_maximized(false);
}
window.set_fullscreen(Some(fullscreen_request(
window,
exclusive,
preferred.as_ref(),
)));
}
None if reapply || mode_change => {
if window.is_maximized() {
window.set_maximized(false);
}
window.set_fullscreen(Some(fullscreen_request(
window,
exclusive,
preferred.as_ref(),
)));
}
None => {}
}
fullscreen_request(window, exclusive, preferred.as_ref()),
),
None if reapply || mode_change => enter_fullscreen(
window,
fullscreen_request(window, exclusive, preferred.as_ref()),
),
None => {}
}
}
@@ -602,6 +581,34 @@ fn monitor_current_mode(
.max_by_key(|m| (m.refresh_rate_millihertz(), m.bit_depth()))
}
/// `window.set_fullscreen(Some(fullscreen))`. On Windows a maximized window leaves its maximized
/// state first: winit keeps a maximized window's client area inside the work area, so a
/// borderless fullscreen kept the taskbar over its bottom and pushed its top off screen (#9984).
pub fn enter_fullscreen(window: &winit::window::Window, fullscreen: winit::window::Fullscreen) {
#[cfg(target_os = "windows")]
if window.is_maximized() {
window.set_maximized(false);
}
window.set_fullscreen(Some(fullscreen));
}
/// Borderless fullscreen on the window's own monitor (the primary one when it has none).
pub fn borderless_fullscreen(window: &winit::window::Window) -> winit::window::Fullscreen {
winit::window::Fullscreen::Borderless(
window
.current_monitor()
.or_else(|| window.primary_monitor()),
)
}
/// A window created fullscreen that the system also marked maximized enters it again
/// unmaximized ([`enter_fullscreen`]); only Windows does that.
pub fn settle_created_fullscreen(window: &winit::window::Window, fullscreen: bool) {
if cfg!(target_os = "windows") && fullscreen && window.is_maximized() {
enter_fullscreen(window, borderless_fullscreen(window));
}
}
/// `Window.applyFullscreen`: the fullscreen the window asks for. Exclusive fullscreen takes
/// `Monitor.getPreferredVideoMode` (the preferred mode if the monitor has it, else the desktop
/// mode); a monitor with no usable mode falls back to borderless, as vanilla does.
crates/horizon-client-render/examples/entity_shadow_ownership.rs
+1
View File
@@ -66,6 +66,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
false,
false,
true,
false,
))?;
assert!(!renderer.pack_entity_shadows(), "no selected pack");
renderer.set_shader_pack(0, None, &[]).unwrap();
crates/horizon-client-render/examples/scene_replay.rs
+1
View File
@@ -224,6 +224,7 @@ fn replay(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
settings.translucent_batching,
false,
false,
false,
))?;
drop(pixels);
render.pixels.pack();
crates/horizon-client-render/examples/standard_pack_gpu_entities.rs
+1
View File
@@ -126,6 +126,7 @@ fn fixture(window: Arc<Window>) -> Result<(), Box<dyn std::error::Error>> {
false,
false,
true,
false,
))?;
renderer.resize(320, 180);
assert!(
crates/horizon-client-render/src/audio.rs
+76 -12
View File
@@ -261,6 +261,40 @@ pub struct Audio {
/// Ticks since the output devices were last looked at (`DeviceTracker.tick`).
#[cfg(feature = "audio")]
device_ticks: u32,
/// The look at the output devices running on its own thread, until a tick
/// takes its answer: listing them can take 100 ms (#11490).
#[cfg(feature = "audio")]
device_probe: Option<PendingProbe>,
}
/// What one look at the output devices found: the system default, the
/// fingerprint, and the device list when those say it may have changed.
#[cfg(feature = "audio")]
struct DeviceProbe {
default: Option<String>,
cards: Option<String>,
devices: Option<Vec<String>>,
}
#[cfg(feature = "audio")]
type PendingProbe = Arc<Mutex<Option<DeviceProbe>>>;
/// Looks at the output devices as `should_change_device` did on the render
/// thread: the device list only when the default or the fingerprint moved.
#[cfg(feature = "audio")]
fn probe_devices(default_seen: Option<String>, cards_seen: Option<String>) -> DeviceProbe {
let default = default_output_name();
let cards = card_fingerprint();
// Listing the devices probes every one (on Linux every built-in PCM,
// printing ALSA's errors for the plugins this system lacks; on macOS
// every Core Audio device, about 90 ms with twenty of them; on Windows
// every endpoint, with no fingerprint to skip it); only the fingerprint's
// devices can change the list, and it is cheap.
let devices = (default != default_seen
|| cards_changed(cards_seen.as_deref(), cards.as_deref()))
.then(output_devices);
DeviceProbe {
default,
cards,
devices,
}
}
fn decode(path: &Path) -> Option<(Vec<f32>, u32, u16)> {
use symphonia::core::{
@@ -1051,6 +1085,8 @@ impl Audio {
devices_seen: devices,
#[cfg(feature = "audio")]
device_ticks: 0,
#[cfg(feature = "audio")]
device_probe: None,
}
}
#[cfg(not(feature = "audio"))]
@@ -1211,6 +1247,8 @@ impl Audio {
devices_seen: self.devices_seen.clone(),
#[cfg(feature = "audio")]
device_ticks: 0,
#[cfg(feature = "audio")]
device_probe: None,
}
}
/// Sync the volume options, refreshing the categories that changed
@@ -1232,7 +1270,8 @@ impl Audio {
/// `SoundEngine.shouldChangeDevice`: the open device was lost, the system
/// default changed (with no device chosen in the options), or the chosen
/// device came back; the output is then opened again. The devices are looked
/// at once a second.
/// at once a second, on a thread of their own: a later tick reads what it
/// found.
#[cfg(feature = "audio")]
fn should_change_device(&mut self) -> bool {
// A splitscreen share plays through the first player's output: it leaves the device,
@@ -1246,29 +1285,54 @@ impl Audio {
};
if lost {
log::info!("Horizon: audio device was lost");
self.device_probe = None;
self.default_seen = default_output_name();
self.cards_seen = card_fingerprint();
self.devices_seen = output_devices();
return true;
}
if let Some(pending) = &self.device_probe {
let Some(probe) = pending.lock().ok().and_then(|mut found| found.take()) else {
return false;
};
self.device_probe = None;
return self.devices_changed(probe, current);
}
self.device_ticks += 1;
if self._stream.is_none() || self.device_ticks < 20 {
return false;
}
self.device_ticks = 0;
let default = default_output_name();
let cards = card_fingerprint();
// Listing the devices probes every one (on Linux every built-in PCM,
// printing ALSA's errors for the plugins this system lacks; on macOS
// every Core Audio device, about 90 ms with twenty of them); only the
// fingerprint's devices can change the list, and it is cheap.
if default == self.default_seen
&& !cards_changed(self.cards_seen.as_deref(), cards.as_deref())
{
return false;
let pending = PendingProbe::default();
let out = Arc::clone(&pending);
let seen = (self.default_seen.clone(), self.cards_seen.clone());
let started = std::thread::Builder::new()
.name("audio-devices".into())
.spawn(move || {
let probe = probe_devices(seen.0, seen.1);
if let Ok(mut found) = out.lock() {
*found = Some(probe);
}
});
match started {
Ok(_) => self.device_probe = Some(pending),
Err(e) => log::warn!("Horizon: could not look at the audio devices: {e}"),
}
false
}
/// The rest of `shouldChangeDevice` with what a look at the devices found,
/// `current` being the device playing now.
#[cfg(feature = "audio")]
fn devices_changed(&mut self, probe: DeviceProbe, current: String) -> bool {
let DeviceProbe {
default,
cards,
devices,
} = probe;
let Some(devices) = devices else {
return false;
};
self.cards_seen = cards;
let devices = output_devices();
// Only a change in the device lists is looked at, as in vanilla: a
// preferred device that is listed but cannot open is not retried.
if default == self.default_seen && devices == self.devices_seen {
crates/horizon-client-render/src/block_entities.rs
+5
View File
@@ -538,6 +538,11 @@ impl BlockEntities {
});
Arc::clone(&self.tickers)
}
/// How many block entities tick (`Level.blockEntityTickers`, the slots still live), as of
/// the last [`Self::tickers`]: what a diagnostics mod counts.
pub fn ticking_len(&self) -> usize {
self.live.len()
}
/// Whether a slot from `tickers` still ticks.
pub fn is_live(&self, (pos, slot): (Pos, u32)) -> bool {
self.live.get(&pos) == Some(&slot) && self.map.contains_key(&pos)
crates/horizon-client-render/src/chat.rs
+36 -4
View File
@@ -1193,6 +1193,10 @@ impl SuggestLayout {
/// the suggestion list, Tab completion, history).
pub struct ChatScreen {
pub input: TextField,
/// `ChatScreen.isDraft`: the box opened with the draft saved last time and
/// has not been edited since. A draft draws grey italic, and the first
/// Backspace clears the whole box instead of one character.
is_draft: bool,
width: i32,
height: i32,
history_buffer: String,
@@ -1300,11 +1304,13 @@ fn truncate_utf16(s: &str, max_units: usize) -> String {
s.to_owned()
}
impl ChatScreen {
/// `ChatScreen.init`: the input at the bottom, focused, holding `initial`.
/// `ChatScreen.init`: the input at the bottom, focused, holding `initial`,
/// which is a draft when `is_draft` (`ChatComponent.createScreen`).
pub fn new(
m: &Measure,
c: &Commands,
initial: &str,
is_draft: bool,
history_len: usize,
width: i32,
height: i32,
@@ -1317,6 +1323,7 @@ impl ChatScreen {
input.set_value(m, initial);
let mut s = Self {
input,
is_draft,
width,
height,
history_buffer: String::new(),
@@ -1353,6 +1360,7 @@ impl ChatScreen {
input.set_value(m, command);
let mut s = Self {
input,
is_draft: false,
width,
height,
history_buffer: String::new(),
@@ -1382,7 +1390,8 @@ impl ChatScreen {
self.input.set_value(m, command);
self.edited(m, c);
}
/// `ChatScreen.resize`: a new screen with the current text.
/// `ChatScreen.resize`: a new screen with the current text, still a draft
/// while it has not been edited (`ChatScreen.resize` keeps the field).
pub fn resize(&mut self, m: &Measure, c: &Commands, width: i32, height: i32) {
if (width, height) != (self.width, self.height) {
let value = self.input.value.clone();
@@ -1390,7 +1399,16 @@ impl ChatScreen {
let abilities = self.abilities;
let message = std::mem::take(&mut self.input.message);
*self = if self.layout == SuggestLayout::CHAT {
Self::new(m, c, &value, self.history_pos, width, height, abilities)
Self::new(
m,
c,
&value,
self.is_draft,
self.history_pos,
width,
height,
abilities,
)
} else {
Self::command_block(m, c, &value, width, height)
};
@@ -1402,6 +1420,7 @@ impl ChatScreen {
fn edited(&mut self, m: &Measure, c: &Commands) {
self.allow_suggestions = true;
self.update_command_info(m, c);
self.is_draft = false;
}
/// Ctrl+A/C/V/X in the input box.
pub fn shortcut(
@@ -1729,6 +1748,14 @@ impl ChatScreen {
if self.suggestions_key(m, c, key, shift) {
return ChatAction::None;
}
// ChatScreen.keyPressed: while the box holds an unedited draft, the
// first Backspace clears all of it rather than one character.
if self.is_draft && key == K::Backspace {
self.input.set_value(m, "");
self.is_draft = false;
self.edited(m, c);
return ChatAction::None;
}
match key {
K::Escape => return ChatAction::Close,
K::Enter | K::NumpadEnter => {
@@ -1862,8 +1889,13 @@ impl ChatScreen {
l.offset = ((l.offset as f64 - amount.clamp(-1.0, 1.0)) as i32).clamp(0, max) as usize;
true
}
/// `CommandSuggestions.formatText`: argument colours over the input.
/// `CommandSuggestions.formatText`: argument colours over the input. The
/// draft formatter (`ChatScreen.formatChat`) is registered before this one
/// and wins while the draft is unedited: the whole text is grey italic.
fn format(&self, value: &str, offset: usize) -> Text {
if self.is_draft {
return Text::literal(value).with_color(text::GRAY).italic();
}
let gray = Style::color(text::GRAY);
let Some(parse) = &self.parse else {
return Text::literal(value);
crates/horizon-client-render/src/chat_tests.rs
+104 -7
View File
@@ -201,7 +201,7 @@ fn locate_coordinates_fill_chat_with_teleport_without_submitting() {
assert_eq!(link.component()["click_event"]["command"], expected);
let mut chat = Chat::default();
add(&mut chat, &font, Text::literal("Found at ").append(link));
let mut screen = ChatScreen::new(&m, &commands, "draft", 0, 640, 360, full());
let mut screen = ChatScreen::new(&m, &commands, "draft", false, 0, 640, 360, full());
let x = 4.0 + f64::from(font.width("Found at "));
assert!(!screen.click(&m, &commands, x, 315.0));
let Some(ClickEvent::SuggestCommand(command)) = chat.click_at(&font, 360, x, 315.0) else {
@@ -242,6 +242,7 @@ fn history_arrows_recall_messages_and_restore_the_draft() {
&m,
&commands,
"unfinished draft",
false,
history.len(),
640,
360,
@@ -263,6 +264,93 @@ fn history_arrows_recall_messages_and_restore_the_draft() {
}
}
/// `ChatScreen.isDraft`: the box opens on the draft kept from last time
/// (`ChatComponent.createScreen` passes `true`, which `ChatScreen.init`
/// stores), so the text draws grey italic through `ChatScreen.formatChat`
/// and the first Backspace clears the whole draft instead of one character.
/// Editing the draft (`onEdited`) ends both.
#[test]
fn a_restored_draft_is_grey_italic_and_one_backspace_clears_it() {
use winit::keyboard::KeyCode::Backspace;
let font = font();
let m = Measure(&font);
let registries = Registries::default();
let c = Commands {
dispatcher: crate::command::vanilla::game_dispatcher(),
registries: &registries,
};
// The input's own text as the game draws it: x 4, y height - 12.
let input_text = |screen: &mut ChatScreen| -> Text {
screen
.draw(&m, (0, 0), 0, i32::MIN)
.into_iter()
.find_map(|draw| match draw {
Draw::Text {
text, x: 4, y: 348, ..
} => Some(text),
_ => None,
})
.expect("the input draws its text")
};
let draft_style = |t: &Text| {
t.spans
.iter()
.all(|s| s.style.color == Some(text::GRAY) && s.style.is_italic())
};
let mut screen = ChatScreen::new(&m, &c, "half-written", true, 0, 640, 360, full());
assert_eq!(screen.value(), "half-written");
assert!(
draft_style(&input_text(&mut screen)),
"the restored draft draws grey italic"
);
// Typing into the draft (`onEdited`) ends the draft style, and Backspace
// eats one character again.
screen.type_text(&m, &c, "!");
assert_eq!(screen.value(), "half-written!");
let typed = input_text(&mut screen);
assert!(
!typed.spans.iter().any(|s| s.style.is_italic()),
"an edited draft is not grey italic"
);
assert_eq!(
screen.key(&m, &c, &[], Backspace, false, false),
ChatAction::None
);
assert_eq!(screen.value(), "half-written");
// A draft left alone clears whole on its first Backspace.
let mut screen = ChatScreen::new(&m, &c, "half-written", true, 0, 640, 360, full());
assert_eq!(
screen.key(&m, &c, &[], Backspace, false, false),
ChatAction::None
);
assert_eq!(screen.value(), "", "the first Backspace clears the draft");
// The flag is gone with it: typing is ordinary text, and Backspace eats
// one character.
screen.type_text(&m, &c, "hi");
assert_eq!(screen.value(), "hi");
let typed = input_text(&mut screen);
assert!(!typed.spans.iter().any(|s| s.style.is_italic()));
assert_eq!(
screen.key(&m, &c, &[], Backspace, false, false),
ChatAction::None
);
assert_eq!(screen.value(), "h");
// A box opened on ordinary text deletes one character at a time.
let mut screen = ChatScreen::new(&m, &c, "half-written", false, 0, 640, 360, full());
assert!(!draft_style(&input_text(&mut screen)));
assert_eq!(
screen.key(&m, &c, &[], Backspace, false, false),
ChatAction::None
);
assert_eq!(screen.value(), "half-writte");
// A command draft is grey italic as a whole: `formatChat` is registered
// before `CommandSuggestions.formatText`, so it wins over the argument
// colours.
let mut screen = ChatScreen::new(&m, &c, "/give @s stone", true, 0, 640, 360, full());
assert!(draft_style(&input_text(&mut screen)));
}
#[test]
fn mod_commands_are_coloured_and_complete_like_vanilla_ones() {
let font = font();
@@ -283,7 +371,7 @@ fn mod_commands_are_coloured_and_complete_like_vanilla_ones() {
dispatcher,
registries: &registries,
};
let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
screen.type_text(&m, &c, line);
screen
};
@@ -333,7 +421,7 @@ fn chat_completes_the_servers_custom_completions_with_the_players() {
dispatcher,
registries,
};
let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
screen.type_text(&m, &c, line);
// Chat shows no list by itself: Tab shows it, Tab again uses it.
for _ in 0..2 {
@@ -381,7 +469,7 @@ fn ask_server_nodes_wait_for_the_servers_completions() {
let tab = |screen: &mut ChatScreen| {
screen.key(&m, &c, &[], winit::keyboard::KeyCode::Tab, false, false);
};
let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
screen.type_text(&m, &c, "/bossbar get pt");
let (request, sent) = screen.take_request().expect("the server is asked");
assert_eq!(sent, "/bossbar get pt");
@@ -403,7 +491,7 @@ fn ask_server_nodes_wait_for_the_servers_completions() {
dispatcher: local,
registries: &registries,
};
let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, full());
let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, full());
screen.type_text(&m, &c, "/bossbar get pt");
assert_eq!(screen.take_request(), None);
}
@@ -473,7 +561,7 @@ fn the_chat_option_decides_what_may_be_sent() {
assert_eq!(abilities.allows("hi"), chat, "{visibility:?}");
assert_eq!(abilities.allows("/time set day"), command, "{visibility:?}");
for (line, allowed) in [("hi", chat), ("/time set day", command)] {
let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, abilities);
let mut screen = ChatScreen::new(&m, &c, "", false, 0, 640, 360, abilities);
screen.type_text(&m, &c, line);
match enter(&mut screen) {
ChatAction::Submit(sent) => {
@@ -499,7 +587,16 @@ fn restricted_input_says_why_it_will_not_send() {
registries: &registries,
};
let usage = |visibility, line: &str| {
let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360, ChatAbilities::new(visibility));
let mut screen = ChatScreen::new(
&m,
&c,
"",
false,
0,
640,
360,
ChatAbilities::new(visibility),
);
screen.type_text(&m, &c, line);
screen.usage.iter().map(|t| t.plain()).collect::<Vec<_>>()
};
crates/horizon-client-render/src/collisions.rs
+14 -1
View File
@@ -243,11 +243,24 @@ impl SceneCollisions<'_, '_> {
max_step: f32,
on_ground: bool,
border: Option<(&BorderGeometry, [f64; 2])>,
) -> Result<Vec3> {
self.resolve_in_border_with(bounds, movement, max_step, on_ground, border, &[])
}
/// [`Self::resolve_in_border`], also stopped by `entities`: the boxes
/// `EntityGetter.getEntityCollisions` gave the moving entity.
pub fn resolve_in_border_with(
self,
bounds: Aabb,
movement: Vec3,
max_step: f32,
on_ground: bool,
border: Option<(&BorderGeometry, [f64; 2])>,
entities: &[Aabb],
) -> Result<Vec3> {
let context = self.context(bounds);
EntityCollisions {
blocks: self,
entities: &[],
entities,
border,
}
.resolve_with_context(bounds, movement, max_step, on_ground, context)
crates/horizon-client-render/src/crash.rs
+22 -1
View File
@@ -10,6 +10,7 @@ use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};
use chrono::{DateTime, Local};
use horizon_telemetry::system::machine_arch;
/// What the game is doing, set as it goes: graphics adapter, settings, packs, world.
static DETAILS: Mutex<Vec<(&'static str, String)>> = Mutex::new(Vec::new());
@@ -242,9 +243,18 @@ fn read(path: &str) -> Option<String> {
std::fs::read_to_string(path).ok()
}
/// The build's architecture, and the machine's after "on" when it emulates the build.
fn arch_label(build: &str, machine: &str) -> String {
if build == machine {
build.to_owned()
} else {
format!("{build} on {machine}")
}
}
/// `PRETTY_NAME` of /etc/os-release and the kernel, or the system's own version string.
fn operating_system() -> String {
let arch = std::env::consts::ARCH;
let arch = arch_label(std::env::consts::ARCH, machine_arch());
let version = if cfg!(target_os = "linux") {
let name = read("/etc/os-release").and_then(|t| {
t.lines()
@@ -683,6 +693,17 @@ pub fn debug_crash_after() -> Option<std::time::Duration> {
mod tests {
use super::*;
#[test]
fn an_emulated_build_names_both_architectures() {
// A Windows ARM64 PC playing the x64 build: its reports say so (#7513 read "x86_64").
assert_eq!(arch_label("x86_64", "aarch64"), "x86_64 on aarch64");
assert_eq!(arch_label("aarch64", "aarch64"), "aarch64");
assert_eq!(arch_label("x86_64", "x86_64"), "x86_64");
// On the machine running the tests: native builds name one architecture.
let label = arch_label(std::env::consts::ARCH, machine_arch());
assert!(label.starts_with(std::env::consts::ARCH));
}
#[test]
fn a_release_reports_its_built_in_version() {
// release.yml builds with HORIZON_VERSION (docs/versioning.md): `v0.2.3`, wherever it is installed.
crates/horizon-client-render/src/custom_sky.rs
+243
View File
@@ -0,0 +1,243 @@
//! OptiFine custom skies (`horizon_optifine::sky`) as the game draws them: a pack's layers with
//! their decoded textures, read once with the pack, and each frame's choice of layers, their
//! brightness and rotation ([`CustomSky::draws`]), which `gfx::custom_sky` draws over the
//! vanilla sky. A pack without `optifine/sky` gives an empty [`CustomSky`] and the sky stays
//! vanilla.
use std::path::Path;
use glam::{Mat4, Vec3};
use horizon_optifine::sky::{Blend, Conditions, Skies, SkyLayer, Transition};
/// A layer's texture, RGBA8.
pub struct Image {
pub width: u32,
pub height: u32,
pub rgba: Vec<u8>,
}
/// The pack's layers, by world, with one texture per layer (`images[i]` for the `i`th layer
/// over all worlds, in `worlds` order).
#[derive(Default)]
pub struct CustomSky {
worlds: Vec<(i32, Vec<SkyLayer>)>,
pub images: Vec<Image>,
}
/// One layer of a frame: which texture, with which blend, how bright and turned how.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Draw {
pub image: u16,
pub blend: Blend,
pub brightness: f32,
/// Camera-relative world from the skybox's space.
pub rotation: Mat4,
}
/// The eased brightness of each layer, kept by the game between frames.
#[derive(Default)]
pub struct State {
world: Option<i32>,
eased: Vec<Transition>,
}
/// Textures past this many texels in all are left out (a skybox is a few megapixels at most).
const TEXEL_BUDGET: u64 = 64 << 20;
impl CustomSky {
/// The custom skies of the overlay at `root`. A layer whose texture does not decode is
/// dropped with a warning.
pub fn load(root: &Path) -> Self {
let skies = Skies::scan(root);
let mut out = Self::default();
let mut texels = 0u64;
for (world, sky) in skies.worlds {
let mut layers = Vec::new();
for layer in sky.layers {
match crate::hud::decode(&root.join(&layer.source)) {
Ok((width, height, rgba))
if texels + u64::from(width) * u64::from(height) <= TEXEL_BUDGET =>
{
texels += u64::from(width) * u64::from(height);
out.images.push(Image {
width,
height,
rgba,
});
layers.push(layer);
}
Ok(_) => log::warn!("{}: past the custom sky's texture budget", layer.source),
Err(e) => log::warn!("{}: {e:#}", layer.source),
}
}
if !layers.is_empty() {
out.worlds.push((world, layers));
}
}
out
}
pub fn is_empty(&self) -> bool {
self.worlds.is_empty()
}
/// Whether `world` has layers (`0` the Overworld, `1` the End).
pub fn has(&self, world: i32) -> bool {
self.worlds.iter().any(|(w, _)| *w == world)
}
/// This frame's layers of `world` into `out` (cleared first), in drawing order: those whose
/// conditions hold, eased over their `transition` by `seconds` since the last frame, at the
/// brightness of their fade times. `sun_turns` is the sun's angle over 360° (`0` at noon).
pub fn draws(
&self,
world: i32,
conditions: &Conditions,
sun_turns: f32,
seconds: f32,
state: &mut State,
out: &mut Vec<Draw>,
) {
out.clear();
let mut first = 0;
let mut found = None;
for (w, layers) in &self.worlds {
if *w == world {
found = Some(layers);
break;
}
first += layers.len();
}
let Some(layers) = found else {
state.world = None;
return;
};
// A new world (or pack) starts each layer where its conditions put it: no fade in.
let snap = state.world != Some(world) || state.eased.len() != layers.len();
if snap {
state.world = Some(world);
state.eased.clear();
state.eased.resize(layers.len(), Transition::default());
}
for (i, (layer, eased)) in layers.iter().zip(&mut state.eased).enumerate() {
let target = if layer.shows(conditions) { 1.0 } else { 0.0 };
let shown = if snap {
eased.value = target;
target
} else {
eased.step(target, seconds, layer.transition)
};
let brightness = shown * layer.brightness(conditions.day_time);
if brightness <= 0.0 {
continue;
}
let turns = layer.turns(conditions.day_time, sun_turns);
let rotation = if turns == 0.0 {
Mat4::IDENTITY
} else {
Mat4::from_axis_angle(Vec3::from_array(layer.axis), turns * std::f32::consts::TAU)
};
out.push(Draw {
image: (first + i) as u16,
blend: layer.blend,
brightness,
rotation,
});
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use horizon_optifine::sky::Now;
fn pack(files: &[(&str, &str)]) -> (std::path::PathBuf, CustomSky) {
let root = std::env::temp_dir().join(format!(
"horizon-custom-sky-{}-{}",
std::process::id(),
files.len()
));
let _ = std::fs::remove_dir_all(&root);
let dir = root.join("assets/minecraft/optifine/sky/world0");
std::fs::create_dir_all(&dir).unwrap();
let png = {
let mut bytes = Vec::new();
let mut encoder = png::Encoder::new(&mut bytes, 6, 4);
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Eight);
let mut writer = encoder.write_header().unwrap();
writer
.write_image_data(&[255, 0, 0, 255].repeat(24))
.unwrap();
writer.finish().unwrap();
bytes
};
for (name, text) in files {
std::fs::write(dir.join(format!("{name}.properties")), text).unwrap();
std::fs::write(dir.join(format!("{name}.png")), &png).unwrap();
}
let sky = CustomSky::load(&root);
(root, sky)
}
fn noon(biome: &str) -> Conditions<'_> {
Conditions {
day_time: 6000,
weather: Now::Clear,
biome,
y: 64,
}
}
#[test]
fn layers_ease_in_at_a_biome_border_but_not_on_arrival() {
let (root, sky) = pack(&[
("sky1", "biomes=desert\ntransition=2"),
("sky2", "blend=alpha\nrotate=false"),
]);
let _ = std::fs::remove_dir_all(root);
assert!(sky.has(0) && !sky.has(1));
assert_eq!(sky.images[0].width, 6);
let (mut state, mut out) = (State::default(), Vec::new());
sky.draws(
0,
&noon("minecraft:desert"),
0.0,
0.05,
&mut state,
&mut out,
);
assert_eq!(
out.iter().map(|d| d.brightness).collect::<Vec<_>>(),
[1.0, 1.0]
);
// Out of the desert: the first layer fades over its two seconds.
sky.draws(0, &noon("minecraft:plains"), 0.0, 0.5, &mut state, &mut out);
assert_eq!(out[0].brightness, 0.75);
assert_eq!(out[1].blend, Blend::Alpha);
sky.draws(0, &noon("minecraft:plains"), 0.0, 2.0, &mut state, &mut out);
assert_eq!(out.len(), 1, "a dark layer is not drawn");
assert_eq!(out[0].image, 1);
// Into the End, which has no layers, and back: no fade.
sky.draws(1, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
assert!(out.is_empty());
sky.draws(0, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
assert_eq!(out.len(), 2);
}
#[test]
fn a_layer_turns_west_like_the_sun() {
let (root, sky) = pack(&[("sky1", "")]);
let _ = std::fs::remove_dir_all(root);
let (mut state, mut out) = (State::default(), Vec::new());
// A quarter turn after noon (sunset): the skybox's zenith has gone down to the west.
let c = Conditions {
day_time: 12000,
..noon("minecraft:plains")
};
sky.draws(0, &c, 0.25, 0.0, &mut state, &mut out);
let up = out[0].rotation.transform_vector3(Vec3::Y);
assert!((up - Vec3::NEG_X).length() < 1e-5, "{up}");
}
}
crates/horizon-client-render/src/effects.rs
+102 -13
View File
@@ -14,6 +14,8 @@ pub struct EffectInstance {
pub amplifier: i32,
pub ambient: bool,
pub visible: bool,
/// `MobEffectInstance.showIcon`: whether the HUD and inventory list it.
pub show_icon: bool,
pub hidden: Option<Box<EffectInstance>>,
}
impl EffectInstance {
@@ -24,9 +26,18 @@ impl EffectInstance {
amplifier: amplifier.clamp(0, 255),
ambient: false,
visible: true,
show_icon: true,
hidden: None,
}
}
/// `new MobEffectInstance(effect, duration, amplifier, ambient, visible)`:
/// the icon shows exactly when the particles do.
pub fn with_flags(mut self, ambient: bool, visible: bool) -> Self {
self.ambient = ambient;
self.visible = visible;
self.show_icon = visible;
self
}
fn infinite(&self) -> bool {
self.duration == -1
}
@@ -71,6 +82,10 @@ impl EffectInstance {
self.visible = take.visible;
changed = true;
}
if take.show_icon != self.show_icon {
self.show_icon = take.show_icon;
changed = true;
}
changed
}
/// `MobEffectInstance.tickClient`: a client counts its effects down
@@ -98,6 +113,7 @@ impl EffectInstance {
self.amplifier = h.amplifier;
self.ambient = h.ambient;
self.visible = h.visible;
self.show_icon = h.show_icon;
self.hidden = h.hidden;
}
}
@@ -116,8 +132,9 @@ pub enum EffectAction {
}
/// `shouldApplyEffectTickThisTick` + `applyEffectTick` for the periodic effects.
fn periodic(id: &str, tick: i32, amp: i32) -> Option<EffectAction> {
// Java's `>>` and `<<` take the shift distance modulo 32 (`wrapping_*`).
let every = |base: i32| {
let interval = base >> amp;
let interval = base.wrapping_shr(amp as u32);
interval <= 0 || tick % interval == 0
};
match id {
@@ -126,10 +143,12 @@ fn periodic(id: &str, tick: i32, amp: i32) -> Option<EffectAction> {
"wither" if every(40) => Some(EffectAction::Hurt("minecraft:wither", 1.0)),
"hunger" => Some(EffectAction::Exhaust(0.005 * (amp + 1) as f32)),
"saturation" if tick >= 1 => Some(EffectAction::Eat(amp + 1, 1.0)),
"instant_health" if tick >= 1 => Some(EffectAction::Heal((4 << amp.min(30)) as f32)),
"instant_health" if tick >= 1 => Some(EffectAction::Heal(
4i32.wrapping_shl(amp as u32).max(0) as f32,
)),
"instant_damage" if tick >= 1 => Some(EffectAction::Hurt(
"minecraft:magic",
(6 << amp.min(30)) as f32,
6i32.wrapping_shl(amp as u32) as f32,
)),
_ => None,
}
@@ -139,11 +158,11 @@ fn periodic(id: &str, tick: i32, amp: i32) -> Option<EffectAction> {
pub fn instant(id: &str, amp: i32, scale: f64) -> Option<EffectAction> {
match id {
"instant_health" => Some(EffectAction::Heal(
(scale * f64::from(4 << amp.min(30)) + 0.5) as i32 as f32,
(scale * f64::from(4i32.wrapping_shl(amp as u32)) + 0.5) as i32 as f32,
)),
"instant_damage" => Some(EffectAction::Hurt(
"minecraft:magic",
(scale * f64::from(6 << amp.min(30)) + 0.5) as i32 as f32,
(scale * f64::from(6i32.wrapping_shl(amp as u32)) + 0.5) as i32 as f32,
)),
"saturation" => Some(EffectAction::Eat(amp + 1, 1.0)),
_ => None,
@@ -168,6 +187,9 @@ pub enum OmenTick {
/// It added this effect, then returned false.
Add(EffectInstance),
}
/// A saved player's effect: id, duration, amplifier, ambient, particles
/// visible, icon shown (`MobEffectInstance.Details`).
pub type SavedEffect = (String, i32, i32, bool, bool, bool);
#[derive(Clone, Debug, Default)]
pub struct PlayerEffects {
pub list: Vec<EffectInstance>,
@@ -201,21 +223,22 @@ impl PlayerEffects {
self.list.clear();
}
/// The effects of a saved player (`Player.active_effects`: id,
/// duration, amplifier, ambient, particles visible).
pub fn from_saved(saved: &[(String, i32, i32, bool, bool)]) -> Self {
/// duration, amplifier, ambient, particles visible, icon shown).
pub fn from_saved(saved: &[SavedEffect]) -> Self {
let mut effects = Self::default();
for (id, duration, amplifier, ambient, particles) in saved {
for (id, duration, amplifier, ambient, particles, icon) in saved {
if let Some(def) = potions::effect(id) {
let mut e = EffectInstance::new(def.id, *duration, *amplifier);
e.ambient = *ambient;
e.visible = *particles;
e.show_icon = *icon;
effects.add(e);
}
}
effects
}
/// `Player.active_effects` for the save.
pub fn saved(&self) -> Vec<(String, i32, i32, bool, bool)> {
pub fn saved(&self) -> Vec<SavedEffect> {
self.list
.iter()
.map(|e| {
@@ -225,14 +248,15 @@ impl PlayerEffects {
e.amplifier,
e.ambient,
e.visible,
e.show_icon,
)
})
.collect()
}
/// ClientboundUpdateMobEffectPacket's flags without blending: ambient,
/// particles visible and the icon shown (always, for these effects).
/// particles visible and the icon shown.
pub fn flags(e: &EffectInstance) -> i8 {
i8::from(e.ambient) | i8::from(e.visible) << 1 | 4
i8::from(e.ambient) | i8::from(e.visible) << 1 | i8::from(e.show_icon) << 2
}
/// `LivingEntity.tickEffects` (server part) with the omens' effect ticks:
/// `omen` answers `BadOmenMobEffect` (every tick), `RaidOmenMobEffect`
@@ -494,7 +518,72 @@ pub fn effect_modifier(effect: &str) -> Option<(&'static str, &'static str, f64,
#[cfg(test)]
mod tests {
use super::*;
/// `HealOrHarmMobEffect`: Java's `<<` shifts by the amplifier modulo
/// 32 and wraps, so amplifier 32 is amplifier 0 again; a ticked heal is
/// at least 0 (#11386).
#[test]
fn heal_and_harm_shift_like_java() {
let magic = "minecraft:magic";
assert_eq!(
instant("instant_health", 32, 1.0),
Some(EffectAction::Heal(4.0))
);
assert_eq!(
instant("instant_damage", 33, 1.0),
Some(EffectAction::Hurt(magic, 12.0))
);
assert_eq!(
instant("instant_health", 1, 0.5),
Some(EffectAction::Heal(4.0))
);
assert_eq!(
periodic("instant_health", 1, 32),
Some(EffectAction::Heal(4.0))
);
// 4 << 29 is i32::MIN: the heal stops at 0. 6 << 30 wraps to i32::MIN.
assert_eq!(
periodic("instant_health", 1, 29),
Some(EffectAction::Heal(0.0))
);
assert_eq!(
periodic("instant_damage", 1, 30),
Some(EffectAction::Hurt(magic, i32::MIN as f32))
);
// Regeneration: 50 >> 32 is 50 again, not 0 (which would heal each tick).
assert_eq!(periodic("regeneration", 49, 32), None);
assert_eq!(
periodic("regeneration", 50, 32),
Some(EffectAction::Heal(1.0))
);
}
/// Warden darkness (`new MobEffectInstance(DARKNESS, 260, 0, false,
/// false)`) shows neither particles nor its icon; a renewal that shows the
/// icon turns it back on (`MobEffectInstance.update`).
#[test]
fn an_effect_without_particles_hides_its_icon() {
let mut fx = PlayerEffects::default();
fx.add(EffectInstance::new("darkness", 260, 0).with_flags(false, false));
let darkness = fx.get("darkness").unwrap();
// ClientboundUpdateMobEffectPacket: no ambient, particles or icon bit.
assert_eq!(PlayerEffects::flags(darkness), 0);
assert!(!crate::hud_overlays::EffectIcon::from(darkness).show_icon);
assert!(fx.add(EffectInstance::new("darkness", 100, 0)));
assert_eq!(PlayerEffects::flags(fx.get("darkness").unwrap()), 2 | 4);
// Details keeps show_icon apart from show_particles.
let mut speed = EffectInstance::new("speed", 100, 0);
speed.show_icon = false;
let mut fx = PlayerEffects::default();
fx.add(speed);
let saved = fx.saved();
assert_eq!(
saved,
[("minecraft:speed".to_owned(), 100, 0, false, true, false)]
);
let loaded = PlayerEffects::from_saved(&saved);
assert_eq!(PlayerEffects::flags(loaded.get("speed").unwrap()), 2);
}
#[test]
fn adding_counts_a_change_only_when_the_effect_changed() {
let mut fx = PlayerEffects::default();
@@ -546,11 +635,11 @@ mod tests {
1,
));
let saved = fx.saved();
assert_eq!(saved, [("ruby:glow".to_owned(), 600, 1, false, true)]);
assert_eq!(saved, [("ruby:glow".to_owned(), 600, 1, false, true, true)]);
assert_eq!(PlayerEffects::from_saved(&saved).list, fx.list);
// Without its mod the saved effect is dropped, as an unknown id is.
assert!(
PlayerEffects::from_saved(&[("gone:glow".into(), 600, 1, false, true)])
PlayerEffects::from_saved(&[("gone:glow".into(), 600, 1, false, true, true)])
.list
.is_empty()
);
crates/horizon-client-render/src/gfx.rs
+331 -97
View File
@@ -173,6 +173,7 @@ mod hdr_icc;
mod hdr_stats;
pub use hdr::Calibration as HdrCalibration;
pub mod block_light;
mod custom_sky;
mod displace;
pub mod lightning;
mod lod;
@@ -1037,6 +1038,25 @@ pub struct ScreenshotRequest {
/// `Renderer::screenshot_quality`, not the window's.
pub scaled: bool,
}
/// A solid terrain pipeline without HDR output's lighting (terrain.wgsl's `HDR_LIGHTING`),
/// for the frames HDR is off, and with it where the display offers HDR output: the
/// lighting's code, even never run, slows the shader on Apple GPUs (~15% of the solid
/// pass at Retina sizes).
pub struct SolidPipeline {
plain: wgpu::RenderPipeline,
hdr: Option<wgpu::RenderPipeline>,
}
impl SolidPipeline {
/// The pipeline for a frame with HDR output on (`hdr`) or off.
pub fn get(&self, hdr: bool) -> &wgpu::RenderPipeline {
match &self.hdr {
Some(lit) if hdr => lit,
_ => &self.plain,
}
}
}
pub struct Renderer {
instance: wgpu::Instance,
adapter: wgpu::Adapter,
@@ -1088,10 +1108,10 @@ pub struct Renderer {
/// operation fails on a lost device (no error scope sees it).
device_lost: Arc<std::sync::atomic::AtomicBool>,
pub config: wgpu::SurfaceConfiguration,
solid: wgpu::RenderPipeline,
solid: SolidPipeline,
/// `solid` split in two passes for the world pass (terrain.wgsl's `opaque_quad`).
solid_opaque: wgpu::RenderPipeline,
solid_cutout: wgpu::RenderPipeline,
solid_opaque: SolidPipeline,
solid_cutout: SolidPipeline,
translucent: wgpu::RenderPipeline,
translucent_mark: wgpu::RenderPipeline,
/// Flat section draws (`flat`), where multi-draw is emulated.
@@ -1194,6 +1214,9 @@ pub struct Renderer {
celestial_buffer: wgpu::Buffer,
end_sky: end_sky::EndSky,
stars: stars::Stars,
/// OptiFine custom sky layers (`crate::custom_sky`), and the frame's from the game.
custom_sky: custom_sky::CustomSky,
custom_sky_draws: Vec<crate::custom_sky::Draw>,
/// The glowing entities' outline (`LevelRenderer.entityOutlineTarget`).
entity_outline: entity_outline::EntityOutline,
panorama: panorama::Panorama,
@@ -1389,9 +1412,12 @@ pub struct Renderer {
hdr_output: Option<hdr::Output>,
/// What every pipeline that draws the frame targets: the swapchain's 8-bit format, or
/// `Rgba16Unorm` when the renderer was made with HDR output on (`wide_frame`) and the
/// device draws and blends into it. A 16-bit frame with HDR off since reaches the
/// swapchain through `readback`.
/// device draws and blends into it, or `LINEAR_FRAME` (`frame_format`). A 16-bit frame
/// with HDR off since reaches the swapchain through `readback`.
frame_format: wgpu::TextureFormat,
/// Whether a pack picked or dropped since the renderer was made has been told it runs on
/// the frame that exists (`set_native_shader_pack`).
frame_kept_logged: bool,
/// The marker file of an HDR output that has not presented a frame yet
/// (`graphics::HDR_MARKER`).
hdr_marker: Option<std::path::PathBuf>,
@@ -1867,9 +1893,10 @@ impl wgpu::rwh::HasDisplayHandle for WindowDisplay {
}
/// The backends to open a device on, each tried in turn until one gives a
/// device. `api` is the player's choice (`GraphicsApi::with_env` applied);
/// `os` is `std::env::consts::OS`; `wgpu_backend`: whether `WGPU_BACKEND` is set,
/// which picks the backends itself. Auto tries DirectX 12 first on Windows ARM64,
/// then Vulkan, based on the device-loss observed in a Windows ARM64 test. Other
/// `os` is `std::env::consts::OS`; `arch` the machine's (`system::machine_arch`), not the
/// build's; `wgpu_backend`: whether `WGPU_BACKEND` is set, which picks the backends itself.
/// Auto tries DirectX 12 first on Windows ARM64, the x64 build emulated there included,
/// then Vulkan, based on the device losses seen there (#7513). Other
/// Windows systems try Vulkan, then DirectX 12, then OpenGL; Linux tries Vulkan then
/// OpenGL. Each is tried when the one before has no surface, adapter or device. A native
/// crash in the driver can't be
@@ -1992,7 +2019,13 @@ fn draws_wide_frame(features: wgpu::Features, format: wgpu::TextureFormatFeature
features.contains(
wgpu::Features::TEXTURE_FORMAT_16BIT_NORM
| wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
) && format.allowed_usages.contains(
) && draws_frame(format)
}
/// Whether a format with the adapter's `format` features takes every usage and flag the
/// passes take of the frame.
fn draws_frame(format: wgpu::TextureFormatFeatures) -> bool {
format.allowed_usages.contains(
wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::COPY_SRC
@@ -2002,8 +2035,14 @@ fn draws_wide_frame(features: wgpu::Features, format: wgpu::TextureFormatFeature
)
}
/// What a renderer's frame is drawn in: `WIDE_FRAME` when it is made with HDR on and Smooth
/// Gradients (`wide_frame`, `Graphics::wide_frame`), the surface offering HDR output
/// The frame of a renderer made with a shader API 0.2 pack picked under
/// `HORIZON_HDR_FRAME=float` (docs/design/hdr-linear-light.md): float, so values over 1
/// survive from the world to the tonemap.
const LINEAR_FRAME: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
/// What a renderer's frame is drawn in: `LINEAR_FRAME` for a 0.2 pack under the switch
/// (`linear`: `(picked, the device draws it)`); else `WIDE_FRAME` when it is made with HDR on
/// and Smooth Gradients (`wide_frame`, `Graphics::wide_frame`), the surface offering HDR output
/// (`hdr_offered`) and the device drawing it (`draws_wide_frame`): an 8-bit frame's steps band
/// in dark gradients, and HDR shows them. Else the swapchain's 8-bit format, as without HDR.
fn frame_format(
@@ -2011,8 +2050,11 @@ fn frame_format(
hdr_offered: bool,
device_draws_it: bool,
swapchain: wgpu::TextureFormat,
linear: (bool, bool),
) -> wgpu::TextureFormat {
if wide_frame && hdr_offered && device_draws_it {
if linear.0 && linear.1 {
LINEAR_FRAME
} else if wide_frame && hdr_offered && device_draws_it {
WIDE_FRAME
} else {
swapchain.remove_srgb_suffix()
@@ -2033,7 +2075,8 @@ async fn open_device(
for (order, allow_cpu) in device_search(
api.with_env(),
std::env::consts::OS,
std::env::consts::ARCH,
// The machine's: the x64 build emulated on a Windows ARM64 PC has its GPU too (#7513).
horizon_telemetry::system::machine_arch(),
wgpu_backend,
) {
match open_device_with(window, offscreen, &order, layers, allow_cpu).await {
@@ -2485,6 +2528,7 @@ impl Renderer {
translucent_batching: bool,
wide_frame: bool,
shader_pack: bool,
linear_pack: bool,
) -> Result<Self> {
let Opened {
instance,
@@ -2618,7 +2662,22 @@ impl Renderer {
adapter.get_texture_format_features(WIDE_FRAME),
);
crate::graphics::offer_smooth_gradients(wide_ok);
let frame_format = frame_format(wide_frame, hdr_output.is_some(), wide_ok, config.format);
let linear = (
linear_pack,
draws_frame(adapter.get_texture_format_features(LINEAR_FRAME)),
);
if linear == (true, false) {
log::warn!(
"Horizon renderer: the device can't draw a float frame; the shader API 0.2 pack runs on the 8-bit one"
);
}
let frame_format = frame_format(
wide_frame,
hdr_output.is_some(),
wide_ok,
config.format,
linear,
);
if previous.is_none() {
startup_step(format_args!("creating the pipelines"));
}
@@ -2752,16 +2811,24 @@ impl Renderer {
step_mode: wgpu::VertexStepMode::Instance,
attributes: &debug_line_attributes,
})];
let pipeline_in = |layout: &wgpu::PipelineLayout,
label: &str,
vertex: &str,
fragment: &str,
buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
topology: wgpu::PrimitiveTopology,
cull: Option<wgpu::Face>,
depth_write: bool,
depth_test: bool,
blend: Option<wgpu::BlendState>| {
// The solid terrain's fragment constants without HDR output's lighting, for the
// frames HDR is off (`SolidPipeline`).
let plain_constants = [
sprite_constants[0],
sprite_constants[1],
("HDR_LIGHTING", 0.0),
];
let pipeline_with = |constants: &[(&str, f64)],
layout: &wgpu::PipelineLayout,
label: &str,
vertex: &str,
fragment: &str,
buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
topology: wgpu::PrimitiveTopology,
cull: Option<wgpu::Face>,
depth_write: bool,
depth_test: bool,
blend: Option<wgpu::BlendState>| {
kept.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(layout),
@@ -2792,7 +2859,7 @@ impl Renderer {
module: &shader,
entry_point: Some(fragment),
compilation_options: wgpu::PipelineCompilationOptions {
constants: &sprite_constants,
constants,
..Default::default()
},
targets: &[Some(wgpu::ColorTargetState {
@@ -2805,6 +2872,57 @@ impl Renderer {
cache: None,
})
};
let pipeline_in = |layout: &wgpu::PipelineLayout,
label: &str,
vertex: &str,
fragment: &str,
buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
topology: wgpu::PrimitiveTopology,
cull: Option<wgpu::Face>,
depth_write: bool,
depth_test: bool,
blend: Option<wgpu::BlendState>| {
pipeline_with(
&sprite_constants,
layout,
label,
vertex,
fragment,
buffers,
topology,
cull,
depth_write,
depth_test,
blend,
)
};
// A solid terrain pipeline (back faces culled, depth written, no blend) without HDR
// output's lighting, and with it where the display offers HDR output.
let solid_in = |layout: &wgpu::PipelineLayout,
label: &str,
vertex: &str,
fragment: &str,
buffers: &[Option<wgpu::VertexBufferLayout<'_>>]| {
let build = |constants: &[(&str, f64)]| {
pipeline_with(
constants,
layout,
label,
vertex,
fragment,
buffers,
wgpu::PrimitiveTopology::TriangleList,
Some(wgpu::Face::Back),
true,
true,
None,
)
};
SolidPipeline {
plain: build(&plain_constants),
hdr: hdr_output.is_some().then(|| build(&sprite_constants)),
}
};
let pipeline = |label: &str,
vertex: &str,
fragment: &str,
@@ -2828,41 +2946,29 @@ impl Renderer {
)
};
let tri = wgpu::PrimitiveTopology::TriangleList;
let solid = pipeline(
let solid = solid_in(
&layout,
"Terrain solid",
"vs_terrain",
"fs_solid",
&terrain_buffers,
tri,
Some(wgpu::Face::Back),
true,
true,
None,
);
// `solid` in two passes (terrain.wgsl's `opaque_quad`, `mesher::Part`), for the
// world pass without a shader pack: no cutout first, through a shader that never
// discards, then the rest.
let solid_opaque = pipeline(
let solid_opaque = solid_in(
&layout,
"Terrain solid opaque",
"vs_terrain_opaque",
"fs_opaque",
&terrain_buffers,
tri,
Some(wgpu::Face::Back),
true,
true,
None,
);
let solid_cutout = pipeline(
let solid_cutout = solid_in(
&layout,
"Terrain solid cutout",
"vs_terrain_cutout",
"fs_solid",
&terrain_buffers,
tri,
Some(wgpu::Face::Back),
true,
true,
None,
);
// The water mirror's camera sees the world from the other side of the plane, which
// flips the winding: its solid terrain culls the front.
@@ -4411,6 +4517,7 @@ impl Renderer {
layout, label, vertex, fragment, buffers, tri, cull, true, true, blend,
)
},
|layout, label, vertex, fragment| solid_in(layout, label, vertex, fragment, &[]),
)
});
// With flat draws' page groups the per-section solid draws read their vertices from
@@ -4424,40 +4531,24 @@ impl Renderer {
..Default::default()
});
let origins = [None, terrain_buffers[1].clone()];
let pulled = |label: &str, vertex: &str, fragment: &str, cull| {
let solid = |label: &str, vertex: &str, fragment: &str| {
solid_in(&pulled_layout, label, vertex, fragment, &origins)
};
(
solid("Terrain solid", "vs_section", "fs_solid"),
solid("Terrain solid opaque", "vs_section_opaque", "fs_opaque"),
solid("Terrain solid cutout", "vs_section_cutout", "fs_solid"),
pipeline_in(
&pulled_layout,
label,
vertex,
fragment,
&origins,
tri,
Some(cull),
true,
true,
None,
)
};
let back = wgpu::Face::Back;
(
pulled("Terrain solid", "vs_section", "fs_solid", back),
pulled(
"Terrain solid opaque",
"vs_section_opaque",
"fs_opaque",
back,
),
pulled(
"Terrain solid cutout",
"vs_section_cutout",
"fs_solid",
back,
),
pulled(
"Terrain solid (mirrored)",
"vs_section",
"fs_solid_mirror",
wgpu::Face::Front,
&origins,
tri,
Some(wgpu::Face::Front),
true,
true,
None,
),
)
}
@@ -4559,6 +4650,7 @@ impl Renderer {
let uploads = upload::Uploads::new(&device);
let section_uploads = upload::Uploads::with_chunk(&device, SECTION_UPLOAD_CHUNK);
let stars = stars::Stars::new(&device, frame_format);
let custom_sky = custom_sky::CustomSky::new(&device, frame_format);
let entity_outline = entity_outline::EntityOutline::new(
&device,
(&entity_shader, &entity_layout, &entity_vertex),
@@ -4683,6 +4775,8 @@ impl Renderer {
celestial_buffer,
end_sky: end_sky::EndSky::default(),
stars,
custom_sky,
custom_sky_draws: Vec::new(),
entity_outline,
panorama,
border_pipeline,
@@ -4800,6 +4894,7 @@ impl Renderer {
emission_stats,
hdr_output,
frame_format,
frame_kept_logged: false,
hdr_marker: None,
pack_post: None,
pack_loading: None,
@@ -4902,6 +4997,15 @@ impl Renderer {
}
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
}
/// The pack's OptiFine custom sky layer textures (`crate::custom_sky::CustomSky::load`).
pub fn set_custom_sky(&mut self, pack: &crate::custom_sky::CustomSky) {
self.custom_sky.set_pack(&self.device, &self.queue, pack);
}
/// The custom sky layers the next frame draws (`CustomSky::draws`): the game refills it each
/// frame, empty when the world's sky has none.
pub fn custom_sky_draws(&mut self) -> &mut Vec<crate::custom_sky::Draw> {
&mut self.custom_sky_draws
}
/// The resource packs' `core/rendertype_lines` (`HudAtlas::lines_shader`) for the block
/// outline, or the built-in one.
pub fn set_lines_shader(&mut self, program: Option<&horizon_shaders::CoreProgram>) {
@@ -6747,6 +6851,18 @@ impl Renderer {
block_light::LightTable,
)>,
) -> std::result::Result<Vec<String>, String> {
let linear = pack
.as_ref()
.is_some_and(|p| p.0.manifest.api == horizon_shader_api::Api::V0_2);
if (linear || self.frame_format == LINEAR_FRAME)
&& linear != (self.frame_format == LINEAR_FRAME)
&& !std::mem::replace(&mut self.frame_kept_logged, true)
{
log::info!(
"Horizon renderer: the {:?} frame stays until the renderer is made again; a shader API 0.2 pack picked or dropped since runs on it",
self.frame_format
);
}
let Some((report, constants, sprite_tags, sprite_materials, lights)) = pack else {
self.native = None;
return Ok(Vec::new());
@@ -8947,6 +9063,12 @@ impl Renderer {
brightness,
);
}
self.custom_sky.prepare(
&mut self.uploads,
&mut encoder,
jittered,
&self.custom_sky_draws,
);
let celestial_vertices = frame.celestial.len().min(2048 * 4);
if frame.end_sky && !frame.title {
self.end_sky.prepare(&self.device, frame.end_sky_sprite);
@@ -9555,6 +9677,8 @@ impl Renderer {
}
}
if let Some(native) = &mut self.native {
let reflection =
reflection.map(|view| native.frame.linear_mirror(&self.device, &mut encoder, view));
native
.frame
.set_reflection(&self.device, reflection.as_ref());
@@ -9588,7 +9712,9 @@ impl Renderer {
.as_ref()
.filter(|_| !frame.title)
.and_then(|n| Some((n.material.as_ref()?, &n.frame.group)));
let solid_pipeline = material.map_or(&self.solid, |(m, _)| &m.solid);
// Without HDR output, the solid shaders without its lighting (`SolidPipeline`).
let hdr = self.hdr.is_some();
let solid_pipeline = material.map_or(self.solid.get(hdr), |(m, _)| &m.solid);
// Two solid passes only where a discard costs the GPU its hidden surface
// removal: Apple's tiled GPUs, behind Metal. Elsewhere the second pass
// would double the solid draw calls and vertex work for nothing.
@@ -9686,6 +9812,12 @@ impl Renderer {
pass.set_vertex_buffer(0, self.sunrise_buffer.slice(..));
pass.draw(0..sunrise_fan::VERTICES as u32, 0..1);
}
// OptiFine custom sky layers, over the disc and sunrise and under the
// sun, moon and stars.
if self.custom_sky.is_drawing() {
self.custom_sky.draw(&mut pass);
pass.set_bind_group(0, &self.group, &[]);
}
}
}
}
@@ -9698,6 +9830,13 @@ impl Renderer {
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
if frame.end_sky {
self.end_sky.draw(&mut pass);
// The End's custom sky layers go over its sky box.
if self.custom_sky.is_drawing() && !pack_draws_sky && self.native.is_none()
{
self.custom_sky.draw(&mut pass);
pass.set_pipeline(&self.celestial_pipeline);
pass.set_bind_group(0, &self.entity_group, &[]);
}
}
if celestial_vertices > 0 && !pack_draws_celestial {
// The Overworld's bodies start with the sun's quad
@@ -9813,14 +9952,14 @@ impl Renderer {
let passes: &[(&wgpu::RenderPipeline, Calls, Calls)] = match pack_flat {
Some(p) => &[(&p.0, 0..flat.phase1_calls, 0..phase2_calls)],
None if split_solid => &[
(&flat.solid_opaque, 0..opaque, 0..phase2_split),
(flat.solid_opaque.get(hdr), 0..opaque, 0..phase2_split),
(
&flat.solid_cutout,
flat.solid_cutout.get(hdr),
cutout..flat.phase1_calls,
phase2_split..phase2_calls,
),
],
None => &[(&flat.solid, 0..flat.phase1_calls, 0..phase2_calls)],
None => &[(flat.solid.get(hdr), 0..flat.phase1_calls, 0..phase2_calls)],
};
let draw = |pass: &mut wgpu::RenderPass<'_>| {
for (pipeline, calls, _) in passes {
@@ -9873,9 +10012,13 @@ impl Renderer {
type Draws = std::ops::Range<u32>;
let passes: &[(&wgpu::RenderPipeline, Draws, Draws)] = match material {
None if split_solid => &[
(&self.solid_opaque, 0..opaque, phase1_draws..phase2_cutout),
(
&self.solid_cutout,
self.solid_opaque.get(hdr),
0..opaque,
phase1_draws..phase2_cutout,
),
(
self.solid_cutout.get(hdr),
cutout..phase1_draws,
phase2_cutout..solid_draws,
),
@@ -10261,12 +10404,7 @@ impl Renderer {
depth.size(),
);
if let Some((color, _)) = &scaled {
let color = color.texture();
encoder.copy_texture_to_texture(
color.as_image_copy(),
native.frame.opaque_color.as_image_copy(),
color.size(),
);
native.frame.copy_opaque(&self.device, &mut encoder, color);
}
pass = world_pass_after_culling(
&mut encoder,
@@ -10898,12 +11036,18 @@ impl Renderer {
{
self.readback.present(&self.device, &mut encoder, image);
}
// A 0.2 pack is shown at paper white: HDR output lifts nothing of its world.
let lifts_world = !frame.title
&& self
.native
.as_ref()
.is_none_or(|n| n.frame.api == horizon_shader_api::Api::V0_1);
match (&self.hdr, &surface_frame) {
(Some(hdr), Some(f)) => hdr.present(
&self.queue,
&mut encoder,
&f.texture,
!frame.title,
lifts_world,
self.own_timing.as_mut(),
),
// Offscreen nothing shows HDR: the target gets the frame as SDR shows it, for
@@ -10922,7 +11066,7 @@ impl Renderer {
.filter(|(request, _)| request.size.is_none())
.zip(self.hdr.as_ref())
.and_then(|(_, hdr)| {
let texture = hdr.capture(&self.device, &self.queue, &mut encoder, !frame.title)?;
let texture = hdr.capture(&self.device, &self.queue, &mut encoder, lifts_world)?;
let size = [self.config.width, self.config.height];
Some(copy_frame(&self.device, &mut encoder, &texture, size))
});
@@ -12452,20 +12596,39 @@ mod tests {
fn the_frame_is_16_bit_only_with_hdr_and_a_device_that_draws_it() {
use super::frame_format;
use wgpu::TextureFormat::{Bgra8Unorm, Bgra8UnormSrgb, Rgba8Unorm, Rgba16Unorm};
assert_eq!(frame_format(true, true, true, Bgra8Unorm), Rgba16Unorm);
for (wide_frame, hdr_offered, draws) in [
(false, true, true),
(true, false, true),
(true, true, false),
(false, false, false),
] {
// No 0.2 pack (or a device without the float frame) leaves it as before.
for linear in [(false, false), (false, true), (true, false)] {
assert_eq!(
frame_format(wide_frame, hdr_offered, draws, Bgra8UnormSrgb),
Bgra8Unorm
frame_format(true, true, true, Bgra8Unorm, linear),
Rgba16Unorm
);
for (wide_frame, hdr_offered, draws) in [
(false, true, true),
(true, false, true),
(true, true, false),
(false, false, false),
] {
assert_eq!(
frame_format(wide_frame, hdr_offered, draws, Bgra8UnormSrgb, linear),
Bgra8Unorm
);
assert_eq!(
frame_format(wide_frame, hdr_offered, draws, Rgba8Unorm, linear),
Rgba8Unorm
);
}
}
}
/// A shader API 0.2 pack picked under `HORIZON_HDR_FRAME=float` gets the float frame
/// wherever the device draws it, HDR on or off.
#[test]
fn a_0_2_pack_gets_the_float_frame_where_the_device_draws_it() {
use super::{LINEAR_FRAME, frame_format};
use wgpu::TextureFormat::Bgra8UnormSrgb;
for (wide_frame, hdr_offered, draws) in [(true, true, true), (false, false, false)] {
assert_eq!(
frame_format(wide_frame, hdr_offered, draws, Rgba8Unorm),
Rgba8Unorm
frame_format(wide_frame, hdr_offered, draws, Bgra8UnormSrgb, (true, true)),
LINEAR_FRAME
);
}
}
@@ -12865,6 +13028,77 @@ mod tests {
}
}
#[test]
fn plain_solid_shaders_translate_for_every_backend() {
// `SolidPipeline::plain` builds terrain.wgsl's solid entries with `HDR_LIGHTING`
// off on every backend: they must still translate (the other test translates them
// with the constants' defaults).
let module = naga::front::wgsl::parse_str(include_str!("terrain.wgsl")).unwrap();
let info = naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.unwrap();
let stage = naga::ShaderStage::Fragment;
let constants = [("HDR_LIGHTING".to_owned(), 0.0)].into_iter().collect();
for entry in ["fs_solid", "fs_opaque"] {
let (module, info) = naga::back::pipeline_constants::process_overrides(
&module,
&info,
Some((stage, entry)),
&constants,
)
.unwrap();
let msl = naga::back::msl::write_string(
&module,
&info,
&naga::back::msl::Options {
fake_missing_bindings: true,
..Default::default()
},
&naga::back::msl::PipelineOptions {
entry_point: Some((stage, entry.to_owned())),
..Default::default()
},
);
// Metal compiles the lighting out from this constant.
assert!(
msl.unwrap()
.0
.contains("constant bool HDR_LIGHTING = false;"),
"{entry}"
);
let mut hlsl = String::new();
naga::back::hlsl::Writer::new(
&mut hlsl,
&Default::default(),
&naga::back::hlsl::PipelineOptions {
entry_point: Some((stage, entry.to_owned())),
},
)
.write(&module, &info, None)
.unwrap_or_else(|e| panic!("{entry}: {e}"));
let mut glsl = String::new();
naga::back::glsl::Writer::new(
&mut glsl,
&module,
&info,
&naga::back::glsl::Options {
version: naga::back::glsl::Version::Desktop(330),
..Default::default()
},
&naga::back::glsl::PipelineOptions {
shader_stage: stage,
entry_point: entry.to_owned(),
multiview: None,
},
Default::default(),
)
.and_then(|mut w| w.write())
.unwrap_or_else(|e| panic!("{entry}: {e}"));
}
}
#[test]
fn entity_shader_validates_with_its_overlay_constants() {
let module = naga::front::wgsl::parse_str(&super::entity_shader()).unwrap();
naga::valid::Validator::new(
crates/horizon-client-render/src/gfx/arena.rs
+8 -1
View File
@@ -1040,7 +1040,14 @@ mod tests {
cache: None,
})
};
let mut flat = flat::Flat::new(&device, &terrain_layout, 4 * GRAIN, 0, pipeline);
let pipeline = &pipeline;
let solid = |layout: &wgpu::PipelineLayout, label: &str, _: &str, _: &str| {
super::super::SolidPipeline {
plain: pipeline(layout, label, "", "", None, None, true),
hdr: None,
}
};
let mut flat = flat::Flat::new(&device, &terrain_layout, 4 * GRAIN, 0, pipeline, solid);
let stride = std::mem::size_of::<crate::mesher::TerrainVertex>() as u64;
let mut translucent = Arena::translucent(&device, stride, 4 * GRAIN);
translucent.page_limit = 4 * GRAIN;
crates/horizon-client-render/src/gfx/custom_sky.rs
+416
View File
@@ -0,0 +1,416 @@
//! OptiFine custom sky layers on the GPU: one texture per layer, kept with the renderer (its pack),
//! a static skybox mesh of the 3x2 grid's six faces, and one pipeline per blend mode. A frame
//! uploads one small uniform per drawn layer ([`crate::custom_sky::Draw`]) and draws 36 vertices
//! each, after the vanilla sky's disc and sunrise and before the sun, moon and stars.
use glam::Mat4;
use horizon_optifine::sky::{Blend, Face};
use wgpu::util::DeviceExt;
use crate::custom_sky::{CustomSky as Pack, Draw};
/// The blend modes in the shader's `mode` order (custom_sky.wgsl).
const MODES: [Blend; 9] = [
Blend::Add,
Blend::Subtract,
Blend::Multiply,
Blend::Dodge,
Blend::Burn,
Blend::Screen,
Blend::Replace,
Blend::Overlay,
Blend::Alpha,
];
/// Layers drawn in a frame at most; a pack's later ones wait for a frame with fewer.
const MAX_DRAWS: usize = 32;
/// Dynamic uniform offsets are 256-byte aligned on every backend.
const STRIDE: u64 = 256;
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct Uniform {
clip_from_sky: [[f32; 4]; 4],
brightness: f32,
mode: u32,
pad: [u32; 2],
}
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct Vertex {
position: [f32; 3],
uv: [f32; 2],
cell: [f32; 4],
}
pub(super) struct CustomSky {
pipelines: Vec<wgpu::RenderPipeline>,
layout: wgpu::BindGroupLayout,
sampler: wgpu::Sampler,
uniform: wgpu::Buffer,
vertices: wgpu::Buffer,
/// One bind group per layer texture of the pack.
groups: Vec<wgpu::BindGroup>,
/// This frame's layers: bind group and pipeline indices.
frame: Vec<(u16, u8)>,
}
/// The fragment's output for each mode is in custom_sky.wgsl; these factors finish it.
fn blend(mode: Blend) -> wgpu::BlendComponent {
use wgpu::BlendFactor as F;
let (src_factor, dst_factor, operation) = match mode {
Blend::Add => (F::One, F::One, wgpu::BlendOperation::Add),
Blend::Subtract => (F::One, F::One, wgpu::BlendOperation::ReverseSubtract),
Blend::Multiply => (F::Zero, F::Src, wgpu::BlendOperation::Add),
// dst + dst * src: lightens.
Blend::Dodge => (F::Dst, F::One, wgpu::BlendOperation::Add),
// dst * (1 - src): darkens.
Blend::Burn => (F::Zero, F::OneMinusSrc, wgpu::BlendOperation::Add),
// src + dst * (1 - src) = 1 - (1 - src)(1 - dst).
Blend::Screen => (F::One, F::OneMinusSrc, wgpu::BlendOperation::Add),
Blend::Replace => (F::One, F::Zero, wgpu::BlendOperation::Add),
// dst * src + src * dst.
Blend::Overlay => (F::Dst, F::Src, wgpu::BlendOperation::Add),
Blend::Alpha => (F::SrcAlpha, F::OneMinusSrcAlpha, wgpu::BlendOperation::Add),
};
wgpu::BlendComponent {
src_factor,
dst_factor,
operation,
}
}
/// The skybox's 36 vertices: two triangles per face, each corner with its cell's UV.
fn mesh() -> Vec<Vertex> {
let mut out = Vec::with_capacity(36);
for face in Face::ALL {
let cell = face.cell();
let [u0, v0, u1, v1] = cell;
let uv = [[u0, v0], [u1, v0], [u1, v1], [u0, v1]];
let corners = face.corners();
for i in [0, 1, 2, 0, 2, 3] {
out.push(Vertex {
position: corners[i],
uv: uv[i],
cell,
});
}
}
out
}
impl CustomSky {
pub(super) fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Custom sky bindings"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
min_binding_size: wgpu::BufferSize::new(
std::mem::size_of::<Uniform>() as u64
),
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Custom sky shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("custom_sky.wgsl").into()),
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Custom sky layout"),
bind_group_layouts: &[Some(&layout)],
..Default::default()
});
let attributes = wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Float32x4];
let pipelines = MODES
.iter()
.map(|&mode| {
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Custom sky layer"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_custom_sky"),
compilation_options: Default::default(),
buffers: &[Some(wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Vertex>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &attributes,
})],
},
primitive: wgpu::PrimitiveState {
cull_mode: None,
..Default::default()
},
depth_stencil: Some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: Some(false),
depth_compare: Some(wgpu::CompareFunction::Always),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some("fs_custom_sky"),
compilation_options: Default::default(),
targets: &[Some(wgpu::ColorTargetState {
format,
// The frame's alpha is HDR output's mark (hdr.wgsl): the sky
// under the layers keeps its own.
blend: Some(wgpu::BlendState {
color: blend(mode),
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::Zero,
dst_factor: wgpu::BlendFactor::One,
operation: wgpu::BlendOperation::Add,
},
}),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
multiview_mask: None,
cache: None,
})
})
.collect();
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Custom sky"),
min_filter: wgpu::FilterMode::Linear,
mag_filter: wgpu::FilterMode::Linear,
..Default::default()
});
let uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Custom sky layers"),
size: STRIDE * MAX_DRAWS as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let vertices = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Custom sky box"),
contents: bytemuck::cast_slice(&mesh()),
usage: wgpu::BufferUsages::VERTEX,
});
Self {
pipelines,
layout,
sampler,
uniform,
vertices,
groups: Vec::new(),
frame: Vec::new(),
}
}
/// The pack's layer textures, replacing any before.
pub(super) fn set_pack(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, pack: &Pack) {
let limit = device.limits().max_texture_dimension_2d;
self.groups = pack
.images
.iter()
.map(|image| {
// Too large for this GPU: a 1x1 transparent texel, so the layer draws nothing.
let (width, height, rgba) = if image.width <= limit && image.height <= limit {
(image.width, image.height, &image.rgba[..])
} else {
log::warn!(
"custom sky texture of {}x{} too large",
image.width,
image.height
);
(1, 1, &[0u8; 4][..])
};
let texture = device.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
label: Some("Custom sky layer"),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
rgba,
);
let view = texture.create_view(&Default::default());
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Custom sky layer"),
layout: &self.layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &self.uniform,
offset: 0,
size: wgpu::BufferSize::new(std::mem::size_of::<Uniform>() as u64),
}),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&self.sampler),
},
],
})
})
.collect();
}
/// Upload this frame's layers; `clip` is clip space from camera-relative world.
pub(super) fn prepare(
&mut self,
uploads: &mut super::upload::Uploads,
encoder: &mut wgpu::CommandEncoder,
clip: Mat4,
draws: &[Draw],
) {
self.frame.clear();
for draw in draws.iter().take(MAX_DRAWS) {
if usize::from(draw.image) >= self.groups.len() {
continue;
}
let mode = MODES.iter().position(|m| *m == draw.blend).unwrap_or(0);
let uniform = Uniform {
clip_from_sky: (clip * draw.rotation).to_cols_array_2d(),
brightness: draw.brightness.clamp(0.0, 1.0),
mode: mode as u32,
pad: [0; 2],
};
let offset = STRIDE * self.frame.len() as u64;
uploads.buffer(encoder, &self.uniform, offset, bytemuck::bytes_of(&uniform));
self.frame.push((draw.image, mode as u8));
}
}
pub(super) fn is_drawing(&self) -> bool {
!self.frame.is_empty()
}
/// The layers [`CustomSky::prepare`] uploaded. Leaves the pass's pipeline and bind group 0
/// changed.
pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>) {
pass.set_vertex_buffer(0, self.vertices.slice(..));
for (i, &(image, mode)) in self.frame.iter().enumerate() {
pass.set_pipeline(&self.pipelines[usize::from(mode)]);
pass.set_bind_group(
0,
&self.groups[usize::from(image)],
&[(STRIDE * i as u64) as u32],
);
pass.draw(0..36, 0..1);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
/// What a blend leaves a sky texel of `dst` with when the shader outputs `src`
/// (custom_sky.wgsl) for a layer texel `t` at brightness `b`, per channel.
fn mix(mode: Blend, dst: f32, t: f32, a: f32, b: f32) -> f32 {
let k = a * b;
let src = match mode {
Blend::Multiply => 1.0 + (t - 1.0) * k,
Blend::Overlay => 0.5 + (t - 0.5) * k,
Blend::Replace | Blend::Alpha => t,
_ => t * k,
};
let c = blend(mode);
let f = |factor: wgpu::BlendFactor| match factor {
wgpu::BlendFactor::One => 1.0,
wgpu::BlendFactor::Zero => 0.0,
wgpu::BlendFactor::Src => src,
wgpu::BlendFactor::OneMinusSrc => 1.0 - src,
wgpu::BlendFactor::Dst => dst,
wgpu::BlendFactor::SrcAlpha => k,
wgpu::BlendFactor::OneMinusSrcAlpha => 1.0 - k,
other => panic!("{other:?}"),
};
let (s, d) = (src * f(c.src_factor), dst * f(c.dst_factor));
match c.operation {
wgpu::BlendOperation::Add => s + d,
wgpu::BlendOperation::ReverseSubtract => d - s,
other => panic!("{other:?}"),
}
}
#[test]
fn every_mode_gives_its_documented_result() {
let close = |a: f32, b: f32| assert!((a - b).abs() < 1e-6, "{a} != {b}");
// Full brightness and alpha, a sky texel of 0.4 under a layer texel of 0.8.
let (d, t) = (0.4, 0.8);
close(mix(Blend::Add, d, t, 1.0, 1.0), 1.2);
close(mix(Blend::Subtract, d, t, 1.0, 1.0), -0.4);
close(mix(Blend::Multiply, d, t, 1.0, 1.0), 0.32);
close(mix(Blend::Screen, d, t, 1.0, 1.0), 1.0 - 0.6 * 0.2);
close(mix(Blend::Replace, d, t, 1.0, 1.0), 0.8);
close(mix(Blend::Overlay, d, t, 1.0, 1.0), 0.64);
close(mix(Blend::Overlay, d, 0.2, 1.0, 1.0), 0.16);
close(mix(Blend::Alpha, d, t, 0.25, 1.0), 0.4 * 0.75 + 0.8 * 0.25);
assert!(mix(Blend::Dodge, d, t, 1.0, 1.0) > d);
assert!(mix(Blend::Burn, d, t, 1.0, 1.0) < d);
// Faded out, every mode but replace (drawn only when bright) leaves the sky alone.
for mode in MODES {
if mode != Blend::Replace {
close(mix(mode, d, t, 1.0, 0.0), d);
}
}
// Half faded: add adds half.
close(mix(Blend::Add, d, t, 1.0, 0.5), 0.8);
}
#[test]
fn the_shader_validates() {
let module = naga::front::wgsl::parse_str(include_str!("custom_sky.wgsl")).unwrap();
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.unwrap();
}
#[test]
fn the_box_covers_every_face_with_its_cell() {
let mesh = mesh();
assert_eq!(mesh.len(), 36);
for v in &mesh {
let [u0, v0, u1, v1] = v.cell;
assert!((u0..=u1).contains(&v.uv[0]) && (v0..=v1).contains(&v.uv[1]));
assert_eq!(v.position.iter().filter(|c| c.abs() == 1.0).count(), 3);
}
}
}
crates/horizon-client-render/src/gfx/custom_sky.wgsl
+61
View File
@@ -0,0 +1,61 @@
// OptiFine custom sky layers (gfx/custom_sky.rs): one skybox per draw, its six faces cut from a
// 3x2 texture, mixed with the sky under it by the pipeline's blend. The fragment's output is
// chosen so that blend gives the layer's documented mode at its brightness, and a layer at
// brightness 0 leaves the sky as it was.
struct Layer {
// Projection * view (camera-relative) * the layer's rotation.
clip_from_sky: mat4x4<f32>,
brightness: f32,
// horizon_optifine::sky::Blend, in gfx/custom_sky.rs's MODES order.
mode: u32,
}
@group(0) @binding(0) var<uniform> layer: Layer;
@group(0) @binding(1) var sky_texture: texture_2d<f32>;
@group(0) @binding(2) var sky_sampler: sampler;
struct Out {
@builtin(position) clip: vec4<f32>,
@location(0) uv: vec2<f32>,
// The face's cell (u0, v0, u1, v1): sampling stays half a texel inside it.
@location(1) @interpolate(flat) cell: vec4<f32>,
}
@vertex fn vs_custom_sky(
@location(0) position: vec3<f32>,
@location(1) uv: vec2<f32>,
@location(2) cell: vec4<f32>,
) -> Out {
var out: Out;
out.clip = layer.clip_from_sky * vec4(position * 100.0, 1.0);
out.uv = uv;
out.cell = cell;
return out;
}
const ADD: u32 = 0u;
const SUBTRACT: u32 = 1u;
const MULTIPLY: u32 = 2u;
const DODGE: u32 = 3u;
const BURN: u32 = 4u;
const SCREEN: u32 = 5u;
const REPLACE: u32 = 6u;
const OVERLAY: u32 = 7u;
const ALPHA: u32 = 8u;
@fragment fn fs_custom_sky(in: Out) -> @location(0) vec4<f32> {
let half = 0.5 / vec2<f32>(textureDimensions(sky_texture));
let uv = clamp(in.uv, in.cell.xy + half, in.cell.zw - half);
let t = textureSample(sky_texture, sky_sampler, uv);
let k = t.a * layer.brightness;
switch layer.mode {
// dst * src: white leaves the sky alone.
case MULTIPLY: { return vec4(mix(vec3(1.0), t.rgb, k), 1.0); }
// 2 * dst * src: grey leaves it alone.
case OVERLAY: { return vec4(mix(vec3(0.5), t.rgb, k), 1.0); }
case REPLACE: { return vec4(t.rgb, 1.0); }
// mix(dst, src, alpha).
case ALPHA: { return vec4(t.rgb, k); }
// add, subtract, dodge, burn, screen: the layer premultiplied, black leaves it alone.
default: { return vec4(t.rgb * k, 1.0); }
}
}
crates/horizon-client-render/src/gfx/flat.rs
+10 -16
View File
@@ -17,6 +17,7 @@
//! copied after the test, which tells which ones it saw: each run of a page
//! reserves room for all of its draws, the copy packs the seen ones at its
//! start, and the run is drawn indirectly with the count the copy reached.
use super::SolidPipeline;
use super::arena::GRAIN;
/// One section draw for `flatten.wgsl`: index count, first sorted index (or
@@ -86,12 +87,12 @@ pub struct Call {
pub struct Flat {
/// The solid draws in one pass (`fs_solid`), where the GPU doesn't hide pixels
/// by tiles (`split_solid` in `Renderer::draw_frame`: elsewhere than Metal).
pub solid: wgpu::RenderPipeline,
pub solid: SolidPipeline,
/// The solid draws in two passes, each over its own part of the draws (terrain.wgsl's
/// `opaque_quad`): the quads with no cutout first, through a shader that never discards,
/// then the rest.
pub solid_opaque: wgpu::RenderPipeline,
pub solid_cutout: wgpu::RenderPipeline,
pub solid_opaque: SolidPipeline,
pub solid_cutout: SolidPipeline,
/// The solid draws as the water mirror's camera draws them (`fs_solid_mirror`).
pub solid_mirror: wgpu::RenderPipeline,
pub translucent: wgpu::RenderPipeline,
@@ -357,7 +358,8 @@ fn plan(
impl Flat {
/// `pipeline(layout, label, vertex entry, fragment entry, blend, cull, pulled)` builds a
/// terrain pipeline as the per-section ones, without the origin buffer, and without
/// vertex buffers when `pulled` (its vertex shader reads the page, `ARENA_BINDING`).
/// vertex buffers when `pulled` (its vertex shader reads the page, `ARENA_BINDING`);
/// `solid(layout, label, vertex entry, fragment entry)` a pulled solid one.
pub fn new(
device: &wgpu::Device,
terrain_layout: &wgpu::BindGroupLayout,
@@ -372,6 +374,7 @@ impl Flat {
Option<wgpu::Face>,
bool,
) -> wgpu::RenderPipeline,
solid: impl Fn(&wgpu::PipelineLayout, &str, &str, &str) -> SolidPipeline,
) -> Self {
let vertex = wgpu::ShaderStages::VERTEX;
let compute = wgpu::ShaderStages::COMPUTE;
@@ -432,32 +435,23 @@ impl Flat {
Self {
// The solid draws read either layout of the solid quads (`mesher::packed`) from
// the page; translucent ones keep their vertex buffer.
solid: pipeline(
solid: solid(
&layout,
"Terrain solid (flat)",
"vs_section_flat",
"fs_solid",
None,
back,
true,
),
solid_opaque: pipeline(
solid_opaque: solid(
&layout,
"Terrain solid opaque (flat)",
"vs_section_flat_opaque",
"fs_opaque",
None,
back,
true,
),
solid_cutout: pipeline(
solid_cutout: solid(
&layout,
"Terrain solid cutout (flat)",
"vs_section_flat_cutout",
"fs_solid",
None,
back,
true,
),
// The mirror flips the winding: its solid terrain culls the front.
solid_mirror: pipeline(
crates/horizon-client-render/src/gfx/native_material.rs
+158 -14
View File
@@ -162,11 +162,13 @@ fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4<f32
horizon_material_face_normal = normal;
horizon_surface = vec4<f32>(0.0);
let tangent = horizon_material_tangent(in.base, in.uv, normal);
return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv,
translucent, horizon_sprite_tags(in.layer & 0x7fffu),
let out = material(MaterialInput(vec4(horizon_line_in(albedo.rgb), albedo.a),
vec4(horizon_line_in(in.tint.rgb), in.tint.a), in.light, horizon_line_in(in.lightmap),
in.position, in.uv, translucent, horizon_sprite_tags(in.layer & 0x7fffu),
horizon_sprite_material(in.layer & 0x7fffu), in.clip.xy / frame.resolution,
in.face, fluid, in.emission, normal, tangent,
horizon_terrain_native_colored_light(in.position), in.displaced)).color;
horizon_line_in(horizon_terrain_native_colored_light(in.position)), in.displaced)).color;
return vec4(horizon_line_out(out.rgb), out.a);
}
var<private> horizon_material_face_normal: vec3<f32>;
struct HorizonMaterialSolid {
@@ -332,7 +334,7 @@ fn horizon_material_displace(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: v
let fluid = high >= 8u && (high & 7u) < 6u;
let lit = min(vec2(f32(light.y), f32(light.x)) / 240.0, vec2(1.0));
return vertex(VertexInput(pos, uv, horizon_sprite_material(layer & 0x7fffu), lit,
vec4(color.rgb, 1.0), select(0u, high & 7u, fluid), u32(fluid)));
vec4(horizon_line_in(color.rgb), 1.0), select(0u, high & 7u, fluid), u32(fluid)));
}
";
@@ -349,12 +351,13 @@ fn shader_source(
source: &str,
tags: &[(u32, u32)],
materials: &[(u32, u32)],
vertex: bool,
displaced: bool,
(vertex, displaced): (bool, bool),
api: horizon_shader_api::Api,
) -> String {
format!(
"{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{}{ENTRIES}{}{}",
"{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{}{}{ENTRIES}{}{}",
vanilla_terrain(),
super::native_post::line_helpers(api),
if vertex {
DISPLACE_PACK
} else {
@@ -378,8 +381,9 @@ fn module(
materials: &[(u32, u32)],
vertex: bool,
displaced: bool,
api: horizon_shader_api::Api,
) -> Result<naga::Module, String> {
let text = shader_source(&stage.source, tags, materials, vertex, displaced);
let text = shader_source(&stage.source, tags, materials, (vertex, displaced), api);
naga::front::wgsl::parse_str(&text)
.map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))
}
@@ -403,6 +407,7 @@ impl NativeMaterial {
shape.sprite_materials,
vertex,
displaced.is_some(),
frame.api,
)?;
let mut constants = present_constants(&module, constants);
let sprite_names = [
@@ -562,7 +567,7 @@ impl NativeMaterial {
#[cfg(test)]
mod tests {
use super::*;
use horizon_shader_api::{MANIFEST, Pack, StageKind, check};
use horizon_shader_api::{Api, MANIFEST, Pack, StageKind, check};
fn stage(material: &str) -> CheckedStage {
let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
@@ -609,7 +614,7 @@ mod tests {
let tags = [(7, 1), (3, 1), (9, 2)];
let materials = [(5, 1000)];
assert!(layer_table("t", &tags).contains("case 3u, 7u: { return 1u; }"));
let module = module(&stage, &tags, &materials, false, false).unwrap();
let module = module(&stage, &tags, &materials, false, false, Api::V0_1).unwrap();
let info = naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
@@ -622,8 +627,8 @@ mod tests {
&stage.source,
&tags,
&materials,
false,
false
(false, false),
Api::V0_1
))
)
});
@@ -647,6 +652,33 @@ mod tests {
);
}
/// The terrain shader of a 0.2 pack with a vertex stage, whose tint the renderer decodes.
#[test]
fn the_terrain_validates_with_a_0_2_pack() {
let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.2\"\n\
[material]\nfile = \"material.wgsl\"\n[vertex]\nfile = \"vertex.wgsl\"\n";
let material = "fn material(input: MaterialInput) -> Surface {\n \
return Surface(input.albedo * input.tint * vec4(input.colored_light, 1.0));\n}\n";
let vertex = "fn vertex(input: VertexInput) -> vec3<f32> {\n \
return input.position + input.tint.rgb;\n}\n";
let files = [
(MANIFEST, manifest),
("material.wgsl", material),
("vertex.wgsl", vertex),
]
.map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
.into();
let report = check(&Pack::from_files(files).unwrap()).unwrap();
let stage = report.stages.iter().find(|s| s.kind == StageKind::Material);
let module = module(stage.unwrap(), &[], &[], true, false, Api::V0_2).unwrap();
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.unwrap();
}
#[test]
fn the_displaced_grid_validates_with_a_pack() {
let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
@@ -661,14 +693,14 @@ mod tests {
let mut report = check(&Pack::from_files(files).unwrap()).unwrap();
let stage = report.stages.remove(0);
let materials = [(5, 1000)];
let module = module(&stage, &[], &materials, false, true).unwrap();
let module = module(&stage, &[], &materials, false, true, Api::V0_1).unwrap();
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.unwrap_or_else(|e| {
let text = shader_source(&stage.source, &[], &materials, false, true);
let text = shader_source(&stage.source, &[], &materials, (false, true), Api::V0_1);
panic!("{}", e.emit_to_string(&text))
});
for entry in [
@@ -681,4 +713,116 @@ mod tests {
);
}
}
/// An identity material (vanilla's own lighting, `albedo * tint * lightmap`) under 0.2,
/// its colours decoded on the way in and encoded on the way out as the entries do, draws
/// what 0.1's does (vanilla's) within an 8-bit step.
#[test]
fn an_identity_0_2_material_is_vanilla_s_within_an_8_bit_step() {
let instance = crate::gfx::test_gpu::instance();
let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
return;
};
let Ok((device, queue)) = pollster::block_on(adapter.request_device(&Default::default()))
else {
return;
};
// The entries' call of `material`, with a 16×16 grid of colours.
let entry = "@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
return vec4<f32>(vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u)) * 2.0 - 1.0, 0.0, 1.0);
}
@fragment fn fs(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> {
let c = floor(p.xy) / 15.0;
let albedo = vec4(c.x, c.y, 1.0 - c.x, 1.0);
let tint = vec4(0.9, 1.0 - 0.5 * c.y, 0.7, 1.0);
let lightmap = vec3(c.y, 0.8, 1.0 - c.y);
let out = material(MaterialInput(vec4(horizon_line_in(albedo.rgb), albedo.a),
vec4(horizon_line_in(tint.rgb), tint.a), vec2(1.0), horizon_line_in(lightmap),
vec3(0.0), vec2(0.0), false, 0u, 0u, vec2(0.0), 0u, 0u, 0.0, vec3(0.0, 1.0, 0.0),
vec4(1.0, 0.0, 0.0, 1.0), horizon_line_in(vec3(0.0)), 0.0)).color;
return vec4(horizon_line_out(out.rgb), out.a);
}
";
let vanilla = "fn material(input: MaterialInput) -> Surface {\n \
return Surface(input.albedo * input.tint * vec4(input.lightmap, 1.0));\n}\n";
let format = wgpu::TextureFormat::Rgba8Unorm;
let draw = |api: Api| {
let manifest = format!(
"schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"{api}\"\n\
[material]\nfile = \"material.wgsl\"\n"
);
let files = [(MANIFEST, manifest.as_str()), ("material.wgsl", vanilla)]
.map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
.into();
let report = check(&Pack::from_files(files).unwrap()).unwrap();
let source = report.stages[0].source.clone()
+ horizon_shader_api::stages::PBR_STUB
+ super::super::native_post::line_helpers(api)
+ entry;
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: None,
source: wgpu::ShaderSource::Wgsl(source.into()),
});
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: None,
layout: None,
vertex: wgpu::VertexState {
module: &module,
entry_point: Some("vs"),
compilation_options: Default::default(),
buffers: &[],
},
primitive: Default::default(),
depth_stencil: None,
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some("fs"),
compilation_options: Default::default(),
targets: &[Some(format.into())],
}),
multiview_mask: None,
cache: None,
});
let size = wgpu::Extent3d {
width: 16,
height: 16,
depth_or_array_layers: 1,
};
let target = device.create_texture(&wgpu::TextureDescriptor {
label: None,
size,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
});
let view = target.create_view(&Default::default());
let mut encoder = device.create_command_encoder(&Default::default());
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &view,
resolve_target: None,
depth_slice: None,
ops: Default::default(),
})],
..Default::default()
});
pass.set_pipeline(&pipeline);
pass.draw(0..3, 0..1);
drop(pass);
let screenshot = crate::gfx::copy_frame(&device, &mut encoder, &target, [16, 16]);
queue.submit([encoder.finish()]);
screenshot
.slice(..)
.map_async(wgpu::MapMode::Read, |r| r.unwrap());
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
screenshot.slice(..).get_mapped_range().unwrap().to_vec()
};
let (old, new) = (draw(Api::V0_1), draw(Api::V0_2));
let worst = old.iter().zip(&new).map(|(a, b)| a.abs_diff(*b)).max();
assert!(worst.is_some_and(|w| w <= 1), "{worst:?}");
}
}
crates/horizon-client-render/src/gfx/native_pack.rs
+16 -3
View File
@@ -101,7 +101,15 @@ impl NativePack {
let settings = chosen
.as_ref()
.map(|settings| super::native_shadow::fitted(device, settings));
let mut frame = NativeFrame::new(device, settings.as_ref(), textures, lights, terrain.pbr);
let api = report.manifest.api;
let mut frame = NativeFrame::new(
device,
settings.as_ref(),
textures,
lights,
terrain.pbr,
api,
);
// `[displacement]`, unless its option is off; nothing to displace without heights.
let displacement = report
.manifest
@@ -222,8 +230,13 @@ impl NativePack {
)
})
.transpose()?;
let post = (!post.is_empty())
.then(|| NativePost::new(device, post, &report.manifest, constants, format, &frame))
// A 0.2 pack always has one: its decode and tonemap run without a chain too.
let tonemap = others.iter().find(|s| s.kind == StageKind::Tonemap);
let post = (!post.is_empty() || api == horizon_shader_api::Api::V0_2)
.then(|| {
let manifest = &report.manifest;
NativePost::new(device, post, manifest, constants, format, &frame, tonemap)
})
.transpose()?;
let mut labels: Vec<String> = sky.iter().map(|s| s.label.clone()).collect();
labels.extend(
crates/horizon-client-render/src/gfx/native_post.rs
+596 -87
View File
@@ -7,11 +7,209 @@
//! (`NativeFrame`).
use glam::{Mat4, Vec3};
use horizon_shader_api::{Frame as FrameInputs, check::CheckedStage, stages::GROUP};
use horizon_shader_api::{
Api, Frame as FrameInputs, StageKind, check::CheckedStage, stages::GROUP,
};
use super::Frame;
const INTERMEDIATE: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
pub(super) const INTERMEDIATE: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
/// What the renderer's own entries call where a stage's colours cross into and out of it: as
/// they are under 0.1; under 0.2 vanilla's 2.2 power, as the prelude's `horizon_decode` and
/// `horizon_encode` (the shadow pass has no prelude, so these stand alone).
pub fn line_helpers(api: Api) -> &'static str {
match api {
Api::V0_1 => {
"fn horizon_line_in(c: vec3<f32>) -> vec3<f32> { return c; }
fn horizon_line_out(c: vec3<f32>) -> vec3<f32> { return c; }
"
}
Api::V0_2 => {
"fn horizon_line_in(c: vec3<f32>) -> vec3<f32> {
return pow(select(vec3<f32>(0.0), c, c > vec3<f32>(0.0)), vec3<f32>(2.2));
}
fn horizon_line_out(c: vec3<f32>) -> vec3<f32> {
return pow(select(vec3<f32>(0.0), c, c > vec3<f32>(0.0)), vec3<f32>(1.0 / 2.2));
}
"
}
}
}
/// 0.2's decoding copy: a picture in the frame's gamma into linear light in `INTERMEDIATE`, of
/// the same size, alpha 1 (`scene_color`, `opaque_color`, the mirror).
#[derive(Clone)]
pub struct Decoder(wgpu::RenderPipeline);
impl Decoder {
fn new(device: &wgpu::Device) -> Self {
let source = line_helpers(Api::V0_2).to_owned()
+ "@group(0) @binding(0) var horizon_from: texture_2d<f32>;
@vertex fn horizon_vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
return vec4<f32>(vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u)) * 2.0 - 1.0, 0.0, 1.0);
}
@fragment fn horizon_fs(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> {
return vec4<f32>(horizon_line_in(textureLoad(horizon_from, vec2<i32>(p.xy), 0).rgb), 1.0);
}
";
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Shader API 0.2 decode"),
source: wgpu::ShaderSource::Wgsl(source.into()),
});
let entries = (None, "horizon_vs", "horizon_fs");
Self(fullscreen_pipeline(
device,
"Shader API 0.2 decode",
&module,
entries,
INTERMEDIATE,
&[],
))
}
/// Draws `from` decoded onto `to`.
pub fn run(
&self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
from: &wgpu::TextureView,
to: &wgpu::TextureView,
) {
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Shader API 0.2 decode"),
layout: &self.0.get_bind_group_layout(0),
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(from),
}],
});
fullscreen_pass(
encoder,
"Shader API 0.2 decode",
to,
&self.0,
(0, &group),
None,
);
}
}
/// A full-screen pipeline `label` of `module`'s entries `(vertex, fragment)`, unblended.
fn fullscreen_pipeline(
device: &wgpu::Device,
label: &str,
module: &wgpu::ShaderModule,
(layout, vertex, fragment): (Option<&wgpu::PipelineLayout>, &str, &str),
format: wgpu::TextureFormat,
constants: &[(&str, f64)],
) -> wgpu::RenderPipeline {
let options = wgpu::PipelineCompilationOptions {
constants,
..Default::default()
};
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout,
vertex: wgpu::VertexState {
module,
entry_point: Some(vertex),
compilation_options: options.clone(),
buffers: &[],
},
primitive: Default::default(),
depth_stencil: None,
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module,
entry_point: Some(fragment),
compilation_options: options,
targets: &[Some(wgpu::ColorTargetState {
format,
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})],
}),
multiview_mask: None,
cache: None,
})
}
/// One full-screen triangle of `pipeline` onto `view`, cleared first.
fn fullscreen_pass(
encoder: &mut wgpu::CommandEncoder,
label: &str,
view: &wgpu::TextureView,
pipeline: &wgpu::RenderPipeline,
(index, group): (u32, &wgpu::BindGroup),
timing: Option<&mut super::pack_timing::PassTiming>,
) {
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some(label),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
store: wgpu::StoreOp::Store,
},
})],
timestamp_writes: timing.and_then(|t| t.writes(label)),
..Default::default()
});
pass.set_pipeline(pipeline);
pass.set_bind_group(index, group, &[]);
pass.draw(0..3, 0..1);
}
/// The tonemap stage's entries as the renderer draws them: the check's, with the result
/// encoded into the frame's gamma, where the camera overlays and the HUD draw on it.
fn tonemap_entries() -> String {
StageKind::Tonemap.entries(Api::V0_2).replace(
"return vec4<f32>(min(horizon_sanitize(out), vec3<f32>(frame.headroom)), 1.0);",
"return vec4<f32>(horizon_encode(min(horizon_sanitize(out), vec3<f32>(frame.headroom))), 1.0);",
)
}
/// Horizon's tonemap for a 0.2 pack without `[tonemap]`: SDR's clip at white, which is the
/// entries' hold at `frame.headroom` (1 until 0.2 packs get HDR output).
const DEFAULT_TONEMAP: &str =
"fn tonemap(input: TonemapInput) -> vec3<f32> { return input.color; }\n";
/// A colour target of `INTERMEDIATE` and `size`, drawn and read.
fn intermediate(device: &wgpu::Device, label: &str, size: [u32; 2]) -> wgpu::TextureView {
device
.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width: size[0].max(1),
height: size[1].max(1),
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: INTERMEDIATE,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
})
.create_view(&Default::default())
}
/// A 0.2 pack's display (docs/api/shaders-reference-0.2.md): the world decoded into
/// `scene_color` (the first pass's `previous`), the chain ending in `picture`, and the tonemap
/// stage drawing that onto the screen.
struct Display {
decoder: Decoder,
/// The pack's `[tonemap]` label, `None` for Horizon's.
label: Option<String>,
tonemap: wgpu::RenderPipeline,
/// `scene_color` at the world's size; `picture` at the window's (none without a chain:
/// the tonemap reads `scene_color`).
scene: Option<([u32; 2], wgpu::TextureView)>,
picture: Option<([u32; 2], wgpu::TextureView)>,
}
/// The world's colour and depth views a set of bind groups was made for.
type WorldViews = (wgpu::TextureView, wgpu::TextureView, wgpu::TextureView);
@@ -98,6 +296,8 @@ pub struct NativePost {
named: Option<([u32; 2], Vec<wgpu::TextureView>)>,
/// The screen's colour format, the world target's too.
format: wgpu::TextureFormat,
/// Under 0.2: the decode, the picture and the tonemap.
display: Option<Display>,
}
/// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame, and
@@ -145,6 +345,11 @@ pub struct NativeFrame {
frames: u32,
/// `frame.wetness`, and when it was last written.
wetness: (f32, Option<std::time::Instant>),
/// The shader API line of the pack, and under 0.2 the decoding copy and the mirror it
/// decoded (`linear_mirror`).
pub api: Api,
pub decoder: Option<Decoder>,
mirror: Option<wgpu::TextureView>,
}
/// A depth texture of `size` the world's depth is copied into.
@@ -179,7 +384,10 @@ fn copy_target(
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
// RENDER_ATTACHMENT: 0.2 draws `opaque_color` decoded rather than copying it.
usage: wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsages::RENDER_ATTACHMENT,
view_formats: &[],
})
}
@@ -225,6 +433,7 @@ impl NativeFrame {
textures: Vec<(wgpu::TextureView, wgpu::Sampler)>,
lights: super::block_light::LightTable,
pbr: Option<&[wgpu::Texture; 2]>,
api: Api,
) -> Self {
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Native shader pack frame"),
@@ -290,7 +499,7 @@ impl NativeFrame {
min_filter: wgpu::FilterMode::Linear,
..Default::default()
});
let shadow_map = super::native_shadow::ShadowMap::new(device, shadow);
let shadow_map = super::native_shadow::ShadowMap::new(device, shadow, api);
let block_light = super::block_light::BlockLight::new(device, lights);
let array_view = |texture: &wgpu::Texture| {
texture.create_view(&wgpu::TextureViewDescriptor {
@@ -347,6 +556,9 @@ impl NativeFrame {
shadow_map,
shadow_camera: shadow.map(super::native_shadow::camera),
reflects: false,
api,
decoder: (api == Api::V0_2).then(|| Decoder::new(device)),
mirror: None,
last: None,
eye: [f32::NAN; 4],
history_reset: true,
@@ -460,6 +672,7 @@ impl NativeFrame {
) {
let size = [depth.width(), depth.height()];
let (color_size, format) = match color {
Some(c) if self.decoder.is_some() => ([c.width(), c.height()], INTERMEDIATE),
Some(c) => ([c.width(), c.height()], c.format()),
None => ([1, 1], self.opaque_color.format()),
};
@@ -478,6 +691,46 @@ impl NativeFrame {
self.regroup(device);
}
/// Fills `opaque_color` from the world's colour `color`: a copy, under 0.2 decoded.
pub fn copy_opaque(
&self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
color: &wgpu::TextureView,
) {
match &self.decoder {
Some(d) => {
let to = self.opaque_color.create_view(&Default::default());
d.run(device, encoder, color, &to);
}
None => encoder.copy_texture_to_texture(
color.texture().as_image_copy(),
self.opaque_color.as_image_copy(),
color.texture().size(),
),
}
}
/// The water mirror `view` as the material reads it: under 0.2 decoded into a copy.
pub fn linear_mirror(
&mut self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
view: wgpu::TextureView,
) -> wgpu::TextureView {
let Some(decoder) = &self.decoder else {
return view;
};
let size = [view.texture().width(), view.texture().height()];
let fits = |m: &wgpu::TextureView| [m.texture().width(), m.texture().height()] == size;
if !self.mirror.as_ref().is_some_and(fits) {
self.mirror = Some(intermediate(device, "Water mirror, linear", size));
}
let mirror = self.mirror.clone().unwrap();
decoder.run(device, encoder, &view, &mirror);
mirror
}
/// Sizes the surface target: the world's while a material stage writes it, else a blank.
pub fn fit_surface(&mut self, device: &wgpu::Device, size: [u32; 2]) {
if [self.surface.width(), self.surface.height()] != size {
@@ -543,6 +796,10 @@ impl NativeFrame {
self.wetness = (wetness(self.wetness.0, frame.pack.rain, since), Some(now));
let mut inputs = frame_inputs(frame, size, seconds, index, self.shadow_camera.as_ref());
inputs.wetness = self.wetness.0;
if self.api == Api::V0_2 {
inputs.sky_color = decoded(inputs.sky_color);
inputs.fog_color = decoded(inputs.fog_color);
}
if !self.reflects {
inputs.has_reflection = 0;
}
@@ -684,7 +941,8 @@ fn sampler_entry(binding: u32) -> wgpu::BindGroupLayoutEntry {
impl NativePost {
/// Pipelines for `stages` (the pack's post passes, in order) with the option values
/// `constants`, drawing onto a screen of `format`. Errors name the pass wgpu refused.
/// `constants`, drawing onto a screen of `format`; under 0.2 the last onto `picture`, and
/// `tonemap` (else Horizon's) onto the screen. Errors name the pass wgpu refused.
pub fn new(
device: &wgpu::Device,
stages: Vec<CheckedStage>,
@@ -692,6 +950,7 @@ impl NativePost {
constants: &[(String, f64)],
format: wgpu::TextureFormat,
frame: &NativeFrame,
tonemap: Option<&CheckedStage>,
) -> Result<Self, String> {
let targets = manifest.post_targets();
let outputs: Vec<Option<usize>> = manifest
@@ -764,7 +1023,7 @@ impl NativePost {
entry_point: Some("horizon_fs_post"),
compilation_options: options,
targets: &[Some(wgpu::ColorTargetState {
format: if plan[i].writes == Writes::Screen {
format: if plan[i].writes == Writes::Screen && frame.decoder.is_none() {
format
} else {
INTERMEDIATE
@@ -781,6 +1040,41 @@ impl NativePost {
}
passes.push((stage.label, pipeline));
}
let display = match &frame.decoder {
Some(decoder) => {
let source = tonemap.map_or_else(
|| StageKind::Tonemap.prelude(Api::V0_2) + DEFAULT_TONEMAP,
|s| s.source.clone(),
) + &tonemap_entries();
let file = tonemap.map_or("<tonemap>", |s| s.file.as_str());
let module = naga::front::wgsl::parse_str(&source)
.map_err(|e| format!("{file}: {}", e.emit_to_string(&source)))?;
let present = present_constants(&module, constants);
let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Tonemap"),
source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)),
});
let entries = (
Some(&pipeline_layout),
"horizon_vs_tonemap",
"horizon_fs_tonemap",
);
let pipeline =
fullscreen_pipeline(device, "Tonemap", &module, entries, format, &present);
if let Some(e) = pollster::block_on(scope.pop()) {
return Err(format!("{file}: {e}"));
}
Some(Display {
decoder: decoder.clone(),
label: tonemap.map(|s| s.label.clone()),
tonemap: pipeline,
scene: None,
picture: None,
})
}
None => None,
};
let sampler = |label, filter| {
device.create_sampler(&wgpu::SamplerDescriptor {
label: Some(label),
@@ -811,12 +1105,18 @@ impl NativePost {
named: None,
plan,
format,
display,
})
}
/// The passes' labels, in order.
/// The passes' labels, in order, then the pack's tonemap's.
pub fn labels(&self) -> Vec<&str> {
self.passes.iter().map(|(l, _)| l.as_str()).collect()
let tonemap = self.display.as_ref().and_then(|d| d.label.as_deref());
self.passes
.iter()
.map(|(l, _)| l.as_str())
.chain(tonemap)
.collect()
}
fn prepare(
@@ -824,8 +1124,26 @@ impl NativePost {
device: &wgpu::Device,
world: (&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView),
size: [u32; 2],
window: [u32; 2],
history_reset: bool,
) {
if let Some(d) = &mut self.display {
if d.scene.as_ref().is_none_or(|s| s.0 != size) {
d.scene = Some((
size,
intermediate(device, "Shader API 0.2 scene_color", size),
));
self.groups = None;
}
let chain = !self.passes.is_empty();
if chain && d.picture.as_ref().is_none_or(|p| p.0 != window) {
d.picture = Some((
window,
intermediate(device, "Shader API 0.2 picture", window),
));
self.groups = None;
}
}
if !self.scales.is_empty() && self.named.as_ref().is_none_or(|n| n.0 != size) {
let views = self
.scales
@@ -913,85 +1231,98 @@ impl NativePost {
}
.create_view(&Default::default());
let blank = self.history_blank.create_view(&Default::default());
let groups = (0..self.passes.len())
// Under 0.2 the passes read the world decoded.
let scene = self
.display
.as_ref()
.and_then(|d| d.scene.as_ref())
.map_or(world.0, |s| &s.1);
let group = |previous: &wgpu::TextureView, writes: Option<Writes>| {
let mut entries = vec![
wgpu::BindGroupEntry {
binding: 0,
resource: self.frame.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(scene),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::TextureView(world.1),
},
wgpu::BindGroupEntry {
binding: 3,
resource: wgpu::BindingResource::TextureView(previous),
},
wgpu::BindGroupEntry {
binding: 4,
resource: wgpu::BindingResource::Sampler(&self.linear),
},
wgpu::BindGroupEntry {
binding: 5,
resource: wgpu::BindingResource::Sampler(&self.nearest),
},
wgpu::BindGroupEntry {
binding: 6,
resource: wgpu::BindingResource::TextureView(&self.shadow.0),
},
wgpu::BindGroupEntry {
binding: 7,
resource: wgpu::BindingResource::Sampler(&self.shadow.1),
},
wgpu::BindGroupEntry {
binding: 8,
resource: wgpu::BindingResource::TextureView(&history),
},
wgpu::BindGroupEntry {
binding: 9,
resource: wgpu::BindingResource::TextureView(&self.shadow.2),
},
wgpu::BindGroupEntry {
binding: 11,
resource: wgpu::BindingResource::TextureView(world.2),
},
wgpu::BindGroupEntry {
binding: 10,
resource: wgpu::BindingResource::TextureView(&self.shadow.3),
},
];
entries.extend(pack_texture_group_entries(&self.textures));
// The pack's targets, a blank one in place of the one this pass writes.
if let Some((_, views)) = &self.named {
entries.extend(views.iter().enumerate().map(|(j, view)| {
let view = if writes == Some(Writes::Target(j)) {
&blank
} else {
view
};
wgpu::BindGroupEntry {
binding: horizon_shader_api::stages::POST_TARGET_BINDING + j as u32,
resource: wgpu::BindingResource::TextureView(view),
}
}));
}
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Native shader pack post"),
layout: &self.layout,
entries: &entries,
})
};
let mut groups: Vec<_> = (0..self.passes.len())
.map(|i| {
// The chain's picture so far: the world's before its first pass.
let previous = match (&self.targets, self.plan[i].reads) {
(Some((_, t)), Some(slot)) => &t[slot],
_ => world.0,
_ => scene,
};
let mut entries = vec![
wgpu::BindGroupEntry {
binding: 0,
resource: self.frame.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(world.0),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::TextureView(world.1),
},
wgpu::BindGroupEntry {
binding: 3,
resource: wgpu::BindingResource::TextureView(previous),
},
wgpu::BindGroupEntry {
binding: 4,
resource: wgpu::BindingResource::Sampler(&self.linear),
},
wgpu::BindGroupEntry {
binding: 5,
resource: wgpu::BindingResource::Sampler(&self.nearest),
},
wgpu::BindGroupEntry {
binding: 6,
resource: wgpu::BindingResource::TextureView(&self.shadow.0),
},
wgpu::BindGroupEntry {
binding: 7,
resource: wgpu::BindingResource::Sampler(&self.shadow.1),
},
wgpu::BindGroupEntry {
binding: 8,
resource: wgpu::BindingResource::TextureView(&history),
},
wgpu::BindGroupEntry {
binding: 9,
resource: wgpu::BindingResource::TextureView(&self.shadow.2),
},
wgpu::BindGroupEntry {
binding: 11,
resource: wgpu::BindingResource::TextureView(world.2),
},
wgpu::BindGroupEntry {
binding: 10,
resource: wgpu::BindingResource::TextureView(&self.shadow.3),
},
];
entries.extend(pack_texture_group_entries(&self.textures));
// The pack's targets, a blank one in place of the one this pass writes.
if let Some((_, views)) = &self.named {
entries.extend(views.iter().enumerate().map(|(j, view)| {
let view = if self.plan[i].writes == Writes::Target(j) {
&blank
} else {
view
};
wgpu::BindGroupEntry {
binding: horizon_shader_api::stages::POST_TARGET_BINDING + j as u32,
resource: wgpu::BindingResource::TextureView(view),
}
}));
}
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Native shader pack post"),
layout: &self.layout,
entries: &entries,
})
group(previous, Some(self.plan[i].writes))
})
.collect();
// The tonemap's, last: the chain's picture, else the decoded world.
if let Some(d) = &self.display {
groups.push(group(d.picture.as_ref().map_or(scene, |p| &p.1), None));
}
self.groups = Some((
(world.0.clone(), world.1.clone(), world.2.clone()),
blank_history,
@@ -1011,18 +1342,34 @@ impl NativePost {
history_reset: bool,
mut timing: Option<&mut super::pack_timing::PassTiming>,
) {
self.prepare(device, world, size, history_reset);
let window = [screen.texture().width(), screen.texture().height()];
self.prepare(device, world, size, window, history_reset);
if let Some(t) = timing.as_deref_mut() {
t.mark(device, encoder, (world.0, self.format));
}
let Some((_, _, groups)) = &self.groups else {
return;
};
if let Some(Display {
decoder,
scene: Some((_, scene)),
..
}) = &self.display
{
decoder.run(device, encoder, world.0, scene);
}
let last = match &self.display {
Some(Display {
picture: Some((_, picture)),
..
}) => picture,
_ => screen,
};
for (i, ((label, pipeline), group)) in self.passes.iter().zip(groups).enumerate() {
let view = match (self.plan[i].writes, &self.targets, &self.named) {
(Writes::Chain(slot), Some((_, t)), _) => &t[slot],
(Writes::Target(j), _, Some((_, n))) => &n[j],
_ => screen,
_ => last,
};
let attachments = [Some(wgpu::RenderPassColorAttachment {
view,
@@ -1043,9 +1390,13 @@ impl NativePost {
pass.set_bind_group(GROUP, group, &[]);
pass.draw(0..3, 0..1);
}
if let (Some(d), Some(group)) = (&self.display, groups.last()) {
let label = d.label.as_deref().unwrap_or("Tonemap");
fullscreen_pass(encoder, label, screen, &d.tonemap, (GROUP, group), timing);
}
// The chain's last picture becomes next frame's `history`, once every pass has read
// this frame's.
let before_last = &self.plan[..self.plan.len() - 1];
let before_last = &self.plan[..self.plan.len().saturating_sub(1)];
if let Some(Writes::Chain(slot)) = before_last
.iter()
.rfind(|p| matches!(p.writes, Writes::Chain(_)))
@@ -1080,6 +1431,11 @@ fn history_target(device: &wgpu::Device, label: &str, size: [u32; 2]) -> wgpu::T
})
}
/// Vanilla's gamma colour `c` in linear light (0.2's decode; negatives and NaN made 0).
fn decoded(c: [f32; 3]) -> [f32; 3] {
c.map(|v| if v > 0.0 { v.powf(2.2) } else { 0.0 })
}
/// `wetness` after `dt` seconds of `rain`: halfway there in 30 seconds while it rains
/// harder, in 10 while it dries (the half-lives of the `shaders/` format's `wetness`).
fn wetness(wetness: f32, rain: f32, dt: f32) -> f32 {
@@ -1342,7 +1698,14 @@ mod tests {
};
let hud = crate::hud::HudBatch::new([4, 4]);
let mut frame = crate::gfx::pack_uniforms::initial_history_tests::frame(&hud);
let mut native = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
let mut native = NativeFrame::new(
&device,
None,
Vec::new(),
Default::default(),
None,
Api::V0_1,
);
frame.pack.still_ticks = Some(47_811);
frame.pack.eye_light = [0, 15];
frame.pack.rain = 1.0;
@@ -1418,7 +1781,14 @@ mod tests {
.into();
let report = check(&Pack::from_files(files).unwrap()).unwrap();
let format = wgpu::TextureFormat::Rgba8Unorm;
let frame = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
let frame = NativeFrame::new(
&device,
None,
Vec::new(),
Default::default(),
None,
Api::V0_1,
);
queue.write_buffer(
&frame.buffer,
0,
@@ -1431,6 +1801,7 @@ mod tests {
&[("gain".into(), 1.0)],
format,
&frame,
None,
)
.unwrap();
assert_eq!(post.labels(), ["a.wgsl", "b.wgsl"]);
@@ -1538,7 +1909,14 @@ file = \"b.wgsl\"
.into();
let report = check(&Pack::from_files(files).unwrap()).unwrap();
let format = wgpu::TextureFormat::Rgba8Unorm;
let frame = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
let frame = NativeFrame::new(
&device,
None,
Vec::new(),
Default::default(),
None,
Api::V0_1,
);
let mut post = NativePost::new(
&device,
report.stages,
@@ -1546,6 +1924,7 @@ file = \"b.wgsl\"
&[],
format,
&frame,
None,
)
.unwrap();
let usage = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
@@ -1650,7 +2029,14 @@ file = \"b.wgsl\"
.into();
let report = check(&Pack::from_files(files).unwrap()).unwrap();
let format = wgpu::TextureFormat::Rgba8Unorm;
let frame = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
let frame = NativeFrame::new(
&device,
None,
Vec::new(),
Default::default(),
None,
Api::V0_1,
);
let mut post = NativePost::new(
&device,
report.stages,
@@ -1658,6 +2044,7 @@ file = \"b.wgsl\"
&[],
format,
&frame,
None,
)
.unwrap();
let usage = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
@@ -1929,4 +2316,126 @@ file = \"b.wgsl\"
);
}
}
/// Shader API 0.2: the world decoded, through a chain that passes it on or none, and
/// Horizon's tonemap or the pack's identity one, comes back encoded as it went in (within
/// an 8-bit step), at alpha 1.
#[test]
fn a_0_2_world_comes_back_through_decode_tonemap_and_encode() {
assert!(tonemap_entries().contains("horizon_encode(min(horizon_sanitize(out)"));
let Some((device, queue)) = device() else {
return;
};
let post = "[[post]]\nfile = \"a.wgsl\"\n[[post]]\nfile = \"b.wgsl\"\n";
let curve = "[tonemap]\nfile = \"t.wgsl\"\n";
// A pack needs a stage: the first has only a sky, and no chain or tonemap.
let sky = "[sky]\nfile = \"s.wgsl\"\n";
for extra in [
sky.into(),
post.into(),
curve.into(),
format!("{post}{curve}"),
] {
let manifest = format!(
"schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.2\"\n{extra}"
);
let pass = "fn post(input: PostInput) -> vec4<f32> { return input.color; }\n";
let identity = "fn tonemap(input: TonemapInput) -> vec3<f32> { return input.color; }\n";
let mut files = vec![(MANIFEST, manifest.as_str())];
if extra.contains("[[post]]") {
files.extend([("a.wgsl", pass), ("b.wgsl", pass)]);
}
if extra.contains("[tonemap]") {
files.push(("t.wgsl", identity));
}
if extra.contains("[sky]") {
files.push((
"s.wgsl",
"fn sky(input: SkyInput) -> vec4<f32> { return input.color; }\n",
));
}
let files = files
.into_iter()
.map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
.collect();
let report = check(&Pack::from_files(files).unwrap()).unwrap();
let (passes, others): (Vec<_>, Vec<_>) = report
.stages
.into_iter()
.partition(|s| s.kind == StageKind::Post);
let format = wgpu::TextureFormat::Rgba8Unorm;
let frame = NativeFrame::new(
&device,
None,
Vec::new(),
Default::default(),
None,
Api::V0_2,
);
let inputs = FrameInputs {
headroom: 1.0,
..Default::default()
};
queue.write_buffer(&frame.buffer, 0, bytemuck::bytes_of(&inputs));
let tonemap = others.iter().find(|s| s.kind == StageKind::Tonemap);
let mut post = NativePost::new(
&device,
passes,
&report.manifest,
&[],
format,
&frame,
tonemap,
)
.unwrap();
assert_eq!(post.labels().last() == Some(&"t.wgsl"), tonemap.is_some());
let usage =
wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
let color = texture(&device, format, usage).create_view(&Default::default());
let depth = texture(&device, wgpu::TextureFormat::Depth32Float, usage)
.create_view(&Default::default());
let screen = texture(
&device,
format,
wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
);
let mut encoder = device.create_command_encoder(&Default::default());
let clear = wgpu::Color {
r: 0.8,
g: 0.4,
b: 0.2,
a: 0.5,
};
drop(encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &color,
resolve_target: None,
depth_slice: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(clear),
store: wgpu::StoreOp::Store,
},
})],
..Default::default()
}));
let view = screen.create_view(&Default::default());
let world = (&color, &depth, &frame.surface_view);
post.run(&device, &mut encoder, world, &view, [4, 4], true, None);
let buffer = crate::gfx::copy_frame(&device, &mut encoder, &screen, [4, 4]);
queue.submit([encoder.finish()]);
buffer
.slice(..)
.map_async(wgpu::MapMode::Read, |r| r.unwrap());
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
let pixel = buffer.slice(..).get_mapped_range().unwrap()[..4].to_vec();
let want = [204, 102, 51, 255];
assert!(
pixel
.iter()
.zip(want)
.all(|(&got, want)| got.abs_diff(want) <= 1),
"{extra}: {pixel:?}"
);
}
}
}
crates/horizon-client-render/src/gfx/native_shadow.rs
+21 -11
View File
@@ -6,7 +6,7 @@
//! draw lists (`ShadowView`) serve both; the map's texels are distorted toward the camera as the
//! prelude's `shadow_position` undoes.
use horizon_shader_api::{Frame as FrameInputs, manifest::Shadow as Settings, stages::GROUP};
use horizon_shader_api::{Api, Frame as FrameInputs, manifest::Shadow as Settings, stages::GROUP};
use horizon_shaders::Shadow;
use super::native_material::TerrainShape;
@@ -75,7 +75,7 @@ fn horizon_shadow_cutout(in: HorizonShadowOut) {
@fragment fn horizon_shadow_fs_translucent(in: HorizonShadowOut) -> @location(0) vec4<f32> {
let color = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
if color.a < 0.01 { discard; }
return vec4(color.rgb * in.tint, select(min(color.a, 0.99), 1.0, in.fluid != 0u));
return vec4(horizon_line_in(color.rgb * in.tint), select(min(color.a, 0.99), 1.0, in.fluid != 0u));
}
";
@@ -152,8 +152,13 @@ pub struct ShadowGrid<'a> {
pub normals: &'a wgpu::TextureView,
}
/// `shadow_color`'s format.
const SHADOW_COLOR: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
/// `shadow_color`'s format: under 0.2 it holds linear light, which 8 bits would band.
fn shadow_color(api: Api) -> wgpu::TextureFormat {
match api {
Api::V0_1 => wgpu::TextureFormat::Rgba8Unorm,
Api::V0_2 => super::native_post::INTERMEDIATE,
}
}
/// The shader pack's shadow camera for `settings`: orthographic over `distance` each side,
/// staying put while the camera walks a `SNAP`-block cell. The map is distorted about its
@@ -218,7 +223,7 @@ pub struct ShadowMap {
}
impl ShadowMap {
pub fn new(device: &wgpu::Device, settings: Option<&Settings>) -> Self {
pub fn new(device: &wgpu::Device, settings: Option<&Settings>, api: Api) -> Self {
let size = settings.map_or(1, |s| s.resolution);
let texture = |label, format, usage| {
device.create_texture(&wgpu::TextureDescriptor {
@@ -250,7 +255,7 @@ impl ShadowMap {
);
let color = texture(
"Native shader pack shadow colour",
SHADOW_COLOR,
shadow_color(api),
wgpu::TextureUsages::empty(),
);
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
@@ -474,6 +479,7 @@ fn shader_source(
vertex: Option<&str>,
materials: &[(u32, u32)],
grid: Option<&str>,
api: Api,
) -> String {
let table = super::native_material::layer_table("horizon_sprite_material", materials);
let (head, displace) = match (grid, vertex) {
@@ -504,11 +510,12 @@ fn shader_source(
),
};
format!(
"{head}// Horizon's terrain (terrain.wgsl)\n{}{solid}{displace}{ENTRIES}",
"{head}// Horizon's terrain (terrain.wgsl)\n{}{solid}{}{displace}{ENTRIES}",
prefixed(
section(TERRAIN, "struct Globals {", "// Sky (SkyRenderer)"),
PREFIX
)
),
super::native_post::line_helpers(api)
)
}
@@ -527,6 +534,7 @@ impl NativeShadow {
vertex.map(|s| s.source.as_str()),
shape.sprite_materials,
grid.as_ref().map(|g| g.material.source.as_str()),
frame.api,
);
let module = naga::front::wgsl::parse_str(&text)
.map_err(|e| format!("shadow pass: {}", e.emit_to_string(&text)))?;
@@ -613,7 +621,7 @@ impl NativeShadow {
attributes: &instance_attributes,
};
let color_target = [Some(wgpu::ColorTargetState {
format: SHADOW_COLOR,
format: shadow_color(frame.api),
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})];
@@ -731,8 +739,9 @@ mod tests {
#[test]
fn the_shadow_shader_validates() {
for materials in [&[][..], &[(3, 7), (4, 8), (9, 7)][..]] {
let text = shader_source(&shadow_solid(materials, &[7]), None, materials, None);
let lines = [Api::V0_1, Api::V0_2];
for (materials, api) in [&[][..], &[(3, 7), (4, 8), (9, 7)][..]].iter().zip(lines) {
let text = shader_source(&shadow_solid(materials, &[7]), None, materials, None, api);
let module = naga::front::wgsl::parse_str(&text).unwrap();
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
@@ -767,6 +776,7 @@ mod tests {
None,
&materials,
Some(&stage.source),
Api::V0_1,
);
let module = naga::front::wgsl::parse_str(&text)
.unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
crates/horizon-client-render/src/gfx/native_sky.rs
+16 -7
View File
@@ -17,7 +17,8 @@ const PREFIX: &str = "horizon_sky_";
const PACK_ENTRY: &str = "
@fragment fn horizon_sky_fs_pack(in: horizon_sky_SkyOut) -> @location(0) vec4<f32> {
let d = horizon_sky_view_ray(in.ndc);
return vec4(sky(SkyInput(d, vec4(horizon_sky_sky_along_ray(d), 1.0))).rgb, 1.0);
let color = vec4(horizon_line_in(horizon_sky_sky_along_ray(d)), 1.0);
return vec4(horizon_line_out(sky(SkyInput(d, color)).rgb), 1.0);
}
";
@@ -38,10 +39,11 @@ fn vanilla_sky() -> String {
}
/// The sky shader for the pack's sky stage `source`.
fn shader_source(source: &str) -> String {
fn shader_source(source: &str, api: horizon_shader_api::Api) -> String {
format!(
"{source}\n// Horizon's sky (terrain.wgsl)\n{}{PACK_ENTRY}",
vanilla_sky()
"{source}\n// Horizon's sky (terrain.wgsl)\n{}{}{PACK_ENTRY}",
vanilla_sky(),
super::native_post::line_helpers(api)
)
}
@@ -99,7 +101,7 @@ fn build(
frame: &NativeFrame,
stage: &CheckedStage,
) -> Result<(naga::Module, wgpu::PipelineLayout), String> {
let text = shader_source(&stage.source);
let text = shader_source(&stage.source, frame.api);
let module = naga::front::wgsl::parse_str(&text)
.map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))?;
let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] = Default::default();
@@ -195,7 +197,7 @@ mod tests {
// A pack may use the renderer's names for its own things.
let own = "override gain: f32;\nconst PI: f32 = 3.0;\nfn view_ray() -> f32 { return PI; }\n\
fn sky(input: SkyInput) -> vec4<f32> { return input.color * gain * view_ray(); }\n";
let text = shader_source(&stage(own).source);
let text = shader_source(&stage(own).source, horizon_shader_api::Api::V0_1);
let module = naga::front::wgsl::parse_str(&text).unwrap_or_else(|e| {
panic!("{}", e.emit_to_string(&text));
});
@@ -252,7 +254,14 @@ mod tests {
resource: globals_buffer.as_entire_binding(),
}],
});
let frame = NativeFrame::new(&device, None, Vec::new(), Default::default(), None);
let frame = NativeFrame::new(
&device,
None,
Vec::new(),
Default::default(),
None,
horizon_shader_api::Api::V0_1,
);
queue.write_buffer(
&frame.buffer,
0,
crates/horizon-client-render/src/gfx/pack_post.rs
+37 -1
View File
@@ -43,6 +43,9 @@ mod higher_shadowcolor_tests;
#[cfg(test)]
mod single_side_tests;
#[cfg(test)]
mod mixed_size_tests;
#[cfg(test)]
mod sky_disc_blend_tests;
@@ -2376,7 +2379,16 @@ impl PackPost {
} else {
written.next()
};
if !in_shadow && group != Group::Final && written.any(|s| Some(s) != first) {
// Sizes of one kind that differ never meet. A size relative to the render size and
// one in pixels can: the pass then draws while they resolve to one size
// (`PackPost::sizes_differ`). Iris 1.11.7 drew a composite program writing
// colortex2 at `0.25 0.25` and colortex3 at `320 180` at 1280×720 (#10454).
let apart = |s: horizon_shaders::BufferSize| {
first.is_some_and(|f| {
f != s && (depth || std::mem::discriminant(&f) == std::mem::discriminant(&s))
})
};
if !in_shadow && group != Group::Final && written.any(apart) {
notes.push(format!(
"{}: writes buffers of different sizes (size.buffer); skipped",
pass.name
@@ -4288,6 +4300,18 @@ impl PackPost {
})
}
/// Whether the buffers `pass` writes have different sizes at the current render size: then
/// it is skipped, as one whose `size.buffer` sizes never meet is when the pack loads. Only
/// a pass writing buffers sized relative to the render size and in pixels can.
fn sizes_differ(&self, pass: &Pass) -> bool {
let Some(targets) = &self.targets else {
return false;
};
let mut sizes = pass.writes.iter().map(|&(_, b)| targets.sizes[b]);
let first = sizes.next();
!pass.group.shadow() && pass.group != Group::Final && sizes.any(|s| Some(s) != first)
}
/// Whether the pack draws terrain itself, or has nothing draw it.
pub fn has_terrain(&self) -> bool {
self.terrain.is_some() || self.terrain_cutout.is_some() || self.terrain_undrawn
@@ -4529,6 +4553,14 @@ impl PackPost {
mips,
});
self.forget_groups();
for pass in self.passes.iter().filter(|p| self.sizes_differ(p)) {
log::info!(
"shader pack: {}: writes buffers of different sizes at {}x{} (size.buffer); skipped",
pass.name,
size[0],
size[1]
);
}
}
/// The shadow pass (2.1, passes 2 and 3): the shadow buffers cleared, then the `shadowcomp`
@@ -5075,6 +5107,10 @@ impl PackPost {
terrain_drawn = true;
self.draw_opaque(device, queue, encoder, size, frame, terrain);
}
// As if the pack didn't have it: no compute stages, flips or stage changes.
if self.sizes_differ(pass) {
continue;
}
if !water_drawn && matches!(pass.group, Group::Composite | Group::Final) {
water_drawn = true;
self.draw_translucent(device, queue, encoder, size, terrain);
crates/horizon-client-render/src/gfx/pack_post/mixed_size_tests.rs
+89
View File
@@ -0,0 +1,89 @@
//! A composite program writing two buffers whose `size.buffer` lines declare one relative to the
//! render size and one in pixels (#10454). Iris 1.11.7 drew such a program where both came to
//! the same size (our probe pack: `0.25 0.25` and `320 180` at 1280×720). The programs here are
//! original and cut down.
use super::destination_tests::Fixture;
use super::*;
use std::io::{Cursor, Write};
const VERTEX: &str = "#version 120\nvarying vec2 uv;\nvoid main() { uv=gl_MultiTexCoord0.xy; gl_Position=ftransform(); }\n";
/// `composite` writes (0.25, 0.5, 0.75) into colortex2, sized `0.25 0.25`, and colortex3, sized
/// `colortex3` (`size.buffer` words); `final` shows colortex2's red and green and colortex3's
/// blue.
fn pack(colortex3: &str) -> Post {
let mut zip = zip::ZipWriter::new(Cursor::new(Vec::new()));
let mut add = |name: &str, source: &str| {
zip.start_file(
format!("shaders/{name}"),
zip::write::SimpleFileOptions::default(),
)
.unwrap();
zip.write_all(source.as_bytes()).unwrap();
};
add(
"shaders.properties",
&format!("size.buffer.colortex2 = 0.25 0.25\nsize.buffer.colortex3 = {colortex3}\n"),
);
add("composite.vsh", VERTEX);
add(
"composite.fsh",
"#version 120\n/* RENDERTARGETS: 2,3 */\nvoid main() {\n\
gl_FragData[0] = vec4(0.25, 0.5, 0.75, 1.0);\ngl_FragData[1] = vec4(0.25, 0.5, 0.75, 1.0);\n}\n",
);
add("final.vsh", VERTEX);
add(
"final.fsh",
"#version 120\nuniform sampler2D colortex2;\nuniform sampler2D colortex3;\nvarying vec2 uv;\n\
void main() {\ngl_FragColor = vec4(texture2D(colortex2, uv).rg, texture2D(colortex3, uv).b, 1.0);\n}\n",
);
let pack =
horizon_shaders::Pack::from_zip_bytes("mixed-sizes", zip.finish().unwrap().into_inner())
.unwrap();
let mut macros = horizon_shaders::Macros::standard();
let (properties, _) = horizon_shaders::read_properties(&pack, &mut macros);
horizon_shaders::load_post(&pack, "", &properties, &macros, &Default::default())
}
/// Every pixel's colour, with how many pixels differ from it by more than one step.
fn one_colour(pixels: &[[u8; 4]]) -> ([u8; 4], usize) {
let first = pixels[0];
let off = pixels
.iter()
.filter(|p| p.iter().zip(first).any(|(a, b)| a.abs_diff(b) > 1))
.count();
(first, off)
}
/// At 16×16 both buffers are 4×4: the program draws. At 32×32 colortex2 is 8×8 and colortex3
/// still 4×4: the program is skipped there, as one whose sizes never meet is (Iris refused
/// the whole pack in that case; Horizon skips only the program).
#[test]
fn a_program_writing_buffers_that_come_to_one_size_draws() {
let Some(gpu) = Fixture::new() else { return };
let mut post = gpu.build(pack("4 4"));
let (colour, off) = one_colour(&gpu.render(&mut post, [16, 16]));
assert_eq!(off, 0, "{colour:?}");
for (got, want) in colour.iter().zip([64, 128, 191, 255]) {
assert!(got.abs_diff(want) <= 1, "{colour:?}");
}
let (colour, off) = one_colour(&gpu.render(&mut post, [32, 32]));
assert_eq!((colour, off), ([0, 0, 0, 255], 0));
}
/// Sizes of one kind that differ never meet: the program is skipped as the pack loads.
#[test]
fn a_program_writing_buffers_of_different_relative_sizes_is_skipped() {
let Some(gpu) = Fixture::new() else { return };
let post = pack("0.5 0.5");
let post = gpu
.try_build(post)
.unwrap_or_else(|_| panic!("the pack runs"));
assert!(
post.notes
.iter()
.any(|n| n == "composite: writes buffers of different sizes (size.buffer); skipped"),
"{:?}",
post.notes
);
}
crates/horizon-client-render/src/gfx/readback.rs
+22
View File
@@ -323,4 +323,26 @@ mod tests {
let unorm = wgpu::TextureFormat::Rgba16Unorm;
reaches_an_8_bit_swapchain(&device, &queue, unorm, color, [0, 51, 255, 255]);
}
/// `Rgba16Float`, the frame of a shader API 0.2 pack under `HORIZON_HDR_FRAME=float`
/// (`Renderer::frame_format`): what the tonemap left over 1 is clipped on the way.
#[test]
fn a_float_frame_reaches_an_8_bit_swapchain() {
let instance = crate::gfx::test_gpu::instance();
let Ok(adapter) = pollster::block_on(instance.request_adapter(&Default::default())) else {
return;
};
let Ok((device, queue)) = pollster::block_on(adapter.request_device(&Default::default()))
else {
return;
};
let color = wgpu::Color {
r: 1.5,
g: 0.2,
b: -0.5,
a: 1.0,
};
let float = wgpu::TextureFormat::Rgba16Float;
reaches_an_8_bit_swapchain(&device, &queue, float, color, [0, 51, 255, 255]);
}
}
crates/horizon-client-render/src/gfx/weather.rs
+23 -17
View File
@@ -217,15 +217,19 @@ struct HorizonWeatherOut {
textureDimensions(horizon_entity_atlas));
let color = textureLoad(horizon_entity_atlas, texel, 0) * in.color;
if color.a < 0.1 { discard; }
return weather(WeatherInput(color, in.light, in.position, in.snow != 0u));
let input = WeatherInput(vec4(horizon_line_in(color.rgb), color.a), in.light, in.position,
in.snow != 0u);
let out = weather(input);
return vec4(horizon_line_out(out.rgb), out.a);
}
";
/// The shader of a native pack's weather stage `source`.
fn native_source(source: &str) -> String {
fn native_source(source: &str, api: horizon_shader_api::Api) -> String {
format!(
"{source}\n// Horizon's weather (entity.wgsl)\n{}{NATIVE_ENTRIES}",
super::wgsl_prefix::prefixed(&super::entity_shader(), "horizon_entity_")
"{source}\n// Horizon's weather (entity.wgsl)\n{}{}{NATIVE_ENTRIES}",
super::wgsl_prefix::prefixed(&super::entity_shader(), "horizon_entity_"),
super::native_post::line_helpers(api)
)
}
@@ -242,7 +246,7 @@ pub(super) fn native_pipeline(
constants: &[(String, f64)],
) -> Result<wgpu::RenderPipeline, String> {
use horizon_shader_api::stages::GROUP;
let text = native_source(&stage.source);
let text = native_source(&stage.source, frame.api);
let module = naga::front::wgsl::parse_str(&text)
.map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))?;
let present = super::native_post::present_constants(&module, constants);
@@ -318,19 +322,21 @@ mod tests {
#[test]
fn a_native_weather_stage_validates() {
use horizon_shader_api::stages::StageKind;
let source = StageKind::Weather.prelude(horizon_shader_api::Api::V0_1)
+ "fn weather(input: WeatherInput) -> vec4<f32> {\n \
return input.color * vec4(input.light, input.position.x, f32(input.snow));\n}\n";
let text = native_source(&source);
let module = naga::front::wgsl::parse_str(&text)
use horizon_shader_api::{Api, stages::StageKind};
for api in [Api::V0_1, Api::V0_2] {
let source = StageKind::Weather.prelude(api)
+ "fn weather(input: WeatherInput) -> vec4<f32> {\n \
return input.color * vec4(input.light, input.position.x, f32(input.snow));\n}\n";
let text = native_source(&source, api);
let module = naga::front::wgsl::parse_str(&text)
.unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.unwrap_or_else(|e| panic!("{}", e.emit_to_string(&text)));
}
}
use crate::weather::{Parameters, Time};
use wgpu::util::DeviceExt;
crates/horizon-client-render/src/graphics_ui.rs
+21 -4
View File
@@ -639,12 +639,20 @@ pub fn rows() -> Vec<(Page, Vec<(&'static str, Vec<Setting>)>)> {
/// BlueMap download radii, in chunks.
const BLUE_MAP_RADII: [u32; 5] = [16, 32, 64, 128, 256];
const UPLOAD_STEPS: [u32; 8] = [0, 256, 512, 1024, 2048, 4096, 8192, 16384];
/// What the LOD Distance slider stops at, in chunks: off, then each doubling
/// What the LOD Distance slider stops at, in chunks: off, fine steps up to 256
/// for a short ring of far terrain past a small render distance (a phone or an
/// integrated GPU at 8 chunks wants LOD to 12 or 16, not 64), then each doubling
/// up to the whole world.
const LOD_STEPS: [u32; 18] = [
const LOD_STEPS: [u32; 24] = [
0,
16,
24,
32,
48,
64,
96,
128,
192,
256,
512,
1024,
@@ -2692,12 +2700,21 @@ mod tests {
item.label(&s).plain(),
format!("LOD Distance: {} chunks", crate::lod::MAX_CHUNKS)
);
item.set_slider(&mut s, 5.0 / 17.0);
item.set_slider(&mut s, 11.0 / 23.0);
assert_eq!(s.horizon.lod_distance, 1024);
assert_eq!(item.label(&s).plain(), "LOD Distance: 1024 chunks");
// The fine stops: a ring of far terrain just past a small render
// distance, which the doubling steps skipped (#9694).
item.set_slider(&mut s, 1.0 / 23.0);
assert_eq!(s.horizon.lod_distance, 16);
assert_eq!(item.label(&s).plain(), "LOD Distance: 16 chunks");
item.set_slider(&mut s, 2.0 / 23.0);
assert_eq!(s.horizon.lod_distance, 24);
// A distance between stops (from the file) sits on the next one.
s.horizon.lod_distance = 3000;
assert_eq!(item.slider(&s), Some(7.0 / 17.0));
assert_eq!(item.slider(&s), Some(13.0 / 23.0));
s.horizon.lod_distance = 12;
assert_eq!(item.slider(&s), Some(1.0 / 23.0));
assert_eq!(
Item::Vanilla(Opt::RenderDistance).label(&s).plain(),
format!("Full Detail Distance: {near} chunks")
crates/horizon-client-render/src/hud_layout.rs
-10
View File
@@ -485,11 +485,6 @@ pub struct HealthHud {
/// `Util.getMillis()` of the last health change.
pub last_health_time: i64,
pub health_blink_time: i64,
/// `Hud.leftHeight` and `rightHeight` once the health, armor, food, mount
/// and air layers have run; the selected item name and the action bar sit
/// above them.
pub left_height: i32,
pub right_height: i32,
/// `Hud.lastBubblePopSoundPlayed`.
pub last_bubble_pop_sound: i32,
/// The `ui.hud.bubble_pop` volume and pitch `playAirBubblePoppedSound`
@@ -655,9 +650,6 @@ impl HealthHud {
let rows = ceil((max_health + absorption as f32) / 2.0 / 10.0);
let row_height = (10 - (rows - 2)).max(3);
let mut y_air = y_base - 10;
self.left_height = 39 + (rows - 1) * row_height + 10 + if i.armor > 0 { 10 } else { 0 };
// The mount's heart rows (`extractVehicleHealth`); food adds its row below.
self.right_height = 39 + 10 * ((i.vehicle_hearts + 9) / 10);
let offset_index = if i.regeneration {
i.tick % ceil(max_health + 5.0)
} else {
@@ -752,13 +744,11 @@ impl HealthHud {
}
}
y_air -= 10;
self.right_height += 10;
}
// Hud.extractAirBubbles.
let max_air = i.max_air.max(1);
let air = i.air.clamp(0, max_air);
if i.under_water || air < max_air {
self.right_height += 10;
let rows = (f64::from(i.vehicle_hearts) / 10.0).ceil() as i32;
let y = y_air - (rows - 1) * 10;
let bubble = |offset: i32| ceil(((air + offset) * 10) as f32 / max_air as f32);
crates/horizon-client-render/src/hud_overlays.rs
+99 -13
View File
@@ -115,8 +115,7 @@ impl From<&crate::effects::EffectInstance> for EffectIcon {
color: def.map_or(0, |d| d.color as i32),
ambient: effect.ambient,
duration: effect.duration,
// Horizon keeps no showIcon flag: every effect shows its icon.
show_icon: true,
show_icon: effect.show_icon,
}
}
}
@@ -323,13 +322,12 @@ impl Titles {
}
}
}
/// `Hud.extractOverlayMessage`; `bar_height` is
/// `max(leftHeight, rightHeight)`.
/// `Hud.extractOverlayMessage`: the action bar keeps its place however
/// tall the health, food, air and mount rows above the hotbar are.
pub fn overlay_message(
&self,
w: i32,
h: i32,
bar_height: i32,
partial: f32,
font: &Font,
background: u32,
@@ -345,12 +343,11 @@ impl Titles {
let alpha = ((t * 255.0 / 20.0) as i32).min(255);
if alpha > 0 {
let message = message.resolve_legacy();
// The bars' height plus the gap between the item name (59) and the
// overlay (68), at least the default level.
let y_shift = bar_height + (68 - 59);
// `Hud.extractOverlayMessage` translates to `guiHeight - 68`, a
// constant the bars above the hotbar never move.
out.push(GuiDraw::Push(vec![PoseOp::Translate(
(w / 2) as f32,
(h - y_shift.max(68)) as f32,
(h - 68) as f32,
)]));
let color = if self.overlay_animated {
hsv_to_argb(t / 50.0, 0.7, 0.6, alpha as u32)
@@ -468,13 +465,13 @@ impl ToolHighlight {
self.last = selected;
}
/// `Hud.extractSelectedItemName`; `can_hurt` is
/// `gameMode.canHurtPlayer()` (survival and adventure) and `bar_height`
/// is `max(leftHeight, rightHeight)`.
/// `gameMode.canHurtPlayer()` (survival and adventure). The name sits 59
/// pixels above the bottom edge whatever the bars above the hotbar do,
/// and 14 lower when the mode cannot hurt the player.
pub fn draw(
&self,
w: i32,
h: i32,
bar_height: i32,
can_hurt: bool,
font: &Font,
background: u32,
@@ -495,7 +492,7 @@ impl ToolHighlight {
}
let str_width = width(font, &name);
let x = (w - str_width) / 2;
let mut y = h - bar_height.max(59);
let mut y = h - 59;
if !can_hurt {
y += 14;
}
@@ -1295,3 +1292,92 @@ mod subtitle_tests {
assert!(!o.listening());
}
}
#[cfg(test)]
mod text_position_tests {
use super::*;
use crate::{font::Font, hud::Rect};
use std::{collections::HashMap, path::Path};
/// The missing-glyph metrics let these tests run without game assets.
fn font() -> Font {
Font::load(
Path::new("/nonexistent-horizon-hud-test-resources"),
&HashMap::new(),
&[],
(1, 1),
(0, 0),
Rect {
u0: 0.0,
v0: 0.0,
u1: 1.0,
v1: 1.0,
w: 1,
h: 1,
},
)
}
fn held() -> HeldName {
HeldName {
item: "minecraft:stone".into(),
hover_name: Text::literal("Stone"),
rarity_color: 0xFFFF_FFFF,
custom_name: false,
}
}
fn text_top(draws: &[GuiDraw]) -> Option<i32> {
draws.iter().find_map(|d| match d {
GuiDraw::Text { y, .. } => Some(*y),
_ => None,
})
}
/// `Hud.extractSelectedItemName`: `guiHeight - 59`, then `+ 14` when the
/// game mode cannot hurt the player. The health, food, air and mount rows
/// above the hotbar never move it: with armor and a second row of hearts
/// they reach 69 pixels, and the name stays where vanilla draws it.
#[test]
fn the_selected_item_name_sits_fifty_nine_above_the_bottom_edge() {
let mut highlight = ToolHighlight {
last: Some(held()),
timer: 40,
};
let f = font();
let draws = highlight.draw(320, 240, true, &f, 0);
assert_eq!(text_top(&draws), Some(240 - 59));
// Creative and spectator add the fourteen pixels the experience bar
// and the food row would have taken.
let draws = highlight.draw(320, 240, false, &f, 0);
assert_eq!(text_top(&draws), Some(240 - 59 + 14));
// No timer, no name.
highlight.timer = 0;
assert!(highlight.draw(320, 240, true, &f, 0).is_empty());
}
/// `Hud.extractOverlayMessage`: the action bar and its text translate to
/// `guiHeight - 68` and `-4`, again wherever the bars above the hotbar
/// reach.
#[test]
fn the_action_bar_sits_sixty_eight_above_the_bottom_edge() {
let mut titles = Titles::default();
titles.set_overlay(Text::literal("Action bar"), false);
let f = font();
let draws = titles.overlay_message(320, 240, 0.0, &f, 0);
let translate = draws.iter().find_map(|d| match d {
GuiDraw::Push(ops) => ops.iter().find_map(|op| match op {
PoseOp::Translate(_, y) => Some(*y),
_ => None,
}),
_ => None,
});
assert_eq!(translate, Some((240 - 68) as f32));
// The text is drawn four pixels below that origin, as vanilla's is.
let relative = draws.iter().find_map(|d| match d {
GuiDraw::Text { y, .. } => Some(*y),
_ => None,
});
assert_eq!(relative, Some(-4));
}
}
crates/horizon-client-render/src/lib.rs
+1
View File
@@ -36,6 +36,7 @@ pub mod connected;
pub mod containers;
pub mod controller_ui;
pub mod crash;
pub mod custom_sky;
pub mod datapack;
pub mod dynamic_light;
pub mod effects;
crates/horizon-client-render/src/logging.rs
+37 -1
View File
@@ -274,6 +274,8 @@ enum Out {
date: NaiveDate,
lines: Vec<String>,
stderr: Option<String>,
/// The message's level, thread and text, for the [`set_line_hook`] callback.
record: (log::Level, String, String),
},
/// Answer once everything before is written.
Flush(mpsc::SyncSender<()>),
@@ -293,12 +295,14 @@ struct Writer {
impl Writer {
fn run(mut self, out: mpsc::Receiver<Out>) {
let stderr = io::stderr();
let mut hook_alive = true;
for msg in out {
match msg {
Out::Write {
date,
lines,
stderr: message,
record: (level, thread, text),
} => {
if let Some(message) = message {
let _ = writeln!(stderr.lock(), "{message}");
@@ -319,6 +323,12 @@ impl Writer {
text.push('\n');
let _ = latest.file.write_all(text.as_bytes());
}
// After the file has it. A callback that panics is not called again: the
// panic's own log line would reach it next.
if let Some(hook) = LINE_HOOK.get().filter(|_| hook_alive) {
let call = || hook(level.as_str(), &thread, &text, &lines.join("\n"));
hook_alive = std::panic::catch_unwind(call).is_ok();
}
}
Out::Flush(done) => {
if let Some(latest) = &mut self.file {
@@ -395,6 +405,18 @@ impl Floods {
static LOGGER: std::sync::OnceLock<Logger> = std::sync::OnceLock::new();
/// What [`set_line_hook`] installed: level (`INFO`, `WARN`, `ERROR`), thread, message, and the
/// lines as `latest.log` got them.
type LineHook = fn(&str, &str, &str, &str);
static LINE_HOOK: std::sync::OnceLock<LineHook> = std::sync::OnceLock::new();
/// Calls `hook` on the log's writer thread for each message written to the log, once the file
/// has it, so the thread that logged never waits on it. Once per process; a second call keeps
/// the first.
pub fn set_line_hook(hook: LineHook) {
let _ = LINE_HOOK.set(hook);
}
fn ours(target: &str) -> bool {
target.starts_with("horizon")
}
@@ -490,6 +512,7 @@ impl Logger {
date: now.date_naive(),
lines,
stderr,
record: (level, thread.to_owned(), message.to_owned()),
};
if let Err(mpsc::SendError(Out::Write {
stderr: Some(message),
@@ -502,12 +525,25 @@ impl Logger {
}
}
/// The `latest.log` this run writes, once `init` opened it.
static LATEST_PATH: std::sync::OnceLock<PathBuf> = std::sync::OnceLock::new();
/// The `latest.log` this run writes, absolute; None before `init` and when it logs to the
/// terminal only.
pub fn latest_path() -> Option<PathBuf> {
LATEST_PATH.get().cloned()
}
/// Starts the log in `home/logs`. The main thread shows as `main_thread` in it. Messages are
/// still printed when the file cannot be opened.
pub fn init(home: &Path, main_thread: &'static str) {
let dir = logs_dir(home);
let file = match open_latest(&dir) {
Ok(Some(latest)) => Some(latest),
Ok(Some(latest)) => {
let path = dir.join("latest.log");
let _ = LATEST_PATH.set(std::path::absolute(&path).unwrap_or(path));
Some(latest)
}
Ok(None) => {
eprintln!(
"Horizon: another game is writing {}; this one logs to the terminal only",
crates/horizon-client-render/src/terrain.wgsl
+8 -3
View File
@@ -63,6 +63,11 @@ struct Globals {
// which then samples exactly as before.
override SPRITE_ARRAYS: u32 = 1u;
override SPRITE_SPLIT: u32 = 2048u;
// Whether the solid shaders carry HDR output's lighting (a pipeline constant): the
// renderer builds its solid terrain without it for the frames HDR is off, where
// `hdr_light.z` is 0, since even a branch never taken costs Apple GPUs ~15% of a
// solid pixel's time (gfx.rs's `SolidPipeline`).
override HDR_LIGHTING: bool = true;
// A sprite sampled with the given gradients, from whichever array holds its layer.
fn sprite_grad(uv: vec2<f32>, layer: u32, dx: vec2<f32>, dy: vec2<f32>) -> vec4<f32> {
let l = i32(layer % SPRITE_SPLIT);
@@ -620,7 +625,7 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
}
// `fs_solid` for the opaque pass (`opaque_quad`): no fade, no cutout, no discard.
@fragment fn fs_opaque(in: TerrainOut) -> @location(0) vec4<f32> {
if globals.hdr_light.z != 0.0 {
if HDR_LIGHTING && globals.hdr_light.z != 0.0 {
hdr_normal = normalize(cross(dpdy(in.local), dpdx(in.local)));
}
let texel = sprite(in.uv, in.layer & 0x7fffu);
@@ -637,7 +642,7 @@ fn hdr_mark(tier: u32, y: f32) -> f32 {
fn solid_color(in: TerrainOut) -> vec4<f32> {
let dx = dpdx(in.local);
let dy = dpdy(in.local);
if globals.hdr_light.z != 0.0 {
if HDR_LIGHTING && globals.hdr_light.z != 0.0 {
hdr_normal = normalize(cross(dy, dx));
}
if faded(in.fade, in.local, dx, dy) { discard; }
@@ -665,7 +670,7 @@ fn solid_finish_at(in: TerrainOut, texel: vec4<f32>, color: vec4<f32>, du: vec2<
// fully fogged mountain would stand out from the fog behind it.
// Without HDR output nothing reads the alpha, so its lighting is not worked out.
var emissive = 1.0;
if globals.hdr_light.z != 0.0 {
if HDR_LIGHTING && globals.hdr_light.z != 0.0 {
let fogged = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
linear_fog(in.cylindrical, globals.fog.z, globals.fog.w)) * globals.fog_color.a;
emissive = hdr_scene_alpha(mix(hdr_scene(in.scene.x, in.scene.y, hdr_facing()),
crates/horizon-client/examples/probe/chat_screen_fixture.rs
+1
View File
@@ -50,6 +50,7 @@ pub fn main() -> horizon_client::Result<()> {
&m,
&c,
case["initial"].as_str().unwrap_or(""),
false,
history.len(),
w,
h,
crates/horizon-client/examples/probe/entity_death_loot_fixture.rs
+3 -2
View File
@@ -8,7 +8,8 @@ use horizon_client::{
blocks::BlockFacts,
items::Items,
mobs::{
Mob, MobTypes, Species, cube, drops, enderman, gear, raider, render::DYE_NAMES, sulfur_cube,
Mob, MobTypes, Species, cube, drops, enderman, gear, raider, render::DYE_NAMES,
species::can_be_a_baby, sulfur_cube,
},
random_sequences::RandomSequences,
};
@@ -111,7 +112,7 @@ pub fn main() -> horizon_client::Result<()> {
for slot in drops::SLOTS {
drops::clear_slot(&mut m, slot);
}
if get("baby", "0") == "1" && drops::can_be_baby(m.species()) {
if get("baby", "0") == "1" && can_be_a_baby(m.species()) {
m.extra.age = -24000;
}
if get("fire", "0") == "1" {
crates/horizon-client/examples/probe/hud_fixture/kinds.rs
+2 -2
View File
@@ -101,7 +101,7 @@ fn title(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec<GuiDraw> {
}
let partial = float(c, "partial", 0.0);
let bg = background(c);
let mut out = t.overlay_message(w, h, 39, partial, &atlas.font, bg);
let mut out = t.overlay_message(w, h, partial, &atlas.font, bg);
out.extend(t.title(w, h, partial, &atlas.font, bg));
out
}
@@ -129,7 +129,7 @@ fn selected(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec<GuiDraw> {
}
let mode = c["gameMode"].as_str().unwrap_or("survival");
let can_hurt = mode == "survival" || mode == "adventure";
highlight.draw(w, h, 39, can_hurt, &atlas.font, background(c))
highlight.draw(w, h, can_hurt, &atlas.font, background(c))
}
fn boss(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec<GuiDraw> {
crates/horizon-client/src/advancements.rs
+32
View File
@@ -146,6 +146,16 @@ fn frame(v: &Value) -> Frame {
}
}
impl Tree {
/// `PlayerAdvancements.checkForAutomaticTriggers`: the advancements that
/// have no criteria at all, so nothing can ever grant them a criterion and
/// vanilla hands them over (and grants their rewards) as the player's
/// progress loads.
pub fn automatic(&self) -> Vec<usize> {
(0..self.list.len())
.filter(|&i| self.list[i].criteria.is_empty())
.collect()
}
/// [`Tree::load`], shared while anyone holds it: a server's advancement
/// packets (`ServerAdvancements`) and its game's criteria read the same
/// files, and each kept its own copy (7 MB). A world whose data packs bring
@@ -2677,6 +2687,28 @@ mod tests {
p.grant("minecraft:t", "b", "now");
assert!(p.done(&a));
}
/// `AdvancementRequirements.test` answers false with no requirement groups, so an advancement
/// without criteria is never done by `isDone`; `PlayerAdvancements.checkForAutomaticTriggers`
/// still grants its rewards as progress loads, and `Tree::automatic` is the list it walks.
#[test]
fn an_advancement_without_criteria_is_not_done_but_granted_automatically() {
let empty = parse("minecraft:free", &serde_json::json!({"criteria": {}})).unwrap();
assert!(!Progress::default().done(&empty), "no groups: not done");
let waiting = parse(
"minecraft:waits",
&serde_json::json!({"criteria": {"a": {"trigger": "minecraft:tick"}}}),
)
.unwrap();
assert!(!Progress::default().done(&waiting));
let tree = tree_of(&[
(
"minecraft:waits",
serde_json::json!({"criteria": {"a": {"trigger": "minecraft:tick"}}}),
),
("minecraft:free", serde_json::json!({"criteria": {}})),
]);
assert_eq!(tree.automatic(), vec![1]);
}
#[test]
fn layout_spreads_children_like_tree_node_position() {
let mut tree = Tree::default();
crates/horizon-client/src/block_contact.rs
+15
View File
@@ -57,6 +57,21 @@ pub fn emit(event: Event<'_>) {
dispatch(event, &mut 0.0);
}
/// The game's native trample hook (`native_trample`), set once by the game: dimension, entity
/// id, entity type, the farmland's position, the fall distance and cancel.
pub static TRAMPLE: OnceLock<fn(&str, i32, &str, [i32; 3], f64, &mut bool)> = OnceLock::new();
/// Whether the mods let `entity` (of type `kind`) trample the farmland at `position`.
pub fn trample_allowed(entity: i32, kind: &str, position: BlockPos, distance: f64) -> bool {
let (Some(dimension), Some(hook)) = (LEVEL.get(), TRAMPLE.get()) else {
return true;
};
let mut cancel = false;
let at = [position.x, position.y, position.z];
hook(dimension, entity, kind, at, distance, &mut cancel);
!cancel
}
/// Damage is the calculated fall damage, before hurt handling and fall sounds.
pub fn fall(contact: Contact<'_>, distance: f64, mut damage: f32) -> f32 {
dispatch(Event::FallOn(contact, distance), &mut damage);
crates/horizon-client/src/cauldron.rs
+20 -8
View File
@@ -42,6 +42,8 @@ pub struct Interaction {
pub sound: Option<&'static str>,
/// The custom statistic the player earns (`use_cauldron`, ...).
pub stat: Option<&'static str>,
/// `lowerFillLevel` posts BLOCK_CHANGE with the new state.
pub lower_fill_level: bool,
}
fn state(name: &str, level: Option<u8>) -> BlockState {
@@ -60,6 +62,7 @@ fn pass() -> Interaction {
block: None,
sound: None,
stat: None,
lower_fill_level: false,
}
}
@@ -126,9 +129,20 @@ fn changed(block: BlockState, sound: Option<&'static str>, stat: &'static str) -
block: Some(block),
sound,
stat: Some(stat),
lower_fill_level: false,
}
}
fn changed_lowered(
cauldron: &BlockState,
sound: Option<&'static str>,
stat: &'static str,
) -> Interaction {
let mut result = changed(lowered(cauldron), sound, stat);
result.lower_fill_level = true;
result
}
const COLORS: [&str; 16] = [
"white",
"orange",
@@ -183,7 +197,7 @@ pub fn interact(
stack.data_mut().dyed_color = None;
stack.tidy();
}
return changed(lowered(cauldron), None, "clean_armor");
return changed_lowered(cauldron, None, "clean_armor");
}
let fill_bucket = |player: &mut dyn Player, new: &str, can_fill: bool, sound| {
if !can_fill {
@@ -208,6 +222,7 @@ pub fn interact(
block: None,
sound: None,
stat: None,
lower_fill_level: false,
}
} else {
empty_bucket(
@@ -231,6 +246,7 @@ pub fn interact(
block: None,
sound: None,
stat: None,
lower_fill_level: false,
}
} else {
empty_bucket(
@@ -266,11 +282,7 @@ pub fn interact(
ItemStack::new("minecraft:potion", 1).with_potion("minecraft:water"),
true,
);
changed(
lowered(cauldron),
Some("minecraft:item.bottle.fill"),
"use_cauldron",
)
changed_lowered(cauldron, Some("minecraft:item.bottle.fill"), "use_cauldron")
}
("water", "minecraft:potion") => {
if level == 3 || !water_potion {
@@ -298,7 +310,7 @@ pub fn interact(
cleaned.data_mut().banner_patterns.pop();
cleaned.tidy();
filled(player, cleaned, false);
changed(lowered(cauldron), None, "clean_banner")
changed_lowered(cauldron, None, "clean_banner")
}
("water", name)
if name
@@ -307,7 +319,7 @@ pub fn interact(
.is_some_and(|c| COLORS.contains(&c)) =>
{
filled(player, held.transmute("minecraft:shulker_box", 1), false);
changed(lowered(cauldron), None, "clean_shulker_box")
changed_lowered(cauldron, None, "clean_shulker_box")
}
("lava", "minecraft:bucket") => fill_bucket(
player,
crates/horizon-client/src/client_lib.rs
+12 -12
View File
@@ -13,18 +13,18 @@ pub use horizon_client_render::{
block_entity_anim, block_entity_render, block_sprites, block_states, bluemap, bluemap_detect,
border_render, breaking, brewing, camera, chat, chunk, chunk_map, cit, cit_armor, cit_assets,
cit_glint, client_resources, clouds, collisions, command_block, containers, controller_ui,
crash, datapack, dynamic_light, effects, environment, extras, fast_hash, fluid_render, fog,
font, gfx, graphics, graphics_style, graphics_ui, hdr_calibration, hud, hud_layout,
hud_overlays, inventory_effects, java_text, jigsaw_block, json_folder, level_loading, light,
lod, logging, menu_blur, mesher, minimap, mipmap, mod_browser, mod_list, model_library, models,
multiline_edit, native_emissive, options_file, options_fixes, options_ui, overlay,
pack_browser, pack_screen, packs, pad_cursor, pad_glyph, par, particles, poi_sections,
post_chain, potent_sulfur, preedit, providers, pvp, pvp_hud, screen_draw, screen_effects,
sculk, section_mask, server_terrain, settings, shader_options, shader_pack_list, signs, skins,
sound_engine, sound_events, sound_preview, spans, split_layout, split_map, split_profiles,
sprites, streaming, structure_block, tab_list, telemetry, terrain_model, test_block,
test_instance_block, testgen, title_edition, trims, ui, vault, weather, widgets, world,
worldborder, zip,
crash, custom_sky, datapack, dynamic_light, effects, environment, extras, fast_hash,
fluid_render, fog, font, gfx, graphics, graphics_style, graphics_ui, hdr_calibration, hud,
hud_layout, hud_overlays, inventory_effects, java_text, jigsaw_block, json_folder,
level_loading, light, lod, logging, menu_blur, mesher, minimap, mipmap, mod_browser, mod_list,
model_library, models, multiline_edit, native_emissive, options_file, options_fixes,
options_ui, overlay, pack_browser, pack_screen, packs, pad_cursor, pad_glyph, par, particles,
poi_sections, post_chain, potent_sulfur, preedit, providers, pvp, pvp_hud, screen_draw,
screen_effects, sculk, section_mask, server_terrain, settings, shader_options,
shader_pack_list, signs, skins, sound_engine, sound_events, sound_preview, spans, split_layout,
split_map, split_profiles, sprites, streaming, structure_block, tab_list, telemetry,
terrain_model, test_block, test_instance_block, testgen, title_edition, trims, ui, vault,
weather, widgets, world, worldborder, zip,
};
pub mod attack_strength;
pub mod attribute_updates;
crates/horizon-client/src/clock.rs
+88
View File
@@ -289,6 +289,8 @@ impl ServerTickRateManager {
/// Ticks one sprint frame may run (rendering carries on between frames).
const SPRINT_PER_FRAME: i64 = 40;
const SAMPLES: usize = 100;
/// The windows of [`FixedStep::tps`], in seconds: one, five and fifteen minutes.
const TPS_WINDOWS: [f64; 3] = [60.0, 300.0, 900.0];
/// A step command's broadcast value and the ticks still owed to a new client.
/// `ServerTickRateManager.updateStepTicks` sends the former immediately;
@@ -316,6 +318,10 @@ pub struct FixedStep {
tick_times: [i64; SAMPLES],
aggregated: i64,
tick_count: i64,
/// The ticks a second over the last [`TPS_WINDOWS`], decayed once a second ([`Self::tps`]).
tps: [f64; 3],
/// When the second being counted started (at a recorded tick's end) and the ticks since.
tps_second: Option<(std::time::Instant, u32)>,
/// A server's client: its level's tick rate only slows the timer down
/// (`Minecraft.getTickTargetMillis`), since the server runs the ticks.
client: bool,
@@ -349,6 +355,8 @@ impl FixedStep {
tick_times: [0; SAMPLES],
aggregated: 0,
tick_count: 0,
tps: [20.0; 3],
tps_second: None,
client: false,
step_changes: 0,
step_requested: 0,
@@ -530,6 +538,41 @@ impl FixedStep {
let end = self.now_ns() + took;
self.manager.end_tick_work(end);
}
self.count_tick(std::time::Instant::now());
}
/// A recorded tick ended at `now`: once a second has passed since the second being
/// counted started, its ticks a second join each average of [`Self::tps`], weighted as a
/// load average is (`exp(-elapsed / window)` kept of the old value).
fn count_tick(&mut self, now: std::time::Instant) {
let Some((start, ticks)) = &mut self.tps_second else {
self.tps_second = Some((now, 0));
return;
};
*ticks += 1;
let elapsed = now.saturating_duration_since(*start).as_secs_f64();
if elapsed < 1.0 {
return;
}
let rate = f64::from(*ticks) / elapsed;
for (average, window) in self.tps.iter_mut().zip(TPS_WINDOWS) {
let kept = (-elapsed / window).exp();
*average = *average * kept + rate * (1.0 - kept);
}
self.tps_second = Some((now, 0));
}
/// The ticks a second the server kept over the last one, five and fifteen minutes (what
/// Bukkit's `Server.getTPS` reports; vanilla keeps no such average): measured between
/// recorded tick ends, so paused passes count where they are recorded. Starts at 20.
pub fn tps(&self) -> [f64; 3] {
self.tps
}
/// `getTickTimesNanos` as vanilla lays it out: the tick numbered `n` (from 1, as
/// `MinecraftServer.tickCount` after its increment) at index `n % 100`, so the
/// newest is at the recorded ticks' count `% 100`; 0 where no tick was recorded yet.
pub fn tick_times_nanos(&self) -> Vec<u64> {
(0..SAMPLES)
.map(|i| self.tick_times[(i + SAMPLES - 1) % SAMPLES].max(0) as u64)
.collect()
}
/// `getAverageTickTimeNanos`.
pub fn average_nanos(&self) -> u64 {
@@ -547,6 +590,51 @@ impl FixedStep {
mod tests {
use super::*;
/// Twenty ticks a second keep 20; ten a second pull the one-minute average down
/// fastest; a second not yet over changes nothing.
#[test]
fn tps_averages_follow_the_ticks_a_second() {
let mut clock = FixedStep::new(false);
let t0 = std::time::Instant::now();
let ms = std::time::Duration::from_millis;
for i in 0..=40 {
clock.count_tick(t0 + ms(50 * i));
}
assert_eq!(
clock.tps().map(|v| (v * 1000.0).round() / 1000.0),
[20.0; 3]
);
let slow = t0 + ms(2000);
for i in 1..=10 {
clock.count_tick(slow + ms(100 * i));
}
let [one, five, fifteen] = clock.tps();
assert!(
one < five && five < fifteen && fifteen < 20.0,
"{:?}",
clock.tps()
);
assert!((one - (20.0 - 10.0 * (1.0 - (-1.0f64 / 60.0).exp()))).abs() < 1e-9);
clock.count_tick(slow + ms(1050));
assert_eq!(clock.tps(), [one, five, fifteen]);
}
/// The tick times sit where vanilla's array has them: tick n at n % 100.
#[test]
fn tick_times_are_laid_out_as_vanillas() {
let mut clock = FixedStep::new(false);
assert_eq!(clock.tick_times_nanos(), vec![0; SAMPLES]);
for n in 1..=150u64 {
clock.record(std::time::Duration::from_nanos(n));
}
let times = clock.tick_times_nanos();
assert_eq!(times.len(), SAMPLES);
assert_eq!(times[50], 150, "the newest, tick 150");
assert_eq!(times[51], 51, "tick 51, overwritten by none yet");
assert_eq!(times[0], 100);
assert_eq!(times[1], 101);
}
#[test]
fn timer_carries_fractions_and_caps_nothing_itself() {
let mut t = Timer::new(20.0, 0);
crates/horizon-client/src/entities.rs
+33 -3
View File
@@ -666,7 +666,7 @@ impl ItemEntity {
wanted
} else {
// `Entity.collide`: the entities that `canBeCollidedWith` the item stop it
// too (a boat, a minecart, a shulker, a happy ghast held still), and
// too (a boat, a shulker, a happy ghast held still; not a minecart), and
// so does the world border (`Entity.collectColliders`).
crate::collisions::EntityCollisions {
blocks: scene,
@@ -1313,6 +1313,35 @@ impl ExperienceOrb {
border: Option<&BorderGeometry>,
fluids: &crate::motion::FluidResources,
on_sound: &mut dyn FnMut([f64; 3], f32),
) -> bool {
self.tick_among(
world,
facts,
collision,
player,
server,
next_float,
border,
fluids,
on_sound,
&[],
)
}
/// [`Self::tick`], its move also stopped by `entities`: the boxes of the
/// entities that `canBeCollidedWith` it (`EntityGetter.getEntityCollisions`).
#[allow(clippy::too_many_arguments)]
pub fn tick_among(
&mut self,
world: &World,
facts: &BlockFacts,
collision: &BlockCollisionRegistry<'_>,
player: Option<[f64; 3]>,
server: bool,
next_float: &mut dyn FnMut() -> f32,
border: Option<&BorderGeometry>,
fluids: &crate::motion::FluidResources,
on_sound: &mut dyn FnMut([f64; 3], f32),
entities: &[Aabb],
) -> bool {
self.ticks += 1;
self.previous = self.position;
@@ -1374,10 +1403,11 @@ impl ExperienceOrb {
// `double fallSpeed = getDeltaMovement().y`, taken after the stuck
// push and before the move.
let wanted = self.velocity;
// Entity.collide: the world border's walls stop the orb too.
// Entity.collide: the world border's walls and the entities that
// `canBeCollidedWith` it (a boat, a shulker) stop the orb too.
let border = border.map(|b| (b, [self.position.x, self.position.z]));
let moved = scene
.resolve_in_border(bounds, wanted, 0.0, self.on_ground, border)
.resolve_in_border_with(bounds, wanted, 0.0, self.on_ground, border, entities)
.unwrap_or(Vec3::ZERO);
self.position = Vec3::new(
self.position.x + moved.x,
crates/horizon-client/src/entity_nbt.rs
+131 -14
View File
@@ -105,6 +105,16 @@ impl Base<'_> {
}
tag
}
/// Preserve Entity data without flags owned by Mob's save writer.
/// Only the dedicated boat, item and armor-stand writers use this path.
fn non_mob_tag(&self, raw: Option<&Tag>) -> Tag {
let mut tag = self.tag(raw);
if let Tag::Compound(map) = &mut tag {
map.remove(&"NoAI".into());
map.remove(&"PersistenceRequired".into());
}
tag
}
}
/// `Entity.saveWithoutId`'s common fields for entities Horizon keeps as raw
@@ -128,8 +138,8 @@ pub fn fill_common_defaults(tag: &mut Tag) {
/// The mobs that save `Age` and `AgeLocked`.
fn saves_age(s: crate::mobs::Species) -> bool {
use crate::mobs::{Species, drops::can_be_baby, finalize::ageable};
s == Species::Tadpole || (ageable(s) && can_be_baby(s))
use crate::mobs::{Species, finalize::ageable, species::can_be_a_baby};
s == Species::Tadpole || (ageable(s) && can_be_a_baby(s))
}
/// `LivingEntity` + `Mob` (+ `AgeableMob`, creeper and skeleton specifics).
/// The mobs whose class extends vanilla's `Animal` (and so save `InLove`):
@@ -633,15 +643,11 @@ pub fn mob_to_nbt(
if species != crate::mobs::Species::Tadpole {
map.insert("ForcedAge".into(), Tag::Int(m.extra.forced_age));
}
} else if matches!(
species,
crate::mobs::Species::Parrot
| crate::mobs::Species::Slime
| crate::mobs::Species::MagmaCube
| crate::mobs::Species::ZombieNautilus
) {
} else if crate::mobs::finalize::ageable(species) {
// AgeableMob.addAdditionalSaveData writes nothing when canBeABaby is
// false: drop the ignored values a raw input compound carried.
// false — the frog, the parrot, the zombie nautilus, the camel husk,
// the slime and the magma cube: drop the ignored values a raw input
// compound carried rather than writing them back out.
for key in ["Age", "ForcedAge", "AgeLocked"] {
map.remove(&key.into());
}
@@ -2356,7 +2362,7 @@ pub fn item_entity_to_nbt(e: &ItemEntity, uuid: [i32; 4], raw: Option<&Tag>) ->
on_ground: e.on_ground,
fall_distance: 0.0,
};
let mut tag = base.tag(raw);
let mut tag = base.non_mob_tag(raw);
for (key, value) in [
("Item", item_to_nbt(&e.stack)),
("Health", Tag::Short(e.health as i16)),
@@ -3428,7 +3434,7 @@ pub fn armor_stand_to_nbt(a: &ArmorStand, uuid: [i32; 4], raw: Option<&Tag>) ->
on_ground: a.on_ground,
fall_distance: a.enchantment_fall_distance,
};
let mut tag = base.tag(raw);
let mut tag = base.non_mob_tag(raw);
let equipment: Vec<(&str, Tag)> = ArmorStand::SLOTS
.iter()
.zip(&a.equipment)
@@ -3582,7 +3588,7 @@ pub fn boat_to_nbt(
on_ground: false,
fall_distance: 0.0,
}
.tag(raw);
.non_mob_tag(raw);
if let (Some(items), Tag::Compound(map)) = (items, &mut tag) {
map.insert("Items".into(), crate::save::encode_items(items));
}
@@ -4038,11 +4044,16 @@ mod tests {
}
#[test]
fn cubes_omit_supplied_age_and_pigs_keep_modeled_age() {
fn an_ageable_mob_that_cannot_be_a_baby_saves_no_age() {
use crate::mobs::Species;
// AgeableMob.addAdditionalSaveData writes Age only when canBeABaby is
// true, so every ageable class that overrides it to false writes none
// of it: a frog and a camel husk keep no raw `Age` either.
for (species, id) in [
(Species::Slime, "minecraft:slime"),
(Species::MagmaCube, "minecraft:magma_cube"),
(Species::Frog, "minecraft:frog"),
(Species::CamelHusk, "minecraft:camel_husk"),
(Species::Pig, "minecraft:pig"),
] {
let mut kind = crate::mobs::sensor_scan_tests::kind();
@@ -4934,6 +4945,95 @@ mod tests {
}
}
#[test]
fn non_mob_saves_drop_mob_flags_without_losing_entity_fields() {
let uuid = [104, 0, 0, 1];
let mut kind = crate::mobs::sensor_scan_tests::kind();
let def = Arc::make_mut(&mut kind);
def.id = "minecraft:pig".into();
def.species = crate::mobs::Species::Pig;
let types = [("minecraft:pig".into(), kind)].into();
for input in [None, Some(0), Some(1)] {
for id in [
"minecraft:oak_boat",
"minecraft:oak_chest_boat",
"minecraft:armor_stand",
"minecraft:item",
"minecraft:pig",
] {
let mut raw = Tag::compound([
("id", string(id)),
("Pos", doubles(&[4.5, 200.0, 4.5])),
("Motion", doubles(&[0.0, 0.0, 0.0])),
("Silent", Tag::Byte(1)),
("NoGravity", Tag::Byte(1)),
("Invulnerable", Tag::Byte(1)),
("PortalCooldown", Tag::Int(17)),
("Tags", Tag::List(vec![string("audit")])),
("Unrelated", string("keep")),
(
"Item",
item_to_nbt(&crate::items::ItemStack::new("minecraft:stone", 1)),
),
]);
if let Some(value) = input {
put(&mut raw, "NoAI", Tag::Byte(value));
put(&mut raw, "PersistenceRequired", Tag::Byte(value));
}
let stand = armor_stand_from_nbt(&raw, 1).unwrap();
let item = item_entity_from_nbt(&raw, 1, 0.0).unwrap();
let boat = boat_from_nbt(&raw).unwrap();
for source in [None, Some(&raw)] {
let saved = match id {
"minecraft:armor_stand" => armor_stand_to_nbt(&stand, uuid, source),
"minecraft:item" => item_entity_to_nbt(&item, uuid, source),
"minecraft:pig" => {
let mut mob = mob_from_nbt(&raw, &types, 1, None).unwrap();
// The writer must use live state, even opposite stale raw values.
mob.no_ai = input != Some(1);
mob.persistent = input != Some(1);
mob_to_nbt(&mob, uuid, source, None, |_| None)
}
_ => boat_to_nbt(
id,
boat.0,
boat.1,
[boat.2, 0.0],
uuid,
source,
(id == "minecraft:oak_chest_boat").then_some(&[]),
),
};
if id == "minecraft:pig" {
let live = input != Some(1);
assert_eq!(saved.get("NoAI"), live.then_some(&Tag::Byte(1)));
assert_eq!(
saved.get("PersistenceRequired"),
Some(&Tag::Byte(i8::from(live)))
);
} else {
assert!(saved.get("NoAI").is_none(), "{id} {input:?}");
assert!(saved.get("PersistenceRequired").is_none(), "{id} {input:?}");
}
assert_eq!(saved.get("UUID"), Some(&Tag::IntArray(uuid.to_vec())));
assert_eq!(saved.get("Pos"), raw.get("Pos"));
if source.is_some() {
for key in [
"Silent",
"NoGravity",
"Invulnerable",
"PortalCooldown",
"Tags",
"Unrelated",
] {
assert_eq!(saved.get(key), raw.get(key), "{id} {key}");
}
}
}
}
}
}
#[test]
fn animal_integer_loads_save_modeled_values_without_raw_source() {
let mut kind = crate::mobs::sensor_scan_tests::kind();
@@ -7763,6 +7863,23 @@ mod generic_home_nbt_tests {
])
}
#[test]
fn spawned_trader_home_restricts_and_survives_save() {
let mut m = mob(Species::WanderingTrader, "minecraft:wandering_trader");
crate::mobs::trader::start_visit(&mut m, [4, 201, 0]);
m.position = Vec3::new(19.5, 201.0, 0.5);
assert!(crate::mobs::trader::within_home(&m));
m.position = Vec3::new(20.5, 201.0, 0.5);
assert!(!crate::mobs::trader::within_home(&m));
let saved = mob_to_nbt(&m, [0; 4], None, None, |_| None);
assert_eq!(saved.get("home_radius"), Some(&Tag::Int(16)));
assert_eq!(saved.get("home_pos"), Some(&Tag::IntArray(vec![4, 201, 0])));
let mut loaded = mob(Species::WanderingTrader, "minecraft:wandering_trader");
loaded.position = m.position;
read_mob_home(&mut loaded, &saved);
assert!(!crate::mobs::trader::within_home(&loaded));
}
#[test]
fn generic_home_output_uses_model_and_removes_stale_raw_fields() {
let mut m = mob(Species::Pig, "minecraft:pig");
crates/horizon-client/src/entry.rs
+61
View File
@@ -46,6 +46,8 @@ pub fn main_with(mods: crate::mod_api::Mods) {
}
(logging::game_home(), "client", "Render thread")
};
// Before the log opens, so a mod's injection hears its first lines.
logging::set_line_hook(crate::native_client_hooks::native_log_line);
if !help {
logging::init(
logging::player_dir_override().unwrap_or(home.as_path()),
@@ -98,6 +100,35 @@ pub fn main_with(mods: crate::mod_api::Mods) {
{
log::warn!("Native data-load hooks already installed; keeping the first callbacks");
}
if horizon_world::worldgen::native_generate::install(
horizon_world::worldgen::native_generate::NativeGenerateHooks {
chunk_generate: |dimension, chunk, seed, flat, chunk_out, generate| {
crate::mod_api::dispatch_chunk_generate(
crate::mod_api::mods(),
dimension,
chunk,
seed,
flat,
chunk_out,
generate,
);
},
lod_column: |dimension, column, seed, flat, column_out| {
crate::mod_api::dispatch_lod_column(
crate::mod_api::mods(),
dimension,
column,
seed,
flat,
column_out,
);
},
},
)
.is_err()
{
log::warn!("Native generation hooks already installed; keeping the first callbacks");
}
if crate::native_client_hooks::install(crate::native_client_hooks::NativeClientHooks {
menu_slot_rules: |menu, slot, stack, may_place, max_stack| {
crate::mod_api::dispatch_menu_slot_rules(
@@ -168,6 +199,23 @@ pub fn main_with(mods: crate::mod_api::Mods) {
register_goals: |mob| {
crate::mod_api::dispatch_register_goals(crate::mod_api::mods(), mob);
},
player_pre_login: |player, name, address, defer| {
crate::mod_api::dispatch_player_pre_login(
crate::mod_api::mods(),
player,
name,
address,
defer,
);
},
player_profile: |player, name, properties| {
crate::mod_api::dispatch_player_profile(
crate::mod_api::mods(),
player,
name,
properties,
);
},
ingredient: |kind, data, items| {
crate::mod_api::dispatch_ingredient(crate::mod_api::mods(), kind, data, items);
},
@@ -180,6 +228,19 @@ pub fn main_with(mods: crate::mod_api::Mods) {
accept,
);
},
log_line: |level, thread, message, line| {
crate::mod_api::dispatch_log_line(crate::mod_api::mods(), level, thread, message, line);
},
handshake: |address, host, intent, cancel, reason| {
crate::mod_api::dispatch_handshake(
crate::mod_api::mods(),
address,
host,
intent,
reason,
cancel,
);
},
})
.is_err()
{
crates/horizon-client/src/furnace.rs
+63 -3
View File
@@ -78,9 +78,6 @@ impl FurnaceCooking for Furnace {
if lit || has_fuel && has_ingredient {
if let Some(ingredient) = self.items[0].clone() {
if let Some(recipe) = recipes.cook(self.kind.recipe_type(), &ingredient) {
if self.cooking_timer == 0 {
self.cooking_total = total_time(recipe.time, self.speed);
}
let max = items.get(&recipe.result.item).map_or(64, |i| i.max_stack);
let can_burn = match &self.items[2] {
None => true,
@@ -250,6 +247,69 @@ mod tests {
(items, recipes, providers)
}
#[test]
fn loaded_totals_survive_until_actual_completion() {
let (items, recipes, providers) = data("loaded-total");
assert_eq!(
recipes
.cook(
FurnaceKind::Furnace.recipe_type(),
&ItemStack::new("test:ore", 3)
)
.unwrap()
.time,
200
);
// Fresh Java's five-case Game fixture independently admits the loaded
// zero (including a missing saved field), five and normal totals.
for (total, timer, completion) in [(0, 0, 1), (5, 0, 5), (200, 0, 200), (5, 1, 4)] {
let mut f = Furnace {
kind: FurnaceKind::Furnace,
items: [Some(ItemStack::new("test:ore", 3)), None, None],
lit_remaining: 20,
lit_total: 20,
cooking_timer: timer,
cooking_total: total,
speed: 1.0,
recipes_used: HashMap::new(),
};
for elapsed in 1..=6 {
let mut drops = Vec::new();
assert!(!f.idle());
assert_eq!(f.tick(&recipes, &items, &providers, &mut drops), None);
assert!(drops.is_empty());
assert_eq!((f.lit_remaining, f.lit_total), (20 - elapsed, 20));
assert!(f.items[1].is_none());
let complete = elapsed >= completion;
assert_eq!(
f.items[0].as_ref().unwrap().count,
if complete { 2 } else { 3 },
"loaded {total}/{timer}, tick {elapsed}"
);
assert_eq!(
f.items[2].as_ref().map(|s| (&*s.item, s.count)),
if complete {
Some(("test:ingot", 1))
} else {
None
}
);
assert_eq!(f.cooking_total, if complete { 200 } else { total });
assert_eq!(
f.cooking_timer,
if complete {
elapsed - completion
} else {
timer + elapsed
}
);
}
// A changed input still goes through setItem's independent reset.
f.set_input(&recipes, Some(ItemStack::new("test:ingot", 1)));
assert_eq!((f.cooking_timer, f.cooking_total), (0, 200));
}
}
#[test]
fn cooking_requires_output_components_and_capacity() {
let (items, recipes, providers) = data("output-components");
crates/horizon-client/src/game.rs
+265 -60
View File
@@ -104,6 +104,7 @@ mod creative_hotbar;
mod creatures;
mod crossbow;
pub(crate) mod cushions;
mod custom_sky;
mod debug_keys;
mod debug_lines;
mod debug_options;
@@ -223,8 +224,10 @@ mod native_biome_colors;
pub mod native_block_entity_draw;
mod native_block_sprites;
mod native_bots;
mod native_chunk_snapshot;
mod native_chunk_tickets;
mod native_claimed_items;
mod native_client_entities;
mod native_client_particles;
mod native_client_particles_fixture;
pub mod native_client_services;
@@ -232,7 +235,9 @@ mod native_client_world;
mod native_components;
mod native_configs;
mod native_criteria;
mod native_damage;
mod native_data_maps;
mod native_diagnostics;
mod native_entities;
mod native_entity_data;
mod native_entity_motion;
@@ -257,8 +262,15 @@ mod native_mobs;
mod native_motion;
mod native_mounts;
mod native_net;
mod native_npcs;
mod native_packets;
mod native_panel;
mod native_panel_recipes;
mod native_permissions;
mod native_player_fx;
mod native_player_reads;
mod native_player_state;
mod native_profiles;
mod native_projectiles;
mod native_quick_move;
mod native_recipes;
@@ -269,11 +281,15 @@ mod native_shaders;
mod native_structures;
mod native_terrain_model;
mod native_ticks;
mod native_travel;
mod native_view_distance;
mod native_visuals;
mod native_world_border;
mod native_world_columns;
pub mod native_world_draw;
mod native_world_edit;
mod native_world_read;
mod native_world_seed;
mod natural_spawning;
mod nautili;
mod net_harness;
@@ -461,6 +477,7 @@ use horizon_world::{
pub use machines::native_fluids::NativeFluidTank;
pub use maps::{NativeMapDecoration, NativeMapInfo};
pub use native_block_entity_draw::BlockEntityDraw;
pub use native_chunk_snapshot::NativeChunkSnapshot;
pub use native_claimed_items::{NativeHeldItem, NativeHit, NativeModEvent};
pub use native_client_world::{NativeBiomeId, NativeClientBiomes, NativeClientChunks};
pub use native_components::NativeComponentError;
@@ -469,8 +486,10 @@ pub use native_criteria::NativeCriterion;
pub use native_data_maps::NativeDataMapType;
pub use native_falling::NativeFalling;
pub use native_hooks::{NativeClock, NativeItemEntity, NativePlayer, NativeShake};
pub use native_inventories::NativeInventoryKind;
pub use native_item_energy::ItemEnergyBuffer;
pub use native_mob_draw::{NativeMobRender, NativePlayerRender};
pub use native_player_state::NativeEffect;
pub use native_reload_listeners::NativeReloadListener;
pub use native_server::NativeExperienceOrb;
pub use native_structures::{NativeStructureBlock, NativeStructureTemplate};
@@ -1114,6 +1133,24 @@ impl EntityObstructionWorld for BuildingObstruction {
.collect())
}
}
/// Whether a block's successful use is `InteractionResult.SUCCESS_SERVER`,
/// which a client does not predict: `useWithoutItem` of a bed, a light
/// block, a charged respawn anchor or a sign. Every other block use the
/// level answers with SUCCESS is `SUCCESS` (`SwingSource.PREDICTED`).
fn server_only_block_use(
block: &horizon_items::blocks::StateFacts,
branch: horizon_world::level::UseBranch,
) -> bool {
branch == horizon_world::level::UseBranch::WithoutItem
&& [
"AbstractBedBlock",
"LightBlock",
"RespawnAnchorBlock",
"SignBlock",
]
.iter()
.any(|class| block.has_class(class))
}
/// An entity's box (`EntityDimensions.makeBoundingBox`): `width` wide and
/// `height` tall, standing on `feet`.
fn point_box(feet: [f64; 3], width: f64, height: f64) -> Aabb {
@@ -1254,6 +1291,11 @@ impl LevelAccess for GameLevel<'_> {
self.native_neighbor_changed(self.dimension, pos, state, changed, moved);
}
}
fn redstone_change(&self, pos: BlockPos, old: i32, new: &mut i32) {
if self.native_authoritative {
self.native_block_redstone(self.dimension, pos, old, new);
}
}
fn allow_spread(
&self,
kind: horizon_world::level::Spread,
@@ -1576,6 +1618,9 @@ impl LevelAccess for GameLevel<'_> {
/// the count a recount of the players with that container open finds, and
/// the count it replaces. Only the block entities that keep a counter and
/// a scheduled recheck answer; anything else is `None`.
fn container_open(&self, pos: BlockPos) -> bool {
self.open_containers.contains(&(pos.x, pos.y, pos.z))
}
fn recheck_container_openers(&mut self, pos: BlockPos) -> Option<(i32, i32)> {
use horizon_world::level::classes::Class;
let data = self.behaviours.data(self.world.block(pos.x, pos.y, pos.z));
@@ -2242,6 +2287,8 @@ pub struct PackResources {
clouds: Arc<(u32, u32, Vec<bool>)>,
/// misc/forcefield.png: (width, height, RGBA) for the world border wall.
forcefield: Arc<(u32, u32, Vec<u8>)>,
/// OptiFine custom sky layers (`optifine/sky`) with their textures; empty without them.
custom_sky: Arc<horizon_client::custom_sky::CustomSky>,
}
impl PackResources {
/// Everything a pack overlay at `root` provides, over `assets` and `render`
@@ -2317,6 +2364,7 @@ impl PackResources {
names: Arc::new(Names::load(root)),
clouds: Arc::new(load_clouds(root)),
forcefield: Arc::new(load_forcefield(root)),
custom_sky: Arc::new(horizon_client::custom_sky::CustomSky::load(root)),
}
}
}
@@ -2876,6 +2924,9 @@ struct Game<'a> {
/// The arm swing (`LivingEntity.SwingState`) and how many swings started.
swing: horizon_client::first_person::SwingState,
swings_started: u32,
/// Swings of uses whose client predicts them (`SwingSource.PREDICTED`):
/// a server does not send these back to the player who swung.
predicted_swings: u32,
/// The first-person equip heights and the items the hands show (with
/// the slot each came from).
heights: horizon_client::first_person::HandHeights,
@@ -2906,6 +2957,8 @@ struct Game<'a> {
/// `ClientAvatarState`: walked distance and view bob.
avatar: horizon_client::camera::AvatarBob,
flash: u32,
/// OptiFine custom sky layers' eased brightness (`custom_sky.rs`).
custom_sky: custom_sky::CustomSkyView,
/// `ClientLevel.rainSoundTime`: ticks of rain since the last rain sound.
rain_sound_time: i32,
/// Bolts that struck here and sky flashes they made, in total (`status`).
@@ -2968,6 +3021,8 @@ struct Game<'a> {
map_frame_model: frames::FrameModel,
glow_map_frame_model: frames::FrameModel,
armor_stands: horizon_client::join_seq::JoinList<horizon_client::entities::ArmorStand>,
/// Worn armor as of the last `collectEquipmentChanges` look (frost walker).
location_armor: [Option<ItemStack>; 4],
/// `Cushion` decoration entities (game/cushions.rs).
cushions: Vec<horizon_client::entities::Cushion>,
/// Entities of types Horizon does not simulate.
@@ -3003,6 +3058,9 @@ struct Game<'a> {
carts: horizon_client::join_seq::JoinList<minecarts::Minecart>,
/// The boats and minecarts `native_vehicle_moved` follows (lan_vehicles.rs).
watched_vehicles: Vec<lan_vehicles::WatchedVehicle>,
/// What the mods asked for server players out of reach (`native_teleport_player`...),
/// done after the players' packets of the tick (native_travel.rs).
native_moves: Vec<(u128, native_travel::NativeMove)>,
/// Songs playing from jukeboxes (tracked sound handles).
jukebox_sounds: HashMap<(i32, i32, i32), u64>,
bolts: Vec<lightning::Bolt>,
@@ -3137,6 +3195,10 @@ struct Game<'a> {
native_configs: native_configs::NativeConfigs,
/// Native mods' messages waiting (`game/native_net.rs`).
native_net: native_net::NativeNet,
/// What native mods send one player, waiting for the hub (`game/native_player_fx.rs`).
native_player_fx: native_player_fx::NativePlayerFx,
/// Native mods' kicks waiting for the tick's end (`game/native_packets.rs`).
native_packets: native_packets::NativePackets,
/// The mod whose own screen is open (`Screen::Mod`).
native_mod_screen: Option<String>,
/// Meshed sections waiting for an upload budget (Horizon settings).
@@ -3283,6 +3345,9 @@ struct Game<'a> {
/// The last `use_hand` that ended the click did so with `FAIL`, which
/// does not consume the action (handleUseItemOn's ANY_BLOCK_USE).
use_failed: bool,
/// A mod canceled a use the acting guest's client predicted (a throw, a
/// placement): their inventory goes out whole when the turn ends.
guest_inventory_resend: bool,
/// Level events of this tick for the guests, and the guest acting now.
lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
/// Jukebox level events 1010 (song name) and 1011 (`None`) for the guests;
@@ -3335,6 +3400,9 @@ struct Game<'a> {
lan_acting_name: Option<String>,
/// Their UUID (`Player.getUUID`).
lan_acting_uuid: Option<u128>,
/// The player and the stack on their cursor as they clicked a native
/// menu, while `native_menu_clicked` hears it (`native_menu_cursor`).
native_click_cursor: Option<(u128, Option<horizon_client::items::ItemStack>)>,
/// Where the mods refused to prime TNT: the sound and game event the level
/// queued right after the prime are dropped (`prime_tnt_event`).
tnt_refused: Option<BlockPos>,
@@ -3343,6 +3411,9 @@ struct Game<'a> {
/// Their entity id, which the hub (often taken out of `lan` while they
/// act) would otherwise have to be asked for.
lan_acting_entity: Option<u32>,
/// The player `native_player_login` hears and their permission level, while it runs
/// (`native_player_permission`): the hub is out of reach there.
native_login_permission: Option<(u128, u8)>,
/// Command feedback to forward to a guest.
chat_capture: Option<Vec<horizon_client::text::Text>>,
/// Packets for the guest acting now, sent once its action returns.
@@ -3350,6 +3421,9 @@ struct Game<'a> {
/// The acting guest's cooldowns, as (item, ticks): their packet needs the
/// hub's item registry, which the guest's turn does not hold.
guest_cooldowns: Vec<(Arc<str>, i32)>,
/// Players whose command tree the mods asked to send again
/// (`native_resend_commands`), sent in the next server tick.
native_resend_trees: Vec<u128>,
/// The acting guest's own entity events (`ServerPlayer.connection.send`),
/// sent with their entity id, which the guest's turn does not hold.
guest_entity_events: Vec<i8>,
@@ -4376,6 +4450,15 @@ impl Game<'_> {
self.award_stat("dropped", &thrown.item, thrown.count as i32);
self.award_custom_stat("drop", 1);
let player = self.native_acting_id();
let mut cancel = false;
self.native_item_dropped_v2(player, &thrown, &mut cancel);
if cancel {
// The stack stays the player's: what doesn't fit is thrown after all.
if let Some(rest) = self.give(thrown) {
self.throw_from_eyes(rest, eye, true);
}
return;
}
self.native_item_dropped(player, &thrown.item, thrown.count);
self.throw_from_eyes(thrown, eye, true);
}
@@ -4652,7 +4735,7 @@ impl Game<'_> {
&& b.max_position().z > min[2];
// ItemEntity.playerTouch: no pickup delay, and the target (if any) is this player.
if touching && item.pickup_delay == 0 && item.target.is_none_or(|t| t == own) {
if self.native_pickup_refused(&item.stack) {
if self.native_pickup_refused(&item.stack, item.thrower, item.position) {
item.pickup_delay = 10;
kept.push(item);
continue;
@@ -5605,9 +5688,10 @@ impl Game<'_> {
LevelEvent::LevelEvent { id: 2009, pos, .. } => {
self.puffs_above_block(pos, horizon_client::particles::ParticleType::Cloud)
}
// LevelEventHandler 2012: a turtle egg laid.
// LevelEventHandler 2011 and 2012: a bee growing a crop, a
// turtle egg laid.
LevelEvent::LevelEvent {
id: 2012,
id: 2011 | 2012,
pos,
data,
} => self.turtle_egg_particles(pos, data),
@@ -6164,11 +6248,12 @@ impl Game<'_> {
/// One falling block's `tick`: places or drops its block in its own tick,
/// so a block falling onto one that just landed lands on top of it. `i` is
/// its place in the list; the caller has checked it is ticking.
fn tick_one_falling(&mut self, i: usize) -> Result<()> {
/// `entities` are the boxes that stop its move (`Game::item_entity_collisions`).
fn tick_one_falling(&mut self, i: usize, entities: &[Aabb]) -> Result<()> {
let entity_drops = self.ui.rules.bool("entity_drops");
let mut f = self.falling.remove(i);
let original = f.clone();
match self.fall_step(&mut f, entity_drops) {
match self.fall_step(&mut f, entity_drops, entities) {
Ok(FallStep::Falling) => self.falling.insert(i.min(self.falling.len()), f),
Ok(FallStep::Gone) => {}
Ok(FallStep::Dropped(at)) => self.drop_falling_block(f.state, at),
@@ -6181,7 +6266,12 @@ impl Game<'_> {
Ok(())
}
/// One `FallingBlockEntity.tick` move of `f`.
fn fall_step(&mut self, f: &mut FallingBlock, entity_drops: bool) -> Result<FallStep> {
fn fall_step(
&mut self,
f: &mut FallingBlock,
entity_drops: bool,
entities: &[Aabb],
) -> Result<FallStep> {
f.previous = f.position;
f.age = f.age.wrapping_add(1);
f.velocity.y -= horizon_client::entity_rules::EntityRules::get_gravity(f);
@@ -6215,10 +6305,11 @@ impl Game<'_> {
false,
);
// On an error the caller keeps the block as it was before this tick.
// Entity.collide: the world border's walls stop it too.
// Entity.collide: the world border's walls and the entities that
// `canBeCollidedWith` it (a boat, a shulker) stop it too.
let movement = collisions::EntityCollisions {
blocks: scene,
entities: &[],
entities,
border: Some((self.border.geometry(), [f.position.x, f.position.z])),
}
.resolve_with_context(
@@ -6731,6 +6822,7 @@ impl Game<'_> {
}
if !claimed {
self.native_interact_entity(id, &kind, stack.as_ref(), &mut claimed);
self.native_interact_entity_v2(id, &kind, self.hand, stack.as_ref(), &mut claimed);
}
if claimed {
self.swing_arm();
@@ -6829,6 +6921,8 @@ impl Game<'_> {
let mut canceled = false;
horizon_client::spans::time("use_mods", || {
self.native_right_click_block(hit.pos, hit.face, &mut canceled);
let hand = self.hand;
self.native_right_click_block_v2(hit.pos, hit.face, hand, &mut canceled);
});
if canceled {
// Nothing was used, so nothing consumed the action.
@@ -7014,7 +7108,13 @@ impl Game<'_> {
}
}
if result.should_swing() {
self.swing_arm();
// SUCCESS swings on the client too; the beds, light,
// respawn anchor and sign's own uses are SUCCESS_SERVER.
if server_only_block_use(self.res.facts().get(cake), branch) {
self.swing_arm();
} else {
self.swing_arm_predicted();
}
}
return Ok(true);
}
@@ -7254,6 +7354,13 @@ impl Game<'_> {
item: stack.item.to_string(),
can_use_game_master_blocks: self.can_use_game_master_blocks(),
};
// The mods, once the position and state are known: a canceled
// placement is a failed one, and the client's prediction is undone.
if self.block_place_canceled(&stack, &ctx) {
self.use_failed = true;
self.guest_inventory_resend = true;
return Ok(true);
}
let outcome = self.with_level(|b, level, ticks| b.place_block(level, ticks, &ctx));
let PlaceOutcome::Placed { pos, state } = outcome else {
self.process_level_events()?;
@@ -7292,7 +7399,8 @@ impl Game<'_> {
_ => {}
}
}
self.swing_arm();
// BlockItem.place's SUCCESS: the client swings with its own prediction.
self.swing_arm_predicted();
// BlockItem.place's sound is among the level events;
// SolidBucketItem.getPlaceSound replaces it with the bucket's own.
let solid_bucket = &*stack.item == "minecraft:powder_snow_bucket";
@@ -7319,6 +7427,30 @@ impl Game<'_> {
}
Ok(true)
}
/// Asks the mods whether the acting guest may place `stack` where and as
/// `BlockItem.place` would for `ctx` (`native_block_place`): true when
/// one canceled it. A game's own player is not asked, nor a placement
/// vanilla refuses.
fn block_place_canceled(&mut self, stack: &ItemStack, ctx: &PlaceContext) -> bool {
let (Some(uuid), Some(name)) = (self.lan_acting_uuid, self.lan_acting_name.clone()) else {
return false;
};
let Some((pos, state)) =
self.with_level(|b, level, ticks| b.placement_state(level, ticks, ctx))
else {
return false;
};
let mut cancel = false;
self.native_block_place(
uuid,
&name,
stack,
[pos.x, pos.y, pos.z],
state,
&mut cancel,
);
cancel
}
/// Asks the mods whether the acting guest may empty `stack` at `pos`
/// (`native_bucket_empty`): true when one cancelled it. A game's own
/// player is not asked.
@@ -7425,6 +7557,7 @@ impl Game<'_> {
);
instance.ambient = eff.ambient;
instance.visible = eff.show_particles;
instance.show_icon = eff.show_icon;
self.add_player_effect(instance);
}
}
@@ -7552,12 +7685,18 @@ impl Game<'_> {
.instrument(&stack)
.map(|i| i.use_ticks().max(0) as u32)
{
// InstrumentItem.getUseDuration: held up that long, nothing more.
self.using = (ticks + 1 < duration).then_some((slot, ticks + 1));
// InstrumentItem.getUseDuration: held up that long. When it runs
// out, LivingEntity.stopUsingItem ends the use and causes the
// interaction vibration; letting go of the button already does.
if ticks + 1 < duration {
self.using = Some((slot, ticks + 1));
} else {
self.stop_using_item(&stack);
}
return;
}
if &*stack.item == "minecraft:brush" {
self.tick_brush(slot, ticks);
self.tick_brush(&stack, slot, ticks);
return;
}
if info.bundle {
@@ -9061,9 +9200,6 @@ impl Game<'_> {
let spectator = self.spectator();
let (wi, hi) = (w as i32, h as i32);
let show_hud = !self.ui.hide_gui;
// max(Hud.leftHeight, Hud.rightHeight) after the bars: the item name and
// the action bar sit above it.
let mut bar_height = 39;
if show_hud {
self.draw_spyglass(&mut batch);
// Hud.extractCrosshair / extractItemHotbar / extractPlayerHealth /
@@ -9162,8 +9298,6 @@ impl Game<'_> {
} else {
self.draw_mount_hud(&mut batch, wi, hi)
};
// Without the survival bars only the mount's hearts raise it.
bar_height = 39 + 10 * ((vehicle_hearts + 9) / 10);
// The one bar above the hotbar: the mount's jump bar, the locator
// bar (with its background) or the experience bar, with the level
// number that a survival player always has.
@@ -9256,10 +9390,6 @@ impl Game<'_> {
self.gui_layer("minecraft:player_health", &mut batch, |g, batch| {
hud_layout::paint(batch, &g.gui.atlas, &draws);
});
bar_height = self
.health_hud
.left_height
.max(self.health_hud.right_height);
// Hud.playAirBubblePoppedSound: Player.playSound (PLAYERS), heard
// by this client only.
if let Some((volume, pitch)) = self.health_hud.bubble_pop_sound.take() {
@@ -9275,7 +9405,7 @@ impl Game<'_> {
}
if !spectator {
self.gui_layer("minecraft:selected_item_name", &mut batch, |g, batch| {
g.draw_selected_name(batch, bar_height, !g.creative);
g.draw_selected_name(batch, !g.creative);
});
}
}
@@ -9286,7 +9416,7 @@ impl Game<'_> {
});
if show_hud {
self.gui_layer("minecraft:overlay_message", &mut batch, |g, batch| {
g.draw_overlay_message(batch, bar_height);
g.draw_overlay_message(batch);
});
self.gui_layer("minecraft:title", &mut batch, |g, batch| {
g.draw_title(batch);
@@ -10440,18 +10570,27 @@ impl Game<'_> {
if let Some((s, mob)) = session.as_mut() {
self.merchant_sync_in(s, *mob);
}
// The cartography table reads and makes the level's maps; a
// Crafting and cartography read and derive the level's maps; a
// server's (the client menu's ContainerLevelAccess.NULL) doesn't.
let level_maps = (kind == Kind::Cartography && self.remote.is_none()).then(|| {
let held: Vec<ItemStack> = before
let level_maps = (matches!(kind, Kind::Cartography | Kind::Crafting | Kind::Inventory)
&& self.remote.is_none())
.then(|| {
before
.iter()
.flatten()
.chain(self.inventory.iter().flatten())
.chain(self.carried.iter())
.cloned()
.collect();
self.level_maps(&held)
});
.collect::<Vec<_>>()
})
.filter(|held| {
kind == Kind::Cartography
|| held
.iter()
.filter_map(maps::map_id)
.any(|id| self.map(id).is_some())
})
.map(|held| self.level_maps(&held));
let next_map = if merchant_open { self.peek_map_id() } else { 0 };
let tag = |t: &str| self.structure_tag(t);
let maps = trading::GameMaps {
@@ -10561,6 +10700,9 @@ impl Game<'_> {
let predicting = self.remote.is_some();
if !predicting {
self.register_exploration_maps(made);
for (item, count) in std::mem::take(&mut menu.crafted_counts) {
self.award_stat("crafted", &item, count);
}
}
if let Some(s) = menu.merchant.take() {
self.merchant_sync_out(s);
@@ -12289,8 +12431,12 @@ impl Game<'_> {
if let Some(hit) = self.tick_mob {
return hit;
}
self.mob_hit_within(self.entity_reach)
}
/// [`Game::mob_hit`] out to `reach` instead of the entity interaction range
/// (`ProjectileUtil.getHitResultOnViewVector` with another range).
pub(super) fn mob_hit_within(&self, reach: f64) -> Option<(usize, f64, [f64; 3])> {
let (eye, dir) = self.aim()?;
let reach: f64 = self.entity_reach;
let mut best: Option<(usize, f64, [f64; 3])> = None;
for (i, m) in self.mobs.iter().enumerate() {
// ProjectileUtil.getEntityHitResult: the mob the player rides
@@ -13806,6 +13952,9 @@ impl Game<'_> {
&& let Ok(new) = registry.resolve(&block)
{
self.level_set(pos, new)?;
if result.lower_fill_level {
self.post_block_game_event("minecraft:block_change", pos, None, Some(new));
}
}
if let Some(sound) = result.sound {
self.audio.play(
@@ -14362,12 +14511,19 @@ impl Game<'_> {
/// `ExperienceOrb.award`: orbs of the largest sizes; each draws the id
/// `tryMergeToExisting` compares from the level random, then moves with
/// its own random.
fn spawn_orbs(&mut self, at: [f64; 3], mut value: u32) {
fn spawn_orbs(&mut self, at: [f64; 3], value: u32) {
self.spawn_orbs_toward(at, [0.0; 3], value);
}
/// `ExperienceOrb.awardWithDirection`: `award` whose fresh orbs start
/// `roughly` that way (`new ExperienceOrb(level, pos, roughly, value)`).
fn spawn_orbs_toward(&mut self, at: [f64; 3], roughly: [f64; 3], mut value: u32) {
while value > 0 {
let v = ExperienceOrb::split(value);
value -= v;
let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
self.award_orb(at, v, merge_id);
if !self.merge_new_orb(at, v, merge_id) {
self.add_orb_toward(at, roughly, v);
}
}
}
/// `ExperienceOrb.tryMergeToExisting`: an orb of the same value within a
@@ -14375,6 +14531,12 @@ impl Game<'_> {
/// the new one as one more in its count (and restarts its age); otherwise
/// a fresh orb spawns.
fn award_orb(&mut self, at: [f64; 3], value: u32, merge_id: i32) {
if !self.merge_new_orb(at, value, merge_id) {
self.add_orb(at, value);
}
}
/// `tryMergeToExisting`: true when an orb took the new one.
fn merge_new_orb(&mut self, at: [f64; 3], value: u32, merge_id: i32) -> bool {
let centre = Vec3::new(at[0], at[1], at[2]);
let half = Vec3::new(0.5, 0.5, 0.5);
let area = Aabb::new(centre.subtract(half), centre.add_vector(half));
@@ -14396,8 +14558,9 @@ impl Game<'_> {
if let Some(i) = target {
self.orbs[i].count += 1;
self.orbs[i].age = 0;
true
} else {
self.add_orb(at, value);
false
}
}
/// Whether orb `into` takes orb `from` (0: a spawning orb of `from_value`),
@@ -14471,10 +14634,33 @@ impl Game<'_> {
/// `new ExperienceOrb(level, pos, Vec3.ZERO, value)`: yaw and motion from
/// the orb's own random.
fn add_orb(&mut self, at: [f64; 3], value: u32) {
let at = self.unstuck_orb(at);
self.add_orb_toward(at, [0.0; 3], value);
}
/// `new ExperienceOrb(level, pos, roughly, value)`: a random motion that
/// points against `roughly` is turned round, and the orb starts half its
/// size (0.25) along `roughly`, unstuck if it collides there.
fn add_orb_toward(&mut self, at: [f64; 3], roughly: [f64; 3], value: u32) {
let len_sqr = roughly.iter().map(|v| v * v).sum::<f64>();
// Vec3.normalize: a vector shorter than 1e-5 has no direction.
let len = len_sqr.sqrt();
let unit = if len < 1.0e-5 {
[0.0; 3]
} else {
roughly.map(|v| v / len)
};
let at = self.unstuck_orb([0, 1, 2].map(|a| at[a] + unit[a] * 0.25));
let mut r = dispenser::entity_random();
let _yaw = r.next_float();
let p = Vec3::new(at[0], at[1], at[2]);
let mut velocity = Vec3::new(
(r.next_double() * 0.2 - 0.1) * 2.0,
r.next_double() * 0.2 * 2.0,
(r.next_double() * 0.2 - 0.1) * 2.0,
);
let dot = roughly[0] * velocity.x + roughly[1] * velocity.y + roughly[2] * velocity.z;
if len_sqr > 0.0 && dot < 0.0 {
velocity = Vec3::new(-velocity.x, -velocity.y, -velocity.z);
}
self.next_entity += 1;
self.orbs.push(ExperienceOrb {
rotation: [0.0, 0.0],
@@ -14483,11 +14669,7 @@ impl Game<'_> {
id: self.next_entity,
position: p,
previous: p,
velocity: Vec3::new(
(r.next_double() * 0.2 - 0.1) * 2.0,
r.next_double() * 0.2 * 2.0,
(r.next_double() * 0.2 - 0.1) * 2.0,
),
velocity,
value,
age: 0,
on_ground: false,
@@ -15159,7 +15341,7 @@ impl Game<'_> {
self.settings.horizon.api,
self.settings.horizon.translucent_batching,
self.settings.horizon.wide_frame(),
shader_packs::picked_pack_draws_flat(&self.settings),
shader_packs::picked_pack_shape(&self.settings),
(
self.settings.file.int("textureFiltering"),
self.settings.file.int("maxAnisotropyBit"),
@@ -15200,7 +15382,7 @@ impl Game<'_> {
self.settings.horizon.api,
self.settings.horizon.translucent_batching,
self.settings.horizon.wide_frame(),
shader_packs::picked_pack_draws_flat(&self.settings),
shader_packs::picked_pack_shape(&self.settings),
(
self.settings.file.int("textureFiltering"),
self.settings.file.int("maxAnisotropyBit"),
@@ -16329,6 +16511,17 @@ impl Game<'_> {
// (`take_parent_vehicle`); here it stays in the chunk saves.
let mut host = host;
for g in host.hub.guests.iter_mut().filter(|g| g.placed) {
// Read-only fixture input, correlated with the real save receipt.
// Keep this identical on the untouched/fixed selector builds.
if std::env::var_os("HORIZON_DEV_ADVANCEMENT_SELECTOR_AUDIT").is_some() {
eprintln!(
"advancement selector model raw: {}",
serde_json::json!({"conn":g.conn,"name":g.name,
"uuid":horizon_protocol::crypto::uuid_string(g.uuid),
"game_time":self.world.game_time,
"progress":g.advancements.to_json(&self.adv.tree, horizon_world::DATA_VERSION)})
);
}
self.guest_attachments_into(g);
self.player_autosaves.enqueue(g, &self.world_root);
}
@@ -16894,6 +17087,7 @@ impl Game<'_> {
} else {
(Vec::new(), None)
};
self.custom_sky_frame([camera.x, camera.y, camera.z], &sky, (rain, thunder), title);
pr.lap("pr_celestial");
let (mut hand, hand_items) = if title || self.scoping() {
Default::default()
@@ -17569,6 +17763,7 @@ impl Game<'_> {
_ if self.screen == Screen::Dead => {
self.death_key(key)?;
}
_ if self.screen == Screen::Stats => self.stats_key(raw),
_ => {}
}
Ok(())
@@ -18211,13 +18406,7 @@ impl ApplicationHandler for Game<'_> {
return;
}
};
if fullscreen && window.is_maximized() {
window.set_maximized(false);
let monitor = window
.current_monitor()
.or_else(|| window.primary_monitor());
window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(monitor)));
}
horizon_client::window::settle_created_fullscreen(&window, fullscreen);
drop(window_step);
horizon_client::telemetry::note_display(&window);
match self.new_renderer(window.clone()) {
@@ -20223,6 +20412,7 @@ impl<'a> Game<'a> {
level_up_sound: Default::default(),
swing: Default::default(),
swings_started: 0,
predicted_swings: 0,
heights: Default::default(),
sway: Default::default(),
visible_hands: [(0, None), (0, None)],
@@ -20240,6 +20430,7 @@ impl<'a> Game<'a> {
dragging: false,
avatar: Default::default(),
flash: 0,
custom_sky: Default::default(),
rain_sound_time: 0,
lightning_seen: [0; 2],
sleeping: None,
@@ -20275,6 +20466,7 @@ impl<'a> Game<'a> {
map_frame_model: prepared.map_frame_model,
glow_map_frame_model: prepared.glow_map_frame_model,
armor_stands: Default::default(),
location_armor: Default::default(),
cushions: Vec::new(),
others: Vec::new(),
armor_stand_assets: prepared.armor_stand_assets,
@@ -20294,6 +20486,7 @@ impl<'a> Game<'a> {
entity_models: prepared.entity_models,
carts: Default::default(),
watched_vehicles: Vec::new(),
native_moves: Vec::new(),
jukebox_sounds: HashMap::new(),
bolts: Vec::new(),
maps: maps::Maps::default(),
@@ -20392,6 +20585,8 @@ impl<'a> Game<'a> {
native_lifecycle: Default::default(),
native_configs: Default::default(),
native_net: Default::default(),
native_player_fx: Default::default(),
native_packets: Default::default(),
native_mod_screen: None,
sky_darken_memo: Default::default(),
water_plane_memo: Default::default(),
@@ -20449,6 +20644,7 @@ impl<'a> Game<'a> {
block_reach: 4.5,
guest_use: None,
use_failed: false,
guest_inventory_resend: false,
lan_events: Vec::new(),
lan_songs: Vec::new(),
lan_cushion_breaks: Vec::new(),
@@ -20470,14 +20666,17 @@ impl<'a> Game<'a> {
lan_break_pos: None,
guest_packets: Vec::new(),
guest_cooldowns: Vec::new(),
native_resend_trees: Vec::new(),
guest_entity_events: Vec::new(),
guest_equipment_breaks: Vec::new(),
guest_player_sounds: Vec::new(),
lan_acting_name: None,
lan_acting_uuid: None,
native_click_cursor: None,
tnt_refused: None,
lan_acting_permission: None,
lan_acting_entity: None,
native_login_permission: None,
chat_capture: None,
admin_feedback: Vec::new(),
console_broadcast: None,
@@ -21895,7 +22094,7 @@ fn build_renderer(
// HDR with Smooth Gradients (`Graphics::wide_frame`): a 16-bit frame where HDR output is
// offered (`Renderer::new`).
wide_frame: bool,
shader_pack: bool,
shader_pack: shader_packs::PickedPack,
filtering: (i32, i32),
) -> Result<Renderer> {
let assets = &pack.render;
@@ -21934,7 +22133,8 @@ fn build_renderer(
api,
translucent_batching,
wide_frame,
shader_pack,
shader_pack.draws_flat,
shader_pack.linear,
))?;
renderer.hud.sprite_animations = atlas
.sprite_animations
@@ -21947,6 +22147,7 @@ fn build_renderer(
pack.item_renderer
.prepare_glint_atlas(renderer.device.limits().max_texture_dimension_2d, filtering)?;
renderer.set_lines_shader(atlas.lines_shader.as_deref());
renderer.set_custom_sky(&pack.custom_sky);
let cit_glints = pack.item_renderer.cit.as_ref().map(|c| &c.glint_textures);
renderer
.hud
@@ -22006,6 +22207,7 @@ fn loading_renderer(
// An 8-bit frame, which HDR output takes as well.
false,
false,
false,
))?;
if let Some(atlas) = atlas {
renderer.hud.sprite_animations = atlas
@@ -22426,13 +22628,7 @@ impl Loading {
return;
}
};
if fullscreen && window.is_maximized() {
window.set_maximized(false);
let monitor = window
.current_monitor()
.or_else(|| window.primary_monitor());
window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(monitor)));
}
horizon_client::window::settle_created_fullscreen(&window, fullscreen);
drop(window_step);
horizon_client::telemetry::note_display(&window);
// The renderer takes seconds to build and winit's window sits white
@@ -22623,7 +22819,7 @@ impl Loading {
self.settings.horizon.api,
self.settings.horizon.translucent_batching,
self.settings.horizon.wide_frame(),
shader_packs::picked_pack_draws_flat(&self.settings),
shader_packs::picked_pack_shape(&self.settings),
(
self.settings.file.int("textureFiltering"),
self.settings.file.int("maxAnisotropyBit"),
@@ -22907,11 +23103,17 @@ pub fn run_with() -> Result<()> {
{
return Ok(());
}
// The packets the server sends its players reach the mods that ask (native_packets.rs).
let _ = horizon_client::lan::conn::SERVER_PACKET.set(Game::native_server_packet);
let _ = horizon_client::lan::conn::ENTITY_DATA_TO.set(Game::native_entity_data_to);
let _ = horizon_client::health::HURT_SERVER.set(native_hooks::hurt_server);
let _ = horizon_client::health::DAMAGE_PRE.set(native_hooks::damage_pre);
let _ = horizon_client::health::DAMAGE_POST.set(native_hooks::damage_post);
let _ = horizon_client::block_contact::HOOK.set(native_hooks::block_contact);
let _ = horizon_client::health::KNOCKBACK.set(native_hooks::knockback);
let _ = horizon_client::lan::hub::PLAYER_MOVE.set(Game::native_player_move);
let _ = horizon_client::lan::hub::PLAYER_TELEPORT.set(Game::native_player_teleport);
let _ = horizon_client::block_contact::TRAMPLE.set(Game::native_trample);
// Before any worker starts: on Linux they go behind the server thread
// and the render thread.
horizon_threads::put_helpers_behind();
@@ -22939,7 +23141,7 @@ pub fn run_with() -> Result<()> {
{
options.spikes = Some(dedicated::SLOW_TICK_MS);
}
horizon_client::spans::enable(options.spikes.is_some());
tick_profile::want_spans(tick_profile::SPANS_SPIKES, options.spikes.is_some());
// A player who allows performance statistics also says what their slow frames spent their
// time in: this thread, which draws the frames, times its steps (wall time only).
if options.execution_role.is_client()
@@ -24213,3 +24415,6 @@ fn write_level_for_role(
level.write_without_player(dir)
}
}
#[cfg(test)]
mod vibration_tests;
crates/horizon-client/src/game/advancements.rs
+60 -41
View File
@@ -392,6 +392,15 @@ impl Game<'_> {
let tree = self.adv.tree.clone();
self.adv.progress = progress;
self.ui.registries.advancements = tree.list.iter().map(|a| a.id.clone()).collect();
// `PlayerAdvancements.checkForAutomaticTriggers`: an advancement with no
// criteria is never done (`AdvancementRequirements.test` is false), but
// its rewards are granted as the progress loads. Vanilla's `award(holder, "")` finds no `""`
// criterion to grant and so returns without a toast or an announcement;
// the reward grant is the whole effect, and it happens again on the next
// load because there is no criterion to record it.
for index in tree.automatic() {
self.grant_rewards(index);
}
}
pub(super) fn save_advancements(&self) {
if !self.adv.loaded || self.remote.is_some() || self.no_player_here() {
@@ -920,47 +929,7 @@ impl Game<'_> {
if let (Some(player), Some(name)) = (self.lan_acting_uuid, self.lan_acting_name.clone()) {
self.native_player_advancement_done(player, &name, &a.id);
}
// AdvancementRewards.grant
if a.rewards.experience > 0 {
let old_level = self.experience.level;
let points = self.xp_change(a.rewards.experience).map_or(0, |p| p.max(0));
let gained_level = self.experience.give(points);
if let Some(level) = gained_level {
self.play_level_up(1, level);
}
self.native_player_level_changed(old_level);
}
// ServerPlayer.awardRecipesByKey: the rewards that name a recipe.
let rewards: Vec<String> = a
.rewards
.recipes
.iter()
.filter(|r| world_stations!(self).recipe_index.contains(r))
.cloned()
.collect();
let (_, unlocked) = self
.level
.recipe_book
.add_recipes(&world_stations!(self).recipe_index, &rewards);
for table in &a.rewards.loot {
let items = world_items!(self).loot_table(table, false, None, &mut self.world.random);
for s in items {
// Inventory.add returns false when anything is left, and
// AdvancementRewards then drops that remainder with no
// pickup sound. A stack the inventory takes whole plays
// entity.item.pickup at the player's feet.
if let Some(rest) = self.give(s) {
if let Some(eye) = self.eye_position() {
self.spawn_item(rest, eye, [0.0; 3], 0);
}
} else {
self.advancement_pickup_sound();
}
}
}
if let Some(function) = &a.rewards.function {
self.run_advancement_reward_function(function);
}
let unlocked = self.grant_rewards(index);
if let Some(d) = &a.display {
// A network player's client shows its own toast.
if d.show_toast
@@ -1012,6 +981,56 @@ impl Game<'_> {
}
self.recipe_unlocked(&unlocked);
}
/// `AdvancementRewards.grant`: the experience, recipes, loot and function of
/// a finished advancement, and the recipes it unlocked for the
/// `recipe_unlocked` trigger, which the caller runs after its toast and
/// announcement. Returns those recipes.
fn grant_rewards(&mut self, index: usize) -> Vec<String> {
let tree = self.adv.tree.clone();
let a = &tree.list[index];
// AdvancementRewards.grant
if a.rewards.experience > 0 {
let old_level = self.experience.level;
let points = self.xp_change(a.rewards.experience).map_or(0, |p| p.max(0));
let gained_level = self.experience.give(points);
if let Some(level) = gained_level {
self.play_level_up(1, level);
}
self.native_player_level_changed(old_level);
}
// ServerPlayer.awardRecipesByKey: the rewards that name a recipe.
let rewards: Vec<String> = a
.rewards
.recipes
.iter()
.filter(|r| world_stations!(self).recipe_index.contains(r))
.cloned()
.collect();
let (_, unlocked) = self
.level
.recipe_book
.add_recipes(&world_stations!(self).recipe_index, &rewards);
for table in &a.rewards.loot {
let items = world_items!(self).loot_table(table, false, None, &mut self.world.random);
for s in items {
// Inventory.add returns false when anything is left, and
// AdvancementRewards then drops that remainder with no
// pickup sound. A stack the inventory takes whole plays
// entity.item.pickup at the player's feet.
if let Some(rest) = self.give(s) {
if let Some(eye) = self.eye_position() {
self.spawn_item(rest, eye, [0.0; 3], 0);
}
} else {
self.advancement_pickup_sound();
}
}
}
if let Some(function) = &a.rewards.function {
self.run_advancement_reward_function(function);
}
unlocked
}
/// `InventoryChangeTrigger`, checked when the inventory changes.
pub(super) fn check_inventory_trigger(&mut self) {
use std::hash::{Hash, Hasher};
crates/horizon-client/src/game/beehives.rs
+58 -1
View File
@@ -151,6 +151,13 @@ impl Game<'_> {
.block_entities
.put(key, BlockEntity::Beehive(hive));
if stored {
let state = self.world.block(at[0], at[1], at[2]);
self.post_block_game_event(
"minecraft:block_change",
at,
Some(Who::Mob(mob)),
Some(state),
);
let kind = self.mobs[i].kind.id.clone();
let block = self
.res
@@ -268,7 +275,9 @@ impl Game<'_> {
} else if let Some(rest) = self.give(bottle)
&& let Some(eye) = self.eye_position()
{
self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
// `player.drop(stack, false, PREDICTED)`: thrown from below
// the eyes along the view, with no thrower.
self.throw_from_eyes(rest, eye, false);
}
self.post_block_game_event("minecraft:fluid_pickup", pos, self.sculk_actor(), None);
}
@@ -368,3 +377,51 @@ impl Game<'_> {
}
}
}
#[cfg(test)]
mod honey_overflow_tests {
use super::*;
/// `BeehiveBlock.useItemOn`: a honey bottle that no longer fits is
/// `player.drop(stack, false, PREDICTED)`: from 0.3 below the eyes,
/// thrown along the view, with no thrower (#11377).
#[test]
#[ignore = "needs prepared resources (HORIZON_TEST_RESOURCES)"]
fn a_honey_bottle_that_does_not_fit_is_thrown_ahead() {
let mut game = super::super::native_machines::tests::server_game();
let registry = &game.pack.assets.registry;
let hive = registry.default_state("minecraft:beehive").unwrap();
let mut full = registry.state(hive).unwrap().clone();
full.properties.insert("honey_level".into(), "5".into());
let full = registry.id(&full).unwrap();
game.world.set(8, 64, 10, full).unwrap();
game.player = Some(
horizon_client::motion::PlayerMotion::new(game.motion, Vec3::new(8.5, 64.0, 8.5))
.unwrap(),
);
// Facing south (+z), towards the hive.
game.yaw = 0.0;
game.pitch = 0.0;
for slot in game.inventory.iter_mut() {
*slot = Some(ItemStack::new("minecraft:stone", 64));
}
game.selected = 0;
let bottles = ItemStack::new("minecraft:glass_bottle", 2);
game.inventory[0] = Some(bottles.clone());
game.dropped.clear();
assert!(game.use_beehive([8, 64, 10], Some(&bottles)).unwrap());
let eye = game.eye_position().unwrap();
let honey: Vec<_> = game
.dropped
.iter()
.filter(|e| &*e.stack.item == "minecraft:honey_bottle")
.collect();
assert_eq!(honey.len(), 1);
let e = honey[0];
assert!((e.position.y - (eye[1] - f64::from(0.3f32))).abs() < 1e-9);
assert!(e.velocity.z > 0.2, "thrown ahead: {:?}", e.velocity);
assert_eq!(e.thrower, None);
assert_eq!(e.pickup_delay, 40);
}
}
crates/horizon-client/src/game/boat_leads.rs
+63
View File
@@ -506,6 +506,69 @@ impl Game<'_> {
mod tests {
use super::*;
#[test]
#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
fn command_view_uses_live_and_pending_boat_leashes_not_raw_tags() {
use crate::game::{Audio, Options, Progress, Settings, commands::Target, load_resources};
let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
let settings = Settings::default();
let loaded = load_resources(
root.clone(),
None,
&root,
&settings,
std::time::Instant::now(),
false,
true,
&Progress::new(),
&mut |_, _| unreachable!(),
)
.unwrap();
let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
options.resources = root.clone();
options.execution_role = crate::game::execution_role::ExecutionRole::IntegratedServer;
let mut game = Game::new(
&loaded.resources,
loaded.pack,
loaded.gui.unwrap(),
options,
settings,
Audio::silent(&root),
None,
)
.unwrap();
game.build_registries();
let (id, uuid, actual_holder, unknown) =
(1, [326, 1, 0, 1], [326, 2, 0, 1], [111, 222, 333, 444]);
game.boats
.push(Boat::new(id, "oak".into(), Vec3::new(6.5, 100.0, 4.5), 0.0));
game.persist.uuids.insert(id, uuid);
game.level.player_uuid = Some([326, 3, 0, 1]);
let read = |game: &mut Game<'_>| game.entity_nbt(Target::Boat(id)).unwrap();
assert!(!game.persist.raw.contains_key(&id));
assert_eq!(
read(&mut game).get("UUID"),
Some(&Tag::IntArray(uuid.to_vec()))
);
assert!(read(&mut game).get("leash").is_none());
game.boats[0].leash = Some(Holder::Player);
game.boats[0].leash_player = Some(actual_holder);
let expected = Tag::compound([("UUID", Tag::IntArray(actual_holder.to_vec()))]);
assert_eq!(read(&mut game).get("leash"), Some(&expected));
assert_eq!(read(&mut game).get("leash"), Some(&expected));
let delayed = Tag::compound([("UUID", Tag::IntArray(unknown.to_vec()))]);
game.persist
.raw
.insert(id, Tag::compound([("leash", delayed.clone())]));
assert_eq!(read(&mut game).get("leash"), Some(&expected));
game.boats[0].leash = None;
game.boats[0].leash_player = None;
game.boats[0].leash_pending = Some(Pending::Uuid(unknown));
assert_eq!(read(&mut game).get("leash"), Some(&delayed));
game.boats[0].leash_pending = None;
assert!(read(&mut game).get("leash").is_none());
}
#[test]
fn a_boat_is_centred_half_its_height_up() {
let b = Boat::new(1, "oak".into(), Vec3::new(1.0, 64.0, 2.0), 0.0);
crates/horizon-client/src/game/bossbars.rs
+17
View File
@@ -26,6 +26,9 @@ pub(super) struct BossState {
loaded: bool,
/// What each viewer was last sent, so a change becomes one packet.
sent: HashMap<u128, HashMap<u128, Offer>>,
/// The bars server mods show single players (`native_boss_bar`): by
/// player UUID, each bar's id and bar, in the order they were added.
pub(super) native: HashMap<u128, Vec<(u128, horizon_client::mod_api::NativeBossBar)>>,
}
impl BossState {
@@ -551,6 +554,20 @@ impl Game<'_> {
scope: Scope::Global,
});
}
// Server mods' bars for this player alone (`native_boss_bar`).
for (id, bar) in self.bosses.native.get(&viewer.uuid).into_iter().flatten() {
out.push(Offer {
id: *id,
name: horizon_client::lan::data::component_nbt(&bar.name.component()),
progress: bar.progress,
color: bar.color,
overlay: bar.overlay,
darken: bar.darken,
music: bar.music,
fog: bar.fog,
scope: Scope::Global,
});
}
if viewer.here
&& let Some(progress) = self.dragon_boss_progress(viewer.at, viewer.alive)
{
crates/horizon-client/src/game/brush.rs
+35 -5
View File
@@ -40,19 +40,49 @@ pub(super) type Brushing = HashMap<[i32; 3], BrushState>;
impl Game<'_> {
/// `BrushItem.onUseTick` for a brush used `ticks` ticks so far, the
/// hand of `slot` acting.
pub(super) fn tick_brush(&mut self, slot: usize, ticks: u32) {
// No block under the crosshair: releaseUsingItem.
pub(super) fn tick_brush(
&mut self,
stack: &horizon_client::items::ItemStack,
slot: usize,
ticks: u32,
) {
// No block under the crosshair: vanilla calls releaseUsingItem, which
// stops the use and causes the interaction vibration.
let Some(hit) = self.pick() else {
self.using = None;
self.stop_using_item(stack);
return;
};
// `BrushItem.onUseTick` aims with `getHitResultOnViewVector` out to the
// block interaction range, for mobs too: a mob between the player and
// the block is nearer, so the hit is not a block and the use releases
// the same way. A guest acts on its client's targeted block, whose view
// we cannot trace here, so only the local aim runs the entity test.
if self.forced_hit.is_none()
&& let Some((eye, _)) = self.aim()
&& let Some((_, mob, _)) = self.mob_hit_within(self.block_reach)
{
let block = (
hit.point[0] - eye[0],
hit.point[1] - eye[1],
hit.point[2] - eye[2],
);
if mob <= (block.0 * block.0 + block.1 * block.1 + block.2 * block.2).sqrt() {
self.stop_using_item(stack);
return;
}
}
let elapsed = ticks + 1;
// The last tick before the backswing.
if elapsed % 10 == 5 {
self.brush_stroke(&hit, slot);
}
// The use ends after 200 ticks; the held button starts it again.
self.using = (elapsed < USE_DURATION).then_some((slot, elapsed));
// The use ends after USE_DURATION; stopUsingItem causes the vibration
// (vanilla's tickUsingItem), the held button starts it again.
if elapsed < USE_DURATION {
self.using = Some((slot, elapsed));
} else {
self.stop_using_item(stack);
}
}
/// One stroke on the block aimed at: dust (this window only), the brush
crates/horizon-client/src/game/building_players.rs
+1
View File
@@ -252,6 +252,7 @@ mod tests {
latency: Arc::new(AtomicI32::new(0)),
address: "127.0.0.1:25565".parse().unwrap(),
expected: false,
configured: Default::default(),
},
2,
[20.5, 64.0, 0.5],
crates/horizon-client/src/game/cartography.rs
+70
View File
@@ -257,6 +257,76 @@ impl MapData {
#[cfg(test)]
mod tests {
#[test]
#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
fn crafting_map_takes_use_real_saved_maps() {
use crate::game::{Audio, Options, Settings, load_resources};
use horizon_client::menu::{Env, Input, Kind, Menu};
let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
let settings = Settings::default();
let loaded = load_resources(
root.clone(),
None,
&root,
&settings,
std::time::Instant::now(),
false,
true,
&crate::game::Progress::new(),
&mut |_, _| unreachable!(),
)
.unwrap();
let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
options.resources = root.clone();
options.execution_role = crate::game::execution_role::ExecutionRole::IntegratedServer;
let mut game = Game::new(
&loaded.resources,
loaded.pack,
loaded.gui.unwrap(),
options,
settings,
Audio::silent(&root),
None,
)
.unwrap();
game.build_registries();
for mode in [Input::Swap, Input::Pickup, Input::QuickMove] {
let source = game.new_map_id(MapData::fresh(4.5, 4.5, 0, "minecraft:overworld"));
let mut input = ItemStack::new("minecraft:filled_map", 1);
input.data_mut().map_id = Some(source);
let maps = game.level_maps([&input]);
let env = Env {
maps: Some(&maps),
..game.menu_env()
};
let mut menu = Menu::new(Kind::Crafting);
for i in [1, 2, 3, 4, 6, 7, 8, 9] {
menu.set_slot(&env, i, Some(ItemStack::new("minecraft:paper", 1)));
}
menu.set_slot(&env, 5, Some(input));
let preview = menu.slot(0).expect("real scaling recipe admitted");
assert_eq!(preview.data().and_then(|d| d.map_id), Some(source));
assert_eq!(preview.data().and_then(|d| d.map_post_processing), Some(1));
menu.click(&env, 0, if mode == Input::Swap { 2 } else { 0 }, mode)
.unwrap();
let output = match mode {
Input::Swap => menu.player_item(2),
Input::Pickup => menu.carried.as_ref(),
_ => menu.player_item(8),
}
.expect("crafted map remains present");
assert_eq!(output.count, 1);
assert_eq!(output.data().and_then(|d| d.map_id), Some(source + 1));
assert_eq!(output.data().and_then(|d| d.map_post_processing), None);
assert!((1..10).all(|i| menu.slot(i).is_none()));
game.register_made_maps(maps);
let original = game.map(source).unwrap();
assert_eq!((original.scale, original.center), (0, [0, 0]));
let derived = game.map(source + 1).unwrap();
assert_eq!((derived.scale, derived.center), (1, [64, 64]));
}
}
use super::*;
use crate::game::maps::{Decoration, Key};
crates/horizon-client/src/game/chat.rs
+67 -11
View File
@@ -720,10 +720,13 @@ impl Game<'_> {
.as_ref()
.filter(|d| !command || d.command)
.map(|d| d.text.clone());
self.open_chat(draft.as_deref().unwrap_or(prefix));
self.open_chat(draft.as_deref().unwrap_or(prefix), draft.is_some());
self.ui.chat_draft_shown = draft.is_some() && self.ui.chat_screen.is_some();
}
pub(super) fn open_chat(&mut self, initial: &str) {
/// Open the chat box on `initial`; `is_draft` when that text is the saved
/// draft (`ChatComponent.createScreen`), which draws grey italic until it
/// is edited.
pub(super) fn open_chat(&mut self, initial: &str, is_draft: bool) {
if self.player.is_none() {
return;
}
@@ -743,6 +746,7 @@ impl Game<'_> {
&m,
&c,
initial,
is_draft,
self.ui.chat.recent.len(),
b.width as i32,
b.height as i32,
@@ -757,6 +761,36 @@ impl Game<'_> {
self.right = false;
self.capture(false);
}
/// The open chat box's text and its cursor, counted in characters; `None`
/// while the chat screen isn't open. API @API:chat_input@.
#[allow(dead_code)]
pub(super) fn native_chat_input(&self) -> Option<(String, usize)> {
let screen = self.ui.chat_screen.as_ref()?;
Some((screen.input.value.clone(), screen.input.cursor))
}
/// Replaces the open chat box's text and puts the cursor at `cursor`
/// (characters, clamped to the text), as an edit: completions refresh as
/// they do for typing. What typing can't put in the box isn't put there
/// either (`chat_box_text`), and the 256-character limit holds. An error
/// while the chat screen isn't open. API @API:chat_input@.
#[allow(dead_code)]
pub(super) fn native_set_chat_input(
&mut self,
text: &str,
cursor: usize,
) -> Result<(), String> {
let m = Measure(&self.gui.atlas.font);
let c = Commands {
dispatcher: chat_tree(&self.remote),
registries: &self.ui.registries,
};
let Some(screen) = self.ui.chat_screen.as_mut() else {
return Err("the chat isn't open".into());
};
screen.suggest_command(&m, &c, &chat_box_text(text));
screen.input.move_cursor_to(&m, cursor, false);
Ok(())
}
pub(super) fn close_chat(&mut self, reason: ChatExit) {
// InBedChatScreen.onClose: leaving the screen means getting up; the
// screen goes once the player has woken (`tick_in_bed_chat`).
@@ -836,11 +870,13 @@ impl Game<'_> {
.map_or_else(String::new, |s| s.value().to_owned());
self.close_chat(ChatExit::Interrupted);
if !text.is_empty() {
self.open_chat(&text);
// InBedChatScreen.onPlayerWokeUp: a new ChatScreen with
// the typed text, not a draft.
self.open_chat(&text, false);
}
}
} else if self.sleeping.is_some() && self.screen == Screen::Playing {
self.open_chat("");
self.open_chat("", false);
self.ui.in_bed_chat = self.screen == Screen::Chat;
}
}
@@ -1627,23 +1663,23 @@ impl Game<'_> {
pub(super) fn toggle_hide_gui(&mut self) {
self.ui.hide_gui = !self.ui.hide_gui;
}
/// F2: ScreenShot.grab into `screenshots/` with vanilla's file name.
pub(super) fn take_screenshot(&mut self) {
/// F2: ScreenShot.grab into `screenshots/` with vanilla's file name. The
/// file it will write, `None` without a window to draw.
pub(super) fn take_screenshot(&mut self) -> Option<std::path::PathBuf> {
let dir = horizon_client::logging::player_dir().join("screenshots");
if std::fs::create_dir_all(&dir).is_err() {
return;
return None;
}
let name = screenshot_name(&dir);
let Some(renderer) = self.renderer.as_mut() else {
return;
};
let renderer = self.renderer.as_mut()?;
let path = dir.join(name);
renderer.screenshot = Some(horizon_client::gfx::ScreenshotRequest {
path: path.clone(),
size: None,
scaled: true,
});
self.ui.screenshot_message = Some(path);
self.ui.screenshot_message = Some(path.clone());
Some(path)
}
/// `Minecraft.handleGlobalKeyPress`'s screenshot branch: the
/// `key.screenshot` mapping (F2 by default) takes the picture before a
@@ -1699,6 +1735,14 @@ impl Game<'_> {
}
}
/// `yyyy-MM-dd_HH.mm.ss[_n].png` (Util.getFilenameFormattedDateTime, in local time).
/// What a mod may write into the chat box: the characters `ChatScreen`'s
/// typing lets in (`StringUtil.isAllowedChatCharacter`: no control
/// characters, no DEL, no section sign).
fn chat_box_text(text: &str) -> String {
text.chars()
.filter(|&ch| ch >= ' ' && ch != '\u{7f}' && ch != '§')
.collect()
}
pub fn screenshot_name(dir: &std::path::Path) -> String {
// Util.getFilenameFormattedDateTime: the local date and time.
let base = chrono::Local::now().format("%Y-%m-%d_%H.%M.%S").to_string();
@@ -1730,6 +1774,17 @@ const LINK_COPY: usize = 1;
mod tests {
use super::*;
/// A mod's text reaches the chat box as typing would leave it: emoji and
/// accents stay, control characters, DEL and the section sign go.
#[test]
fn a_mods_chat_text_keeps_what_typing_allows() {
assert_eq!(
super::chat_box_text("hi :smile: → 😀 é"),
"hi :smile: → 😀 é"
);
assert_eq!(super::chat_box_text("a\nb\tc\u{7f}d§6e"), "abcd6e");
}
/// `ChatScreen.shouldDiscardDraft`.
#[test]
fn draft_discard_follows_the_exit_reason() {
@@ -2057,6 +2112,7 @@ mod tests {
&m,
&c,
"",
false,
0,
width as i32,
height as i32,
crates/horizon-client/src/game/command_harness.rs
+247
View File
@@ -599,6 +599,47 @@ impl Game<'_> {
}
// Java produced the fixture file before this world was opened; map_state loads it.
"crafter_max_map_fixture" => {}
"boat_interact" => {
let uuid = u128::from_str_radix(
&op["uuid"]
.as_str()
.ok_or("boat click: missing UUID")?
.replace('-', ""),
16,
)?;
self.in_owner_level(|g| -> Result<()> {
let id = g
.boat_by_uuid(horizon_client::lan::playerdata::uuid_ints(uuid))
.ok_or("boat click: missing live boat")?;
let owner = g.serving.as_ref().ok_or("boat click: no server")?.owner;
let conn = g
.lan
.as_ref()
.and_then(|h| {
h.hub
.guests
.iter()
.find(|p| p.uuid == owner && p.placed)
.map(|p| p.conn)
})
.ok_or("boat click: owner not connected")?;
let mut host = g.lan.take().ok_or("boat click: no hub")?;
g.lan_guest_packet(
&mut host,
conn,
horizon_protocol::packets::play::Serverbound::Interact(
horizon_protocol::packets::play::Interact {
id: id as i32,
hand: 0,
location: [0.0; 3],
secondary: false,
},
),
);
g.lan = Some(host);
Ok(())
})?;
}
"use_item" => {
let owner = self
.serving
@@ -685,6 +726,100 @@ impl Game<'_> {
);
out.push('\n');
}
"craft_menu_click" | "craft_menu_state" | "craft_menu_close" => {
let owner = self.serving.as_ref().ok_or("no server")?.owner;
let state = self.in_owner_level(|g| -> Result<Value> {
let conn = g.lan.as_ref().and_then(|h| h.hub.guests.iter()
.find(|p| p.uuid == owner && p.placed).map(|p| p.conn))
.ok_or("craft fixture: no connected owner")?;
let mut host = g.lan.take().ok_or("no hub")?;
let result = (|| -> Result<Value> {
let (window, revision, _, _) = host.play.get(&conn)
.and_then(|p| p.crafting.table.as_ref())
.ok_or("craft fixture: crafting menu not open")?;
let (window, revision) = (*window, *revision);
if op["op"] == "craft_menu_click" {
// Revision last sent by the real table-content sync, never a fixed 0.
eprintln!("craft fixture click: window={window}, revision={revision}");
g.lan_guest_packet(&mut host, conn,
horizon_protocol::packets::play::Serverbound::ContainerClick(
horizon_protocol::packets::play::ContainerClick {
container: window, state: revision,
slot: op["slot"].as_i64().ok_or("click slot")? as i16,
button: op["button"].as_i64().unwrap_or(0) as i8,
input: op["input"].as_i64().unwrap_or(0) as i32,
changed: Vec::new(), carried: None,
}));
return Ok(Value::Null);
}
if op["op"] == "craft_menu_close" {
g.lan_guest_packet(&mut host, conn,
horizon_protocol::packets::play::Serverbound::ContainerClose(
horizon_protocol::packets::play::ContainerClose { container: window }));
return Ok(Value::Null);
}
let (_, _, menu, _) = host.play.get(&conn)
.and_then(|p| p.crafting.table.as_ref()).unwrap();
if menu.kind() != horizon_client::menu::Kind::Crafting {
return Err("craft fixture: wrong menu kind".into());
}
let guest = host.hub.guest(conn).ok_or("no guest")?;
let stack = |s: Option<&horizon_client::items::ItemStack>| {
s.map(|s| json!([&*s.item, s.count,
s.data().and_then(|d| d.map_id),
s.data().and_then(|d| d.map_post_processing)]))
};
// Table's ten slots plus the owner's live inventory in menu order.
let slots: Vec<_> = (0..10).map(|i| stack(menu.slot(i)))
.chain((9..36).chain(0..9).map(|i| stack(guest.inventory[i].as_ref())))
.collect();
Ok(json!({"window": window, "kind": "minecraft:crafting",
"slots": slots, "carried": stack(guest.carried.as_ref()).unwrap_or_else(|| json!([]))}))
})();
g.lan = Some(host);
result
})?;
if op["op"] == "craft_menu_state" {
let record = json!({"cmd": format!("#craft_menu {}", op["label"].as_str().unwrap_or("")),
"state": state, "messages": [], "results": []});
out.push_str(&record.to_string());
out.push('\n');
}
}
"map_files" => {
let state = self.harness_owner(|g| {
use horizon_world::nbt::Tag;
g.save_maps();
let directory = g.world_root.join("data/minecraft/maps");
let maps: Vec<_> = op["ids"].as_array().ok_or("map IDs")?.iter().map(|id| {
let path = directory.join(format!("{}.dat", id.as_i64().unwrap()));
horizon_client::save::read_dat(&path).map(|root| {
let data = root.get("data").unwrap_or(&root);
let number = |key| match data.get(key) {
Some(Tag::Int(v)) => *v, Some(Tag::Byte(v)) => i32::from(*v), _ => 0,
};
let colors = match data.get("colors") {
Some(Tag::ByteArray(bytes)) => Some(bytes.len()), _ => None,
};
json!({"scale": number("scale"), "locked": number("locked") != 0,
"center": [number("xCenter"), number("zCenter")],
"dimension": horizon_client::save::text(data.get("dimension")),
"byte_array_length": colors})
})
}).collect();
let last = horizon_client::save::read_dat(&directory.join("last_id.dat"))
.and_then(|tag| match tag.get("data").and_then(|d| d.get("map")) {
Some(Tag::Int(v)) => Some(*v), _ => None,
});
Ok(json!({"maps": maps, "last_id": last}))
})?;
out.push_str(
&json!({"cmd": "#map_files", "state": state,
"messages": [], "results": []})
.to_string(),
);
out.push('\n');
}
"map_state" => {
let id = op["id"].as_i64().ok_or("command harness: map id")? as i32;
let value = self.harness_owner(|g| {
@@ -718,6 +853,118 @@ impl Game<'_> {
out.push_str(&record.to_string());
out.push('\n');
}
"merchant_saved_stats" => {
let (state, raw) = self.harness_owner(|g| {
g.load_stats();
if !g.stats.loaded { return Err("merchant stats not loaded".into()); }
g.save_stats();
let uuid = g.level.player_uuid.ok_or("merchant stats UUID")?;
let path = super::stats::player_json(&g.world_root, "stats", uuid);
let raw = std::fs::read_to_string(path)?;
let saved: Value = serde_json::from_str(&raw)?;
let value = |ty: &str, key: &str| saved["stats"][ty][key].as_i64().unwrap_or(0);
Ok((json!({"uuid":uuid,"books":value("minecraft:crafted","minecraft:bookshelf"),
"glass":value("minecraft:crafted","minecraft:glass"),
"trades":value("minecraft:custom","minecraft:traded_with_villager")}), raw))
})?;
let label = op["label"].as_str().unwrap_or("");
std::fs::write(
output.with_file_name(format!("native-merchant-stats-{label}.json")),
raw,
)?;
out.push_str(
&json!({"cmd":format!("#merchant_saved_stats {label}"),
"messages":[],"results":[],"state":state})
.to_string(),
);
out.push('\n');
}
"merchant_action" | "merchant_state" => {
let observe = op["op"] == "merchant_state";
let state = self.in_owner_level(|g| -> Result<Value> {
let mut host = g.lan.take().ok_or("merchant oracle: no hub")?;
let result = (|| -> Result<Value> {
let owner = g
.serving
.as_ref()
.ok_or("merchant oracle: no server")?
.owner;
let conn = host
.hub
.guests
.iter()
.find(|p| p.uuid == owner && p.placed)
.ok_or("merchant oracle: owner not connected")?
.conn;
if observe {
return Ok(g
.harness_merchant(&host, conn)
.ok_or("merchant oracle: no live menu")?
.2);
}
use horizon_protocol::packets::play::{self, Serverbound as S};
let packet = match op["action"].as_str().unwrap_or("") {
"open" => {
let uuid = u128::from_str_radix(
op["uuid"]
.as_str()
.ok_or("merchant oracle: UUID")?
.replace('-', "")
.as_str(),
16,
)?;
let Some(super::commands::Target::Mob(id)) =
g.target_by_uuid(uuid)
else {
return Err("merchant oracle: missing live mob".into());
};
S::Interact(play::Interact {
id: id as i32,
hand: 0,
location: [0.0; 3],
secondary: false,
})
}
"select" => S::SelectTrade(play::SelectTrade {
item: op["index"].as_i64().unwrap_or(0) as i32,
}),
"click" => {
let (container, state, _) = g
.harness_merchant(&host, conn)
.ok_or("merchant oracle: no menu")?;
S::ContainerClick(play::ContainerClick {
container,
state,
slot: op["slot"].as_i64().ok_or("merchant oracle: slot")?
as i16,
button: op["button"].as_i64().unwrap_or(0) as i8,
input: op["input"].as_i64().unwrap_or(0) as i32,
changed: Vec::new(),
carried: None,
})
}
"close" => S::ContainerClose(play::ContainerClose {
container: g
.harness_merchant(&host, conn)
.ok_or("merchant oracle: no menu")?
.0,
}),
_ => return Err("merchant oracle: unknown action".into()),
};
eprintln!("merchant action receipt: action={} owner={owner:032x} conn={conn} menu={:?} clock={}",
op["action"], g.harness_merchant(&host, conn).map(|(w, r, _)| (w, r)), g.world.game_time);
g.lan_guest_packet(&mut host, conn, packet);
Ok(Value::Null)
})();
g.lan = Some(host);
result
})?;
if observe {
out.push_str(&json!({"cmd":format!("#merchant_state {}",op["label"].as_str().unwrap_or("")),
"messages":[],"results":[],"state":state}).to_string());
out.push('\n');
}
}
"menu_state" => {
let (_, own_slots, _) = self.harness_owner_menu()?;
let record = json!({"cmd": format!("#menu_state {}", op["label"].as_str().unwrap_or("")),
crates/horizon-client/src/game/commands.rs
+52 -5
View File
@@ -906,7 +906,7 @@ impl Game<'_> {
/// the entity lists (a kind added there joins `@e` once it names its
/// `Target`), then the kinds that are not on the walk. An
/// unsorted selector lists them in that order.
fn level_candidates(&self) -> Vec<Target> {
pub(in crate::game) fn level_candidates(&self) -> Vec<Target> {
use super::entity::{Entity as _, entity_lists_of, for_each_entity};
let mut candidates = Vec::new();
for_each_entity!(entity_lists_of!(self), entity => {
@@ -1559,6 +1559,7 @@ impl Game<'_> {
// there at once: the arrival they were waiting for elsewhere
// in it (whose chunks lose their tickets) is abandoned.
if let Some(conn) = self.lan_acting {
horizon_client::lan::hub::teleport_cause(Some("command"));
self.server_trips.retain(|trip| !trip.is(conn));
}
let from = self
@@ -1816,6 +1817,7 @@ impl Game<'_> {
at: pos,
rotation,
vehicle: None,
cause: Some("command"),
});
Ok(true)
}
@@ -4009,6 +4011,7 @@ impl Game<'_> {
));
Ok(count as i32)
}
/// `SayCommand.register`: resolve the source name and broadcast unsigned announcements.
fn cmd_say(&mut self, id: &str, ctx: &Context) -> R<i32> {
let raw = match ctx.get(if id == "me" { "action" } else { "message" }) {
Some(Arg::Str(s)) => s.clone(),
@@ -4016,13 +4019,42 @@ impl Game<'_> {
};
let message = self.expand_selectors(&raw);
// CommandSourceStack.getDisplayName: the executing entity's name.
let name = match self.command_source.map(|s| s.entity) {
Some(Some(t)) => self.target_name(t),
Some(None) => Text::literal("Server"),
let name = match self.command_source {
Some(source) => match source.entity {
Some(target) => self.target_name(target),
None => source
.block
.and_then(|pos| match self.world.block_entities.get(&pos) {
Some(horizon_client::containers::BlockEntity::CommandBlock(block)) => {
Some(block.name())
}
_ => None,
})
.or_else(|| {
source.cart.and_then(|id| {
self.carts
.iter()
.find(|cart| cart.id == id)
.map(|cart| cart.command.name())
})
})
.unwrap_or_else(|| Text::literal("Server")),
},
None => self.player_display_name(),
};
let line = match id {
"say" => Text::translate("chat.type.announcement", &[name, message]),
"say" => {
// SayCommand broadcasts independently of the command source's feedback.
if let Some(host) = &self.lan {
use horizon_client::lan::data::component_nbt;
host.hub.broadcast_source_chat(
"say_command",
component_nbt(&name.component()),
component_nbt(&message.component()),
);
}
Text::translate("chat.type.announcement", &[name, message])
}
"me" => Text::translate("chat.type.emote", &[name, message]),
_ => {
let _ = self.entities(ctx, "targets", true)?;
@@ -4042,6 +4074,21 @@ impl Game<'_> {
.italic()
}
};
if id == "say" {
if self.lan.is_some() && self.options.dedicated.is_some() {
self.lan_log_event(horizon_client::lan::hub::HostEvent::Chat {
line: line.plain(),
secure: false,
});
}
// SayCommand sends no feedback: the broadcast above already reached
// the guest whose command is being captured.
if self.lan.is_some() && self.chat_capture.is_some() {
return Ok(1);
}
self.player_message(line);
return Ok(1);
}
if let Some(capture) = self.chat_capture.as_mut() {
capture.push(line.clone());
}
crates/horizon-client/src/game/commands/data.rs
+8 -3
View File
@@ -136,8 +136,9 @@ impl Game<'_> {
}
Target::Boat(id) => {
let uuid = self.uuid_for(id);
let b = self.boats.iter().find(|b| b.id == id)?;
entity_nbt::boat_to_nbt(
let i = self.boats.iter().position(|b| b.id == id)?;
let b = &self.boats[i];
let mut tag = entity_nbt::boat_to_nbt(
&b.entity_type(),
b.position,
b.velocity,
@@ -145,7 +146,10 @@ impl Game<'_> {
uuid,
self.persist.raw.get(&id),
b.chest.then_some(&b.items[..]),
)
);
// AbstractBoat.addAdditionalSaveData: the live or pending leash.
self.write_boat_leash(&mut tag, i);
tag
}
Target::Cart(id) => {
let uuid = self.uuid_for(id);
@@ -313,6 +317,7 @@ impl Game<'_> {
return Err(err("commands.data.entity.invalid", &[]));
}
Target::Mob(id) => {
Self::normalize_loaded_mob_tags(&mut tag);
let uuid = self.uuid_for(id);
let kind = self
.mobs
crates/horizon-client/src/game/commands/effects.rs
+11 -2
View File
@@ -65,8 +65,9 @@ impl Game<'_> {
for t in self.living_targets(ctx)? {
let changed = match t {
Target::Player | Target::Guest(_) => {
let mut instance = EffectInstance::new(effect.id, duration, amplifier);
instance.visible = particles;
// `new MobEffectInstance(effect, duration, amplifier, false, particles)`.
let instance = EffectInstance::new(effect.id, duration, amplifier)
.with_flags(false, particles);
self.for_player(t, |g| g.add_player_effect(instance))
.unwrap_or(false)
}
@@ -77,6 +78,14 @@ impl Game<'_> {
// `new MobEffectInstance(effect, duration, amplifier, false, particles)`.
let changed =
m.add_effect_with(name, duration, amplifier, false, particles);
// MobEffect.onEffectAdded: an omen's sound, at the mob's feet.
if new
&& changed
&& let Some(sound) = super::super::potions::sound_on_added(name)
{
let at = [m.position.x, m.position.y, m.position.z];
self.audio.play(sound, Some(at), 1.0, 1.0);
}
self.mod_effect_added(name, Some(id as i32), amplifier, new);
changed
}
crates/horizon-client/src/game/commands/execute.rs
+1 -1
View File
@@ -1156,7 +1156,7 @@ impl Game<'_> {
Ok((true, count))
}
/// The biome name at a block position.
fn biome_name_at_block(&self, p: [i32; 3]) -> Option<String> {
pub(in crate::game) fn biome_name_at_block(&self, p: [i32; 3]) -> Option<String> {
let chunk = self.world.chunks.get(&(p[0] >> 4, p[2] >> 4))?;
// The world's table (`world_biomes!`): a packed biome's id is past
// the built-in list, and `Biomes::get` would clamp it to the last
crates/horizon-client/src/game/commands/world_cmds.rs
+56 -42
View File
@@ -195,9 +195,37 @@ impl Game<'_> {
_ => by.and_then(|t| self.target_position(t)),
};
// Destruction can remove the target before its success message is built.
let discarded_name = matches!(target, Target::Item(_) | Target::Boat(_) | Target::Cart(_))
let item_name = matches!(target, Target::Item(_) | Target::Boat(_) | Target::Cart(_))
.then(|| self.target_name(target));
let hurt = match target {
let hurt = self.damage_target(target, amount, &ty, cause, by, from);
if !hurt {
return Err(err("commands.damage.invulnerable", &[]));
}
let name = item_name.unwrap_or_else(|| self.target_name(target));
self.feedback(Text::translate(
"commands.damage.success",
&[
Text::literal(horizon_client::snbt::java_float(amount)),
name,
],
));
Ok(1)
}
/// `DamageCommand.damage`'s hurt: `target` takes `amount` of `ty` (`minecraft:mob_attack`)
/// from the causing entity `cause` and the direct one `by` (the causing one is either when
/// the other is none), from `from` (the knockback's direction): whether it was hurt. Also
/// `native_hurt_entity`'s.
pub(in crate::game) fn damage_target(
&mut self,
target: Target,
amount: f32,
ty: &str,
cause: Option<Target>,
by: Option<Target>,
from: Option<[f64; 3]>,
) -> bool {
match target {
// The causing mob is the one the hit is credited to and thorns
// answer; the source position gives the knockback its direction.
Target::Player | Target::Guest(_) => {
@@ -217,9 +245,9 @@ impl Game<'_> {
return false;
}
if let Some(name) = named {
g.note_direct_entity(&ty, name);
g.note_direct_entity(ty, name);
}
g.hurt_player_from(amount, from, &ty, attacker)
g.hurt_player_from(amount, from, ty, attacker)
})
.unwrap_or(false)
}
@@ -234,7 +262,7 @@ impl Game<'_> {
_ => None,
};
let damage = Damage {
kind: Self::damage_kind(&ty),
kind: Self::damage_kind(ty),
attacker,
from,
attacker_species,
@@ -264,15 +292,15 @@ impl Game<'_> {
self.command_damage_mob(id, amount, damage)
}
}
Target::Item(id) => self.command_damage_item(id, amount, &ty, cause.or(by)),
Target::Item(id) => self.command_damage_item(id, amount, ty, cause.or(by)),
Target::Boat(_) | Target::Cart(_) => {
self.command_damage_vehicle(target, amount, &ty, cause.or(by))
self.command_damage_vehicle(target, amount, ty, cause.or(by))
}
Target::Dragon(id) => self.command_damage_dragon(
id,
amount,
&ty,
Self::damage_kind(&ty),
ty,
Self::damage_kind(ty),
(
by,
cause.or(by),
@@ -280,22 +308,10 @@ impl Game<'_> {
),
),
Target::Crystal(id) => {
self.command_damage_crystal(id, &ty, Self::damage_kind(&ty), cause.or(by))
self.command_damage_crystal(id, ty, Self::damage_kind(ty), cause.or(by))
}
_ => false,
};
if !hurt {
return Err(err("commands.damage.invulnerable", &[]));
}
let name = discarded_name.unwrap_or_else(|| self.target_name(target));
self.feedback(Text::translate(
"commands.damage.success",
&[
Text::literal(horizon_client::snbt::java_float(amount)),
name,
],
));
Ok(1)
}
/// `VehicleEntity.hurtServer`: report acceptance even when the vehicle survives.
@@ -1509,6 +1525,20 @@ impl Game<'_> {
return Ok(0);
};
let vehicle_name = self.target_name(vehicle);
self.ride_mount(target, vehicle)?;
self.feedback(Text::translate(
"commands.ride.mount.success",
&[name, vehicle_name],
));
Ok(1)
}
/// `RideCommand.mount` once the targets are known: `target` (the player
/// in place or a mob) rides `vehicle`, as `startRiding(vehicle, true,
/// true)` forces it (also for `native_mount`).
pub(in crate::game) fn ride_mount(&mut self, target: Target, vehicle: Target) -> R<()> {
let name = self.target_name(target);
let vehicle_name = self.target_name(vehicle);
if let Some(current) = self.ride_vehicle(target) {
let current = self.target_name(current);
return Err(err(
@@ -1574,11 +1604,7 @@ impl Game<'_> {
// sendEventAndTriggers: START_RIDING_TRIGGER.
self.start_riding(id);
}
self.feedback(Text::translate(
"commands.ride.mount.success",
&[name, vehicle_name],
));
return Ok(1);
return Ok(());
}
Target::Cart(id) => {
if target != Target::Player
@@ -1588,11 +1614,7 @@ impl Game<'_> {
return Err(generic());
}
self.start_riding(id);
self.feedback(Text::translate(
"commands.ride.mount.success",
&[name, vehicle_name],
));
return Ok(1);
return Ok(());
}
_ => {}
}
@@ -1608,11 +1630,7 @@ impl Game<'_> {
if !self.try_mount_mob(rider, mob_id) {
return Err(generic());
}
self.feedback(Text::translate(
"commands.ride.mount.success",
&[name, vehicle_name],
));
return Ok(1);
return Ok(());
}
if !self.native_may_board(mob_id) {
return Err(generic());
@@ -1625,11 +1643,7 @@ impl Game<'_> {
self.mount.jump_ticks = 0;
self.mount.jump_scale = 0.0;
self.start_riding(mob_id);
self.feedback(Text::translate(
"commands.ride.mount.success",
&[name, vehicle_name],
));
Ok(1)
Ok(())
}
/// Entity.getVehicle: the player's mount, or a mob's.
crates/horizon-client/src/game/consume.rs
+3
View File
@@ -386,6 +386,9 @@ impl TeleportConsumeWorld for Teleporter<'_, '_> {
let y = to[1].clamp(f64::from(shape.min_y), f64::from(high));
*target = Vec3::new(to[0], y, to[2]);
}
if !cancel {
horizon_client::lan::hub::teleport_cause(Some("chorus_fruit"));
}
Ok(!cancel)
}
fn random_teleport(&mut self, target: Vec3) -> Result<bool, Infallible> {
crates/horizon-client/src/game/creatures.rs
+291 -8
View File
@@ -17,7 +17,7 @@ use horizon_client::{
collisions::SceneCollisions,
crafting::Recipes,
graphics::EntityCullingMode,
health::{HurtSource, Hurting, Knock, knockback_canceled},
health::{HealthEvent, HurtSource, Hurting, Knock, knockback_canceled},
items::ItemStack,
mesher::Vertex,
mobs::{
@@ -108,6 +108,9 @@ pub(super) struct Creatures {
/// The snapshot's buffer between ticks, empty: ~400 bytes a mob, so
/// thousands of mobs would allocate and free megabytes every tick.
seen_buf: Vec<Seen>,
/// The targets the mobs had before their ticks, kept between ticks
/// (empty) as `seen_buf` is: `native_living_change_target` hears a change.
target_buf: Vec<Option<Who>>,
/// The mobs whose own tick ran in the last `tick_creature_entities`:
/// `ServerLevel.tick` ticks only the entities in entity-ticking range, so
/// what the passes after the loop do for a mob's `aiStep`, goals or brain
@@ -124,6 +127,17 @@ pub(super) struct Creatures {
/// Particles from a guest's turn, waiting for it to end.
pub lan_particles: Vec<super::lan_particles::QueuedParticle>,
}
/// Whether `p`'s next step goes from inside the world border (`bounds`: [minX, minZ, maxX,
/// maxZ]) to outside it, as `clip_including_border` would stop it.
fn border_crossing(p: &Projectile, bounds: Option<[f64; 4]>) -> bool {
let Some([min_x, min_z, max_x, max_z]) = bounds else {
return false;
};
let within = |x: f64, z: f64| x >= min_x && x < max_x && z >= min_z && z < max_z;
let (at, v) = (p.position, p.velocity);
within(at.x, at.z) && !within(at.x + v.x, at.z + v.z)
}
pub(super) struct ProjWorld<'a, 'w> {
pub w: &'a MobWorld<'w>,
pub targets: Vec<(Who, Aabb)>,
@@ -296,6 +310,53 @@ fn flame_geometry(
pub(super) fn seen(m: &Mob, player: Option<[i32; 4]>) -> Seen {
m.seen(player)
}
/// A mob's target as `native_living_change_target` names it: a player's UUID
/// or a mob's id, both None for no target; None for one it cannot name.
/// `Who::Player` is the guest the mob sees (`seen`, a connection) or, with
/// none, the host's own player (`host`); a guest's entity (`guest_ids`, by
/// connection) is that guest.
fn target_named(
target: Option<Who>,
seen: Option<u32>,
guests: &super::lan_mobs::GuestViews,
guest_ids: &[(u32, u32)],
host: Option<&PlayerView>,
) -> Option<(Option<u128>, Option<u32>)> {
let uuid = |v: &PlayerView| horizon_client::lan::playerdata::ints_uuid(v.uuid);
let guest = |conn: u32| guests.iter().find(|g| g.0 == conn).map(|g| uuid(&g.1));
match target {
None => Some((None, None)),
Some(Who::Player) => {
let player = match seen {
Some(conn) => guest(conn),
None => host.map(uuid),
};
Some((Some(player?), None))
}
Some(Who::Mob(id)) => match guest_ids.iter().find(|g| g.1 == id) {
Some(&(conn, _)) => Some((Some(guest(conn)?), None)),
None => Some((None, Some(id))),
},
}
}
/// Whether `e`, from a mob's tick, is a hit it deals `target`: a melee hit
/// (with its effect), a sting, a sonic boom.
fn hits_target(e: &MobEvent, want: Who) -> bool {
match (e, want) {
(
MobEvent::AttackPlayer(..)
| MobEvent::AttackPlayerWithEffect { .. }
| MobEvent::StingPlayer { .. },
Who::Player,
) => true,
(
MobEvent::AttackMob { target, .. } | MobEvent::AttackMobWithEffect { target, .. },
Who::Mob(id),
) => *target == id,
(MobEvent::SonicBoom { target, .. }, _) => *target == want,
_ => false,
}
}
/// Whether a mob a packet named may take the click: `mob_hit` skips a mob in
/// its death animation, the one the player rides (it shares the player's root
/// vehicle) and the camera entity the pick starts from, so a packet that names
@@ -1020,6 +1081,11 @@ impl Game<'_> {
snapshot.extend(self.mobs.iter().map(|m| seen(m, uuid)));
let mut events = Vec::new();
let mut mobs = std::mem::take(&mut self.mobs);
// Each mob's target as the mods last heard it, by its place in `mobs`
// (`native_living_change_target`).
let mut targets = std::mem::take(&mut self.creatures.target_buf);
targets.clear();
targets.extend(mobs.iter().map(|m| m.ai.target));
let mut dead = Vec::new();
let mut corpses = Vec::new();
let mut died = std::mem::take(&mut self.died);
@@ -1209,6 +1275,46 @@ impl Game<'_> {
} else if let Some(k) = lent {
spare = w.player.map(|v| std::mem::replace(&mut guests[k].1, v));
}
// Its tick changed its target: the mods may keep the one it had
// (`native_living_change_target`), and then what the tick did to
// the new one is not dealt.
if let Some(&before) = targets.get(i)
&& m.ai.target != before
{
let named = target_named(
m.ai.target,
seen_guest,
&guests,
&guest_ids,
base.player.as_ref(),
);
if let Some((player, mob)) = named {
let kind = super::native_hooks::mob_kind(m);
let mut cancel = false;
Self::native_living_change_target(
level_id,
m.id,
&kind,
player,
mob,
&mut cancel,
);
if cancel {
if let Some(new) = m.ai.target {
let mut k = from;
while k < events.len() {
if hits_target(&events[k], new) {
events.remove(k);
} else {
k += 1;
}
}
}
m.ai.target = before;
}
}
targets[i] = m.ai.target;
}
// A killed mob's body is removed: its effects that act on
// death run (`LivingEntity.remove` with KILLED).
if !kept && !m.alive() && !m.removed && !m.extra.effects.is_empty() {
@@ -1272,6 +1378,43 @@ impl Game<'_> {
grid.update(i, snapshot[i].bounds);
horizon_client::mobs::apply_brain_events(&mut mobs, &mut events, from);
}
// Targets changed after the mob's own tick (another mob's alert):
// heard now, and a cancel puts the old one back before its next tick.
for (i, m) in mobs.iter_mut().enumerate() {
let Some(&before) = targets.get(i) else {
break;
};
if m.ai.target == before {
continue;
}
let seen_guest = if guests.is_empty() {
None
} else {
bindings.get(&m.id).copied()
};
let named = target_named(
m.ai.target,
seen_guest,
&guests,
&guest_ids,
base.player.as_ref(),
);
if let Some((player, mob)) = named {
let kind = super::native_hooks::mob_kind(m);
let mut cancel = false;
Self::native_living_change_target(
level_id,
m.id,
&kind,
player,
mob,
&mut cancel,
);
if cancel {
m.ai.target = before;
}
}
}
laps.lap("creature_loop");
let mut flags = keep.into_iter();
mobs.retain(|_| flags.next().unwrap_or(true));
@@ -1303,6 +1446,8 @@ impl Game<'_> {
snapshot.clear();
self.creatures.seen_buf = snapshot;
self.creatures.ticked = ticked;
targets.clear();
self.creatures.target_buf = targets;
self.native_tick_post_batch(round);
// ... and entity event 60 goes out as it is: the poof.
// 🤖 Agent: the split follows the poof, as `LivingEntity.tickDeath`
@@ -2215,6 +2360,15 @@ impl Game<'_> {
let ctx = self.who_context(Some(Who::Mob(source)), None);
self.post_game_event(event, at, ctx);
}
MobEvent::GameEvent {
event: "minecraft:block_place",
at,
source,
state,
} => {
let ctx = self.who_context(Some(Who::Mob(source)), Some(state));
self.post_game_event("minecraft:block_place", at, ctx);
}
// The sculk layer tracks steps and bee/bat flaps itself
// (`entity_motion_events`, `tick_mob_sculk_events`). Birds
// above use their movement's flyDist/nextFlap threshold.
@@ -3316,10 +3470,11 @@ impl Game<'_> {
}
}
/// `Animal.finalizeSpawnChildFromBreeding`'s experience orb: only when the
/// `mob_drops` game rule is on.
/// `mob_drops` game rule is on, and one `new ExperienceOrb` of the whole
/// value (not split or merged as `ExperienceOrb.award` does).
fn spawn_breeding_orb(&mut self, at: [f64; 3], amount: u32) {
if self.ui.rules.bool("mob_drops") {
self.spawn_orbs(at, amount);
self.add_orb(at, amount);
}
}
/// `ServerPlayer.tellNeutralMobsThatIDied`: the mobs within 32 blocks
@@ -3680,13 +3835,14 @@ impl Game<'_> {
self.breeding_orb(parent, [p.position.x, p.position.y, p.position.z]);
}
/// `Animal.finalizeSpawnChildFromBreeding`'s experience, from the breeding
/// parent's own random, and only when the `mob_drops` game rule is on.
/// parent's own random, and only when the `mob_drops` game rule is on: one
/// fresh orb of 1 to 7 (#11388).
fn breeding_orb(&mut self, parent: u32, at: [f64; 3]) {
if self.ui.rules.bool("mob_drops")
&& let Some(m) = self.mobs.iter_mut().find(|m| m.id == parent)
{
let xp = 1 + m.random.next_int_bound(7).unwrap_or(0) as u32;
self.spawn_orbs(at, xp);
self.add_orb(at, xp);
}
}
/// `MobEffectUtil.addEffectToPlayersAround` for an elder guardian:
@@ -3844,6 +4000,7 @@ impl Game<'_> {
// The hit's own push, held back until after the shield's (`hurtServer`
// runs `applyItemBlocking` before `dealDefaultKnockback`).
let mut default_push: Option<([f64; 2], HurtSource<'_>)> = None;
let events_before = self.player.as_ref().map_or(0, |p| p.events.len());
if let Some(player) = self.player.as_mut()
&& let Some(id) = self.health_resources.damage.id(damage_type)
&& let Ok(o) = player.hurt_caused_by(
@@ -3879,15 +4036,36 @@ impl Game<'_> {
default_push = Some(([xd, zd], source));
}
// The thorns hurt the entity that caused the hit, if there is one.
// Thorns' own hit is no attack, so nothing answers it
// (`doPostAttackEffects` runs from the attacks, not `hurtServer`).
let killed = self.player.as_ref().is_some_and(|p| {
super::wither::killed(true, p.health.dead_or_dying(), p.health.totem_used)
});
if let Some(a) = attacker.or(owner)
&& !(post_attack_if_alive && killed)
&& damage_type != "minecraft:thorns"
{
self.thorns(a);
}
}
// LivingEntity.playSecondaryHurtSound: a thorns hit that landed whole
// sounds where the player stands, for everyone around.
if let Some(p) = self.player.as_ref()
&& p.events.get(events_before..).is_some_and(|new| {
new.iter().any(|e| {
matches!(
e,
horizon_client::motion::MotionEvent::Health(HealthEvent::Phase(
"thorns-sound"
))
)
})
})
{
let at = [p.position.x, p.position.y, p.position.z];
self.audio
.play("minecraft:enchant.thorns.hit", Some(at), 1.0, 1.0);
}
// LivingEntity.hurtServer: ENTITY_HURT_PLAYER, unless it returned
// early (invulnerable, or inside the hurt cooldown).
// A hit a native mod canceled records no damage (hurtServer never ran).
@@ -4113,6 +4291,7 @@ impl Game<'_> {
Vec::new()
};
let border = Some(self.border.bounds());
let dimension = self.dim.id();
let pw = ProjWorld {
w: &w,
targets,
@@ -4158,6 +4337,23 @@ impl Game<'_> {
keep_flags[i] = false;
continue;
}
// MC-310476: the mods may let a thrown projectile through the world border.
let through = p.arrow.is_none() && !p.stuck && border_crossing(p, border) && {
let (at, v) = (p.position, p.velocity);
let (mut pos, mut velocity) = ([at.x, at.y, at.z], [v.x, v.y, v.z]);
let mut collide = true;
let kind = p.kind.id();
let (vel, c) = (&mut velocity, &mut collide);
Self::native_projectile_world_border(dimension, p.id, kind, &mut pos, vel, c);
if pos.iter().chain(&velocity).all(|v| v.is_finite())
&& (pos != [at.x, at.y, at.z] || velocity != [v.x, v.y, v.z])
{
p.position = Vec3::new(pos[0], pos[1], pos[2]);
p.velocity = Vec3::new(velocity[0], velocity[1], velocity[2]);
p.needs_sync = true;
}
!collide
};
// The projectile as it was, to fly on if a mod cancels its impact.
let before = (hear && !p.stuck).then(|| p.clone());
let mob_shot = !matches!(p.owner, Some(Who::Player));
@@ -4188,6 +4384,16 @@ impl Game<'_> {
targets.extend(winds);
horizon_client::arrows::tick(p, &scene, &targets)
}
// Through the border: this tick's ray does not stop on it.
(false, with_guests, true) if through => p.tick(&ProjWorld {
w: pw.w,
targets: if with_guests {
pw_guests.targets.clone()
} else {
pw.targets.clone()
},
border: None,
}),
(false, false, true) => p.tick(&pw),
(false, true, true) => p.tick(&pw_guests),
(false, pvp_shot, false) => {
@@ -4200,7 +4406,7 @@ impl Game<'_> {
p.tick(&ProjWorld {
w: if pvp_shot { pw_guests.w } else { pw.w },
targets,
border,
border: border.filter(|_| !through),
})
}
};
@@ -4440,6 +4646,23 @@ impl Game<'_> {
None => self.projectile_hit(p, hit),
}
}
/// `EnchantmentHelper.doPostAttackEffects` after the player's shot `p`
/// (its `direct` entity, a hit of `damage_type`) hurt the mob `who`: the
/// victim's own post-attack enchantments answer the player (Thorns).
pub(super) fn shot_post_attack(
&mut self,
p: &Projectile,
who: Who,
direct: &str,
damage_type: &str,
) {
if p.owner == Some(Who::Player)
&& let Who::Mob(id) = who
&& let Some(index) = self.mobs.iter().position(|m| m.id == id)
{
self.victim_post_attack(index, direct, Some(damage_type));
}
}
/// What an arrow or a thrown trident hits an entity of type `victim`
/// for (`AbstractArrow.onHitEntity`, `ThrownTrident.onHitEntity`): a
/// trident's 8 through `EnchantmentHelper.modifyDamage` of the trident
@@ -4746,6 +4969,12 @@ impl Game<'_> {
}
}
pub(super) fn projectile_hit(&mut self, p: &Projectile, hit: Hit) -> Result<()> {
let result = self.projectile_hit_inner(p, hit);
// LivingEntity.actuallyHurt credits the shooter (a ServerPlayer) with the absorbed damage.
self.settle_dealt_absorbed(p.owner == Some(Who::Player));
result
}
fn projectile_hit_inner(&mut self, p: &Projectile, hit: Hit) -> Result<()> {
let _attacker = self.knockback_scope_for(p.owner);
// Projectile.onHitBlock: BlockState.onProjectileHit, for every
// projectile (a wind charge out of the world's top has no face).
@@ -4949,6 +5178,7 @@ impl Game<'_> {
}),
};
let outcome = if hurt {
self.shot_post_attack(p, who, "minecraft:trident", "minecraft:trident");
EntityHit::Hurt
} else {
EntityHit::Refused
@@ -5123,6 +5353,16 @@ impl Game<'_> {
}])?;
}
if hurt {
let spectral = p
.arrow
.as_ref()
.is_some_and(|a| &*a.pickup_item.item == "minecraft:spectral_arrow");
let direct = if spectral {
"minecraft:spectral_arrow"
} else {
"minecraft:arrow"
};
self.shot_post_attack(p, who, direct, "minecraft:arrow");
self.arrow_post_hurt_effects(p, who);
}
match (hurt, who) {
@@ -5327,6 +5567,9 @@ impl Game<'_> {
pl.fall_distance = 0.0;
pl.teleported = true;
}
if self.lan_acting.is_some() {
horizon_client::lan::hub::teleport_cause(Some("ender_pearl"));
}
self.previous_position = to;
if damage > 0.0 {
self.hurt_player_by("minecraft:ender_pearl", damage);
@@ -5478,7 +5721,7 @@ impl Game<'_> {
_ => None,
};
let owner = self.potion_owner(p.owner);
self.splash(stack, at, mob, block, p.age, &owner);
self.splash(stack, at, mob, block, p.age, &owner, p.velocity);
if stack.item.as_ref() != "minecraft:experience_bottle" {
let item = stack.item.to_string();
self.native_potion_splash(&item, [at.x, at.y, at.z]);
@@ -6711,6 +6954,17 @@ impl Game<'_> {
let Some(eye) = self.eye_position() else {
return Ok(false);
};
// The mods, before the projectile exists: a canceled throw is a
// failed use, and the guest's client gets back the item it took.
if let (Some(player), Some(name)) = (self.lan_acting_uuid, self.lan_acting_name.clone()) {
let mut cancel = false;
self.native_player_launch_projectile_v2(player, &name, stack, &mut cancel);
if cancel {
self.use_failed = true;
self.guest_inventory_resend = true;
return Ok(true);
}
}
let Some(p) = self.player.as_ref() else {
return Ok(false);
};
@@ -6770,7 +7024,7 @@ impl Game<'_> {
let parent = &self.mobs[index];
if !parent.alive()
|| !horizon_client::mobs::finalize::spawn_egg_is_for(&stack.item, &parent.kind.id)
|| !horizon_client::mobs::drops::can_be_baby(parent.species())
|| !horizon_client::mobs::species::can_be_a_baby(parent.species())
// WanderingTrader.getBreedOffspring returns null: no offspring, the
// click carries on to trading.
|| parent.species() == Species::WanderingTrader
@@ -8850,3 +9104,32 @@ mod pickable_projectile_tests {
}
}
}
#[cfg(test)]
mod breeding_orb_tests {
use super::*;
/// `Animal.finalizeSpawnChildFromBreeding`: one fresh orb of the parent's
/// 1-to-7 roll, never split (4 is not 3 + 1) or merged (#11388).
#[test]
#[ignore = "needs prepared resources (HORIZON_TEST_RESOURCES)"]
fn breeding_drops_one_orb_of_the_whole_roll() {
let mut game = super::super::native_machines::tests::server_game();
let kind = game.res.mob_types().get("minecraft:cow").unwrap().clone();
game.mobs
.push(Mob::new(7, kind, Vec3::new(8.5, 64.0, 8.5), 0.0));
let mut values = std::collections::BTreeSet::new();
for _ in 0..40 {
let roll = 1 + game.mobs[0].random.clone().next_int_bound(7).unwrap() as u32;
let orbs = game.orbs.len();
game.breeding_orb(7, [8.5, 64.0, 8.5]);
assert_eq!(game.orbs.len(), orbs + 1, "a fresh orb, not merged");
assert_eq!(
game.orbs.last().map(|o| (o.value, o.count)),
Some((roll, 1))
);
values.insert(roll);
}
assert!(values.iter().any(|v| matches!(v, 4..=6)), "{values:?}");
}
}
crates/horizon-client/src/game/custom_sky.rs
+75
View File
@@ -0,0 +1,75 @@
//! OptiFine custom skies (`horizon_client::custom_sky`): each frame, the layers of the world's sky
//! whose day, weather, biome and height hold at the camera, handed to the renderer, which draws
//! them over the vanilla sky. A pack without `optifine/sky` hands it none.
use super::*;
use horizon_optifine::sky::{Conditions, Now};
/// The layers' eased brightness between frames, and when the last frame was.
#[derive(Default)]
pub(super) struct CustomSkyView {
state: horizon_client::custom_sky::State,
last: Option<std::time::Instant>,
}
impl Game<'_> {
/// Fills the renderer's custom sky layers for this frame; `camera` is the eye's position.
/// Nothing for the title screen, the Nether (it has no sky) or a sky a shader pack draws.
pub(super) fn custom_sky_frame(
&mut self,
camera: [f64; 3],
sky: &horizon_client::environment::Sky,
(rain, thunder): (f32, f32),
title: bool,
) {
let Some(mut draws) = self
.renderer
.as_mut()
.map(|r| std::mem::take(r.custom_sky_draws()))
else {
return;
};
draws.clear();
let world = match self.dim {
Dim::Overworld => Some(0),
Dim::End => Some(1),
Dim::Nether => None,
};
let now = std::time::Instant::now();
let seconds = self
.custom_sky
.last
.replace(now)
.map_or(0.0, |t| now.duration_since(t).as_secs_f32());
if let Some(world) =
world.filter(|&w| !title && self.settings.horizon.sky && self.pack.custom_sky.has(w))
{
let mut state = std::mem::take(&mut self.custom_sky.state);
// Level.isThundering / isRaining.
let weather = if thunder > 0.9 && rain > 0.2 {
Now::Thunder
} else if rain > 0.2 {
Now::Rain
} else {
Now::Clear
};
let conditions = Conditions {
day_time: self.view_day_time(),
weather,
biome: self.biome_at(camera),
y: camera[1].floor() as i32,
};
self.pack.custom_sky.draws(
world,
&conditions,
sky.sun_angle / 360.0,
seconds,
&mut state,
&mut draws,
);
self.custom_sky.state = state;
}
if let Some(renderer) = self.renderer.as_mut() {
*renderer.custom_sky_draws() = draws;
}
}
}
crates/horizon-client/src/game/dedicated.rs
+19
View File
@@ -168,6 +168,16 @@ pub(super) fn player_joined(id: u128, name: &str) {
}
}
/// A player in the user cache by name (`UserCache::find_by_name`), on a dedicated server.
pub(super) fn cached_user_by_name(name: &str) -> Option<NameAndId> {
USER_CACHE.lock().unwrap().as_ref()?.find_by_name(name)
}
/// A player in the user cache by id, on a dedicated server.
pub(super) fn cached_user_by_id(id: u128) -> Option<NameAndId> {
USER_CACHE.lock().unwrap().as_mut()?.get_by_id(id)
}
/// `server.toml`'s `[anticheat]`, beside server.properties when horizon-server runs the game; the
/// default (on) without the file or the section, off (with an error logged) when the section is wrong.
fn load_anticheat() -> horizon_anticheat::Config {
@@ -1616,6 +1626,15 @@ impl Game<'_> {
/// server (permission level 4). The dedicated-only commands are here;
/// everything else goes to the game's dispatcher.
fn console_command(&mut self, state: &mut ServerState, line: &str) {
let (mut cancel, mut replies) = (false, Vec::new());
let source = if self.rcon_source { "rcon" } else { "console" };
self.native_console_line(source, line, &mut cancel, &mut replies);
for reply in replies {
self.console_reply(reply);
}
if cancel {
return;
}
let line = line.strip_prefix('/').unwrap_or(line);
let mut words = line.split_whitespace();
let Some(command) = words.next() else {
crates/horizon-client/src/game/dedicated/report.rs
+3 -4
View File
@@ -51,7 +51,7 @@ pub(super) struct Recording {
impl Recording {
pub(super) fn start(seconds: u32, wire: Vec<(u32, (u64, u64))>) -> Self {
let spans_were_on = spans::enabled();
spans::enable(true);
tick_profile::want_spans(tick_profile::SPANS_REPORT, true);
job_stats::enable(true);
job_stats::take();
tick_profile::take();
@@ -355,9 +355,8 @@ impl Game<'_> {
pub(super) fn finish_report(&mut self, r: Recording, view: (u32, u32), max_players: usize) {
let span_ns = span_cost_nanos();
let mob_ns = tick_profile::sample_cost_nanos();
if !r.spans_were_on {
spans::enable(false);
}
// Off unless `HORIZON_SPIKES` or a mod (`native_spans`) still wants them.
tick_profile::want_spans(tick_profile::SPANS_REPORT, false);
job_stats::enable(false);
let window_s = r.started.elapsed().as_secs_f64();
let (ticks, spans, worst) = tick_summary(&r, window_s);
crates/horizon-client/src/game/dispense_fixture.rs
+60 -3
View File
@@ -655,6 +655,8 @@ impl Game<'_> {
v[2].as_f64().unwrap_or(0.0),
)
};
// A new player: no combat of an earlier case's.
self.combat = Default::default();
let mut player = PlayerMotion::new(self.motion, v3(&op["player"]))?;
player.velocity = v3(&op["motion"]);
player.fall_distance = op["fall"].as_f64().unwrap_or(0.0);
@@ -670,6 +672,7 @@ impl Game<'_> {
let used_before = stack
.as_ref()
.map_or(0, |s| self.stats.get("used", &s.item));
let taken_before = self.stats.get("custom", "minecraft:damage_taken");
let base = op["base"].as_f64().unwrap_or(0.0) as f32;
let source = self.attack_source(feet);
let (bonus, hurt) = match targets.first() {
@@ -707,12 +710,39 @@ impl Game<'_> {
};
self.process_level_events()?;
let mut out = Vec::new();
// What the player's tick makes of its own hurt (the victim's Thorns):
// the combat record with its statistic, the hurt sound where it
// stands and the damage game event of the health it lost.
let events = self
.player
.as_mut()
.map(|p| std::mem::take(&mut p.events))
.unwrap_or_default();
self.record_combat(&events);
for event in &events {
if let horizon_client::motion::MotionEvent::HurtSound(sound) = event {
out.push(format!("S {} {sound}", floor_pos(feet)));
}
}
if self
.player
.as_ref()
.is_some_and(|p| p.health.health() < 20.0)
{
self.post_entity_event("minecraft:entity_damage", horizon_client::mobs::Who::Player);
}
if let Some(s) = &stack {
let used = self.stats.get("used", &s.item) - used_before;
if used != 0 {
out.push(format!("stat {} minecraft:used {used}", s.item));
}
}
let taken = self.stats.get("custom", "minecraft:damage_taken") - taken_before;
if taken != 0 {
out.push(format!(
"stat minecraft:damage_taken minecraft:custom {taken}"
));
}
let source = match source.kind {
horizon_client::mobs::DamageKind::MaceSmash => "minecraft:mace_smash",
horizon_client::mobs::DamageKind::Spear => "minecraft:spear",
@@ -743,6 +773,25 @@ impl Game<'_> {
num(v.z)
));
}
// What the first target wears, worn by its Thorns.
if let Some(&Target::Mob(id)) = targets.first()
&& let Some(m) = self.mobs.iter().find(|m| m.id == id)
{
use horizon_client::mobs::finalize as f;
for (slot, name) in [
(f::FEET, "feet"),
(f::LEGS, "legs"),
(f::CHEST, "chest"),
(f::HEAD, "head"),
] {
if let Some(s) = f::item_stack(m, slot) {
out.push(format!("W {name} {}", canon_stack(Some(&s))));
}
}
}
if let Some(p) = self.player.as_ref() {
out.push(format!("H {}", num(f64::from(p.health.health()))));
}
if let Some(p) = self.player.take() {
let impact = p.impulse.impact_position.map_or("-".to_owned(), |i| {
format!("{},{},{}", num(i.x), num(i.y), num(i.z))
@@ -1044,12 +1093,20 @@ impl Game<'_> {
if flag("brown") && s == Species::Mooshroom {
mob.extra.variant = 1;
}
for (slot, snbt) in e["equip"].as_object().into_iter().flatten() {
for (name, snbt) in e["equip"].as_object().into_iter().flatten() {
if let (Some(slot), Some(stack)) = (
Slot::from_name(slot),
Slot::from_name(name),
parse_stack(snbt.as_str().unwrap_or("-"))?,
) {
mob_set_slot(&mut mob, slot, stack);
// `setItemSlot` keeps the whole stack: a piece's enchantments and damage.
let kept = ["mainhand", "offhand", "feet", "legs", "chest", "head"]
.iter()
.position(|s| s == name)
.filter(|_| stack.extra.is_some() || stack.damage > 0);
match kept {
Some(at) => horizon_client::mobs::finalize::set_item_stack(&mut mob, at, stack),
None => mob_set_slot(&mut mob, slot, stack),
}
}
}
self.mobs.push(mob);
crates/horizon-client/src/game/enchant_effects.rs
+206 -9
View File
@@ -17,6 +17,9 @@ use horizon_core::{position::BlockPos, random::RandomSource};
use horizon_world::{fluid::FluidKind, level::LevelAccess, registry::BlockStateId};
use serde_json::Value;
/// `EquipmentSlot.getName` of each `mobs::finalize` slot (hands, feet to head).
const MOB_SLOTS: [&str; 6] = ["mainhand", "offhand", "feet", "legs", "chest", "head"];
/// Where Mending found a damaged item (`EnchantedItemInUse.inSlot`).
#[derive(Clone, Copy)]
enum MendSlot {
@@ -178,8 +181,12 @@ impl Game<'_> {
let _ = p.set_sprinting(false);
}
}
/// After a successful melee hit: fire aspect and wind burst.
/// `EnchantmentHelper.doPostAttackEffectsWithItemSource` after a successful
/// melee hit (`Player.itemAttackInteraction`, the sweep's
/// `doPostAttackEffects`): the victim's equipment first (Thorns), then the
/// attacker's weapon on the victim (fire aspect and wind burst).
pub(super) fn post_attack(&mut self, mob: usize) {
self.victim_post_attack(mob, "minecraft:player", None);
let Some(held) = self.held().cloned() else {
return;
};
@@ -519,6 +526,152 @@ impl Game<'_> {
}
hits
}
/// `EnchantmentHelper.doPostAttackEffectsWithItemSource`'s `VICTIM` loop
/// after the player's hit hurt the mob at `victim` (`direct` is the hit's
/// direct entity: the player, or its arrow or trident):
/// `runIterationOnEquipment` over what the mob holds and wears, in
/// `EquipmentSlot` order, runs the `minecraft:post_attack` effects with
/// `enchanted: victim` of each enchantment on the player (Thorns).
pub(super) fn victim_post_attack(
&mut self,
victim: usize,
direct: &str,
damage_type: Option<&str>,
) {
use horizon_client::mobs::finalize as f;
let Some(m) = self.mobs.get(victim) else {
return;
};
let (id, kind) = (m.id, m.kind.id.clone());
// EquipmentSlot.VALUES: the hands, then the feet up to the head (the
// body and the saddle keep no enchantments here).
for slot in [f::MAINHAND, f::OFFHAND, f::FEET, f::LEGS, f::CHEST, f::HEAD] {
let Some(stack) = self
.mobs
.iter()
.find(|m| m.id == id)
.and_then(|m| f::item_stack(m, slot))
else {
continue;
};
let name = MOB_SLOTS[slot];
let hand = slot == f::MAINHAND || slot == f::OFFHAND;
let mut effects = Vec::new();
for (enchantment, level) in stack.enchantments() {
let Some(def) = world_stations!(self).enchantments.get(enchantment) else {
continue;
};
// Enchantment.matchingSlot
if !def.slots.iter().any(|s| {
s == name || s == "any" || (s == "armor" && !hand) || (s == "hand" && hand)
}) {
continue;
}
for effect in def.effects["minecraft:post_attack"]
.as_array()
.into_iter()
.flatten()
{
if effect["enchanted"] == "victim" {
effects.push((effect.clone(), *level));
}
}
}
for (effect, level) in effects {
// Enchantment.damageContext: random_chance draws from the level's random.
let ctx = EffectContext {
this: Some(&kind),
attacker: Some("minecraft:player"),
direct_attacker: Some(direct),
is_direct: direct == "minecraft:player",
damage_type,
items: Some(world_items!(self)),
..Default::default()
};
let ok = effect.get("requirements").is_none_or(|r| {
world_stations!(self).enchantments.condition(
r,
level,
&ctx,
&mut self.world.random,
)
});
// The player is the attacker; with no attacker nothing applies.
if ok && effect["affected"] == "attacker" && self.player.is_some() {
self.victim_effect_on_player(&effect["effect"], level, id, slot);
}
}
}
}
/// `DamageEntity.apply`, `ChangeItemDamage.apply` (on the piece) and
/// `AllOf` for one `post_attack` effect of the piece the mob `wearer` has
/// in `slot`, on the player that hit it.
fn victim_effect_on_player(&mut self, effect: &Value, level: u32, wearer: u32, slot: usize) {
match effect["type"]
.as_str()
.map(|t| t.trim_start_matches("minecraft:"))
{
Some("all_of") => {
for e in effect["effects"].as_array().into_iter().flatten() {
self.victim_effect_on_player(e, level, wearer, slot);
}
}
// Mth.randomBetween from the hurt entity's own random (the
// player's, which no level draw shares), then its hurtServer by a
// source the wearer caused: from where the wearer stands.
Some("damage_entity") => {
let min = level_value(&effect["min_damage"], level);
let max = level_value(&effect["max_damage"], level);
let damage = super::dispenser::entity_random().next_float() * (max - min) + min;
let Some(m) = self.mobs.iter().find(|m| m.id == wearer) else {
return;
};
let from = [m.position.x, m.position.y, m.position.z];
let kind = effect["damage_type"].as_str().unwrap_or("minecraft:thorns");
self.mob_hits_player_caused(damage, from, kind, Some(wearer));
}
Some("change_item_damage") => {
let amount = level_value(&effect["amount"], level) as u32;
self.wear_mob_piece(wearer, slot, amount);
}
_ => {}
}
}
/// `ItemStack.hurtAndBreak` with no player for what the mob `id` has in
/// `slot`: Unbreaking takes its share from the level's random, and a
/// piece worn out leaves the slot with its break event
/// (`LivingEntity.onEquippedItemBroken`).
fn wear_mob_piece(&mut self, id: u32, slot: usize, amount: u32) {
use horizon_client::mobs::finalize as f;
let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
return;
};
let at = [m.position.x, m.position.y, m.position.z];
let Some(stack) = f::item_stack(m, slot).filter(|s| {
amount > 0 && horizon_client::stations::is_damageable(world_items!(self), s)
}) else {
return;
};
let loss = self.durability_loss(&stack, amount);
if loss == 0 {
return;
}
let damage = stack.damage + loss;
let max = world_items!(self)
.get(&stack.item)
.map_or(0, |i| i.max_damage);
let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) else {
return;
};
if damage < max {
f::set_slot_damage(m, slot, damage);
return;
}
horizon_client::mobs::drops::clear_slot(m, MOB_SLOTS[slot]);
// LivingEntity.entityEventForEquipmentBreak
let event = [47, 48, 52, 51, 50, 49][slot];
self.lan_entity_event(id as i32, event, at);
}
/// `ExperienceOrb.repairPlayerItems`: returns the experience left over.
pub(super) fn mending(&mut self, amount: u32) -> u32 {
let mut amount = amount;
@@ -840,16 +993,26 @@ impl Game<'_> {
let at = [p.position.x, p.position.y, p.position.z];
let on_ground = p.ground.on_ground;
let cell = |v: [f64; 3]| v.map(|c| c.floor() as i32);
if cell(from) == cell(at) && !(on_ground && !was_on_ground) {
// LivingEntity.collectEquipmentChanges: newly worn armor runs its
// location_changed effects at once, even when standing still.
let changed = armor_changes(&mut self.location_armor, &self.armor);
let moved = cell(from) != cell(at) || (on_ground && !was_on_ground);
if !moved && !changed.iter().any(|c| *c) {
return;
}
let riding = self.riding.is_some();
let disks = location_disks(
&self.stations().enchantments,
self.armor.iter().zip(["head", "chest", "legs", "feet"]),
on_ground,
riding,
);
let slots = ["head", "chest", "legs", "feet"];
let mut disks = Vec::new();
for i in 0..4 {
if moved || changed[i] {
disks.extend(location_disks(
&self.stations().enchantments,
std::iter::once((&self.armor[i], slots[i])),
on_ground,
riding,
));
}
}
for (effect, level) in disks {
self.replace_disk(&effect, level, at, Who::Player);
}
@@ -1182,9 +1345,43 @@ fn location_requirements(req: &Value, on_ground: bool, riding: bool) -> bool {
}
}
/// `LivingEntity.collectEquipmentChanges`: which armor slots differ from the
/// `snapshot` taken at the last look, which is then brought up to date.
fn armor_changes(
snapshot: &mut [Option<ItemStack>; 4],
armor: &[Option<ItemStack>; 4],
) -> [bool; 4] {
let changed: [bool; 4] = std::array::from_fn(|i| armor[i] != snapshot[i]);
// Only a changed slot is copied: the check runs every tick for every player.
for ((kept, worn), changed) in snapshot.iter_mut().zip(armor).zip(changed) {
if changed {
kept.clone_from(worn);
}
}
changed
}
#[cfg(test)]
mod tests {
use super::block_break_speed_factor;
use super::{armor_changes, block_break_speed_factor};
use horizon_client::items::ItemStack;
/// The snapshot reports a newly worn piece once, then settles.
#[test]
fn armor_changes_settle_after_one_look() {
let worn = [
None,
None,
None,
Some(ItemStack::new("minecraft:iron_boots", 1)),
];
let mut snapshot: [Option<ItemStack>; 4] = Default::default();
assert_eq!(
armor_changes(&mut snapshot, &worn),
[false, false, false, true]
);
assert_eq!(armor_changes(&mut snapshot, &worn), [false; 4]);
}
/// #4094: `BLOCK_BREAK_SPEED` is a multiplier on the destroy speed.
#[test]
crates/horizon-client/src/game/fishing.rs
+79 -2
View File
@@ -408,6 +408,8 @@ impl Game<'_> {
};
let mut cancel = false;
self.native_player_fish(uuid, &name, state, &mut cancel);
let hand = self.hand;
self.native_player_fish_v2(uuid, &name, state, hand, &mut cancel);
if cancel {
return true;
}
@@ -766,6 +768,17 @@ impl Game<'_> {
{
let mut cancel = false;
self.native_player_fish(uuid, &name, 1, &mut cancel);
// A bite has no hand of its own: the one holding the rod, the main
// hand first, as `FishingHook.shouldStopFishing` looks.
let hand = if self
.stack_in(self.selected)
.is_some_and(|s| &*s.item == "minecraft:fishing_rod")
{
horizon_client::first_person::Hand::Main
} else {
horizon_client::first_person::Hand::Off
};
self.native_player_fish_v2(uuid, &name, 1, hand, &mut cancel);
if cancel {
h.time_until_lured = 0;
h.time_until_hooked = 0;
@@ -896,6 +909,10 @@ impl Game<'_> {
];
let liquid = self.water_height(b[0], b[1], b[2]).map_or(0.0, |w| w.0);
let in_water = liquid > 0.0;
// The block a flying bobber meets or rests on this tick (and the face), for
// `native_fishing_hook_landed` once the tick is done.
let rested = h.on_ground;
let mut landed: Option<([i32; 3], [i32; 3])> = None;
match h.state {
State::Flying => {
if in_water {
@@ -908,7 +925,8 @@ impl Game<'_> {
// checkCollision: find the first block and entity on the movement
// segment so a fast hook cannot tunnel or catch through a wall.
let to = h.position.add_vector(h.velocity);
let block_hit = self.hook_block_hit(h.position, to);
let block_hit_at = self.hook_block_hit_at(h.position, to);
let block_hit = block_hit_at.map(|hit| hit.location);
let entity_end = block_hit.unwrap_or(to);
let owner = self.lan_acting;
let own_vehicle = self.own_vehicle();
@@ -979,6 +997,8 @@ impl Game<'_> {
}
}
} else if let Some(hit) = block_hit {
landed = block_hit_at
.map(|at| ([at.block.x, at.block.y, at.block.z], at.direction.normal()));
// Projectile.onHit on a block: PROJECTILE_LAND.
self.projectile_event(
"minecraft:projectile_land",
@@ -1101,7 +1121,24 @@ impl Game<'_> {
h.velocity.y * 0.92,
h.velocity.z * 0.92,
);
// A bobber lying on a block (on the ground as the tick began or ends) rests on
// the block under its centre, on that block's top.
if landed.is_none() && h.state == State::Flying && (rested || h.on_ground) {
let below = [
h.position.x.floor() as i32,
(h.position.y - 1.0e-4).floor() as i32,
h.position.z.floor() as i32,
];
landed = Some((below, [0, 1, 0]));
}
let id = h.id;
self.hook = Some(h);
// The mods hear a server player's bobber on a block with the bobber in place, so
// `native_remove_entity` can take it.
if let (Some((block, face)), Some(player)) = (landed, self.lan_acting_uuid) {
let dimension = self.dim.id();
self.native_fishing_hook_landed(player, id, dimension, block, face);
}
}
/// The players a hook can catch: everyone but spectators and the dead
/// (`Projectile.canHitEntity`), the host and the guests in the level.
@@ -1601,6 +1638,10 @@ impl Game<'_> {
/// `FishingHook.checkCollision` clips blocks on both sides of the connection.
fn hook_block_hit(&self, from: Vec3, to: Vec3) -> Option<Vec3> {
self.hook_block_hit_at(from, to).map(|hit| hit.location)
}
/// [`Self::hook_block_hit`] with the block and the face it meets.
fn hook_block_hit_at(&self, from: Vec3, to: Vec3) -> Option<horizon_core::geometry::BlockHit> {
let mut scene = SceneCollisions {
world: &self.world,
binding: self.collision,
@@ -1618,7 +1659,6 @@ impl Game<'_> {
})
.ok()
.flatten()
.map(|hit| hit.location)
}
/// `FishingHook.tick`: one tick of movement without the fishing (the
@@ -1726,6 +1766,43 @@ impl Game<'_> {
(position, velocity, state, on_ground)
}
/// Takes the server's fishing bobber `id` out of the level in place, for
/// `native_remove_entity`: the bobber of the player in place, or another of this
/// level's players' (out of reach during a guest's turn, when the hub is taken out).
/// Its tracking removes it from the clients; the rod is left as when the bobber goes
/// by itself. Whether it was there.
pub(super) fn remove_server_hook(&mut self, id: u32) -> bool {
if self.remote.is_some() || id == 0 {
return false;
}
if self.hook.as_ref().is_some_and(|h| h.id == id) {
self.hook = None;
return true;
}
let Some(host) = self.lan.as_mut() else {
return false;
};
let owner = host
.hub
.guests
.iter()
.filter(|g| host.hub.here(g))
.map(|g| g.conn)
.find(|conn| {
host.play
.get(conn)
.and_then(|p| p.hook.as_ref())
.is_some_and(|h| h.id == id)
});
match owner.and_then(|conn| host.play.get_mut(&conn)) {
Some(play) => {
play.hook = None;
true
}
None => false,
}
}
pub(super) fn remove_remote_hook(&mut self, id: u32) {
if self.remote.is_some() && self.hook.as_ref().is_some_and(|h| h.id == id) {
self.hook = None;
crates/horizon-client/src/game/frames.rs
+81 -6
View File
@@ -116,12 +116,7 @@ impl Game<'_> {
));
let supported = behind.legacy_solid || (s[1] == 0 && behind.has_class("DiodeBlock"));
// canCoexist(true): only hanging entities facing the same way block it.
let overlaps = |o: ([f64; 3], [f64; 3])| (0..3).all(|i| o.0[i] < hi[i] && lo[i] < o.1[i]);
supported
&& !self
.item_frames
.iter()
.any(|o| o.id != f.id && o.facing == f.facing && overlaps(o.bounds()))
supported && super::paintings::frame_coexists(f, &self.item_frames, &self.paintings)
}
/// Asks the mods whether the acting guest may place a hanging entity
/// of type `kind` at `pos` (`native_hanging_place`): true when one
@@ -288,6 +283,13 @@ impl Game<'_> {
let Some(held) = self.held().cloned() else {
return false;
};
// A map tracking more than 256 counted markers stays in the hand
// (InteractionResult.FAIL): nothing else is tried, no swing (#11383).
if let Some(id) = super::maps::map_id(&held)
&& self.map(id).is_some_and(|m| m.tracked_over_limit(256))
{
return true;
}
self.item_frames[i].item = Some(ItemStack { count: 1, ..held });
action = "put";
self.audio
@@ -709,3 +711,76 @@ impl Game<'_> {
}
}
}
#[cfg(test)]
mod map_limit_tests {
use super::super::maps::{Decoration, Key, MapData};
use super::super::native_machines::tests::server_game;
use super::*;
fn frame(id: u32) -> ItemFrame {
ItemFrame {
id,
pos: [0, 64, id as i32],
facing: 3,
glow: false,
item: None,
rotation: 0,
drop_chance: 1.0,
fixed: false,
invisible: false,
check_interval: 0,
custom_name: None,
}
}
/// A map whose `count` frame markers all count toward the limit.
fn map_tracking(count: i32) -> MapData {
let mut map = MapData::fresh(0.0, 0.0, 0, "minecraft:overworld");
map.decorations = (0..count)
.map(|i| Decoration {
sprite: "map/decorations/frame",
x: 0,
y: 0,
rot: 0,
name: None,
key: Key::Frame(1000 + i),
})
.collect();
map
}
fn filled_map(id: i32) -> ItemStack {
let mut stack = ItemStack::new("minecraft:filled_map", 1);
stack.data_mut().map_id = Some(id);
stack
}
fn at(id: u32) -> Option<InteractTarget> {
Some(InteractTarget {
id: id as i32,
location: [0.0; 3],
})
}
#[test]
#[ignore = "needs prepared resources (HORIZON_TEST_RESOURCES)"]
fn a_map_tracking_more_than_256_markers_stays_in_the_hand() {
let mut game = server_game();
game.item_frames = vec![frame(1), frame(2)];
game.maps.data.insert(7, map_tracking(257));
game.maps.data.insert(8, map_tracking(256));
// ItemFrame.interact: FAIL, the frame stays empty and the map is kept.
*game.held_mut() = Some(filled_map(7));
assert!(
game.interact_frame(at(1)),
"the refusal ends the interaction"
);
assert!(game.item_frames[0].item.is_none());
assert_eq!(game.held().and_then(|s| s.data()?.map_id), Some(7));
// At the limit (not over it) the map goes in.
*game.held_mut() = Some(filled_map(8));
assert!(game.interact_frame(at(2)));
let framed = game.item_frames[1].item.as_ref();
assert_eq!(framed.and_then(|s| s.data()?.map_id), Some(8));
}
}
crates/horizon-client/src/game/ghasts.rs
+89 -4
View File
@@ -37,9 +37,10 @@ impl Game<'_> {
.collect()
}
/// `EntityGetter.getEntityCollisions` for a dropped item: the entities whose
/// `canBeCollidedWith(item)` is true. A boat and a minecart always, a living shulker,
/// and a happy ghast only while it is held still (`isOnStillTimeout`): a player on its
/// back keeps it still, so an item dropped there stays on top.
/// `canBeCollidedWith(item)` is true. A boat always, a living shulker, and a happy
/// ghast only while it is held still (`isOnStillTimeout`): a player on its back keeps
/// it still, so an item dropped there stays on top. A minecart keeps `Entity`'s false
/// (`AbstractMinecart` overrides only `canCollideWith`), so an item falls through it.
pub(super) fn item_entity_collisions(&self) -> Vec<Aabb> {
self.mobs
.iter()
@@ -52,7 +53,6 @@ impl Game<'_> {
})
.map(|m| m.bounds())
.chain(self.boats.iter().map(super::boats::Boat::bounds))
.chain(self.carts.iter().map(|c| c.bounds()))
.collect()
}
/// `HappyGhast.mobInteract`. Returns whether the click was used.
@@ -179,3 +179,88 @@ impl Game<'_> {
}
}
}
#[cfg(test)]
mod item_collision_tests {
use crate::game::{Audio, Game, Options, Progress, Settings, load_resources};
use horizon_client::chunk::Chunk;
use horizon_core::position::ChunkPos;
use std::sync::Arc;
/// An item dropped onto a minecart falls through it to the floor, and one
/// dropped onto a boat rests on the boat (`canBeCollidedWith`).
#[test]
#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
fn a_dropped_item_rests_on_a_boat_but_falls_through_a_minecart() {
let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
let settings = Settings::default();
let loaded = load_resources(
root.clone(),
None,
&root,
&settings,
std::time::Instant::now(),
false,
true,
&Progress::new(),
&mut |_, _| unreachable!(),
)
.unwrap();
let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
options.resources = root.clone();
options.game_dir = Some(
std::env::temp_dir().join(format!("horizon-item-cart-unit-{}", std::process::id())),
);
options.execution_role = crate::game::execution_role::ExecutionRole::IntegratedServer;
let mut game = Game::new(
&loaded.resources,
loaded.pack,
loaded.gui.unwrap(),
options,
settings,
Audio::silent(&root),
None,
)
.unwrap();
game.build_registries();
game.set_allow_commands(true);
let stone = game
.pack
.assets
.registry
.default_state("minecraft:stone")
.unwrap()
.0;
let mut chunk = Chunk::empty(0, 0);
for x in 0..16 {
for z in 0..16 {
chunk.set(x, 199, z, stone);
}
}
game.world.chunks.insert((0, 0), Arc::new(chunk));
game.block_ticks
.add_empty_chunk(ChunkPos::new(0, 0))
.unwrap();
assert!(game.run_command("forceload add 0 0"));
assert!(game.run_command("summon minecart 4.5 200 4.5"));
assert!(game.run_command("summon oak_boat 10.5 200 10.5"));
for (x, z) in [(4.5, 4.5), (10.5, 10.5)] {
assert!(game.run_command(&format!(
"summon item {x} 201.5 {z} {{Item:{{id:\"minecraft:stick\",count:1}},Motion:[0.0d,0.0d,0.0d]}}"
)));
}
for _ in 0..60 {
game.tick_world(true).unwrap();
}
let rest = |x: f64| {
game.dropped
.iter()
.find(|d| (d.position.x - x).abs() < 0.5)
.map(|d| d.position.y)
.unwrap()
};
assert_eq!(rest(4.5), 200.0, "through the minecart to the stone");
let boat_top = game.boats[0].bounds().max_position().y;
assert_eq!(rest(10.5), boat_top, "on the boat");
}
}
crates/horizon-client/src/game/hand.rs
+9
View File
@@ -200,6 +200,15 @@ impl Game<'_> {
pub(super) fn swing_arm(&mut self) {
self.swing_hand(self.hand, SwingAnimation::DEFAULT);
}
/// `swing_arm` for a use whose result is `SwingSource.PREDICTED`: the
/// player's client swings by itself, so a server keeps it to the others.
pub(super) fn swing_arm_predicted(&mut self) {
let before = self.swings_started;
self.swing_arm();
if self.swings_started != before {
self.predicted_swings += 1;
}
}
/// `Player.resetAttackStrengthTicker`.
pub(super) fn reset_attack_strength(&mut self) {
self.attack_ticks = 0;
crates/horizon-client/src/game/integrated.rs
+3 -1
View File
@@ -561,6 +561,7 @@ impl Game<'_> {
self.server_packs_world_pack(&folder);
self.connect_local(pipe, &player)?;
if let Some(r) = self.remote.as_mut() {
r.save_folder = Some(folder.clone());
// `new LevelLoadTracker(newWorld ? 500L : 0L)`.
r.level_load = horizon_client::level_loading::LevelLoadTracker::new(if new_world {
horizon_client::level_loading::LEVEL_LOAD_CLOSE_DELAY_MS
@@ -971,7 +972,8 @@ impl Game<'_> {
g.chat_capture = Some(Vec::new());
// A command a native mod registered goes to the mods
// first, as the owner's own chat does (the console is
// level 4, so every registered usage is allowed).
// level 4, so every registered usage is allowed; one with
// a permission node asks the mods for the owner).
if !g.perform_native_command(conn, 4, command.trim()) {
g.run_command(&command);
}
crates/horizon-client/src/game/lan.rs
+54 -11
View File
@@ -262,6 +262,11 @@ pub(super) struct LanHost {
/// Native mods' commands and the level each needs, once asked
/// (game/native_server.rs).
pub native_commands: Option<HashMap<String, u8>>,
/// The permission node of each native mod's command that has one
/// (`NativeCommand::permission`), in registration order.
pub native_command_nodes: Vec<(String, String)>,
/// The usages behind them, as the mods registered them.
pub native_usages: Vec<horizon_client::mod_api::NativeCommand>,
/// The players a native mod leaves out of the sleep count when they
/// aren't in bed (`native_sleep_ignored`).
pub sleep_ignored: std::collections::HashSet<u128>,
@@ -1450,6 +1455,8 @@ impl Game<'_> {
quiet: std::collections::VecDeque::new(),
far,
native_commands: None,
native_command_nodes: Vec::new(),
native_usages: Vec::new(),
sleep_ignored: Default::default(),
states: Default::default(),
states_next_entity: None,
@@ -2082,12 +2089,16 @@ impl Game<'_> {
}
HostEvent::Joined(conn) => {
// The mods may refuse the login before the player is placed.
if let Some((uuid, name)) =
host.hub.guest(conn).map(|g| (g.uuid, g.name.clone()))
if let Some((uuid, name, permission)) = host
.hub
.guest(conn)
.map(|g| (g.uuid, g.name.clone(), g.permission))
{
let mut cancel = false;
let mut reason = None;
self.native_login_permission = Some((uuid, permission));
self.native_player_login(uuid, &name, &mut cancel, &mut reason);
self.native_login_permission = None;
if cancel {
let reason = match reason {
Some(text) => {
@@ -2158,6 +2169,8 @@ impl Game<'_> {
{
self.lan = Some(host);
self.native_player_logged_in(uuid, &name);
// What the client said in its configuration (native_packets.rs).
self.configuration_heard(uuid, &name);
// A hook's command can close the hub.
host = self.lan.take()?;
}
@@ -2172,6 +2185,11 @@ impl Game<'_> {
let conn = guest.conn;
let at = host.hub.guests.len();
host.hub.guests.push(*guest);
// Bukkit's PlayerQuitEvent: the mods hear them leave while
// they are still here.
if !host.players_told_left {
host = self.tell_mods_logging_out(host, conn)?;
}
self.guest_disconnected(&mut host, conn);
*guest = host.hub.guests.remove(at);
}
@@ -2404,7 +2422,7 @@ impl Game<'_> {
.take()
.expect("the hub is back after the advancement grants");
}
if !host.hub.native_menu_events.is_empty() {
if !host.hub.native_menu_events.is_empty() || !host.hub.native_menu_returns.is_empty() {
self.lan = Some(host);
horizon_client::spans::time("lan_menu_events", || self.run_native_menu_events());
host = self
@@ -2412,6 +2430,14 @@ impl Game<'_> {
.take()
.expect("the hub is back after the menu events");
}
if !self.native_moves.is_empty() {
self.lan = Some(host);
horizon_client::spans::time("lan_native_moves", || self.run_native_moves());
host = self
.lan
.take()
.expect("the hub is back after the mods' moves");
}
host.states = entities;
self.level_pass.packets_drained = true;
drop(holding);
@@ -2549,6 +2575,7 @@ impl Game<'_> {
// What the tick sends a guest goes to its connection at the end.
let holding = lan::Holding::start();
self.register_native_commands(&mut host);
self.resend_native_trees(&mut host);
// The host's own commands' (and command blocks') players moving
// to another level, and their broadcastToAdmins lines.
if !self.level_teleports.is_empty() {
@@ -2591,13 +2618,7 @@ impl Game<'_> {
let mut states = std::mem::take(&mut host.states);
if has_guests {
self.lan_assign_ids();
let guests: Vec<(u32, i32)> = host
.hub
.guests
.iter()
.filter_map(|g| Some((g.vehicle?, g.entity_id)))
.collect();
self.lan_riding(&guests, &mut host.hub.riding);
self.lan_riding(&host.hub.guests, &mut host.hub.riding);
// Idle states are kept only when the players' moves are in:
// the clients that could pair are known. The range scale is
// the one the tracker gets below.
@@ -2765,7 +2786,7 @@ impl Game<'_> {
.take()
.expect("the hub is back after the advancement grants");
}
if !host.hub.native_menu_events.is_empty() {
if !host.hub.native_menu_events.is_empty() || !host.hub.native_menu_returns.is_empty() {
self.lan = Some(host);
self.run_native_menu_events();
host = self
@@ -2803,6 +2824,7 @@ impl Game<'_> {
drop(holding);
self.flush_attachment_sync(&mut host);
self.flush_native_net(&mut host);
self.flush_native_player_fx(&mut host);
self.flush_far_terrain(&mut host);
lan::flush_all(host.hub.guests.iter().map(|g| &g.sender));
self.lan = Some(host);
@@ -2870,6 +2892,27 @@ impl Game<'_> {
g.food = 20;
g.dimension = super::Dim::Overworld.id().to_owned();
}
// Spigot's PlayerSpawnLocationEvent: the mods may place them elsewhere.
let (mut dimension, mut position, mut rotation) =
(g.dimension.clone(), g.position, [g.yaw, g.pitch]);
self.native_player_spawn_location(
g.uuid,
&g.name,
&mut dimension,
&mut position,
&mut rotation,
);
if dimension != g.dimension && super::Dim::from_id(&dimension).id() == dimension {
g.dimension = dimension;
}
if position != g.position && position.iter().all(|v| v.is_finite()) {
g.position = position;
g.previous_position = position;
}
if rotation != [g.yaw, g.pitch] && rotation.iter().all(|v| v.is_finite()) {
(g.yaw, g.pitch) = (rotation[0], rotation[1]);
g.head_yaw = g.yaw;
}
// A server places each player in their own level (`PlayerList.placeNewPlayer`).
let back = self.dim;
let level = super::Dim::from_id(&g.dimension);
crates/horizon-client/src/game/lan_actions.rs
+565 -47
View File
@@ -137,6 +137,9 @@ pub(super) struct GuestPlay {
/// What `ServerPlayer` last recorded for the guest's scoreboard criteria
/// (`lastRecordedHealthAndAbsorption` and the others).
score_recorded: super::scoreboard::Recorded,
/// The window slots of the drag the guest is making, for
/// `native_inventory_drag` at its end.
drag_heard: Option<Vec<i32>>,
}
/// A guest's command waiting for the hub (`LanHost::commands`).
@@ -309,6 +312,25 @@ fn direction(face: i32) -> [i32; 3] {
}
}
/// The windows a guest has open besides their inventory: the block or mod
/// container, the crafting table, a station, a lectern, a merchant, a mount.
fn guest_open_windows(host: &LanHost, conn: u32) -> Vec<i32> {
let mut windows: Vec<i32> = host
.hub
.guest(conn)
.and_then(|g| g.menu.as_ref().map(|m| m.window))
.into_iter()
.collect();
if let Some(p) = host.play.get(&conn) {
windows.extend(p.crafting.table.as_ref().map(|t| t.0));
windows.extend(p.station.as_ref().map(|s| s.window));
windows.extend(p.lectern.as_ref().map(|l| l.window));
windows.extend(p.merchant.as_ref().map(|m| m.window));
windows.extend(p.mount_window.as_ref().map(|m| m.window));
}
windows
}
/// The hub's current bodies, across dimensions. A borrowed ancestor's
/// live body takes precedence over this saved state until its turn returns.
fn building_players(host: &LanHost) -> Vec<BuildingPlayer> {
@@ -497,14 +519,15 @@ impl Game<'_> {
motion.yaw = g.yaw;
motion.pitch = g.pitch;
motion.sprinting = g.sprinting;
motion.may_fly = g.creative() || g.game_mode == SPECTATOR;
let mode_flies = g.creative() || g.game_mode == SPECTATOR;
motion.may_fly = mode_flies || g.allow_flight;
motion.flying = g.flying;
motion.flying_speed = g.flying_speed;
// FireworkRocketItem.use boosts only a gliding player.
motion.fall_flying = g.fall_flying;
// A player frozen for a hand-over takes no damage (`Abilities.invulnerable`, which the
// void and `/kill` still pass), so its record stays true until the release.
motion.invulnerable = motion.may_fly || g.handover.is_some();
motion.invulnerable = mode_flies || g.handover.is_some();
// `ServerPlayer.isInvulnerableTo`'s connection term, as of now.
motion.client_loaded = g.client_loaded();
let _ = motion.set_health(g.health, false);
@@ -519,6 +542,7 @@ impl Game<'_> {
self.pitch = g.pitch;
std::mem::swap(&mut self.inventory, &mut g.inventory);
std::mem::swap(&mut self.armor, &mut g.armor);
std::mem::swap(&mut self.location_armor, &mut g.location_armor);
std::mem::swap(&mut self.offhand, &mut g.offhand);
std::mem::swap(&mut self.carried, &mut g.carried);
let selected = std::mem::replace(&mut self.selected, g.selected);
@@ -620,6 +644,8 @@ impl Game<'_> {
self.lan_acting_permission.replace(g.permission),
self.lan_acting_entity.replace(g.entity_id as u32),
);
// The damage hooks name the guest by UUID from here on.
super::native_damage::note_player(g.entity_id, g.uuid);
let packets = std::mem::take(&mut self.guest_packets);
let entity_events = std::mem::take(&mut self.guest_entity_events);
let equipment_breaks = std::mem::take(&mut self.guest_equipment_breaks);
@@ -1021,6 +1047,7 @@ impl Game<'_> {
g.selected = std::mem::replace(&mut self.selected, selected);
std::mem::swap(&mut self.inventory, &mut g.inventory);
std::mem::swap(&mut self.armor, &mut g.armor);
std::mem::swap(&mut self.location_armor, &mut g.location_armor);
std::mem::swap(&mut self.offhand, &mut g.offhand);
std::mem::swap(&mut self.carried, &mut g.carried);
// A teleport with a rotation (commands) turns the guest. `/rotate`
@@ -1074,7 +1101,15 @@ impl Game<'_> {
passengers: Vec::new(),
}));
}
// What moved them in their turn, for `native_player_teleport`.
let cause = horizon_client::lan::hub::teleport_cause(None);
if g.vehicle.is_none() && (moved > 0.0001 || turned || teleported) {
let other = if left_vehicle.is_some() {
"dismount"
} else {
"unknown"
};
horizon_client::lan::hub::teleport_cause(Some(cause.unwrap_or(other)));
host.hub.teleport(i, Some(at));
} else if teleported {
// ServerPlayer.startRiding and an asPassenger transition also
@@ -1149,6 +1184,10 @@ impl Game<'_> {
if let Some(mob) = guest_mount {
self.lan_open_mount(host, conn, mob);
}
// A use a mod canceled: the client's prediction of it is taken back.
if std::mem::take(&mut self.guest_inventory_resend) {
host.hub.send_inventory(i);
}
// The turn's teleports are in the hub now: the mods hear them.
self.flush_teleport_notes(host);
// An inner turn may move, kill or change a player's mode. Once its
@@ -1654,6 +1693,8 @@ impl Game<'_> {
}
host.hub.container_closed(conn, window);
}
// A mod's menu with input slots gives them back (`clearContainer`).
self.native_menu_returned(host, conn, removal);
self.lan_merchant_closed(host, conn, None);
self.lan_crafting_removed(host, conn, None, removal);
if removal == MenuRemoval::Disconnected {
@@ -1806,19 +1847,7 @@ impl Game<'_> {
if self.guest_menu_still_valid(host, conn) {
return;
}
let mut windows: Vec<i32> = host
.hub
.guest(conn)
.and_then(|g| g.menu.as_ref().map(|m| m.window))
.into_iter()
.collect();
if let Some(p) = host.play.get(&conn) {
windows.extend(p.crafting.table.as_ref().map(|t| t.0));
windows.extend(p.station.as_ref().map(|s| s.window));
windows.extend(p.lectern.as_ref().map(|l| l.window));
windows.extend(p.merchant.as_ref().map(|m| m.window));
windows.extend(p.mount_window.as_ref().map(|m| m.window));
}
let windows = guest_open_windows(host, conn);
self.guest_close_all(host, conn);
for container in windows {
host.hub
@@ -1826,6 +1855,76 @@ impl Game<'_> {
}
}
/// The mods hear a guest's click in their own inventory or a vanilla
/// menu they have open (`native_inventory_click`, and a drag's end
/// `native_inventory_drag`) before any handler does. A canceled click
/// becomes a drag start of no type, which every menu takes as
/// `resetQuickCraft` and nothing else, so it moves nothing and the
/// client's predicted slots and cursor are answered as for any click the
/// server refused.
fn lan_inventory_click_hooks(
&mut self,
host: &mut LanHost,
conn: u32,
p: &mut play::ContainerClick,
) {
let Some(g) = host.hub.guest(conn).filter(|g| !g.spectator()) else {
return;
};
// A mod's own menu is `native_menu_clicked`'s.
if g.menu
.as_ref()
.is_some_and(|m| m.window == p.container && m.slots == Slots::Native)
|| (p.container != 0 && !guest_open_windows(host, conn).contains(&p.container))
{
return;
}
let (uuid, name) = (g.uuid, g.name.clone());
let play = host.play.entry(conn).or_default();
let mut cancel = false;
if p.input == 5 {
// A drag is heard once, at its end, with the slots it went over.
match p.button & 3 {
0 => play.drag_heard = Some(Vec::new()),
1 => {
let slot = i32::from(p.slot);
if let Some(slots) = play.drag_heard.as_mut()
&& !slots.contains(&slot)
{
slots.push(slot);
}
}
_ => {
if let Some(slots) = play.drag_heard.take() {
let kind = i32::from(p.button >> 2) & 3;
self.native_inventory_drag(
uuid,
&name,
p.container,
kind,
&slots,
&mut cancel,
);
}
}
}
} else {
play.drag_heard = None;
self.native_inventory_click(
uuid,
&name,
p.container,
i32::from(p.slot),
i32::from(p.button),
p.input,
&mut cancel,
);
}
if cancel {
(p.slot, p.button, p.input) = (-999, 3 << 2, 5);
}
}
/// `ContainerEntity.isChestVehicleStillValid`: the chest minecart or chest
/// boat is still there and within the guest's entity interaction range
/// plus 4 of its box.
@@ -1952,6 +2051,27 @@ impl Game<'_> {
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
return;
};
// Plugin channels a client registers in play (minecraft:register), from a dead player
// too; the packet goes on as before.
if let S::CustomPayload(p) = &packet
&& let Some(register) = horizon_client::lan::channel_registration(&p.channel)
{
self.guest_channels(host, gi, &p.data, register);
}
// A plugin channel's message on a channel that isn't one of Horizon's own (the match below
// takes those) is for the mods, from a dead player too: vanilla's handleCustomPayload doesn't
// look at health.
let packet = match packet {
S::CustomPayload(p)
if p.channel != horizon_protocol::quiet::CHANNEL
&& p.channel != horizon_protocol::mod_net::CHANNEL
&& p.channel != horizon_client::lod_net::CHANNEL =>
{
self.guest_custom_payload(host, conn, p.channel, p.data);
return;
}
packet => packet,
};
// A dead player acts no more, but the death screen still respawns and chats: its
// commands run as anyone's (ServerGamePacketListenerImpl.handleChatCommand doesn't
// look at the player's health).
@@ -1976,6 +2096,13 @@ impl Game<'_> {
) {
self.guest_validate_menu(host, conn);
}
let mut packet = packet;
if let S::ContainerClick(p) = &mut packet {
self.lan_inventory_click_hooks(host, conn, p);
}
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
return;
};
let spectator = host.hub.guests[gi].spectator();
match packet {
S::PlayerAction(a) => match a.action {
@@ -2300,6 +2427,9 @@ impl Game<'_> {
.border
.contains(f64::from(p.pos[0]), f64::from(p.pos[2]))
{
if spectator && self.spectator_use_portal(host, conn, gi, p.pos) {
return;
}
let logged = self.world.block_log.as_ref().map_or(0, Vec::len);
let heard = self.audio.capture.as_ref().map_or(0, Vec::len);
let used = self.as_guest(host, conn, |g| {
@@ -2307,6 +2437,7 @@ impl Game<'_> {
g.forced_hit = Some(hit);
g.guest_use = Some(GuestUse::OnBlock(hand));
let swings = g.swings_started;
let predicted = g.predicted_swings;
// InteractionResult.consumesAction: a FAIL (`use_failed`,
// as BlockItem.place's failed placement) does not count,
// even though the click ended on it.
@@ -2324,7 +2455,8 @@ impl Game<'_> {
reset_use_attack_strength(&mut g.attack_ticks, swings, g.swings_started);
g.forced_hit = None;
g.guest_use = None;
(g.swings_started != swings, consumed, attempt)
let echo = g.swings_started != swings && g.predicted_swings == predicted;
(echo, consumed, attempt)
});
let swung = used.map(|u| u.0);
self.lan_swing_back(host, conn, swung);
@@ -2551,6 +2683,7 @@ impl Game<'_> {
S::ResourcePack(r) => {
let (uuid, name) = (host.hub.guests[gi].uuid, host.hub.guests[gi].name.clone());
self.as_guest(host, conn, |g| {
g.native_resource_pack_status_v2(uuid, &name, r.id, r.action);
g.native_resource_pack_status(uuid, &name, r.action);
});
}
@@ -2606,6 +2739,8 @@ impl Game<'_> {
}
}
S::ContainerClick(p) => {
// A mod's menu on an away player's file: read before the click.
let away = self.away_menu_click_start(host, gi, p.container);
let rules = ItemRules(world_items!(self));
let slots = host.hub.guests[gi]
.menu
@@ -2614,6 +2749,10 @@ impl Game<'_> {
.map(|m| m.slots);
let before = slots.and_then(|s| s.read(&self.world, &host.hub.guests[gi]));
let drops = host.hub.container_click(conn, &p, &mut self.world, &rules);
let drops = match away {
Some(click) => self.away_menu_click_end(host, gi, click, drops),
None => drops,
};
// A click that changed the container's slots: BlockEntity.setChanged,
// so comparators read it again (a double chest's other half follows).
if let Some(Slots::Block(key) | Slots::Double(key, _)) = slots
@@ -2650,6 +2789,7 @@ impl Game<'_> {
self.close_guest_vehicle_menu(host, conn, key);
}
host.hub.container_closed(conn, p.container);
self.native_menu_returned(host, conn, MenuRemoval::Live);
self.guest_carried_back(host, gi);
}
S::ChatCommand(c) => self.guest_chat_command(host, conn, &c.command),
@@ -2952,7 +3092,10 @@ impl Game<'_> {
let (item, count) = stack.map_or(("minecraft:air", 0), |s| (&*s.item, s.count as i32));
let mut cancel = false;
let mut hook = |game: &mut Self| {
game.native_creative_slot(uuid, &name, slot, item, count, &mut cancel)
game.native_creative_slot_v2(uuid, &name, slot, stack, &mut cancel);
if !cancel {
game.native_creative_slot(uuid, &name, slot, item, count, &mut cancel);
}
};
// The guest whose turn it is is in place already.
if self.lan_acting == Some(conn) {
@@ -3019,6 +3162,7 @@ impl Game<'_> {
at,
rotation: Some([yaw, pitch]),
vehicle: None,
cause: Some("spectate"),
});
return;
}
@@ -3027,6 +3171,7 @@ impl Game<'_> {
// A new body there: no fall distance or motion carried over, but the
// player's attributes (ServerPlayer.teleport keeps the entity).
g.new_body(true);
horizon_client::lan::hub::teleport_cause(Some("spectate"));
host.hub.teleport(gi, Some(at));
}
fn guest_tick_death(&mut self, host: &mut LanHost, gi: usize) {
@@ -3440,12 +3585,24 @@ impl Game<'_> {
self.guest_tempban_command(host, conn, &words);
return;
}
// A native mod's command, for every player its level allows,
// whether the world allows commands or not (game/native_server.rs).
// A native mod's command, for every player its level allows (or,
// for one with a permission node, whom the node lets: asked when it
// runs), whether the world allows commands or not
// (game/native_server.rs).
let integrated = host.hub.config.integrated;
if let Some(level) = Self::native_command_level(host, command.trim_start_matches('/'))
&& let Some(permission) = host.hub.guest(conn).map(|g| g.permission)
&& permission >= level
let line = command.trim_start_matches('/');
// The level this one command runs at, which the mods may change.
let Some((uuid, name, mut permission)) = host
.hub
.guest(conn)
.map(|g| (g.uuid, g.name.clone(), g.permission))
else {
return;
};
self.native_player_command_level(uuid, &name, line, &mut permission);
let permission = permission.min(4);
if let Some(level) = Self::native_command_level(host, line)
&& (permission >= level || Self::native_command_node(host, line).is_some())
{
host.commands.push(GuestCommand {
conn,
@@ -3472,10 +3629,8 @@ impl Game<'_> {
return;
}
// The guest's own level (Commands.performCommand with the player's
// source): an operator's on a dedicated server, never the host's.
let Some(permission) = host.hub.guest(conn).map(|g| g.permission) else {
return;
};
// source): an operator's on a dedicated server, never the host's,
// unless a mod changed it for this command.
host.commands.push(GuestCommand {
conn,
command: command.trim_start_matches('/').to_owned(),
@@ -3503,12 +3658,19 @@ impl Game<'_> {
/// One guest's command as that guest, its feedback sent to them; false
/// when it failed (or the guest is gone).
pub(super) fn run_guest_command(&mut self, c: GuestCommand) -> bool {
let Some(mut host) = self.lan.take() else {
return false;
};
self.run_guest_command_told(c).is_some_and(|(ok, _)| ok)
}
/// `run_guest_command`, with the lines it sent the guest; None when the
/// guest is gone.
pub(super) fn run_guest_command_told(
&mut self,
c: GuestCommand,
) -> Option<(bool, Vec<horizon_client::text::Text>)> {
let mut host = self.lan.take()?;
let Some(swap) = self.enter_guest(&mut host, c.conn, self.dim) else {
self.lan = Some(host);
return false;
return None;
};
self.lan = Some(host);
self.chat_capture = Some(Vec::new());
@@ -3536,7 +3698,7 @@ impl Game<'_> {
}
// What the command earned is announced before its feedback.
self.announce_guest_advancements(&mut host);
for line in lines {
for line in &lines {
host.hub.send_to(
c.conn,
&C::SystemChat(play::SystemChat {
@@ -3548,7 +3710,7 @@ impl Game<'_> {
// The other operators hear of it; never the player whose command it was.
self.send_admin_feedback(&mut host, Some(c.conn));
self.lan = Some(host);
ok
Some((ok, lines))
}
/// The `broadcastToAdmins` lines a command queued (`source`: the guest
@@ -3653,8 +3815,31 @@ impl Game<'_> {
let own_banned_ips = std::mem::replace(&mut reg.banned_ips, banned_ips);
let own_whitelisted = std::mem::replace(&mut reg.whitelisted, whitelisted);
let parse = d.parse(command, &self.ui.registries);
let ((start, end), mut suggestions) =
let ((mut start, mut end), mut suggestions) =
d.suggestions(&parse, command.len(), &self.ui.registries);
let (label, rest) = command.split_once(' ').unwrap_or((command, ""));
let arguments: Vec<String> = if command.contains(' ') {
rest.split(' ').map(str::to_owned).collect()
} else {
Vec::new()
};
// A mod's command, which vanilla's tree doesn't know: the word being typed.
if let Some(typed) = arguments.last()
&& Self::native_command_level(host, command).is_some_and(|l| l <= permission)
{
(start, end) = (command.len() - typed.len(), command.len());
let words: Vec<&str> = arguments.iter().map(String::as_str).collect();
if super::native_server::completes_player_name(
&host.native_usages,
permission,
label,
&words,
) {
let mut names = horizon_client::command::SuggestionsBuilder::new(command, start);
names.suggest_matching(host.hub.guests.iter().map(|g| g.name.as_str()));
suggestions.extend(names.out);
}
}
self.native_tab_complete(
player_uuid,
&player_name,
@@ -3662,6 +3847,14 @@ impl Game<'_> {
[start, end],
&mut suggestions,
);
self.native_tab_complete_v2(
player_uuid,
&player_name,
label,
&arguments,
[start, end],
&mut suggestions,
);
let reg = &mut self.ui.registries;
reg.permission = level;
reg.players = own_players;
@@ -3693,7 +3886,7 @@ impl Game<'_> {
);
}
fn guest_respawn(&mut self, host: &mut LanHost, conn: u32) {
pub(super) fn guest_respawn(&mut self, host: &mut LanHost, conn: u32) {
let Some(i) = host.hub.guests.iter().position(|g| g.conn == conn) else {
return;
};
@@ -3737,11 +3930,11 @@ impl Game<'_> {
.respawn_elsewhere
.as_ref()
.map(RespawnConfig::from_saved);
let elsewhere = own.filter(|_| server);
let mut elsewhere = own.filter(|_| server);
// In the window's world a guest has no level of its own to wait in:
// its bed is resolved at once when its chunk is there, else it
// comes back on the bed.
let in_frame_bed = own.filter(|c| !server && c.dim == super::Dim::Overworld);
let mut in_frame_bed = own.filter(|c| !server && c.dim == super::Dim::Overworld);
let spawn = in_frame_bed.map_or(spawn, |c| {
[
f64::from(c.pos[0]) + 0.5,
@@ -3749,14 +3942,34 @@ impl Game<'_> {
f64::from(c.pos[2]) + 0.5,
]
});
let level = elsewhere.map_or(super::Dim::Overworld, |c| c.dim);
let spawn = elsewhere.map_or(spawn, |c| {
let mut level = elsewhere.map_or(super::Dim::Overworld, |c| c.dim);
let mut spawn = elsewhere.map_or(spawn, |c| {
[
f64::from(c.pos[0]) + 0.5,
f64::from(c.pos[1]),
f64::from(c.pos[2]) + 0.5,
]
});
// PlayerRespawnPositionEvent: a point the mods choose is taken as it is.
let (mut dimension, mut at, mut rotation) = (level.id().to_owned(), spawn, [0.0f32; 2]);
let (uuid, name) = (host.hub.guests[i].uuid, host.hub.guests[i].name.clone());
let [yaw, pitch] = &mut rotation;
self.native_player_respawn_position(uuid, &name, &mut dimension, &mut at, yaw, pitch);
let known = super::Dim::from_id(&dimension).id() == dimension;
let moved = at != spawn && at.iter().all(|v| v.is_finite());
let chosen = (known && dimension != level.id()) || moved;
if chosen {
(elsewhere, in_frame_bed) = (None, None);
if known && server {
level = super::Dim::from_id(&dimension);
}
if moved {
spawn = at;
}
}
if !rotation.iter().all(|v| v.is_finite()) {
rotation = [0.0; 2];
}
let back = self.dim;
let left = super::Dim::from_id(&host.hub.guests[i].dimension);
let away = server && host.hub.guests[i].dimension != level.id();
@@ -3812,7 +4025,7 @@ impl Game<'_> {
border: &self.border,
streaming: Some(&self.streaming),
};
host.hub.respawn(i, spawn, &ctx);
host.hub.respawn(i, spawn, rotation, &ctx);
// ServerGamePacketListenerImpl.handleClientCommand: a hardcore world's
// respawned player only watches.
if self.level.hardcore {
@@ -3831,7 +4044,7 @@ impl Game<'_> {
}
if let Some(config) = elsewhere {
self.respawn_trip(conn, config);
} else if in_frame_bed.is_none() && host.hub.guests[i].spawn.is_none() {
} else if !chosen && in_frame_bed.is_none() && host.hub.guests[i].spawn.is_none() {
// TeleportTransition.createDefault: no point of its own, so the
// world spawn's free column once its chunks have loaded.
self.world_spawn_trip(conn);
@@ -4047,6 +4260,30 @@ impl Game<'_> {
}
}
/// `native_player_logging_out` for guest `conn`, who has left but is still in the hub
/// and in their level (`HostEvent::Left`): the hub goes back into `self.lan` for the
/// hook, so its helpers and commands reach them, and a death it caused (`kill`) is
/// died at once, as they get no tick to die in. None when a hook's command closed the hub.
pub(super) fn tell_mods_logging_out(&mut self, host: LanHost, conn: u32) -> Option<LanHost> {
let Some((uuid, name, alive)) = host
.hub
.guest(conn)
.map(|g| (g.uuid, g.name.clone(), g.health > 0.0 && !g.dead))
else {
return Some(host);
};
self.lan = Some(host);
self.native_player_logging_out(uuid, &name);
let mut host = self.lan.take()?;
if alive
&& let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn)
&& host.hub.guests[gi].health <= 0.0
{
self.guest_die(&mut host, gi, conn);
}
Some(host)
}
/// `ServerPlayer.die` for a guest whose health has run out: the death
/// message, the loot and experience, the death screen.
fn guest_die(&mut self, host: &mut LanHost, gi: usize, conn: u32) {
@@ -5346,9 +5583,10 @@ impl Game<'_> {
let Some(item) = self.dropped.iter().find(|d| d.id == item_id) else {
continue;
};
let stack = item.stack.clone();
let refused =
self.as_guest(host, conn, |g| g.native_pickup_refused(&stack)) == Some(true);
let (stack, thrower, at) = (item.stack.clone(), item.thrower, item.position);
let refused = self
.as_guest(host, conn, |g| g.native_pickup_refused(&stack, thrower, at))
== Some(true);
// The hook can remove or change any item entity.
let Some(i) = self.dropped.iter().position(|d| d.id == item_id) else {
continue;
@@ -5711,10 +5949,10 @@ impl Game<'_> {
}
/// A use the server ran swung the guest's hand: their own client is told
/// too (`swing(hand, true)` for a SwingSource.SERVER result). Horizon's
/// client does not run uses itself, so it does not predict the swing; a
/// client that did (a block placed) is still in the first half of its
/// swing and ignores it (`SwingState.startIfAble`).
/// too (`swing(hand, true)` for a result that is not SwingSource.PREDICTED).
/// A predicted swing (a block placed, a block's own SUCCESS) is the
/// client's own: sent back, it arrived after the first half of that swing
/// on a slow connection and swung the arm again (#9887).
fn lan_swing_back(&mut self, host: &mut LanHost, conn: u32, swung: Option<bool>) {
if swung != Some(true) {
return;
@@ -6208,6 +6446,7 @@ mod respawn_world_point_tests {
latency: Arc::new(AtomicI32::new(0)),
address: "127.0.0.1:25565".parse().unwrap(),
expected: false,
configured: Default::default(),
},
2,
[0.5, 100.0, 0.5],
@@ -6260,4 +6499,283 @@ mod respawn_world_point_tests {
drop(game);
std::fs::remove_dir_all(scratch).unwrap();
}
/// A mod's health 0 for a guest dies as `/kill` does: the death message
/// and the death screen, not only a zero in the record.
#[test]
#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
fn a_mods_zero_health_kills_a_guest_as_kill_does() {
let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
let settings = Settings::default();
let loaded = load_resources(
root.clone(),
None,
&root,
&settings,
std::time::Instant::now(),
false,
true,
&Progress::new(),
&mut |_, _| unreachable!(),
)
.unwrap();
let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
options.resources = root.clone();
options.execution_role = crate::game::execution_role::ExecutionRole::IntegratedServer;
let mut game = Game::new(
&loaded.resources,
loaded.pack,
loaded.gui.unwrap(),
options,
settings,
Audio::silent(&root),
None,
)
.unwrap();
let scratch = std::env::temp_dir().join(format!(
"horizon-status-death-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
std::fs::create_dir_all(&scratch).unwrap();
game.world_root = scratch.clone();
game.level.world_spawn = Some([0, 100, 0]);
game.spawn = Some(Vec3::new(0.5, 100.0, 0.5));
game.lan_host(
super::super::lan::LanSettings {
port: 0,
guest_commands: true,
force_game_mode: false,
},
NetConfig {
announce: false,
..NetConfig::loopback(0, "status-death-test".into(), 2)
},
HubConfig {
default_game_mode: 0,
guest_commands: true,
force_game_mode: false,
hardcore: false,
view_distance: 2,
simulation_distance: 2,
dimension: "minecraft:overworld".into(),
allow_flight: false,
seed: 0,
max_players: 2,
integrated: false,
levels: Default::default(),
},
)
.unwrap();
let (tx, _rx) = mpsc::channel();
let mut guest = Guest::new(
Joined {
conn: 2,
uuid: 331,
name: "StatusGuest".into(),
properties: Vec::new(),
info: ClientInformation::new(2),
brand: "test".into(),
sender: PlayerSender::new(tx, Arc::default()),
latency: Arc::new(AtomicI32::new(0)),
address: "127.0.0.1:25565".parse().unwrap(),
expected: false,
configured: Default::default(),
},
2,
[0.5, 100.0, 0.5],
2,
);
guest.dimension = "minecraft:overworld".into();
guest.placed = true;
guest.loaded = true;
let mut host = game.lan.take().unwrap();
host.hub.guests.push(guest);
// Inside the player's own turn, as a tick hook sets it.
let set = game.as_guest(&mut host, 2, |g| {
g.native_set_player_status(331, Some(0.0), None, None)
});
assert_eq!(set, Some(true));
assert_eq!(host.hub.guests[0].health, 0.0);
game.guest_die(&mut host, 0, 2);
assert!(host.hub.guests[0].dead, "health 0 must kill");
drop(host);
drop(game);
std::fs::remove_dir_all(scratch).unwrap();
}
}
#[cfg(test)]
mod swing_echo_tests {
use super::ItemStack;
use crate::game::{Audio, Game, Options, Progress, Settings, load_resources};
use horizon_client::chunk::Chunk;
use horizon_client::lan::{Joined, NetConfig, Out, PlayerSender, guest::Guest, hub::HubConfig};
use horizon_core::position::ChunkPos;
use horizon_protocol::packets::{
configuration::ClientInformation,
play::{self, Clientbound, Serverbound},
};
use std::sync::{Arc, atomic::AtomicI32, mpsc};
/// handleUseItemOn swings the player's arm, but sends the swing to the
/// player's own client only when the client did not predict it: a block
/// placed (SUCCESS) is the client's own swing, a bed's use
/// (SUCCESS_SERVER) is not (#9887).
#[test]
#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
fn only_a_server_only_use_swings_back_to_the_player() {
let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
let settings = Settings::default();
let loaded = load_resources(
root.clone(),
None,
&root,
&settings,
std::time::Instant::now(),
false,
true,
&Progress::new(),
&mut |_, _| unreachable!(),
)
.unwrap();
let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
options.resources = root.clone();
options.game_dir = Some(
std::env::temp_dir().join(format!("horizon-swing-echo-unit-{}", std::process::id())),
);
options.execution_role = crate::game::execution_role::ExecutionRole::IntegratedServer;
let mut game = Game::new(
&loaded.resources,
loaded.pack,
loaded.gui.unwrap(),
options,
settings,
Audio::silent(&root),
None,
)
.unwrap();
game.build_registries();
game.set_allow_commands(true);
let stone = game
.pack
.assets
.registry
.default_state("minecraft:stone")
.unwrap()
.0;
let mut chunk = Chunk::empty(0, 0);
for x in 0..16 {
for z in 0..16 {
chunk.set(x, 199, z, stone);
}
}
game.world.chunks.insert((0, 0), Arc::new(chunk));
game.block_ticks
.add_empty_chunk(ChunkPos::new(0, 0))
.unwrap();
assert!(game.run_command("forceload add 0 0"));
assert!(game.run_command("setblock 6 200 4 red_bed[facing=north,part=foot]"));
assert!(game.run_command("setblock 6 200 3 red_bed[facing=north,part=head]"));
game.lan_host(
super::super::lan::LanSettings {
port: 0,
guest_commands: true,
force_game_mode: false,
},
NetConfig {
announce: false,
..NetConfig::loopback(0, "swing-echo-test".into(), 2)
},
HubConfig {
default_game_mode: 0,
guest_commands: true,
force_game_mode: false,
hardcore: false,
view_distance: 2,
simulation_distance: 2,
dimension: "minecraft:overworld".into(),
allow_flight: false,
seed: 0,
max_players: 2,
integrated: false,
levels: Default::default(),
},
)
.unwrap();
let (tx, rx) = mpsc::channel();
let mut guest = Guest::new(
Joined {
conn: 2,
uuid: 331,
name: "SwingGuest".into(),
properties: Vec::new(),
info: ClientInformation::new(2),
brand: "test".into(),
sender: PlayerSender::new(tx, Arc::default()),
latency: Arc::new(AtomicI32::new(0)),
address: "127.0.0.1:25565".parse().unwrap(),
expected: false,
configured: Default::default(),
},
2,
[4.5, 200.0, 4.5],
2,
);
guest.dimension = "minecraft:overworld".into();
guest.placed = true;
guest.loaded = true;
guest.inventory[0] = Some(ItemStack::new("minecraft:stone", 16));
guest.selected = 0;
let mut host = game.lan.take().unwrap();
host.hub.guests.push(guest);
let id = host.hub.guests[0].entity_id;
let swings_back = || {
let mut n = 0;
for out in rx.try_iter() {
let bodies = match out {
Out::Packet(body) => vec![body],
Out::Packets(bodies) => bodies,
Out::Disconnect(_) => panic!("unexpected disconnect"),
};
for body in bodies {
let mut r = horizon_protocol::buf::Reader::new(&body);
let packet_id = r.varint().unwrap();
if let Ok(Clientbound::SwingAnimation(p)) =
Clientbound::decode(packet_id, r.rest())
&& p.id == id
{
n += 1;
}
}
}
n
};
let use_on = |pos: [i32; 3], cursor: [f32; 3], sequence: i32| {
Serverbound::UseItemOn(play::UseItemOn {
hand: 0,
pos,
face: 1,
cursor,
inside: false,
world_border: false,
sequence,
})
};
// BlockItem.place: SUCCESS, the client's own swing.
game.lan_guest_packet(&mut host, 2, use_on([4, 199, 6], [0.5, 1.0, 0.5], 1));
assert_eq!(game.world.block(4, 200, 6).0, stone, "the stone is placed");
assert_eq!(swings_back(), 0, "a placement is not swung back");
// The swing ends before the next use can start one.
for _ in 0..8 {
game.lan_swings(&mut host);
}
host.hub.guests[0].selected = 1;
// BedBlock.useWithoutItem: SUCCESS_SERVER, the server's swing only.
game.lan_guest_packet(&mut host, 2, use_on([6, 200, 4], [0.5, 0.5625, 0.5], 2));
assert_eq!(swings_back(), 1, "a bed's use is swung back");
}
}
crates/horizon-client/src/game/lan_crafting.rs
+17 -6
View File
@@ -125,16 +125,27 @@ impl Game<'_> {
menu: &mut Menu,
op: impl FnOnce(&mut Menu, &Env) -> R,
) -> R {
// The cartography table reads and makes the host level's maps.
let maps = (menu.kind() == Kind::Cartography).then(|| {
// Crafting and cartography read and derive this level's saved maps.
let maps = matches!(
menu.kind(),
Kind::Cartography | Kind::Crafting | Kind::Inventory
)
.then(|| {
let g = &host.hub.guests[gi];
let held: Vec<ItemStack> = (0..menu.slot_count())
(0..menu.slot_count())
.filter_map(|s| menu.slot(s).cloned())
.chain(g.inventory.iter().flatten().cloned())
.chain(g.carried.clone())
.collect();
self.level_maps(&held)
});
.collect::<Vec<_>>()
})
.filter(|held| {
menu.kind() == Kind::Cartography
|| held
.iter()
.filter_map(super::maps::map_id)
.any(|id| self.map(id).is_some())
})
.map(|held| self.level_maps(&held));
let env = Env {
maps: maps.as_ref().map(|m| m as &dyn horizon_client::menu::Maps),
limited_crafting: host.hub.limited_crafting,
crates/horizon-client/src/game/lan_entities.rs
+12 -4
View File
@@ -6,6 +6,7 @@
use super::Game;
use horizon_client::lan::{
entity::{EntityState, Riding, States},
guest::Guest,
hub::Hub,
playerdata::ints_uuid,
};
@@ -157,10 +158,17 @@ impl Game<'_> {
/// Who rides what (`Entity.getPassengers`): the players in their vehicles and
/// mobs on mobs.
pub(super) fn lan_riding(&self, guests: &[(u32, i32)], riding: &mut Riding) {
pub(super) fn lan_riding(&self, guests: &[Guest], riding: &mut Riding) {
riding.clear();
// The server's players in their boats and minecarts.
for &(vehicle, guest) in guests {
// The server's players in their boats and minecarts, in the order they
// got in: the first one drives (`getControllingPassenger`), and its
// client is the one that moves the vehicle.
let mut seated: Vec<(u64, u32, i32)> = guests
.iter()
.filter_map(|g| Some((g.vehicle_order, g.vehicle?, g.entity_id)))
.collect();
seated.sort_by_key(|&(order, ..)| order);
for (_, vehicle, guest) in seated {
riding.add(vehicle as i32, guest);
}
for m in self.mobs.iter().filter(|m| !m.removed) {
@@ -462,7 +470,7 @@ impl Game<'_> {
/// The synched data of a text, block or item display kept unsimulated,
/// from its compound (`Display.readAdditionalSaveData`), with the
/// defaults to send when a value goes back to one.
fn lan_display_data(&self, tag: &Tag, hub: &mut Hub, e: &mut EntityState) {
pub(super) fn lan_display_data(&self, tag: &Tag, hub: &mut Hub, e: &mut EntityState) {
use horizon_client::text_display::{display_data, text_display_data};
let empty = Tag::Compound(Default::default());
let (meta, defaults) = match e.kind.as_str() {
crates/horizon-client/src/game/lan_mobs.rs
+20
View File
@@ -159,6 +159,26 @@ fn guest_view(mut v: PlayerView, uuid: u128, moved: [f64; 3]) -> PlayerView {
}
impl Game<'_> {
/// How mobs see the guest `conn`, as `lan_guest_views` gives each: None
/// for no such guest in play here, or while the hub is taken out.
pub(super) fn lan_guest_view(&mut self, conn: u32) -> Option<PlayerView> {
let mut host = self.lan.take()?;
let found = host
.hub
.guests
.iter()
.find(|g| g.conn == conn && host.hub.here(g) && g.loaded && !g.dead)
.map(|g| {
let moved = [0, 1, 2].map(|k| g.position[k] - g.previous_position[k]);
(g.uuid, moved)
});
let view = found.and_then(|(uuid, moved)| {
let v = self.as_guest(&mut host, conn, |g| g.player_view())??;
Some(guest_view(v, uuid, moved))
});
self.lan = Some(host);
view
}
/// How mobs see each guest in play (`player_view` with the guest swapped
/// in).
pub(super) fn lan_guest_views(&mut self) -> GuestViews {
crates/horizon-client/src/game/lan_particles.rs
+1
View File
@@ -978,6 +978,7 @@ mod tests {
latency: std::sync::Arc::new(std::sync::atomic::AtomicI32::new(0)),
address: format!("127.0.0.1:{}", 25565 + conn).parse().unwrap(),
expected: false,
configured: Default::default(),
},
1,
at,
crates/horizon-client/src/game/lan_pvp.rs
+113 -2
View File
@@ -30,6 +30,42 @@ pub(super) fn meets_players(kind: &ProjectileKind) -> bool {
)
}
/// The player-versus-player hit being landed, which `native_player_hurt_by_player`
/// hears at the victim's `hurtServer` (`native_hooks::hurt_server`).
#[derive(Clone, Copy)]
pub(super) struct PvpHit {
pub(super) attacker: u128,
pub(super) attacker_entity: i32,
pub(super) victim: u128,
pub(super) victim_entity: i32,
/// `melee`, `sweep` or the projectile's entity type.
pub(super) source: &'static str,
}
thread_local! {
static PVP_HIT: std::cell::Cell<Option<PvpHit>> = const { std::cell::Cell::new(None) };
}
/// The hit being landed on the player `victim_entity`, if one is.
pub(super) fn pvp_hit(victim_entity: i32) -> Option<PvpHit> {
PVP_HIT
.get()
.filter(|hit| hit.victim_entity == victim_entity)
}
/// Names `hit` as the one being landed until it drops.
struct PvpScope(Option<PvpHit>);
impl Drop for PvpScope {
fn drop(&mut self) {
PVP_HIT.set(self.0);
}
}
fn pvp_scope(hit: Option<PvpHit>) -> PvpScope {
PvpScope(PVP_HIT.replace(hit))
}
/// Who a player's attack lands on: a player by connection.
#[derive(Clone, Copy, PartialEq, Eq)]
pub(super) enum Victim {
@@ -259,10 +295,25 @@ impl Game<'_> {
at,
};
let shooter = self.player_attacker(&host, p.guest);
let spectral = p
.arrow
.as_ref()
.is_some_and(|a| a.spectral || &*a.pickup_item.item == "minecraft:spectral_arrow");
let source = if spectral {
"minecraft:spectral_arrow"
} else {
p.kind.id()
};
let hit = self.pvp_hit_of(&host, p.guest, victim, source);
let zero = matches!(p.kind, ProjectileKind::Snowball | ProjectileKind::Egg);
let result = match victim {
Victim::Guest(conn) => self.guest_hit_by(&mut host, conn, |g| {
g.combat.refuse_player_hit = refused;
g.combat.projectile_attacker = shooter;
let _hit = pvp_scope(hit);
if zero && !refused {
g.pvp_zero_hurt(hit, "minecraft:thrown");
}
let r = g.projectile_hit(p, on_player);
g.combat.refuse_player_hit = false;
g.combat.projectile_attacker = None;
@@ -273,6 +324,58 @@ impl Game<'_> {
result.unwrap_or(Ok(()))
}
/// The hit of `attacker` (a guest; none: this game's player) on `victim` as
/// `native_player_hurt_by_player` names it, none when either has gone.
fn pvp_hit_of(
&mut self,
host: &LanHost,
attacker: Option<u32>,
victim: Victim,
source: &'static str,
) -> Option<PvpHit> {
let Victim::Guest(conn) = victim;
let (victim, victim_entity) = host.hub.guest(conn).map(|g| (g.uuid, g.entity_id))?;
let (attacker, attacker_entity) = match attacker {
Some(conn) => host.hub.guest(conn).map(|g| (g.uuid, g.entity_id))?,
None => (self.native_acting_id(), self.player.as_ref()?.entity_id),
};
Some(PvpHit {
attacker,
attacker_entity,
victim,
victim_entity,
source,
})
}
/// `Player.hurtServer` of a snowball's or egg's zero damage on the player in place: past
/// its guards (not creative, a spectator or dead) the mods hear it, then it stops on zero.
fn pvp_zero_hurt(&mut self, hit: Option<PvpHit>, damage_type: &str) {
let Some(hit) = hit else {
return;
};
if self.creative
|| self.spectator()
|| self
.player
.as_ref()
.is_none_or(|p| p.health.dead_or_dying())
{
return;
}
let (mut amount, mut canceled) = (0.0, false);
Self::native_player_hurt_by_player(
hit.attacker,
hit.attacker_entity,
hit.victim,
hit.victim_entity,
hit.source,
damage_type,
&mut amount,
&mut canceled,
);
}
pub(super) fn player_attacker(&self, host: &LanHost, conn: Option<u32>) -> Option<(u32, Text)> {
match conn {
Some(conn) => {
@@ -314,6 +417,7 @@ impl Game<'_> {
.map(|a| (a.entity_id, self.player_text(&a.name, a.uuid)))
});
let attacker_id = self.player.as_ref().map_or(0, |p| p.entity_id);
let hit = self.pvp_hit_of(host, s.attacker, victim, "melee");
let land = |g: &mut Self| {
let _attacker =
g.knockback_scope(attacker_note.as_ref().map_or(attacker_id, |(id, _)| *id));
@@ -321,7 +425,10 @@ impl Game<'_> {
if let Some((id, name)) = attacker_note.clone() {
g.note_player_attacker("minecraft:player_attack", id as u32, name, s.item.clone());
}
let hurt = g.mob_hits_player(s.amount, s.from, "minecraft:player_attack");
let hurt = {
let _hit = pvp_scope(hit);
g.mob_hits_player(s.amount, s.from, "minecraft:player_attack")
};
g.combat.player_attacker = None;
let (strength, xd, zd) = s.knockback;
if hurt && strength > 0.0 {
@@ -537,8 +644,12 @@ impl Game<'_> {
{
continue;
}
let hit = self.pvp_hit_of(host, sweep.attacker, victim, "sweep");
let Victim::Guest(conn) = victim;
self.guest_struck_by(host, conn, land);
self.guest_struck_by(host, conn, |g| {
let _hit = pvp_scope(hit);
land(g)
});
}
}
}
crates/horizon-client/src/game/lan_trading.rs
+39
View File
@@ -36,6 +36,36 @@ fn uuid_words(uuid: u128) -> [i32; 4] {
}
impl Game<'_> {
/// Development oracle: observe the actual open guest merchant, never a synthetic menu.
pub(super) fn harness_merchant(
&self,
host: &LanHost,
conn: u32,
) -> Option<(i32, i32, serde_json::Value)> {
use serde_json::json;
let gm = host.play.get(&conn)?.merchant.as_ref()?;
let guest = host
.hub
.guests
.iter()
.find(|g| g.conn == conn && g.placed)?;
let id = gm.merchant.mob?;
self.mobs
.iter()
.find(|m| m.id == id && m.alive() && !m.removed)?;
let stack = |s: &Option<ItemStack>| s.as_ref().map(|s| json!([s.item.as_ref(), s.count]));
let session = &gm.merchant.session;
Some((
gm.window,
gm.state,
json!({"window":gm.window,"merchant":self.persist.uuids.get(&id)?,
"player":uuid_words(guest.uuid),"slots":gm.slots.iter().map(stack).collect::<Vec<_>>(),
"carried":stack(&guest.carried),"xp":session.xp,
"offers":session.offers.iter().map(|o|json!({"uses":o.uses,
"special":o.special_price_diff,"cost":o.cost_a_count(self.items())})).collect::<Vec<_>>()}),
))
}
/// A trading screen the guest's interaction opened (it opened as a
/// station while the guest acted): handed to the guest.
pub(super) fn lan_open_merchant(
@@ -271,6 +301,7 @@ impl Game<'_> {
let made = maps.made.take();
let session = menu.merchant.take().expect("attached");
let dropped = std::mem::take(&mut menu.dropped);
let crafted_counts = std::mem::take(&mut menu.crafted_counts);
gm.slots = [
menu.slot(0).cloned(),
menu.slot(1).cloned(),
@@ -285,6 +316,14 @@ impl Game<'_> {
g.carried = menu.carried.take();
}
self.register_exploration_maps(made);
// MerchantResultSlot checks achievements before notifying the merchant.
if !crafted_counts.is_empty() {
self.as_guest(host, conn, |g| {
for (item, count) in crafted_counts {
g.award_stat("crafted", &item, count);
}
});
}
let (session, traded) = self.merchant_apply(session, gm.merchant.mob);
gm.merchant.session = session;
if !traded.is_empty() {
crates/horizon-client/src/game/lan_vehicles.rs
+246 -23
View File
@@ -38,11 +38,13 @@ fn corners(b: Aabb) -> ([f64; 3], [f64; 3]) {
([lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z])
}
/// A boat or minecart a server player rode, followed for
/// `native_vehicle_moved`.
/// A boat, minecart or mount a server player rode, followed for
/// `native_vehicle_moved` (a mount only for its v2).
pub(super) struct WatchedVehicle {
id: u32,
dim: Dim,
/// A mob (a horse, a pig), which v1 does not hear.
mount: bool,
/// The server player it carries now.
rider: Option<u128>,
/// Where the hook last heard of it.
@@ -52,18 +54,25 @@ pub(super) struct WatchedVehicle {
}
impl Game<'_> {
/// Where the boat or minecart `id` of this level is.
fn watched_vehicle_position(&self, id: u32) -> Option<[f64; 3]> {
/// Where the boat, minecart or mount `id` of this level is, and whether
/// it is a mount.
fn watched_vehicle_position(&self, id: u32) -> Option<([f64; 3], bool)> {
let at = |v: Vec3| [v.x, v.y, v.z];
self.boats
.iter()
.find(|b| b.id == id)
.map(|b| at(b.position))
.map(|b| (at(b.position), false))
.or_else(|| {
self.carts
.iter()
.find(|c| c.id == id)
.map(|c| at(c.position))
.map(|c| (at(c.position), false))
})
.or_else(|| {
self.mobs
.iter()
.find(|m| m.id == id && !m.removed)
.map(|m| (at(m.position), true))
})
}
@@ -82,7 +91,7 @@ impl Game<'_> {
}
let dim = self.dim;
for &(id, _, uuid) in &riders {
let Some(at) = self.watched_vehicle_position(id) else {
let Some((at, mount)) = self.watched_vehicle_position(id) else {
continue;
};
match self.watched_vehicles.iter_mut().find(|w| w.id == id) {
@@ -90,6 +99,7 @@ impl Game<'_> {
None => self.watched_vehicles.push(WatchedVehicle {
id,
dim,
mount,
rider: Some(uuid),
at,
still: 0,
@@ -97,7 +107,7 @@ impl Game<'_> {
}
}
let mut kept = Vec::new();
// (rider's connection and UUID, vehicle type, from, to)
// (rider's connection and UUID, vehicle, type, mount, from, to)
let mut moved = Vec::new();
for mut w in std::mem::take(&mut self.watched_vehicles) {
// Another level's vehicle is told of on that level's tick.
@@ -106,7 +116,7 @@ impl Game<'_> {
continue;
}
// Broken, or gone from this level.
let Some(now) = self.watched_vehicle_position(w.id) else {
let Some((now, _)) = self.watched_vehicle_position(w.id) else {
continue;
};
let rider = riders.iter().find(|r| r.0 == w.id);
@@ -118,7 +128,7 @@ impl Game<'_> {
self.level_entity(w.id as i32)
.unwrap_or(super::commands::Target::Boat(w.id)),
);
moved.push((rider.map(|r| (r.1, r.2)), kind, from, now));
moved.push((rider.map(|r| (r.1, r.2)), w.id, kind, w.mount, from, now));
} else {
w.still += 1;
if w.rider.is_none() && w.still > 200 {
@@ -130,21 +140,66 @@ impl Game<'_> {
self.watched_vehicles = kept;
// The rider's state is swapped in for the call, so the helpers reach
// them; a vehicle nobody rides is told of with nobody swapped in.
for (rider, kind, from, to) in moved {
let Some((conn, uuid)) = rider else {
self.native_vehicle_moved(None, &kind, from, to);
continue;
for (rider, id, kind, mount, from, to) in moved {
let (mut dest, mut cancel) = (to, false);
let mut hook = |game: &mut Self| {
if !mount {
game.native_vehicle_moved(rider.map(|r| r.1), &kind, from, to);
}
let player = rider.map(|r| r.1);
game.native_vehicle_moved_v2(
player,
dim.id(),
id,
&kind,
from,
&mut dest,
&mut cancel,
);
};
let Some(mut host) = self.lan.take() else {
continue;
};
let hook = |game: &mut Self| game.native_vehicle_moved(Some(uuid), &kind, from, to);
if self.lan_acting == Some(conn) {
hook(self);
} else {
self.as_guest(&mut host, conn, hook);
match rider {
None => hook(self),
Some((conn, _)) => {
let Some(mut host) = self.lan.take() else {
continue;
};
if self.lan_acting == Some(conn) {
hook(self);
} else {
self.as_guest(&mut host, conn, hook);
}
self.lan = Some(host);
}
}
self.lan = Some(host);
self.native_vehicle_move_answer(id, from, to, dest, cancel);
}
}
/// `native_vehicle_moved_v2`'s answer: a canceled move puts the vehicle
/// back at `from`, a changed `to` puts it there, with its riders
/// (`native_teleport_vehicle`), and the watch hears it from there.
fn native_vehicle_move_answer(
&mut self,
id: u32,
from: [f64; 3],
to: [f64; 3],
dest: [f64; 3],
cancel: bool,
) {
let at = if cancel {
from
} else if dest != to && dest.iter().all(|v| v.is_finite()) {
dest
} else {
return;
};
if !self.native_teleport_vehicle(self.dim.id(), id, at) {
return;
}
if let Some((now, _)) = self.watched_vehicle_position(id)
&& let Some(w) = self.watched_vehicles.iter_mut().find(|w| w.id == id)
{
w.at = now;
}
}
@@ -387,6 +442,13 @@ impl Game<'_> {
if g.awaiting_teleport.is_some() || !g.client_loaded() {
return;
}
// Only the vehicle's controlling passenger moves it: the move of a
// player in a boat's second seat is ignored (#11541).
if g.vehicle
.is_some_and(|v| !self.guest_controls_vehicle(host, conn, v))
{
return;
}
let owner = host.hub.singleplayer_owner == Some(g.uuid);
let (vehicle, good) = (g.vehicle, g.vehicle_good);
let back = |host: &mut LanHost, position: Vec3, yaw: f32| {
@@ -563,3 +625,164 @@ impl Game<'_> {
}
}
}
#[cfg(test)]
mod controller_tests {
use crate::game::{Audio, Game, Options, Progress, Settings, load_resources};
use horizon_client::chunk::Chunk;
use horizon_client::lan::{Joined, NetConfig, PlayerSender, guest::Guest, hub::HubConfig};
use horizon_core::position::ChunkPos;
use horizon_protocol::packets::{configuration::ClientInformation, play};
use std::sync::{Arc, atomic::AtomicI32, mpsc};
fn guest(conn: u32, uuid: u128) -> Guest {
let (tx, _rx) = mpsc::channel();
let mut g = Guest::new(
Joined {
conn,
uuid,
name: format!("Rider{conn}"),
properties: Vec::new(),
info: ClientInformation::new(2),
brand: "test".into(),
sender: PlayerSender::new(tx, Arc::default()),
latency: Arc::new(AtomicI32::new(0)),
address: "127.0.0.1:25565".parse().unwrap(),
expected: false,
configured: Default::default(),
},
1000 + conn as i32,
[4.5, 200.0, 4.5],
2,
);
g.dimension = "minecraft:overworld".into();
g.placed = true;
g.loaded = true;
// PlayerLoaded came in: its moves count.
g.load_timeout = 0;
g
}
/// Two players in one boat: the one that got in first drives it
/// (`getControllingPassenger`), whichever joined the server first. Its
/// client hears it sits first, and only its moves count; the second
/// seat's client, which still sends where it sees the boat, used to put
/// the boat back every tick (#11541).
#[test]
#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
fn the_first_rider_in_drives_the_boat() {
let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
let settings = Settings::default();
let loaded = load_resources(
root.clone(),
None,
&root,
&settings,
std::time::Instant::now(),
false,
true,
&Progress::new(),
&mut |_, _| unreachable!(),
)
.unwrap();
let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
options.resources = root.clone();
options.game_dir = Some(
std::env::temp_dir().join(format!("horizon-boat-driver-unit-{}", std::process::id())),
);
options.execution_role = crate::game::execution_role::ExecutionRole::IntegratedServer;
let mut game = Game::new(
&loaded.resources,
loaded.pack,
loaded.gui.unwrap(),
options,
settings,
Audio::silent(&root),
None,
)
.unwrap();
game.build_registries();
game.set_allow_commands(true);
let stone = game
.pack
.assets
.registry
.default_state("minecraft:stone")
.unwrap()
.0;
let mut chunk = Chunk::empty(0, 0);
for x in 0..16 {
for z in 0..16 {
chunk.set(x, 199, z, stone);
}
}
game.world.chunks.insert((0, 0), Arc::new(chunk));
game.block_ticks
.add_empty_chunk(ChunkPos::new(0, 0))
.unwrap();
assert!(game.run_command("forceload add 0 0"));
assert!(game.run_command("summon minecraft:oak_boat 4.5 200 4.5"));
let boat = game.boats[0].id;
let start = game.boats[0].position;
game.lan_host(
super::super::lan::LanSettings {
port: 0,
guest_commands: true,
force_game_mode: false,
},
NetConfig {
announce: false,
..NetConfig::loopback(0, "boat-driver-test".into(), 3)
},
HubConfig {
default_game_mode: 0,
guest_commands: true,
force_game_mode: false,
hardcore: false,
view_distance: 2,
simulation_distance: 2,
dimension: "minecraft:overworld".into(),
allow_flight: false,
seed: 0,
max_players: 3,
integrated: false,
levels: Default::default(),
},
)
.unwrap();
let mut host = game.lan.take().unwrap();
// The second seat's player joined the server first; the driver got
// into the boat first.
let (mut passenger, mut driver) = (guest(2, 21), guest(3, 22));
(driver.vehicle, driver.vehicle_order) = (Some(boat), 1);
(passenger.vehicle, passenger.vehicle_order) = (Some(boat), 2);
let (passenger_id, driver_id) = (passenger.entity_id, driver.entity_id);
host.hub.guests.push(passenger);
host.hub.guests.push(driver);
game.lan_riding(&host.hub.guests, &mut host.hub.riding);
assert_eq!(
host.hub.riding.passengers(boat as i32),
[driver_id, passenger_id],
"the driver sits first"
);
let move_to = |x: f64| play::MoveVehicleRequest {
position: [x, start.y, start.z],
yaw: 0.0,
pitch: 0.0,
on_ground: true,
};
game.guest_move_vehicle(&mut host, 2, &move_to(start.x + 0.3));
assert_eq!(
game.boats[0].position, start,
"the second seat moves nothing"
);
game.guest_move_vehicle(&mut host, 3, &move_to(start.x + 0.3));
assert!(
(game.boats[0].position.x - (start.x + 0.3)).abs() < 1.0e-9,
"the driver moves the boat: {:?}",
game.boats[0].position
);
}
}
crates/horizon-client/src/game/leads.rs
+6
View File
@@ -532,6 +532,12 @@ impl Game<'_> {
attached |= self.take_knot_boats(knot_pos);
}
if attached {
let event_at = if knot_hit {
[knot.x, knot.y - 0.25, knot.z]
} else {
knot_pos.map(|v| f64::from(v) + 0.5)
};
self.lead_game_event("minecraft:block_attach", event_at);
self.lead_sound("tied", at);
self.swing_arm();
}
crates/horizon-client/src/game/level_particles.rs
+3 -2
View File
@@ -145,8 +145,9 @@ impl Game<'_> {
}
}
}
/// `LevelEventHandler` 2012 (a turtle egg laid on sand):
/// `ParticleUtils.spawnParticleInBlock` with happy villager sparks.
/// `LevelEventHandler` 2011 (a bee grew a crop) and 2012 (a turtle egg
/// laid on sand): `ParticleUtils.spawnParticleInBlock` with happy villager
/// sparks.
pub(super) fn turtle_egg_particles(&mut self, pos: BlockPos, count: i32) {
let at = [pos.x, pos.y, pos.z];
let height = self.block_shape_top(at);
crates/horizon-client/src/game/levels.rs
+15 -1
View File
@@ -144,7 +144,6 @@ impl Levels {
self.parked.get(&dim).map(|level| &level.world)
}
/// The worlds of the levels not in place.
/// A parked level's world border.
pub(super) fn parked_border(
&self,
@@ -153,6 +152,7 @@ impl Levels {
self.parked.get(&dim).map(|level| &level.border)
}
/// The worlds of the levels not in place.
pub(super) fn parked_worlds(&self) -> impl Iterator<Item = &World> {
self.parked.values().map(|level| &level.world)
}
@@ -162,6 +162,11 @@ impl Levels {
self.parked.get_mut(&dim).map(|level| &mut level.world)
}
/// The streaming of the level not in place, in `dim`, to change.
pub(super) fn parked_streaming_mut(&mut self, dim: Dim) -> Option<&mut Streaming> {
self.parked.get_mut(&dim).map(|level| &mut level.streaming)
}
/// The level not in place, in `dim`.
pub(super) fn parked_mut(&mut self, dim: Dim) -> Option<&mut Parked> {
self.parked.get_mut(&dim)
@@ -413,6 +418,8 @@ impl Game<'_> {
if opened {
// The new streaming's radius and meshing options.
self.apply_settings();
// A mod's tickets held for the level while it was closed.
self.native_chunk_tickets_opened();
self.native_level_opened(target);
}
}
@@ -578,6 +585,10 @@ impl Game<'_> {
// `ServerTickEnd`: an errored tick or an idle-close failure (at
// the `?` above) never reaches this site.
self.native_lifecycle_server_tick_end(paused);
// The packets counted for `native_server_packets` (only while a mod counts them).
if server {
self.diagnostics_packets_tick();
}
Ok(())
}
@@ -628,6 +639,7 @@ impl Game<'_> {
slowest_steps(&notes)
);
}
self.native_server_tick_timed(wall, cpu, &spans);
record(wall, cpu, spans, in_tick);
result
}
@@ -702,6 +714,8 @@ impl Game<'_> {
|| self.mod_container_viewers.keys().any(|(k, _)| *k == d.id())
|| self.player_bed_levels().any(|b| b == *d)
|| forced
// A native mod's tickets for a level not open yet (`native_force_chunk_in`).
|| self.mod_chunk_tickets.get(d).is_some_and(|l| !l.is_empty())
// A game test runs in its own level, players or not.
|| self.game_tests.has_tests_in(*d)
|| self.pregen_level() == Some(*d)
crates/horizon-client/src/game/lightning.rs
+56 -1
View File
@@ -300,7 +300,8 @@ impl Game<'_> {
});
}
/// `spawnFire`: fire at the strike point and `extra` random neighbours,
/// wherever `BaseFireBlock.getState` fire can survive. Returns how many
/// wherever `BaseFireBlock.getState` fire can survive, when a player is
/// within the fire-spread radius. Returns how many
/// blocks it set on fire.
fn bolt_fire(&mut self, at: [f64; 3], extra: i32) -> i32 {
let mut set = 0;
@@ -309,6 +310,14 @@ impl Game<'_> {
at[1].floor() as i32,
at[2].floor() as i32,
];
// ServerLevel.canSpreadFireAround at the bolt: no fire at all, and no
// draws for the extra sources, away from every player (#11376).
let origin = BlockPos::new(base[0], base[1], base[2]);
if !self.with_level(|_, level, _| {
horizon_world::level::LevelAccess::can_spread_fire_around(level, origin)
}) {
return 0;
}
let mut spots = vec![base];
for _ in 0..extra {
let r = &mut self.world.random;
@@ -756,6 +765,52 @@ mod tests {
use horizon_core::geometry::Vec3;
use std::sync::Arc;
/// `LightningBolt.spawnFire` places nothing, and draws no extra sources,
/// unless `canSpreadFireAround` passes at the bolt (#11376).
#[test]
#[ignore = "needs prepared resources (HORIZON_TEST_RESOURCES)"]
fn a_bolt_away_from_players_starts_no_fire() {
use horizon_client::gamerules::Value;
let mut game = super::super::native_machines::tests::server_game();
let stone = game
.pack
.assets
.registry
.default_state("minecraft:stone")
.unwrap();
let air = game.res.facts().air;
game.world.set(8, 64, 8, stone).unwrap();
let bolt = [8.5, 65.0, 8.5];
// (radius, player's x): fires expected at the strike.
for (radius, player_x, fires) in [
(128, 12.5, true),
(1, 12.5, false),
(0, 8.5, false),
(-1, 1000.0, true),
] {
game.world.set(8, 65, 8, air).unwrap();
game.ui
.rules
.set("fire_spread_radius_around_player", Value::Int(radius));
game.player = Some(
horizon_client::motion::PlayerMotion::new(
game.motion,
Vec3::new(player_x, 65.0, 8.5),
)
.unwrap(),
);
let random = game.world.random.clone();
let set = game.bolt_fire(bolt, 4);
let burning = game.world.block(8, 65, 8) != air;
assert_eq!((set > 0, burning), (fires, fires), "radius {radius}");
if !fires {
// No offset draws either.
let mut before = random;
assert_eq!(game.world.random.next_long(), before.next_long());
}
}
}
#[test]
fn viewer_box_reaches_15_around_and_down_and_21_up() {
let bolt = [0.0, 64.0, 0.0];
crates/horizon-client/src/game/mace.rs
+15
View File
@@ -280,12 +280,27 @@ impl Game<'_> {
}
hurt
}
/// Takes the absorbed tenths a projectile's hit left on the mobs; the shooter gets them
/// as `damage_dealt_absorbed` when it is the player (`LivingEntity.actuallyHurt`).
pub(super) fn settle_dealt_absorbed(&mut self, by_player: bool) {
let absorbed: i32 = self
.mobs
.iter_mut()
.map(|m| std::mem::take(&mut m.dealt_absorbed))
.fold(0, i32::saturating_add);
if by_player && absorbed > 0 {
self.award_custom_stat("damage_dealt_absorbed", absorbed);
}
}
/// `Player.itemAttackInteraction` after the player's hit landed on the mob
/// at `index`: the item's `hurtEnemy` (the "used" statistic of a weapon),
/// the post-attack enchantments, then `postHurtEnemy` with the weapon's
/// wear.
pub(super) fn weapon_hit(&mut self, index: usize) {
let Some(stack) = self.held().cloned() else {
// An empty hand still meets the victim's own post-attack
// enchantments (Thorns).
self.post_attack(index);
return;
};
let weapon = self
crates/horizon-client/src/game/machines.rs
+13
View File
@@ -646,6 +646,7 @@ impl Game<'_> {
let was_empty = c.is_empty(view);
let max = c.max_stack(&stack);
let mut success = false;
let mut filled_empty = false;
let Some(target) = self.slot_mut_at(view, slot) else {
return (Some(stack), false);
};
@@ -663,6 +664,7 @@ impl Game<'_> {
});
stack.count = 0;
success = true;
filled_empty = true;
}
Some(current)
// HopperBlockEntity.canMergeItems
@@ -676,6 +678,17 @@ impl Game<'_> {
}
Some(_) => {}
}
// tryMoveInItem's setItem on an empty slot: AbstractFurnaceBlockEntity.setItem restarts
// the cooking for a new input (a merge only grows the stack, and keeps it).
let recipes = world_recipes!(self);
if filled_empty
&& let Some((pos, 0)) = view.locate(slot)
&& let Some(BlockEntity::Furnace(furnace)) = self.world.block_entities.get_mut(&pos)
{
use horizon_client::furnace::FurnaceCooking;
let input = furnace.items[0].take();
furnace.set_input(recipes, input);
}
if success && was_empty && view.kind == Kind::Hopper {
let dest = view.parts[0].0;
let from_ticked = from_hopper.and_then(|p| self.hoppers.get(&p).map(|h| h.ticked));
crates/horizon-client/src/game/maps.rs
+16 -1
View File
@@ -252,6 +252,21 @@ impl MapData {
texture_dirty: true,
}
}
/// The whole picture replaced by a mod (`native_paint_map`): saved with
/// the maps and sent in full to everyone carrying it or seeing it framed,
/// as `update_color` would over every pixel (`setColorsDirty`).
pub(super) fn paint(&mut self, colors: &[u8]) {
if self.colors.as_slice() == colors {
return;
}
self.colors.clear();
self.colors.extend_from_slice(colors);
self.dirty = true;
self.texture_dirty = true;
for h in &mut self.holders {
h.dirty = Some([0, 0, 127, 127]);
}
}
fn update_color(&mut self, x: i32, y: i32, color: u8) -> bool {
let i = (x + y * 128) as usize;
if self.colors[i] == color {
@@ -428,7 +443,7 @@ impl MapData {
}
/// `MapItemSavedData.isTrackedCountOverLimit`: more than `limit`
/// decorations count (`MapDecorationType.trackCount`).
fn tracked_over_limit(&self, limit: usize) -> bool {
pub(super) fn tracked_over_limit(&self, limit: usize) -> bool {
self.decorations
.iter()
.filter(|d| tracks_count(d.sprite))
crates/horizon-client/src/game/mods.rs
+4
View File
@@ -966,8 +966,12 @@ mod tests {
living_fall: |_, _, _, _, _| {},
living_jump: |_, _| {},
register_goals: |mob| dispatch_register_goals(&MODS, mob),
player_pre_login: |_, _, _, _| {},
player_profile: |_, _, _| {},
ingredient: |_, _, _| {},
ingredient_test: |_, _, _, _| {},
log_line: |_, _, _, _| {},
handshake: |_, _, _, _, _| {},
});
assert!(installed.is_ok());
crates/horizon-client/src/game/music.rs
+1 -1
View File
@@ -253,7 +253,7 @@ impl Game<'_> {
(situation.music(), situation.volume())
}
/// `BiomeManager.getNoiseBiomeAtPosition`: the quart cell holding a position.
fn biome_at(&self, p: [f64; 3]) -> &str {
pub(super) fn biome_at(&self, p: [f64; 3]) -> &str {
let (x, y, z) = (
p[0].floor() as i32,
p[1].floor() as i32,
crates/horizon-client/src/game/native_chunk_snapshot.rs
+149
View File
@@ -0,0 +1,149 @@
//! Read-only chunk snapshots for native server mods (docs/native-mods.md,
//! "Server hooks for plugin ports: world"): a web map or a backup tool takes
//! a loaded chunk as it is now and reads it later, off the server thread,
//! with the block map colours and biome tints to draw it.
use super::{Dim, Game};
use horizon_client::{biome::BiomeColors, blocks::MAP_COLORS, chunk::Chunk};
use horizon_core::{biome::BiomeZoom, position::BlockPos};
use horizon_world::registry::BlockStateId;
use std::sync::Arc;
/// A loaded chunk as it was when `native_chunk_snapshot` took it: its block
/// states and biomes, shared with the level until the level changes them
/// (copy on write), so taking one is cheap and holding it doesn't stop the
/// level. It can be sent to another thread. Coordinates are the level's
/// block coordinates.
#[derive(Clone)]
pub struct NativeChunkSnapshot {
chunk: Arc<Chunk>,
pos: [i32; 2],
min_y: i32,
top_y: i32,
ceiling: bool,
zoom: BiomeZoom,
/// Air, cave air and void air (`BlockState.isAir`).
air: [Option<BlockStateId>; 3],
}
impl NativeChunkSnapshot {
/// The chunk's position, `[x, z]` (block coordinates `>> 4`).
pub fn chunk(&self) -> [i32; 2] {
self.pos
}
/// The level's lowest block `y` and one above its highest
/// (`getMinY`, `getMaxY` + 1).
pub fn height(&self) -> (i32, i32) {
(self.min_y, self.top_y)
}
/// Whether the level has a ceiling (`DimensionType.hasCeiling`: the Nether).
pub fn has_ceiling(&self) -> bool {
self.ceiling
}
/// The block state at `x, y, z` (`getBlockState`), as the state helpers
/// take it (`native_state_block`); None outside this chunk or the level's
/// height.
pub fn block_state(&self, x: i32, y: i32, z: i32) -> Option<BlockStateId> {
let inside =
(x >> 4, z >> 4) == (self.pos[0], self.pos[1]) && (self.min_y..self.top_y).contains(&y);
inside.then(|| self.chunk.block(x & 15, y, z & 15))
}
/// `getHeight(Heightmap.Types.WORLD_SURFACE, x, z)`: one above the
/// highest block that isn't air, the level's lowest `y` in an empty
/// column. None outside this chunk.
pub fn surface(&self, x: i32, z: i32) -> Option<i32> {
let air = self.air;
((x >> 4, z >> 4) == (self.pos[0], self.pos[1])).then(|| {
self.chunk
.world_surface(x & 15, z & 15, |v| air.contains(&Some(BlockStateId(v))))
})
}
/// The biome of quart cell `qx, qy, qz` (block coordinates `>> 2`,
/// `getNoiseBiome`), the `y` clamped to the level, as a biome id of
/// `native_biome_name` and `native_biome_tint`. None for a cell outside
/// this chunk.
pub fn noise_biome(&self, qx: i32, qy: i32, qz: i32) -> Option<u16> {
let (x, z) = (qx << 2, qz << 2);
((x >> 4, z >> 4) == (self.pos[0], self.pos[1])).then(|| self.chunk.biome(x, qy << 2, z))
}
/// The quart cell whose biome is the biome at block `x, y, z`
/// (`BiomeManager.getBiome`'s fuzzy zoom with the world's seed): it can
/// lie in a neighbouring chunk, so read it with `noise_biome` of that
/// chunk's snapshot.
pub fn biome_cell(&self, x: i32, y: i32, z: i32) -> [i32; 3] {
self.zoom.quart_at_block(BlockPos::new(x, y, z))
}
}
// Native mods use these; nothing in Horizon does.
#[allow(dead_code)]
impl Game<'_> {
/// A snapshot of loaded chunk `chunk` (`[x, z]`) of the level `dimension`
/// (`minecraft:the_nether`), in place or open with nobody in it. None off
/// a server, for a level not open and for a chunk not loaded; nothing is
/// loaded or generated for it. API @API:chunk_snapshot@.
pub(super) fn native_chunk_snapshot(
&self,
dimension: &str,
chunk: [i32; 2],
) -> Option<NativeChunkSnapshot> {
if !self.native_authoritative() {
return None;
}
let world = if dimension == self.dim.id() {
&self.world
} else {
let dim = [Dim::Overworld, Dim::Nether, Dim::End]
.into_iter()
.find(|d| d.id() == dimension)?;
self.levels.parked_world(dim)?
};
Some(NativeChunkSnapshot {
chunk: world.chunks.get(&(chunk[0], chunk[1]))?.clone(),
pos: chunk,
min_y: world.shape.min_y,
top_y: world.shape.max_y(),
ceiling: world.shape.has_ceiling,
zoom: self.streaming.biome_zoom,
air: ["minecraft:air", "minecraft:cave_air", "minecraft:void_air"]
.map(|name| self.pack.assets.registry.default_state(name)),
})
}
/// The map colour of block state `state` (`BlockState.getMapColor`):
/// `(id, colour)`, the `MapColor` id and its `col` (0xRRGGBB), `(0, 0)`
/// for `MapColor.NONE` (air, glass). None for an unknown state. API
/// @API:chunk_snapshot@.
pub(super) fn native_block_map_color(&self, state: BlockStateId) -> Option<(u8, u32)> {
let known = usize::try_from(state.0).is_ok_and(|s| s < self.pack.assets.registry.len());
if !known {
return None;
}
let id = self.res.facts().get(state).map_color;
Some((id, MAP_COLORS.get(usize::from(id)).copied().unwrap_or(0)))
}
/// The name of biome id `biome` (`minecraft:plains`), as a snapshot's
/// `noise_biome` gives it. None for an unknown id. API
/// @API:chunk_snapshot@.
pub(super) fn native_biome_name(&self, biome: u16) -> Option<&str> {
let biomes = world_biomes!(self);
biomes.list.get(usize::from(biome)).map(|b| b.name.as_str())
}
/// The tints of biome id `biome` at block column `x, z`, each 0xRRGGBB:
/// grass (`Biome.getGrassColor`, with the dark forest's and the swamp's
/// modifiers), foliage, dry foliage and water, after
/// `native_biome_colors`. The biome's own, not blended over the biome
/// blend radius as the client draws them. None for an unknown id. API
/// @API:chunk_snapshot@.
pub(super) fn native_biome_tint(&self, biome: u16, x: i32, z: i32) -> Option<BiomeColors> {
let biomes = world_biomes!(self);
let b = biomes.list.get(usize::from(biome))?;
Some(BiomeColors {
grass: biomes.grass(biome, f64::from(x), f64::from(z)),
foliage: b.foliage,
dry_foliage: b.dry_foliage,
water: b.water,
})
}
}
crates/horizon-client/src/game/native_chunk_tickets.rs
+54 -6
View File
@@ -3,7 +3,7 @@
//! working (docs/native-mods.md, "Chunk tickets"). A held chunk is as a
//! `/forceload`ed one, its level stays open, but `/forceload` neither lists
//! nor releases it and it isn't saved.
use super::Game;
use super::{Dim, Game};
// Native mods use these; nothing in Horizon does.
#[allow(dead_code)]
@@ -21,6 +21,34 @@ impl Game<'_> {
/// set of owners changed; false for an owner without a namespace, a chunk
/// past the world's edge (as `/forceload` refuses it) and off a server. API @API:chunk_tickets@.
pub(super) fn native_force_chunk(&mut self, owner: &str, chunk: [i32; 2], hold: bool) -> bool {
self.native_chunk_ticket(self.dim, owner, chunk, hold)
}
/// `native_force_chunk` for the level `dimension` (`minecraft:the_nether`),
/// whether it is in place, open with nobody in it, or not open yet: a
/// level held this way opens at the next server tick and ticks from then
/// on, so a mod can generate or run the Nether and the End from any
/// server hook. False also for a dimension other than the Overworld, the
/// Nether and the End. API @API:chunk_tickets_in_level@.
pub(super) fn native_force_chunk_in(
&mut self,
owner: &str,
dimension: &str,
chunk: [i32; 2],
hold: bool,
) -> bool {
let dim = match dimension {
"minecraft:overworld" => Dim::Overworld,
"minecraft:the_nether" => Dim::Nether,
"minecraft:the_end" => Dim::End,
_ => return false,
};
self.native_chunk_ticket(dim, owner, chunk, hold)
}
/// Hold or release `owner`'s ticket on `chunk` of `dim`'s level, and
/// hand the level's held chunks to its streaming if it is open.
fn native_chunk_ticket(&mut self, dim: Dim, owner: &str, chunk: [i32; 2], hold: bool) -> bool {
let namespaced = owner
.split_once(':')
.is_some_and(|(ns, path)| !ns.is_empty() && !path.is_empty());
@@ -32,7 +60,7 @@ impl Game<'_> {
return false;
}
let key = (chunk[0], chunk[1]);
let level = self.mod_chunk_tickets.entry(self.dim).or_default();
let level = self.mod_chunk_tickets.entry(dim).or_default();
let changed = if hold {
level.entry(key).or_default().insert(owner.to_owned())
} else {
@@ -45,14 +73,34 @@ impl Game<'_> {
if !changed {
return false;
}
if level.contains_key(&key) {
let held = level.contains_key(&key);
// A level not open yet gets its tickets when it opens
// (`native_chunk_tickets_opened`).
let streaming = if dim == self.dim {
Some(&mut self.streaming)
} else {
self.levels.parked_streaming_mut(dim)
};
if let Some(streaming) = streaming {
if !held {
streaming.mod_forced.remove(&key);
} else if streaming.mod_forced.insert(key) {
streaming.rank_forced(key.0, key.1, key.0, key.1);
}
}
true
}
/// The level just opened in place takes the tickets mods hold for it.
pub(super) fn native_chunk_tickets_opened(&mut self) {
let Some(level) = self.mod_chunk_tickets.get(&self.dim) else {
return;
};
for &key in level.keys() {
if self.streaming.mod_forced.insert(key) {
self.streaming.rank_forced(key.0, key.1, key.0, key.1);
}
} else {
self.streaming.mod_forced.remove(&key);
}
true
}
/// The chunks of the level in place `owner` holds (`native_force_chunk`),
crates/horizon-client/src/game/native_client_entities.rs
+270
View File
@@ -0,0 +1,270 @@
//! Entities shown to one player's client alone, for native server mods
//! (docs/native-mods.md, "Server hooks for plugin ports: vanish and per-viewer
//! visuals"): a hologram or a board only its owner sees. No level holds them:
//! they are never simulated, saved or tracked, nobody else sees them, and the
//! client forgets them when its player changes dimension or leaves. Their
//! synched data comes from a compound as `/summon` reads it.
use super::Game;
use horizon_client::lan::entity::EntityState;
use horizon_protocol::{
buf::pack_degrees,
entity_data::{Value, serializer},
packets::play::{self, Clientbound as C},
};
use horizon_world::nbt::{Compound, Tag};
/// A synched data entry: its id, serializer and value.
type Entry = (u8, i32, Value);
/// `Entity`'s own synched data from a compound as `Entity.load` reads it:
/// `Invisible` and `Glowing` (DATA_SHARED_FLAGS_ID 0x20 and 0x40),
/// `CustomName`, `CustomNameVisible`, `Silent` and `NoGravity` (ids 2 to 5);
/// then the defaults of all of them.
fn entity_data(tag: &Tag) -> (Vec<Entry>, Vec<Entry>) {
let flag = |key: &str| match tag.get(key) {
Some(Tag::Byte(v)) => *v != 0,
Some(Tag::Int(v)) => *v != 0,
_ => false,
};
let mut meta = Vec::new();
let flags = i8::from(flag("Invisible")) << 5 | i8::from(flag("Glowing")) << 6;
if flags != 0 {
meta.push((0, serializer::BYTE, Value::Byte(flags)));
}
if let Some(name) = tag.get("CustomName") {
meta.push((
2,
serializer::OPTIONAL_COMPONENT,
Value::OptText(Some(name.clone())),
));
}
for (id, key) in [(3, "CustomNameVisible"), (4, "Silent"), (5, "NoGravity")] {
if flag(key) {
meta.push((id, serializer::BOOLEAN, Value::Bool(true)));
}
}
let defaults = vec![
(0, serializer::BYTE, Value::Byte(0)),
(2, serializer::OPTIONAL_COMPONENT, Value::OptText(None)),
(3, serializer::BOOLEAN, Value::Bool(false)),
(4, serializer::BOOLEAN, Value::Bool(false)),
(5, serializer::BOOLEAN, Value::Bool(false)),
];
(meta, defaults)
}
/// An entity type's id with its namespace (`text_display` is
/// `minecraft:text_display`).
fn namespaced(kind: &str) -> String {
if kind.contains(':') {
kind.to_owned()
} else {
["minecraft:", kind].concat()
}
}
// Native mods use these; nothing in Horizon does.
#[allow(dead_code)]
impl Game<'_> {
/// The synched data `nbt` gives an entity of type `kind`: a display's
/// (`Display`, `TextDisplay`, `BlockDisplay`, `ItemDisplay`) and every
/// entity's own (`entity_data`). With `all`, also the defaults of what
/// `nbt` leaves out. None where the server is out of reach.
fn native_client_entity_data(
&mut self,
kind: &str,
nbt: &Compound,
all: bool,
) -> Option<Vec<Entry>> {
let tag = Tag::Compound(nbt.clone());
let mut e = EntityState {
kind: kind.to_owned(),
..Default::default()
};
// `lan_display_data` reads the hub's item ids; the hub goes back at once.
let mut host = self.lan.take()?;
self.lan_display_data(&tag, &mut host.hub, &mut e);
self.lan = Some(host);
let (meta, defaults) = entity_data(&tag);
e.meta.extend(meta);
e.defaults.extend(defaults);
if !all {
return Some(e.meta);
}
let mut values = e.defaults;
for v in &mut values {
if let Some(m) = e.meta.iter().find(|m| m.0 == v.0) {
v.clone_from(m);
}
}
let rest: Vec<Entry> = e
.meta
.iter()
.filter(|m| !values.iter().any(|v| v.0 == m.0))
.cloned()
.collect();
values.extend(rest);
Some(values)
}
/// The type of `viewer`'s client-side entity `id`, if it is one.
fn native_client_entity_kind(&self, viewer: u128, id: i32) -> Option<String> {
self.lan
.as_ref()?
.hub
.guests
.iter()
.find(|g| g.placed && g.uuid == viewer)?
.client_entities
.get(&id)
.cloned()
}
/// An entity id no entity of this server will take
/// (`Entity.nextEntityId`'s counter), for a mod's own packets to a
/// client. API @API:client_entities@.
pub(super) fn native_reserve_entity_id(&mut self) -> i32 {
self.take_entity_id() as i32
}
/// Shows an entity of type `kind` (`minecraft:text_display`, `text_display`)
/// to the player `viewer` alone, at `pos` (the feet) facing `yaw`, with the
/// synched data `nbt` gives it as `/summon` reads it: all of a display's
/// (`text`, `background`, `billboard`, `transformation`, `item`,
/// `block_state`, `teleport_duration`...), and of any type `CustomName`,
/// `CustomNameVisible`, `Invisible`, `Glowing`, `Silent` and `NoGravity`;
/// other types' own data is not read. No level holds it: it is not
/// simulated, saved, tracked or seen by anyone else, and the client
/// forgets it when the player changes dimension or leaves. Returns its id
/// (one the server's entities never take), for `native_client_entity_set`,
/// `_move` and `_remove`. None when `viewer` isn't on, for an unknown
/// type, a player, a position or yaw that isn't finite, and inside a
/// player's hook where the server is out of reach. Bukkit has no such API
/// (plugins send the packets). API @API:client_entities@.
pub(super) fn native_client_entity_spawn(
&mut self,
viewer: u128,
kind: &str,
pos: [f64; 3],
yaw: f32,
nbt: &Compound,
) -> Option<i32> {
if !pos.iter().all(|v| v.is_finite()) || !yaw.is_finite() {
return None;
}
let kind = namespaced(kind);
// A player's entity needs a player list entry the server doesn't have.
if kind == "minecraft:player" {
return None;
}
let hub = &self.lan.as_ref()?.hub;
hub.guests.iter().find(|g| g.placed && g.uuid == viewer)?;
let type_id = hub.registry_id("minecraft:entity_type", &kind)?;
let values = self.native_client_entity_data(&kind, nbt, false)?;
let id = self.take_entity_id();
let add = C::AddEntity(play::AddEntity {
id: id as i32,
uuid: super::lan::entity_uuid(id),
kind: type_id,
position: pos,
velocity: [0.0; 3],
pitch: 0,
yaw: pack_degrees(yaw),
head_yaw: pack_degrees(yaw),
data: 0,
});
let id = id as i32;
let host = self.lan.as_mut()?;
let g = host
.hub
.guests
.iter_mut()
.find(|g| g.placed && g.uuid == viewer)?;
g.client_entities.insert(id, kind);
self.native_send(viewer, add);
if !values.is_empty() {
self.native_send(viewer, C::SetEntityData(play::SetEntityData { id, values }));
}
Some(id)
}
/// Gives `viewer`'s client-side entity `id` the synched data `nbt` gives
/// its type, as `native_client_entity_spawn` reads it: what `nbt` leaves
/// out goes back to its default, so pass the whole of what it shows. A
/// display's `start_interpolation` is sent with it, so a changed
/// transformation eases over `interpolation_duration`. False when it is
/// not their client-side entity, and where the server is out of reach.
/// API @API:client_entities@.
pub(super) fn native_client_entity_set(
&mut self,
viewer: u128,
id: i32,
nbt: &Compound,
) -> bool {
let Some(kind) = self.native_client_entity_kind(viewer, id) else {
return false;
};
let Some(values) = self.native_client_entity_data(&kind, nbt, true) else {
return false;
};
self.native_send(viewer, C::SetEntityData(play::SetEntityData { id, values }))
}
/// Moves `viewer`'s client-side entity `id` to `pos` facing `yaw`
/// (`ClientboundTeleportEntityPacket`, absolute; a display eases over its
/// `teleport_duration`). False when it is not their client-side entity,
/// for a position or yaw that isn't finite, and where the server is out
/// of reach. API @API:client_entities@.
pub(super) fn native_client_entity_move(
&mut self,
viewer: u128,
id: i32,
pos: [f64; 3],
yaw: f32,
) -> bool {
if !pos.iter().all(|v| v.is_finite()) || !yaw.is_finite() {
return false;
}
if self.native_client_entity_kind(viewer, id).is_none() {
return false;
}
let packet = C::TeleportEntity(play::TeleportEntity {
id,
position: pos,
delta: [0.0; 3],
yaw,
pitch: 0.0,
relatives: 0,
on_ground: false,
});
self.native_send(viewer, packet)
}
/// Takes `viewer`'s client-side entities `ids` away from their client
/// (`ClientboundRemoveEntitiesPacket`); ids that are not theirs are left
/// alone (an entity the server tracks is hidden with
/// `native_hide_entity_from`). False when none of them was theirs, and
/// where the server is out of reach. API @API:client_entities@.
pub(super) fn native_client_entity_remove(&mut self, viewer: u128, ids: &[i32]) -> bool {
let Some(host) = &mut self.lan else {
return false;
};
let Some(g) = host
.hub
.guests
.iter_mut()
.find(|g| g.placed && g.uuid == viewer)
else {
return false;
};
let ids: Vec<i32> = ids
.iter()
.copied()
.filter(|id| g.client_entities.remove(id).is_some())
.collect();
if ids.is_empty() {
return false;
}
self.native_send(viewer, C::RemoveEntities(play::RemoveEntities { ids }))
}
}
crates/horizon-client/src/game/native_client_services.rs
+541 -1
View File
@@ -1,13 +1,18 @@
//! Client services for trait mods, without exposing `Game` or the atlas.
use super::Game;
use super::{Game, Screen};
use horizon_client::{
client_resources::TexturePixels,
collisions::SceneCollisions,
hud::{HudBatch, rgba},
hud_layout::GuiDraw,
items::ItemStack,
mod_api::Text,
net::FRIEND,
};
use horizon_core::geometry::Vec3;
use horizon_friends::invite::{self, Parsed};
use std::borrow::Cow;
use std::net::SocketAddr;
use winit::keyboard::KeyCode;
/// This window's state; unavailable on a server or before a window is attached.
@@ -25,6 +30,89 @@ pub struct NativeClientState {
pub yaw: f32,
pub pitch: f32,
pub menu_blur: f32,
/// What covers the world. API @API:session_state@.
pub screen: NativeScreenKind,
/// F3's debug screen is showing (`DebugScreenOverlay.showDebugScreen`).
/// API @API:session_state@.
pub debug_screen: bool,
/// The world joined, None before one is. API @API:session_state@.
pub world: Option<NativeWorldId>,
/// The head of the bed the player sleeps in, as the server says
/// (`LivingEntity.getSleepingPos`). API @API:session_state@.
pub sleeping_pos: Option<[i32; 3]>,
}
/// What covers the world, in the kinds a HUD tells apart (vanilla's
/// `Minecraft.screen`).
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum NativeScreenKind {
/// No screen: the world is played.
#[default]
Playing,
/// The chat box (`ChatScreen`), which a minimap still draws under.
Chat,
/// The death screen (`DeathScreen`).
Death,
/// Any other: the pause menu, an inventory or container, a sign, book,
/// dialog or prompt, the loading screen, the title's screens.
Other,
}
impl NativeScreenKind {
/// `covered`: a screen Horizon keeps outside `Screen` is up over it.
fn of(screen: Screen, covered: bool) -> Self {
match screen {
_ if covered => Self::Other,
Screen::Playing => Self::Playing,
Screen::Chat => Self::Chat,
Screen::Dead => Self::Death,
_ => Self::Other,
}
}
}
/// The world this window plays, for a mod that keeps data per world, as
/// Xaero's minimap and JourneyMap do. A later Horizon may add kinds.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum NativeWorldId {
/// Single player, its LAN host and splitscreen seats: the save's folder
/// in `saves/`, not its shown name.
Singleplayer(String),
/// A server, a LAN world joined included: its address as the player
/// joined it (`mc.example.com:25565`). A friend's world is `friend:` and
/// what its invite shows anyone (its host's addresses and its relay
/// nameplate), never the invite's secret.
Server(String),
}
impl NativeWorldId {
/// `save` is set for single player's world joined through memory.
fn of(save: Option<&str>, address: &str) -> Self {
match (save, address.strip_prefix(FRIEND)) {
(Some(folder), _) => Self::Singleplayer(folder.to_owned()),
(None, Some(code)) => Self::Server(format!("{FRIEND}{}", invite_public_part(code))),
(None, None) => Self::Server(address.to_owned()),
}
}
}
/// The part of a friend's invite anyone may see. A host's code is fresh each
/// time it shares, so a friend's world is known for that sharing only. The
/// relay is kept beside the addresses: two hosts on other networks can share
/// a private address and the fixed direct port.
fn invite_public_part(code: &str) -> String {
match invite::parse(code) {
Some(Parsed::Short(code)) => code.nameplate,
Some(Parsed::Long(invite)) => {
let relay = invite
.relay
.map(|r| format!("{}/{}", r.address, r.code.nameplate));
let endpoints = invite.endpoints.iter().map(SocketAddr::to_string);
endpoints.chain(relay).collect::<Vec<_>>().join(",")
}
None => String::new(),
}
}
/// A living entity known to the client, before interpolation. No authoritative writes.
@@ -42,6 +130,51 @@ pub struct NativeClientEntity {
pub head_pitch: f32,
pub alive: bool,
pub invisible: bool,
/// Its entity type (`minecraft:zombie`). API @API:client_entity_list@.
pub kind: String,
/// `Entity.getYRot` in degrees, 0 facing south and 90 west.
pub yaw: f32,
pub baby: bool,
/// A player in spectator mode, whom vanilla draws only to spectators.
pub spectator: bool,
/// The texture its body draws with (`EntityRenderer.getTextureLocation`):
/// `entity/cow/cow_temperate_baby`, or a player's skin. Pixels through
/// `native_client_texture`.
pub texture: Option<String>,
}
impl NativeClientEntity {
/// Where this frame draws it (`Entity.getPosition(partialTick)`), given
/// `NativeClientState::world_partial_tick`. API @API:client_entity_list@.
pub fn position_at(&self, partial_tick: f64) -> [f64; 3] {
position_at(self.previous_position, self.position, partial_tick)
}
}
/// A dropped item the client shows. API @API:client_entity_list@.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct NativeClientItem {
pub id: u32,
pub stack: ItemStack,
pub position: [f64; 3],
pub previous_position: [f64; 3],
}
impl NativeClientItem {
/// Where this frame draws it, as `NativeClientEntity::position_at`.
pub fn position_at(&self, partial_tick: f64) -> [f64; 3] {
position_at(self.previous_position, self.position, partial_tick)
}
}
/// `Downloader::image` keeps every skin at 64x64.
const SKIN_SIDE: u32 = 64;
fn position_at(previous: [f64; 3], position: [f64; 3], partial_tick: f64) -> [f64; 3] {
let vec = |[x, y, z]: [f64; 3]| Vec3::new(x, y, z);
let at = vec(previous).lerp(vec(position), partial_tick);
[at.x, at.y, at.z]
}
/// A posed model head, relative to its interpolated origin, in block units.
@@ -68,6 +201,23 @@ pub struct NativeClientProfile {
#[allow(dead_code)]
impl Game<'_> {
/// A screenshot as F2 takes it (`ScreenShot.grab`): of the next frame, at
/// the game's resolution times Screenshot Quality, into `screenshots/` with
/// vanilla's file name, and the same "Saved screenshot as" line in chat.
/// The file it will write, as a path string; an error without a window to draw, or while
/// another screenshot waits for the frame (F2's, an agent's, the world
/// icon's), which a mod's would replace. API @API:take_screenshot@.
pub(super) fn native_take_screenshot(&mut self) -> Result<String, String> {
let Some(renderer) = self.renderer.as_ref() else {
return Err("no window to take it from".into());
};
if renderer.screenshot.is_some() {
return Err("another screenshot is waiting for the frame".into());
}
self.take_screenshot()
.map(|path| path.to_string_lossy().into_owned())
.ok_or_else(|| "the screenshots folder can't be made".into())
}
/// Client/window/connection state, including when menus cover the world.
pub(super) fn native_client_state(&self) -> Option<NativeClientState> {
if !self.native_window() {
@@ -86,6 +236,20 @@ impl Game<'_> {
yaw: self.yaw,
pitch: self.pitch,
menu_blur: self.settings.menu_blur as f32,
screen: NativeScreenKind::of(
self.screen,
self.title.is_some()
|| self.screen_over_playing()
|| self.remote_screen_up()
|| self.pack_reload.is_some(),
),
debug_screen: self.debug,
world: self
.remote
.as_ref()
.filter(|r| r.logged_in)
.map(|r| NativeWorldId::of(r.save_folder.as_deref(), &r.session.address)),
sleeping_pos: self.sleeping,
})
}
/// Bulk client render data. Unlike EntityRef, this snapshot expires independently of handles.
@@ -111,10 +275,53 @@ impl Game<'_> {
head_pitch: m.head_pitch,
alive: m.alive(),
invisible: m.invisible || m.has_effect("minecraft:invisibility"),
kind: m.kind.id.to_string(),
yaw: m.yaw,
baby: m.is_baby(),
spectator: m.extra.spectator,
texture: Some(horizon_client::mobs::render::body(m).1)
.filter(|t| !t.is_empty())
.map(Cow::into_owned),
}
})
.collect()
}
/// The dropped items the server shows this window, by the same rules as
/// `native_client_entities`. API @API:client_entity_list@.
pub(super) fn native_client_items(&self) -> Vec<NativeClientItem> {
if !self.native_window() || self.remote.is_none() {
return Vec::new();
}
self.dropped
.iter()
.filter(|e| e.stack.count > 0)
.map(|e| NativeClientItem {
id: e.id,
stack: e.stack.clone(),
position: [e.position.x, e.position.y, e.position.z],
previous_position: [e.previous.x, e.previous.y, e.previous.z],
})
.collect()
}
/// The pixels of a texture as this window draws it, by the name
/// `NativeClientEntity::texture` and `NativeClientProfile::skin` give: a
/// downloaded skin while the client holds it, else
/// `native_client_resources().texture(name)`. Decodes on each call; None
/// on a server or for a texture it can't read. API
/// @API:client_entity_list@.
pub(super) fn native_client_texture(&self, texture: &str) -> Option<TexturePixels> {
if !self.native_window() {
return None;
}
if let Some(rgba) = self.skin_downloads.borrow().image(texture) {
return Some(TexturePixels {
width: SKIN_SIDE,
height: SKIN_SIDE,
rgba: rgba.to_vec(),
});
}
self.native_client_resources().texture(texture)
}
/// Requested model heads at a finite partial tick in 0..=1; at most 4096 IDs.
/// Name bounds are vanilla's, without dispatching name hooks recursively.
pub(super) fn native_client_heads(&self, ids: &[u32], partial: f64) -> Vec<NativeClientHead> {
@@ -330,3 +537,336 @@ impl Game<'_> {
self.physical_keys.contains(&key)
}
}
#[cfg(test)]
mod tests {
use super::*;
use horizon_friends::code::Code;
#[test]
fn a_world_is_its_save_in_single_player_and_its_address_on_a_server() {
assert_eq!(
NativeWorldId::of(Some("New World"), "local"),
NativeWorldId::Singleplayer("New World".into())
);
assert_eq!(
NativeWorldId::of(None, "mc.example.com:25565"),
NativeWorldId::Server("mc.example.com:25565".into())
);
}
#[test]
fn friends_worlds_are_told_apart_by_their_hosts_never_by_their_secrets() {
const PORT: u16 = 50000;
const RELAY: &str = "relay.example.com:443";
// A short code: its nameplate, then its secret.
let short = |nameplate: &str, secret: &str| Code {
nameplate: nameplate.into(),
secret: secret.into(),
};
let invite = |secret: u8, host: &str, relay: Option<Code>| {
let code = invite::Invite {
secret: [secret; invite::SECRET],
port: PORT,
endpoints: vec![format!("{host}:{PORT}").parse().unwrap()],
relay: relay.map(|code| invite::RelayRef {
address: RELAY.into(),
code,
}),
}
.encode();
NativeWorldId::of(None, &format!("{FRIEND}{code}"))
};
assert_ne!(
invite(1, "192.168.1.5", None),
invite(1, "192.168.1.6", None),
"two friends"
);
assert_ne!(
invite(1, "192.168.1.5", Some(short("ABCD", "WXYZ"))),
invite(1, "192.168.1.5", Some(short("EFGH", "WXYZ"))),
"two friends on other networks behind the same private address"
);
assert_eq!(
invite(1, "192.168.1.5", Some(short("ABCD", "WXYZ"))),
invite(2, "192.168.1.5", Some(short("ABCD", "QRST"))),
"the invite's and the relay code's secrets take no part"
);
let typed = |code: Code| NativeWorldId::of(None, &format!("{FRIEND}{code}"));
assert_eq!(typed(short("ABCD", "WXYZ")), typed(short("ABCD", "QRST")));
assert_eq!(
typed(short("ABCD", "WXYZ")),
NativeWorldId::Server(format!("{FRIEND}ABCD"))
);
}
#[test]
fn a_hud_tells_chat_and_death_from_other_screens() {
assert_eq!(
NativeScreenKind::of(Screen::Playing, false),
NativeScreenKind::Playing
);
assert_eq!(
NativeScreenKind::of(Screen::Chat, false),
NativeScreenKind::Chat
);
assert_eq!(
NativeScreenKind::of(Screen::Dead, false),
NativeScreenKind::Death
);
assert_eq!(
NativeScreenKind::of(Screen::Inventory, false),
NativeScreenKind::Other
);
assert_eq!(
NativeScreenKind::of(Screen::Chat, true),
NativeScreenKind::Other,
"a sign or dialog over chat covers the world"
);
}
#[test]
fn an_entity_is_drawn_between_its_last_two_tick_positions() {
let entity = NativeClientEntity {
previous_position: [0.0, 64.0, -2.0],
position: [2.0, 65.0, 2.0],
..Default::default()
};
assert_eq!(entity.position_at(0.0), [0.0, 64.0, -2.0]);
assert_eq!(entity.position_at(0.25), [0.5, 64.25, -1.0]);
assert_eq!(entity.position_at(1.0), [2.0, 65.0, 2.0]);
}
}
/// A window joined to a server through memory, fed the server's packets as
/// it would receive them: what a client mod lists through the mod `Host`.
#[cfg(test)]
mod client_tests {
use crate::game::{Audio, Game, Options, Progress, Settings, load_resources};
use horizon_client::mod_api::Host;
use horizon_protocol::entity_data::{Value, serializer};
use horizon_protocol::item::Stack;
use horizon_protocol::packets::play::{self, Clientbound as C};
/// `AgeableMob.DATA_BABY_ID` and `ItemEntity.DATA_ITEM`, the entity data
/// a calf and a dropped item come with.
const DATA_BABY_ID: u8 = 16;
const DATA_ITEM: u8 = 8;
/// Vanilla's `zombie.png`, like every skin, is 64x64 RGBA.
const TEXTURE_SIDE: u32 = 64;
const RGBA_BYTES: usize = 4;
/// The network ids the server gives the window's player and the entities.
const OWN_PLAYER: i32 = 7;
const ZOMBIE: i32 = 20;
const CALF: i32 = 21;
const DIAMONDS: i32 = 22;
const ALEX: i32 = 23;
/// `UUID.hashCode` 2: `DefaultPlayerSkin.get` picks the third default
/// skin, slim Efe.
const ALEX_UUID: u128 = 2;
/// `ClientboundPlayerInfoUpdatePacket`'s `ADD_PLAYER` and
/// `UPDATE_GAME_MODE` actions, and `GameType.SPECTATOR`.
const ADD_PLAYER: u8 = 1;
const UPDATE_GAME_MODE: u8 = 4;
const SPECTATOR: i32 = 3;
#[test]
#[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES"]
fn a_client_lists_the_mobs_and_items_the_server_shows_it() {
let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
let settings = Settings::default();
let loaded = load_resources(
root.clone(),
None,
&root,
&settings,
std::time::Instant::now(),
false,
true,
&Progress::new(),
&mut |_, _| unreachable!(),
)
.unwrap();
let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
options.resources = root.clone();
let mut game = Game::new(
&loaded.resources,
loaded.pack,
loaded.gui.unwrap(),
options,
settings,
Audio::silent(&root),
None,
)
.unwrap();
let (pipe, _server) = horizon_protocol::connection::Pipe::pair();
game.connect_local(pipe, "Steve").unwrap();
let builtin = game.remote.as_ref().unwrap().builtin.clone();
let id = |registry: &str, name: &str| builtin.get(registry).unwrap().id(name).unwrap();
let entity = |entity: i32, kind: &str, position: [f64; 3]| play::AddEntity {
id: entity,
uuid: entity as u128,
kind: id("minecraft:entity_type", kind),
position,
velocity: [0.0; 3],
pitch: 0,
yaw: 64,
head_yaw: 64,
data: 0,
};
let add =
|id: i32, kind: &str, position: [f64; 3]| C::AddEntity(entity(id, kind, position));
let data = |entity: i32, value: (u8, i32, Value)| {
C::SetEntityData(play::SetEntityData {
id: entity,
values: vec![value],
})
};
game.handle_packet(C::Login(play::Login {
player_id: OWN_PLAYER,
hardcore: false,
levels: vec!["minecraft:overworld".into()],
max_players: 20,
chunk_radius: 8,
simulation_distance: 8,
reduced_debug_info: false,
show_death_screen: true,
limited_crafting: false,
spawn: play::SpawnInfo {
dimension_type: 0,
dimension: "minecraft:overworld".into(),
seed: 1,
game_type: 0,
previous_game_type: None,
debug: false,
flat: false,
last_death: None,
portal_cooldown: 0,
sea_level: 63,
},
online_mode: false,
enforces_secure_chat: false,
}))
.unwrap();
game.handle_packet(C::PlayerPosition(play::PlayerPosition {
teleport: 1,
position: [0.5, 65.0, 0.5],
delta: [0.0; 3],
yaw: 0.0,
pitch: 0.0,
relatives: 0,
}))
.unwrap();
// What the server sends for `/summon zombie`, and for a calf.
game.handle_packet(add(ZOMBIE, "minecraft:zombie", [1.5, 64.0, 2.5]))
.unwrap();
game.handle_packet(add(CALF, "minecraft:cow", [-3.5, 64.0, 0.5]))
.unwrap();
game.handle_packet(data(
CALF,
(DATA_BABY_ID, serializer::BOOLEAN, Value::Bool(true)),
))
.unwrap();
let entities = game.client_entities();
let listed = |id: i32| entities.iter().find(|e| e.id == id as u32);
assert_eq!(entities.len(), 2);
assert!(listed(OWN_PLAYER).is_none(), "the window's own player");
let zombie = listed(ZOMBIE).unwrap();
assert_eq!(zombie.kind, "minecraft:zombie");
assert_eq!(zombie.position_at(0.5), [1.5, 64.0, 2.5]);
assert_eq!(zombie.yaw, 90.0);
assert!(!zombie.baby);
assert_eq!(zombie.texture.as_deref(), Some("entity/zombie/zombie"));
let calf = listed(CALF).unwrap();
assert!(calf.baby);
assert_eq!(
calf.texture.as_deref(),
Some("entity/cow/cow_temperate_baby")
);
// A dropped item is listed once its stack arrives.
game.handle_packet(add(DIAMONDS, "minecraft:item", [0.5, 65.0, 4.5]))
.unwrap();
assert!(game.client_items().is_empty());
let diamonds = Stack::new(id("minecraft:item", "minecraft:diamond"), 3);
game.handle_packet(data(
DIAMONDS,
(
DATA_ITEM,
serializer::ITEM_STACK,
Value::Item(Some(diamonds)),
),
))
.unwrap();
let items = game.client_items();
assert_eq!(items.len(), 1);
assert_eq!(items[0].id, DIAMONDS as u32);
assert_eq!(
(&*items[0].stack.item, items[0].stack.count),
("minecraft:diamond", 3)
);
assert_eq!(items[0].position_at(1.0), [0.5, 65.0, 4.5]);
// Another player: its list entry, a spectator, then its entity. The
// frame's skin refresh (`draw_tab_list`) and a client tick
// (`isSpectator` from the list) follow.
game.handle_packet(C::PlayerInfoUpdate(play::PlayerInfoUpdate {
actions: ADD_PLAYER | UPDATE_GAME_MODE,
entries: vec![play::PlayerInfo {
uuid: ALEX_UUID,
name: Some("Alex".into()),
game_mode: Some(SPECTATOR),
..Default::default()
}],
}))
.unwrap();
game.handle_packet(C::AddEntity(play::AddEntity {
uuid: ALEX_UUID,
..entity(ALEX, "minecraft:player", [3.5, 64.0, -1.5])
}))
.unwrap();
game.update_remote_skins();
game.tick_remote().unwrap();
let alex = game
.client_entities()
.into_iter()
.find(|e| e.id == ALEX as u32)
.unwrap();
assert_eq!(alex.player_uuid, Some(ALEX_UUID));
assert_eq!(alex.player_name.as_deref(), Some("Alex"));
assert!(alex.spectator);
assert_eq!(alex.texture.as_deref(), Some("entity/player/slim/efe"));
let pixels = (TEXTURE_SIDE * TEXTURE_SIDE) as usize * RGBA_BYTES;
let face = game.client_texture("entity/zombie/zombie").unwrap();
assert_eq!((face.width, face.height), (TEXTURE_SIDE, TEXTURE_SIDE));
assert_eq!(face.rgba.len(), pixels);
// A downloaded skin comes from memory.
let skin = vec![7; pixels];
game.skin_downloads
.borrow_mut()
.remember_image("skins/0123abcd", &skin);
assert_eq!(game.client_texture("skins/0123abcd").unwrap().rgba, skin);
assert!(
game.client_texture("entity/zombie/no_such_zombie")
.is_none()
);
let skin = game.client_texture("entity/player/slim/efe").unwrap();
assert_eq!((skin.width, skin.height), (TEXTURE_SIDE, TEXTURE_SIDE));
// A name that climbs out of the packs is refused, even where a picture
// is there.
let packs = std::env::temp_dir().join(format!("horizon-texture-{}", std::process::id()));
let textures = packs.join("assets/minecraft/textures");
std::fs::create_dir_all(&textures).unwrap();
let png =
std::fs::read(root.join("assets/minecraft/textures/entity/zombie/zombie.png")).unwrap();
std::fs::write(textures.join("inside.png"), &png).unwrap();
std::fs::write(packs.join("outside.png"), &png).unwrap();
game.options.resources = packs.clone();
assert!(game.client_texture("inside").is_some());
assert!(game.client_texture("../../../outside").is_none());
std::fs::remove_dir_all(&packs).unwrap();
}
}
crates/horizon-client/src/game/native_damage.rs
+85
View File
@@ -0,0 +1,85 @@
//! Who a hit names, for `native_living_incoming_damage_v3` (docs/native-mods.md, "Server hooks
//! for plugin ports"): the hit arrives through `health::HURT_SERVER` with entity ids only, and
//! no `Game` to look a player up in, so the server's players are noted by entity id as each
//! guest's turn starts. Kept out of `native_hooks.rs`, whose lines may not hold macros.
use horizon_client::health::{Hurting, knockback_attacker};
use horizon_client::mobs::Who;
use std::{cell::RefCell, collections::HashMap};
/// More players than a server holds at once: past it, the notes start over (an entity id
/// is never reused, so a left or respawned player's note is only stale).
const MAX_NOTED: usize = 4096;
thread_local! {
/// The server's players' UUIDs by entity id, noted on the thread that ticks the world.
static PLAYERS: RefCell<HashMap<i32, u128>> = RefCell::new(HashMap::new());
}
/// Notes that the player with entity id `entity` is `uuid` (a guest whose turn starts), while
/// a native mod is loaded: a hit on them or by them is named by it from then on.
pub(super) fn note_player(entity: i32, uuid: u128) {
if horizon_client::mod_api::mods().is_empty() {
return;
}
PLAYERS.with(|players| {
let mut players = players.borrow_mut();
if players.len() >= MAX_NOTED && !players.contains_key(&entity) {
players.clear();
}
players.insert(entity, uuid);
});
}
/// The UUID of the player with entity id `entity`, if one was noted.
fn player_uuid(entity: i32) -> Option<u128> {
PLAYERS.with(|players| players.borrow().get(&entity).copied())
}
/// The victim's UUID (a player's), the hit's attacker (the causing entity), its UUID and the
/// direct entity, each none when not known.
pub(super) struct Parties {
pub victim_uuid: Option<u128>,
pub attacker: Option<u32>,
/// A player attacker's UUID.
pub attacker_uuid: Option<u128>,
pub direct: Option<u32>,
}
/// Who `hurting` names. The causing entity is the source's, or a mob's attacker; a player
/// attacker (`Who::Player`) and a source that names none fall back to the synchronous attack in
/// progress (`health::knockback_attacker`), as `native_living_knockback_v2` does. An attacker
/// that is the victim itself (thorns inside the victim's own attack) is none.
pub(super) fn parties(hurting: &Hurting<'_>) -> Parties {
let scope = knockback_attacker();
let (victim, victim_uuid, causing, direct) = match hurting {
Hurting::Player(entity, source) => {
(*entity, player_uuid(*entity), source.causing, source.direct)
}
Hurting::Mob(mob, damage) => {
let causing = match damage.attacker {
Some(Who::Mob(id)) => id as i32,
Some(Who::Player) => scope,
None => 0,
};
let direct = if super::creatures::melee(damage.kind) {
causing
} else {
0
};
// A mob's UUID is the game's (`persist.uuids`), out of reach here.
(mob.id as i32, None, causing, direct)
}
Hurting::Dragon(entity, source) | Hurting::ArmorStand(entity, source) => {
(*entity, None, source.causing, source.direct)
}
};
let causing = if causing != 0 { causing } else { scope };
let known = |id: i32| (id > 0 && id != victim).then_some(id as u32);
let attacker = known(causing);
Parties {
victim_uuid,
attacker,
attacker_uuid: attacker.and_then(|a| player_uuid(a as i32)),
direct: known(direct),
}
}
crates/horizon-client/src/game/native_diagnostics.rs
+251
View File
@@ -0,0 +1,251 @@
//! What a server's diagnostics mod reads (docs/native-mods.md, "Server hooks
//! for plugin ports: diagnostics"): the tick clock as vanilla and Bukkit
//! report it, what each open level holds, the packets each player's
//! connection carries, and the switches of the tick's profiler (spans and
//! sampled mob costs). Reads only; nothing here changes what the server
//! does.
use super::{Dim, Game, commands::Target, native_entities::target_id, tick_profile};
use horizon_client::{
mod_api::{NativeLevelStats, NativeMobCost},
world::World,
};
use std::collections::BTreeMap;
// Native mods use these; nothing in Horizon does.
#[allow(dead_code)]
impl Game<'_> {
/// The last 100 server ticks' durations in nanoseconds, as vanilla's
/// `MinecraftServer.getTickTimesNanos` lays them out: the tick numbered
/// `n` at index `n % 100` (0 where none was recorded yet). Sort a copy
/// for percentiles; the average is `native_tick_stats`'. On a client, its
/// own ticks. API @API:tick_times@.
pub(super) fn native_tick_times(&self) -> Vec<u64> {
self.clock.tick_times_nanos()
}
/// The ticks a second over the last one, five and fifteen minutes
/// (Bukkit's `Server.getTPS`), measured between the ends of the recorded
/// ticks and averaged once a second as a load average is; 20 at the
/// start. A sprint reads more than the rate, a server that falls behind
/// less. API @API:tick_times@.
pub(super) fn native_tps(&self) -> [f64; 3] {
self.clock.tps()
}
/// The counts of the open level `dimension` (`minecraft:the_nether`):
/// its loaded and forced chunks, its block entities (and how many tick),
/// and its entities and block entities by type. A level not in place is
/// swapped in for the count and back, as `/execute in` does; the players
/// are those the hub holds, so inside a player's own hook (the hub taken
/// out) none are counted. A walk over every entity: once a second or
/// less, not every tick. None on a client and for a level that isn't
/// open. API @API:level_stats@.
pub(super) fn native_level_stats(&mut self, dimension: &str) -> Option<NativeLevelStats> {
let dim = self.diagnosed_level(dimension)?;
self.with_level_in_place(dim, |game| {
let mut entities = BTreeMap::new();
for (_, kind, _) in game.entities_in_place() {
*entities.entry(kind).or_default() += 1;
}
let mut block_entity_types = BTreeMap::new();
for (_, kind) in game.block_entity_types(&game.world) {
*block_entity_types.entry(kind).or_default() += 1;
}
NativeLevelStats {
chunks: game.world.chunks.len(),
forced_chunks: game.streaming.forced.len(),
block_entities: game.world.block_entities.len(),
ticking_block_entities: game.world.block_entities.ticking_len(),
entities: most_first(entities),
block_entity_types: most_first(block_entity_types),
}
})
}
/// Every entity of the open level `dimension`: its id (the one events
/// and `native_entity` take), its type and its position, players
/// included (as `native_level_stats` counts them). Empty on a client and
/// for a level that isn't open. API @API:level_stats@.
pub(super) fn native_level_entities(
&mut self,
dimension: &str,
) -> Vec<(u32, String, [f64; 3])> {
let Some(dim) = self.diagnosed_level(dimension) else {
return Vec::new();
};
self.with_level_in_place(dim, Self::entities_in_place)
.unwrap_or_default()
}
/// Every block entity of the open level `dimension`: its position and
/// its type, the vanilla block entity type of its block (`minecraft:chest`,
/// `minecraft:barrel`, `minecraft:mob_spawner`), else the block's name (a
/// mod's). Empty on a client and for a level that isn't open. API
/// @API:level_stats@.
pub(super) fn native_level_block_entities(&self, dimension: &str) -> Vec<([i32; 3], String)> {
let world = match self.diagnosed_level(dimension) {
Some(dim) if dim == self.dim => Some(&self.world),
Some(dim) => self.levels.parked_world(dim),
None => None,
};
world.map_or_else(Vec::new, |world| self.block_entity_types(world))
}
/// Keep (or stop keeping) every player's play packets for
/// `native_server_packets`, from now on: while on, each packet costs the
/// network thread a lock and a list entry, so turn it on for a session
/// and off after. Off drops what is kept. A switch for the whole server,
/// shared by every mod. API @API:server_packets@.
pub(super) fn native_count_packets(&self, on: bool) {
horizon_client::lan::conn::count_packets(on);
if !on {
for g in self.lan.iter().flat_map(|h| h.hub.guests.iter()) {
g.sender.take_packets();
}
}
}
/// The end of a server tick: each player's packets kept since the last
/// one go to `native_server_packets`. One relaxed load while nobody counts.
pub(super) fn diagnostics_packets_tick(&mut self) {
if !horizon_client::lan::conn::counting_packets() {
return;
}
let kept: Vec<_> = self
.lan
.iter()
.flat_map(|h| h.hub.guests.iter())
.map(|g| (g.uuid, g.sender.take_packets()))
.collect();
for (player, [sent, received]) in kept {
if !sent.is_empty() {
self.native_server_packets(player, &sent, true);
}
if !received.is_empty() {
self.native_server_packets(player, &received, false);
}
}
}
/// Record the server tick's spans for `native_server_tick_timed` (or no
/// longer): elsewhere than on a dedicated server, which records them
/// anyway, the hook fires only while they are on. One switch shared with
/// `HORIZON_SPIKES`, performance reports and every mod: spans stay on
/// while anyone wants them. Spans are recorded on every thread (two clock
/// reads a step): turn them on for a profiling session and off after.
/// Only on a server. API @API:server_tick_timed@.
pub(super) fn native_spans(&self, on: bool) {
if self.native_authoritative() {
tick_profile::want_spans(tick_profile::SPANS_MOD, on);
}
}
/// Time every mob's own tick (its riders inside it) from now on, or no
/// longer, summed by level and mob type for `native_take_mob_costs`:
/// two clock reads and a map update a mob while on, one thread-local
/// read off. Sampled apart from a performance report's, so both can run.
/// For a lighter profile, turn it on in `ServerTickStart` of one tick in
/// N and off after. Call it from a server hook (it belongs to the server
/// thread). API @API:server_tick_timed@.
pub(super) fn native_mob_cost_sampling(&self, on: bool) {
tick_profile::set_mod_sampling(on);
}
/// The mob costs sampled since the last call (`native_mob_cost_sampling`),
/// costliest first; clears them. API @API:server_tick_timed@.
pub(super) fn native_take_mob_costs(&self) -> Vec<NativeMobCost> {
tick_profile::take_mod()
.into_iter()
.map(|c| NativeMobCost {
dimension: c.dimension.to_owned(),
kind: c.kind,
nanos: c.nanos,
mob_ticks: c.mob_ticks,
})
.collect()
}
/// The open level `dimension` names, on a server.
fn diagnosed_level(&self, dimension: &str) -> Option<Dim> {
if !self.native_authoritative() {
return None;
}
std::iter::once(self.dim)
.chain(self.levels.parked_dims())
.find(|d| d.id() == dimension)
}
/// `f` with the level `dim` in place, then the level that was in place
/// back (`/execute in`'s swap). None when it could not be opened.
fn with_level_in_place<R>(&mut self, dim: Dim, f: impl FnOnce(&Self) -> R) -> Option<R> {
let back = self.enter_command_level(dim);
let result = (self.dim == dim).then(|| f(self));
if let Some(back) = back {
self.enter_command_level(back);
}
result
}
/// The entities of the level in place, as a selector finds them (`@e`),
/// and the hub's players in it.
fn entities_in_place(&self) -> Vec<(u32, String, [f64; 3])> {
let mut out = Vec::new();
for t in self.level_candidates() {
if let Target::Mob(id) = t
&& !self.mobs.iter().any(|m| m.id == id && !m.removed)
{
continue;
}
if let (Some(id), Some(pos)) = (target_id(t), self.target_position(t)) {
out.push((id, self.target_type(t), pos));
}
}
let dimension = self.dim.id();
for g in self.lan.iter().flat_map(|h| h.hub.guests.iter()) {
if g.placed && g.dimension == dimension {
out.push((
g.entity_id as u32,
"minecraft:player".to_owned(),
g.position,
));
}
}
out
}
/// A world's block entities with their types (`native_level_block_entities`).
fn block_entity_types(&self, world: &World) -> Vec<([i32; 3], String)> {
let facts = self.res.facts();
world
.block_entities
.iter()
.map(|(&(x, y, z), _)| {
let name = &facts.get(world.block(x, y, z)).name;
let kind = horizon_client::lan::chunks::block_entity_type(name)
.map_or_else(|| name.to_string(), str::to_owned);
([x, y, z], kind)
})
.collect()
}
}
/// Counts by name, the most first and ties by name.
fn most_first(counts: BTreeMap<String, usize>) -> Vec<(String, usize)> {
let mut out: Vec<_> = counts.into_iter().collect();
out.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
out
}
#[cfg(test)]
mod tests {
/// Most first; a tie keeps the names in order.
#[test]
fn counts_come_most_first() {
let counts = [
("minecraft:cow", 2),
("minecraft:bat", 2),
("minecraft:zombie", 5),
]
.map(|(k, n)| (k.to_owned(), n))
.into_iter()
.collect();
let names: Vec<_> = super::most_first(counts)
.into_iter()
.map(|(k, n)| format!("{k} {n}"))
.collect();
assert_eq!(
names,
["minecraft:zombie 5", "minecraft:bat 2", "minecraft:cow 2"]
);
}
}
crates/horizon-client/src/game/native_entities.rs
+97 -8
View File
@@ -100,7 +100,7 @@ fn root_id(target: Option<Target>, first: u32, live: impl Fn(u32) -> bool) -> Op
}
/// The entity id a summoned stack's root is known by.
fn target_id(t: Target) -> Option<u32> {
pub(super) fn target_id(t: Target) -> Option<u32> {
match t {
Target::Mob(id)
| Target::Item(id)
@@ -134,10 +134,12 @@ impl Game<'_> {
/// Spawns an entity of `kind` (`minecraft:item_display`) at `pos` in the
/// level in place, `dimension`, from `nbt` (its compound, as `/summon
/// <kind> <pos> <nbt>` takes it; passengers included): its id. None on a
/// client's copy of the world, for another dimension, a position outside
/// client's copy of the world, for a position outside
/// `/summon`'s bounds, a chunk that isn't loaded, a kind Horizon can't
/// load, or one a mod kept out (`native_entity_join_level`). API
/// 59.
/// 59. Since API @API:npc_any_level@, `dimension` may be any level the
/// server has loaded, which is put in place for the summon (`execute in
/// <dimension> run summon`); a level not loaded is refused.
pub(super) fn native_summon(
&mut self,
dimension: &str,
@@ -145,6 +147,13 @@ impl Game<'_> {
pos: [f64; 3],
nbt: Compound,
) -> Option<u32> {
if (self.serving.is_some() || self.options.dedicated.is_some())
&& dimension != self.dim.id()
{
return self
.npc_in_level(dimension, |g| g.native_summon(dimension, kind, pos, nbt))
.flatten();
}
if !self.native_simulates_level(dimension) || !position_ok(pos) {
return None;
}
@@ -250,14 +259,94 @@ impl Game<'_> {
/// Removes entity `id`, one Horizon keeps without simulating, as `/kill`
/// does (it drops nothing and isn't saved). False for no such entity or
/// another dimension. Mobs go with `native_remove_mob`. API
/// 59.
/// 59. Since API @API:remove_projectiles@ it also takes projectiles
/// (arrows, tridents, snowballs, eggs, pearls, fireballs, wind charges,
/// llama spit, shulker bullets, firework rockets) as `/kill` does, and a
/// server player's fishing bobber (`Entity.discard`; the player in place's,
/// or, outside a guest's turn, any of this level's players').
pub(super) fn native_remove_entity(&mut self, dimension: &str, id: u32) -> bool {
if !self.native_simulates_level(dimension) || !self.others.iter().any(|o| o.id == id) {
if !self.native_simulates_level(dimension) {
return false;
}
self.others.retain(|o| o.id != id);
self.persist.raw.remove(&id);
true
if self.others.iter().any(|o| o.id == id) {
self.others.retain(|o| o.id != id);
self.persist.raw.remove(&id);
return true;
}
// An id of 0 is a projectile no server tracks yet: never one a mod was told of.
if id != 0
&& let Some(
projectile @ (Target::Projectile(_) | Target::Trident(_) | Target::Rocket(_)),
) = self.level_entity(id as i32)
{
self.kill_target(projectile);
return true;
}
self.remove_server_hook(id)
}
/// Hurts the living entity `target` (a mob, or a player of the level `dimension`) by
/// `amount` of `damage_type` (`minecraft:mob_attack`), from `attacker` (a mob's or a
/// player's entity id: the causing and direct entity, as vanilla's
/// `damageSources().mobAttack(attacker)`; none for no entity), as `LivingEntity.hurtServer`
/// and `/damage <target> <amount> <damage_type> by <attacker>` do: armour, effects,
/// invulnerability time, knockback from the attacker, death and its message, and the damage
/// hooks (`native_living_incoming_damage` and its versions) hear it. Whether it was hurt:
/// false for an invulnerable, dead or creative target, another dimension, an entity that
/// isn't living, an attacker that isn't there, or an amount that isn't a finite number.
/// API @API:hurt_entity@.
pub(super) fn native_hurt_entity(
&mut self,
dimension: &str,
target: u32,
amount: f32,
damage_type: &str,
attacker: Option<u32>,
) -> bool {
if !self.native_simulates_level(dimension) || !amount.is_finite() {
return false;
}
let Some(victim) = self.hurt_entity_target(dimension, target) else {
return false;
};
let by = match attacker {
Some(id) => match self.hurt_entity_target(dimension, id) {
Some(t) => Some(t),
None => return false,
},
None => None,
};
let from = by.and_then(|t| self.target_position(t));
self.damage_target(victim, amount, damage_type, None, by, from)
}
/// The player or mob `id` names in the level `dimension`: a player by their entity id
/// (the one in place, whose turn it is, as `Target::Player`), a mob that is there.
fn hurt_entity_target(&self, dimension: &str, id: u32) -> Option<Target> {
let entity = i32::try_from(id).ok()?;
let guest = self
.lan
.iter()
.flat_map(|h| h.hub.guests.iter())
.find(|g| g.placed && g.entity_id == entity && g.dimension == dimension);
if let Some(g) = guest {
let acting = self.lan_acting == Some(g.conn) && self.player.is_some();
return Some(if acting {
Target::Player
} else {
Target::Guest(g.conn)
});
}
// The player in place while the hub is out (a guest's turn), or a LAN host.
if (self.lan_acting.is_some() || self.options.dedicated.is_none())
&& self.player.as_ref().is_some_and(|p| p.entity_id == entity)
{
return Some(Target::Player);
}
match self.level_entity(entity)? {
Target::Mob(mob) if self.mobs.iter().any(|m| m.id == mob && m.alive()) => {
Some(Target::Mob(mob))
}
_ => None,
}
}
}
Loaded 100 of 488 files, more files were not shown because too many files have changed in this diff. Show more