diff --git a/.dockerignore b/.dockerignore
index 417a1867c..458330c93 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -2,7 +2,6 @@
target/
.local/
**/node_modules/
-website/
benchmarks/
packs/
mods/
diff --git a/.gitattributes b/.gitattributes
index 358aeae7a..f9e1922d7 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -2,5 +2,5 @@
# where Git for Windows' core.autocrlf would check them out with CRLF.
docs/launcher-commands.md text eol=lf
docs/horizon-ctl-commands.md text eol=lf
-website/src/tokens.css text eol=lf
+crates/horizon-theme/tokens.css text eol=lf
docs/api/*-reference.md text eol=lf
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index eff82fa99..39ea920da 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -73,6 +73,42 @@ jobs:
run: |
cargo +stable test --workspace --lib --bins --tests --features horizon-client/mods,horizon-mods/pack
cargo +stable test --workspace --doc --features horizon-client/mods,horizon-mods/pack
+ # The launcher is its own workspace (launcher/Cargo.toml), so verify's cargo runs never build it. A pull request that
+ # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
+ # alone and break it together (#2059 and the registry ratings did, 2026-10-26).
+ launcher:
+ runs-on: ubuntu-latest
+ timeout-minutes: 30
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+ - name: Does this pull request change the launcher or a crate it builds?
+ if: github.event_name == 'pull_request'
+ id: launcher
+ env:
+ BASE_SHA: ${{ github.event.pull_request.base.sha }}
+ HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+ run: python3 tools/ci/rust_changes.py --launcher "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
+ - name: Install Rust and the headers GPUI links against
+ if: steps.launcher.outputs.required != 'false'
+ run: |
+ sudo apt-get update && sudo apt-get install -y --no-install-recommends libxkbcommon-x11-dev libwayland-dev \
+ libx11-xcb-dev libfontconfig-dev libvulkan-dev libasound2-dev libudev-dev
+ rustup toolchain install stable --profile minimal --component rustfmt --component clippy
+ - uses: Swatinem/rust-cache@v2
+ if: steps.launcher.outputs.required != 'false'
+ with:
+ workspaces: launcher
+ shared-key: launcher
+ save-if: ${{ github.ref == 'refs/heads/main' }}
+ - name: Check the launcher's formatting, lint and tests
+ if: steps.launcher.outputs.required != 'false'
+ working-directory: launcher
+ run: |
+ cargo +stable fmt --check
+ cargo +stable clippy --all-targets --locked -- -D warnings
+ cargo +stable test --locked --lib
# Most pull requests leave the harnesses to parity-main, which runs them on main a batch of merges at a time
# (.github/workflows/parity-main.yml; releases wait for it). A pull request still runs them itself when it changes
# a harness, an oracle, a probe or the runner, or carries the run-parity label (run-parity.yml, when it is added).
diff --git a/.github/workflows/parity-main.yml b/.github/workflows/parity-main.yml
index c47005ab0..70fb33796 100644
--- a/.github/workflows/parity-main.yml
+++ b/.github/workflows/parity-main.yml
@@ -48,6 +48,9 @@ jobs:
GH_TOKEN: ${{ github.token }}
run: echo "sha=$(python3 tools/parity_main.py base)" >> "$GITHUB_OUTPUT"
- name: The harnesses the merges since then can affect
+ id: harnesses
+ # A failure here is judged by the next step: the run passes when every failed harness passes again at HEAD.
+ continue-on-error: true
env:
PARITY_HOSTS: ''
BASE_SHA: ${{ steps.base.outputs.sha }}
@@ -55,8 +58,8 @@ jobs:
echo "Merges since ${BASE_SHA}:"
git log --first-parent --format=' %h %s' "$BASE_SHA..HEAD"
python3 tools/parity.py --changed "$BASE_SHA" --timeout 2400
- - name: The merge that broke them
- if: failure()
+ - name: A flake, or the merge that broke them
+ if: steps.harnesses.outcome == 'failure'
env:
GH_TOKEN: ${{ github.token }}
PARITY_HOSTS: ''
@@ -65,7 +68,7 @@ jobs:
rm -rf .local/parity-main-logs && cp -R .local/parity-runner/logs .local/parity-main-logs 2>/dev/null || true
python3 tools/parity_main.py bisect "$BASE_SHA" --comment
- name: Logs of the failed harnesses
- if: failure()
+ if: steps.harnesses.outcome == 'failure'
uses: actions/upload-artifact@v4
with:
name: parity-main-logs
diff --git a/AGENTS.md b/AGENTS.md
index dcd4ca595..e1fa9e7fe 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -54,7 +54,8 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
Other top-level folders: `tools/` (harnesses and dev scripts), `tests/` (Python unit tests: `python3 -m
unittest discover -s tests`), `mods/horizon/src/test/java/dev/horizonlab/parity/` (Java oracles),
-`website/` (playhorizon.dev; its paths are relative to `website/`), `docs/`, `.github/workflows/`.
+`docs/`, `.github/workflows/`. The website (playhorizon.dev) is the private ludovic111/horizon-site: its build
+reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` and `crates/horizon-theme/tokens.css` from main.
## Build and test fast
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 21951c083..03f3bd97b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,8 +4,8 @@ Thanks for helping. Horizon is Minecraft: Java Edition 26.3 rewritten in Rust, a
everything is that **it plays exactly like vanilla**. This page is the short version of how we work; questions are
welcome on [Discord](https://discord.gg/HcTeMZxe5E).
-This repository holds the game, the launcher and the website, plus the tools, tests and docs that build, check and
-release them. Anything else (videos, Discord and other community material) lives elsewhere.
+This repository holds the game and the launcher, plus the tools, tests and docs that build, check and release them.
+The website (playhorizon.dev) is built in a separate repository from this one's README, `docs/api/` and roadmap. Anything else (videos, Discord and other community material) lives elsewhere.
**Where to start: [playhorizon.dev/hub](https://playhorizon.dev/hub).** It shows what is being done now and next
([ROADMAP.md](ROADMAP.md) in the repository), the work board, good first tasks, and the forms to report a bug or
diff --git a/Cargo.lock b/Cargo.lock
index 0e93bba0e..bbbac4b2c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -216,6 +216,13 @@ version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+[[package]]
+name = "beacons"
+version = "0.1.0"
+dependencies = [
+ "horizon-mod-sdk",
+]
+
[[package]]
name = "bit-set"
version = "0.10.0"
@@ -1368,6 +1375,7 @@ dependencies = [
"horizon-core",
"horizon-dualsense",
"horizon-friends",
+ "horizon-hdr",
"horizon-mods",
"horizon-protocol",
"horizon-server-files",
@@ -1426,6 +1434,14 @@ dependencies = [
"spake2",
]
+[[package]]
+name = "horizon-hdr"
+version = "0.1.0"
+dependencies = [
+ "ash",
+ "wgpu",
+]
+
[[package]]
name = "horizon-mod-sdk"
version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index e4628f962..ac1a19865 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
[workspace]
exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"]
-members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"]
+members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-hdr", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "crates/horizon-mod-sdk/examples/beacons", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"]
resolver = "2"
[workspace.package]
diff --git a/ROADMAP.md b/ROADMAP.md
index a04eca2ce..9b82f4fac 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -134,7 +134,7 @@ Better tools for mod makers: a test runner that needs no game window, templates
`cargo horizon-mod test` runs a mod's test scripts against a fake game snapshot ([#1816](https://github.com/ludovic111/horizon/issues/1816)) and, for server mods, scripted server events ([#1837](https://github.com/ludovic111/horizon/issues/1837)); the content template and the guides are merged ([#1859](https://github.com/ludovic111/horizon/issues/1859), [#1810](https://github.com/ludovic111/horizon/issues/1810), [docs/api/stability.md](docs/api/stability.md)). Left: templates for hud, server and machine mods, typed wrappers in the SDK, a frozen 0.1 compatibility mod that every runtime must load, a CI check that fails when a stable reference entry is removed without a new major version, and the SDK on crates.io once the API is stable.
-More: [website/docs/test-a-mod.md](website/docs/test-a-mod.md)
+More: [https://playhorizon.dev/docs/test-a-mod](https://playhorizon.dev/docs/test-a-mod)
@@ -160,6 +160,66 @@ Translatable components resolved through the selected language for items, contai
+#### Cooldowns drawn on items
+
+After you throw an ender pearl, its slot should show the cooldown sweeping away, as in vanilla.
+
+Technical
+
+Vanilla draws `ItemCooldowns`' percent as a white overlay over the slot (`GuiGraphicsExtractor.itemDecorations` and `itemCooldown`) in the hotbar and in inventories. Issue [#1763](https://github.com/ludovic111/horizon/issues/1763).
+
+More: [#1933](https://github.com/ludovic111/horizon/issues/1933)
+
+Technical
+
+Vanilla checks `ChatVisiblity` before it delivers chat and system messages ([#1376](https://github.com/ludovic111/horizon/issues/1376)), and chat uses the team-formatted display name ([#1378](https://github.com/ludovic111/horizon/issues/1378)). Both issues have exact steps to reproduce.
+
+More: [#1932](https://github.com/ludovic111/horizon/issues/1932) · [#1841](https://github.com/ludovic111/horizon/issues/1841)
+
+Technical
+
+26.3's `AbstractWidget` asks for a cursor from `CursorTypes` when it is hovered; winit's `CursorIcon::Pointer` gives the same shape. Issue [#1347](https://github.com/ludovic111/horizon/issues/1347).
+
+More: [#1897](https://github.com/ludovic111/horizon/issues/1897)
+
+Technical
+
+`EditBox` deletes by word with Ctrl ([#1764](https://github.com/ludovic111/horizon/issues/1764)); the Game Rules and Statistics lists' scroll bars can't be dragged ([#1782](https://github.com/ludovic111/horizon/issues/1782), after [#978](https://github.com/ludovic111/horizon/issues/978)).
+
+More: [#1884](https://github.com/ludovic111/horizon/issues/1884) · [#1931](https://github.com/ludovic111/horizon/issues/1931)
+
+Technical
+
+Vanilla's `Chicken.aiStep` updates `flap` and `flapSpeed` when the chicken isn't on the ground, and the model's wings follow them. Issue [#1706](https://github.com/ludovic111/horizon/issues/1706).
+
+More: [#1892](https://github.com/ludovic111/horizon/issues/1892)
+
+Technical
-A player runs their own agent locally with `horizon-ctl` and the MCP servers ([docs/agent-control.md](docs/agent-control.md)), `cargo horizon-mod`, `horizon-port-pack` and the parity harnesses as the check. Horizon writes the guide ([website/docs/agents.md](website/docs/agents.md), [docs/modpacks.md](docs/modpacks.md)) and runs no agents, accounts or keys for players. The No AI switch turns all of it off.
+A player runs their own agent locally with `horizon-ctl` and the MCP servers ([docs/agent-control.md](docs/agent-control.md)), `cargo horizon-mod`, `horizon-port-pack` and the parity harnesses as the check. Horizon writes the guide (playhorizon.dev/docs/agents, [docs/modpacks.md](docs/modpacks.md)) and runs no agents, accounts or keys for players. The No AI switch turns all of it off.
+
+More: [https://playhorizon.dev/docs/agents](https://playhorizon.dev/docs/agents)
Technical
-`horizon-launcher play --arg=--benchmark --arg=standard` writes a JSON report; `horizon-launcher data benchmark ` shows what would be sent and uploads it ([website/docs/performance.md](website/docs/performance.md)). Results from three installs with the same hardware appear on the Benchmarks page. Example: [#1711](https://github.com/ludovic111/horizon/issues/1711).
+`horizon-launcher play --arg=--benchmark --arg=standard` writes a JSON report; `horizon-launcher data benchmark ` shows what would be sent and uploads it (playhorizon.dev/docs/performance). Results from three installs with the same hardware appear on the Benchmarks page. Example: [#1711](https://github.com/ludovic111/horizon/issues/1711).
+
+More: [https://playhorizon.dev/docs/performance](https://playhorizon.dev/docs/performance)
Technical
-
-Vanilla draws `ItemCooldowns`' percent as a white overlay over the slot (`GuiGraphicsExtractor.itemDecorations` and `itemCooldown`) in the hotbar and in inventories. Issue [#1763](https://github.com/ludovic111/horizon/issues/1763).
-
-Technical
-
-Vanilla checks `ChatVisiblity` before it delivers chat and system messages ([#1376](https://github.com/ludovic111/horizon/issues/1376)), and chat uses the team-formatted display name ([#1378](https://github.com/ludovic111/horizon/issues/1378)). Both issues have exact steps to reproduce.
-
-Technical
-
-26.3's `AbstractWidget` asks for a cursor from `CursorTypes` when it is hovered; winit's `CursorIcon::Pointer` gives the same shape. Issue [#1347](https://github.com/ludovic111/horizon/issues/1347).
-
-Technical
-
-`EditBox` deletes by word with Ctrl ([#1764](https://github.com/ludovic111/horizon/issues/1764)); the Game Rules and Statistics lists' scroll bars can't be dragged ([#1782](https://github.com/ludovic111/horizon/issues/1782), after [#978](https://github.com/ludovic111/horizon/issues/978)).
-
-Technical
-
-Vanilla's `Chicken.aiStep` updates `flap` and `flapSpeed` when the chicken isn't on the ground, and the model's wings follow them. Issue [#1706](https://github.com/ludovic111/horizon/issues/1706).
-
-- {
+ let (lo, hi) = (a.min_position(), a.max_position());
+ let (x0, y0, z0) = (
+ lo.x.floor() as i32,
+ lo.y.floor() as i32,
+ lo.z.floor() as i32,
+ );
+ let (x1, y1, z1) = (
+ hi.x.floor() as i32,
+ hi.y.floor() as i32,
+ hi.z.floor() as i32,
+ );
+ (y0..=y1).flat_map(move |y| (z0..=z1).flat_map(move |z| (x0..=x1).map(move |x| [x, y, z])))
+}
+
+pub fn survives(world: &impl World, bounds: Aabb) -> bool {
+ let (lo, hi) = (bounds.min_position(), bounds.max_position());
+ let anchor = Aabb::new(
+ Vec3::new(lo.x, lo.y - 0.015625, lo.z),
+ Vec3::new(hi.x.next_down(), lo.y, hi.z.next_down()),
+ );
+ // The extra eighth block expands the scan, not the intersection test.
+ let supported = blocks_in(anchor.expand_towards(Vec3::new(0.0, -0.125, 0.0))).any(|p| {
+ world
+ .outline_bounds(p)
+ .is_some_and(|shape| shape.intersects(anchor))
+ });
+ supported && !blocks_in(bounds.next_deflated()).all(|p| world.suffocating(p))
+}
+
+pub fn can_place(world: &impl World, bounds: Aabb) -> bool {
+ if !survives(world, bounds) {
+ return false;
+ }
+ let (lo, hi) = (bounds.min_position(), bounds.max_position());
+ let slab = Aabb::new(lo, Vec3::new(hi.x, lo.y + 0.015625, hi.z)).next_deflated();
+ let Ok(mut remaining) = VoxelShape::from_box(slab) else {
+ return false;
+ };
+ for shape in world.collision_shapes(slab) {
+ let Ok(next) = remaining.join(&shape, ShapeOp::ONLY_FIRST) else {
+ return false;
+ };
+ remaining = next;
+ if remaining.is_empty() {
+ return false;
+ }
+ }
+ true
+}
diff --git a/crates/horizon-client/src/debug_overlay.rs b/crates/horizon-client/src/debug_overlay.rs
index 7140905a8..f55d4ee6e 100644
--- a/crates/horizon-client/src/debug_overlay.rs
+++ b/crates/horizon-client/src/debug_overlay.rs
@@ -221,18 +221,17 @@ pub fn scale(
pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec {
let mut out = vec![GuiDraw::Push(vec![PoseOp::Scale(scale, scale)])];
for (lines, align_left) in [(columns[0], true), (columns[1], false)] {
- let placed: Vec<(&String, i32, i32)> = lines
+ let placed: Vec<(&String, i32, i32, i32)> = lines
.iter()
.enumerate()
.filter(|(_, l)| !l.is_empty())
.map(|(i, l)| {
let w = font.width(l) as i32;
let left = if align_left { 2 } else { width - 2 - w };
- (l, left, 2 + LINE_HEIGHT * i as i32)
+ (l, left, 2 + LINE_HEIGHT * i as i32, w)
})
.collect();
- for (line, left, top) in &placed {
- let w = font.width(line) as i32;
+ for (_, left, top, w) in &placed {
out.push(fill(
left - 1,
top - 1,
@@ -241,7 +240,7 @@ pub fn draw(font: &Font, columns: [&[String]; 2], scale: f32, width: i32) -> Vec
BACKGROUND,
));
}
- for (line, left, top) in placed {
+ for (line, left, top, _) in placed {
out.push(GuiDraw::Text {
text: Text::literal(line.clone()),
x: left,
diff --git a/crates/horizon-client/src/entities.rs b/crates/horizon-client/src/entities.rs
index 6e8089e9d..44f07dc82 100644
--- a/crates/horizon-client/src/entities.rs
+++ b/crates/horizon-client/src/entities.rs
@@ -95,6 +95,15 @@ impl ItemEntity {
self.health -= fire_damage as i32;
}
}
+ // CactusBlock.entityInside: `entity.hurt(cactus, 1.0)`. An item has no
+ // hurt cooldown, so it loses 1 health every tick it touches a cactus
+ // (5 health: gone in 5 ticks). Fire resistance does not help;
+ // `ItemStack.canBeHurtBy` only skips it for a damage_resistant stack.
+ if crate::motion::environment::cactus_contact(world, registry, self.bounds())
+ && !items.resists_cactus(&self.stack)
+ {
+ self.health -= 1;
+ }
ItemEnvironmentTick {
alive: self.health > 0,
lava_hurt,
@@ -385,8 +394,29 @@ pub struct ExperienceOrb {
pub value: u32,
pub age: u32,
pub on_ground: bool,
+ /// `ExperienceOrb.count`: orbs merged into this one; each pickup gives
+ /// `value` once and takes one off.
+ pub count: u32,
+ /// `Entity.tickCount`, which paces `ExperienceOrb.scanForMerges`.
+ pub ticks: u32,
}
impl ExperienceOrb {
+ pub fn bounds(&self) -> Aabb {
+ let h = 0.25;
+ Aabb::new(
+ Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
+ Vec3::new(
+ self.position.x + h,
+ self.position.y + 0.5,
+ self.position.z + h,
+ ),
+ )
+ }
+ /// `ExperienceOrb.canMerge(orb, id, value)` for an orb that is not removed:
+ /// the same value and ids a multiple of 40 apart.
+ pub fn can_merge(&self, id: u32, value: u32) -> bool {
+ self.value == value && (self.id as i32).wrapping_sub(id as i32) % 40 == 0
+ }
/// ExperienceOrb.getExperienceValue: the largest orb size not above `value`.
pub fn split(value: u32) -> u32 {
[2477, 1237, 617, 307, 149, 73, 37, 17, 7, 3, 1]
@@ -416,7 +446,9 @@ impl ExperienceOrb {
facts: &BlockFacts,
collision: &BlockCollisionRegistry<'_>,
player: Option<[f64; 3]>,
+ next_float: &mut dyn FnMut() -> f32,
) -> bool {
+ self.ticks += 1;
self.previous = self.position;
let block = world.block(
self.position.x.floor() as i32,
@@ -432,6 +464,14 @@ impl ExperienceOrb {
} else {
self.velocity.y -= 0.03;
}
+ if facts.get(block).fluid == Fluid::Lava {
+ // ExperienceOrb.tick: lava throws the orb back out.
+ self.velocity = Vec3::new(
+ f64::from((next_float() - next_float()) * 0.2),
+ f64::from(0.2f32),
+ f64::from((next_float() - next_float()) * 0.2),
+ );
+ }
if let Some(p) = player {
let d = [
(p[0] - self.position.x) / 8.0,
@@ -449,15 +489,7 @@ impl ExperienceOrb {
);
}
}
- let h = 0.25;
- let bounds = Aabb::new(
- Vec3::new(self.position.x - h, self.position.y, self.position.z - h),
- Vec3::new(
- self.position.x + h,
- self.position.y + 0.5,
- self.position.z + h,
- ),
- );
+ let bounds = self.bounds();
let mut scene = SceneCollisions {
world,
binding: collision,
@@ -494,6 +526,31 @@ impl ExperienceOrb {
self.age < 6000
}
}
+/// `ExperienceOrb.scanForMerges`, run by each orb on `tickCount % 20 == 1`:
+/// it absorbs the orbs that `canMerge` within 0.5 blocks of its box,
+/// adding their counts and keeping the smaller age.
+pub fn merge_orbs(orbs: &mut Vec) {
+ let mut removed = vec![false; orbs.len()];
+ for i in 0..orbs.len() {
+ if removed[i] || orbs[i].ticks % 20 != 1 {
+ continue;
+ }
+ let area = orbs[i].bounds().inflate(Vec3::new(0.5, 0.5, 0.5));
+ for j in 0..orbs.len() {
+ if j != i
+ && !removed[j]
+ && orbs[j].can_merge(orbs[i].id, orbs[i].value)
+ && orbs[j].bounds().intersects(area)
+ {
+ orbs[i].count += orbs[j].count;
+ orbs[i].age = orbs[i].age.min(orbs[j].age);
+ removed[j] = true;
+ }
+ }
+ }
+ let mut removed = removed.into_iter();
+ orbs.retain(|_| !removed.next().unwrap_or(false));
+}
/// Player experience (Player.giveExperiencePoints / getXpNeededForNextLevel).
#[derive(Clone, Copy, Debug, Default)]
pub struct Experience {
@@ -591,6 +648,57 @@ impl Painting {
)
}
}
+/// The `DyeColor` ordinal of a colour name (`DyeColor.byName`), white when
+/// the name is unknown.
+pub fn dye_index(name: &str) -> u8 {
+ crate::mobs::render::DYE_NAMES
+ .iter()
+ .position(|n| *n == name)
+ .unwrap_or(0) as u8
+}
+/// A cushion (`Cushion`, a `BlockAttachedEntity`): a 1 x 0.25 block pillow
+/// that seats a player. It sits on the top face of a block, at the clicked
+/// height, and is coloured by its `DyeColor`.
+#[derive(Clone, Debug)]
+pub struct Cushion {
+ pub id: u32,
+ /// `Entity.position`: the bottom centre of the cushion.
+ pub position: Vec3,
+ /// `BlockAttachedEntity.pos` (the saved `block_pos`).
+ pub pos: [i32; 3],
+ pub yaw: f32,
+ /// `DyeColor` ordinal: white 0, orange 1, ..., black 15.
+ pub color: u8,
+ /// BlockAttachedEntity.ticksSinceLastCheck.
+ pub check_interval: u32,
+}
+impl Cushion {
+ /// `Entity.makeBoundingBox`: x and z half a block out, y to y + 0.25.
+ pub fn bounds(&self) -> ([f64; 3], [f64; 3]) {
+ let p = self.position;
+ (
+ [p.x - 0.5, p.y, p.z - 0.5],
+ [p.x + 0.5, p.y + 0.25, p.z + 0.5],
+ )
+ }
+ /// The `DyeColor` name of the cushion.
+ pub fn color_name(&self) -> &'static str {
+ crate::mobs::render::DYE_NAMES[usize::from(self.color.min(15))]
+ }
+ /// `Cushion.getCushionItemStackWithData`: the matching coloured item.
+ pub fn item(&self) -> String {
+ format!("minecraft:{}_cushion", self.color_name())
+ }
+ /// `Cushion.interact`'s seat: the vehicle's PASSENGER attachment
+ /// `(0, 0.25, 0)` less the player's `(0, 0.6, 0)`.
+ pub fn seat(&self) -> Vec3 {
+ Vec3::new(self.position.x, self.position.y - 0.35, self.position.z)
+ }
+ /// `Entity.getDismountLocationForPassenger`: on top of the cushion.
+ pub fn dismount(&self) -> Vec3 {
+ Vec3::new(self.position.x, self.position.y + 0.25, self.position.z)
+ }
+}
/// An item frame or glow item frame (`ItemFrame`).
#[derive(Clone, Debug)]
pub struct ItemFrame {
diff --git a/crates/horizon-client/src/entity.wgsl b/crates/horizon-client/src/entity.wgsl
index 2e865dfb1..79e11719f 100644
--- a/crates/horizon-client/src/entity.wgsl
+++ b/crates/horizon-client/src/entity.wgsl
@@ -166,12 +166,23 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 {
if d >= end { return 1.0; }
return (d - start) / (end - start);
}
+// CRUMBLING_UV_BEGIN
+fn crumbling_uv(uv: vec2, packed_origin: vec2, sprite_size: vec2, dimensions: vec2) -> vec2 {
+ let size = vec2(dimensions);
+ // Undo stage_light's 16-bit quantization before adding local texels. Otherwise
+ // different stages can fall on opposite sides of a nearest-sampling boundary.
+ let origin = round(packed_origin * size);
+ let extent = max(round(sprite_size * size), vec2(1.0));
+ let local = min(floor(fract(uv) * extent), extent - vec2(1.0));
+ return (origin + local + vec2(0.5)) / size;
+}
+// CRUMBLING_UV_END
@fragment fn fs_entity(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4 {
var uv = in.uv;
if in.overlay == 6u { uv.y = in.wrap.x + fract(in.uv.y) * in.wrap.y; }
if in.overlay == 11u || in.overlay == 12u {
// Each crack's stage sprite origin comes in its light bytes (breaking::stage_light).
- uv = in.wrap + fract(in.uv) * globals.crumbling_sprite.zw;
+ uv = crumbling_uv(in.uv, in.wrap, globals.crumbling_sprite.zw, textureDimensions(atlas));
}
var color = textureSample(atlas, atlas_sampler, uv) * select(in.back_color, in.color, front);
if in.overlay == 9u || in.overlay == 10u {
diff --git a/crates/horizon-client/src/entity_nbt.rs b/crates/horizon-client/src/entity_nbt.rs
index 00576ea02..161ca12e9 100644
--- a/crates/horizon-client/src/entity_nbt.rs
+++ b/crates/horizon-client/src/entity_nbt.rs
@@ -6,7 +6,7 @@
//! survive a Horizon save.
use crate::{
arrows::Pickup,
- entities::{ArmorStand, ExperienceOrb, ItemEntity, ItemFrame, Painting},
+ entities::{ArmorStand, Cushion, ExperienceOrb, ItemEntity, ItemFrame, Painting},
mobs::{Mob, MobType, Who},
projectiles::{Projectile, ProjectileKind},
save::{
@@ -265,6 +265,19 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
Tag::Byte(i8::from(m.extra.flag2)),
);
map.insert("TimeInOverworld".into(), Tag::Int(m.extra.counter2));
+ if id == "minecraft:piglin" {
+ // InventoryCarrier.writeInventoryToTag.
+ map.insert(
+ "Inventory".into(),
+ Tag::List(
+ m.extra
+ .inventory
+ .iter()
+ .map(crate::save::item_to_nbt)
+ .collect(),
+ ),
+ );
+ }
}
"minecraft:horse"
| "minecraft:donkey"
@@ -357,6 +370,12 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
"minecraft:bat" => {
map.insert("BatFlags".into(), Tag::Byte(i8::from(m.extra.flag)));
}
+ "minecraft:turtle" => {
+ map.insert("has_egg".into(), Tag::Byte(i8::from(m.extra.flag)));
+ if let Some(home) = m.extra.home {
+ map.insert("home_pos".into(), Tag::IntArray(home.to_vec()));
+ }
+ }
"minecraft:creaking" => {
// home_pos: the heart it is bound to.
if let Some(home) = m.extra.home {
@@ -482,7 +501,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
"minecraft:zombie" => {
map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
for (key, value) in [
- ("CanBreakDoors", Tag::Byte(0)),
("DrownedConversionTime", Tag::Int(-1)),
("InWaterTime", Tag::Int(-1)),
] {
@@ -507,6 +525,13 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
}
_ => {}
}
+ // Zombie.addAdditionalSaveData: CanBreakDoors.
+ if crate::mobs::doors::is_zombie(m.species()) {
+ map.insert(
+ "CanBreakDoors".into(),
+ Tag::Byte(i8::from(m.extra.can_break_doors)),
+ );
+ }
crate::mobs::raider::write_nbt(m, map);
crate::mobs::riders::write_nbt(m, map);
// LivingEntity equipment: what the mob holds now.
@@ -706,6 +731,16 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) -
) {
m.extra.flag2 = flag(tag, "IsImmuneToZombification");
m.extra.counter2 = number(tag.get("TimeInOverworld")).unwrap_or(0) as i32;
+ if m.species() == crate::mobs::Species::Piglin
+ && let Some(Tag::List(items)) = tag.get("Inventory")
+ {
+ // InventoryCarrier.readInventoryFromTag (eight slots).
+ m.extra.inventory = items
+ .iter()
+ .filter_map(crate::save::item_from_nbt)
+ .take(8)
+ .collect();
+ }
}
if matches!(
m.species(),
@@ -847,6 +882,18 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) -
{
crate::mobs::creaking::set_transient(&mut m, [home[0], home[1], home[2]]);
}
+ if m.species() == crate::mobs::Species::Turtle {
+ // Turtle.readAdditionalSaveData: `home_pos` (else where it stands) and `has_egg`.
+ m.extra.flag = flag(tag, "has_egg");
+ m.extra.home = Some(match tag.get("home_pos") {
+ Some(Tag::IntArray(home)) if home.len() == 3 => [home[0], home[1], home[2]],
+ _ => [
+ m.position.x.floor() as i32,
+ m.position.y.floor() as i32,
+ m.position.z.floor() as i32,
+ ],
+ });
+ }
if m.species() == crate::mobs::Species::Wither {
m.extra.counter = number(tag.get("Invul")).unwrap_or(0) as i32;
}
@@ -925,6 +972,10 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap>, id: u32) -
if !crate::mobs::finalize::ageable(m.species()) && flag(tag, "IsBaby") {
crate::mobs::finalize::set_baby(&mut m, true);
}
+ // Zombie.readAdditionalSaveData: setCanBreakDoors.
+ if crate::mobs::doors::is_zombie(m.species()) {
+ crate::mobs::doors::set_can_break_doors(&mut m, flag(tag, "CanBreakDoors"));
+ }
crate::mobs::raider::read_nbt(&mut m, tag);
crate::mobs::riders::read_nbt(&mut m, tag);
// A mob saved mid-death finishes dying; one saved dead is dropped.
@@ -1043,18 +1094,18 @@ pub fn orb_to_nbt(o: &ExperienceOrb, uuid: [i32; 4]) -> Tag {
("Health", Tag::Short(5)),
("Age", Tag::Short(o.age.min(i16::MAX as u32) as i16)),
("Value", Tag::Short(o.value.min(i16::MAX as u32) as i16)),
- ("Count", Tag::Int(1)),
+ ("Count", Tag::Int(o.count.min(i32::MAX as u32) as i32)),
] {
put(&mut tag, key, value);
}
tag
}
-/// One Horizon orb per counted orb (vanilla merges orbs of equal value).
+/// One orb with its merged `Count`.
pub fn orbs_from_nbt(tag: &Tag) -> Vec {
let Some(position) = position(tag) else {
return Vec::new();
};
- let count = number(tag.get("Count")).unwrap_or(1).clamp(1, 64) as usize;
+ let count = number(tag.get("Count")).unwrap_or(1).max(1) as u32;
let orb = ExperienceOrb {
id: 0,
position,
@@ -1063,8 +1114,10 @@ pub fn orbs_from_nbt(tag: &Tag) -> Vec {
value: number(tag.get("Value")).unwrap_or(1).max(1) as u32,
age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
on_ground: flag(tag, "OnGround"),
+ count,
+ ticks: 0,
};
- vec![orb; count]
+ vec![orb]
}
/// `Projectile` + `AbstractArrow.addAdditionalSaveData` of a live arrow;
@@ -1313,6 +1366,79 @@ pub fn painting_from_nbt(tag: &Tag) -> Option<([i32; 3], u8, String)> {
let facing = (number(tag.get("facing")).unwrap_or(0) & 3) as u8;
Some((pos, facing, text(tag.get("variant"))?))
}
+/// Cushion.addAdditionalSaveData: the block it sits on and its colour.
+pub fn cushion_to_nbt(c: &Cushion, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
+ let base = Base {
+ id: "minecraft:cushion",
+ uuid,
+ position: c.position,
+ motion: Vec3::ZERO,
+ rotation: [c.yaw, 0.0],
+ on_ground: false,
+ fall_distance: 0.0,
+ };
+ let mut tag = base.tag(raw);
+ put(&mut tag, "block_pos", Tag::IntArray(c.pos.to_vec()));
+ put(&mut tag, "color", string(c.color_name()));
+ tag
+}
+/// The position, block position, yaw and colour of a saved cushion.
+pub fn cushion_from_nbt(tag: &Tag, id: u32) -> Option {
+ let position = position(tag)?;
+ let pos = match tag.get("block_pos") {
+ Some(Tag::IntArray(v)) if v.len() == 3 => [v[0], v[1], v[2]],
+ _ => [
+ position.x.floor() as i32,
+ position.y.floor() as i32,
+ position.z.floor() as i32,
+ ],
+ };
+ let yaw = match tag.get("Rotation") {
+ Some(Tag::List(l)) => l
+ .first()
+ .and_then(|v| crate::save::float(Some(v)))
+ .unwrap_or(0.0) as f32,
+ _ => 0.0,
+ };
+ let color =
+ crate::entities::dye_index(&text(tag.get("color")).unwrap_or_else(|| "white".into()));
+ Some(Cushion {
+ id,
+ position,
+ pos,
+ yaw,
+ color,
+ check_interval: 0,
+ })
+}
+
+#[cfg(test)]
+mod cushion_tests {
+ use super::*;
+
+ #[test]
+ fn cushion_save_preserves_color_anchor_rotation_and_unknown_data() {
+ let cushion = Cushion {
+ id: 7,
+ position: Vec3::new(-1.5, 64.5, 3.5),
+ pos: [-2, 64, 3],
+ yaw: 270.0,
+ color: 14,
+ check_interval: 55,
+ };
+ let raw = Tag::compound([("CustomName", string("Seat"))]);
+ let tag = cushion_to_nbt(&cushion, [1, 2, 3, 4], Some(&raw));
+ assert_eq!(text(tag.get("CustomName")).as_deref(), Some("Seat"));
+ let loaded = cushion_from_nbt(&tag, 8).unwrap();
+ assert_eq!(loaded.id, 8);
+ assert_eq!(loaded.position, cushion.position);
+ assert_eq!(loaded.pos, cushion.pos);
+ assert_eq!(loaded.yaw, cushion.yaw);
+ assert_eq!(loaded.color_name(), "red");
+ assert_eq!(loaded.check_interval, 0);
+ assert_eq!(loaded.bounds(), cushion.bounds());
+ }
+}
/// ItemFrame.addAdditionalSaveData.
pub fn item_frame_to_nbt(f: &ItemFrame, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
let (lo, hi) = f.bounds();
@@ -1840,7 +1966,7 @@ mod tests {
assert_eq!(number(tag.get("Health")), Some(5));
}
#[test]
- fn orbs_expand_their_count() {
+ fn orbs_keep_their_count() {
let o = ExperienceOrb {
id: 0,
position: Vec3::new(1.0, 2.0, 3.0),
@@ -1849,12 +1975,14 @@ mod tests {
value: 7,
age: 3,
on_ground: false,
+ count: 3,
+ ticks: 0,
};
- let mut tag = orb_to_nbt(&o, [0; 4]);
- put(&mut tag, "Count", Tag::Int(3));
+ let tag = orb_to_nbt(&o, [0; 4]);
let back = orbs_from_nbt(&tag);
- assert_eq!(back.len(), 3);
+ assert_eq!(back.len(), 1);
assert_eq!(back[0].value, 7);
+ assert_eq!(back[0].count, 3);
}
}
@@ -1919,12 +2047,39 @@ fn restore_axolotl_memories(m: &mut Mob, tag: &Tag) {
}
}
const AXOLOTL_VARIANTS: [&str; 5] = ["lucy", "wild", "gold", "cyan", "blue"];
+/// `Salmon.Variant` names, by id.
+const SALMON_SIZES: [&str; 3] = ["small", "medium", "large"];
+/// `TropicalFish.Pattern` names in enum order: the six small patterns, then
+/// the six large ones (the order of `extra.variant`).
+const TROPICAL_PATTERNS: [&str; 12] = [
+ "kob",
+ "sunstreak",
+ "snooper",
+ "dasher",
+ "brinely",
+ "spotty",
+ "flopper",
+ "stripey",
+ "glitter",
+ "blockfish",
+ "betty",
+ "clayfish",
+];
+/// `Bucketable.saveDefaultDataToBucketTag`, with the age an axolotl and a
+/// tadpole add (`saveToBucketTag`).
pub fn bucket_data(m: &Mob) -> Tag {
- let mut data = Tag::compound([
- ("Age", Tag::Int(m.extra.age)),
- ("AgeLocked", Tag::Byte(i8::from(m.extra.age_locked))),
- ("Health", Tag::Float(m.health.to_bits())),
- ]);
+ let mut data = Tag::compound([("Health", Tag::Float(m.health.to_bits()))]);
+ if matches!(
+ m.species(),
+ crate::mobs::Species::Axolotl | crate::mobs::Species::Tadpole
+ ) {
+ put(&mut data, "Age", Tag::Int(m.extra.age));
+ put(
+ &mut data,
+ "AgeLocked",
+ Tag::Byte(i8::from(m.extra.age_locked)),
+ );
+ }
for (key, on) in [
("NoAI", m.no_ai),
("Silent", m.silent),
@@ -1954,6 +2109,29 @@ pub fn bucket_components(m: &Mob) -> crate::item_data::StackData {
.unwrap_or(&"lucy");
data.set_other("minecraft:axolotl/variant", Some(string(variant)));
}
+ // Salmon.saveToBucketTag: the size.
+ if m.species() == crate::mobs::Species::Salmon {
+ let size = SALMON_SIZES
+ .get(usize::from(m.extra.variant))
+ .unwrap_or(&"medium");
+ data.set_other("minecraft:salmon/size", Some(string(size)));
+ }
+ // TropicalFish.saveToBucketTag: the pattern and both colours.
+ if m.species() == crate::mobs::Species::TropicalFish {
+ let dye = |i: u8| crate::mobs::render::DYE_NAMES[usize::from(i) & 15];
+ let pattern = TROPICAL_PATTERNS
+ .get(usize::from(m.extra.variant))
+ .unwrap_or(&"kob");
+ data.set_other("minecraft:tropical_fish/pattern", Some(string(pattern)));
+ data.set_other(
+ "minecraft:tropical_fish/base_color",
+ Some(string(dye(m.extra.variant2))),
+ );
+ data.set_other(
+ "minecraft:tropical_fish/pattern_color",
+ Some(string(dye(m.extra.variant3))),
+ );
+ }
data
}
pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
@@ -2004,6 +2182,39 @@ pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
{
m.extra.variant = id as u8;
}
+ // Salmon.applyImplicitComponents: the size.
+ if m.species() == crate::mobs::Species::Salmon
+ && let Some(name) = text(components.other("minecraft:salmon/size"))
+ && let Some(id) = SALMON_SIZES
+ .iter()
+ .position(|&v| v == name.trim_start_matches("minecraft:"))
+ {
+ m.extra.variant = id as u8;
+ }
+ // TropicalFish.applyImplicitComponent: the pattern and both colours.
+ if m.species() == crate::mobs::Species::TropicalFish {
+ let name = |key| text(components.other(key));
+ let dye = |key| {
+ name(key).and_then(|n| {
+ crate::mobs::render::DYE_NAMES
+ .iter()
+ .position(|&v| v == n.trim_start_matches("minecraft:"))
+ })
+ };
+ if let Some(id) = name("minecraft:tropical_fish/pattern").and_then(|n| {
+ TROPICAL_PATTERNS
+ .iter()
+ .position(|&v| v == n.trim_start_matches("minecraft:"))
+ }) {
+ m.extra.variant = id as u8;
+ }
+ if let Some(id) = dye("minecraft:tropical_fish/base_color") {
+ m.extra.variant2 = id as u8;
+ }
+ if let Some(id) = dye("minecraft:tropical_fish/pattern_color") {
+ m.extra.variant3 = id as u8;
+ }
+ }
}
#[cfg(test)]
diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs
index 1903cab7e..d0e8c8499 100644
--- a/crates/horizon-client/src/font.rs
+++ b/crates/horizon-client/src/font.rs
@@ -1201,6 +1201,31 @@ mod tests {
assert!(!font.take_patches().is_empty());
}
+ /// A renderer rebuilt over the same font (the loading screen's handoff)
+ /// makes its atlas texture from the textures alone, so the glyphs it had
+ /// rasterized into the previous texture must be placed into the new one.
+ #[test]
+ fn a_rebuilt_atlas_gets_its_glyphs_again() {
+ let sheet = png(16, 8, |x, _| x < 2 || (8..14).contains(&x));
+ let default = br#"{"providers":[{"type":"bitmap","file":"minecraft:font/a.png","ascent":7,"chars":["ab"]}]}"#;
+ let root = root(
+ "rebuild",
+ &[
+ ("assets/minecraft/font/default.json", default),
+ ("assets/minecraft/textures/font/a.png", &sheet),
+ ],
+ );
+ let font = load(&root);
+ let _ = std::fs::remove_dir_all(&root);
+ let first = font.glyph('a');
+ assert_eq!(font.take_patches().len(), 1);
+ font.reset_cache();
+ // Nothing is left over: drawing the character again places its pixels.
+ assert!(font.take_patches().is_empty());
+ assert_eq!(font.glyph('a').advance, first.advance);
+ assert_eq!(font.take_patches().len(), 1);
+ }
+
#[test]
fn provider_filters_follow_the_font_options() {
let sheet = png(8, 8, |x, _| x < 4);
diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs
index 826ea73c1..807a1d2cf 100644
--- a/crates/horizon-client/src/game.rs
+++ b/crates/horizon-client/src/game.rs
@@ -18,6 +18,8 @@ mod boats;
mod books;
mod bossbars;
mod breezes;
+mod campfire;
+mod campfire_douse;
mod cartography;
mod chat;
mod client_ambient;
@@ -33,6 +35,7 @@ mod copper_golems;
mod creaking;
mod creatures;
mod crossbow;
+pub(crate) mod cushions;
mod debug_keys;
mod decorated_pot;
mod dedicated;
@@ -150,6 +153,7 @@ mod scoreboard;
mod screens;
mod sculk;
mod sculk_fixture;
+mod server_mods;
mod server_packs;
mod server_travel;
mod shader_packs;
@@ -184,6 +188,7 @@ mod win;
mod wind;
mod wither;
mod world_loading;
+mod zombie_reinforcements;
mod zombie_villagers;
use horizon_client::{
Result,
@@ -535,6 +540,8 @@ struct GameLevel<'w> {
events: &'w mut Vec,
dimension: LevelDimension,
darken: i32,
+ /// The environment of the level's dimension (`SUN_ANGLE`).
+ environment: &'w Environment,
raining: bool,
thundering: bool,
player_box: Option<([f64; 3], [f64; 3])>,
@@ -543,6 +550,8 @@ struct GameLevel<'w> {
player_collision: Option,
/// Minecart boxes (detector rails).
cart_boxes: Vec<([f64; 3], [f64; 3])>,
+ /// Arrow and thrown trident boxes (wooden buttons).
+ arrow_boxes: Vec<([f64; 3], [f64; 3])>,
/// The other entities that keep blocks from being placed into them.
blockers: Blockers<'w>,
biomes: &'w Biomes,
@@ -555,6 +564,11 @@ struct GameLevel<'w> {
loot: Option>,
registry: &'static horizon_world::registry::BlockRegistry,
rules: horizon_world::level::GameRules,
+ /// `Difficulty.getId()` (peaceful 0 .. hard 3).
+ difficulty: i32,
+ /// The feet of the players who keep fire spreading around them: the local
+ /// player and the LAN guests in this level, spectators aside.
+ fire_players: Vec<[f64; 3]>,
/// Block loot random sequences (`ServerLevel.getRandomSequence`).
rand_sequences: &'w mut horizon_client::random_sequences::RandomSequences,
pending: &'w mut spill::Pending,
@@ -564,6 +578,9 @@ struct GameLevel<'w> {
random_tick_sections: &'w mut horizon_client::random_tick_sections::RandomTickSections,
/// Players with each chest open (a trapped chest's signal).
lid_openers: &'w HashMap<(i32, i32, i32), i32>,
+ /// `Level.isClientSide`: a client's copy of the level (a guest of a LAN
+ /// world, a window on its server thread, a dedicated server's client).
+ client_side: bool,
}
struct PlayerCollision {
y: f64,
@@ -653,6 +670,9 @@ impl GameLevel<'_> {
}
}
impl LevelAccess for GameLevel<'_> {
+ fn is_client_side(&self) -> bool {
+ self.client_side
+ }
fn world_surface(&self, x: i32, z: i32) -> i32 {
self.world.world_surface(x, z, |s| self.facts.is_air(s))
}
@@ -718,6 +738,34 @@ impl LevelAccess for GameLevel<'_> {
fn game_rules(&self) -> horizon_world::level::GameRules {
self.rules
}
+ fn difficulty(&self) -> i32 {
+ self.difficulty
+ }
+ /// `ServerLevel.canSpreadFireAround`: a player (not a spectator) closer
+ /// than the `fire_spread_radius_around_player` rule to the block's corner
+ /// (`ChunkMap.anyPlayerCloseEnoughTo`); -1 spreads everywhere.
+ fn can_spread_fire_around(&self, pos: BlockPos) -> bool {
+ let radius = self.rules.fire_spread_radius_around_player;
+ radius == -1
+ || self.fire_players.iter().any(|p| {
+ let d = [
+ p[0] - f64::from(pos.x),
+ p[1] - f64::from(pos.y),
+ p[2] - f64::from(pos.z),
+ ];
+ d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < f64::from(radius) * f64::from(radius)
+ })
+ }
+ fn increased_fire_burnout(&self, pos: BlockPos) -> bool {
+ self.world
+ .chunks
+ .get(&(pos.x >> 4, pos.z >> 4))
+ .is_some_and(|chunk| {
+ self.biomes
+ .get(chunk.biome(pos.x, pos.y, pos.z))
+ .increased_fire_burnout
+ })
+ }
fn block_state(&self, pos: BlockPos) -> BlockStateId {
self.world.block(pos.x, pos.y, pos.z)
}
@@ -762,6 +810,11 @@ impl LevelAccess for GameLevel<'_> {
fn sky_darken(&self) -> i32 {
self.darken
}
+ fn sun_angle(&self, _pos: BlockPos) -> f32 {
+ self.environment
+ .sample(self.world.day_time, None, None)
+ .sun_angle
+ }
fn is_raining(&self) -> bool {
self.raining
}
@@ -830,8 +883,9 @@ impl LevelAccess for GameLevel<'_> {
fn is_ticking_chunk(&self, chunk: horizon_core::position::ChunkPos) -> bool {
self.tickets.block_ticking(chunk.x, chunk.z) && ticking_chunk(self.world, chunk.x, chunk.z)
}
- /// Entities that trigger pressure plates, tripwires and detector rails:
- /// the players (the host and the LAN guests, mobs) and the minecarts.
+ /// Entities that trigger pressure plates, tripwires, detector rails and
+ /// wooden buttons: the players (the host and the LAN guests, mobs) and
+ /// the minecarts, and for `EntityQuery::Arrows` the arrows.
fn count_entities(&self, area: Aabb, query: EntityQuery) -> usize {
let hit = |(lo, hi): &([f64; 3], [f64; 3])| {
area.intersects(Aabb::new(
@@ -840,6 +894,7 @@ impl LevelAccess for GameLevel<'_> {
))
};
let carts = || self.cart_boxes.iter().filter(|b| hit(b)).count();
+ let arrows = || self.arrow_boxes.iter().filter(|b| hit(b)).count();
let players = || {
self.player_box
.iter()
@@ -849,6 +904,7 @@ impl LevelAccess for GameLevel<'_> {
};
match query {
EntityQuery::Minecart => carts(),
+ EntityQuery::Arrows => arrows(),
EntityQuery::Mobs => players(),
EntityQuery::Everything => players() + carts(),
}
@@ -856,7 +912,16 @@ impl LevelAccess for GameLevel<'_> {
fn emit(&mut self, event: LevelEvent) {
match event {
// Block.dropResources draws its loot and spots right away.
- LevelEvent::DropResources { pos, state } => self.drop_resources_now(pos, state),
+ // `popResource` only drops server-side (`!level.isClientSide`):
+ // a client's moveBlocks (a piston's block event) skips it.
+ LevelEvent::DropResources { pos, state } if !self.client_side => {
+ self.drop_resources_now(pos, state)
+ }
+ LevelEvent::DropResources { .. } => {}
+ // `ClientLevel.playSeededSound` plays only when the excluded
+ // player is this client's own: the block's `playSound(null, ...)`
+ // (a piston's move, a note) reaches it from the server instead.
+ LevelEvent::Sound { .. } if self.client_side => {}
// Block.popResource of the block's own item (tall flowers, flower beds).
LevelEvent::BlockEvent {
pos,
@@ -1269,6 +1334,13 @@ struct Game<'a> {
/// Controllers (Horizon's own).
pad: pad::Pads,
frames: u64,
+ /// `item_level` for one frame, game time, day time and dimension.
+ item_level_cache: std::cell::RefCell<
+ Option<(
+ (u64, i64, i64, &'static str),
+ horizon_assets::item_model::LevelState,
+ )>,
+ >,
/// Frames drawn with the player in the world, for `--world-frames`.
world_frames: u64,
fps: f32,
@@ -1432,6 +1504,8 @@ struct Game<'a> {
map_frame_model: frames::FrameModel,
glow_map_frame_model: frames::FrameModel,
armor_stands: Vec,
+ /// `Cushion` decoration entities (game/cushions.rs).
+ cushions: Vec,
/// Entities of types Horizon does not simulate.
others: Vec,
armor_stand_assets: armor_stands::ArmorStandAssets,
@@ -1447,6 +1521,8 @@ struct Game<'a> {
boat_models: boats::BoatModels,
/// EndCrystalModel's baked layer.
crystal_model: Option,
+ /// CushionModel's baked layer.
+ cushion_model: Option,
carts: Vec,
/// Songs playing from jukeboxes (tracked sound handles).
jukebox_sounds: HashMap<(i32, i32, i32), u64>,
@@ -1583,6 +1659,8 @@ struct Game<'a> {
/// position) for the guests.
lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
lan_entity_events: Vec<(i32, i8, [f64; 3])>,
+ /// Successful crits (attacking guest, hit entity), queued while the hub is taken.
+ lan_critical_hits: Vec<(Option, i32)>,
/// Global level events for every guest (`ServerLevel.globalLevelEvent`).
lan_global_events: Vec<(i32, [i32; 3], i32)>,
/// `ContainerOpenersCounter`: how many players (the host and the guests)
@@ -2162,8 +2240,9 @@ impl Game<'_> {
ticks: 0,
});
}
- /// `Block.getDrops`: the block's loot table, drawing from its server random
- /// sequence (`LootContext.Builder.create`), else the level random.
+ /// `Block.getDrops` for a block a player breaks: the block's loot table
+ /// with the player as `this`, drawing from its server random sequence
+ /// (`LootContext.Builder.create`), else the level random.
fn block_loot_at(
&mut self,
pos: [i32; 3],
@@ -2177,9 +2256,9 @@ impl Game<'_> {
let random = self.rand_sequences.get(&sequence, self.level.seed);
self.res
.items()
- .block_drops_with(registry, state, held, &dynamic, random)
+ .block_drops_by_player(registry, state, held, &dynamic, random)
}
- None => self.res.items().block_drops_with(
+ None => self.res.items().block_drops_by_player(
registry,
state,
held,
@@ -2223,11 +2302,13 @@ impl Game<'_> {
// Player.drop: the drop statistics.
self.stats.add("dropped", &thrown.item, thrown.count as i32);
self.stats.custom("drop", 1);
- self.throw_from_eyes(thrown, eye);
+ self.throw_from_eyes(thrown, eye, true);
}
/// `Player.createItemStackToDrop`: an item entity thrown from the eyes
- /// along the view direction.
- fn throw_from_eyes(&mut self, thrown: ItemStack, eye: [f64; 3]) {
+ /// along the view direction. `thrown_from_hand` (`drop(stack, true)`, the
+ /// drop key) names the player as the thrower; `drop(stack, false)`, for
+ /// what no longer fits in the inventory, does not.
+ fn throw_from_eyes(&mut self, thrown: ItemStack, eye: [f64; 3], thrown_from_hand: bool) {
let (yaw, pitch) = (
f64::from(self.yaw).to_radians(),
f64::from(self.pitch).to_radians(),
@@ -2241,7 +2322,7 @@ impl Game<'_> {
yaw.cos() * pitch.cos() * 0.3 + spread.sin() * strength,
];
self.spawn_item(thrown, [eye[0], eye[1] - 0.3, eye[2]], v, 40);
- if self.lan_acting.is_none() {
+ if thrown_from_hand && self.lan_acting.is_none() {
let uuid = self.level.ensure_player_uuid();
self.dropped.last_mut().unwrap().thrower = Some(uuid);
}
@@ -2448,6 +2529,18 @@ impl Game<'_> {
)
})
.collect();
+ let arrow_boxes = self
+ .creatures
+ .projectiles
+ .iter()
+ .filter(|p| p.arrow.is_some())
+ .map(|p| p.position)
+ .chain(self.tridents.iter().map(|t| t.position))
+ .map(|at| {
+ let b = horizon_client::arrows::arrow_bounds(at);
+ (b.min_position().components(), b.max_position().components())
+ })
+ .collect();
let guest_boxes = self.lan_block_trigger_boxes();
let dimension = match self.dim {
Dim::Overworld => LevelDimension::Overworld,
@@ -2455,6 +2548,19 @@ impl Game<'_> {
Dim::End => LevelDimension::End,
};
let rules = self.level_rules();
+ let fire_players: Vec<[f64; 3]> = self
+ .player
+ .iter()
+ .filter(|_| !spectator)
+ .map(|p| [p.position.x, p.position.y, p.position.z])
+ .chain(self.lan.iter().flat_map(|h| {
+ h.hub
+ .guests
+ .iter()
+ .filter(|g| h.hub.here(g) && !g.spectator())
+ .map(|g| g.position)
+ }))
+ .collect();
let blockers = Blockers {
mobs: &self.mobs,
armor_stands: &self.armor_stands,
@@ -2465,6 +2571,7 @@ impl Game<'_> {
};
let mut level = GameLevel {
cart_boxes,
+ arrow_boxes,
blockers,
world: &mut self.world,
facts: self.res.facts(),
@@ -2472,6 +2579,11 @@ impl Game<'_> {
events: &mut self.level_events,
dimension,
darken,
+ environment: match dimension {
+ LevelDimension::Overworld => self.res.environment(),
+ LevelDimension::Nether => self.res.nether_environment(),
+ LevelDimension::End => self.res.end_environment(),
+ },
raining: rain > 0.2,
thundering: thunder > 0.9,
player_box,
@@ -2485,12 +2597,15 @@ impl Game<'_> {
loot: horizon_client::structure_blocks::loot_data(&self.options.resources),
registry: self.pack.assets.registry,
rules,
+ difficulty: i32::from(self.ui.difficulty),
+ fire_players,
rand_sequences: &mut self.rand_sequences,
pending: &mut self.pending,
spill: &mut self.spill,
tickets: self.tickets.levels(),
random_tick_sections: &mut self.random_tick_sections,
lid_openers: &self.lid_openers,
+ client_side: self.remote.is_some(),
};
let result = f(self.res.behaviours(), &mut level, &mut self.block_ticks);
self.flush_spill();
@@ -2552,14 +2667,15 @@ impl Game<'_> {
(p.position.z.floor() as i32) >> 4,
));
}
- let sources = (self.options.dedicated.is_some() || !players.is_empty()).then(|| {
- horizon_client::ticket_levels::Sources {
- players,
- forced: self.streaming.forced.iter().copied().collect(),
- view_distance: self.settings.render_distance.clamp(2, 32),
- simulation_distance: self.settings.simulation_distance.max(2),
- }
- });
+ let sources =
+ (!self.options.execution_role.is_client() || !players.is_empty()).then(|| {
+ horizon_client::ticket_levels::Sources {
+ players,
+ forced: self.streaming.forced.iter().copied().collect(),
+ view_distance: self.settings.render_distance.clamp(2, 32),
+ simulation_distance: self.settings.simulation_distance.max(2),
+ }
+ });
self.tickets.update(sources);
}
/// `ServerLevel.startTickingChunk`: a loaded chunk's saved ticks are
@@ -2594,8 +2710,9 @@ impl Game<'_> {
.copied()
.filter(|&(x, z)| levels.random_ticking(x, z) && ticking_chunk(&self.world, x, z))
.collect();
- // Entity.checkInsideBlocks for the plates, tripwires and detector rails
- // under the players (the host and the LAN guests) and the minecarts.
+ // Entity.checkInsideBlocks for the plates, tripwires, detector rails and
+ // buttons under the players (the host and the LAN guests), the minecarts
+ // and the arrows.
let mut inside = Vec::new();
let guests = self.lan_block_trigger_boxes();
let boxes = self
@@ -2627,6 +2744,24 @@ impl Game<'_> {
}
}
}
+ // AbstractArrow.applyEffectsFromBlocks: the blocks every arrow passed
+ // through this tick (a wooden button is pressed by one inside it), and
+ // the ones a thrown trident is in.
+ for p in self
+ .creatures
+ .projectiles
+ .iter()
+ .filter(|p| p.arrow.is_some())
+ {
+ inside.extend(horizon_client::arrows::blocks_inside(
+ p.previous, p.position,
+ ));
+ }
+ for t in &self.tridents {
+ inside.extend(horizon_client::arrows::blocks_inside(
+ t.position, t.position,
+ ));
+ }
// BigDripleafBlock.entityInside also asks whether the player stands on
// the ground and how high its feet are: the leaves its box's feet
// layer is inside (the host and the LAN guests).
@@ -2788,6 +2923,9 @@ impl Game<'_> {
pos,
data,
} => self.consume_teleport_particles([pos.x, pos.y, pos.z], data),
+ LevelEvent::LevelEvent { id: 2003, pos, .. } => {
+ self.eye_break_particles([pos.x, pos.y, pos.z]);
+ }
LevelEvent::LevelEvent {
id: 2013,
pos,
@@ -2818,6 +2956,9 @@ impl Game<'_> {
1501 => Some(("minecraft:block.lava.extinguish", 0.5)),
1009 => Some(("minecraft:block.fire.extinguish", 0.5)),
1502 => Some(("minecraft:block.redstone_torch.burnout", 0.5)),
+ // LevelEvent.SOUND_ZOMBIE_WOODEN_DOOR (attack, break).
+ 1019 => Some(("minecraft:entity.zombie.attack_wooden_door", 2.0)),
+ 1021 => Some(("minecraft:entity.zombie.break_wooden_door", 2.0)),
1030 => Some(("minecraft:block.anvil.use", 1.0)),
1029 => Some(("minecraft:block.anvil.destroy", 1.0)),
1031 => Some(("minecraft:block.anvil.land", 0.3)),
@@ -2837,9 +2978,14 @@ impl Game<'_> {
1029 | 1030 | 1042 | 1043 | 1044 => {
self.world.random.next_float() * 0.1 + 0.9
}
+ 1019 | 1021 => {
+ (self.world.random.next_float() - self.world.random.next_float())
+ * 0.2
+ + 1.0
+ }
_ => 1.0,
};
- if matches!(id, 1029 | 1030) {
+ if matches!(id, 1019 | 1021 | 1029 | 1030) {
// Clients play the anvil sound from its level event;
// capturing it also sends a duplicate sound packet.
self.audio.play_unshared(name, c, volume, pitch);
@@ -2969,6 +3115,11 @@ impl Game<'_> {
kind: "hatch_sniffer",
..
} => self.hatch_sniffer([pos.x, pos.y, pos.z]),
+ LevelEvent::BlockEvent {
+ pos,
+ state,
+ kind: "hatch_turtles",
+ } => self.hatch_turtles([pos.x, pos.y, pos.z], state),
LevelEvent::BlockEvent {
pos,
kind: "portal_spawn",
@@ -3006,6 +3157,10 @@ impl Game<'_> {
.name
.clone();
let key = (pos[0], pos[1], pos[2]);
+ if self.chest_menu_blocked(key, &name) {
+ // The use still succeeds, but no menu, stat or piglin anger.
+ return;
+ }
if &*name == "minecraft:lectern" {
self.open_lectern(pos);
return;
@@ -3336,9 +3491,17 @@ impl Game<'_> {
self.with_player_actor(|game| game.break_block_as_player(pos))
}
fn break_block_as_player(&mut self, pos: [i32; 3]) -> Result<()> {
+ if !self
+ .res
+ .items()
+ .can_destroy_block(self.held(), self.creative)
+ {
+ return Ok(());
+ }
self.pad_rumble(horizon_client::gamepad::Rumble::BlockBroken);
// ServerPlayerGameMode.destroyBlock.
let state = self.world.block(pos[0], pos[1], pos[2]);
+ let broken = state;
let facts = self.res.facts().get(state).clone();
let state = self.crack_mined_pot(pos, state);
// Block.playerWillDestroy: mining their gold angers all nearby piglins.
@@ -3370,6 +3533,9 @@ impl Game<'_> {
creative,
)
});
+ if removed {
+ self.mod_block_event(pos, broken, false);
+ }
if removed && !creative {
let held = self.held().cloned();
self.mine_block_with_held(&facts.name, facts.hardness);
@@ -3478,6 +3644,7 @@ impl Game<'_> {
fn interact_entity(&mut self) -> Result {
Ok(self.interact_frame()
|| self.interact_armor_stand()
+ || self.interact_cushion()
|| self.interact_boat()
|| self.interact_cart()
|| self.interact_mob()?
@@ -3539,6 +3706,10 @@ impl Game<'_> {
self.swing_arm();
return Ok(true);
}
+ if self.use_campfire_douse(hit.pos, held.as_ref())? {
+ self.swing_arm();
+ return Ok(true);
+ }
match self.use_respawn_anchor(hit.pos, held.as_ref())? {
respawn_anchor::AnchorUse::Charged => {
self.swing_arm();
@@ -3664,6 +3835,7 @@ impl Game<'_> {
|| self.place_painting(hit, &stack)
|| self.place_item_frame(hit, &stack)
|| self.place_armor_stand(hit, &stack)
+ || self.place_cushion(hit, &stack)
|| self.place_end_crystal(hit, &stack))
{
return Ok(true);
@@ -3712,6 +3884,7 @@ impl Game<'_> {
return Ok(true);
};
let target = [pos.x, pos.y, pos.z];
+ self.mod_block_event(target, state, true);
if let Some(entity) = BlockEntity::for_block(&self.res.facts().get(state).name) {
let key = (target[0], target[1], target[2]);
self.world.block_entities.insert(key, entity);
@@ -3954,7 +4127,12 @@ impl Game<'_> {
return Ok(());
};
// GameType.isBlockPlacingRestricted: adventure and spectator.
- if !self.may_build() {
+ if !self.may_build()
+ || !self
+ .res
+ .items()
+ .can_destroy_block(self.held(), self.creative)
+ {
self.mining = None;
return Ok(());
}
@@ -4228,8 +4406,9 @@ impl Game<'_> {
if running {
self.world.game_time += 1;
if self.ui.rules.bool("advance_weather") {
- self.world.weather.tick(&mut self.world.random);
+ self.world.weather.tick_timers(&mut self.world.random);
}
+ self.world.weather.tick_levels();
self.tick_weather_effects();
}
if self.ticks.is_multiple_of(6000) {
@@ -4245,6 +4424,7 @@ impl Game<'_> {
self.update_totem_ready();
self.tick_command_extras();
self.tick_mods();
+ self.tick_server_mods();
let camera_eye = self.camera_eye_height();
let stick = self.pad_move();
if self.riding.is_some() && self.player.is_some() {
@@ -4327,12 +4507,6 @@ impl Game<'_> {
let events = std::mem::take(&mut player.events);
let spin_hit = player.spin_hit.take();
let glider_wear = std::mem::take(&mut player.glider_wear);
- if glider_wear > 0
- && !self.creative
- && let Some(elytra) = self.armor[1].as_mut()
- {
- elytra.damage += glider_wear;
- }
let feet = [player.position.x, player.position.y, player.position.z];
let player_velocity = [player.velocity.x, player.velocity.y, player.velocity.z];
self.previous_eye = self.eye;
@@ -4343,9 +4517,20 @@ impl Game<'_> {
};
self.eye += (camera_eye.unwrap_or(eye_height) - self.eye) * 0.5;
let crouching = player.pose == horizon_client::pose::Pose::Crouching;
+ // `ItemStack.hurtAndBreak` for the glide: Unbreaking can save the wear.
+ if glider_wear > 0
+ && !self.creative
+ && let Some(stack) = self.armor[1].clone()
+ {
+ let loss = self.durability_loss(&stack, glider_wear);
+ if let Some(elytra) = self.armor[1].as_mut() {
+ elytra.damage += loss;
+ }
+ }
self.tick_avatar(before, riding);
self.end_spin_attack(spin_hit);
self.record_combat(&events);
+ self.wear_armor(&events);
for event in events {
match event {
MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, feet),
@@ -4518,7 +4703,7 @@ impl Game<'_> {
&& let Some(stack) = self.carried.take()
&& let Some(eye) = self.eye_position()
{
- self.throw_from_eyes(stack, eye);
+ self.throw_from_eyes(stack, eye, false);
}
}
self.tick_world(running)
@@ -4547,6 +4732,7 @@ impl Game<'_> {
horizon_client::spans::time("tick_paintings", || self.tick_paintings());
horizon_client::spans::time("tick_item_frames", || self.tick_item_frames());
horizon_client::spans::time("tick_armor_stands", || self.tick_armor_stands());
+ horizon_client::spans::time("tick_cushions", || self.tick_cushions());
horizon_client::spans::time("tick_boats", || self.tick_boats());
horizon_client::spans::time("tick_carts", || self.tick_carts());
horizon_client::spans::time("tick_thunder", || self.tick_thunder());
@@ -4755,7 +4941,10 @@ impl Game<'_> {
if capture && !self.focused {
return;
}
- if !capture {
+ if capture {
+ // The inventory's screens are behind us: no drag survives them.
+ self.reset_inventory_clicks();
+ } else {
self.stop_mining();
}
// The real pointer takes over from an agent's.
@@ -4834,7 +5023,7 @@ impl Game<'_> {
self.capture(true);
}
}
- fn draw_item(&mut self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) {
+ fn draw_item(&self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) {
// `GuiGraphics.renderItem`: the resolved item model (tints, foil and
// special renderers included), then the decorations.
self.draw_item_model(batch, stack, x, y);
@@ -4924,7 +5113,7 @@ impl Game<'_> {
/// `GuiGraphicsExtractor.itemDecorations`: the count (or `count_text`)
/// and damage bar.
fn draw_item_decorations(
- &mut self,
+ &self,
batch: &mut HudBatch,
stack: &ItemStack,
x: f32,
@@ -5051,12 +5240,12 @@ impl Game<'_> {
for d in &draws {
if let hud_layout::GuiDraw::Item { slot, x, y, .. } = *d {
let stack = if slot == 40 {
- self.offhand.clone()
+ self.offhand.as_ref()
} else {
- self.inventory[slot as usize].clone()
+ self.inventory[slot as usize].as_ref()
};
if let Some(stack) = stack {
- self.draw_item(&mut batch, &stack, x as f32, y as f32);
+ self.draw_item(&mut batch, stack, x as f32, y as f32);
}
}
}
@@ -5281,7 +5470,9 @@ impl Game<'_> {
| BlockEntity::Vault(_)
| BlockEntity::Beehive(_)
| BlockEntity::CommandBlock(_)
- | BlockEntity::Skull(_),
+ | BlockEntity::Skull(_)
+ | BlockEntity::DaylightDetector
+ | BlockEntity::Campfire(_),
) => {}
None => {
v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i));
@@ -5551,7 +5742,9 @@ impl Game<'_> {
| BlockEntity::Vault(_)
| BlockEntity::Beehive(_)
| BlockEntity::CommandBlock(_)
- | BlockEntity::Skull(_),
+ | BlockEntity::Skull(_)
+ | BlockEntity::DaylightDetector
+ | BlockEntity::Campfire(_),
) => {}
None if self.mount_active() => self.draw_mount_background(batch, ox, oy),
None => {
@@ -5594,7 +5787,18 @@ impl Game<'_> {
self.draw_inventory_effects(batch, (ox, oy), 176);
}
}
+ /// `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it
+ /// belongs to on the screen; Horizon keeps them on the game, so they are
+ /// dropped when a screen closes. A press whose release never reaches the
+ /// screen (the pointer left the window, or the screen closed first) would
+ /// otherwise leave every later press on every later screen swallowed.
+ pub(super) fn reset_inventory_clicks(&mut self) {
+ self.inv_clicks = Default::default();
+ self.inv_drag = None;
+ self.last_inv_click = None;
+ }
pub(super) fn close_container(&mut self) {
+ self.reset_inventory_clicks();
self.close_station();
self.mount_closed();
self.recipe_ui.reset_screen();
@@ -5607,7 +5811,8 @@ impl Game<'_> {
if let Some(rest) = self.give(stack)
&& let Some(eye) = self.eye_position()
{
- self.spawn_item(rest, [eye[0], eye[1] - 0.3, eye[2]], [0.0, 0.1, 0.0], 40);
+ // AbstractContainerMenu.dropOrPlaceInInventory: `drop(stack, false)`.
+ self.throw_from_eyes(rest, eye, false);
}
}
self.craft_size = 2;
@@ -5690,8 +5895,9 @@ impl Game<'_> {
if self.creative_screen.tab().search {
// CreativeModeInventoryScreen.slotClicked: moveCursorToEnd, then
// setHighlightPos(0), so typing replaces the whole query.
- let search = &self.creative_screen.search;
- self.text_selection.select(("creative.search", 0), search);
+ let search = &mut self.creative_screen.search;
+ search.move_cursor_to_end(false);
+ search.highlight = 0;
}
let items = self.creative_screen.items(&self.pack.names);
let first = self.creative_screen.first_row(&self.pack.names);
@@ -6333,6 +6539,13 @@ impl Game<'_> {
false,
);
if outside {
+ // AbstractRecipeBookScreen.mouseClicked: the book takes the click
+ // before the outside test, and its tabs sit left of the strip
+ // hasClickedOutside counts as the book.
+ if self.recipe_book_click(right) {
+ self.inv_clicks.skip_release();
+ return;
+ }
// slotId -999: an empty hand throws nothing; a carried stack
// starts a drag whose release drops it.
match input {
@@ -6898,6 +7111,9 @@ impl Game<'_> {
self.prepare_entity_culling(camera);
self.prepare_trims();
self.mark_entity(out.len(), "minecraft:entity_flame");
+ // One scan for both passes that draw them (block entities below and the
+ // overlay near the end of this function).
+ let cracks = self.cracks(camera);
let fire_yaw = if self.camera_type == perspective::CameraType::ThirdPersonFront {
self.yaw + 180.0
} else {
@@ -6994,6 +7210,9 @@ impl Game<'_> {
// `VaultRenderer`.
self.mark_entity(out.len(), "");
self.vault_geometry(camera, alpha, &mut out);
+ // `CampfireRenderer`.
+ self.mark_entity(out.len(), "");
+ self.campfire_geometry(camera, &mut out);
self.mark_entity(out.len(), "minecraft:ominous_item_spawner");
self.ominous_item_spawner_geometry(camera, alpha, &mut out);
// Mobs and their projectiles (a span each).
@@ -7123,7 +7342,7 @@ impl Game<'_> {
.render(&scene, visible, &mut out);
}
self.mark_stage(out.len(), "DESTROY");
- for (pos, stage) in self.cracks(camera) {
+ for &(pos, stage) in &cracks {
let state = self.world.block(pos[0], pos[1], pos[2]);
self.res
.block_entity_render()
@@ -7236,6 +7455,7 @@ impl Game<'_> {
self.frame_geometry(camera, &mut out);
self.mark_entity(out.len(), "minecraft:armor_stand");
self.armor_stand_geometry(camera, alpha, &mut out);
+ self.cushion_geometry(camera, &mut out);
self.mark_entity(out.len(), "minecraft:oak_boat");
self.boat_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:minecart");
@@ -7266,7 +7486,7 @@ impl Game<'_> {
);
// Breaking progress overlays (destroy_stage_0..9): ours and the other players'.
self.mark_stage(out.len(), "DESTROY");
- for (pos, stage) in self.cracks(camera) {
+ for &(pos, stage) in &cracks {
let o = (glam::DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
- camera)
.as_vec3();
@@ -7314,6 +7534,20 @@ impl Game<'_> {
/// other players' (`renderBlockDestroyAnimation`: within 32 blocks of the camera, the
/// furthest progress on each block).
fn cracks(&self, camera: glam::DVec3) -> Vec<([i32; 3], [f32; 2])> {
+ // `destroy_stage_0` .. `destroy_stage_9`: the sprite name by stage, so the
+ // lookup does not format a string per crack.
+ const DESTROY_STAGES: [&str; 10] = [
+ "block/destroy_stage_0",
+ "block/destroy_stage_1",
+ "block/destroy_stage_2",
+ "block/destroy_stage_3",
+ "block/destroy_stage_4",
+ "block/destroy_stage_5",
+ "block/destroy_stage_6",
+ "block/destroy_stage_7",
+ "block/destroy_stage_8",
+ "block/destroy_stage_9",
+ ];
let mut stages: Vec<([i32; 3], u32)> = Vec::new();
let mut add = |pos: [i32; 3], stage: u32| match stages.iter_mut().find(|c| c.0 == pos) {
Some(c) => c.1 = c.1.max(stage),
@@ -7339,11 +7573,8 @@ impl Game<'_> {
d.length_squared() <= 1024.0
})
.filter_map(|(pos, stage)| {
- let r = self
- .gui
- .atlas
- .sprites
- .get(&format!("block/destroy_stage_{stage}"))?;
+ let name = DESTROY_STAGES.get(stage as usize)?;
+ let r = self.gui.atlas.sprites.get(*name)?;
Some((pos, [r.u0, r.v0]))
})
.collect()
@@ -7468,6 +7699,69 @@ impl Game<'_> {
self.audio
.play("minecraft:entity.player.attack.sweep", from, 1.0, 1.0);
}
+ /// The damage and knockback part of `Player.doSweepAttack` after a sweep
+ /// hit on the mob at `target`: every other living mob in its box grown by
+ /// (1, 0.25, 1) and closer than 3 blocks (`distanceToSqr < 9`, in creative
+ /// too), but the player's allies
+ /// (`isAlliedTo`), takes `1 + sweeping_damage_ratio * baseDamage` with the
+ /// weapon's enchantments, scaled by the attack strength, and is pushed 0.4
+ /// along the player's yaw.
+ pub(super) fn sweep_damage(&mut self, target: usize, scale: f32) {
+ let Some(p) = self.player.as_ref() else {
+ return;
+ };
+ let from = [p.position.x, p.position.y, p.position.z];
+ // `baseDamage` of `Player.attack` before a critical hit (a sweep has
+ // none) and the enchantments: the attack damage attribute with the
+ // strength and weakness effects, scaled by the attack strength.
+ let hand_damage = 1.0 + self.attack_item_info().map_or(0.0, |i| i.attack_damage);
+ let base_damage = (hand_damage + self.effect_attack_bonus()) * (0.2 + scale * scale * 0.8);
+ // The enchantment's attribute modifier on the attribute's 0 to 1 range.
+ let ratio = self
+ .res
+ .stations()
+ .enchantments
+ .attribute_add(
+ self.inventory[self.selected].as_ref(),
+ "minecraft:sweeping_damage_ratio",
+ )
+ .clamp(0.0, 1.0) as f32;
+ let sweep_damage = 1.0 + ratio * base_damage;
+ let hit_box = self.mobs[target]
+ .bounds()
+ .inflate(horizon_core::geometry::Vec3::new(1.0, 0.25, 1.0));
+ let (uuid, allies) = (
+ self.level.player_uuid.or(Some([0, 0, 0, 1])),
+ self.player_allies(),
+ );
+ let nearby: Vec = self
+ .mobs
+ .iter()
+ .enumerate()
+ .filter(|(i, m)| {
+ *i != target
+ && m.alive()
+ && !m.removed
+ && !allies.contains(&m.id)
+ && !mace::ally_of_player(m, uuid)
+ && m.bounds().intersects(hit_box)
+ && m.position.distance_squared(p.position) < 9.0
+ })
+ .map(|(i, _)| i)
+ .collect();
+ let (xd, zd) = self.extra_knockback_direction();
+ for i in nearby {
+ let kind = self.mobs[i].kind.id.clone();
+ let kind = format!("minecraft:{}", kind.trim_start_matches("minecraft:"));
+ let damage = (sweep_damage + self.enchant_damage_bonus(&kind)) * scale;
+ let source = self.attack_source(from);
+ if self.hurt_by_player(i, damage, source) {
+ self.mobs[i].knockback(0.4, xd, zd);
+ self.last_hurt_by_player
+ .insert(self.mobs[i].id, self.lan_acting);
+ }
+ }
+ }
/// `Player.attack`'s sounds when a vehicle takes the hit (it always does,
/// and can't be hit critically): knockback when sprinting at full
/// strength, then strong or weak. Before `swing_arm` resets the charge.
@@ -7521,6 +7815,7 @@ impl Game<'_> {
.map_or(0.0, |i| i.attack_damage);
if self.attack_frame()
|| self.attack_armor_stand()
+ || self.attack_cushion()
|| self.attack_boat(hand_damage)
|| self.attack_cart(hand_damage)
|| self.attack_dragon()
@@ -7608,10 +7903,9 @@ impl Game<'_> {
self.stats
.custom("damage_dealt", (actual * 10.0).round() as i32);
if crit {
- self.particles.tracking_emitter(
- horizon_client::particles::ParticleOptions::simple(
- horizon_client::particles::ParticleType::Crit,
- ),
+ self.critical_hit(
+ self.lan_acting,
+ self.mobs[index].id as i32,
feet,
width,
height,
@@ -7641,6 +7935,7 @@ impl Game<'_> {
// Player.playServerSideSound: at the player.
if let Some(at) = sweep {
self.sweep_attack(at, from);
+ self.sweep_damage(index, scale);
} else {
self.audio.play(sound, from, 1.0, 1.0);
}
@@ -7651,6 +7946,9 @@ impl Game<'_> {
if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event {
self.audio
.play(&format!("minecraft:{s}"), Some(at), volume, pitch);
+ } else {
+ // Left for the end of the tick.
+ self.mobs[index].outbox.push(event);
}
}
self.weapon_hit(index);
@@ -7660,15 +7958,18 @@ impl Game<'_> {
}
}
/// ServerExplosion: rays from a 16^3 grid lose (resistance + 0.3) * 0.3 per step.
- /// A mob explosion (`Level.ExplosionInteraction.MOB`: drop decay with the
- /// default mobGriefing rule).
+ /// A mob explosion (`ServerLevel.explode` with `ExplosionInteraction.MOB`:
+ /// blocks are kept without mobGriefing, else the mob_explosion_drop_decay
+ /// rule picks decay).
fn explode(&mut self, center: [f64; 3], radius: f32) -> Result<()> {
- self.server_explode(
- center,
- radius,
- explosion::BlockInteraction::DestroyWithDecay,
- false,
- )
+ let interaction = if !self.ui.rules.bool("mob_griefing") {
+ explosion::BlockInteraction::Keep
+ } else if self.ui.rules.bool("mob_explosion_drop_decay") {
+ explosion::BlockInteraction::DestroyWithDecay
+ } else {
+ explosion::BlockInteraction::Destroy
+ };
+ self.server_explode(center, radius, interaction, false)
}
/// Copies of a save batch carrying its live block entities and save data.
fn with_entities<'a>(
@@ -7993,6 +8294,7 @@ impl Game<'_> {
/// (scaled coordinates, or the End portal's fixed destination).
pub(super) fn switch_level(&mut self, target: Dim, from: Vec3) -> Result {
// Save the departing dimension's changed chunks.
+ self.save.save_forced_chunks(&self.streaming.forced)?;
self.streaming.save(&mut self.world, true);
let keys: Vec<_> = self.world.modified.drain().collect();
let chunks = self.with_entities(keys.iter().filter_map(|k| self.world.chunks.get(k)));
@@ -8266,6 +8568,7 @@ impl Game<'_> {
self.boats.clear();
self.carts.clear();
self.armor_stands.clear();
+ self.cushions.clear();
self.item_frames.clear();
self.paintings.clear();
self.others.clear();
@@ -8320,15 +8623,54 @@ impl Game<'_> {
}
self.apply_enchantment_attributes();
}
- /// Inventory.hurtArmor: each piece loses max(1, damage / 4) durability.
- fn hurt_armor(&mut self, damage: f32) {
+ /// The armor hits among a tick's motion events (`Player.hurtArmor` from
+ /// `getDamageAfterArmorAbsorb`), whatever the damage: a mob, an explosion,
+ /// a cactus, lava, a campfire.
+ fn wear_armor(&mut self, events: &[MotionEvent]) {
+ for event in events {
+ if let MotionEvent::Health(horizon_client::health::HealthEvent::ArmorHurt {
+ source,
+ amount,
+ }) = event
+ {
+ self.hurt_armor(*source, *amount);
+ }
+ }
+ }
+ /// `Player.hurtArmor` -> `LivingEntity.doHurtEquipment`: each worn piece that
+ /// wears when its wearer is hurt loses max(1, damage / 4) durability, except
+ /// to a fire source when the piece resists fire (`ItemStack.canBeHurtBy`).
+ fn hurt_armor(&mut self, source: horizon_world::damage_source::DamageTypeId, damage: f32) {
+ if damage <= 0.0 {
+ return;
+ }
let amount = ((damage / 4.0) as u32).max(1);
+ let name = self
+ .motion
+ .health
+ .damage
+ .definition(source)
+ .map(|d| d.name.clone())
+ .unwrap_or_default();
+ let fire = self
+ .motion
+ .health
+ .damage
+ .in_tag(source, "minecraft:is_fire");
let mut broke = false;
let losses: Vec = (0..4)
- .map(|i| {
- self.armor[i]
- .clone()
- .map_or(amount, |s| self.durability_loss(&s, amount))
+ .map(|i| match self.armor[i].clone() {
+ Some(s)
+ if self
+ .res
+ .items()
+ .get(&s.item)
+ .is_some_and(|info| info.equip_damage_on_hurt)
+ && !(fire && self.res.items().resists_fire(&s, &name)) =>
+ {
+ self.durability_loss(&s, amount)
+ }
+ _ => 0,
})
.collect();
for (slot, amount) in self.armor.iter_mut().zip(losses) {
@@ -8425,7 +8767,8 @@ impl Game<'_> {
}
fn drop_stack(&mut self, stack: ItemStack) {
if let Some(eye) = self.0.eye_position() {
- self.0.spawn_item(stack, eye, [0.0, 0.1, 0.0], 40);
+ // ItemUtils.createFilledResult: `player.drop(stack, false)`.
+ self.0.throw_from_eyes(stack, eye, false);
}
}
}
@@ -8663,6 +9006,24 @@ impl Game<'_> {
}
}
}
+ /// `ItemStack.hurtWithoutBreaking`: Unbreaking applies, but the stack stops at
+ /// one point of durability left instead of breaking.
+ fn hurt_held_without_breaking(&mut self, amount: u32) {
+ if self.creative {
+ return;
+ }
+ let Some(held) = self.held().cloned() else {
+ return;
+ };
+ let amount = self.durability_loss(&held, amount);
+ let max = self.res.items().get(&held.item).map_or(0, |i| i.max_damage);
+ if amount == 0 || max == 0 {
+ return;
+ }
+ if let Some(stack) = self.held_mut().as_mut() {
+ stack.damage = (stack.damage + amount).min(max - 1);
+ }
+ }
/// Block tool use: distinguish success, failure and fall-through for hand feedback.
fn use_tool(
&mut self,
@@ -8684,6 +9045,13 @@ impl Game<'_> {
{
return Ok(UseResult::Success { swing: true });
}
+ if allow_block_actions
+ && let Some(hit) = self.pick()
+ && let Some(placed) = self.use_on_campfire(hit.pos)?
+ {
+ // SUCCESS_SERVER swings; a full campfire's CONSUME does not.
+ return Ok(UseResult::Success { swing: placed });
+ }
// BucketItem has no useOn: a guest's UseItemOn leaves it to UseItem.
let bucket = horizon_client::items::bucket_contents(&stack.item);
if matches!(self.guest_use, Some(GuestUse::OnBlock(_)))
@@ -8743,7 +9111,8 @@ impl Game<'_> {
} else if let Some(rest) = self.give(filled)
&& let Some(eye) = self.eye_position()
{
- self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
+ // ItemUtils.createFilledResult: `player.drop(stack, false)`.
+ self.throw_from_eyes(rest, eye, false);
}
}
return Ok(UseResult::Success { swing: true });
@@ -8893,8 +9262,29 @@ impl Game<'_> {
while value > 0 {
let v = ExperienceOrb::split(value);
value -= v;
- let _merge_id = self.world.random.next_int_bound(40);
- self.add_orb(at, v);
+ let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
+ self.award_orb(at, v, merge_id);
+ }
+ }
+ /// `ExperienceOrb.tryMergeToExisting`: an orb of the same value within a
+ /// 1 block box of `at`, whose id is a multiple of 40 from `merge_id`, takes
+ /// 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) {
+ 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));
+ // A server's orbs are its own; a LAN or server guest only shows them.
+ let target = self.remote.is_none().then(|| {
+ self.orbs
+ .iter_mut()
+ .find(|o| o.can_merge(merge_id as u32, value) && o.bounds().intersects(area))
+ });
+ if let Some(Some(orb)) = target {
+ orb.count += 1;
+ orb.age = 0;
+ } else {
+ self.add_orb(at, value);
}
}
/// `new ExperienceOrb(level, pos, Vec3.ZERO, value)`: yaw and motion from
@@ -8916,6 +9306,8 @@ impl Game<'_> {
value,
age: 0,
on_ground: false,
+ count: 1,
+ ticks: 0,
});
}
fn can_place_used_fire(&mut self, target: [i32; 3]) -> bool {
@@ -8992,18 +9384,31 @@ impl Game<'_> {
}),
);
}
+ // Player.aiStep: the pickup area is the box inflated by (1, 0.5, 1).
let bounds = player.map(|p| {
let w = f64::from(p.dimensions.width) / 2.0;
(
- [p.position.x - w, p.position.y, p.position.z - w],
[
- p.position.x + w,
- p.position.y + f64::from(p.dimensions.height),
- p.position.z + w,
+ p.position.x - w - 1.0,
+ p.position.y - 0.5,
+ p.position.z - w - 1.0,
+ ],
+ [
+ p.position.x + w + 1.0,
+ p.position.y + f64::from(p.dimensions.height) + 0.5,
+ p.position.z + w + 1.0,
],
)
});
let mut orbs = std::mem::take(&mut self.orbs);
+ // An orb has no random of its own here: lava draws from one made on
+ // first use, apart from the level stream.
+ let mut lava_random = None;
+ let mut next_float = || {
+ lava_random
+ .get_or_insert_with(dispenser::entity_random)
+ .next_float()
+ };
orbs.retain_mut(|o| {
let distance = |feet: &[f64; 3]| -> f64 {
(feet[0] - o.position.x).powi(2)
@@ -9015,12 +9420,22 @@ impl Game<'_> {
.filter(|(feet, _)| distance(feet) < 64.0)
.min_by(|a, b| distance(&a.0).total_cmp(&distance(&b.0)))
.map(|(_, target)| *target);
- o.tick(&self.world, self.res.facts(), self.collision, target)
+ o.tick(
+ &self.world,
+ self.res.facts(),
+ self.collision,
+ target,
+ &mut next_float,
+ )
});
+ // ExperienceOrb.scanForMerges runs on the server only.
+ if self.remote.is_none() {
+ horizon_client::entities::merge_orbs(&mut orbs);
+ }
let mut gained = 0;
let mut taken = Vec::new();
if let Some((min, max)) = bounds {
- orbs.retain(|o| {
+ orbs.retain_mut(|o| {
let touching = o.position.x + 0.25 > min[0]
&& o.position.x - 0.25 < max[0]
&& o.position.y + 0.5 > min[1]
@@ -9028,11 +9443,13 @@ impl Game<'_> {
&& o.position.z + 0.25 > min[2]
&& o.position.z - 0.25 < max[2];
if touching && self.xp_delay == 0 {
- // ExperienceOrb.playerTouch: one orb every 2 ticks.
+ // ExperienceOrb.playerTouch: one orb every 2 ticks; a
+ // merged orb gives its value once per count.
self.xp_delay = 2;
gained += o.value;
taken.push(o.clone());
- return false;
+ o.count -= 1;
+ return o.count > 0;
}
true
});
@@ -9108,7 +9525,10 @@ impl Game<'_> {
};
// BowItem.shootProjectile: shootFromRotation(power * 3, inaccuracy 1).
let p = Vec3::new(eye[0], eye[1] - 0.1, eye[2]);
- let (power_bonus, infinity) = self.bow_enchantments();
+ let ammo = arrow_slot
+ .and_then(|i| self.stack_in(i).cloned())
+ .unwrap_or_else(|| ItemStack::new("minecraft:arrow", 1));
+ let (power_bonus, infinity) = self.bow_enchantments(&ammo.item);
let kind = horizon_client::projectiles::ProjectileKind::Arrow {
base_damage: 2.0 + power_bonus,
critical: power >= 1.0,
@@ -9122,9 +9542,6 @@ impl Game<'_> {
// ProjectileWeaponItem.useAmmo: creative and Infinity draw without
// using the ammo, so the arrow is CREATIVE_ONLY; else setOwner(player)
// lets it be picked up.
- let ammo = arrow_slot
- .and_then(|i| self.stack_in(i).cloned())
- .unwrap_or_else(|| ItemStack::new("minecraft:arrow", 1));
if let Some(a) = arrow.arrow.as_mut() {
a.set_item(&horizon_client::arrows::drawn_ammo(
&ammo,
@@ -9582,8 +9999,9 @@ impl Game<'_> {
rain.extend(snow_vertices);
rain
}
- /// Player.startSleepInBed: night or thunder, no monsters within 8 blocks;
- /// the bed becomes the respawn point either way.
+ /// ServerPlayer.startSleepInBed: in reach, not obstructed, night or thunder,
+ /// and (outside creative) no monsters within 8 blocks; the bed becomes the
+ /// respawn point either way.
fn try_sleep(&mut self, pos: [i32; 3]) {
let Some(p) = self.player.as_ref() else {
return;
@@ -9598,22 +10016,40 @@ impl Game<'_> {
.state(state)
.map(|s| s.properties.clone())
.unwrap_or_default();
- let head = if props.get("part").map(String::as_str) == Some("foot") {
- let d = facing_offset(props.get("facing").map_or("north", String::as_str));
- [pos[0] + d[0], pos[1], pos[2] + d[2]]
+ // The head and the foot: the block faces from the foot to the head.
+ let d = facing_offset(props.get("facing").map_or("north", String::as_str));
+ let (head, foot) = if props.get("part").map(String::as_str) == Some("foot") {
+ ([pos[0] + d[0], pos[1], pos[2] + d[2]], pos)
} else {
- pos
+ (pos, [pos[0] - d[0], pos[1], pos[2] - d[2]])
};
- let dist = ((p.position.x - f64::from(head[0]) - 0.5).powi(2)
- + (p.position.z - f64::from(head[2]) - 0.5).powi(2))
- .sqrt();
- if dist > 3.0 {
+ // ServerPlayer.bedInRange / isReachableBedBlock: within 3 blocks
+ // sideways and 2 vertically of the head or the foot.
+ let reachable = |bed: [i32; 3]| {
+ (p.position.x - f64::from(bed[0]) - 0.5).abs() <= 3.0
+ && (p.position.y - f64::from(bed[1])).abs() <= 2.0
+ && (p.position.z - f64::from(bed[2]) - 0.5).abs() <= 3.0
+ };
+ if !reachable(head) && !reachable(foot) {
self.message = Some((
"You may not rest now; the bed is too far away".into(),
Instant::now(),
));
return;
}
+ // ServerPlayer.bedBlocked: Player.freeAt (not suffocating) for the
+ // blocks above the head and the foot, as `in_wall` reads suffocating.
+ let blocked = [head, foot].iter().any(|bed| {
+ let f = self
+ .res
+ .facts()
+ .get(self.world.block(bed[0], bed[1] + 1, bed[2]));
+ f.full_collision && f.solid_render
+ });
+ if blocked {
+ self.message = Some(("This bed is obstructed".into(), Instant::now()));
+ return;
+ }
// In reach (bedInRange), day or night: setRespawnPosition(
// RespawnConfig(the head, the player's yaw), not forced). It replaces
// an anchor or a spawnpoint; respawning checks the bed is still there
@@ -9643,13 +10079,15 @@ impl Game<'_> {
));
return;
}
- let monsters = self.mobs.iter().any(|m| {
- m.hostile()
- && m.alive()
- && (m.position.x - p.position.x).abs() < 8.0
- && (m.position.y - p.position.y).abs() < 5.0
- && (m.position.z - p.position.z).abs() < 8.0
- });
+ // Creative players skip the monster check (`!this.isCreative()`).
+ let monsters = !self.creative
+ && self.mobs.iter().any(|m| {
+ m.hostile()
+ && m.alive()
+ && (m.position.x - p.position.x).abs() < 8.0
+ && (m.position.y - p.position.y).abs() < 5.0
+ && (m.position.z - p.position.z).abs() < 8.0
+ });
if monsters {
self.message = Some((
"You may not rest now; there are monsters nearby".into(),
@@ -9699,14 +10137,20 @@ impl Game<'_> {
}
}
// ServerLevel.tick: once enough of the players have slept 100 ticks,
- // skip to morning, clear the weather and wake everyone.
+ // skip to morning if `advance_time` is on, wake everyone, and
+ // resetWeatherCycle if `advance_weather` is on and it is raining.
if self.enough_slept() {
- let t = self.world.day_time;
- self.world.day_time = t + 24000 - t.rem_euclid(24000);
- self.world.weather.raining = false;
- self.world.weather.thundering = false;
- self.world.weather.rain_time = 0;
- self.world.weather.thunder_time = 0;
+ if self.ui.rules.bool("advance_time") {
+ let t = self.world.day_time;
+ self.world.day_time = t + 24000 - t.rem_euclid(24000);
+ }
+ // Level.isRaining: the rain level is above 0.2.
+ if self.ui.rules.bool("advance_weather") && self.world.weather.levels(1.0).0 > 0.2 {
+ self.world.weather.raining = false;
+ self.world.weather.thundering = false;
+ self.world.weather.rain_time = 0;
+ self.world.weather.thunder_time = 0;
+ }
if self.sleeping.is_some() {
self.wake_up();
}
@@ -9734,8 +10178,9 @@ impl Game<'_> {
fn draw_creative(&mut self, batch: &mut HudBatch) {
let (ox, oy) = Self::creative_origin(batch);
let selected = self.creative_screen.selected;
- let tabs = self.creative_screen.tabs.clone();
- let tab = self.creative_screen.tab().clone();
+ // Only what is drawn of the tabs: their stacks stay where they are.
+ let tabs = self.creative_screen.tab_headers();
+ let tab = tabs[selected.min(tabs.len() - 1)].clone();
let tab_sprite = |t: &horizon_client::creative::Tab, on: bool| {
format!(
"gui/sprites/container/creative_inventory/tab_{}_{}_{}",
@@ -9801,20 +10246,16 @@ impl Game<'_> {
);
}
if tab.search {
- // The search box: an unbordered EditBox of 80 at (82, 6), white.
- let search = &self.creative_screen.search;
- horizon_client::ui::append_field(
- batch,
- atlas,
- search,
- (ox + 82.0, oy + 6.0, 80.0),
- (u32::MAX, true),
- clipboard::CREATIVE_SEARCH_CHARS,
- self.text_selection
- .covers(clipboard::CREATIVE_SEARCH, search),
- true,
- self.creative_screen.search_focused.elapsed().as_millis(),
- );
+ // CreativeModeInventoryScreen: an unbordered EditBox of 50 at (82, 6).
+ let search = &mut self.creative_screen.search;
+ search.x = ox + 82.0;
+ search.y = oy + 6.0;
+ search.width = 80.0;
+ search.bordered = false;
+ search.focused = true;
+ search.text_color = u32::MAX;
+ search.max_length = clipboard::CREATIVE_SEARCH_CHARS;
+ search.draw(batch, atlas, None);
}
let mut hovered: Option = None;
if tab.inventory {
@@ -9922,8 +10363,7 @@ impl Game<'_> {
} else if self.carried.is_none()
&& let Some(item) = hovered
{
- let lines = self.stack_tooltip(&item);
- self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
+ self.draw_stack_tooltip(batch, &item, self.cursor.0, self.cursor.1);
}
self.draw_inventory_effects(batch, (ox, oy), Creative::WIDTH as i32);
}
@@ -9976,6 +10416,9 @@ impl Game<'_> {
}
return;
}
+ if !right && self.creative_search_click(ox, oy) {
+ return;
+ }
// Holding the scrollbar scrolls as the mouse moves (mouseDragged).
if !right
&& self
@@ -9988,6 +10431,24 @@ impl Game<'_> {
self.inventory_press(right);
}
}
+ /// A click on the search tab's box (`EditBox.onClick`).
+ fn creative_search_click(&mut self, ox: f32, oy: f32) -> bool {
+ if !self.creative_screen.tab().search {
+ return false;
+ }
+ let (x, y, w, h) = (ox + 82.0, oy + 6.0, 80.0, 9.0);
+ let (mx, my) = self.cursor;
+ if mx < x || my < y || mx >= x + w || my >= y + h {
+ return false;
+ }
+ let shift = self.has_shift_down();
+ let search = &mut self.creative_screen.search;
+ search.x = x;
+ search.y = y;
+ search.width = w;
+ search.click(&self.gui.atlas, mx, shift, false);
+ true
+ }
/// Copy the live player and world state into the `Level` that gets saved.
pub(super) fn sync_level(&mut self) {
// Level.write saves the game rules (game_rules.dat) with the rest.
@@ -10107,6 +10568,7 @@ impl Game<'_> {
}
/// Save the level in place: its changed chunks, its entities and its raids.
fn save_level(&mut self, wait: bool) -> Result<()> {
+ self.save.save_forced_chunks(&self.streaming.forced)?;
self.streaming.save(&mut self.world, wait);
let keys: Vec<_> = self.world.modified.drain().collect();
let chunks = self.with_entities(keys.iter().filter_map(|k| self.world.chunks.get(k)));
@@ -10306,8 +10768,6 @@ impl Game<'_> {
Vec::new()
};
let mut hud = horizon_client::spans::time("hud", || self.hud(size));
- // Map textures changed since the last drawn frame (game/maps.rs).
- hud.patches.append(&mut self.map_patches);
// LevelLoadingScreen (Reason.OTHER) draws the title's panorama.
let title = self.title.is_some()
|| self.loading_reason() == Some(horizon_client::level_loading::Reason::Other);
@@ -10409,6 +10869,10 @@ impl Game<'_> {
} else {
self.shader_pack_inputs(camera, alpha as f32)
};
+ // Map textures and font glyphs changed while building this frame's
+ // geometry (game/maps.rs, world text) upload with this batch; draining
+ // map_patches any earlier leaves them a frame behind.
+ hud.patches.append(&mut self.map_patches);
let entity_spans = std::mem::take(self.entity_spans.get_mut());
let frame = Frame {
weather: &weather,
@@ -11495,16 +11959,17 @@ impl ApplicationHandler for Game<'_> {
}
self.extras_mouse(button, pressed);
self.mod_mouse_key(button, pressed);
- match self.settings.keys.translate_mouse(button) {
- Some(Err(b)) => self.play_mouse(b, pressed)?,
- Some(Ok(k)) if pressed => {
- self.keys.insert(k);
- self.key_pressed(k)?;
+ for mapped in self.settings.keys.translate_mouse_all(button) {
+ match mapped {
+ Err(b) => self.play_mouse(b, pressed)?,
+ Ok(k) if pressed => {
+ self.keys.insert(k);
+ self.key_pressed(k)?;
+ }
+ Ok(k) => {
+ self.keys.remove(&k);
+ }
}
- Some(Ok(k)) => {
- self.keys.remove(&k);
- }
- None => {}
}
}
Screen::Inventory | Screen::Creative
@@ -11631,8 +12096,17 @@ impl ApplicationHandler for Game<'_> {
// The hovered slot took the key (`ignoreTextInput`).
} else if let Some(shortcut) = self.edit_shortcut(&event) {
self.creative_search_shortcut(shortcut);
- } else if event.physical_key == PhysicalKey::Code(KeyCode::Backspace) {
- self.creative_search_backspace(self.has_control_down());
+ } else if let PhysicalKey::Code(key) = event.physical_key {
+ // EditBox.keyPressed: arrows, Home, End, Delete and Backspace.
+ let before = self.creative_screen.search.value.clone();
+ let (ctrl, shift) = (self.has_control_down(), self.has_shift_down());
+ if self.creative_screen.search.key(key, ctrl, shift) {
+ if self.creative_screen.search.value != before {
+ self.creative_screen.scroll = 0.0;
+ }
+ } else {
+ self.creative_search_edit(event.text.as_deref());
+ }
} else {
self.creative_search_edit(event.text.as_deref());
}
@@ -11653,6 +12127,9 @@ impl ApplicationHandler for Game<'_> {
// The anvil rename box takes every key but Escape (AnvilScreen.keyPressed).
if let Some(shortcut) = self.edit_shortcut(&event) {
self.station_shortcut(shortcut);
+ } else if let PhysicalKey::Code(key) = event.physical_key
+ && self.station_key(key)
+ {
} else {
let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
self.station_text(event.text.as_deref(), backspace);
@@ -11740,18 +12217,24 @@ impl ApplicationHandler for Game<'_> {
{
self.smooth_camera = !self.smooth_camera;
}
- // Key binds: act as the default key of the bound mapping.
- let key = match self.settings.keys.translate(key) {
- Some(Ok(k)) => k,
- Some(Err(button)) => {
- if self.screen == Screen::Playing && !event.repeat {
- self.play_mouse(button, event.state == ElementState::Pressed)?;
+ // Key binds: act as the default key of every mapping bound
+ // to it (KeyMapping.set drives them all).
+ for mapped in self.settings.keys.translate_all(key) {
+ match mapped {
+ Ok(k) => {
+ self.mapped_key(
+ k,
+ event.state == ElementState::Pressed,
+ event.repeat,
+ )?;
+ }
+ Err(button) => {
+ if self.screen == Screen::Playing && !event.repeat {
+ self.play_mouse(button, event.state == ElementState::Pressed)?;
+ }
}
- return Ok(());
}
- None => return Ok(()),
- };
- self.mapped_key(key, event.state == ElementState::Pressed, event.repeat)?;
+ }
}
WindowEvent::RedrawRequested => {
self.observe_fullscreen();
@@ -12165,6 +12648,7 @@ impl<'a> Game<'a> {
last_input: now,
pad: Default::default(),
frames: 0,
+ item_level_cache: Default::default(),
world_frames: 0,
fps: 0.0,
fps_frames: 0,
@@ -12269,6 +12753,7 @@ impl<'a> Game<'a> {
map_frame_model: prepared.map_frame_model,
glow_map_frame_model: prepared.glow_map_frame_model,
armor_stands: Vec::new(),
+ cushions: Vec::new(),
others: Vec::new(),
armor_stand_assets: prepared.armor_stand_assets,
waypoint_styles: prepared.waypoint_styles,
@@ -12278,6 +12763,7 @@ impl<'a> Game<'a> {
boats: Vec::new(),
boat_models: prepared.boat_models,
crystal_model: prepared.crystal_model,
+ cushion_model: prepared.cushion_model,
carts: Vec::new(),
jukebox_sounds: HashMap::new(),
bolts: Vec::new(),
@@ -12364,6 +12850,7 @@ impl<'a> Game<'a> {
lan_events: Vec::new(),
lan_block_events: Vec::new(),
lan_entity_events: Vec::new(),
+ lan_critical_hits: Vec::new(),
lan_global_events: Vec::new(),
lid_openers: HashMap::new(),
lan_acting: None,
@@ -12415,6 +12902,7 @@ struct GameCpuResources {
boat_models: boats::BoatModels,
cart_models: minecarts::CartModels,
crystal_model: Option,
+ cushion_model: Option,
dragon_model: Option,
arrow_model: Option,
trident_model: Option,
@@ -12435,6 +12923,7 @@ impl GameCpuResources {
boat_models: boats::BoatModels::load(document.as_ref()),
cart_models: minecarts::CartModels::load(document.as_ref()),
crystal_model: model("minecraft:end_crystal#main"),
+ cushion_model: model("minecraft:cushion#main"),
dragon_model: model("minecraft:ender_dragon#main"),
arrow_model: model("minecraft:arrow#main"),
trident_model: model("minecraft:trident#main"),
@@ -12994,6 +13483,14 @@ fn build_renderer(
) -> Result {
let assets = &pack.render;
let atlas = &gui.atlas;
+ // The new renderer's atlas texture starts from `HudAtlas.pixels`, which
+ // holds the textures but never a glyph rasterized at run time. The font's
+ // cache still answers with the rects it drew into the previous renderer's
+ // texture, so forget them: the glyphs that are drawn again are placed into
+ // this texture (as `ui_theme` does when its atlas changes). Without this,
+ // Chinese and Japanese menu labels go blank when the loading screen hands
+ // over to the game.
+ atlas.font.reset_cache();
let mut renderer = pollster::block_on(Renderer::new(
window,
offscreen,
@@ -13040,6 +13537,12 @@ fn loading_renderer(
Some(atlas) => (atlas.pixels.as_slice(), atlas.width, atlas.height),
None => (EMPTY_HUD.as_slice(), 1, 1),
};
+ // A glyph rasterized into an earlier texture is not in these pixels; the
+ // new texture gets it again when the character is drawn (see
+ // `build_renderer`).
+ if let Some(atlas) = atlas {
+ atlas.font.reset_cache();
+ }
let mut renderer = pollster::block_on(Renderer::new(
window,
offscreen,
@@ -13776,7 +14279,7 @@ mod startup_cpu_tests {
r#"{
"minecraft:end_crystal#main": {}, "minecraft:ender_dragon#main": {},
"minecraft:arrow#main": {}, "minecraft:trident#main": {},
- "minecraft:armor_stand#main": {}
+ "minecraft:armor_stand#main": {}, "minecraft:cushion#main": {}
}"#,
)
.unwrap();
@@ -13796,6 +14299,7 @@ mod startup_cpu_tests {
.unwrap();
std::fs::remove_dir_all(&root).unwrap();
assert!(prepared.crystal_model.is_some());
+ assert!(prepared.cushion_model.is_some());
assert!(prepared.dragon_model.is_some());
assert!(prepared.arrow_model.is_some());
assert!(prepared.trident_model.is_some());
diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs
index f175af401..9a8c846c5 100644
--- a/crates/horizon-client/src/game/armor_stands.rs
+++ b/crates/horizon-client/src/game/armor_stands.rs
@@ -453,6 +453,11 @@ impl Game<'_> {
}
// ArmorStand.swapItem.
match held {
+ // A player with infinite materials puts a copy of one on an empty
+ // slot and keeps the stack.
+ Some(h) if self.creative && current.is_none() => {
+ self.armor_stands[i].equipment[slot] = Some(ItemStack { count: 1, ..h });
+ }
Some(h) if h.count > 1 => {
if current.is_some() {
return true;
diff --git a/crates/horizon-client/src/game/beacon.rs b/crates/horizon-client/src/game/beacon.rs
index 24ead3a3d..97177f2b9 100644
--- a/crates/horizon-client/src/game/beacon.rs
+++ b/crates/horizon-client/src/game/beacon.rs
@@ -515,8 +515,7 @@ impl Game<'_> {
if self.carried.is_some() {
self.draw_carried(batch);
} else if let Some(stack) = stack_tip {
- let lines = self.stack_tooltip(&stack);
- self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
+ self.draw_stack_tooltip(batch, &stack, self.cursor.0, self.cursor.1);
} else if let Some(key) = tooltip {
let text = self.translate(&key, &key);
self.draw_tooltip_lines(
diff --git a/crates/horizon-client/src/game/block_entity_anims.rs b/crates/horizon-client/src/game/block_entity_anims.rs
index 3d452596e..6f92d7f55 100644
--- a/crates/horizon-client/src/game/block_entity_anims.rs
+++ b/crates/horizon-client/src/game/block_entity_anims.rs
@@ -5,10 +5,14 @@
//! [`Game::block_anim`] and [`Game::chest_lid`].
use super::Game;
use horizon_client::{
- block_entity_anim::{BellEntity, EndGateway, Shulker, ShulkerStatus, Ticker},
+ block_entity_anim::{
+ BellEntity, ConduitServer, ConduitTarget, EndGateway, Shulker, ShulkerStatus, Ticker,
+ },
block_entity_render::BlockAnim,
collisions::{SceneCollisions, no_collision_empty},
containers::BlockEntity,
+ effects::EffectInstance,
+ mobs::{Damage, DamageKind},
particles::{ParticleOptions, ParticleType},
save::number,
skins,
@@ -16,6 +20,7 @@ use horizon_client::{
use horizon_core::{
geometry::{Aabb, Vec3},
position::BlockPos,
+ random::RandomSource,
};
use horizon_world::nbt::Tag;
@@ -218,9 +223,12 @@ impl Game<'_> {
/// The client tickers of the loaded animated block entities, once per
/// client tick (`ClientLevel.tickBlockEntities`).
pub(super) fn tick_block_entity_anims(&mut self) {
+ // A server has no window, but its gateways and conduits still run
+ // their server tickers; a client of one only animates what it is sent.
+ if self.remote.is_none() {
+ self.tick_conduit_servers();
+ }
let Some(r) = &self.renderer else {
- // A server has no window, but its gateways still run their
- // server ticker.
if self.remote.is_none() {
self.tick_gateway_servers();
}
@@ -337,6 +345,7 @@ impl Game<'_> {
}
}
Ticker::Conduit => {
+ let target = self.conduit_target(pos);
let world = &self.world;
let facts = self.res.facts();
let registry = self.pack.assets.registry;
@@ -356,7 +365,7 @@ impl Game<'_> {
time,
is_water,
is_frame,
- None,
+ target,
self.particles.random(),
);
let nautilus = ParticleOptions::simple(ParticleType::Nautilus);
@@ -383,6 +392,248 @@ impl Game<'_> {
}
self.be_anims.present = positions;
}
+ /// `ConduitBlockEntity.serverTick` of every conduit in the chunks that
+ /// tick blocks, with or without a renderer. The conduits are looked for
+ /// when the shape is checked, every 40 ticks (they have no block entity
+ /// of their own here).
+ fn tick_conduit_servers(&mut self) {
+ if self.world.game_time % 40 == 0 {
+ self.find_conduits();
+ }
+ let mut positions: Vec<[i32; 3]> = self.be_anims.conduit_servers.keys().copied().collect();
+ positions.sort_unstable();
+ for pos in positions {
+ self.tick_conduit_server(pos);
+ }
+ }
+ /// Sets `be_anims.conduit_servers` to the conduits in the
+ /// chunks that tick blocks, keeping the state of those already known.
+ fn find_conduits(&mut self) {
+ let levels = self.tickets.levels();
+ let kinds = &self.be_anims.kinds;
+ let is_conduit = |id: u32| matches!(kinds.get(id as usize), Some(Some(Ticker::Conduit)));
+ let mut found = Vec::new();
+ for (&(cx, cz), chunk) in &self.world.chunks {
+ if !levels.block_ticking_at(cx * 16, cz * 16) {
+ continue;
+ }
+ for (si, section) in chunk.sections.iter().enumerate() {
+ if !section.blocks.maybe_has(is_conduit) {
+ continue;
+ }
+ for i in 0..4096 {
+ if is_conduit(section.get(i)) {
+ found.push([
+ cx * 16 + (i & 15) as i32,
+ horizon_client::chunk::MIN_Y + si as i32 * 16 + (i >> 8) as i32,
+ cz * 16 + ((i >> 4) & 15) as i32,
+ ]);
+ }
+ }
+ }
+ }
+ let mut old = std::mem::take(&mut self.be_anims.conduit_servers);
+ for pos in found {
+ let known = old.remove(&pos).unwrap_or_default();
+ self.be_anims.conduit_servers.insert(pos, known);
+ }
+ }
+ /// `ConduitBlockEntity.serverTick` of the conduit at `pos`, in a chunk
+ /// that ticks blocks: the shape check every 40 ticks with its sounds, the
+ /// power for players in range, the hurt for an enemy, then the ambient
+ /// sounds.
+ fn tick_conduit_server(&mut self, pos: [i32; 3]) {
+ let state = self.world.block(pos[0], pos[1], pos[2]).0;
+ if self.be_anims.ticker(state) != Some(Ticker::Conduit) {
+ // Broken since the chunks were searched.
+ self.be_anims.conduit_servers.remove(&pos);
+ return;
+ }
+ if !self.tickets.levels().block_ticking_at(pos[0], pos[2])
+ || !self.border.contains(f64::from(pos[0]), f64::from(pos[2]))
+ {
+ return;
+ }
+ let time = self.world.game_time;
+ let mut conduit = self
+ .be_anims
+ .conduit_servers
+ .remove(&pos)
+ .unwrap_or_default();
+ let check = {
+ let world = &self.world;
+ let facts = self.res.facts();
+ let registry = self.pack.assets.registry;
+ let frames = self
+ .res
+ .items()
+ .block_tags
+ .get("minecraft:conduit_effect_block");
+ // Level.isWaterAt: the fluid at the position is water.
+ let is_water = |p: [i32; 3]| {
+ facts.get(world.block(p[0], p[1], p[2])).fluid
+ == horizon_client::blocks::Fluid::Water
+ };
+ let is_frame = |p: [i32; 3]| {
+ registry
+ .state(world.block(p[0], p[1], p[2]))
+ .is_some_and(|s| frames.is_some_and(|f| f.contains(&s.name)))
+ };
+ conduit.check(pos, time, is_water, is_frame)
+ };
+ let centre = [
+ f64::from(pos[0]) + 0.5,
+ f64::from(pos[1]) + 0.5,
+ f64::from(pos[2]) + 0.5,
+ ];
+ if let Some(check) = check {
+ if let Some(active) = check.toggled {
+ let sound = if active {
+ "minecraft:block.conduit.activate"
+ } else {
+ "minecraft:block.conduit.deactivate"
+ };
+ self.audio.play(sound, Some(centre), 1.0, 1.0);
+ }
+ if let Some(frames) = check.frames {
+ self.conduit_apply_effects(pos, frames);
+ self.conduit_attack(&mut conduit, pos, frames >= 42);
+ }
+ }
+ let (ambient, short) = conduit.ambient(time, &mut self.world.random);
+ if ambient {
+ self.audio
+ .play("minecraft:block.conduit.ambient", Some(centre), 1.0, 1.0);
+ }
+ if short {
+ self.audio.play(
+ "minecraft:block.conduit.ambient_short",
+ Some(centre),
+ 1.0,
+ 1.0,
+ );
+ }
+ self.be_anims.conduit_servers.insert(pos, conduit);
+ }
+ /// `ConduitBlockEntity.applyEffects`: conduit power for every player
+ /// in water or rain within `frames / 7 * 16` blocks.
+ fn conduit_apply_effects(&mut self, pos: [i32; 3], frames: usize) {
+ let range = (frames / 7 * 16) as i64;
+ self.for_each_player(|g| {
+ let Some(p) = g.player.as_ref().filter(|p| !p.health.dead_or_dying()) else {
+ return;
+ };
+ if g.spectator() {
+ return;
+ }
+ let at = p.position;
+ let in_water = p.fluids.was_touching_water;
+ let top = at.y + f64::from(p.dimensions.height);
+ // BlockPos.closerThan: the squared distance under range squared.
+ let d = [at.x, at.y, at.z]
+ .map(|v| v.floor() as i64)
+ .iter()
+ .zip(pos)
+ .map(|(a, b)| (a - i64::from(b)).pow(2))
+ .sum::();
+ if d >= range * range || !(in_water || g.in_rain(at, top)) {
+ return;
+ }
+ let power = EffectInstance {
+ ambient: true,
+ ..EffectInstance::new("conduit_power", 260, 0)
+ };
+ g.potions.effects.add(power);
+ });
+ }
+ /// `Entity.isInRain`: rain at the block position or at the top of the box.
+ fn in_rain(&mut self, at: Vec3, top: f64) -> bool {
+ let p = BlockPos::new(
+ at.x.floor() as i32,
+ at.y.floor() as i32,
+ at.z.floor() as i32,
+ );
+ let up = BlockPos::new(p.x, top.floor() as i32, p.z);
+ self.with_level(|b, level, _| b.is_raining_at(level, p) || b.is_raining_at(level, up))
+ }
+ /// `ConduitBlockEntity.updateAndAttackTarget`: while the conduit hunts
+ /// (42 frame blocks) its target stays until it dies or leaves the 8
+ /// blocks, else a random enemy in water or rain is chosen; the target
+ /// takes 4 magic damage.
+ fn conduit_attack(&mut self, conduit: &mut ConduitServer, pos: [i32; 3], hunting: bool) {
+ conduit.target = match conduit.target {
+ _ if !hunting => None,
+ None => self.conduit_new_target(pos),
+ Some(id) => self
+ .mobs
+ .iter()
+ .find(|m| m.id == id && !m.removed)
+ .filter(|m| {
+ let at = [m.position.x, m.position.y, m.position.z].map(|v| v.floor() as i64);
+ m.alive()
+ && at
+ .iter()
+ .zip(pos)
+ .map(|(a, b)| (a - i64::from(b)).pow(2))
+ .sum::()
+ < 64
+ })
+ .map(|m| m.id),
+ };
+ let Some(m) = conduit
+ .target
+ .and_then(|id| self.mobs.iter_mut().find(|m| m.id == id))
+ else {
+ return;
+ };
+ let at = [m.position.x, m.position.y, m.position.z];
+ m.damage(4.0, Damage::of(DamageKind::Magic));
+ self.audio
+ .play("minecraft:block.conduit.attack.target", Some(at), 1.0, 1.0);
+ }
+ /// `ConduitBlockEntity.selectNewTarget`: one of the enemies in water or
+ /// rain whose box meets the conduit's block inflated by 8.
+ fn conduit_new_target(&mut self, pos: [i32; 3]) -> Option {
+ let [x, y, z] = pos.map(f64::from);
+ let area = Aabb::new(
+ Vec3::new(x - 8.0, y - 8.0, z - 8.0),
+ Vec3::new(x + 9.0, y + 9.0, z + 9.0),
+ );
+ let near: Vec<(u32, bool, Vec3, f64)> = self
+ .mobs
+ .iter()
+ .filter(|m| m.hostile() && !m.removed && m.bounds().intersects(area))
+ .map(|m| {
+ let top = m.position.y + f64::from(m.height());
+ (m.id, m.fluids.in_water, m.position, top)
+ })
+ .collect();
+ let candidates: Vec = near
+ .into_iter()
+ .filter(|&(_, in_water, at, top)| in_water || self.in_rain(at, top))
+ .map(|(id, ..)| id)
+ .collect();
+ if candidates.is_empty() {
+ return None;
+ }
+ let pick = self
+ .world
+ .random
+ .next_int_bound(candidates.len() as i32)
+ .unwrap_or(0);
+ Some(candidates[pick as usize])
+ }
+ /// The conduit's `destroyTarget` as the client draws it.
+ fn conduit_target(&self, pos: [i32; 3]) -> Option {
+ let id = self.be_anims.conduit_servers.get(&pos)?.target?;
+ let m = self.mobs.iter().find(|m| m.id == id && !m.removed)?;
+ Some(ConduitTarget {
+ position: [m.position.x, m.position.y, m.position.z],
+ eye_y: m.eye_y(),
+ width: m.width(),
+ height: m.height(),
+ })
+ }
/// `TheEndGatewayBlockEntity.portalTick` (the server ticker) of the
/// gateways a server keeps a copy of, in block-ticking chunks
/// (`Level.tickBlockEntities`): the cooldown an entry started runs out,
diff --git a/crates/horizon-client/src/game/block_entity_ticks.rs b/crates/horizon-client/src/game/block_entity_ticks.rs
index e48c8f398..2778bb531 100644
--- a/crates/horizon-client/src/game/block_entity_ticks.rs
+++ b/crates/horizon-client/src/game/block_entity_ticks.rs
@@ -10,6 +10,7 @@ use horizon_client::{
block_entities::{Pos, Ticking},
containers::{BlockEntity, FurnaceKind, HOPPER_SLOTS},
};
+use horizon_core::position::BlockPos;
use horizon_world::registry::BlockStateId;
impl Game<'_> {
@@ -56,6 +57,8 @@ impl Game<'_> {
Some(BlockEntity::Beehive(_)) => self.tick_beehive(pos),
Some(BlockEntity::Furnace(_)) => self.tick_furnace(pos)?,
Some(BlockEntity::Brewing(_)) => self.tick_brewing_stand(pos)?,
+ Some(BlockEntity::DaylightDetector) => self.tick_daylight_detector(pos),
+ Some(BlockEntity::Campfire(_)) => self.tick_campfire(pos)?,
_ => {}
}
}
@@ -92,7 +95,11 @@ impl Game<'_> {
| "minecraft:vault"
| "minecraft:beehive"
| "minecraft:bee_nest"
- | "minecraft:brewing_stand" => Ticking::Yes,
+ | "minecraft:brewing_stand"
+ | "minecraft:daylight_detector"
+ // Lit, cookTick; unlit, cooldownTick.
+ | "minecraft:campfire"
+ | "minecraft:soul_campfire" => Ticking::Yes,
"minecraft:jukebox" => {
let record = registry
.state(state)
@@ -113,6 +120,16 @@ impl Game<'_> {
let levels = self.tickets.levels();
move |x, z| levels.block_ticking_at(x, z)
}
+ /// `DaylightDetectorBlock.tickEntity` of the detector at `pos`.
+ fn tick_daylight_detector(&mut self, pos: Pos) {
+ // It updates every 20 game ticks (the behaviour checks this too).
+ if self.world.game_time % 20 != 0 {
+ return;
+ }
+ let at = BlockPos::new(pos.0, pos.1, pos.2);
+ self.with_level(|b, level, ticks| b.tick_daylight_detector(level, ticks, at));
+ let _ = self.process_level_events();
+ }
/// `AbstractFurnaceBlockEntity.serverTick` of the furnace at `pos`, and
/// its block's `lit` following it.
fn tick_furnace(&mut self, pos: Pos) -> Result<()> {
diff --git a/crates/horizon-client/src/game/boats.rs b/crates/horizon-client/src/game/boats.rs
index df7158d9a..06dfab22d 100644
--- a/crates/horizon-client/src/game/boats.rs
+++ b/crates/horizon-client/src/game/boats.rs
@@ -55,7 +55,7 @@ pub(super) struct Boat {
/// `ChestBoat.CONTAINER_SIZE`.
pub(super) const CHEST_SLOTS: usize = 27;
pub(super) const WIDTH: f64 = 1.375;
-const HEIGHT: f64 = 0.5625;
+pub(super) const HEIGHT: f64 = 0.5625;
impl Boat {
pub fn new(id: u32, wood: Arc, position: Vec3, yaw: f32) -> Self {
Self {
@@ -587,6 +587,9 @@ impl Game<'_> {
}
/// The player's tick while riding: steer, tick the boat, sit in it.
pub(super) fn tick_riding(&mut self, keys: Keys) -> horizon_client::Result<()> {
+ if self.tick_cushion_riding(keys) {
+ return Ok(());
+ }
let Some(i) = self.boats.iter().position(|b| Some(b.id) == self.riding) else {
if self.tick_cart_riding(keys) || self.tick_mount_riding(keys) {
return Ok(());
diff --git a/crates/horizon-client/src/game/books.rs b/crates/horizon-client/src/game/books.rs
index 9af1da70c..2f38dffd9 100644
--- a/crates/horizon-client/src/game/books.rs
+++ b/crates/horizon-client/src/game/books.rs
@@ -17,7 +17,6 @@ use horizon_client::{
use horizon_core::position::BlockPos;
use horizon_protocol::packets::play::{self, Clientbound as C, Serverbound as S};
use horizon_world::level::flags as level_flags;
-use std::time::Instant;
use winit::{
event::{ElementState, KeyEvent},
keyboard::{KeyCode, PhysicalKey},
@@ -27,8 +26,24 @@ const BLACK: u32 = 0xFF00_0000;
const PAGE_CHARS: usize = 1024;
const MAX_PAGES: usize = 100;
const LINES: usize = 14;
-/// `BookSignScreen`'s title box.
-const BOOK_TITLE: horizon_client::clipboard::FieldId = ("book.title", 0);
+
+fn book_title_box() -> ui::EditBox {
+ let mut edit = ui::EditBox::new(0.0, 0.0, 114.0, 9.0);
+ edit.bordered = false;
+ edit.max_length = 15;
+ edit.text_color = BLACK;
+ edit.focused = true;
+ edit
+}
+fn book_page_box() -> ui::EditBox {
+ let mut edit = ui::EditBox::new(0.0, 0.0, 114.0, 9.0);
+ edit.bordered = false;
+ edit.multiline = true;
+ edit.max_length = PAGE_CHARS;
+ edit.text_color = BLACK;
+ edit.focused = true;
+ edit
+}
pub(super) enum BookScreen {
Edit {
@@ -38,7 +53,10 @@ pub(super) enum BookScreen {
page: usize,
signing: bool,
title: String,
- opened: Instant,
+ /// BookSignScreen's title box (`EditBox` of 15).
+ title_edit: ui::EditBox,
+ /// BookEditScreen's page (`MultiLineEditBox`).
+ page_edit: ui::EditBox,
},
View {
pages: Vec,
@@ -84,13 +102,16 @@ impl Game<'_> {
if pages.is_empty() {
pages.push(String::new());
}
+ let mut page_edit = book_page_box();
+ page_edit.set_value(&pages[0]);
BookScreen::Edit {
slot: self.held_slot(),
pages,
page: 0,
signing: false,
title: String::new(),
- opened: Instant::now(),
+ title_edit: book_title_box(),
+ page_edit,
}
}
"minecraft:written_book" => BookScreen::View {
@@ -239,34 +260,24 @@ impl Game<'_> {
Some(KeyCode::PageDown) => self.turn_page(true),
_ => {}
},
- Some(BookScreen::Edit {
- signing: true,
- title,
- ..
- }) => match key {
+ Some(BookScreen::Edit { signing: true, .. }) => match key {
Some(KeyCode::Escape) => {
if let Some(BookScreen::Edit { signing, .. }) = self.book.as_mut() {
*signing = false;
}
}
- Some(KeyCode::Backspace) => {
- if !self.text_selection.take(BOOK_TITLE, title) {
- title.pop();
- }
- }
Some(KeyCode::Enter | KeyCode::NumpadEnter) => {
- if !title.trim().is_empty() {
+ let blank = self.book.as_ref().is_some_and(
+ |b| matches!(b, BookScreen::Edit { title, .. } if title.trim().is_empty()),
+ );
+ if !blank {
self.save_book(true);
}
}
+ Some(key) if self.book_title_key(key) => {}
_ => {
if let Some(typed) = text {
- self.text_selection.take(BOOK_TITLE, title);
- for c in typed.chars().filter(|c| !c.is_control()) {
- if title.chars().count() < 15 {
- title.push(c);
- }
- }
+ self.book_title_insert(typed);
}
}
},
@@ -274,24 +285,13 @@ impl Game<'_> {
Some(KeyCode::Escape) => self.save_book(false),
Some(KeyCode::PageUp) => self.turn_page(false),
Some(KeyCode::PageDown) => self.turn_page(true),
- Some(KeyCode::Backspace) => {
- if !self.take_page_selection() {
- self.edit_page(|p| {
- p.pop();
- })
- }
- }
- Some(KeyCode::Enter | KeyCode::NumpadEnter) => {
- self.take_page_selection();
- self.type_into_page("\n")
- }
+ Some(KeyCode::ArrowUp) => self.book_move_line(-1),
+ Some(KeyCode::ArrowDown) => self.book_move_line(1),
+ Some(KeyCode::Enter | KeyCode::NumpadEnter) => self.page_insert("\n"),
+ Some(key) if self.book_page_key(key) => {}
_ => {
if let Some(typed) = text {
- let typed: String = typed.chars().filter(|c| !c.is_control()).collect();
- if !typed.is_empty() {
- self.take_page_selection();
- }
- self.type_into_page(&typed);
+ self.page_insert(typed);
}
}
},
@@ -302,99 +302,258 @@ impl Game<'_> {
pub(super) fn book_type(&mut self, text: &str) {
let text = text.replace("\\n", "\n");
match self.book.as_mut() {
- Some(BookScreen::Edit {
- signing: true,
- title,
- ..
- }) => {
- for c in text.chars().filter(|c| !c.is_control()) {
- if title.chars().count() < 15 {
- title.push(c);
- }
- }
- }
- Some(BookScreen::Edit { .. }) => self.type_into_page(&text),
+ Some(BookScreen::Edit { signing: true, .. }) => self.book_title_insert(&text),
+ Some(BookScreen::Edit { .. }) => self.page_insert(&text),
_ => {}
}
}
- /// Before typing on a page: Select All's selection is cleared (true).
- fn take_page_selection(&mut self) -> bool {
- match self.book.as_mut() {
- Some(BookScreen::Edit { pages, page, .. }) => self
- .text_selection
- .take(("book.page", *page), &mut pages[*page]),
- _ => false,
+ /// `BookSignScreen.keyPressed` on the title box.
+ fn book_title_key(&mut self, key: KeyCode) -> bool {
+ let (ctrl, shift) = (self.has_control_down(), self.has_shift_down());
+ let Some(BookScreen::Edit {
+ title, title_edit, ..
+ }) = self.book.as_mut()
+ else {
+ return false;
+ };
+ if !title_edit.key(key, ctrl, shift) {
+ return false;
}
+ title.clone_from(&title_edit.value);
+ true
}
- /// Ctrl+A/C/V/X: the title box (an `EditBox` of 15) while signing, else
- /// the page (`MultilineTextField.insertText`: line breaks kept, cut to
- /// the 1024 characters left, rejected when it overflows the 14 lines).
- pub(super) fn book_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
- let font = &self.gui.atlas.font;
- match self.book.as_mut() {
- Some(BookScreen::Edit {
- signing: true,
- title,
- ..
- }) => {
- Self::append_shortcut(
- &mut self.text_selection,
- &mut self.clipboard,
- BOOK_TITLE,
- title,
- shortcut,
- 15,
- );
- }
- Some(BookScreen::Edit { pages, page, .. }) => {
- // truncateInsertionText counts the whole value, selection included.
- let room = PAGE_CHARS.saturating_sub(pages[*page].chars().count());
- self.text_selection.apply(
- ("book.page", *page),
- &mut pages[*page],
- shortcut,
- &mut self.clipboard,
- |value, pasted| {
- let text: String = horizon_client::clipboard::filter_text(pasted, true)
- .chars()
- .take(room)
- .collect();
- let next = format!("{value}{text}");
- font.split(&Text::literal(&next), 114.0).len() <= LINES && {
- *value = next;
- true
- }
- },
- );
- }
- _ => {}
- }
- }
- fn edit_page(&mut self, f: impl FnOnce(&mut String)) {
- if let Some(BookScreen::Edit { pages, page, .. }) = self.book.as_mut() {
- f(&mut pages[*page]);
- }
- }
- /// MultiLineEditBox: characters that keep the page within 14 lines and 1024 characters.
- fn type_into_page(&mut self, typed: &str) {
- let Some(BookScreen::Edit { pages, page, .. }) = self.book.as_ref() else {
+ fn book_title_insert(&mut self, text: &str) {
+ let Some(BookScreen::Edit {
+ title, title_edit, ..
+ }) = self.book.as_mut()
+ else {
return;
};
- let mut text = pages[*page].clone();
- for c in typed.chars() {
- let mut next = text.clone();
- next.push(c);
- if next.chars().count() <= PAGE_CHARS && self.book_lines(&next).len() <= LINES {
- text = next;
+ title_edit.insert_text(text);
+ title.clone_from(&title_edit.value);
+ }
+ /// `BookEditScreen.keyPressed` on the page, apart from the line moves.
+ fn book_page_key(&mut self, key: KeyCode) -> bool {
+ let (ctrl, shift) = (self.has_control_down(), self.has_shift_down());
+ let before = match self.book.as_ref() {
+ Some(BookScreen::Edit { page_edit, .. }) => Some((
+ page_edit.value.clone(),
+ page_edit.cursor,
+ page_edit.highlight,
+ )),
+ _ => return false,
+ };
+ let handled = if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+ page_edit.key(key, ctrl, shift)
+ } else {
+ false
+ };
+ if handled {
+ self.page_keep(before);
+ }
+ handled
+ }
+ /// One character at a time, so a page stops at the last character that fits.
+ fn page_insert(&mut self, text: &str) {
+ for c in text.chars() {
+ self.page_change(|edit| edit.insert_text(&c.to_string()));
+ }
+ }
+ /// Ctrl+A/C/V/X: the title box while signing, else the page.
+ pub(super) fn book_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
+ let signing = matches!(self.book, Some(BookScreen::Edit { signing: true, .. }));
+ if signing {
+ if let Some(BookScreen::Edit {
+ title, title_edit, ..
+ }) = self.book.as_mut()
+ {
+ title_edit.shortcut(shortcut, &mut self.clipboard);
+ title.clone_from(&title_edit.value);
+ }
+ return;
+ }
+ let before = match self.book.as_ref() {
+ Some(BookScreen::Edit { page_edit, .. }) => Some((
+ page_edit.value.clone(),
+ page_edit.cursor,
+ page_edit.highlight,
+ )),
+ _ => None,
+ };
+ if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+ page_edit.shortcut(shortcut, &mut self.clipboard);
+ }
+ self.page_keep(before);
+ }
+ /// Edit the page box, then keep it only within 14 lines and 1024 characters.
+ fn page_change(&mut self, f: impl FnOnce(&mut ui::EditBox)) -> bool {
+ let before = match self.book.as_ref() {
+ Some(BookScreen::Edit { page_edit, .. }) => Some((
+ page_edit.value.clone(),
+ page_edit.cursor,
+ page_edit.highlight,
+ )),
+ _ => return false,
+ };
+ let ran = if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+ f(page_edit);
+ true
+ } else {
+ false
+ };
+ ran && self.page_keep(before)
+ }
+ /// Write the page, or put the previous text back when it no longer fits.
+ fn page_keep(&mut self, before: Option<(String, usize, usize)>) -> bool {
+ let next = match self.book.as_ref() {
+ Some(BookScreen::Edit { page_edit, .. }) => page_edit.value.clone(),
+ _ => return false,
+ };
+ let ok = next.chars().count() <= PAGE_CHARS && self.book_lines(&next).len() <= LINES;
+ let Some(BookScreen::Edit {
+ pages,
+ page,
+ page_edit,
+ ..
+ }) = self.book.as_mut()
+ else {
+ return false;
+ };
+ if ok {
+ pages[*page].clone_from(&page_edit.value);
+ } else if let Some((value, cursor, highlight)) = before {
+ page_edit.value = value;
+ page_edit.cursor = cursor;
+ page_edit.highlight = highlight;
+ }
+ ok
+ }
+ /// ArrowUp and ArrowDown move a visual line, keeping the column.
+ fn book_move_line(&mut self, dir: isize) {
+ let shift = self.has_shift_down();
+ let (text, cursor) = match self.book.as_ref() {
+ Some(BookScreen::Edit {
+ pages,
+ page,
+ page_edit,
+ ..
+ }) => (pages[*page].clone(), page_edit.cursor),
+ _ => return,
+ };
+ let rows = self.page_rows(&text);
+ let (x, line) = self.caret_on(&text, &rows, cursor);
+ let next = (line as isize + dir).clamp(0, rows.len() as isize - 1) as usize;
+ let (start, end) = rows[next];
+ let chars: Vec = text.chars().collect();
+ let slice: String = chars[start..end].iter().collect();
+ let pos = start + self.gui.atlas.font.fit(&slice, x);
+ if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+ page_edit.set_cursor(pos, shift);
+ }
+ }
+ /// Wrapped rows of a page as character ranges, the same breaks as `font.split`.
+ fn page_rows(&self, page: &str) -> Vec<(usize, usize)> {
+ let font = &self.gui.atlas.font;
+ let chars: Vec = page.chars().collect();
+ let mut rows = Vec::new();
+ let mut start = 0;
+ while start < chars.len() {
+ let mut end = chars.len();
+ let mut next = chars.len();
+ let mut last_space = None;
+ for i in start..chars.len() {
+ if chars[i] == '\n' {
+ end = i;
+ next = i + 1;
+ break;
+ }
+ if chars[i] == ' ' {
+ last_space = Some(i);
+ }
+ let slice: String = chars[start..=i].iter().collect();
+ if font.width(&slice) > 114.0 {
+ match last_space {
+ Some(s) if s > start => {
+ end = s;
+ next = s + 1;
+ }
+ _ => {
+ end = i.max(start + 1);
+ next = end;
+ }
+ }
+ break;
+ }
+ }
+ rows.push((start, end));
+ start = next;
+ if start == chars.len() && chars.last() == Some(&'\n') {
+ rows.push((chars.len(), chars.len()));
}
}
- self.edit_page(|p| *p = text);
+ if rows.is_empty() {
+ rows.push((0, 0));
+ }
+ rows
+ }
+ /// GUI x of the caret and the row it sits on.
+ fn caret_on(&self, page: &str, rows: &[(usize, usize)], cursor: usize) -> (f32, usize) {
+ let chars: Vec = page.chars().collect();
+ for (i, &(start, end)) in rows.iter().enumerate() {
+ if cursor <= end || i + 1 == rows.len() {
+ let take = cursor.saturating_sub(start).min(end.saturating_sub(start));
+ let prefix: String = chars.iter().skip(start).take(take).collect();
+ return (self.gui.atlas.font.width(&prefix), i);
+ }
+ }
+ (0.0, 0)
+ }
+ fn page_index_at(&self, page: &str, local_x: f32, local_y: f32) -> usize {
+ let rows = self.page_rows(page);
+ let line = (local_y / 9.0).floor().max(0.0) as usize;
+ let line = line.min(rows.len().saturating_sub(1));
+ let (start, end) = rows[line];
+ let chars: Vec = page.chars().collect();
+ let slice: String = chars[start..end].iter().collect();
+ start + self.gui.atlas.font.fit(&slice, local_x.max(0.0))
+ }
+ /// A click on the centred title (`EditBox.onClick`).
+ fn book_title_click(&mut self, field_x: f32, mx: f32) {
+ let shift = self.has_shift_down();
+ let Some(BookScreen::Edit {
+ title, title_edit, ..
+ }) = self.book.as_mut()
+ else {
+ return;
+ };
+ let tx = field_x + ((114.0 - self.gui.atlas.font.width(title)) / 2.0).floor();
+ let rel = (mx - tx).max(0.0);
+ let pos = self.gui.atlas.font.fit(title, rel);
+ title_edit.set_cursor(pos, shift);
+ }
+ /// A click on the open page.
+ fn book_page_click(&mut self, origin_x: f32, origin_y: f32, mx: f32, my: f32) {
+ let shift = self.has_shift_down();
+ let text = match self.book.as_ref() {
+ Some(BookScreen::Edit { pages, page, .. }) => pages[*page].clone(),
+ _ => return,
+ };
+ let pos = self.page_index_at(&text, mx - origin_x, my - origin_y);
+ if let Some(BookScreen::Edit { page_edit, .. }) = self.book.as_mut() {
+ page_edit.set_cursor(pos, shift);
+ }
}
/// The page buttons (`pageForward` adds a page while editing).
fn turn_page(&mut self, forward: bool) {
let mut lectern_page = None;
match self.book.as_mut() {
- Some(BookScreen::Edit { pages, page, .. }) => {
+ Some(BookScreen::Edit {
+ pages,
+ page,
+ page_edit,
+ ..
+ }) => {
+ let before = *page;
if forward {
if *page + 1 >= pages.len() && pages.len() < MAX_PAGES {
pages.push(String::new());
@@ -405,6 +564,10 @@ impl Game<'_> {
} else if *page > 0 {
*page -= 1;
}
+ if *page != before {
+ let text = pages[*page].clone();
+ page_edit.set_value(&text);
+ }
}
Some(BookScreen::View {
lectern: Some(key), ..
@@ -764,6 +927,8 @@ impl Game<'_> {
if let Some(BookScreen::Edit { signing, .. }) = self.book.as_mut() {
*signing = false;
}
+ } else if inside(left + 36.0, 50.0, 114.0, 9.0) {
+ self.book_title_click(left + 36.0, mx);
}
}
Some(BookScreen::Edit { page, .. }) => {
@@ -780,6 +945,8 @@ impl Game<'_> {
} else if inside(w / 2.0 + 2.0, 196.0, 98.0, 20.0) {
click(self);
self.save_book(false);
+ } else if inside(left + 36.0, 32.0, 114.0, 14.0 * 9.0) {
+ self.book_page_click(left + 36.0, 32.0, mx, my);
}
}
Some(BookScreen::View {
@@ -865,7 +1032,7 @@ impl Game<'_> {
BookScreen::Edit {
signing: true,
title,
- opened,
+ title_edit,
..
} => {
let edit = tr("book.editTitle", "Enter Book Title:");
@@ -881,19 +1048,35 @@ impl Game<'_> {
// The title box: an unbordered, centred EditBox of 114 with
// black text and no shadow; the value alone is centred, the
// cursor follows it.
+ let value = &title_edit.value;
let x = left + 36.0;
- let tx = x + ((114.0 - HudBatch::text_width(atlas, title)) / 2.0).floor();
- horizon_client::ui::append_field(
- batch,
- atlas,
- title,
- (tx, 50.0, x + 114.0 - tx),
- (BLACK, false),
- 15,
- self.text_selection.covers(BOOK_TITLE, title),
- true,
- opened.elapsed().as_millis(),
- );
+ let tx = x + ((114.0 - HudBatch::text_width(atlas, value)) / 2.0).floor();
+ batch.text(atlas, value, tx, 50.0, BLACK, false);
+ if title_edit.cursor != title_edit.highlight {
+ let (a, b) = (
+ title_edit.cursor.min(title_edit.highlight),
+ title_edit.cursor.max(title_edit.highlight),
+ );
+ let pre: String = value.chars().take(a).collect();
+ let sel: String = value.chars().skip(a).take(b - a).collect();
+ let sx = tx + HudBatch::text_width(atlas, &pre);
+ batch.text_highlight(
+ atlas,
+ (sx, 49.0, HudBatch::text_width(atlas, &sel), 11.0),
+ true,
+ );
+ }
+ if title_edit.cursor_visible() {
+ let pre: String = value.chars().take(title_edit.cursor).collect();
+ batch.fill(
+ atlas,
+ tx + HudBatch::text_width(atlas, &pre),
+ 49.0,
+ 1.0,
+ 9.0,
+ BLACK,
+ );
+ }
let by = tr("book.byAuthor", "by %1$s").replace("%1$s", super::chat::PLAYER_NAME);
let tw = HudBatch::text_width(atlas, &by);
batch.text(
@@ -941,12 +1124,12 @@ impl Game<'_> {
BookScreen::Edit {
pages,
page,
- opened,
+ page_edit,
..
} => {
indicator(batch, *page, pages.len());
- let blink = (opened.elapsed().as_millis() / 300) % 2 == 0;
- let lines = self.book_lines(&pages[*page]);
+ let text = &pages[*page];
+ let lines = self.book_lines(text);
for (i, line) in lines.iter().take(LINES).enumerate() {
batch.text_styled(
atlas,
@@ -957,27 +1140,39 @@ impl Game<'_> {
false,
);
}
- if blink {
- // The cursor after the last character.
- let last = lines
- .last()
- .map(|l| atlas.font.width_text(l))
- .unwrap_or(0.0);
- let row = lines.len().saturating_sub(1) as f32
- + if pages[*page].ends_with('\n') {
- 1.0
- } else {
- 0.0
- };
- let x = if pages[*page].ends_with('\n') {
- 0.0
- } else {
- last
- };
+ let rows = self.page_rows(text);
+ let (sel_a, sel_b) = (
+ page_edit.cursor.min(page_edit.highlight),
+ page_edit.cursor.max(page_edit.highlight),
+ );
+ if sel_a != sel_b {
+ let chars: Vec = text.chars().collect();
+ for (i, &(start, end)) in rows.iter().enumerate().take(LINES) {
+ let from = sel_a.max(start);
+ let to = sel_b.min(end);
+ if from >= to {
+ continue;
+ }
+ let pre: String = chars[start..from].iter().collect();
+ let sel: String = chars[from..to].iter().collect();
+ batch.text_highlight(
+ atlas,
+ (
+ left + 36.0 + atlas.font.width(&pre),
+ top + 29.0 + i as f32 * 9.0,
+ atlas.font.width(&sel),
+ 9.0,
+ ),
+ true,
+ );
+ }
+ }
+ if page_edit.cursor_visible() {
+ let (x, row) = self.caret_on(text, &rows, page_edit.cursor);
batch.fill(
atlas,
left + 36.0 + x,
- top + 29.0 + row * 9.0,
+ top + 29.0 + row as f32 * 9.0,
1.0,
9.0,
BLACK,
diff --git a/crates/horizon-client/src/game/campfire.rs b/crates/horizon-client/src/game/campfire.rs
new file mode 100644
index 000000000..c388b7561
--- /dev/null
+++ b/crates/horizon-client/src/game/campfire.rs
@@ -0,0 +1,190 @@
+//! Campfires' cooking: `CampfireBlock.useItemOn` (`CampfireBlockEntity.placeFood`)
+//! and the block entity's `cookTick` (lit) and `cooldownTick` (unlit). The
+//! items drawn on the fire are `campfire_geometry`'s; a server's clients get
+//! them through the block entity's update tag (`lan::chunks::entity_tag`).
+use super::Game;
+use horizon_assets::item_model::DisplayContext;
+use horizon_client::{
+ Result, block_entities::Pos, block_entity_render::vertex_light, containers::BlockEntity,
+ items::ItemStack, mesher::Vertex, mobs::Who,
+};
+use horizon_core::position::BlockPos;
+
+/// The `campfire_cooking` recipe kind (`RecipeType.CAMPFIRE_COOKING`).
+const KIND: &str = "minecraft:campfire_cooking";
+
+fn is_campfire(name: &str) -> bool {
+ name == "minecraft:campfire" || name == "minecraft:soul_campfire"
+}
+
+impl Game<'_> {
+ /// `CampfireBlock.useItemOn` with a held item that is a campfire recipe's
+ /// input (`RecipePropertySet.CAMPFIRE_INPUT`): on a server level the food
+ /// goes into the first free slot (`placeFood`), and the use is consumed
+ /// whether or not there was room. A client of a server leaves the placing
+ /// to the server. Whether the food went in; None when this isn't a
+ /// campfire use, so the item's own use runs.
+ pub(super) fn use_on_campfire(&mut self, pos: [i32; 3]) -> Result> {
+ let state = self.world.block(pos[0], pos[1], pos[2]);
+ if !is_campfire(&self.res.facts().get(state).name) {
+ return Ok(None);
+ }
+ let Some(held) = self.held().cloned() else {
+ return Ok(None);
+ };
+ let Some(time) = self.res.recipes().cook(KIND, &held).map(|r| r.time as i32) else {
+ return Ok(None);
+ };
+ // A client of a server predicts the placing; the server decides.
+ if self.remote.is_some() {
+ return Ok(Some(true));
+ }
+ let key = (pos[0], pos[1], pos[2]);
+ let placed = match self.world.block_entities.get_mut(&key) {
+ Some(BlockEntity::Campfire(c)) => {
+ let mut one = held.clone();
+ c.place_food(&mut one, time)
+ }
+ _ => false,
+ };
+ if placed {
+ // ItemStack.consumeAndReturn: creative keeps the item.
+ self.consume_held();
+ self.stats.custom("interact_with_campfire", 1);
+ self.post_block_game_event(
+ "minecraft:block_change",
+ pos,
+ Some(Who::Player),
+ Some(state),
+ );
+ self.mark_block_entity_updated(key);
+ }
+ Ok(Some(placed))
+ }
+
+ /// `CampfireBlockEntity.cookTick` of a lit campfire, `cooldownTick` of an
+ /// unlit one. A finished item's result (the recipe's, or the item itself
+ /// when no recipe takes it any more) drops at the block's corner
+ /// (`Containers.dropItemStack` at its integer position), then the clients
+ /// see the slot empty and a `block_change` goes out.
+ pub(super) fn tick_campfire(&mut self, pos: Pos) -> Result<()> {
+ let state = self.world.block(pos.0, pos.1, pos.2);
+ let lit = self
+ .pack
+ .assets
+ .registry
+ .state(state)
+ .and_then(|s| s.properties.get("lit"))
+ .is_some_and(|v| v == "true");
+ let Some(BlockEntity::Campfire(c)) = self.world.block_entities.get_mut(&pos) else {
+ return Ok(());
+ };
+ // BlockEntity.setChanged: a timer that moved is saved with the
+ // chunk (no update to the clients, who don't see the timers).
+ let changed = if lit {
+ c.items.iter().any(Option::is_some)
+ } else {
+ c.cooldown_tick()
+ };
+ if changed {
+ self.world.modified.insert((pos.0 >> 4, pos.2 >> 4));
+ }
+ if !lit {
+ return Ok(());
+ }
+ let Some(BlockEntity::Campfire(c)) = self.world.block_entities.get_mut(&pos) else {
+ return Ok(());
+ };
+ let done = c.cook_tick();
+ for (_, item) in done {
+ let result = self
+ .res
+ .recipes()
+ .cook(KIND, &item)
+ .map_or_else(|| item.clone(), |r| r.result.clone());
+ self.campfire_drop(pos, result);
+ self.mark_block_entity_updated(pos);
+ self.post_block_game_event(
+ "minecraft:block_change",
+ [pos.0, pos.1, pos.2],
+ None,
+ Some(state),
+ );
+ }
+ Ok(())
+ }
+
+ /// `CampfireRenderer`: each cooking item lies on the fire, slot `i`
+ /// turned to `Direction.from2DDataValue((i + facing) % 4)`, laid flat
+ /// (90° about X), at a corner and three eighths of its size, drawn as a
+ /// FIXED item seeded by the block's position plus the slot.
+ pub(super) fn campfire_geometry(&self, camera: glam::DVec3, out: &mut Vec) {
+ for (key, entity) in &self.world.block_entities {
+ let BlockEntity::Campfire(c) = entity else {
+ continue;
+ };
+ if c.items.iter().all(Option::is_none) {
+ continue;
+ }
+ let at = glam::DVec3::new(f64::from(key.0), f64::from(key.1), f64::from(key.2));
+ if at.distance_squared(camera) >= 64.0 * 64.0 {
+ continue;
+ }
+ // Direction.get2DDataValue: south 0, west 1, north 2, east 3.
+ let state = self.world.block(key.0, key.1, key.2);
+ let facing = match self
+ .pack
+ .assets
+ .registry
+ .state(state)
+ .and_then(|s| s.properties.get("facing"))
+ .map(String::as_str)
+ {
+ Some("west") => 1,
+ Some("north") => 2,
+ Some("east") => 3,
+ _ => 0,
+ };
+ let light = vertex_light(self.world.light(key.0, key.1, key.2));
+ let packed = BlockPos::new(key.0, key.1, key.2).pack();
+ for (i, stack) in c.items.iter().enumerate() {
+ let Some(stack) = stack else {
+ continue;
+ };
+ let seed = (packed as i32).wrapping_add(i as i32);
+ let item = self.resolve_item(stack, DisplayContext::Fixed, None, seed);
+ if item.is_empty() {
+ continue;
+ }
+ // Direction.toYRot: 90° per 2D step from south.
+ let yaw = -(((i + facing) % 4) as f32 * 90.0);
+ let pose = glam::Mat4::from_translation(
+ (at - camera).as_vec3() + glam::Vec3::new(0.5, 0.449_218_75, 0.5),
+ ) * glam::Mat4::from_rotation_y(yaw.to_radians())
+ * glam::Mat4::from_rotation_x(90f32.to_radians())
+ * glam::Mat4::from_translation(glam::Vec3::new(-0.3125, -0.3125, 0.0))
+ * glam::Mat4::from_scale(glam::Vec3::splat(0.375));
+ self.submit_item_world(&item, pose, light, out);
+ }
+ }
+ }
+
+ /// `Containers.dropItemStack(level, x, y, z, stack)` at the block's
+ /// integer position.
+ fn campfire_drop(&mut self, pos: Pos, stack: ItemStack) {
+ let at = BlockPos::new(pos.0, pos.1, pos.2);
+ for piece in
+ horizon_world::level::removal::drop_item_stack(&mut self.world.random, at, stack.count)
+ {
+ self.spawn_item(
+ ItemStack {
+ count: piece.count,
+ ..stack.clone()
+ },
+ piece.pos,
+ piece.motion,
+ 0,
+ );
+ }
+ }
+}
diff --git a/crates/horizon-client/src/game/campfire_douse.rs b/crates/horizon-client/src/game/campfire_douse.rs
new file mode 100644
index 000000000..04accb2d3
--- /dev/null
+++ b/crates/horizon-client/src/game/campfire_douse.rs
@@ -0,0 +1,53 @@
+//! `CampfireBlock.useItemOn`: an item in `#minecraft:douses_campfires` (the
+//! shovels) put on a lit campfire puts it out.
+use super::Game;
+use horizon_client::{Result, animate_tick::make_campfire_smoke, items::ItemStack};
+
+impl Game<'_> {
+ /// `CampfireBlock.useItemOn` with `held` in the hand that acts, the block
+ /// at `pos` clicked: true when it doused a lit campfire (SUCCESS).
+ pub(super) fn use_campfire_douse(
+ &mut self,
+ pos: [i32; 3],
+ held: Option<&ItemStack>,
+ ) -> Result {
+ let Some(tool) = held.filter(|s| {
+ self.res
+ .items()
+ .item_tags
+ .get("minecraft:douses_campfires")
+ .is_some_and(|members| members.contains(&*s.item))
+ }) else {
+ return Ok(false);
+ };
+ let registry = self.pack.assets.registry;
+ let Some(mut state) = registry
+ .state(self.world.block(pos[0], pos[1], pos[2]))
+ .filter(|s| matches!(&*s.name, "minecraft:campfire" | "minecraft:soul_campfire"))
+ .filter(|s| s.properties.get("lit").map(String::as_str) == Some("true"))
+ .cloned()
+ else {
+ return Ok(false);
+ };
+ // Level event 1009 (SOUND_EXTINGUISH_FIRE) goes to every player.
+ self.level_event_at(1009, pos, 0);
+ // CampfireBlock.douse: the acting client's own smoke (twenty puffs),
+ // then the block change game event from the player.
+ if self.lan_acting.is_none() {
+ let signal = state.properties.get("signal_fire").map(String::as_str) == Some("true");
+ for _ in 0..20 {
+ make_campfire_smoke(&mut self.particles, pos, signal, true);
+ }
+ }
+ self.post_block_game_event("minecraft:block_change", pos, self.sculk_actor(), None);
+ state.properties.insert("lit".into(), "false".into());
+ if let Ok(unlit) = registry.resolve(&state) {
+ self.level_set(pos, unlit)?;
+ }
+ let used = tool.clone();
+ self.damage_held(1);
+ // ServerPlayerGameMode.useItemOn: the action was consumed.
+ self.trigger_block("minecraft:item_used_on_block", pos, &used);
+ Ok(true)
+ }
+}
diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs
index 5d3919c8b..03174c009 100644
--- a/crates/horizon-client/src/game/chat.rs
+++ b/crates/horizon-client/src/game/chat.rs
@@ -464,7 +464,28 @@ impl Game<'_> {
return;
}
// The Chat option's Hidden level takes the server's messages too.
- if !self.ui.chat.shows(ChatSource::Server) {
+ self.local_chat_line(text, Some(SYSTEM_INDICATOR), ChatSource::Server);
+ }
+ /// A player's chat line on the window's own chat: a LAN guest's message
+ /// while the host runs in-frame (`HostEvent::Chat`). `ChatListener`
+ /// checks `canReceivePlayerMessages` for these, so Commands Only and
+ /// Hidden drop them; command feedback (`/list`, `/tp`) is a system
+ /// message and takes the system-message permission instead.
+ pub(super) fn player_message(&mut self, text: Text) {
+ if let Some(capture) = self.chat_capture.as_mut() {
+ capture.push(text);
+ return;
+ }
+ // A server's client receives the line as a packet (PlayerChat or
+ // DisguisedChat) and filters it there.
+ if self.remote.is_none() {
+ self.local_chat_line(text, None, ChatSource::Player);
+ }
+ }
+ /// A line on the window's own chat when the Chat option lets `source`
+ /// through; running mods hear it.
+ fn local_chat_line(&mut self, text: Text, indicator: Option, source: ChatSource) {
+ if !self.ui.chat.shows(source) {
return;
}
let focused = self.screen == Screen::Chat;
@@ -472,8 +493,8 @@ impl Game<'_> {
self.ui.chat.add(
&self.gui.atlas,
text,
- Some(SYSTEM_INDICATOR),
- ChatSource::Server,
+ indicator,
+ source,
self.ticks,
focused,
);
@@ -602,7 +623,10 @@ impl Game<'_> {
return;
}
if let Some(command) = message.strip_prefix('/') {
- self.run_command(command);
+ // A client mod's command first, then a server mod's, as on a server.
+ if !self.mod_command(command) && !self.local_server_mod_command(command) {
+ self.run_command(command);
+ }
} else {
let line = Text::translate(
"chat.type.text",
@@ -622,6 +646,7 @@ impl Game<'_> {
self.mods_chat(&line);
}
self.lan_host_chat(message);
+ self.mod_player_chat(super::server_mods::Who::Local, message);
}
}
pub(super) fn chat_scroll(&mut self, amount: f32) {
@@ -757,6 +782,7 @@ impl Game<'_> {
max_snow_accumulation_height: r.int("max_snow_accumulation_height"),
spawn_mobs: r.bool("spawn_mobs"),
spawn_monsters: r.bool("spawn_monsters"),
+ fire_spread_radius_around_player: r.int("fire_spread_radius_around_player"),
}
}
/// Apply rules mirrored in other state (natural regeneration, difficulty).
diff --git a/crates/horizon-client/src/game/clipboard.rs b/crates/horizon-client/src/game/clipboard.rs
index c87aa3681..6e81bf3ee 100644
--- a/crates/horizon-client/src/game/clipboard.rs
+++ b/crates/horizon-client/src/game/clipboard.rs
@@ -63,8 +63,8 @@ impl Game<'_> {
}
}
}
- /// Typing or a backspace in a field of the title screens: in the server
- /// screens' append-only fields Select All's selection is replaced first.
+ /// Typing or a backspace in a title-screen field. A field that still only
+ /// appends replaces a Select All selection before the edit.
pub(super) fn title_edit(&mut self, typed: Option<&str>, backspace: bool) {
let Some(title) = self.title.as_mut() else {
return;
@@ -86,42 +86,31 @@ impl Game<'_> {
}
/// Shortcuts in the creative inventory's search box (an `EditBox` of 50).
pub(super) fn creative_search_shortcut(&mut self, shortcut: EditShortcut) {
- if Self::append_shortcut(
- &mut self.text_selection,
- &mut self.clipboard,
- CREATIVE_SEARCH,
- &mut self.creative_screen.search,
- shortcut,
- CREATIVE_SEARCH_CHARS,
- ) {
+ if self
+ .creative_screen
+ .search
+ .shortcut(shortcut, &mut self.clipboard)
+ {
self.creative_screen.scroll = 0.0;
}
}
/// A backspace in the creative search box: with Ctrl, the whole word
/// before the caret (`EditBox.deleteWords(-1)`), otherwise one character.
- /// A Select All selection is what it deletes, as in `EditBox.keyPressed`.
+ /// A selection is what it deletes, as in `EditBox.keyPressed`.
pub(super) fn creative_search_backspace(&mut self, ctrl: bool) {
- let search = &mut self.creative_screen.search;
- if !self.text_selection.take(CREATIVE_SEARCH, search) {
- if ctrl {
- horizon_client::ui::delete_words(search, -1);
- } else {
- search.pop();
- }
- }
+ self.creative_screen
+ .search
+ .key(KeyCode::Backspace, ctrl, false);
self.creative_screen.scroll = 0.0;
}
/// Typing in the creative search box.
pub(super) fn creative_search_edit(&mut self, typed: Option<&str>) {
- let search = &mut self.creative_screen.search;
- self.text_selection.take(CREATIVE_SEARCH, search);
if let Some(text) = typed {
- clipboard::append_limited(search, text, CREATIVE_SEARCH_CHARS);
+ self.creative_screen.search.insert_text(text);
+ self.creative_screen.scroll = 0.0;
}
- self.creative_screen.scroll = 0.0;
}
}
/// `CreativeModeInventoryScreen`'s search box: `setMaxLength(50)`.
pub(super) const CREATIVE_SEARCH_CHARS: usize = 50;
-pub(super) const CREATIVE_SEARCH: horizon_client::clipboard::FieldId = ("creative.search", 0);
diff --git a/crates/horizon-client/src/game/combat.rs b/crates/horizon-client/src/game/combat.rs
index 227aa0332..6e1d5d82b 100644
--- a/crates/horizon-client/src/game/combat.rs
+++ b/crates/horizon-client/src/game/combat.rs
@@ -31,6 +31,10 @@ pub(super) struct CombatTracker {
/// The mob exploding now (`ServerExplosion.source`): its team's friendly
/// fire decides whom the blast may hurt.
pub(super) explosion_source: Option,
+ /// Charged creepers whose blast just went off and that have not dropped
+ /// a head yet (`Creeper.droppedSkulls`): they are gone from the mob list,
+ /// but the mobs they killed still ask for their loot.
+ pub(super) charged_exploders: Vec,
/// The player's fall distance before this tick's movement (as of the
/// end of the last one).
fall_before: f64,
@@ -52,11 +56,16 @@ impl Game<'_> {
/// Remember who deals the next `damage_type` damage to the player.
pub(super) fn note_attacker(&mut self, damage_type: &str, mob: u32) {
if let Some(name) = self.mob_display_name(mob) {
- self.combat
- .pending
- .push((damage_type.to_owned(), (mob, name)));
+ self.note_named_attacker(damage_type, mob, name);
}
}
+ /// `note_attacker` for an entity that is not one of `self.mobs` (the
+ /// ender dragon).
+ pub(super) fn note_named_attacker(&mut self, damage_type: &str, id: u32, name: Text) {
+ self.combat
+ .pending
+ .push((damage_type.to_owned(), (id, name)));
+ }
/// `LivingEntity.handleDamageEvent` for the player: the hurt sound of the
/// source's `DamageEffects` (`Player.getHurtSound`).
pub(super) fn player_hurt_sound(&mut self, sound: &str, at: [f64; 3]) {
diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs
index dbe5d0ada..22041c3b2 100644
--- a/crates/horizon-client/src/game/commands.rs
+++ b/crates/horizon-client/src/game/commands.rs
@@ -1697,6 +1697,8 @@ impl Game<'_> {
value: 0,
age: 0,
on_ground: false,
+ count: 1,
+ ticks: 0,
});
name = Text::translate("entity.minecraft.experience_orb", &[]);
}
@@ -1885,11 +1887,12 @@ impl Game<'_> {
}
}
}
- let Some((_, new)) = horizon_client::save::decode_block_entity(&tag) else {
+ let Some((_, mut new)) = horizon_client::save::decode_block_entity(&tag) else {
return false;
};
+ let rolled = self.take_loot_table(key, &tag, &mut new);
let after = horizon_client::save::encode_block_entity(key, &new, &name);
- if after == before {
+ if after == before && !rolled {
return false;
}
self.world.block_entities.insert(key, new);
@@ -1897,6 +1900,79 @@ impl Game<'_> {
let _ = self.world.set(pos[0], pos[1], pos[2], state);
true
}
+ /// RandomizableContainer.tryLoadLootTable for a tag a command gives a
+ /// container (`setblock`, `data`): an empty container with a `LootTable`
+ /// is rolled now, as a loaded chunk's are (`save::roll_loaded_loot`), and
+ /// the roll is kept with its chunk, so that the container saves, and
+ /// `data get` shows, its table and seed until its items change. A tag
+ /// without one drops what the container had. True when it had a table.
+ pub(super) fn take_loot_table(
+ &mut self,
+ key: (i32, i32, i32),
+ tag: &horizon_world::nbt::Tag,
+ entity: &mut horizon_client::containers::BlockEntity,
+ ) -> bool {
+ use horizon_client::{containers::BlockEntity, save, structure_blocks};
+ let table = save::text(tag.get("LootTable"));
+ let rolled = match (table, entity) {
+ (Some(table), BlockEntity::Chest(slots)) if slots.iter().all(Option::is_none) => {
+ let loot = structure_blocks::loot_data(&self.options.resources);
+ let at = Vec3::new(f64::from(key.0), f64::from(key.1), f64::from(key.2));
+ let biome = self.biome_name_at(at).unwrap_or_default();
+ Some(structure_blocks::roll_container(
+ slots,
+ loot.as_deref(),
+ table,
+ structure_blocks::loot_seed(tag),
+ key,
+ &biome,
+ ))
+ }
+ _ => None,
+ };
+ let Some(chunk) = self.world.chunks.get_mut(&(key.0 >> 4, key.2 >> 4)) else {
+ return false;
+ };
+ let held = |c: &horizon_client::chunk::Chunk| {
+ c.saved
+ .as_ref()
+ .is_some_and(|s| s.rolled_loot.iter().any(|r| r.pos == key))
+ };
+ if rolled.is_none() && !held(chunk) {
+ return false;
+ }
+ let chunk = std::sync::Arc::make_mut(chunk);
+ let mut extras = chunk
+ .saved
+ .take()
+ .map(std::sync::Arc::unwrap_or_clone)
+ .unwrap_or_default();
+ extras.rolled_loot.retain(|r| r.pos != key);
+ let taken = rolled.is_some();
+ extras.rolled_loot.extend(rolled);
+ chunk.saved = Some(std::sync::Arc::new(extras));
+ taken
+ }
+ /// The loot table and seed a container still holding its roll saves
+ /// (`RolledLoot::restore`), in place of its items.
+ pub(super) fn restore_loot_table(
+ &self,
+ key: (i32, i32, i32),
+ tag: &mut horizon_world::nbt::Tag,
+ ) {
+ let horizon_world::nbt::Tag::Compound(map) = tag else {
+ return;
+ };
+ let rolled = self
+ .world
+ .chunks
+ .get(&(key.0 >> 4, key.2 >> 4))
+ .and_then(|c| c.saved.as_ref())
+ .and_then(|s| s.rolled_loot.iter().find(|r| r.pos == key));
+ if let Some(r) = rolled {
+ r.restore(map);
+ }
+ }
fn cmd_fill(&mut self, ctx: &Context) -> R {
let a = self.block_pos_arg(ctx, "from")?;
let b = self.block_pos_arg(ctx, "to")?;
@@ -2593,38 +2669,7 @@ impl Game<'_> {
/// `PoiTypes`: the point of interest type of a block state.
fn poi_type(&self, state: horizon_world::registry::BlockStateId) -> Option<&'static str> {
let s = self.pack.assets.registry.state(state)?;
- let name = s.name.strip_prefix("minecraft:")?;
- Some(match name {
- "blast_furnace" => "minecraft:armorer",
- "smoker" => "minecraft:butcher",
- "cartography_table" => "minecraft:cartographer",
- "brewing_stand" => "minecraft:cleric",
- "composter" => "minecraft:farmer",
- "barrel" => "minecraft:fisherman",
- "fletching_table" => "minecraft:fletcher",
- "cauldron" | "lava_cauldron" | "water_cauldron" | "powder_snow_cauldron" => {
- "minecraft:leatherworker"
- }
- "lectern" => "minecraft:librarian",
- "stonecutter" => "minecraft:mason",
- "loom" => "minecraft:shepherd",
- "smithing_table" => "minecraft:toolsmith",
- "grindstone" => "minecraft:weaponsmith",
- "bell" => "minecraft:meeting",
- "beehive" => "minecraft:beehive",
- "bee_nest" => "minecraft:bee_nest",
- "nether_portal" => "minecraft:nether_portal",
- "lodestone" => "minecraft:lodestone",
- "test_instance_block" => "minecraft:test_instance",
- n if n.ends_with("_bed") => {
- if s.properties.get("part").map(String::as_str) != Some("head") {
- return None;
- }
- "minecraft:home"
- }
- n if n.ends_with("lightning_rod") => "minecraft:lightning_rod",
- _ => return None,
- })
+ horizon_client::save::poi_type(s).map(|(kind, _)| kind)
}
/// `LocateCommand.locatePoi`: `PoiManager.findClosestWithType` within
/// 256 blocks of the source, over the loaded chunks.
diff --git a/crates/horizon-client/src/game/commands/data.rs b/crates/horizon-client/src/game/commands/data.rs
index 18035ddd7..ac16c5e7c 100644
--- a/crates/horizon-client/src/game/commands/data.rs
+++ b/crates/horizon-client/src/game/commands/data.rs
@@ -286,6 +286,7 @@ impl Game<'_> {
if let Tag::Compound(c) = &mut tag {
c.remove(&"keepPacked".into());
}
+ self.restore_loot_table(key, &mut tag);
Ok(tag)
}
DataRef::Storage(id) => Ok(self.score.storage.get(id)),
@@ -296,7 +297,8 @@ impl Game<'_> {
DataRef::Entity(t) => self.apply_entity_nbt(*t, tag),
DataRef::Block(p) => {
let key = (p[0], p[1], p[2]);
- if let Some((_, new)) = save::decode_block_entity(&tag) {
+ if let Some((_, mut new)) = save::decode_block_entity(&tag) {
+ self.take_loot_table(key, &tag, &mut new);
self.world.block_entities.insert(key, new);
let state = self.world.block(p[0], p[1], p[2]);
// Redraw what shows the block entity (signs, banners).
diff --git a/crates/horizon-client/src/game/commands/world_cmds.rs b/crates/horizon-client/src/game/commands/world_cmds.rs
index 30f019997..687eb3f88 100644
--- a/crates/horizon-client/src/game/commands/world_cmds.rs
+++ b/crates/horizon-client/src/game/commands/world_cmds.rs
@@ -49,26 +49,12 @@ impl Game<'_> {
let mut tracker = Tracker::default();
for &t in &targets {
let h = holder(self.target_name(t));
- // ServerRecipeBook.addRecipes/removeRecipes count recipe book
- // displays (a transmute recipe has one per material count).
- let mut n = 0;
- // ServerPlayer.awardRecipes / resetRecipes: the displays changed.
- let index = &self.res.stations().recipe_index;
- n += if give {
- let (count, unlocked) = self.level.recipe_book.add_recipes(index, &recipes);
- self.recipe_unlocked(&unlocked);
- count as i32
- } else {
- let removed = self.level.recipe_book.remove_recipes(index, &recipes);
- let count = removed.len() as i32;
- // A network player's client drops them from its book.
- if self.lan_acting.is_some() && !removed.is_empty() {
- self.guest_packets.push(C::RecipeBookRemove(
- horizon_protocol::packets::recipes::RecipeBookRemove { ids: removed },
- ));
- }
- count
- };
+ // ServerPlayer.awardRecipes / resetRecipes on the target's own
+ // ServerRecipeBook: a guest's is swapped in for the call, and the
+ // packets go to its client.
+ let n = self
+ .for_player(t, |g| g.change_recipes(give, &recipes))
+ .unwrap_or(0);
tracker.track(&h, n);
}
let verb = if give { "give" } else { "take" };
@@ -92,6 +78,27 @@ impl Game<'_> {
Ok(total)
}
+ /// ServerRecipeBook.addRecipes/removeRecipes for the player in place: how
+ /// many recipe book displays changed (a transmute recipe has one per
+ /// material count).
+ fn change_recipes(&mut self, give: bool, recipes: &[String]) -> i32 {
+ let index = &self.res.stations().recipe_index;
+ if give {
+ let (count, unlocked) = self.level.recipe_book.add_recipes(index, recipes);
+ self.recipe_unlocked(&unlocked);
+ return count as i32;
+ }
+ let removed = self.level.recipe_book.remove_recipes(index, recipes);
+ let count = removed.len() as i32;
+ // A network player's client drops them from its book.
+ if self.lan_acting.is_some() && !removed.is_empty() {
+ self.guest_packets.push(C::RecipeBookRemove(
+ horizon_protocol::packets::recipes::RecipeBookRemove { ids: removed },
+ ));
+ }
+ count
+ }
+
// ---- /damage ----------------------------------------------------------------
fn damage_kind(ty: &str) -> DamageKind {
diff --git a/crates/horizon-client/src/game/composter.rs b/crates/horizon-client/src/game/composter.rs
index 3f57229ad..4013155ad 100644
--- a/crates/horizon-client/src/game/composter.rs
+++ b/crates/horizon-client/src/game/composter.rs
@@ -5,6 +5,7 @@
use super::{Game, commands::compute::ComputeContext};
use horizon_client::{
items::ItemStack,
+ mobs::villager,
particles::{ParticleOptions, ParticleType},
};
use horizon_core::{position::BlockPos, random::RandomSource};
@@ -86,6 +87,82 @@ impl Game<'_> {
self.composter_add(pos, &layers);
(stack.count > 0).then_some(stack)
}
+ /// `WorkAtComposter.compostItems` for the villager at `mob`: a full
+ /// composter is emptied, then up to 20 wheat or beetroot seeds go in
+ /// (keeping 10 of each kind) until the composter reaches level 7. Level
+ /// event 1500 plays once, at the end.
+ pub(super) fn villager_compost_items(&mut self, mob: usize, pos: [i32; 3]) {
+ let at = BlockPos::new(pos[0], pos[1], pos[2]);
+ let Some(mut before) = self.composter_level(pos) else {
+ return;
+ };
+ if before == 8 {
+ self.with_level(|b, level, ticks| b.composter_extract(level, ticks, at));
+ let _ = self.process_level_events();
+ before = 0;
+ }
+ let mut remaining = 20;
+ let mut amounts: Vec<(std::sync::Arc, i32)> = Vec::new();
+ let slots = villager::ext(&self.mobs[mob]).map_or(0, |e| e.inventory.len());
+ 'slots: for slot in (0..slots).rev() {
+ if remaining <= 0 {
+ break;
+ }
+ let stack = villager::ext_mut(&mut self.mobs[mob]).inventory[slot].clone();
+ if !matches!(
+ &*stack.item,
+ "minecraft:wheat_seeds" | "minecraft:beetroot_seeds"
+ ) {
+ continue;
+ }
+ let known = amounts.iter().position(|(item, _)| *item == stack.item);
+ let total = known.map_or(0, |k| amounts[k].1) + stack.count as i32;
+ match known {
+ Some(k) => amounts[k].1 = total,
+ None => amounts.push((stack.item.clone(), total)),
+ }
+ let uses = (total - 10).min(remaining).min(stack.count as i32);
+ if uses <= 0 {
+ continue;
+ }
+ remaining -= uses;
+ for _ in 0..uses {
+ self.villager_insert_item(mob, slot, &stack, pos);
+ if self.composter_level(pos) == Some(7) {
+ break 'slots;
+ }
+ }
+ }
+ let after = self.composter_level(pos).unwrap_or(before);
+ self.with_level(|b, level, ticks| {
+ b.composter_fill_effects(level, ticks, at, after != before)
+ });
+ let _ = self.process_level_events();
+ }
+ /// `ComposterBlock.insertItem` with a villager's stack: below level 7 a
+ /// compostable item is used up and may add a layer.
+ fn villager_insert_item(&mut self, mob: usize, slot: usize, stack: &ItemStack, pos: [i32; 3]) {
+ if self.composter_level(pos).is_none_or(|level| level >= 7) {
+ return;
+ }
+ let Some(layers) = self.compostable(stack) else {
+ return;
+ };
+ let context = ComputeContext {
+ block: Some(pos),
+ target: None,
+ };
+ let layers = self.provider_int(&layers, &context, 0).unwrap_or(0);
+ let at = BlockPos::new(pos[0], pos[1], pos[2]);
+ self.with_level(|b, level, ticks| b.composter_layer(level, ticks, at, layers));
+ self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
+ let _ = self.process_level_events();
+ let inventory = &mut villager::ext_mut(&mut self.mobs[mob]).inventory;
+ inventory[slot].count -= 1;
+ if inventory[slot].count == 0 {
+ inventory.remove(slot);
+ }
+ }
/// `ComposterBlock.handleFill` (level event 1500) on the client: the
/// fill sound and ten composter particles above the compost.
pub(super) fn composter_fill_event(&mut self, pos: BlockPos, success: bool) {
diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs
index 3a8562ee1..f6961ab13 100644
--- a/crates/horizon-client/src/game/creatures.rs
+++ b/crates/horizon-client/src/game/creatures.rs
@@ -50,9 +50,9 @@ pub(super) struct Creatures {
/// The wandering trader spawner's clock.
pub trader: super::wandering_trader::Spawner,
}
-struct ProjWorld<'a, 'w> {
- w: &'a MobWorld<'w>,
- targets: Vec<(Who, Aabb)>,
+pub(super) struct ProjWorld<'a, 'w> {
+ pub w: &'a MobWorld<'w>,
+ pub targets: Vec<(Who, Aabb)>,
}
impl ProjectileWorld for ProjWorld<'_, '_> {
fn clip(&self, from: Vec3, to: Vec3) -> Option<(Vec3, [i32; 3], [i32; 3])> {
@@ -193,6 +193,7 @@ impl Game<'_> {
velocity: p.velocity,
yaw: self.yaw,
hero: self.potions.effects.get("hero_of_the_village").is_some(),
+ effects: self.potions.effects.list.iter().map(|e| e.id).collect(),
uuid: self.level.player_uuid.unwrap_or_default(),
allies: std::sync::Arc::new(self.player_allies()),
remote: false,
@@ -373,6 +374,7 @@ impl Game<'_> {
// Drawn seated (Entity.isPassenger); set apart because the
// json! above is at the macro recursion limit.
state["passenger"] = m.extra.passenger.into();
+ state["guardian_beam"] = serde_json::json!(horizon_client::mobs::guardian::beam(m, 0.0));
state
})
.collect();
@@ -391,6 +393,9 @@ impl Game<'_> {
}
pub(super) fn mob_world_base<'s>(&'s self, others: &'s [Seen]) -> MobWorld<'s> {
let (rain, thunder) = self.world.weather.levels(1.0);
+ // Level.canHaveWeather: only the overworld's rain and thunder levels
+ // ever rise, so nothing rains or thunders in the Nether or the End.
+ let weather = self.dim == Dim::Overworld;
let player = self.player_view();
MobWorld {
world: &self.world,
@@ -407,8 +412,8 @@ impl Game<'_> {
daylight: self.dim != Dim::Nether && self.sky_darken() < 4,
game_time: self.world.game_time,
day_time: self.world.day_time,
- raining: rain > 0.2,
- thundering: thunder > 0.9,
+ raining: weather && rain > 0.2,
+ thundering: weather && thunder > 0.9,
nether: self.dim == Dim::Nether,
block_tags: &self.res.items().block_tags,
biomes: self.res.biomes(),
@@ -493,6 +498,8 @@ impl Game<'_> {
self.died.insert(m.id);
self.mob_died(&m);
}
+ // Their victims have been looted: no charged creeper is waiting any more.
+ self.combat.charged_exploders.clear();
let uuid = self.level.player_uuid;
let mut snapshot: Vec = self.mobs.iter().map(|m| seen(m, uuid)).collect();
let mut events = Vec::new();
@@ -775,7 +782,17 @@ impl Game<'_> {
.mobs
.iter()
.find(|o| o.id == id)
- .map(|o| drops::loot_entity(o, None)),
+ .map(|o| drops::loot_entity(o, None))
+ // A charged creeper's blast kills after the creeper left the list.
+ .or_else(|| {
+ self.combat
+ .charged_exploders
+ .contains(&id)
+ .then(|| LootEntity {
+ powered: true,
+ ..LootEntity::new("minecraft:creeper")
+ })
+ }),
None => None,
};
let direct = match d.kind {
@@ -811,12 +828,12 @@ impl Game<'_> {
world_seed: self.level.seed,
};
let (items, skulls) = drops::die(m, &death, &mut self.rand_sequences);
- if skulls
- && let Some(Who::Mob(id)) = m.last_damage.and_then(|(d, _)| d.attacker)
- && let Some(creeper) = self.mobs.iter_mut().find(|o| o.id == id)
- {
+ if skulls && let Some(Who::Mob(id)) = m.last_damage.and_then(|(d, _)| d.attacker) {
// Creeper.droppedSkulls: one head per charged explosion.
- creeper.extra.charged = false;
+ self.combat.charged_exploders.retain(|c| *c != id);
+ if let Some(creeper) = self.mobs.iter_mut().find(|o| o.id == id) {
+ creeper.extra.charged = false;
+ }
}
let raider = horizon_client::mobs::raider::is_raider(m.species());
for d in items {
@@ -834,9 +851,51 @@ impl Game<'_> {
}
}
}
+ /// `LivingEntity.dropFromGiftLootTable`: the gift table from its random
+ /// sequence with the mob as `this` (a chicken's egg depends on its
+ /// variant); the loot data of the game's resources decides, and without it
+ /// the items' table engine (no entity) rolls it.
+ fn drop_gift_loot(&mut self, mob: u32, table: &'static str, at: [f64; 3]) {
+ use horizon_client::mobs::drops;
+ use horizon_world::loot::EntityLootParams;
+ let loot = horizon_client::structure_blocks::loot_data(&self.options.resources);
+ let this = self
+ .mobs
+ .iter()
+ .find(|m| m.id == mob)
+ .map(|m| drops::loot_entity(m, None));
+ let stacks = match (loot, this) {
+ (Some(loot), Some(this)) if loot.has_table(table) => {
+ let params = EntityLootParams {
+ this,
+ ..EntityLootParams::default()
+ };
+ let seed = self.level.seed;
+ match loot.random_sequence(table) {
+ Some(id) => {
+ let random = self.rand_sequences.get(id, seed);
+ loot.roll_entity(table, random, ¶ms)
+ .iter()
+ .filter(|s| !s.is_empty())
+ .map(from_loot)
+ .collect()
+ }
+ None => Vec::new(),
+ }
+ }
+ _ => self
+ .res
+ .items()
+ .loot_table(table, false, None, &mut self.world.random),
+ };
+ for d in stacks {
+ self.spawn_item(d, at, [0.0, 0.2, 0.0], 10);
+ }
+ }
pub(super) fn handle_mob_events(&mut self, events: Vec) -> Result<()> {
for e in events {
match e {
+ MobEvent::SquidCycle { mob, at } => self.lan_entity_event(mob as i32, 19, at),
MobEvent::RabbitHop { mob, at } => self.lan_entity_event(mob as i32, 1, at),
MobEvent::Sound(name, at, volume, pitch)
| MobEvent::LocalSound(name, at, volume, pitch) => {
@@ -898,16 +957,24 @@ impl Game<'_> {
owner,
} => self.add_fangs(at, yaw, delay, owner),
MobEvent::Shoot(..) => {}
+ MobEvent::ExplosionSource { mob, charged } => {
+ self.combat.explosion_source = Some(mob);
+ if charged {
+ self.combat.charged_exploders.push(mob);
+ }
+ }
MobEvent::Explode(at, radius) => {
// The exploding mob causes the damage (Creeper.explodeCreeper).
- let source_mob = self
- .mobs
- .iter()
- .filter(|m| {
- (m.position.x - at[0]).powi(2) + (m.position.z - at[2]).powi(2) < 1.0
- })
- .map(|m| m.id)
- .next();
+ let source_mob = self.combat.explosion_source.or_else(|| {
+ self.mobs
+ .iter()
+ .filter(|m| {
+ (m.position.x - at[0]).powi(2) + (m.position.z - at[2]).powi(2)
+ < 1.0
+ })
+ .map(|m| m.id)
+ .next()
+ });
if let Some(id) = source_mob {
self.note_attacker("minecraft:explosion", id);
}
@@ -938,6 +1005,9 @@ impl Game<'_> {
volume,
pitch,
);
+ } else {
+ // Left for the end of the tick.
+ t.outbox.push(event);
}
}
}
@@ -1040,6 +1110,40 @@ impl Game<'_> {
self.with_level(|b, level, ticks| b.set_door_open(level, ticks, pos, open));
self.process_level_events()?;
}
+ MobEvent::BreakDoor { pos } => {
+ // BreakDoorGoal.tick: removeBlock, then level events 1021
+ // and 2001 with the state that is there now.
+ let air = self.world.air;
+ let at = BlockPos::new(pos[0], pos[1], pos[2]);
+ self.with_level(|b, level, ticks| b.set_block(level, ticks, at, air, 3));
+ self.process_level_events()?;
+ self.level_event_at(1021, pos, 0);
+ let left = self.world.block(pos[0], pos[1], pos[2]);
+ self.level_event_at(2001, pos, left.0 as i32);
+ }
+ MobEvent::DestroyProgress { mob, pos, progress } => {
+ self.destroy_block_progress(mob as i32, pos, progress);
+ // ServerLevel.destroyBlockProgress: every player nearby sees it.
+ if let Some(host) = self.lan.as_ref() {
+ host.hub.broadcast_near(
+ [f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])],
+ 64.0,
+ &horizon_protocol::packets::play::Clientbound::BlockDestruction(
+ horizon_protocol::packets::play::BlockDestruction {
+ id: mob as i32,
+ pos,
+ progress: if (0..10).contains(&progress) {
+ progress as u8
+ } else {
+ 255
+ },
+ },
+ ),
+ None,
+ );
+ }
+ }
+ MobEvent::LevelEvent { id, pos, data } => self.level_event_at(id, pos, data),
MobEvent::SetBlockName { pos, name, effect } => {
if effect {
let old = self.world.block(pos[0], pos[1], pos[2]);
@@ -1062,7 +1166,10 @@ impl Game<'_> {
}
MobEvent::BreakBlock { pos, drop } => {
let old = self.world.block(pos[0], pos[1], pos[2]);
- self.destroy_particles(pos, old);
+ // Block.spawnDestroyParticles: fire breaks leave nothing.
+ if !self.res.facts().get(old).has_class("BaseFireBlock") {
+ self.destroy_particles(pos, old);
+ }
if drop {
let drops = self.res.items().block_drops_in(
self.pack.assets.registry,
@@ -1084,6 +1191,9 @@ impl Game<'_> {
self.ensure_item_particle_sprites();
}
let options = horizon_client::particles::ParticleOptions::simple(ty);
+ if ty == horizon_client::particles::ParticleType::SonicBoom {
+ self.lan_sonic_boom(&options, at);
+ }
// Count 0: one particle exactly there, at rest.
if count == 0 {
self.particles.add(&options, at, [0.0; 3]);
@@ -1117,7 +1227,7 @@ impl Game<'_> {
self.particles.add(&options, at, velocity);
}
}
- MobEvent::Experience { at, amount } => self.spawn_orbs(at, amount),
+ MobEvent::Experience { at, amount } => self.spawn_breeding_orb(at, amount),
MobEvent::AxolotlSupportPlayer => {
let previous = self
.potions
@@ -1179,6 +1289,10 @@ impl Game<'_> {
self.mob_vibration_particle(from, to, ticks)
}
MobEvent::DigParticles { at } => self.warden_dig_particles(at),
+ MobEvent::BlockBreakEffect { pos, block } => {
+ let state = self.world.block(block[0], block[1], block[2]);
+ self.destroy_particles(pos, state);
+ }
MobEvent::Darkness { at, radius } => self.apply_darkness(at, radius),
MobEvent::CreakingHurt {
home,
@@ -1189,12 +1303,14 @@ impl Game<'_> {
self.creaking_tear_down(center, spread)
}
MobEvent::CureZombieVillager { mob } => self.cure_zombie_villager(mob),
+ MobEvent::Reinforcements { mob, target } => self.call_reinforcements(mob, target),
MobEvent::VillagerMeet { mob, other } => self.villager_meet(mob, other),
MobEvent::VillagerBirth {
parent,
partner,
child,
} => self.villager_birth(parent, partner, child),
+ MobEvent::WorkAtComposter { mob, pos } => self.villager_work_at_composter(mob, pos),
MobEvent::GolemCheck { mob, needed } => self.villager_golem_check(mob, needed),
MobEvent::Firework { at, color, flight } => {
self.villager_firework(at, color, flight)
@@ -1215,19 +1331,51 @@ impl Game<'_> {
m.ai.aggressive |= aggressive;
}
}
- MobEvent::GiftLoot { table, at } => {
- let drops =
- self.res
- .items()
- .loot_table(table, false, None, &mut self.world.random);
- for d in drops {
- self.spawn_item(d, at, [0.0, 0.2, 0.0], 10);
+ MobEvent::GiftLoot { mob, table, at } => {
+ // Turtle.ageBoundaryReached: only with mob loot on.
+ if table == "minecraft:gameplay/turtle_grow" && !self.ui.rules.bool("mob_drops")
+ {
+ continue;
}
+ self.drop_gift_loot(mob, table, at);
}
}
}
Ok(())
}
+ /// `TurtleEggBlock.randomTick` at the last hatch stage: one baby turtle
+ /// per egg, a day from grown, with the egg as its home (the sound, the
+ /// crumbs and the block's removal came from the level).
+ pub(super) fn hatch_turtles(
+ &mut self,
+ pos: [i32; 3],
+ state: horizon_world::registry::BlockStateId,
+ ) {
+ let eggs = self
+ .pack
+ .assets
+ .registry
+ .state(state)
+ .and_then(|s| s.properties.get("eggs"))
+ .and_then(|v| v.parse::().ok())
+ .unwrap_or(1);
+ for i in 0..eggs {
+ let at = [
+ f64::from(pos[0]) + 0.3 + f64::from(i) * 0.2,
+ f64::from(pos[1]),
+ f64::from(pos[2]) + 0.3,
+ ];
+ if let Some(id) = self.spawn_mob("minecraft:turtle", at, true)
+ && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
+ {
+ m.extra.age = -24000;
+ m.extra.home = Some(pos);
+ m.yaw = 0.0;
+ m.body_yaw = 0.0;
+ m.head_yaw = 0.0;
+ }
+ }
+ }
fn apply_setup(&mut self, id: u32, setup: &SpawnSetup) {
let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) else {
return;
@@ -1261,6 +1409,13 @@ impl Game<'_> {
m.extra.egg_time = life;
}
}
+ /// `Animal.finalizeSpawnChildFromBreeding`'s experience orb: only when the
+ /// `mob_drops` game rule is on.
+ fn spawn_breeding_orb(&mut self, at: [f64; 3], amount: u32) {
+ if self.ui.rules.bool("mob_drops") {
+ self.spawn_orbs(at, amount);
+ }
+ }
/// Animal.spawnChildFromBreeding
fn breed(
&mut self,
@@ -1283,6 +1438,8 @@ impl Game<'_> {
.unwrap_or_else(|| parent.clone());
let mut child = parent.clone();
child.baby = true;
+ // TurtleBreedGoal.breed triggers it without a child.
+ let turtle = p.species() == Species::Turtle;
if matches!(
(
p.species(),
@@ -1295,7 +1452,7 @@ impl Game<'_> {
) {
child.kind = "minecraft:mule".into();
}
- self.trigger_bred(&parent, &partner_view, Some(&child));
+ self.trigger_bred(&parent, &partner_view, (!turtle).then_some(&child));
}
if let Some(q) = self.mobs.iter_mut().find(|m| m.id == partner) {
q.extra.age = 6000;
@@ -1307,6 +1464,19 @@ impl Game<'_> {
self.lay_sniffer_egg(&p);
return;
}
+ // TurtleBreedGoal.breed: the goal gave the mother her egg; only the
+ // experience is left, and only with mob loot on.
+ if p.species() == Species::Turtle {
+ // One `new ExperienceOrb` of 1 to 7 from the mother's random (not
+ // split up as `ExperienceOrb.award` does).
+ 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.add_orb([p.position.x, p.position.y, p.position.z], xp);
+ }
+ return;
+ }
let coin = self.world.random.next_int_bound(2).unwrap_or(0) == 0;
let coin2 = self.world.random.next_int_bound(2).unwrap_or(0) == 0;
// A horse and a donkey have a mule.
@@ -1354,7 +1524,7 @@ impl Game<'_> {
}
self.world.random = r;
let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
- self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+ self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
return;
}
if p.species() == Species::Cat {
@@ -1375,7 +1545,7 @@ impl Game<'_> {
};
}
let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
- self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+ self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
return;
}
if p.species() == Species::Wolf {
@@ -1397,7 +1567,7 @@ impl Game<'_> {
};
}
let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
- self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+ self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
return;
}
// Nautilus.getBreedOffspring: a tame parent's baby is tame too.
@@ -1413,7 +1583,7 @@ impl Game<'_> {
}
}
let xp = 1 + self.world.random.next_int_bound(7).unwrap_or(0) as u32;
- self.spawn_orbs([p.position.x, p.position.y, p.position.z], xp);
+ self.spawn_breeding_orb([p.position.x, p.position.y, p.position.z], xp);
}
/// `MobEffectUtil.addEffectToPlayersAround` for an elder guardian:
/// mining fatigue III for five minutes unless a stronger or longer one
@@ -1509,15 +1679,19 @@ impl Game<'_> {
if let Some(a) = attacker.or(owner) {
self.note_attacker(damage_type, a);
}
+ // DamageSource.scalesWithDifficulty: a mob (or its projectile's
+ // owner) caused the hit, not a player.
+ let living_cause = attacker.or(owner).is_some();
let mut outcome = horizon_client::health::BlockOutcome::default();
if let Some(player) = self.player.as_mut()
&& let Some(id) = self.motion.health.damage.id(damage_type)
- && let Ok(o) = player.hurt_blocking(
+ && let Ok(o) = player.hurt_caused_by(
&self.motion.health,
self.world.health_rules,
id,
amount,
blocking,
+ living_cause,
)
&& {
outcome = o;
@@ -1535,8 +1709,10 @@ impl Game<'_> {
r.knockback = Some([p.velocity.x, p.velocity.y, p.velocity.z]);
}
}
- self.hurt_armor(amount);
- self.thorns(from);
+ // The thorns hurt the entity that caused the hit, if there is one.
+ if let Some(a) = attacker.or(owner) {
+ self.thorns(a);
+ }
}
if raised {
self.after_block(outcome, amount, attacker, projectile);
@@ -1987,6 +2163,23 @@ impl Game<'_> {
self.creatures.projectiles.push(arrow);
}
}
+ /// `TargetBlock.onProjectileHit`: a target block takes its power from
+ /// where the projectile landed and resets after 20 ticks for an arrow, 8
+ /// for any other projectile. A player's shot counts as a target hit.
+ fn target_block_hit(&mut self, p: &Projectile, pos: [i32; 3], at: Vec3, face: [i32; 3]) {
+ let block = BlockPos::new(pos[0], pos[1], pos[2]);
+ let arrow = p.arrow.is_some();
+ let location = [at.x, at.y, at.z];
+ let hit = self.with_level(|b, level, ticks| {
+ b.target_projectile_hit(level, ticks, block, location, face, arrow)
+ });
+ if hit.is_some() {
+ let _ = self.process_level_events();
+ if p.owner == Some(Who::Player) {
+ self.stats.custom("target_hit", 1);
+ }
+ }
+ }
pub(super) fn projectile_hit(&mut self, p: &Projectile, hit: Hit) -> Result<()> {
self.combat.projectile_owner = match p.owner {
Some(Who::Mob(id)) => Some(id),
@@ -1996,6 +2189,13 @@ impl Game<'_> {
Hit::Entity { at, .. } | Hit::Block { at, .. } => at,
Hit::None => return Ok(()),
};
+ // Projectile.onHitBlock: BlockState.onProjectileHit, for every
+ // projectile (a wind charge out of the world's top has no face).
+ if let Hit::Block { pos, face, .. } = hit
+ && face != [0; 3]
+ {
+ self.target_block_hit(p, pos, at, face);
+ }
if let Hit::Entity {
who: Who::Mob(id),
at,
@@ -2358,12 +2558,14 @@ impl Game<'_> {
// ShulkerBullet.onHitEntity: 4 damage, then levitation for 10 s.
(ProjectileKind::ShulkerBullet { .. }, Hit::Entity { who, .. }) => match who {
Who::Player => {
- if !self.creative {
- self.mob_hits_player(
+ // Only a hit that hurt (`wasHurt`) brings the levitation.
+ if !self.creative
+ && self.mob_hits_player(
4.0,
[p.previous.x, p.previous.y, p.previous.z],
"minecraft:mob_projectile",
- );
+ )
+ {
self.give_player_effect("minecraft:levitation", 200, 0);
}
}
@@ -2372,6 +2574,8 @@ impl Game<'_> {
&& m.damage(4.0, source)
{
m.extra.levitation = 200;
+ // Shulker.hurtServer: a shulker hit by a bullet.
+ horizon_client::mobs::shulker::hit_by_bullet(m);
}
}
},
@@ -2453,21 +2657,22 @@ impl Game<'_> {
.as_ref()
.map(|h| h.item.to_string())
.unwrap_or_default();
+ // Bucketable.bucketMobPickup: a water bucket scoops up a fish, a
+ // tadpole or an axolotl, with the data its bucket carries.
if item == "minecraft:water_bucket"
- && self.mobs[index].species() == Species::Axolotl
&& self.mobs[index].alive()
+ && let Some((bucket, sound)) = bucketable(self.mobs[index].species())
{
- let mut filled = ItemStack::new("minecraft:axolotl_bucket", 1);
+ let mut filled = ItemStack::new(bucket, 1);
filled.extra = Some(Box::new(horizon_client::entity_nbt::bucket_components(
&self.mobs[index],
)));
- self.audio.play(
- "minecraft:item.bucket.fill_axolotl",
- Some(self.mobs[index].center()),
- 1.0,
- 1.0,
- );
+ self.audio
+ .play(sound, Some(self.mobs[index].center()), 1.0, 1.0);
self.trigger_item("minecraft:filled_bucket", &filled);
+ // Leashable.dropLeash, then discard.
+ let id = self.mobs[index].id;
+ self.break_leash(id, true, false);
self.mobs[index].removed = true;
if self.creative {
if let Some(rest) = self.give(filled) {
@@ -2521,6 +2726,19 @@ impl Game<'_> {
}
return Ok(true);
}
+ // Creeper.mobInteract: any item in #creeper_igniters, damaged when it
+ // is damageable and used up otherwise.
+ let creeper_igniter = self
+ .res
+ .items()
+ .item_tags
+ .get("minecraft:creeper_igniters")
+ .is_some_and(|t| t.contains(&*item));
+ let damageable = self
+ .res
+ .items()
+ .get(&item)
+ .is_some_and(|i| i.max_damage > 0);
let m = &mut self.mobs[index];
if !m.alive() {
return Ok(false);
@@ -2536,6 +2754,7 @@ impl Game<'_> {
let mut handled = true;
let mut drops: Vec<(String, u32)> = Vec::new();
let is_food = m.kind.food.contains(&item);
+ let baby_turtle = species == Species::Turtle && m.is_baby();
match species {
Species::Cow | Species::Mooshroom if item == "minecraft:bucket" && !m.is_baby() => {
give = Some("minecraft:milk_bucket");
@@ -2761,10 +2980,21 @@ impl Game<'_> {
consume = true;
sound = Some("entity.iron_golem.repair");
}
- Species::Creeper if item == "minecraft:flint_and_steel" => {
+ Species::Creeper if creeper_igniter => {
m.extra.flag = true;
- sound = Some("item.flintandsteel.use");
- self.damage_held_tool();
+ // FIRECHARGE_USE for a fire charge, else FLINTANDSTEEL_USE,
+ // at the creeper's feet with a pitch from its own random.
+ let event = if item == "minecraft:fire_charge" {
+ "item.firecharge.use"
+ } else {
+ "item.flintandsteel.use"
+ };
+ eat = Some((event, 1.0, m.random.next_float() * 0.4 + 0.8));
+ if damageable {
+ self.damage_held_tool();
+ } else {
+ consume = true;
+ }
}
// Parrot.mobInteract: parrot food may tame a wild one (one time in
// ten); a parrot never takes it as Animal food (isFood is false).
@@ -2814,6 +3044,14 @@ impl Game<'_> {
if !handled {
return Ok(false);
}
+ // Turtle.ageBoundaryReached: food that finishes a baby's growth.
+ if baby_turtle && !self.mobs[index].is_baby() {
+ self.handle_mob_events(vec![MobEvent::GiftLoot {
+ mob: self.mobs[index].id,
+ table: "minecraft:gameplay/turtle_grow",
+ at: feet,
+ }])?;
+ }
self.swing_arm();
if let Some(s) = sound {
let pitch =
@@ -3247,6 +3485,26 @@ impl Game<'_> {
}
}
}
+/// `Bucketable.getBucketItemStack` and `getPickupSound` of a mob that a water
+/// bucket picks up.
+fn bucketable(species: Species) -> Option<(&'static str, &'static str)> {
+ let fish = "minecraft:item.bucket.fill_fish";
+ Some(match species {
+ Species::Cod => ("minecraft:cod_bucket", fish),
+ Species::Salmon => ("minecraft:salmon_bucket", fish),
+ Species::Pufferfish => ("minecraft:pufferfish_bucket", fish),
+ Species::TropicalFish => ("minecraft:tropical_fish_bucket", fish),
+ Species::Tadpole => (
+ "minecraft:tadpole_bucket",
+ "minecraft:item.bucket.fill_tadpole",
+ ),
+ Species::Axolotl => (
+ "minecraft:axolotl_bucket",
+ "minecraft:item.bucket.fill_axolotl",
+ ),
+ _ => return None,
+ })
+}
/// Mob.getBaseExperienceReward
/// The damage type id of a Horizon damage kind.
pub(super) fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool) -> &'static str {
@@ -3291,6 +3549,7 @@ fn to_loot(stack: &ItemStack) -> horizon_world::loot::LootStack {
map: false,
exploration: None,
ominous_amplifier: None,
+ stew_effects: Vec::new(),
}
}
/// A generated loot stack as a Horizon item stack.
diff --git a/crates/horizon-client/src/game/crossbow.rs b/crates/horizon-client/src/game/crossbow.rs
index 70ccba8d3..bc49c4b90 100644
--- a/crates/horizon-client/src/game/crossbow.rs
+++ b/crates/horizon-client/src/game/crossbow.rs
@@ -6,6 +6,7 @@
//! finds the ammo for bows and crossbows.
use super::{Game, shield::OFFHAND_SLOT, view_vector};
use horizon_client::{
+ enchant::EffectContext,
items::ItemStack,
mobs::Who,
projectiles::{Projectile, ProjectileKind},
@@ -152,6 +153,20 @@ impl Game<'_> {
};
let charged = std::mem::take(&mut bow.data_mut().charged);
bow.tidy();
+ let weapon = bow.clone();
+ // AbstractArrow's constructor: `getPiercingCount` of the weapon.
+ let pierce = self
+ .res
+ .stations()
+ .enchantments
+ .modify_value(
+ Some(&weapon),
+ "minecraft:projectile_piercing",
+ &EffectContext::default(),
+ &mut self.world.random,
+ 0.0,
+ )
+ .clamp(0.0, 127.0) as u8;
let count = charged.len();
// getShootingPower: a rocket among them slows every shot.
let power = if charged.iter().any(|s| &*s.item == FIREWORK_ROCKET) {
@@ -204,6 +219,7 @@ impl Game<'_> {
if let Some(a) = arrow.arrow.as_mut() {
a.set_item(ammo);
a.set_owner(Some(Who::Player));
+ a.pierce = pierce;
}
arrow.shoot(&mut self.world.random, dir.to_array(), power, 1.0);
self.creatures.projectiles.push(arrow);
diff --git a/crates/horizon-client/src/game/cushions.rs b/crates/horizon-client/src/game/cushions.rs
new file mode 100644
index 000000000..0847321d6
--- /dev/null
+++ b/crates/horizon-client/src/game/cushions.rs
@@ -0,0 +1,494 @@
+//! Cushions: `CushionItem.useOn` placement on the top face of a block,
+//! `Cushion.canBePlacedAt`/`survives`, `Cushion.interact` (sit),
+//! `BlockAttachedEntity.hurtServer` (break, dropping the matching colour),
+//! `BlockAttachedEntity.tick` and `CushionRenderer`.
+//!
+//! A cushion is a `BlockAttachedEntity`, not a block: it has no block state,
+//! only an entity whose `Pos` is the click point's height. Placement uses
+//! outline bounds, collision shapes and suffocation predicates.
+use super::{Game, Hit, view_vector};
+use horizon_client::entities::{Cushion, dye_index};
+use horizon_client::items::ItemStack;
+use horizon_client::mobs::anim::Poses;
+use horizon_core::geometry::{Aabb, Vec3};
+use winit::keyboard::KeyCode;
+
+/// `Direction.fromYRot(yaw).toYRot()`: the nearest 90 degree step.
+pub(crate) fn snap_yaw(yaw: f32) -> f32 {
+ (((f64::from(yaw) / 90.0 + 0.5).floor() as i64) & 3) as f32 * 90.0
+}
+
+fn aabb(bounds: ([f64; 3], [f64; 3])) -> Aabb {
+ Aabb::new(
+ Vec3::new(bounds.0[0], bounds.0[1], bounds.0[2]),
+ Vec3::new(bounds.1[0], bounds.1[1], bounds.1[2]),
+ )
+}
+
+fn overlaps(a: Aabb, b: Aabb) -> bool {
+ a.intersects(b)
+}
+use horizon_client::cushion::blocks_in;
+
+struct PlacementWorld<'a, 'r>(&'a Game<'r>);
+impl horizon_client::cushion::World for PlacementWorld<'_, '_> {
+ fn outline_bounds(&self, p: [i32; 3]) -> Option {
+ let boxes = self.0.outline_boxes(p);
+ let mut shape = *boxes.first()?;
+ for b in &boxes[1..] {
+ for k in 0..3 {
+ shape[k] = shape[k].min(b[k]);
+ shape[k + 3] = shape[k + 3].max(b[k + 3]);
+ }
+ }
+ Some(Aabb::new(
+ Vec3::new(shape[0], shape[1], shape[2]),
+ Vec3::new(shape[3], shape[4], shape[5]),
+ ))
+ }
+
+ fn collision_shapes(&self, bounds: Aabb) -> Vec {
+ let binding = self.0.res.collision();
+ let mut world = horizon_client::collisions::SceneCollisions {
+ world: &self.0.world,
+ binding,
+ subject: None,
+ };
+ // Include neighbour blocks whose collision shape can reach outside their cell.
+ blocks_in(bounds.inflate(Vec3::new(1.0, 1.0, 1.0)))
+ .filter_map(|p| {
+ let state = self.0.world.block(p[0], p[1], p[2]);
+ binding
+ .collision_shape(&mut world, state, p)
+ .ok()
+ .map(|s| s.moved(Vec3::new(f64::from(p[0]), f64::from(p[1]), f64::from(p[2]))))
+ })
+ .collect()
+ }
+ fn suffocating(&self, p: [i32; 3]) -> bool {
+ let state = self.0.world.block(p[0], p[1], p[2]);
+ let facts = self.0.res.facts().get(state);
+ let name = facts.name.as_ref();
+ // Blocks' explicit predicates, then the default causes_suffocation/full-shape rule.
+ match name {
+ "minecraft:dirt_path"
+ | "minecraft:farmland"
+ | "minecraft:mud"
+ | "minecraft:soul_sand" => true,
+ "minecraft:piston" | "minecraft:sticky_piston" => self
+ .0
+ .pack
+ .assets
+ .registry
+ .state(state)
+ .is_some_and(|s| s.properties.get("extended").is_some_and(|p| p == "false")),
+ "minecraft:mangrove_roots" | "minecraft:moving_piston" => false,
+ _ if name.ends_with("_leaves")
+ || name.ends_with("glass")
+ || name.ends_with("copper_grate") =>
+ {
+ false
+ }
+ // ShulkerBoxBlock: suffocating while closed; a box seen open
+ // here is rare enough to count as closed.
+ _ if name.ends_with("shulker_box") => true,
+ _ => {
+ facts.full_collision
+ && self
+ .0
+ .res
+ .items()
+ .block_in_tag("minecraft:causes_suffocation", name)
+ }
+ }
+ }
+}
+
+impl Game<'_> {
+ /// The cushion under the crosshair, its distance and the hit point.
+ pub(super) fn cushion_hit(&self) -> Option<(usize, f64, [f64; 3])> {
+ let eye = self.eye_position()?;
+ let dir = view_vector(self.yaw, self.pitch);
+ let reach: f64 = if self.creative { 5.0 } else { 3.0 };
+ let mut best: Option<(usize, f64, [f64; 3])> = None;
+ for (i, c) in self.cushions.iter().enumerate() {
+ let Some(d) = super::ray_box(eye, dir, reach, aabb(c.bounds())) else {
+ continue;
+ };
+ if best.is_none_or(|b| d < b.1) {
+ best = Some((i, d, std::array::from_fn(|k| eye[k] + dir[k] * d)));
+ }
+ }
+ best
+ }
+
+ pub(super) fn cushion_survives(&self, c: &Cushion) -> bool {
+ horizon_client::cushion::survives(&PlacementWorld(self), aabb(c.bounds()))
+ }
+
+ /// `Cushion.destroyIfInFire`: a fire-tagged block inside the deflated box.
+ fn cushion_in_fire(&self, c: &Cushion) -> bool {
+ let bounds = aabb(c.bounds()).next_deflated();
+ blocks_in(bounds).any(|p| {
+ let facts = self.res.facts().get(self.world.block(p[0], p[1], p[2]));
+ self.res.items().block_in_tag("minecraft:fire", &facts.name)
+ })
+ }
+
+ /// `CushionItem.useOn`: on the top face only, spawning at the click's
+ /// height above the clicked block (or the replaceable block itself).
+ pub(super) fn place_cushion(&mut self, hit: &Hit, stack: &ItemStack) -> bool {
+ let Some(info) = self.res.items().get(&stack.item).cloned() else {
+ return false;
+ };
+ let Some(default_color) = info.cushion_color.as_deref() else {
+ return false;
+ };
+ let color_override = stack
+ .data()
+ .and_then(|d| d.other("minecraft:cushion/color"))
+ .and_then(|tag| match tag {
+ horizon_world::nbt::Tag::String(s) => Some(s.to_string_lossy()),
+ _ => None,
+ });
+ let color = dye_index(color_override.as_deref().unwrap_or(default_color));
+ // CushionItem.recalculateContextForSpecialCollisionShapes: open containers
+ // (cauldrons, hoppers and composters) use the collision ray's actual height.
+ let mut adjusted = Hit {
+ pos: hit.pos,
+ face: hit.face,
+ point: hit.point,
+ };
+ let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
+ if self.res.items().block_in_tag(
+ "minecraft:cushion_uses_collision_shape",
+ &self.res.facts().get(state).name,
+ ) && let Some(eye) = self.eye_position()
+ {
+ let start = Vec3::new(eye[0], eye[1], eye[2]);
+ let point = Vec3::new(hit.point[0], hit.point[1], hit.point[2]);
+ let end = point.add_vector(point.subtract(start).normalize().scale(0.001));
+ let binding = self.res.collision();
+ let mut world = horizon_client::collisions::SceneCollisions {
+ world: &self.world,
+ binding,
+ subject: None,
+ };
+ if let Ok(shape) = binding.collision_shape(&mut world, state, hit.pos)
+ && let Some(result) = shape.clip(
+ start,
+ end,
+ horizon_core::position::BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
+ )
+ {
+ adjusted.face = result.direction.normal();
+ adjusted.point = [result.location.x, result.location.y, result.location.z];
+ }
+ }
+ let hit = &adjusted;
+ if hit.face != [0, 1, 0] {
+ return false;
+ }
+ // BlockPlaceContext: a replaceable clicked block is replaced.
+ let clicked = self
+ .res
+ .facts()
+ .get(self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]));
+ let pos = if clicked.replaceable {
+ hit.pos
+ } else {
+ std::array::from_fn(|i| hit.pos[i] + hit.face[i])
+ };
+ // `Vec3.atCenterOfWithY(clickedPos, clickLocation.y)`.
+ let y = hit.point[1];
+ let position = Vec3::new(f64::from(pos[0]) + 0.5, y, f64::from(pos[2]) + 0.5);
+ let bounds = aabb((
+ [position.x - 0.5, position.y, position.z - 0.5],
+ [position.x + 0.5, position.y + 0.25, position.z + 0.5],
+ ));
+ if !horizon_client::cushion::can_place(&PlacementWorld(self), bounds) {
+ return false;
+ }
+ // `getEntitiesOfClass(Cushion.class, spawnAABB).isEmpty()`.
+ if self
+ .cushions
+ .iter()
+ .any(|c| overlaps(aabb(c.bounds()), bounds))
+ {
+ return false;
+ }
+ self.next_entity += 1;
+ let id = self.next_entity;
+ // `BlockAttachedEntity.setPos`: `BlockPos.containing(position)`.
+ let attached = [
+ position.x.floor() as i32,
+ position.y.floor() as i32,
+ position.z.floor() as i32,
+ ];
+ self.cushions.push(Cushion {
+ id,
+ position,
+ pos: attached,
+ yaw: snap_yaw(self.yaw),
+ color,
+ check_interval: 0,
+ });
+ self.world
+ .modified
+ .insert((attached[0] >> 4, attached[2] >> 4));
+ // `destroyIfInFire`: placed into fire, it breaks at once.
+ let placed = self.cushions.len() - 1;
+ if self.cushion_in_fire(&self.cushions[placed]) {
+ self.break_cushion(placed, false);
+ }
+ self.audio.play(
+ "minecraft:entity.cushion.place",
+ Some([position.x, position.y, position.z]),
+ 0.75,
+ 0.8,
+ );
+ let ctx = self.who_context(Some(horizon_client::mobs::Who::Player), None);
+ self.post_game_event(
+ "minecraft:entity_place",
+ [position.x, position.y, position.z],
+ ctx,
+ );
+ if !self.creative {
+ self.consume_held();
+ }
+ true
+ }
+
+ /// `Cushion.interact`: sit down unless sneaking or already occupied.
+ pub(super) fn interact_cushion(&mut self) -> bool {
+ let Some((i, d, _)) = self.cushion_hit() else {
+ return false;
+ };
+ if !self.before_block(d) {
+ return false;
+ }
+ // isSecondaryUseActive.
+ if self.keys.contains(&KeyCode::ShiftLeft) {
+ return false;
+ }
+ let id = self.cushions[i].id;
+ let occupied = self.riding == Some(id)
+ || self
+ .lan
+ .as_ref()
+ .is_some_and(|h| h.hub.guests.iter().any(|g| g.vehicle == Some(id)));
+ // `Cushion.interact`: an occupied cushion (`isVehicle`) passes.
+ if occupied {
+ return false;
+ }
+ // `Player.startRiding` gives up the vehicle it already has; the
+ // client never sends that click, so pass instead.
+ if self.riding.is_some() {
+ return false;
+ }
+ self.riding = Some(id);
+ let p = self.cushions[i].position;
+ self.audio.play(
+ "minecraft:entity.cushion.sit",
+ Some([p.x, p.y, p.z]),
+ 1.0,
+ 1.0,
+ );
+ self.swing_arm();
+ true
+ }
+
+ /// `Cushion.hurtServer` from a player: killed, then the item dropped.
+ pub(super) fn attack_cushion(&mut self) -> bool {
+ let Some((i, d, _)) = self.cushion_hit() else {
+ return false;
+ };
+ if !self.before_block(d) || self.mob_hit().is_some_and(|m| m.1 < d) {
+ return false;
+ }
+ // `skipAttackInteraction` when `mayInteract` is false.
+ if !self.may_build() {
+ return true;
+ }
+ self.break_cushion(i, true);
+ true
+ }
+
+ /// `Cushion.dropItem`: the break sound and particles, then the coloured
+ /// item unless drops are off or the breaker has infinite materials.
+ pub(super) fn break_cushion(&mut self, index: usize, by_player: bool) {
+ let c = self.cushions.remove(index);
+ let p = c.position;
+ self.world.modified.insert((c.pos[0] >> 4, c.pos[2] >> 4));
+ if self.riding == Some(c.id) {
+ self.riding = None;
+ }
+ self.audio.play(
+ "minecraft:entity.cushion.break",
+ Some([p.x, p.y, p.z]),
+ 1.0,
+ 1.0,
+ );
+ self.cushion_break_particles(&c);
+ if !self.ui.rules.bool("entity_drops") || (by_player && self.creative) {
+ return;
+ }
+ let stack = ItemStack {
+ item: std::sync::Arc::from(c.item()),
+ count: 1,
+ damage: 0,
+ extra: None,
+ };
+ self.spawn_item(stack, [p.x, p.y, p.z], [0.0; 3], 10);
+ }
+
+ /// `Cushion.showBreakingParticles`: ten of the matching wool block.
+ fn cushion_break_particles(&mut self, c: &Cushion) {
+ let name = format!("minecraft:{}_wool", c.color_name());
+ let Some(state) = self.pack.assets.registry.default_state(&name) else {
+ return;
+ };
+ let at = [
+ c.position.x.floor() as i32,
+ c.position.y.floor() as i32,
+ c.position.z.floor() as i32,
+ ];
+ let Some((sprite, tint)) = self.particle_sprite(state, at) else {
+ return;
+ };
+ let options = horizon_client::particles::ParticleOptions::block(
+ horizon_client::particles::ParticleType::Block,
+ sprite,
+ tint,
+ );
+ let p = c.position;
+ self.particles.send_particles(
+ &options,
+ [p.x, p.y + 0.666_666_7, p.z],
+ [0.25, 0.0625, 0.25],
+ 0.05,
+ 10,
+ );
+ }
+
+ /// `BlockAttachedEntity.tick`: survive and burn checks after the post-increment reaches 100.
+ pub(super) fn tick_cushions(&mut self) {
+ let ticking = self.entity_ticking_area();
+ let mut i = 0;
+ while i < self.cushions.len() {
+ let p = self.cushions[i].position;
+ if !ticking(p.x.floor() as i32, p.z.floor() as i32) {
+ i += 1;
+ continue;
+ }
+ let previous = self.cushions[i].check_interval;
+ self.cushions[i].check_interval += 1;
+ if previous < 100 {
+ i += 1;
+ continue;
+ }
+ self.cushions[i].check_interval = 0;
+ let c = self.cushions[i].clone();
+ if self.cushion_in_fire(&c) || !self.cushion_survives(&c) {
+ self.break_cushion(i, false);
+ continue;
+ }
+ i += 1;
+ }
+ }
+
+ /// `Player.rideTick` on a cushion: hold the seat, and get up on sneak.
+ pub(super) fn tick_cushion_riding(&mut self, keys: super::Keys) -> bool {
+ let Some(c) = self
+ .cushions
+ .iter()
+ .find(|c| Some(c.id) == self.riding)
+ .cloned()
+ else {
+ return false;
+ };
+ if keys.shift {
+ let at = c.dismount();
+ self.riding = None;
+ if let Some(p) = self.player.as_mut() {
+ self.previous_position = p.position;
+ p.position = at;
+ p.velocity = Vec3::ZERO;
+ p.fall_distance = 0.0;
+ }
+ // `Cushion.removePassenger`: the get-up sound for a rider that
+ // left rather than one whose cushion was killed.
+ self.audio.play(
+ "minecraft:entity.cushion.get_up",
+ Some([c.position.x, c.position.y, c.position.z]),
+ 1.0,
+ 1.0,
+ );
+ return true;
+ }
+ let seat = c.seat();
+ if let Some(p) = self.player.as_mut() {
+ self.previous_position = p.position;
+ p.position = seat;
+ p.velocity = Vec3::ZERO;
+ p.fall_distance = 0.0;
+ }
+ true
+ }
+
+ /// `CushionRenderer`: the coloured model, rotated to the nearest
+ /// direction, with its bottom on the cushion's position.
+ pub(super) fn cushion_geometry(
+ &self,
+ camera: glam::DVec3,
+ out: &mut Vec,
+ ) {
+ let Some(model) = self.cushion_model.as_ref() else {
+ return;
+ };
+ let sprites = &self.gui.atlas.sprites;
+ for c in &self.cushions {
+ let entity_start = out.len();
+ let a = aabb(c.bounds());
+ let (lo, hi) = (a.min_position(), a.max_position());
+ let (lo, hi) = (
+ glam::DVec3::new(lo.x, lo.y, lo.z),
+ glam::DVec3::new(hi.x, hi.y, hi.z),
+ );
+ let range =
+ super::entity_culling::default_range(hi - lo, self.settings.entity_distance);
+ if !self.entity_in_view(camera, (lo + hi) / 2.0, range, lo, hi) {
+ continue;
+ }
+ let Some(uv) = sprites
+ .get(&format!("entity/cushion/{}_cushion", c.color_name()))
+ .map(|r| [r.u0, r.v0, r.u1, r.v1])
+ else {
+ continue;
+ };
+ let p = glam::DVec3::new(c.position.x, c.position.y, c.position.z) - camera;
+ let base = glam::Mat4::from_translation(p.as_vec3())
+ * glam::Mat4::from_rotation_y((180.0 - snap_yaw(c.yaw)).to_radians())
+ * glam::Mat4::from_rotation_x(std::f32::consts::PI)
+ * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.25, 0.0));
+ // `EntityRenderer.getPackedLightCoords` probes at the eye height.
+ let l = self.world.light(
+ c.position.x.floor() as i32,
+ (c.position.y + 0.2125).floor() as i32,
+ c.position.z.floor() as i32,
+ );
+ let packed = (u32::from(l >> 4) * 16) | ((u32::from(l & 15) * 16) << 8);
+ horizon_client::mobs::render::draw(
+ model,
+ base,
+ &Poses::new(model),
+ uv,
+ 0xFFFF_FFFF,
+ packed,
+ 0,
+ out,
+ );
+ self.cull_entity_vertices(out, entity_start);
+ }
+ }
+}
diff --git a/crates/horizon-client/src/game/dispense_fixture.rs b/crates/horizon-client/src/game/dispense_fixture.rs
index 267f323c3..33da8b5ce 100644
--- a/crates/horizon-client/src/game/dispense_fixture.rs
+++ b/crates/horizon-client/src/game/dispense_fixture.rs
@@ -725,6 +725,11 @@ impl Game<'_> {
match self.world.block_entities.get_mut(&p) {
Some(BlockEntity::Jukebox(j)) => j.record = stack,
Some(BlockEntity::Lectern(l)) => l.book = stack,
+ Some(BlockEntity::Campfire(c)) => {
+ if let Some(cell) = c.items.get_mut(slot) {
+ *cell = stack;
+ }
+ }
Some(e) => {
if let Some(cell) = e.slots_mut().get_mut(slot) {
*cell = stack;
@@ -1126,14 +1131,18 @@ impl Game<'_> {
let (p, v) = (b.position, b.velocity);
out.push(line(&kind, [p.x, p.y, p.z], [v.x, v.y, v.z], ""));
}
+ // A merged orb prints once per count, as the oracle does: whether orbs
+ // merge depends on entity ids, which differ from vanilla's.
for o in &self.orbs {
let (p, v) = (o.position, o.velocity);
- out.push(line(
- "minecraft:experience_orb",
- [p.x, p.y, p.z],
- [v.x, v.y, v.z],
- "",
- ));
+ for _ in 0..o.count.max(1) {
+ out.push(line(
+ "minecraft:experience_orb",
+ [p.x, p.y, p.z],
+ [v.x, v.y, v.z],
+ "",
+ ));
+ }
}
for c in &self.carts {
let (p, v) = (c.position, c.velocity);
diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs
index 8c316deeb..fff03ef1c 100644
--- a/crates/horizon-client/src/game/dragon.rs
+++ b/crates/horizon-client/src/game/dragon.rs
@@ -12,11 +12,13 @@ use horizon_client::{
hud_layout, hud_overlays,
mesher::Vertex,
particles::{ParticleOptions, ParticleType},
+ text::Text,
};
use horizon_core::{
geometry::{Aabb, Vec3},
random::{LegacyRandom, RandomSource},
};
+use horizon_protocol::entity_data::Value;
use horizon_world::nbt::Tag;
/// Mob ids from here on are dragon parts (`SPECIAL + part`) and crystals
@@ -1558,6 +1560,7 @@ impl Game<'_> {
y -= 1.0;
}
self.breath_clouds.push(Breath {
+ id: 0,
at: [x, y.floor() + 1.0, z],
radius: 5.0,
age: 0,
@@ -1684,32 +1687,17 @@ impl Game<'_> {
.play("minecraft:entity.ender_dragon.growl", Some(at), 2.5, pitch);
}
}
- // checkCrystals: heal 1 every 10 ticks from the nearest crystal within 32.
+ // checkCrystals: heal 1 every 10 ticks from the nearest crystal, found
+ // among those touching the dragon's box grown by 32.
let d = self.dragon.as_mut().expect("dragon");
if d.nearest_crystal.is_some() && d.ticks % 10 == 0 && d.health < MAX_HEALTH {
- d.health += 1.0;
+ // LivingEntity.setHealth clamps to the maximum.
+ d.health = (d.health + 1.0).min(MAX_HEALTH);
}
if d.random.next_int_bound(10).unwrap_or(1) == 0 {
let p = d.position;
- d.nearest_crystal = self
- .crystals
- .iter()
- .enumerate()
- .filter(|(_, c)| {
- (c.position.x - p.x).abs() <= 32.0
- && (c.position.y - p.y).abs() <= 32.0
- && (c.position.z - p.z).abs() <= 32.0
- })
- .min_by(|a, b| {
- let da = (a.1.position.x - p.x).powi(2)
- + (a.1.position.y - p.y).powi(2)
- + (a.1.position.z - p.z).powi(2);
- let db = (b.1.position.x - p.x).powi(2)
- + (b.1.position.y - p.y).powi(2)
- + (b.1.position.z - p.z).powi(2);
- da.total_cmp(&db)
- })
- .map(|(i, _)| i);
+ let nearest = self.nearest_crystal_to(p);
+ self.dragon.as_mut().expect("dragon").nearest_crystal = nearest;
}
let d = self.dragon.as_mut().expect("dragon");
d.yaw = wrap(d.yaw);
@@ -1870,7 +1858,7 @@ impl Game<'_> {
pl.velocity.z += zd / dd * 4.0;
}
if !sitting {
- g.hurt_player_by("minecraft:mob_attack", 5.0);
+ g.dragon_hurts_player("minecraft:mob_attack", 5.0);
}
});
}
@@ -1879,7 +1867,7 @@ impl Game<'_> {
for h in heads {
if h.inflate(Vec3::new(1.0, 1.0, 1.0)).intersects(p.bounds) {
self.as_fight_player(p.who, |g| {
- g.hurt_player_by("minecraft:mob_attack", 10.0);
+ g.dragon_hurts_player("minecraft:mob_attack", 10.0);
});
}
}
@@ -2037,6 +2025,7 @@ impl Game<'_> {
// assignDirectionalMovement: the direction times the acceleration power 0.1.
let velocity = Vec3::new(v.x * 0.1, v.y * 0.1, v.z * 0.1);
self.dragon_fireballs.push(DragonFireball {
+ id: 0,
position: at,
previous: at,
velocity,
@@ -2083,6 +2072,7 @@ impl Game<'_> {
});
if hit_block || hit_player || b.age > 600 {
self.breath_clouds.push(Breath {
+ id: 0,
at: [next.x, next.y, next.z],
radius: 3.0,
age: 0,
@@ -2161,10 +2151,20 @@ impl Game<'_> {
self.breath_clouds.append(&mut clouds);
for (who, amount) in harmed {
self.as_fight_player(who, |g| {
- g.hurt_player_by("minecraft:indirect_magic", amount);
+ g.dragon_hurts_player("minecraft:indirect_magic", amount);
});
}
}
+ /// Damage from the dragon, which is its causing entity
+ /// (`DamageSources.mobAttack(dragon)`, `indirectMagic(cloud, dragon)`): the
+ /// death message names it.
+ fn dragon_hurts_player(&mut self, damage_type: &str, amount: f32) {
+ if let Some(id) = self.dragon.as_ref().map(|d| d.id) {
+ let name = Text::translate("entity.minecraft.ender_dragon", &[]);
+ self.note_named_attacker(damage_type, id, name);
+ }
+ self.hurt_player_by(damage_type, amount);
+ }
/// `BossHealthOverlay.extractRenderState`: whatever `publish_boss_bars`
/// (or a server's packets) put on this client's overlay.
pub(super) fn draw_boss_bars(&self, batch: &mut HudBatch) {
@@ -2202,15 +2202,58 @@ impl Game<'_> {
}
}
pub(super) struct DragonFireball {
- position: Vec3,
- previous: Vec3,
- velocity: Vec3,
+ /// Its entity id once a server's players track it (0 until then).
+ pub(super) id: u32,
+ pub(super) position: Vec3,
+ pub(super) previous: Vec3,
+ pub(super) velocity: Vec3,
age: i32,
}
+impl DragonFireball {
+ /// One a server sent (`handleAddEntity`).
+ pub(super) fn remote(id: u32, at: Vec3, velocity: Vec3) -> Self {
+ Self {
+ id,
+ position: at,
+ previous: at,
+ velocity,
+ age: 0,
+ }
+ }
+ /// `AbstractHurtingProjectile.tick` on a server's client: `applyInertia`
+ /// first (power 0.1, inertia 0.95 or 0.8 in water), then the move; only
+ /// the server decides what it hits.
+ pub(super) fn remote_step(&mut self, water: bool) {
+ self.previous = self.position;
+ self.age += 1;
+ let v = self.velocity;
+ // Vec3.normalize: a vector shorter than 1e-5 stays zero.
+ let l = (v.x * v.x + v.y * v.y + v.z * v.z).sqrt();
+ let n = if l < 1.0e-5 {
+ Vec3::new(0.0, 0.0, 0.0)
+ } else {
+ Vec3::new(v.x / l, v.y / l, v.z / l)
+ };
+ let inertia = f64::from(if water { 0.8f32 } else { 0.95f32 });
+ let v = Vec3::new(
+ (v.x + n.x * 0.1) * inertia,
+ (v.y + n.y * 0.1) * inertia,
+ (v.z + n.z * 0.1) * inertia,
+ );
+ self.velocity = v;
+ self.position = Vec3::new(
+ self.position.x + v.x,
+ self.position.y + v.y,
+ self.position.z + v.z,
+ );
+ }
+}
pub(super) struct Breath {
- at: [f64; 3],
- radius: f32,
- age: i32,
+ /// Its entity id once a server's players track it (0 until then).
+ pub(super) id: u32,
+ pub(super) at: [f64; 3],
+ pub(super) radius: f32,
+ pub(super) age: i32,
duration: i32,
from_dragon: bool,
}
@@ -3132,6 +3175,212 @@ impl Game<'_> {
let _ = self.activate_exit_portal();
self.fight.dirty = true;
}
+ /// `EnderDragon.checkCrystals`' search: the nearest crystal whose box
+ /// meets the dragon's box grown by 32.
+ fn nearest_crystal_to(&self, p: Vec3) -> Option {
+ // The dragon's 16 by 8 box.
+ let reach = Aabb::new(
+ Vec3::new(p.x - 8.0, p.y, p.z - 8.0),
+ Vec3::new(p.x + 8.0, p.y + 8.0, p.z + 8.0),
+ )
+ .inflate(Vec3::new(32.0, 32.0, 32.0));
+ self.crystals
+ .iter()
+ .enumerate()
+ .filter(|(_, c)| {
+ // An end crystal's 2 by 2 box.
+ reach.intersects(Aabb::new(
+ Vec3::new(c.position.x - 1.0, c.position.y, c.position.z - 1.0),
+ Vec3::new(c.position.x + 1.0, c.position.y + 2.0, c.position.z + 1.0),
+ ))
+ })
+ .min_by(|a, b| {
+ let da = (a.1.position.x - p.x).powi(2)
+ + (a.1.position.y - p.y).powi(2)
+ + (a.1.position.z - p.z).powi(2);
+ let db = (b.1.position.x - p.x).powi(2)
+ + (b.1.position.y - p.y).powi(2)
+ + (b.1.position.z - p.z).powi(2);
+ da.total_cmp(&db)
+ })
+ .map(|(i, _)| i)
+ }
+}
+
+/// The dragon on a server's client (`ClientPacketListener.handleAddEntity`
+/// and the client side of `EnderDragon.aiStep`): the server flies it and
+/// sends its moves, health and phase; the client flaps its wings, keeps
+/// its flight history and places its parts, so it can be drawn and hit.
+impl Game<'_> {
+ /// `handleAddEntity` for `minecraft:ender_dragon`. Its constructor
+ /// sets the full health and the hovering phase until the server's
+ /// synched data says otherwise.
+ pub(super) fn spawn_remote_dragon(&mut self, id: i32, position: [f64; 3], yaw: f32) {
+ let at = Vec3::new(position[0], position[1], position[2]);
+ let mut d = Dragon::new(at, yaw, i64::from(id));
+ d.id = id as u32;
+ d.phase = Phase::from_id(10);
+ self.dragon = Some(d);
+ self.place_dragon_parts();
+ if let Some(d) = self.dragon.as_mut() {
+ for part in &mut d.parts {
+ part.1 = part.0;
+ }
+ }
+ }
+ /// The remote dragon, if `id` is it.
+ fn remote_dragon_mut(&mut self, id: i32) -> Option<&mut Dragon> {
+ self.dragon.as_mut().filter(|d| d.id as i32 == id)
+ }
+ /// `handleSetEntityData`: LivingEntity.DATA_HEALTH_ID and
+ /// EnderDragon.DATA_PHASE (`onSyncedDataUpdated` sets the phase).
+ pub(super) fn remote_dragon_data(&mut self, id: i32, values: &[(u8, i32, Value)]) {
+ let Some(d) = self.remote_dragon_mut(id) else {
+ return;
+ };
+ for (index, _, value) in values {
+ match (index, value) {
+ (9, Value::Float(health)) => d.health = *health,
+ (16, Value::Int(phase)) => d.set_phase(Phase::from_id(*phase)),
+ _ => {}
+ }
+ }
+ }
+ /// `handleSetEntityMotion`: the velocity its wings flap by.
+ pub(super) fn remote_dragon_motion(&mut self, id: i32, velocity: [f64; 3]) {
+ if let Some(d) = self.remote_dragon_mut(id) {
+ d.velocity = Vec3::new(velocity[0], velocity[1], velocity[2]);
+ }
+ }
+ /// `handleHurtAnimation` and `handleDamageEvent`: the red flash.
+ pub(super) fn remote_dragon_hurt(&mut self, id: i32) {
+ if let Some(d) = self.remote_dragon_mut(id) {
+ d.hurt_time = 10;
+ }
+ }
+ /// `handleRemoveEntities`, or a crystal removed: the healing beam
+ /// keeps pointing at the same crystal.
+ pub(super) fn remove_remote_dragon(&mut self, id: i32) {
+ if self.remote_dragon_mut(id).is_some() {
+ self.dragon = None;
+ return;
+ }
+ let Some(index) = self.crystals.iter().position(|c| c.id as i32 == id) else {
+ return;
+ };
+ if let Some(d) = self.dragon.as_mut() {
+ match d.nearest_crystal {
+ Some(n) if n == index => d.nearest_crystal = None,
+ Some(n) if n > index => d.nearest_crystal = Some(n - 1),
+ _ => {}
+ }
+ }
+ }
+ /// One client tick of the dragon. `lerp`: the step toward its last
+ /// sent position and yaw (LivingEntity's interpolation), and the
+ /// steps left including this one.
+ pub(super) fn tick_remote_dragon(&mut self, lerp: Option<([f64; 3], Option, u32)>) {
+ let Some(d) = self.dragon.as_mut() else {
+ return;
+ };
+ d.previous = d.position;
+ d.previous_yaw = d.yaw;
+ d.old_flap = d.flap;
+ d.ticks += 1;
+ d.hurt_time = (d.hurt_time - 1).max(0);
+ for part in &mut d.parts {
+ part.1 = part.0;
+ }
+ if let Some((target, yaw, steps)) = lerp {
+ let n = f64::from(steps.max(1));
+ d.position = Vec3::new(
+ d.position.x + (target[0] - d.position.x) / n,
+ d.position.y + (target[1] - d.position.y) / n,
+ d.position.z + (target[2] - d.position.z) / n,
+ );
+ if let Some(yaw) = yaw {
+ d.yaw += wrap(yaw - d.yaw) / steps.max(1) as f32;
+ }
+ }
+ if !d.alive() {
+ // EnderDragon.tickDeath on a client: it rises, and bursts
+ // from tick 180 to 200; the server removes it.
+ d.death_time += 1;
+ let (t, p) = (d.death_time, d.position);
+ if (180..=200).contains(&t) {
+ let r = &mut d.random;
+ let o = [
+ f64::from((r.next_float() - 0.5) * 8.0),
+ f64::from((r.next_float() - 0.5) * 4.0),
+ f64::from((r.next_float() - 0.5) * 8.0),
+ ];
+ self.particles.add(
+ &ParticleOptions::simple(ParticleType::ExplosionEmitter),
+ [p.x + o[0], p.y + 2.0 + o[1], p.z + o[2]],
+ [0.0; 3],
+ );
+ }
+ if let Some(d) = self.dragon.as_mut() {
+ d.position.y += 0.1;
+ for part in &mut d.parts {
+ part.0.y += 0.1;
+ }
+ }
+ return;
+ }
+ // processFlappingMovement and onFlap: its wing beats, and their sound.
+ let flap_was = (d.old_flap * std::f32::consts::TAU).cos();
+ let v = d.velocity;
+ let mut flap_speed = 0.2 / ((v.x.hypot(v.z) as f32) * 10.0 + 1.0);
+ flap_speed *= 2f32.powf(v.y as f32);
+ d.flap += if d.phase.sitting() { 0.1 } else { flap_speed };
+ let flap_now = (d.flap * std::f32::consts::TAU).cos();
+ let at = [d.position.x, d.position.y, d.position.z];
+ if flap_was <= -0.3 && flap_now >= -0.3 {
+ let pitch = 0.8 + self.world.random.next_float() * 0.3;
+ self.audio
+ .play("minecraft:entity.ender_dragon.flap", Some(at), 5.0, pitch);
+ }
+ let d = self.dragon.as_mut().expect("dragon");
+ if !d.phase.sitting() {
+ d.growl -= 1;
+ if d.growl < 0 {
+ d.growl = 200 + d.random.next_int_bound(200).unwrap_or(0);
+ let pitch = 0.8 + self.world.random.next_float() * 0.3;
+ self.audio
+ .play("minecraft:entity.ender_dragon.growl", Some(at), 2.5, pitch);
+ }
+ }
+ // checkCrystals' search runs on a client too (the healing beam).
+ let d = self.dragon.as_mut().expect("dragon");
+ if d.random.next_int_bound(10).unwrap_or(1) == 0 {
+ let p = d.position;
+ let nearest = self.nearest_crystal_to(p);
+ self.dragon.as_mut().expect("dragon").nearest_crystal = nearest;
+ }
+ let d = self.dragon.as_mut().expect("dragon");
+ d.yaw = wrap(d.yaw);
+ d.record();
+ self.place_dragon_parts();
+ }
+ /// The dragon's parts as a server's client attacks them: the server's
+ /// ids for `EnderDragonPart`s follow the dragon's.
+ pub(super) fn remote_dragon_part_hit(
+ &self,
+ eye: [f64; 3],
+ dir: [f64; 3],
+ reach: f64,
+ ) -> Option<(i32, f64, [f64; 3])> {
+ let d = self.dragon.as_ref().filter(|d| d.alive() && d.id != 0)?;
+ (0..8)
+ .filter_map(|i| {
+ let b = d.part_box(i);
+ let p = d.parts[i].0;
+ super::ray_box(eye, dir, reach, b)
+ .map(|t| ((d.id + 1 + i as u32) as i32, t, [p.x, p.y, p.z]))
+ })
+ .min_by(|a, b| a.1.total_cmp(&b.1))
+ }
}
#[cfg(test)]
diff --git a/crates/horizon-client/src/game/enchant_effects.rs b/crates/horizon-client/src/game/enchant_effects.rs
index aa9f75e06..776cfbd4a 100644
--- a/crates/horizon-client/src/game/enchant_effects.rs
+++ b/crates/horizon-client/src/game/enchant_effects.rs
@@ -255,23 +255,26 @@ impl Game<'_> {
let _ = self.wind_burst(feet, radius, knockback, false, false);
}
}
- /// Thorns on worn armor when a mob at `from` hits the player.
- pub(super) fn thorns(&mut self, from: [f64; 3]) {
- let attacker = self
- .mobs
- .iter()
- .enumerate()
- .filter(|(_, m)| m.alive())
- .min_by(|a, b| {
- let d = |m: &horizon_client::mobs::Mob| {
- (m.position.x - from[0]).powi(2)
- + (m.position.y - from[1]).powi(2)
- + (m.position.z - from[2]).powi(2)
- };
- d(a.1).total_cmp(&d(b.1))
- })
- .map(|(i, _)| i);
- let Some(attacker) = attacker else { return };
+ /// Thorns on worn armor when the mob `attacker` hits the player: the
+ /// `affected: attacker` effect of `Enchantment.doPostAttack` hurts the
+ /// entity that caused the hit.
+ pub(super) fn thorns(&mut self, attacker: u32) {
+ let Some(index) = self.mobs.iter().position(|m| m.id == attacker && m.alive()) else {
+ return;
+ };
+ for damage in self.thorns_damage() {
+ let m = &mut self.mobs[index];
+ m.hurt(damage, None, &mut self.world.random);
+ let center = [m.position.x, m.position.y, m.position.z];
+ self.audio
+ .play("minecraft:enchant.thorns.hit", Some(center), 1.0, 1.0);
+ }
+ }
+ /// The victim's side of thorns: for each worn piece whose chance comes up,
+ /// the damage to deal the attacker (`DamageEntity` min 1, max 5) and the
+ /// piece's wear (`ChangeItemDamage` 2).
+ pub(super) fn thorns_damage(&mut self) -> Vec {
+ let mut hits = Vec::new();
for slot in 0..4 {
let Some(stack) = self.armor[slot].clone() else {
continue;
@@ -299,15 +302,7 @@ impl Game<'_> {
if !ok {
continue;
}
- // DamageEntity(min 1, max 5) and ChangeItemDamage(2).
- let damage = 1.0 + self.world.random.next_float() * 4.0;
- let center = {
- let m = &mut self.mobs[attacker];
- m.hurt(damage, None, &mut self.world.random);
- [m.position.x, m.position.y, m.position.z]
- };
- self.audio
- .play("minecraft:enchant.thorns.hit", Some(center), 1.0, 1.0);
+ hits.push(1.0 + self.world.random.next_float() * 4.0);
if let Some(s) = self.armor[slot].as_mut() {
s.damage += 2;
if self
@@ -320,6 +315,7 @@ impl Game<'_> {
}
}
}
+ hits
}
/// `ExperienceOrb.repairPlayerItems`: returns the experience left over.
pub(super) fn mending(&mut self, amount: u32) -> u32 {
@@ -388,7 +384,9 @@ impl Game<'_> {
}
}
/// Bow enchantments at release: (extra base damage, infinity keeps the arrow).
- pub(super) fn bow_enchantments(&mut self) -> (f64, bool) {
+ /// `ammo` is the item being fired: `Enchantment.itemContext` hands it to the
+ /// `ammo_use` conditions as the tool, so Infinity only frees plain arrows.
+ pub(super) fn bow_enchantments(&mut self, ammo: &str) -> (f64, bool) {
let Some(bow) = self.inventory[self.selected].clone() else {
return (0.0, false);
};
@@ -407,7 +405,7 @@ impl Game<'_> {
0.0,
);
let ammo_ctx = EffectContext {
- tool: Some("minecraft:arrow"),
+ tool: Some(ammo),
items: Some(self.res.items()),
..Default::default()
};
diff --git a/crates/horizon-client/src/game/end.rs b/crates/horizon-client/src/game/end.rs
index 904c035c5..32d5113b0 100644
--- a/crates/horizon-client/src/game/end.rs
+++ b/crates/horizon-client/src/game/end.rs
@@ -129,15 +129,32 @@ impl EndState {
survive: false,
});
}
- /// One tick of a server's client: `step` moves each toward where the
- /// server put it.
- pub(super) fn step_remote_eyes(&mut self, mut step: impl FnMut(u32, [f64; 3]) -> [f64; 3]) {
+ /// `EyeOfEnder.tick` on a server's client: it moves by its last known
+ /// motion; only the server steers it.
+ pub(super) fn step_remote_eyes(&mut self) {
for e in &mut self.eyes {
e.previous = e.position;
e.life += 1;
- e.position = glam::DVec3::from_array(step(e.id, e.position.to_array()));
+ e.position += e.velocity;
}
}
+ /// A server's move: an eye has no interpolation handler, so
+ /// `moveOrInterpolateTo` puts it there at once. False when `id` isn't one.
+ pub(super) fn move_remote_eye(&mut self, id: u32, at: [f64; 3]) -> bool {
+ let Some(e) = self.eyes.iter_mut().find(|e| e.id == id) else {
+ return false;
+ };
+ e.position = glam::DVec3::from_array(at);
+ true
+ }
+ /// `handleSetEntityMotion` for an eye. False when `id` isn't one.
+ pub(super) fn remote_eye_motion(&mut self, id: u32, velocity: [f64; 3]) -> bool {
+ let Some(e) = self.eyes.iter_mut().find(|e| e.id == id) else {
+ return false;
+ };
+ e.velocity = glam::DVec3::from_array(velocity);
+ true
+ }
pub(super) fn remove_remote_eye(&mut self, id: u32) {
self.eyes.retain(|e| e.id != id);
}
@@ -1099,6 +1116,7 @@ impl Game<'_> {
/// EyeOfEnder.tick: fly, then drop (4 in 5) or shatter after 80 ticks.
fn tick_eyes(&mut self) {
let mut eyes = std::mem::take(&mut self.end.eyes);
+ let mut shattered = Vec::new();
eyes.retain_mut(|eye| {
eye.previous = eye.position;
let next = eye.position + eye.velocity;
@@ -1122,10 +1140,44 @@ impl Game<'_> {
extra: None,
};
self.spawn_item(stack, at, [vx, 0.2, vz], 0);
+ } else {
+ shattered.push(at.map(|v| v.floor() as i32));
}
false
});
self.end.eyes = eyes;
+ for pos in shattered {
+ self.level_event_at(2003, pos, 0);
+ }
+ }
+
+ /// `LevelEventHandler` 2003: a shattered eye's item crumbs and two rings
+ /// of portal particles drawn in towards it.
+ pub(super) fn eye_break_particles(&mut self, pos: [i32; 3]) {
+ let (x, y, z) = (
+ f64::from(pos[0]) + 0.5,
+ f64::from(pos[1]),
+ f64::from(pos[2]) + 0.5,
+ );
+ let crumbs = self.item_particle(&ItemStack::new("minecraft:ender_eye", 1));
+ for _ in 0..8 {
+ let r = self.particles.random();
+ let v = [
+ r.next_gaussian() * 0.15,
+ r.next_double() * 0.2,
+ r.next_gaussian() * 0.15,
+ ];
+ self.particles.add(&crumbs, [x, y, z], v);
+ }
+ let portal = ParticleOptions::simple(ParticleType::Portal);
+ let mut angle = 0.0f64;
+ while angle < std::f64::consts::PI * 2.0 {
+ let (c, s) = (angle.cos(), angle.sin());
+ let at = [x + c * 5.0, y - 0.4, z + s * 5.0];
+ self.particles.add(&portal, at, [c * -5.0, 0.0, s * -5.0]);
+ self.particles.add(&portal, at, [c * -7.0, 0.0, s * -7.0]);
+ angle += std::f64::consts::PI / 20.0;
+ }
}
/// `EyeOfEnder.tick` on a client: behind each eye (a quarter of its last
diff --git a/crates/horizon-client/src/game/explosion.rs b/crates/horizon-client/src/game/explosion.rs
index 6ecba3a54..687884519 100644
--- a/crates/horizon-client/src/game/explosion.rs
+++ b/crates/horizon-client/src/game/explosion.rs
@@ -296,12 +296,14 @@ impl Game<'_> {
if !creative
&& !spectator
&& hurtable
- && let Ok(o) = p.hurt_blocking(
+ && let Ok(o) = p.hurt_caused_by(
&self.motion.health,
self.world.health_rules,
id,
amount,
blocking,
+ // The exploding mob is the causing entity.
+ exploding.is_some(),
)
{
outcome = o;
@@ -314,9 +316,6 @@ impl Game<'_> {
);
}
}
- if outcome.hurt && !creative {
- self.hurt_armor(amount);
- }
if raised {
self.after_block(outcome, amount, None, false);
}
@@ -391,9 +390,11 @@ impl Game<'_> {
[feet[0] - w, feet[1], feet[2] - w],
[feet[0] + w, feet[1] + h, feet[2] + w],
);
+ // The exploding mob is the damage source's entity, so victims
+ // it kills drop its charged-creeper loot (`Creeper.killedEntity`).
let source = horizon_client::mobs::Damage {
kind: horizon_client::mobs::DamageKind::Explosion,
- attacker: None,
+ attacker: exploding.map(horizon_client::mobs::Who::Mob),
from: Some(center),
};
if hurtable && !m.damage(damage(dist, exposure), source) {
@@ -620,6 +621,7 @@ impl Game<'_> {
&mut self.world.random,
Some((&mut self.rand_sequences, self.level.seed)),
decay,
+ false,
);
for mut stack in drops {
if &*stack.item == "minecraft:air" || stack.count == 0 {
diff --git a/crates/horizon-client/src/game/falling_damage.rs b/crates/horizon-client/src/game/falling_damage.rs
index 8eec28d1d..759b4f646 100644
--- a/crates/horizon-client/src/game/falling_damage.rs
+++ b/crates/horizon-client/src/game/falling_damage.rs
@@ -108,16 +108,10 @@ impl Game<'_> {
} else {
amount
};
- let hurt = if let Some(p) = self.player.as_mut()
+ if let Some(p) = self.player.as_mut()
&& let Some(id) = self.motion.health.damage.id(kind)
{
- p.hurt(&self.motion.health, self.world.health_rules, id, amount)
- .unwrap_or(false)
- } else {
- false
- };
- if hurt {
- self.hurt_armor(amount);
+ let _ = p.hurt(&self.motion.health, self.world.health_rules, id, amount);
}
}
}
diff --git a/crates/horizon-client/src/game/fangs.rs b/crates/horizon-client/src/game/fangs.rs
index cdf2d17a5..aed692649 100644
--- a/crates/horizon-client/src/game/fangs.rs
+++ b/crates/horizon-client/src/game/fangs.rs
@@ -81,16 +81,28 @@ impl Game<'_> {
};
bite(self);
self.each_guest_hit(bite);
+ // `AbstractIllager.considersEntityAsAlly`: with no teams, the illager
+ // tag is allied; `Evoker.considersEntityAsAlly` adds a vex whose
+ // owner is allied (itself or another illager). Teams are not modelled.
+ let illager = |s: Species| {
+ matches!(
+ s,
+ Species::Evoker | Species::Illusioner | Species::Pillager | Species::Vindicator
+ )
+ };
+ let illagers: Vec = self
+ .mobs
+ .iter()
+ .filter(|m| illager(m.species()))
+ .map(|m| m.id)
+ .collect();
+ // A missing owner hurts everyone (`currentOwner == null`).
+ let owner_known = illagers.contains(&f.owner);
for m in &mut self.mobs {
- let ally = matches!(
- m.species(),
- Species::Evoker
- | Species::Illusioner
- | Species::Vex
- | Species::Pillager
- | Species::Vindicator
- | Species::Witch
- );
+ let ally = owner_known
+ && (illager(m.species())
+ || m.species() == Species::Vex
+ && illagers.contains(&(m.extra.counter2 as u32)));
if m.id != f.owner && !ally && m.alive() && m.bounds().intersects(b) {
m.damage(
6.0,
diff --git a/crates/horizon-client/src/game/fireworks.rs b/crates/horizon-client/src/game/fireworks.rs
index e6b4eb136..38fd74ed8 100644
--- a/crates/horizon-client/src/game/fireworks.rs
+++ b/crates/horizon-client/src/game/fireworks.rs
@@ -17,6 +17,8 @@ use horizon_core::{
random::RandomSource,
};
+pub(super) const FIREWORK_EXPLODE_EVENT: i8 = 17;
+
pub(super) struct Rocket {
/// The entity id a server tracks it by (0 until it is tracked).
pub id: u32,
@@ -261,6 +263,14 @@ impl Game<'_> {
/// `FireworkRocketEntity.explode` and `dealExplosionDamage`.
fn explode_rocket(&mut self, r: &Rocket) {
let at = [r.position.x, r.position.y, r.position.z];
+ // FireworkRocketEntity.explode broadcasts before discard. Send now:
+ // tick_lan removes missing tracked entities before flushing effects.
+ if r.id != 0
+ && let Some(host) = &self.lan
+ {
+ host.hub
+ .entity_event(r.id as i32, FIREWORK_EXPLODE_EVENT, at);
+ }
if !r.explosions.is_empty() {
let damage = 5.0 + r.explosions.len() as f32 * 2.0;
let from = r.position;
@@ -322,6 +332,16 @@ impl Game<'_> {
self.particles
.fireworks(at, v, r.explosions.clone(), camera);
}
+ /// FireworkRocketEntity.handleEntityEvent: use the synchronized item data.
+ pub(super) fn remote_firework_explosion(&mut self, id: i32) {
+ let camera = self.eye_position();
+ if let Some(r) = self.rockets.iter().find(|r| r.id == id as u32) {
+ let at = [r.position.x, r.position.y, r.position.z];
+ let v = [r.velocity.x, r.velocity.y, r.velocity.z];
+ self.particles
+ .fireworks(at, v, r.explosions.clone(), camera.unwrap_or(at));
+ }
+ }
/// `dealExplosionDamage` on a player that is not the rocket's
/// `attachedToEntity`: within 5 blocks, when the rocket sees its feet or
/// its middle (`ClipContext.Block.COLLIDER`, no fluids).
@@ -352,17 +372,11 @@ impl Game<'_> {
if self.creative || self.spectator() {
return;
}
- let hurt = if let Some(p) = self.player.as_mut()
+ if let Some(p) = self.player.as_mut()
&& !p.health.dead_or_dying()
&& let Some(id) = self.motion.health.damage.id("minecraft:fireworks")
{
- p.hurt(&self.motion.health, self.world.health_rules, id, amount)
- .unwrap_or(false)
- } else {
- false
- };
- if hurt {
- self.hurt_armor(amount);
+ let _ = p.hurt(&self.motion.health, self.world.health_rules, id, amount);
}
}
/// `FireworkEntityRenderer.submit`: the item (GROUND) facing the camera,
diff --git a/crates/horizon-client/src/game/fishing.rs b/crates/horizon-client/src/game/fishing.rs
index d454df406..39f9e5ffe 100644
--- a/crates/horizon-client/src/game/fishing.rs
+++ b/crates/horizon-client/src/game/fishing.rs
@@ -154,37 +154,54 @@ impl Game<'_> {
let mut damage = 0;
if let State::Hooked(id) = hook.state {
// pullEntity: 0.1 of the way to the owner.
+ let d = Vec3::new(
+ owner.x - hook.position.x,
+ owner.y - hook.position.y,
+ owner.z - hook.position.z,
+ );
+ let pulled = |v: Vec3| Vec3::new(v.x + d.x * 0.1, v.y + d.y * 0.1, v.z + d.z * 0.1);
+ let mut hooked_item = false;
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
- let d = Vec3::new(
- owner.x - hook.position.x,
- owner.y - hook.position.y,
- owner.z - hook.position.z,
- );
- m.velocity = Vec3::new(
- m.velocity.x + d.x * 0.1,
- m.velocity.y + d.y * 0.1,
- m.velocity.z + d.z * 0.1,
- );
+ m.velocity = pulled(m.velocity);
+ } else if let Some(item) = self.dropped.iter_mut().find(|i| i.id == id) {
+ item.velocity = pulled(item.velocity);
+ hooked_item = true;
}
- damage = 5;
+ // `hookedIn instanceof ItemEntity ? 3 : 5`.
+ damage = if hooked_item { 3 } else { 5 };
} else if hook.nibble > 0 {
let biome = self.biome_name_at(hook.position);
let Some(loot) = horizon_client::structure_blocks::loot_data(&self.options.resources)
else {
return damage;
};
+ // `withLuck(this.luck + owner.getLuck())`: the rod's Luck of the Sea
+ // plus the owner's luck attribute (the Luck and Bad Luck effects).
+ let owner_luck = self
+ .player
+ .as_mut()
+ .and_then(|p| p.attribute("minecraft:luck").ok())
+ .unwrap_or(0.0) as f32;
let mut random = self.world.random.clone();
let items = loot.roll(
"minecraft:gameplay/fishing",
&mut random,
- hook.luck as f32,
+ hook.luck as f32 + owner_luck,
biome.as_deref(),
Some(hook.open_water),
);
self.world.random = random;
- // FishingHook.retrieve: fish_caught for a catch.
- self.stats.custom("fish_caught", 1);
for stack in items {
+ // FishingHook.retrieve: fish_caught for each catch in #minecraft:fishes.
+ if self
+ .res
+ .items()
+ .item_tags
+ .get("minecraft:fishes")
+ .is_some_and(|t| t.contains(stack.item.as_str()))
+ {
+ self.stats.custom("fish_caught", 1);
+ }
let mut item = ItemStack {
item: Arc::from(stack.item.as_str()),
count: stack.count.max(1) as u32,
@@ -231,7 +248,7 @@ impl Game<'_> {
}
damage
}
- fn biome_name_at(&self, p: Vec3) -> Option {
+ pub(super) fn biome_name_at(&self, p: Vec3) -> Option {
let (x, y, z) = (p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
let c = self.world.chunks.get(&(x >> 4, z >> 4))?;
Some(
@@ -457,35 +474,47 @@ impl Game<'_> {
self.hook = Some(h);
return;
}
- // checkCollision: hook the first living mob it touches.
+ // checkCollision: hook the first living mob it touches, or (via
+ // `canHitEntity`) a dropped item.
let bb = bounds(h.position);
let (lo, hi) = (bb.min_position(), bb.max_position());
- if let Some(m) = self.mobs.iter().find(|m| {
- let mb = m.bounds();
- let (a, z) = (mb.min_position(), mb.max_position());
- m.alive()
- && a.x < hi.x
- && lo.x < z.x
- && a.y < hi.y
- && lo.y < z.y
- && a.z < hi.z
- && lo.z < z.z
- }) {
- h.state = State::Hooked(m.id);
+ let touches = |b: Aabb| {
+ let (a, z) = (b.min_position(), b.max_position());
+ a.x < hi.x && lo.x < z.x && a.y < hi.y && lo.y < z.y && a.z < hi.z && lo.z < z.z
+ };
+ let hit = self
+ .mobs
+ .iter()
+ .find(|m| m.alive() && touches(m.bounds()))
+ .map(|m| m.id)
+ .or_else(|| {
+ self.dropped
+ .iter()
+ .find(|i| touches(i.bounds()))
+ .map(|i| i.id)
+ });
+ if let Some(id) = hit {
+ h.state = State::Hooked(id);
h.velocity = Vec3::ZERO;
self.hook = Some(h);
return;
}
}
State::Hooked(id) => {
- match self.mobs.iter().find(|m| m.id == id && m.alive()) {
- Some(m) => {
- h.position = Vec3::new(
- m.position.x,
- m.position.y + f64::from(m.height()) * 0.8,
- m.position.z,
- )
- }
+ // updateHookedEntity: ride the hooked mob or item at 0.8 of its height.
+ let hooked = self
+ .mobs
+ .iter()
+ .find(|m| m.id == id && m.alive())
+ .map(|m| (m.position, f64::from(m.height())))
+ .or_else(|| {
+ self.dropped
+ .iter()
+ .find(|i| i.id == id)
+ .map(|i| (i.position, horizon_client::entities::ItemEntity::WIDTH))
+ });
+ match hooked {
+ Some((at, height)) => h.position = Vec3::new(at.x, at.y + height * 0.8, at.z),
None => h.state = State::Flying,
}
self.hook = Some(h);
diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs
index 7f5e6c26a..d08c5f283 100644
--- a/crates/horizon-client/src/game/frames.rs
+++ b/crates/horizon-client/src/game/frames.rs
@@ -355,12 +355,23 @@ impl Game<'_> {
* glam::DMat4::from_rotation_y(y_rot.to_radians());
let light = self.world.light(f.pos[0], f.pos[1], f.pos[2]);
let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
+ // ItemFrameRenderer.getBlockLightLevel: a glow frame's model is at least 5 bright.
+ let frame_light = if f.glow {
+ (light & 0xF0) | (light & 15).max(5)
+ } else {
+ light
+ };
+ let frame_packed =
+ (u32::from(frame_light >> 4) * 16) | ((u32::from(frame_light & 15) * 16) << 8);
let mut quad =
|m: &glam::DMat4, corners: [[f64; 3]; 4], uv: [[f32; 2]; 4], light: u32| {
- for (c, uv) in corners.iter().zip(uv) {
- let p = m.transform_point3(glam::DVec3::from_array(*c));
+ // The frame model is drawn with the entity shader, lit by its face normal.
+ let at = corners.map(|c| m.transform_point3(glam::DVec3::from_array(c)));
+ let n = (at[1] - at[0]).cross(at[2] - at[0]).normalize_or_zero();
+ let normal = [0, 1, 2].map(|k| (n[k].clamp(-1.0, 1.0) * 127.0) as i8);
+ for (p, uv) in at.into_iter().zip(uv) {
out.push(Vertex {
- normal: [0; 4],
+ normal: [normal[0], normal[1], normal[2], -127],
pos: p.as_vec3().to_array(),
uv,
layer: 0,
@@ -393,7 +404,7 @@ impl Game<'_> {
]
}),
map_uv(r, *uv),
- packed,
+ frame_packed,
);
}
}
diff --git a/crates/horizon-client/src/game/hand.rs b/crates/horizon-client/src/game/hand.rs
index a7218ff3c..d91d3b979 100644
--- a/crates/horizon-client/src/game/hand.rs
+++ b/crates/horizon-client/src/game/hand.rs
@@ -151,6 +151,7 @@ impl Game<'_> {
before(self.painting_hit().map(|h| h.1))
|| before(self.frame_hit().map(|h| h.1))
|| before(self.armor_stand_hit().map(|h| h.1))
+ || before(self.cushion_hit().map(|h| h.1))
|| before(self.boat_hit().map(|h| h.1))
|| before(self.cart_hit().map(|h| h.1))
|| before(self.dragon_hit().map(|h| h.1))
diff --git a/crates/horizon-client/src/game/integrated.rs b/crates/horizon-client/src/game/integrated.rs
index 14a18caa6..dd1c04e23 100644
--- a/crates/horizon-client/src/game/integrated.rs
+++ b/crates/horizon-client/src/game/integrated.rs
@@ -222,7 +222,6 @@ impl Game<'_> {
options.report = None;
options.server = None;
options.world = None;
- options.dev_mods.clear();
self.join_world_rest()?;
let (res, pack, settings) = (self.res.clone(), self.pack.clone(), self.settings.clone());
let flags = Arc::new(Flags::default());
@@ -292,6 +291,9 @@ impl Game<'_> {
launch.create.as_ref(),
)?)?;
let saved = Box::new(self.level.clone());
+ // IntegratedServer runs the server mods; the window the client mods.
+ self.mods.dev = self.options.dev_mods.clone();
+ self.start_mods();
// Math.max(2, options.renderDistance): past vanilla's 32 when the
// window's render distance is (Horizon's options go to 64).
let view_distance = self.settings.render_distance.max(2);
diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs
index 1d79f077d..b6b7e2fb7 100644
--- a/crates/horizon-client/src/game/item_draw.rs
+++ b/crates/horizon-client/src/game/item_draw.rs
@@ -196,13 +196,31 @@ impl Game<'_> {
skins: &self.skin_downloads,
}
}
- /// The client level as item models read it.
+ /// The client level as item models read it: worked out once a frame (a
+ /// screen of items read the same level, its sky sampled once).
pub(super) fn item_level(&self) -> LevelState {
let dimension = match self.dim {
Dim::Overworld => "minecraft:overworld",
Dim::Nether => "minecraft:the_nether",
Dim::End => "minecraft:the_end",
};
+ let key = (
+ self.frames,
+ self.world.game_time,
+ self.world.day_time,
+ dimension,
+ );
+ let mut cached = self.item_level_cache.borrow_mut();
+ if let Some((at, level)) = cached.as_ref()
+ && *at == key
+ {
+ return level.clone();
+ }
+ let level = self.level_state_now(dimension);
+ *cached = Some((key, level.clone()));
+ level
+ }
+ fn level_state_now(&self, dimension: &'static str) -> LevelState {
let sky = self
.dim_environment()
.sample(self.world.day_time, None, None);
diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs
index b2af02f8a..5292cd31b 100644
--- a/crates/horizon-client/src/game/lan.rs
+++ b/crates/horizon-client/src/game/lan.rs
@@ -14,7 +14,7 @@ use horizon_client::{
hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
playerdata,
},
- mobs::{Mob, leash::Holder},
+ mobs::{Mob, Who, leash::Holder},
text::Text,
};
use horizon_core::geometry::Vec3;
@@ -147,6 +147,7 @@ pub(super) fn baby_index(kind: &str) -> Option {
fn mob_meta(
m: &Mob,
hub: &Hub,
+ player_entity: Option,
meta: &mut Vec<(u8, i32, Value)>,
defaults: &mut Vec<(u8, i32, Value)>,
) {
@@ -196,6 +197,32 @@ fn mob_meta(
let e = &m.extra;
let id = |registry: &str, name: &str| hub.registry_id(registry, &format!("minecraft:{name}"));
match kind {
+ "minecraft:guardian" | "minecraft:elder_guardian" => {
+ // Guardian.DATA_ID_MOVING and DATA_ID_ATTACK_TARGET.
+ if e.flag2 {
+ meta.push((16, serializer::BOOLEAN, Value::Bool(true)));
+ }
+ let target = if e.flag {
+ m.ai.target.and_then(|who| match who {
+ Who::Player => player_entity,
+ Who::Mob(id) => Some(id as i32),
+ })
+ } else {
+ None
+ };
+ if let Some(target) = target {
+ meta.push((17, serializer::INT, Value::Int(target)));
+ }
+ defaults.push((16, serializer::BOOLEAN, Value::Bool(false)));
+ defaults.push((17, serializer::INT, Value::Int(0)));
+ }
+ // Bat.DATA_ID_FLAGS: resting in bit 0, flying by default.
+ "minecraft:bat" => {
+ if e.flag {
+ meta.push((16, serializer::BYTE, Value::Byte(1)));
+ }
+ defaults.push((16, serializer::BYTE, Value::Byte(0)));
+ }
// Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 when sheared.
"minecraft:sheep" => {
let value = (e.color & 15) | if e.sheared { 16 } else { 0 };
@@ -637,6 +664,7 @@ impl Game<'_> {
self.world.light_log = None;
self.audio.capture = None;
self.lan_events.clear();
+ self.lan_critical_hits.clear();
self.streaming.extra.clear();
if announce {
self.system_message(Text::translate(
@@ -823,12 +851,13 @@ impl Game<'_> {
for m in self.mobs.iter().filter(|m| !m.removed) {
// The lead's holder: the player the mob sees (a guest, else the
// host) or another mob. A fence knot isn't an entity here.
+ let player_entity = mob_players
+ .get(&m.id)
+ .and_then(|conn| hub.guest(*conn))
+ .map(|g| g.entity_id)
+ .or(host_entity);
let leash = m.extra.leash.and_then(|h| match h {
- Holder::Player => mob_players
- .get(&m.id)
- .and_then(|conn| hub.guest(*conn))
- .map(|g| g.entity_id)
- .or(host_entity),
+ Holder::Player => player_entity,
Holder::Mob(id) => Some(id as i32),
Holder::Knot(_) => None,
});
@@ -838,7 +867,7 @@ impl Game<'_> {
e.on_ground = m.on_ground;
e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z];
e.needs_sync = m.needs_sync;
- mob_meta(m, hub, &mut e.meta, &mut e.defaults);
+ mob_meta(m, hub, player_entity, &mut e.meta, &mut e.defaults);
mob_equipment(m, hub, &mut e.equipment);
self.mob_attributes(m, &mut e.attributes);
e.leash = leash;
@@ -915,6 +944,13 @@ impl Game<'_> {
for m in &mut self.mobs {
m.needs_sync = false;
}
+ // `runBlockEvents`' broadcast precedes the tick's block changes
+ // (`ChunkHolder.broadcastChanges` in `tick_level` below): the
+ // guest re-runs a piston's `triggerEvent` while its level still
+ // has the blocks as they were before the move.
+ for (pos, b0, b1, state) in std::mem::take(&mut self.lan_block_events) {
+ host.hub.block_event(pos, b0, b1, state);
+ }
let entities = states.as_slice();
let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]);
let events = {
@@ -963,6 +999,9 @@ impl Game<'_> {
event @ (HostEvent::Chat { .. } | HostEvent::Warn(_) | HostEvent::Error(_)) => {
self.lan_log_event(event);
}
+ HostEvent::PlayerChat { sender, text } => {
+ self.mod_player_chat(super::server_mods::Who::Uuid(sender), &text);
+ }
HostEvent::Joined(conn) => {
self.lan_guest_joined(&mut host, conn, state.as_ref(), entities, spawn);
if self.options.dedicated.is_some()
@@ -1145,17 +1184,29 @@ impl Game<'_> {
return;
}
for e in events {
- if let horizon_world::level::LevelEvent::LevelEvent { id, pos, data } = e {
- // The acting guest does not predict the egg's teleport
- // particles, bone meal's growth, or anvil result sounds
- // (these levelEvent calls name no excluded player).
- let except = if matches!(*id, 2015 | 1505 | 1029 | 1030) {
- None
- } else {
- self.lan_acting
- };
- self.lan_events
- .push((*id, [pos.x, pos.y, pos.z], *data, except));
+ match e {
+ horizon_world::level::LevelEvent::LevelEvent { id, pos, data } => {
+ // The acting guest does not predict the egg's teleport
+ // particles, bone meal's growth, or anvil result sounds
+ // (these levelEvent calls name no excluded player).
+ let except = if matches!(*id, 2015 | 1505 | 1029 | 1030) {
+ None
+ } else {
+ self.lan_acting
+ };
+ self.lan_events
+ .push((*id, [pos.x, pos.y, pos.z], *data, except));
+ }
+ // `ServerLevel.runBlockEvents` broadcasts a handled block
+ // event (`ClientboundBlockEventPacket`): the guest re-runs
+ // the block's `triggerEvent` — a piston's `moveBlocks` is
+ // what animates the move there. `state` is the block the
+ // event named, read before it ran (the packet's `block`).
+ horizon_world::level::LevelEvent::BlockEntityEvent { pos, state, a, b } => {
+ self.lan_block_events
+ .push(([pos.x, pos.y, pos.z], *a, *b, state.0));
+ }
+ _ => {}
}
}
}
@@ -1173,8 +1224,30 @@ impl Game<'_> {
self.lan_entity_events.push((id, event, at));
}
}
+ /// `ServerPlayer.crit`: this window's emitter, and an animation for the
+ /// attacker's client and observers once the hub is back in place.
+ pub(super) fn critical_hit(
+ &mut self,
+ attacker: Option,
+ id: i32,
+ feet: [f64; 3],
+ width: f64,
+ height: f64,
+ ) {
+ use horizon_client::particles::{ParticleOptions, ParticleType};
+ self.particles.tracking_emitter(
+ ParticleOptions::simple(ParticleType::Crit),
+ feet,
+ width,
+ height,
+ );
+ if self.audio.capture.is_some() {
+ self.lan_critical_hits.push((attacker, id));
+ }
+ }
/// Send the tick's level events, sounds and mob animations.
fn lan_flush_effects(&mut self, host: &mut LanHost) {
+ let critical_hits = std::mem::take(&mut self.lan_critical_hits);
for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) {
if kind == 2001 {
host.broken
@@ -1247,6 +1320,14 @@ impl Game<'_> {
seen.insert(m.id, (m.hurt_time, dead, swing));
}
host.mob_state.insert(self.dim, seen);
+ for (attacker, target) in critical_hits {
+ let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| {
+ host.hub.guest(conn).map(|g| g.entity_id)
+ }) else {
+ continue;
+ };
+ host.hub.critical_hit(attacker, target);
+ }
}
/// Keep the chunks around every guest loaded.
@@ -1414,7 +1495,11 @@ impl Game<'_> {
let tag = if secure { "" } else { "[Not Secure] " };
super::dedicated::log("INFO", &format!("{tag}{line}"));
}
- HostEvent::Chat { line, .. } => self.system_message(Text::literal(line)),
+ // Player chat (and `/say`'s or `/me`'s, which are chat messages
+ // too): the host's Chat option decides, as `ChatListener` does
+ // for the guests' packets. Command feedback is a system message
+ // and takes the system-message permission instead.
+ HostEvent::Chat { line, .. } => self.player_message(Text::literal(line)),
HostEvent::Warn(line) if dedicated => super::dedicated::log("WARN", &line),
HostEvent::Warn(line) => log::warn!("{line}"),
HostEvent::Error(line) if dedicated => super::dedicated::log("ERROR", &line),
diff --git a/crates/horizon-client/src/game/lan_actions.rs b/crates/horizon-client/src/game/lan_actions.rs
index 0ad14bbcc..98162ae46 100644
--- a/crates/horizon-client/src/game/lan_actions.rs
+++ b/crates/horizon-client/src/game/lan_actions.rs
@@ -77,6 +77,10 @@ pub(super) struct GuestPlay {
last_inventory: u64,
/// `Entity.portalProcess` and `portalCooldown` (game/server_travel.rs).
pub(super) portal: horizon_client::nether_portal::PortalState,
+ /// `ServerPlayer.wonGame`: the End poem is showing, the player waits for
+ /// its client's PERFORM_RESPAWN (`respawn_requested`).
+ pub(super) won_game: bool,
+ pub(super) respawn_requested: bool,
/// `Player.takeXpDelay`: ticks until the next orb can be taken.
xp_delay: u32,
/// What last killed the guest outright (`/kill`): the death message's key.
@@ -875,7 +879,11 @@ impl Game<'_> {
.filter(|g| host.hub.here(g))
.filter(|g| {
g.menu.as_ref().is_some_and(|m| {
- m.slots.valid(&self.world) && !m.slots.still_valid(&self.world, g, m.pos)
+ (m.slots.valid(&self.world) && !m.slots.still_valid(&self.world, g, m.pos))
+ || m.pos.is_some_and(|k| {
+ k.1 == super::minecarts::CART_KEY_Y
+ && !self.chest_vehicle_still_valid(k.2, g)
+ })
})
})
.map(|g| g.conn)
@@ -889,6 +897,35 @@ impl Game<'_> {
}
}
+ /// `ContainerEntity.isChestVehicleStillValid`: the chest minecart or chest
+ /// boat is still there and within the guest's entity interaction range
+ /// plus 4 of its box.
+ fn chest_vehicle_still_valid(&self, id: i32, g: &horizon_client::lan::guest::Guest) -> bool {
+ let bounds = self
+ .carts
+ .iter()
+ .find(|c| c.id as i32 == id)
+ .map(|c| c.bounds())
+ .or_else(|| {
+ self.boats
+ .iter()
+ .find(|b| b.id as i32 == id)
+ .map(|b| b.bounds())
+ });
+ let Some(b) = bounds else {
+ return false;
+ };
+ let eye = [g.position[0], g.position[1] + g.eye_height(), g.position[2]];
+ let (lo, hi) = (b.min_position(), b.max_position());
+ let d = [
+ eye[0] - eye[0].clamp(lo.x, hi.x),
+ eye[1] - eye[1].clamp(lo.y, hi.y),
+ eye[2] - eye[2].clamp(lo.z, hi.z),
+ ];
+ let range = if g.creative() { 5.0 } else { 3.0 } + 4.0;
+ d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < range * range
+ }
+
/// A packet from a guest that the hub does not handle itself.
pub(super) fn lan_guest_packet(&mut self, host: &mut LanHost, conn: u32, packet: S) {
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
@@ -1314,6 +1351,13 @@ impl Game<'_> {
self.guest_suggestions(host, conn, &payload);
}
S::PlaceRecipe(p) => self.lan_place_recipe(host, conn, &p),
+ // handleClientCommand: PERFORM_RESPAWN after the poem leaves the End
+ // (the next server tick sends the player on).
+ S::ClientCommand(c)
+ if c.action == 0 && host.play.get(&conn).is_some_and(|p| p.won_game) =>
+ {
+ host.play.entry(conn).or_default().respawn_requested = true;
+ }
S::ClientCommand(c) if c.action == 0 => self.guest_respawn(host, conn),
// ServerStatsCounter.sendStats.
S::ClientCommand(c) if c.action == 1 => {
@@ -1539,6 +1583,10 @@ impl Game<'_> {
);
return;
}
+ // A server mod's command, for every player whatever their level.
+ if self.guest_server_mod_command(host, conn, command.trim_start_matches('/')) {
+ return;
+ }
// An integrated server runs every player's commands at their own
// permission level (`CommandSourceStack.permissions`); a LAN world
// follows its Allow Commands, and a dedicated server leaves it to
@@ -2253,6 +2301,7 @@ impl Game<'_> {
let marked = std::mem::take(&mut player.health.sync_velocity);
let velocity = marked.then_some(player.velocity);
game.record_combat(&events);
+ game.wear_armor(&events);
(events, velocity)
});
let Some((events, marked)) = events else {
@@ -2346,9 +2395,13 @@ impl Game<'_> {
}
if (next / 10) % 2 == 0
&& !creative
- && let Some(elytra) = game.armor[1].as_mut()
+ && let Some(stack) = game.armor[1].clone()
{
- elytra.damage += 1;
+ // `ItemStack.hurtAndBreak`: Unbreaking can save the wear.
+ let loss = game.durability_loss(&stack, 1);
+ if let Some(elytra) = game.armor[1].as_mut() {
+ elytra.damage += loss;
+ }
}
let ctx = game.player_context(None);
game.post_game_event("minecraft:elytra_glide", at, ctx);
@@ -2611,7 +2664,13 @@ impl Game<'_> {
.random
.next_int_bound(touching.len() as i32)
.unwrap_or(0) as usize;
- let orb = self.orbs.remove(touching[pick]);
+ // A merged orb gives its value once per count and goes at zero.
+ let orb = self.orbs[touching[pick]].clone();
+ if orb.count <= 1 {
+ self.orbs.remove(touching[pick]);
+ } else {
+ self.orbs[touching[pick]].count -= 1;
+ }
play.xp_delay = 2;
host.hub.take_item(orb.id as i32, id, 1, at);
// ClientPacketListener.handleTakeItemEntity's sound, at the orb.
diff --git a/crates/horizon-client/src/game/lan_entities.rs b/crates/horizon-client/src/game/lan_entities.rs
index cd4ba2fb8..529666590 100644
--- a/crates/horizon-client/src/game/lan_entities.rs
+++ b/crates/horizon-client/src/game/lan_entities.rs
@@ -245,6 +245,16 @@ impl Game<'_> {
}
out.push(e);
}
+ for c in &self.cushions {
+ let p = c.position;
+ let mut e = state(c.id, "minecraft:cushion", [p.x, p.y, p.z], c.yaw, false);
+ // Cushion.DATA_COLOR, set unless it is the default white.
+ if c.color != 0 {
+ e.meta
+ .push((8, serializer::DYE_COLOR, Value::Id(i32::from(c.color))));
+ }
+ out.push(e);
+ }
self.lan_projectile_states(host_entity, hub, out);
for o in &self.others {
let p = o.position;
@@ -279,6 +289,10 @@ impl Game<'_> {
self.bolts.iter_mut().for_each(|b| give(&mut b.id));
self.potions.thrown_ids().for_each(&mut give);
self.end.eye_ids().for_each(&mut give);
+ self.breath_clouds.iter_mut().for_each(|b| give(&mut b.id));
+ self.dragon_fireballs
+ .iter_mut()
+ .for_each(|b| give(&mut b.id));
}
/// Primed TNT, falling blocks, projectiles, tridents, firework rockets and
@@ -435,6 +449,35 @@ impl Game<'_> {
}
out.push(e);
}
+ // The dragon's breath clouds (AreaEffectCloud's DATA_RADIUS,
+ // DATA_WAITING for its 20-tick wait, and DATA_PARTICLE): the
+ // client draws them from these (`tick_remote_clouds`).
+ let breath = self.network_particle(
+ &horizon_client::particles::ParticleOptions::simple(
+ horizon_client::particles::ParticleType::DragonBreath,
+ ),
+ None,
+ );
+ for b in self.dragon_fireballs.iter().filter(|b| b.id != 0) {
+ let p = b.position;
+ let mut e = state(b.id, "minecraft:dragon_fireball", at(p), 0.0, false);
+ e.velocity = [b.velocity.x, b.velocity.y, b.velocity.z];
+ out.push(e);
+ }
+ for b in self.breath_clouds.iter().filter(|b| b.id != 0) {
+ let mut e = state(b.id, "minecraft:area_effect_cloud", b.at, 0.0, false);
+ e.meta.push((8, serializer::FLOAT, Value::Float(b.radius)));
+ if b.age < 20 {
+ e.meta.push((9, serializer::BOOLEAN, Value::Bool(true)));
+ }
+ if let Some(p) = &breath {
+ e.meta
+ .push((10, serializer::PARTICLE, Value::Particle(p.clone())));
+ }
+ e.defaults
+ .push((9, serializer::BOOLEAN, Value::Bool(false)));
+ out.push(e);
+ }
out.extend(self.lan_dragon_state());
}
}
diff --git a/crates/horizon-client/src/game/lan_mobs.rs b/crates/horizon-client/src/game/lan_mobs.rs
index 4f53cec60..6527f1015 100644
--- a/crates/horizon-client/src/game/lan_mobs.rs
+++ b/crates/horizon-client/src/game/lan_mobs.rs
@@ -370,6 +370,7 @@ mod tests {
velocity: Vec3::ZERO,
yaw: 0.0,
hero: false,
+ effects: Vec::new(),
uuid: [0; 4],
allies: Default::default(),
remote: false,
diff --git a/crates/horizon-client/src/game/lan_particles.rs b/crates/horizon-client/src/game/lan_particles.rs
index 0e35392bf..c41fdf1ad 100644
--- a/crates/horizon-client/src/game/lan_particles.rs
+++ b/crates/horizon-client/src/game/lan_particles.rs
@@ -25,6 +25,33 @@ fn rgb(c: [f32; 4]) -> [f32; 3] {
}
impl Game<'_> {
+ /// `SonicBoom.tick` uses `ServerLevel.sendParticles` for each ray point.
+ /// Keep the local event's rendering; connected players receive one at rest.
+ pub(super) fn lan_sonic_boom(&self, options: &ParticleOptions, at: [f64; 3]) {
+ let (Some(host), Some(particle)) = (&self.lan, self.network_particle(options, None)) else {
+ return;
+ };
+ let packet = C::LevelParticles(play::LevelParticles {
+ particle,
+ override_limiter: false,
+ always_show: false,
+ pos: at,
+ dist: [0.0; 3],
+ max_speed: [0.0; 3],
+ count: 0,
+ randomization: 0,
+ });
+ for g in host.hub.guests.iter().filter(|g| host.hub.here(g)) {
+ // ServerLevel compares the player's block centre, strictly within 32.
+ let distance: f64 = (0..3)
+ .map(|k| (g.position[k].floor() + 0.5 - at[k]).powi(2))
+ .sum();
+ if distance < 32.0 * 32.0 {
+ g.send(&packet);
+ }
+ }
+ }
+
/// `ParticleTypes.STREAM_CODEC`'s value for `options`: the type's
/// network id and the data it carries (`state` for the block particles).
/// None while not serving, or for a particle whose data isn't sent from
@@ -68,7 +95,11 @@ impl Game<'_> {
/// The options a server's particle stands for (None for a type or data
/// this client doesn't draw).
- fn received_particle(&mut self, p: &Particle, at: [f64; 3]) -> Option {
+ pub(super) fn received_particle(
+ &mut self,
+ p: &Particle,
+ at: [f64; 3],
+ ) -> Option {
let name = self
.remote
.as_ref()?
diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs
index 467c4537c..8e756b7be 100644
--- a/crates/horizon-client/src/game/lan_pvp.rs
+++ b/crates/horizon-client/src/game/lan_pvp.rs
@@ -32,6 +32,8 @@ pub(super) enum Victim {
/// The attacker's side of the hit.
pub(super) struct Strike {
+ /// The attacking guest, kept after their turn through `as_guest` ends.
+ attacker: Option,
amount: f32,
scale: f32,
crit: bool,
@@ -119,6 +121,7 @@ impl Game<'_> {
}
self.swing_arm();
Some(Strike {
+ attacker: self.lan_acting,
amount,
scale,
crit,
@@ -242,14 +245,46 @@ impl Game<'_> {
if hurt && strength > 0.0 {
g.knock_back_player(f64::from(strength), xd, zd);
}
- hurt
+ // The victim's thorns, dealt to the attacker below.
+ let thorns = if hurt { g.thorns_damage() } else { Vec::new() };
+ (hurt, thorns)
};
- let hurt = self.ui.rules.bool("pvp")
- && harm
- && match victim {
+ let (hurt, thorns) = if self.ui.rules.bool("pvp") && harm {
+ match victim {
Victim::Host => land(self),
- Victim::Guest(conn) => self.guest_struck_by(host, conn, land).unwrap_or(false),
+ Victim::Guest(conn) => self.guest_struck_by(host, conn, land).unwrap_or_default(),
+ }
+ } else {
+ Default::default()
+ };
+ if hurt && s.crit {
+ let target = match victim {
+ Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)),
+ Victim::Guest(conn) => host
+ .hub
+ .guest(conn)
+ .and_then(|g| g.motion.as_deref().map(|p| (g.entity_id, p))),
};
+ if let Some((id, p)) = target {
+ let d = p.dimensions;
+ self.critical_hit(
+ s.attacker,
+ id,
+ [p.position.x, p.position.y, p.position.z],
+ f64::from(d.width),
+ f64::from(d.height),
+ );
+ }
+ }
+ // `Enchantment.doPostAttack`: thorns hurt the attacking player.
+ for damage in thorns {
+ match s.attacker {
+ None => self.hurt_player_by("minecraft:thorns", damage),
+ Some(conn) => {
+ self.guest_hit_by(host, conn, |g| g.hurt_player_by("minecraft:thorns", damage));
+ }
+ }
+ }
let sound = match (hurt, s.crit, s.scale > 0.9) {
(false, ..) => "minecraft:entity.player.attack.nodamage",
(true, true, _) => "minecraft:entity.player.attack.crit",
diff --git a/crates/horizon-client/src/game/lan_trading.rs b/crates/horizon-client/src/game/lan_trading.rs
index 1bec9809d..7beeeba2f 100644
--- a/crates/horizon-client/src/game/lan_trading.rs
+++ b/crates/horizon-client/src/game/lan_trading.rs
@@ -144,15 +144,16 @@ impl Game<'_> {
.offers
.iter()
.filter_map(|o| {
- let cost =
- |st: &ItemStack, hub: &mut horizon_client::lan::hub::Hub| play::NetCost {
- item: hub.item_id(&st.item),
- count: st.count as i32,
- };
+ let cost = |st: &ItemStack, hub: &mut horizon_client::lan::hub::Hub| {
+ hub.stack(&Some(st.clone())).map(play::NetCost::from)
+ };
Some(play::NetOffer {
- cost_a: cost(&o.base_cost_a.stack, &mut host.hub),
+ cost_a: cost(&o.base_cost_a.stack, &mut host.hub)?,
result: host.hub.stack(&Some(o.result.clone()))?,
- cost_b: o.cost_b.as_ref().map(|b| cost(&b.stack, &mut host.hub)),
+ cost_b: match &o.cost_b {
+ Some(b) => Some(cost(&b.stack, &mut host.hub)?),
+ None => None,
+ },
out_of_stock: o.out_of_stock(),
uses: o.uses,
max_uses: o.max_uses,
diff --git a/crates/horizon-client/src/game/lan_vehicles.rs b/crates/horizon-client/src/game/lan_vehicles.rs
index f16a1e37d..00795aa62 100644
--- a/crates/horizon-client/src/game/lan_vehicles.rs
+++ b/crates/horizon-client/src/game/lan_vehicles.rs
@@ -56,6 +56,13 @@ impl Game<'_> {
let (lo, hi) = corners(a.bounds());
return Some((lo, hi, at(a.position)));
}
+ if let Some(c) = self.cushions.iter().find(|c| c.id == id) {
+ let (lo, hi) = corners(Aabb::new(
+ Vec3::new(c.position.x - 0.5, c.position.y, c.position.z - 0.5),
+ Vec3::new(c.position.x + 0.5, c.position.y + 0.25, c.position.z + 0.5),
+ ));
+ return Some((lo, hi, at(c.position)));
+ }
if let Some(f) = self.item_frames.iter().find(|f| f.id == id) {
let (lo, hi) = f.bounds();
return Some((lo, hi, centre(f.pos)));
@@ -98,9 +105,10 @@ impl Game<'_> {
let boat = self.boats.iter().position(|b| b.id == vehicle);
let cart = self.carts.iter().any(|c| c.id == vehicle);
let mount = self.mobs.iter().any(|m| m.id == vehicle);
+ let cushion = self.cushions.iter().any(|c| c.id == vehicle);
// The vehicle is gone (broken, in another level) or the rider died:
// its client drops it with the entity or the death screen.
- if dead || (boat.is_none() && !cart && !mount) {
+ if dead || (boat.is_none() && !cart && !mount && !cushion) {
let g = &mut host.hub.guests[gi];
(g.vehicle, g.vehicle_good) = (None, None);
return;
@@ -115,6 +123,17 @@ impl Game<'_> {
// Getting out goes through leave_guest, which tells the client and
// teleports it (ServerPlayer.dismountTo).
let seat = self.as_guest(host, conn, |game| {
+ // A cushion does not move: the rider sits on it until it sneaks
+ // (`Cushion.removePassenger` plays the get-up sound).
+ if game.cushions.iter().any(|c| Some(c.id) == game.riding) {
+ if keys.shift {
+ game.tick_cushion_riding(keys);
+ return None;
+ }
+ let c = game.cushions.iter().find(|c| Some(c.id) == game.riding)?;
+ let p = c.seat();
+ return Some([p.x, p.y, p.z]);
+ }
if let Some(i) = game.boats.iter().position(|b| Some(b.id) == game.riding) {
if keys.shift {
game.dismount(i);
@@ -168,6 +187,12 @@ impl Game<'_> {
.iter()
.find(|c| c.id == vehicle)
.map(|c| (c.position, c.position.add_vector(Vec3::new(0.0, SEAT, 0.0))))
+ })
+ .or_else(|| {
+ self.cushions
+ .iter()
+ .find(|c| c.id == vehicle)
+ .map(|c| (c.position, c.seat()))
});
if let Some((p, seat)) = at {
let g = &mut host.hub.guests[gi];
diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs
index e8a8cfb59..29bf6d511 100644
--- a/crates/horizon-client/src/game/levels.rs
+++ b/crates/horizon-client/src/game/levels.rs
@@ -3,8 +3,8 @@
//! The game's tick code reads one level: the one in place, held in `Game`'s
//! own fields (the world, its streaming and save, block ticks, entities).
//! A server (the dedicated server and single player's server thread) keeps
-//! the other dimensions' levels here and ticks each one that has players by
-//! swapping it into place (`enter_level`), the way `as_guest` swaps a player
+//! the other dimensions' levels here and ticks each one with players or forced
+//! chunks by swapping it into place (`enter_level`), the way `as_guest` swaps a player
//! in, so the tick code runs unchanged, one level at a time. The in-frame
//! game holds one level, which follows its player (`enter_dimension`).
//!
@@ -50,6 +50,7 @@ pub(super) struct Parked {
paintings: Vec,
item_frames: Vec,
armor_stands: Vec,
+ cushions: Vec,
others: Vec,
boats: Vec,
carts: Vec,
@@ -74,6 +75,7 @@ pub(super) struct Parked {
lan_events: Vec<(i32, [i32; 3], i32, Option)>,
lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
lan_entity_events: Vec<(i32, i8, [f64; 3])>,
+ lan_critical_hits: Vec<(Option, i32)>,
/// Only the per-level parts of these are used (`swap_level`).
anims: BlockEntityAnims,
raiding: Raiding,
@@ -107,6 +109,19 @@ pub(super) struct Levels {
parked: HashMap,
}
+impl Levels {
+ /// The chunks of each level not in place (capability `world` lends
+ /// them to server mods for a call).
+ #[cfg_attr(not(feature = "mods"), allow(dead_code))]
+ pub(super) fn parked_chunks(
+ &mut self,
+ ) -> impl Iterator
- {
+ self.parked
+ .iter_mut()
+ .map(|(d, p)| (*d, &mut p.world.chunks))
+ }
+}
+
impl Game<'_> {
/// A new level for `dim`, opened from the save (`MinecraftServer.createLevels`).
fn open_level(&self, dim: Dim) -> Result {
@@ -135,6 +150,7 @@ impl Game<'_> {
paintings: Vec::new(),
item_frames: Vec::new(),
armor_stands: Vec::new(),
+ cushions: Vec::new(),
others: Vec::new(),
boats: Vec::new(),
carts: Vec::new(),
@@ -159,6 +175,7 @@ impl Game<'_> {
lan_events: Vec::new(),
lan_block_events: Vec::new(),
lan_entity_events: Vec::new(),
+ lan_critical_hits: Vec::new(),
anims: Default::default(),
raiding: Default::default(),
sculk: Default::default(),
@@ -185,6 +202,7 @@ impl Game<'_> {
swap(&mut self.paintings, &mut p.paintings);
swap(&mut self.item_frames, &mut p.item_frames);
swap(&mut self.armor_stands, &mut p.armor_stands);
+ swap(&mut self.cushions, &mut p.cushions);
swap(&mut self.others, &mut p.others);
swap(&mut self.boats, &mut p.boats);
swap(&mut self.carts, &mut p.carts);
@@ -209,6 +227,7 @@ impl Game<'_> {
swap(&mut self.lan_events, &mut p.lan_events);
swap(&mut self.lan_block_events, &mut p.lan_block_events);
swap(&mut self.lan_entity_events, &mut p.lan_entity_events);
+ swap(&mut self.lan_critical_hits, &mut p.lan_critical_hits);
let (a, b) = (&mut self.be_anims, &mut p.anims);
swap(&mut a.chests, &mut b.chests);
swap(&mut a.books, &mut b.books);
@@ -219,6 +238,7 @@ impl Game<'_> {
swap(&mut a.pots, &mut b.pots);
swap(&mut a.gateways, &mut b.gateways);
swap(&mut a.gateway_servers, &mut b.gateway_servers);
+ swap(&mut a.conduit_servers, &mut b.conduit_servers);
self.raiding.swap_level(&mut p.raiding);
self.sculk.swap_level(&mut p.sculk);
self.creaking.swap_level(&mut p.creaking);
@@ -287,8 +307,8 @@ impl Game<'_> {
}
/// One server tick (`MinecraftServer.tickServer`): each level with
- /// players in turn (`tickChildren`), its chunks streamed and loaded and
- /// its world ticked. The first pass reads the network and runs the
+ /// players or forced chunks in turn (`tickChildren`), its chunks streamed
+ /// and loaded and its world ticked. The first pass reads the network and runs the
/// tick's shared parts (the clock, the weather, functions, the autosave);
/// the next ones only their level. While `paused`, only the connections
/// run.
@@ -307,6 +327,8 @@ impl Game<'_> {
};
self.update_dedicated_streaming();
self.update_world();
+ // What server mods set in this level since its last tick.
+ self.apply_mod_block_writes();
result = if paused {
self.tick_lan(true);
Ok(())
@@ -390,7 +412,7 @@ impl Game<'_> {
/// The levels this server tick runs, in `MinecraftServer.levels` order
/// (the Overworld, the Nether, the End): every level with a player in
- /// it or a `/pregen` task, or the Overworld while nobody is online.
+ /// it, forced chunks or a `/pregen` task, or the Overworld while idle.
pub(super) fn levels_to_tick(&self) -> Vec {
let guests = self
.lan
@@ -399,7 +421,17 @@ impl Game<'_> {
let mut dims: Vec = [Dim::Overworld, Dim::Nether, Dim::End]
.into_iter()
.filter(|d| {
- guests.iter().any(|g| g.dimension == d.id()) || self.pregen_level() == Some(*d)
+ let forced = if *d == self.dim {
+ !self.streaming.forced.is_empty()
+ } else {
+ self.levels
+ .parked
+ .get(d)
+ .is_some_and(|p| !p.streaming.forced.is_empty())
+ };
+ guests.iter().any(|g| g.dimension == d.id())
+ || forced
+ || self.pregen_level() == Some(*d)
})
.collect();
if dims.is_empty() {
diff --git a/crates/horizon-client/src/game/lightning.rs b/crates/horizon-client/src/game/lightning.rs
index 916bd2a0a..8a3ac2745 100644
--- a/crates/horizon-client/src/game/lightning.rs
+++ b/crates/horizon-client/src/game/lightning.rs
@@ -74,14 +74,74 @@ impl Game<'_> {
self.spawn_bolt(at, trap);
}
}
- /// `findLightningTargetAround`: a living entity under open sky in the
- /// column (3 blocks around), else the top of the column.
+ /// `ServerLevel.findLightningRod`: `PoiManager.findClosest` over the
+ /// lightning rod points of interest within 128 blocks of `center` whose
+ /// block is the top (`WORLD_SURFACE`) of its column; the strike lands one
+ /// above it. Horizon keeps no point-of-interest index, so this scans the
+ /// loaded chunks the way `/locate poi` does.
+ fn find_lightning_rod(&self, center: [i32; 3]) -> Option<[i32; 3]> {
+ const RANGE: i32 = 128;
+ let facts = self.res.facts();
+ let mut is_rod: std::collections::HashMap = std::collections::HashMap::new();
+ let mut best: Option<(i64, [i32; 3])> = None;
+ let (cx0, cz0) = ((center[0] - RANGE) >> 4, (center[2] - RANGE) >> 4);
+ let (cx1, cz1) = ((center[0] + RANGE) >> 4, (center[2] + RANGE) >> 4);
+ for cx in cx0..=cx1 {
+ for cz in cz0..=cz1 {
+ let Some(chunk) = self.world.chunks.get(&(cx, cz)) else {
+ continue;
+ };
+ for (i, section) in chunk.sections.iter().enumerate() {
+ let mut rod = |state: u32| {
+ *is_rod.entry(state).or_insert_with(|| {
+ facts
+ .get(horizon_world::registry::BlockStateId(state))
+ .name
+ .ends_with("lightning_rod")
+ })
+ };
+ if !section.blocks.maybe_has(&mut rod) {
+ continue;
+ }
+ let base_y = horizon_client::chunk::MIN_Y + 16 * i as i32;
+ for j in 0..4096 {
+ if !rod(section.get(j)) {
+ continue;
+ }
+ let p = [
+ cx * 16 + (j & 15) as i32,
+ base_y + (j >> 8) as i32,
+ cz * 16 + ((j >> 4) & 15) as i32,
+ ];
+ let d = [p[0] - center[0], p[1] - center[1], p[2] - center[2]]
+ .map(|d| i64::from(d) * i64::from(d))
+ .iter()
+ .sum::();
+ if d > i64::from(RANGE * RANGE) || best.is_some_and(|(b, _)| d >= b) {
+ continue;
+ }
+ let surface = self.world.world_surface(p[0], p[2], |s| facts.is_air(s));
+ if p[1] == surface - 1 {
+ best = Some((d, p));
+ }
+ }
+ }
+ }
+ }
+ best.map(|(_, p)| [p[0], p[1] + 1, p[2]])
+ }
+ /// `findLightningTargetAround`: the closest lightning rod, else a living
+ /// entity under open sky in the column (3 blocks around), else the top of
+ /// the column.
fn lightning_target(&mut self, x: i32, z: i32) -> Option<[i32; 3]> {
if !self.world.loaded(x, z) {
return None;
}
let top =
self.with_level(|b, level, _| b.motion_blocking_top(level, BlockPos::new(x, 0, z)));
+ if let Some(rod) = self.find_lightning_rod([x, top.y, z]) {
+ return Some(rod);
+ }
let sees_sky = |g: &Self, p: [i32; 3]| g.world.light(p[0], p[1], p[2]) >> 4 == 15;
let mut candidates: Vec<[i32; 3]> = self
.mobs
@@ -162,11 +222,9 @@ impl Game<'_> {
converted: Vec::new(),
});
}
- /// `spawnFire`: fire at the strike point and `extra` random neighbours.
+ /// `spawnFire`: fire at the strike point and `extra` random neighbours,
+ /// wherever `BaseFireBlock.getState` fire can survive.
fn bolt_fire(&mut self, at: [f64; 3], extra: i32) {
- if self.ui.difficulty < 2 {
- return;
- }
let base = [
at[0].floor() as i32,
at[1].floor() as i32,
@@ -183,18 +241,13 @@ impl Game<'_> {
if !self.res.facts().is_air(state) {
continue;
}
- // BaseFireBlock.getState: soul fire on soul soil and sand.
- let below = self.res.facts().get(self.world.block(p[0], p[1] - 1, p[2]));
- let name = if matches!(&*below.name, "minecraft:soul_soil" | "minecraft:soul_sand") {
- "minecraft:soul_fire"
- } else {
- "minecraft:fire"
- };
- // FireBlock.canSurvive: a sturdy floor (flammable neighbours aside).
- if below.sturdy_full >> 1 & 1 == 0 {
- continue;
- }
- if let Some(fire) = self.pack.assets.registry.default_state(name) {
+ // BaseFireBlock.getState and FireBlock/SoulFireBlock.canSurvive.
+ let at = BlockPos::new(p[0], p[1], p[2]);
+ let fire = self.with_level(|b, level, ticks| {
+ let fire = b.fire_state_for(level, ticks, at);
+ b.can_survive(level, ticks, at, fire).then_some(fire)
+ });
+ if let Some(fire) = fire {
let _ = self.level_set(p, fire);
}
}
@@ -219,7 +272,10 @@ impl Game<'_> {
pitch,
);
if !b.visual_only {
- self.bolt_fire(b.at, 4);
+ // Only Normal and Hard start fires with the strike itself.
+ if self.ui.difficulty >= 2 {
+ self.bolt_fire(b.at, 4);
+ }
self.strike_rod(b.at);
}
}
diff --git a/crates/horizon-client/src/game/mace.rs b/crates/horizon-client/src/game/mace.rs
index 8ad5e76c3..34c968980 100644
--- a/crates/horizon-client/src/game/mace.rs
+++ b/crates/horizon-client/src/game/mace.rs
@@ -24,7 +24,7 @@ const KNOCKBACK_POWER: f32 = 0.7;
/// `Entity.isAlliedTo` between the player (`player` its UUID) and a mob
/// without teams: `TamableAnimal.considersEntityAsAlly` (a pet it tamed) and
/// `Allay.considersEntityAsAlly` (an allay that likes it).
-fn ally_of_player(m: &Mob, player: Option<[i32; 4]>) -> bool {
+pub(super) fn ally_of_player(m: &Mob, player: Option<[i32; 4]>) -> bool {
let tamable = matches!(
m.species(),
Species::Wolf
diff --git a/crates/horizon-client/src/game/machines.rs b/crates/horizon-client/src/game/machines.rs
index 8742962e9..bb936744b 100644
--- a/crates/horizon-client/src/game/machines.rs
+++ b/crates/horizon-client/src/game/machines.rs
@@ -159,8 +159,10 @@ impl Containers<'_> {
});
}
let entity = self.world.block_entities.get(&pos)?;
- // A beehive keeps bees, not items: it is no `Container`.
- if matches!(entity, BlockEntity::Beehive(_)) {
+ // A beehive keeps bees, not items, and a campfire cooks its own: neither
+ // is a `Container` (HopperBlockEntity.getContainerAt), so a dropper drops
+ // in front of them and a hopper leaves them alone.
+ if matches!(entity, BlockEntity::Beehive(_) | BlockEntity::Campfire(_)) {
return None;
}
let kind = match (entity, name) {
diff --git a/crates/horizon-client/src/game/minecarts.rs b/crates/horizon-client/src/game/minecarts.rs
index a19b6df73..072059e49 100644
--- a/crates/horizon-client/src/game/minecarts.rs
+++ b/crates/horizon-client/src/game/minecarts.rs
@@ -87,9 +87,12 @@ pub(super) struct Minecart {
pub fuse: i32,
/// Hopper minecarts: an unpowered activator rail enables them.
pub enabled: bool,
+ /// Chest minecarts: the loot table rolled into `items` on load, saved
+ /// again while the items are still that roll.
+ pub loot: Option,
}
-const WIDTH: f64 = 0.98;
-const HEIGHT: f64 = 0.7;
+pub(super) const WIDTH: f64 = 0.98;
+pub(super) const HEIGHT: f64 = 0.7;
/// AbstractMinecart.getDefaultDisplayOffset, in sixteenths of a block.
fn display_offset(kind: CartKind) -> f64 {
if kind == CartKind::Hopper { 1.0 } else { 6.0 }
@@ -97,7 +100,7 @@ fn display_offset(kind: CartKind) -> f64 {
/// The minecart's passenger attachment minus Player.DEFAULT_VEHICLE_ATTACHMENT.
pub(super) const SEAT: f64 = 0.1875 - 0.6;
/// The placeholder container key under which an open cart's items live.
-pub(super) const CART_KEY_Y: i32 = -100_000;
+pub(super) const CART_KEY_Y: i32 = horizon_client::lan::menu::VEHICLE_KEY_Y;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub(super) enum Shape {
@@ -182,6 +185,7 @@ impl Minecart {
push: [0.0; 2],
fuse: -1,
enabled: true,
+ loot: None,
}
}
pub fn bounds(&self) -> Aabb {
@@ -1527,6 +1531,12 @@ impl Minecart {
}
CartKind::Rideable => {}
}
+ // A loaded loot table goes back while the items are still its roll;
+ // otherwise the items replace it, as vanilla's unpackLootTable does.
+ if !self.loot.as_ref().is_some_and(|l| l.restore(map)) {
+ map.remove(&JavaString::from("LootTable"));
+ map.remove(&JavaString::from("LootTableSeed"));
+ }
}
tag
}
diff --git a/crates/horizon-client/src/game/mods.rs b/crates/horizon-client/src/game/mods.rs
index 156467e7a..807d052ae 100644
--- a/crates/horizon-client/src/game/mods.rs
+++ b/crates/horizon-client/src/game/mods.rs
@@ -17,6 +17,7 @@ use std::{path::PathBuf, time::Duration};
#[cfg(feature = "mods")]
use {
super::Screen,
+ super::{execution_role::ExecutionRole, lan::LanHost, server_mods::ModEvent},
horizon_client::{
extras::Corner,
extras_hud,
@@ -28,7 +29,8 @@ use {
ui,
},
horizon_mods::{
- Clock, ModKey, Mods, Output, Player, Runs, Snapshot, Status, UiScreen, UiWidget,
+ Clock, ModKey, Mods, Output, Player, Runs, ServerPlayer, Snapshot, Status, UiScreen,
+ UiWidget,
},
std::time::Instant,
winit::{event::MouseButton, keyboard::KeyCode},
@@ -52,6 +54,23 @@ pub(super) struct ModsState {
/// The chat's command tree while a running mod owns commands.
#[cfg(feature = "mods")]
tree: Option,
+ /// A server mod runs here: what players do is queued for it.
+ #[cfg(feature = "mods")]
+ pub(super) server: bool,
+ /// The players server mods saw last tick, for joins and leaves.
+ #[cfg(feature = "mods")]
+ pub(super) players: Vec,
+ /// What players did this tick, for server mods at its end.
+ #[cfg(feature = "mods")]
+ pub(super) events: Vec,
+ /// A running server mod has capability `world`: its calls get the
+ /// levels' chunks to read.
+ #[cfg(feature = "mods")]
+ pub(super) world: bool,
+ /// Blocks server mods set, by dimension, made before that level's next
+ /// tick.
+ #[cfg(feature = "mods")]
+ pub(super) block_writes: Vec<(String, horizon_mods::BlockChange)>,
/// `command.run` lines for this window's own world, run on the next tick:
/// run at once, their chat lines would reach the mods while their output
/// is still being shown, and a mod answering its own lines would recurse.
@@ -282,7 +301,7 @@ impl Game<'_> {
.collect();
let enabled = &self.settings.mods.enabled;
let on = |id: &str| enabled.contains(id) || dev_ids.iter().any(|d| d == id);
- let mods = Mods::load_for(Runs::Client, &paths, on, vanilla_command);
+ let mods = Mods::load_for(self.mod_runs(), &paths, on, vanilla_command);
self.mods.mods = mods;
let chosen = &self.settings.mods;
self.mods.mods.set_bindings(|id| chosen.keys_of(id));
@@ -294,8 +313,19 @@ impl Game<'_> {
self.sync_mod_commands();
self.show_mod_output();
}
+ /// Which mods this game runs: a server the server mods, the window
+ /// client mods, and both when it simulates the world itself (in-frame).
+ fn mod_runs(&self) -> Runs {
+ match self.options.execution_role {
+ ExecutionRole::IntegratedServer | ExecutionRole::DedicatedServer => Runs::Server,
+ ExecutionRole::Client if self.options.server_thread => Runs::Client,
+ ExecutionRole::Client => Runs::Both,
+ }
+ }
/// The Mods page's rows, from what loaded.
fn list_mods(&mut self) {
+ self.mods.server = self.mods.mods.runs_server();
+ self.mods.world = self.mods.mods.wants_world();
let dev = &self.mods.dev;
self.settings.mods.installed = self
.mods
@@ -381,8 +411,18 @@ impl Game<'_> {
self.start_mods();
}
}
- /// What mods read this tick (or frame, for mods with a `frame` hook).
+ /// What mods read this tick (or frame, for mods with a `frame` hook): the
+ /// server's players as they were at the last tick's end.
fn mod_snapshot(&mut self) -> Snapshot {
+ let players = if self.mods.server {
+ self.mods.players.clone()
+ } else {
+ Vec::new()
+ };
+ self.mod_snapshot_with(players)
+ }
+ /// What mods read, with these players on the server.
+ pub(super) fn mod_snapshot_with(&mut self, players: Vec) -> Snapshot {
let player = self.player.as_ref().map(|p| Player {
x: p.position.x,
y: p.position.y,
@@ -427,7 +467,7 @@ impl Game<'_> {
mappings,
cps,
font_widths: self.mods.font_widths.clone(),
- players: Vec::new(),
+ players,
view_hit: self.mod_view_hit(),
recipes,
known_recipes,
@@ -553,23 +593,32 @@ impl Game<'_> {
self.mods.mods.tick(self.ticks);
self.show_mod_output();
}
- /// Once per frame: the frame hook, and dev mods' rebuilds.
- pub(super) fn mods_frame(&mut self, elapsed: Duration) {
- if !self.mods.dev.is_empty()
- && self
+ /// Restarts the dev mods rebuilt since the last check, once a second.
+ pub(super) fn reload_dev_mods(&mut self) {
+ if self.mods.dev.is_empty()
+ || self
.mods
.checked
- .is_none_or(|t| t.elapsed() >= RELOAD_CHECK)
+ .is_some_and(|t| t.elapsed() < RELOAD_CHECK)
{
- self.mods.checked = Some(Instant::now());
- if self.mods.mods.reload_changed(vanilla_command) {
- let chosen = &self.settings.mods;
- self.mods.mods.set_bindings(|id| chosen.keys_of(id));
- self.list_mods();
- self.sync_mod_commands();
+ return;
+ }
+ self.mods.checked = Some(Instant::now());
+ if self.mods.mods.reload_changed(vanilla_command) {
+ let chosen = &self.settings.mods;
+ self.mods.mods.set_bindings(|id| chosen.keys_of(id));
+ self.list_mods();
+ self.sync_mod_commands();
+ if self.options.execution_role.is_client() {
self.system_message(Text::literal("Mods reloaded").with_color(text::GRAY));
+ } else {
+ log::info!("Horizon: mods reloaded");
}
}
+ }
+ /// Once per frame: the frame hook, and dev mods' rebuilds.
+ pub(super) fn mods_frame(&mut self, elapsed: Duration) {
+ self.reload_dev_mods();
if !self.mods.mods.is_running() {
return;
}
@@ -600,8 +649,13 @@ impl Game<'_> {
self.mods.mods.chat(line);
self.show_mod_output();
}
- /// Chat lines, command feedback and stopped mods, into the chat.
- fn show_mod_output(&mut self) {
+ /// What mods showed: client mods' lines into the chat, server mods'
+ /// to their players.
+ pub(super) fn show_mod_output(&mut self) {
+ self.route_mod_output(None);
+ }
+ /// [`Game::show_mod_output`], with the hub when it is out of `self.lan`.
+ pub(super) fn route_mod_output(&mut self, mut host: Option<&mut LanHost>) {
for output in self.mods.mods.drain() {
let line = match output {
Output::Chat { name, text } => {
@@ -633,7 +687,18 @@ impl Game<'_> {
// `mod_ui_view` finds no widgets and the screen closes.
self.list_mods();
self.sync_mod_commands();
- Text::literal(format!("Mod {name} stopped: {reason}")).with_color(text::RED)
+ let line = format!("Mod {name} stopped: {reason}");
+ if self.options.dedicated.is_some() {
+ super::dedicated::log("WARN", &line);
+ }
+ Text::literal(line).with_color(text::RED)
+ }
+ server @ (Output::Tell { .. }
+ | Output::Broadcast { .. }
+ | Output::Reply { .. }
+ | Output::SetBlocks { .. }) => {
+ self.route_server_output(host.as_deref_mut(), server);
+ continue;
}
Output::OpenScreen { owner } => {
self.open_mod_screen(owner, false);
@@ -649,20 +714,8 @@ impl Game<'_> {
}
continue;
}
- // Server mods' lines: this game runs no server mod yet.
- Output::Tell { .. } | Output::Broadcast { .. } | Output::Reply { .. } => continue,
};
- // Not through system_message: a mod must not hear its own lines.
- // Written by this client, so the Chat option doesn't hide it.
- let focused = self.screen == Screen::Chat;
- self.ui.chat.add(
- &self.gui.atlas,
- line,
- None,
- horizon_client::chat::ChatSource::Client,
- self.ticks,
- focused,
- );
+ self.add_mod_chat_line(line);
}
// A mod may set or clear its settings page in any call, not only
// while loading: its row's Settings button follows.
@@ -671,6 +724,20 @@ impl Game<'_> {
row.has_settings = e.has_ui_settings();
}
}
+ /// A mod's line in the window's chat; not through system_message: a mod
+ /// must not hear its own lines.
+ /// Written by this client, so the Chat option doesn't hide it.
+ pub(super) fn add_mod_chat_line(&mut self, line: Text) {
+ let focused = self.screen == Screen::Chat;
+ self.ui.chat.add(
+ &self.gui.atlas,
+ line,
+ None,
+ horizon_client::chat::ChatSource::Client,
+ self.ticks,
+ focused,
+ );
+ }
/// The mods' HUD panels, stacked with the extras in their corners.
pub(super) fn draw_mod_panels(&self, batch: &mut HudBatch, corners: &mut Corners) {
for panel in self.mods.mods.panels() {
diff --git a/crates/horizon-client/src/game/music.rs b/crates/horizon-client/src/game/music.rs
index 6f8b5e7ae..fa5e71f7b 100644
--- a/crates/horizon-client/src/game/music.rs
+++ b/crates/horizon-client/src/game/music.rs
@@ -91,7 +91,7 @@ impl Game<'_> {
})
}
/// `isEyeInFluid(WATER)`: the eye inside the water of its block column.
- fn eye_in_water(&self, x: f64, eye_y: f64, z: f64) -> bool {
+ pub(super) fn eye_in_water(&self, x: f64, eye_y: f64, z: f64) -> bool {
let (bx, by, bz) = (x.floor() as i32, eye_y.floor() as i32, z.floor() as i32);
let f = self.res.facts().get(self.world.block(bx, by, bz));
if f.fluid != Fluid::Water {
diff --git a/crates/horizon-client/src/game/names.rs b/crates/horizon-client/src/game/names.rs
index f249bd01f..9f7561e53 100644
--- a/crates/horizon-client/src/game/names.rs
+++ b/crates/horizon-client/src/game/names.rs
@@ -86,6 +86,10 @@ impl Game<'_> {
.iter()
.filter_map(|m| Some((m, m.custom_name.clone()?, false)));
let players = players.into_iter().map(|(m, name)| (m, name, true));
+ // Who is riding whom: asked once per tag below, and rescanning every mob
+ // for each tag made this quadratic in the number of loaded mobs.
+ let ridden: std::collections::HashSet =
+ self.mobs.iter().filter_map(|o| o.extra.mount).collect();
for (m, name, player) in named.chain(players) {
if !m.alive() {
continue;
@@ -134,7 +138,7 @@ impl Game<'_> {
invisible_to_viewer: invisible,
hud_hidden: self.ui.hide_gui,
is_camera: false,
- is_vehicle: self.mobs.iter().any(|o| o.extra.mount == Some(m.id)),
+ is_vehicle: ridden.contains(&m.id),
};
// MobRenderer.shouldShowName: a visible name, or the mob under the
// crosshair; players (LivingEntityRenderer) need neither.
@@ -310,7 +314,7 @@ impl Game<'_> {
}
/// The lines of one name tag, `o` from the camera: the text at
/// `text_alpha` in its layer, on the translucent black background
- /// (unlit, a hair behind) when `background`.
+ /// (in `text_layer` like the glyphs, a hair behind) when `background`.
#[allow(clippy::too_many_arguments)]
fn name_tag_quads(
&self,
@@ -382,7 +386,7 @@ impl Game<'_> {
[white.u0, white.v0, white.u1, white.v1],
BACKGROUND,
true,
- 2,
+ text_layer,
);
}
let mut x = x0;
diff --git a/crates/horizon-client/src/game/nether_portal.rs b/crates/horizon-client/src/game/nether_portal.rs
index 353ad216c..87ba81c93 100644
--- a/crates/horizon-client/src/game/nether_portal.rs
+++ b/crates/horizon-client/src/game/nether_portal.rs
@@ -454,11 +454,24 @@ impl Game<'_> {
for m in &self.mobs {
self.portals.before.insert(m.id, m.position);
}
+ for b in &self.boats {
+ self.portals.before.insert(b.id, b.position);
+ }
+ for c in &self.carts {
+ self.portals.before.insert(c.id, c.position);
+ }
let ids: Vec<(u32, bool)> = self
.dropped
.iter()
.map(|e| (e.id, true))
.chain(self.mobs.iter().map(|m| (m.id, self.mob_can_use_portal(m))))
+ .chain(
+ self.boats
+ .iter()
+ .map(|b| b.id)
+ .chain(self.carts.iter().map(|c| c.id))
+ .map(|id| (id, !self.vehicle_occupied(id))),
+ )
.collect();
let present: std::collections::HashSet = ids.iter().map(|(id, _)| *id).collect();
self.portals.entities.retain(|id, _| present.contains(id));
@@ -501,8 +514,15 @@ impl Game<'_> {
&& self.riding != Some(m.id)
&& m.species() != Species::Wither
}
- /// `NetherPortalBlock.entityInside` for the items and mobs that moved this
- /// tick: the portal blocks their box swept through.
+ /// Whether the player, a server player or a mob rides vehicle `id`.
+ fn vehicle_occupied(&self, id: u32) -> bool {
+ self.riding == Some(id)
+ || self.ridden_by_guest(id)
+ || self.mobs.iter().any(|m| m.extra.mount == Some(id))
+ }
+ /// `NetherPortalBlock.entityInside` for the items, mobs and empty boats
+ /// and minecarts that moved this tick: the portal blocks their box swept
+ /// through.
pub(super) fn find_entity_portals(&mut self) {
if self.remote.is_some() {
return;
@@ -519,8 +539,23 @@ impl Game<'_> {
.filter(|m| self.mob_can_use_portal(m))
.map(|m| (m.id, m.position, m.width(), m.height()))
.collect();
+ let vehicles: Vec<(u32, Vec3, f32, f32)> = self
+ .boats
+ .iter()
+ .map(|b| (b.id, b.position, super::boats::WIDTH, super::boats::HEIGHT))
+ .chain(self.carts.iter().map(|c| {
+ (
+ c.id,
+ c.position,
+ super::minecarts::WIDTH,
+ super::minecarts::HEIGHT,
+ )
+ }))
+ .filter(|(id, ..)| !self.vehicle_occupied(*id))
+ .map(|(id, at, w, h)| (id, at, w as f32, h as f32))
+ .collect();
let mut portal_sections = std::mem::take(&mut self.portals.sections);
- for (id, to, width, height) in items.into_iter().chain(mobs) {
+ for (id, to, width, height) in items.into_iter().chain(mobs).chain(vehicles) {
let from = self.portals.before.get(&id).copied().unwrap_or(to);
if let Some(pos) = self.swept_portal(from, to, width, height, &mut portal_sections) {
inside.push((id, pos));
@@ -678,6 +713,44 @@ impl Game<'_> {
}
self.portals.arrivals.push(Arrival { plan, tag });
self.portals.dirty = true;
+ } else if let Some(i) = self.boats.iter().position(|b| b.id == id) {
+ let b = &self.boats[i];
+ let (width, height) = (super::boats::WIDTH as f32, super::boats::HEIGHT as f32);
+ let plan = self.portal_plan(entry, b.position, width, height, false);
+ if !self.may_enter(plan.dim) {
+ return;
+ }
+ let uuid = self.uuid_for(id);
+ let b = &self.boats[i];
+ let tag = horizon_client::entity_nbt::boat_to_nbt(
+ &b.entity_type(),
+ b.position,
+ b.velocity,
+ b.yaw,
+ uuid,
+ self.persist_raw(id),
+ b.chest.then_some(&b.items[..]),
+ );
+ self.boats.remove(i);
+ self.forget_entity(id);
+ self.portals.arrivals.push(Arrival { plan, tag });
+ self.portals.dirty = true;
+ } else if let Some(i) = self.carts.iter().position(|c| c.id == id) {
+ let c = &self.carts[i];
+ let (width, height) = (
+ super::minecarts::WIDTH as f32,
+ super::minecarts::HEIGHT as f32,
+ );
+ let plan = self.portal_plan(entry, c.position, width, height, false);
+ if !self.may_enter(plan.dim) {
+ return;
+ }
+ let uuid = self.uuid_for(id);
+ let tag = self.carts[i].to_nbt(uuid, self.persist_raw(id));
+ self.carts.remove(i);
+ self.forget_entity(id);
+ self.portals.arrivals.push(Arrival { plan, tag });
+ self.portals.dirty = true;
}
}
/// Entities waiting for the loaded dimension whose exit area is loaded:
diff --git a/crates/horizon-client/src/game/options.rs b/crates/horizon-client/src/game/options.rs
index 243eced5c..7ac4ae98b 100644
--- a/crates/horizon-client/src/game/options.rs
+++ b/crates/horizon-client/src/game/options.rs
@@ -257,6 +257,7 @@ impl Game<'_> {
lang::set(lang::Language::load(&[&root], code));
self.refresh_remote_language();
self.ui.chat.rescale(&self.gui.atlas);
+ self.creative_screen.forget_items();
}
/// Settings that Horizon applies beyond render distance, volume and GUI scale.
pub(super) fn apply_ui_settings(&mut self) {
@@ -268,6 +269,11 @@ impl Game<'_> {
r.animated_textures = s.horizon.animated_textures;
r.set_mipmap_levels(s.mipmap_levels.max(0) as u32);
r.set_world_post(s.horizon.resolution_scale as f32 / 100.0, s.horizon.fxaa);
+ r.set_hdr(
+ s.horizon.hdr,
+ s.horizon.hdr_paper_white as f32,
+ s.horizon.hdr_peak as f32,
+ );
}
// Window.updateFullscreenIfChanged: only a changed option asks the
// window to change, so applying settings never undoes a fullscreen
diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs
index ee57e9f2b..569c63083 100644
--- a/crates/horizon-client/src/game/packs.rs
+++ b/crates/horizon-client/src/game/packs.rs
@@ -163,7 +163,7 @@ impl Game<'_> {
self.pack.context.biomes.clone(),
self.pack.context.light.clone(),
)?;
- // Keep the working GPU resources, but release its exclusive window surface.
+ // Keep the working GPU resources, and hand its window surface over.
if let Some(renderer) = &mut self.renderer {
renderer.release_surface();
}
@@ -221,6 +221,8 @@ impl Game<'_> {
self.apply_ui_settings();
}
self.ui.chat.rescale(&self.gui.atlas);
+ // The creative screen survives the reload; item names may not.
+ self.creative_screen.forget_items();
Ok(())
}
}
diff --git a/crates/horizon-client/src/game/persist.rs b/crates/horizon-client/src/game/persist.rs
index 45ef8801f..b5e650e70 100644
--- a/crates/horizon-client/src/game/persist.rs
+++ b/crates/horizon-client/src/game/persist.rs
@@ -279,7 +279,8 @@ impl Game<'_> {
k if super::minecarts::CartKind::from_id(k).is_some() => {
let kind = super::minecarts::CartKind::from_id(k).unwrap();
let id = self.next_entity + 1;
- if let Some(c) = super::minecarts::Minecart::from_nbt(&tag, id, kind) {
+ if let Some(mut c) = super::minecarts::Minecart::from_nbt(&tag, id, kind) {
+ self.roll_cart_loot(&mut c, &tag);
self.next_entity = id;
self.remember(id, uuid, tag);
self.carts.push(c);
@@ -314,6 +315,13 @@ impl Game<'_> {
self.item_frames.push(f);
}
}
+ "minecraft:cushion" => {
+ self.next_entity += 1;
+ if let Some(c) = entity_nbt::cushion_from_nbt(&tag, self.next_entity) {
+ self.remember(c.id, uuid, tag);
+ self.cushions.push(c);
+ }
+ }
"minecraft:painting" => {
if let Some((pos, facing, variant)) = entity_nbt::painting_from_nbt(&tag)
&& let Some(v) = self.painting_variants.get(&variant).cloned()
@@ -527,6 +535,30 @@ impl Game<'_> {
pub(super) fn persist_raw(&self, id: u32) -> Option<&Tag> {
self.persist.raw.get(&id)
}
+ /// A loaded chest minecart with a loot table and no items: the table
+ /// rolled now, as generated containers are (Horizon does not unpack on
+ /// first open), and kept to save it again while unchanged.
+ fn roll_cart_loot(&self, cart: &mut super::minecarts::Minecart, tag: &Tag) {
+ let Some(table) = horizon_client::save::text(tag.get("LootTable")) else {
+ return;
+ };
+ if cart.items.is_empty() || cart.items.iter().any(Option::is_some) {
+ return;
+ }
+ let loot = horizon_client::structure_blocks::loot_data(&self.options.resources);
+ let p = cart.position;
+ let pos = (p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
+ let biome = self.biome_name_at(p).unwrap_or_default();
+ let seed = horizon_client::structure_blocks::loot_seed(tag);
+ cart.loot = Some(horizon_client::structure_blocks::roll_container(
+ &mut cart.items,
+ loot.as_deref(),
+ table,
+ seed,
+ pos,
+ &biome,
+ ));
+ }
fn remember(&mut self, id: u32, uuid: Option<[i32; 4]>, tag: Tag) {
self.restore_portal_cooldown(id, &tag);
if let Some(u) = uuid {
@@ -776,6 +808,18 @@ impl Game<'_> {
out.entry(chunk_of(at)).or_default().push(tag);
}
}
+ for c in &self.cushions {
+ if keys.contains(&chunk_of(c.position)) {
+ let uuid = self
+ .persist
+ .uuids
+ .get(&c.id)
+ .copied()
+ .unwrap_or_else(random_uuid);
+ let tag = entity_nbt::cushion_to_nbt(c, uuid, self.persist.raw.get(&c.id));
+ out.entry(chunk_of(c.position)).or_default().push(tag);
+ }
+ }
for p in &self.paintings {
let at = painting_center(p);
if keys.contains(&chunk_of(at)) {
@@ -868,6 +912,13 @@ impl Game<'_> {
}
keep
});
+ self.cushions.retain(|c| {
+ let keep = !gone(c.position);
+ if !keep {
+ removed.push(c.id);
+ }
+ keep
+ });
// Riders leave with their root vehicle, a boat's with the boat.
let leaving: HashSet = (0..self.mobs.len())
.filter(|&i| {
@@ -934,6 +985,7 @@ impl Game<'_> {
.chain(self.boats.iter().map(|e| e.id))
.chain(self.carts.iter().map(|e| e.id))
.chain(self.armor_stands.iter().map(|e| e.id))
+ .chain(self.cushions.iter().map(|e| e.id))
.chain(self.item_frames.iter().map(|e| e.id))
.chain(self.paintings.iter().map(|e| e.id))
.chain(self.others.iter().map(|e| e.id))
diff --git a/crates/horizon-client/src/game/pickups.rs b/crates/horizon-client/src/game/pickups.rs
index 1e19bcfc3..040a6f01b 100644
--- a/crates/horizon-client/src/game/pickups.rs
+++ b/crates/horizon-client/src/game/pickups.rs
@@ -155,6 +155,8 @@ mod tests {
value: 1,
age: 0,
on_ground: false,
+ count: 1,
+ ticks: 0,
}))
}
diff --git a/crates/horizon-client/src/game/piglins.rs b/crates/horizon-client/src/game/piglins.rs
index bcf9e6ab5..edfd9a3a0 100644
--- a/crates/horizon-client/src/game/piglins.rs
+++ b/crates/horizon-client/src/game/piglins.rs
@@ -4,18 +4,172 @@
use super::Game;
use horizon_client::{
items::ItemStack,
- mobs::{Species, Who, piglin::ADMIRE},
+ mobs::{
+ Mob, Species, Who,
+ finalize::{
+ SLOT_NAMES, set_drop_chance, set_item, set_slot_enchantments, slot_enchantments,
+ stored_drop_chance,
+ },
+ piglin::{ADMIRE, ATE_RECENTLY},
+ },
};
use horizon_core::{geometry::Vec3, random::RandomSource};
impl Game<'_> {
- fn piglin_loved(&self, item: &str) -> bool {
+ fn item_in_tag(&self, tag: &str, item: &str) -> bool {
self.res
.items()
.item_tags
- .get("minecraft:piglin_loved")
+ .get(tag)
.is_some_and(|t| t.contains(item))
}
+ fn piglin_loved(&self, item: &str) -> bool {
+ self.item_in_tag("minecraft:piglin_loved", item)
+ }
+ /// `PiglinAi.isLovedItem` or a preferred weapon (`Piglin.canReplaceCurrentItem`).
+ fn piglin_wanted(&self, item: &str) -> bool {
+ self.piglin_loved(item) || self.item_in_tag("minecraft:piglin_preferred_weapons", item)
+ }
+ /// The `SLOT_NAMES` index `getEquipmentSlotForItem` picks: armour goes
+ /// to its slot, anything else to the main hand.
+ fn piglin_slot(&self, item: &str) -> usize {
+ let slot = self
+ .res
+ .items()
+ .get(item)
+ .and_then(|i| i.equip_slot.as_deref())
+ .filter(|s| matches!(*s, "head" | "chest" | "legs" | "feet"))
+ .unwrap_or("mainhand");
+ SLOT_NAMES.iter().position(|n| *n == slot).unwrap_or(0)
+ }
+ /// `Piglin.canReplaceCurrentItem`: an empty slot takes anything, a wanted
+ /// item replaces an unwanted one and never the other way round. Vanilla's
+ /// armour and weapon comparison for two equal-interest items is left out
+ /// (the piglin keeps what it has).
+ fn piglin_can_replace(&self, m: &Mob, item: &str, slot: usize) -> bool {
+ let Some(current) = horizon_client::mobs::finalize::item(m, slot) else {
+ return true;
+ };
+ self.piglin_wanted(item) && !self.piglin_wanted(¤t)
+ }
+ /// `SimpleContainer.canAddItem` on the piglin's eight slots.
+ fn piglin_can_add(&self, m: &Mob, stack: &ItemStack) -> bool {
+ m.extra.inventory.len() < 8
+ || m.extra.inventory.iter().any(|s| {
+ s.same_item_same_components(stack) && s.count < self.piglin_max_stack(&s.item)
+ })
+ }
+ fn piglin_max_stack(&self, item: &str) -> u32 {
+ self.res.items().get(item).map_or(64, |i| i.max_stack)
+ }
+ /// `PiglinAi.wantsToPickup` (an adult that is not hurt-shy), without
+ /// the baby rule, which babies skip entirely here.
+ fn piglin_wants(&self, m: &Mob, stack: &ItemStack) -> bool {
+ let item = &*stack.item;
+ if self.item_in_tag("minecraft:piglin_repellents", item) {
+ return false;
+ }
+ let holds_loved = m
+ .extra
+ .off_hand
+ .as_deref()
+ .is_some_and(|o| self.piglin_loved(o));
+ if item == "minecraft:gold_ingot" {
+ return !holds_loved;
+ }
+ let space = self.piglin_can_add(m, stack);
+ if item == "minecraft:gold_nugget" {
+ space
+ } else if self.item_in_tag("minecraft:piglin_food", item) {
+ m.extra.ints[0] <= 0 && space
+ } else if !self.piglin_loved(item) {
+ self.piglin_can_replace(m, item, self.piglin_slot(item))
+ } else {
+ !holds_loved && space
+ }
+ }
+ /// `Mob.equipItemIfPossible` for a piglin: put it in its slot when that
+ /// slot takes it (an armour piece that cannot replace what is worn goes
+ /// to an empty main hand), dropping what it replaces by drop chance.
+ fn piglin_equip(&mut self, index: usize, stack: &ItemStack) -> bool {
+ let item = &*stack.item;
+ let mut slot = self.piglin_slot(item);
+ let m = &self.mobs[index];
+ let mut replace = self.piglin_can_replace(m, item, slot);
+ if slot > 1 && !replace {
+ slot = 0;
+ replace = m.extra.main_hand.is_none();
+ }
+ if !replace {
+ return false;
+ }
+ let m = &mut self.mobs[index];
+ let old = horizon_client::mobs::finalize::item(m, slot);
+ let chance = stored_drop_chance(m, slot);
+ let drop_old = old.is_some() && (m.random.next_float() - 0.1).max(0.0) < chance;
+ let old_enchantments = slot_enchantments(m, slot);
+ set_item(m, slot, item);
+ // The piglin keeps what the stack carried (Protection IV stays on).
+ set_slot_enchantments(m, slot, stack.enchantments().to_vec());
+ // setItemSlotAndDropWhenKilled, then persistenceRequired.
+ set_drop_chance(m, slot, 2.0);
+ m.persistent = true;
+ let at = [m.position.x, m.position.y, m.position.z];
+ if let (true, Some(old)) = (drop_old, old) {
+ let mut dropped = ItemStack::new(&old, 1);
+ dropped.set_crafting_enchantments(old_enchantments);
+ self.spawn_item(dropped, at, super::dispenser::new_item_motion(), 10);
+ }
+ true
+ }
+ /// `PiglinAi.putInInventory`: what does not fit is thrown at a random
+ /// spot nearby.
+ fn piglin_stash(&mut self, index: usize, mut stack: ItemStack) {
+ let max = self.piglin_max_stack(&stack.item);
+ let m = &mut self.mobs[index];
+ for s in &mut m.extra.inventory {
+ if stack.count > 0 && s.same_item_same_components(&stack) && s.count < max {
+ let n = (max - s.count).min(stack.count);
+ s.count += n;
+ stack.count -= n;
+ }
+ }
+ while stack.count > 0 && m.extra.inventory.len() < 8 {
+ let n = stack.count.min(max);
+ m.extra.inventory.push(ItemStack {
+ count: n,
+ ..stack.clone()
+ });
+ stack.count -= n;
+ }
+ if stack.count == 0 {
+ return;
+ }
+ let from = [m.position.x, m.position.y + 1.3, m.position.z];
+ let r = &mut self.world.random;
+ let to = [
+ from[0] + f64::from(r.next_float() * 8.0 - 4.0),
+ from[1],
+ from[2] + f64::from(r.next_float() * 8.0 - 4.0),
+ ];
+ self.piglin_throw(from, to, stack);
+ }
+ /// `PiglinAi.stopHoldingOffHandItem` for something that is not
+ /// bartering currency: wear it if it can, else keep it in the inventory.
+ fn piglin_keep(&mut self, index: usize, stack: ItemStack) {
+ // Nuggets keep their whole stack in the inventory (a hand slot here
+ // holds one item id only).
+ if &*stack.item == "minecraft:gold_nugget" || !self.piglin_equip(index, &stack) {
+ self.piglin_stash(index, stack);
+ }
+ }
+ /// `BehaviorUtils.throwItem`: toss a stack from a point toward another.
+ fn piglin_throw(&mut self, from: [f64; 3], to: [f64; 3], stack: ItemStack) {
+ let d = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
+ let len = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt().max(1e-6);
+ let v = [d[0] / len * 0.3, d[1] / len * 0.3 + 0.1, d[2] / len * 0.3];
+ self.spawn_item(stack, from, v, 40);
+ }
/// `PiglinAi.isWearingSafeArmor`.
pub(super) fn wearing_gold(&self) -> bool {
let tag = self
@@ -28,15 +182,13 @@ impl Game<'_> {
.flatten()
.any(|s| tag.is_some_and(|t| t.contains(&*s.item)))
}
- /// Piglins notice gold on the ground within 9 blocks, walk to it and
- /// take it (`GoToWantedItem`, `Piglin.pickUpItem`).
+ /// Piglins notice wanted items on the ground within 9 blocks (`PiglinAi.wantsToPickup`:
+ /// gold and other loved items, nuggets, food, gear), walk to them and
+ /// take them (`GoToWantedItem`, `Piglin.pickUpItem`).
pub(super) fn piglin_pickups(&mut self) {
if !self.ui.rules.bool("mob_griefing") {
return;
}
- // Whether each item is piglin-loved, kept until an item is added or
- // removed (added ones are pushed at the end under a new id).
- let mut loved: (Option<(usize, Option)>, Vec) = (None, Vec::new());
for i in 0..self.mobs.len() {
let m = &self.mobs[i];
if m.species() != Species::Piglin
@@ -44,27 +196,17 @@ impl Game<'_> {
|| m.is_baby()
|| m.extra.using_item > 0
|| m.extra.egg_time > 0
- || m.extra.off_hand.is_some()
{
continue;
}
let pos = m.position;
- let key = (self.dropped.len(), self.dropped.last().map(|e| e.id));
- if loved.0 != Some(key) {
- loved.0 = Some(key);
- loved.1 = self
- .dropped
- .iter()
- .map(|e| self.piglin_loved(&e.stack.item))
- .collect();
- }
let best = self
.dropped
.iter()
.enumerate()
- .filter(|&(j, _)| loved.1[j])
.map(|(j, e)| (j, e.position.distance_squared(pos)))
.filter(|(_, d)| *d <= 81.0)
+ .filter(|&(j, _)| self.piglin_wants(m, &self.dropped[j].stack))
.min_by(|a, b| a.1.total_cmp(&b.1));
let Some((j, _)) = best else {
self.mobs[i].extra.point = None;
@@ -79,24 +221,38 @@ impl Game<'_> {
continue;
}
// Nuggets come whole, anything else one at a time.
- let item = e.stack.item.clone();
let (taken_item, id) = (e.clone(), self.mobs[i].id);
+ let item = e.stack.item.clone();
self.add_pickup(
super::pickups::Taken::Item(Box::new(taken_item)),
super::pickups::Collector::Mob(id),
);
- let taken = if &*item == "minecraft:gold_nugget" {
- self.dropped.remove(j).stack.count
+ let stack = if &*item == "minecraft:gold_nugget" {
+ self.dropped.remove(j).stack
} else {
let e = &mut self.dropped[j];
e.stack.count -= 1;
+ let one = ItemStack {
+ count: 1,
+ ..e.stack.clone()
+ };
if e.stack.count == 0 {
self.dropped.remove(j);
}
- 1
+ one
};
- let _ = taken;
- self.start_admiring(i, item);
+ if self.piglin_loved(&item) {
+ self.start_admiring(i, item);
+ } else if self.item_in_tag("minecraft:piglin_food", &item)
+ && self.mobs[i].extra.ints[0] <= 0
+ {
+ // PiglinAi.eat: the food is gone and it will not eat for a while.
+ self.mobs[i].extra.ints[0] = ATE_RECENTLY;
+ self.mobs[i].nav_stop();
+ } else {
+ self.mobs[i].nav_stop();
+ self.piglin_keep(i, stack);
+ }
}
}
fn start_admiring(&mut self, index: usize, item: std::sync::Arc) {
@@ -109,14 +265,15 @@ impl Game<'_> {
self.audio
.play("minecraft:entity.piglin.admiring_item", Some(at), 1.0, 1.0);
}
- /// `PiglinAi.mobInteract`: hand a piglin something it loves.
+ /// `PiglinAi.mobInteract`: hand a piglin a gold ingot (only piglin
+ /// currency is accepted from the hand; other loved items are passed over).
pub(super) fn give_piglin(&mut self, index: usize, item: &str) -> bool {
let m = &self.mobs[index];
if m.species() != Species::Piglin
|| m.is_baby()
|| m.extra.using_item > 0
|| m.extra.egg_time > 0
- || !self.piglin_loved(item)
+ || item != "minecraft:gold_ingot"
{
return false;
}
@@ -124,7 +281,8 @@ impl Game<'_> {
true
}
/// `PiglinAi.stopHoldingOffHandItem` after admiring: gold ingots buy a
- /// roll of the bartering table, thrown toward the player.
+ /// roll of the bartering table, thrown toward the player; any other loved
+ /// item it picked up is kept (worn if it can be, else stored).
pub(super) fn finish_admiring(&mut self, mob: u32) {
let Some(i) = self.mobs.iter().position(|m| m.id == mob) else {
return;
@@ -132,9 +290,13 @@ impl Game<'_> {
let Some(item) = self.mobs[i].extra.off_hand.take() else {
return;
};
+ if &*item != "minecraft:gold_ingot" {
+ self.piglin_keep(i, ItemStack::new(&item, 1));
+ return;
+ }
let m = &self.mobs[i];
let from = [m.position.x, m.position.y + 1.3, m.position.z];
- let items = if &*item == "minecraft:gold_ingot" && !m.is_baby() {
+ let items = if !m.is_baby() {
self.res.items().loot_table(
"minecraft:gameplay/piglin_bartering",
false,
@@ -176,10 +338,7 @@ impl Game<'_> {
from[2] + f64::from(r.next_float() * 8.0 - 4.0),
]
});
- let d = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
- let len = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt().max(1e-6);
- let v = [d[0] / len * 0.3, d[1] / len * 0.3 + 0.1, d[2] / len * 0.3];
- self.spawn_item(stack, from, v, 40);
+ self.piglin_throw(from, to, stack);
}
}
/// `PiglinAi.angerNearbyPiglins`.
diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs
index b28c2fb4d..2ccfd4116 100644
--- a/crates/horizon-client/src/game/potions.rs
+++ b/crates/horizon-client/src/game/potions.rs
@@ -71,6 +71,8 @@ pub(super) struct BodyPotions {
pub(super) struct PotionState {
pub(super) effects: PlayerEffects,
thrown: Vec,
+ /// The area effect clouds a server tracks (game/remote_projectiles.rs).
+ pub(super) clouds: Vec,
applied: Vec<(&'static str, &'static str, f64, &'static str)>,
/// Armor the protection table was computed for.
protection_for: Option>>,
@@ -141,14 +143,22 @@ impl PotionState {
t.stack = stack;
}
}
- /// One tick of a server's client: `step` moves each toward where the
- /// server put it.
- pub(super) fn step_remote_thrown(&mut self, mut step: impl FnMut(u32, Vec3) -> Vec3) {
- for t in &mut self.thrown {
- t.previous = t.position;
- t.age += 1;
- t.position = step(t.id, t.position);
- }
+ /// A server's move: thrown potions have no interpolation handler, so
+ /// `moveOrInterpolateTo` puts them there at once. False when `id` isn't one.
+ pub(super) fn move_remote_thrown(&mut self, id: u32, at: Vec3) -> bool {
+ let Some(t) = self.thrown.iter_mut().find(|t| t.id == id) else {
+ return false;
+ };
+ t.position = at;
+ true
+ }
+ /// `handleSetEntityMotion` for a thrown potion. False when `id` isn't one.
+ pub(super) fn remote_thrown_motion(&mut self, id: u32, velocity: Vec3) -> bool {
+ let Some(t) = self.thrown.iter_mut().find(|t| t.id == id) else {
+ return false;
+ };
+ t.velocity = velocity;
+ true
}
pub(super) fn remove_remote_thrown(&mut self, id: u32) {
self.thrown.retain(|t| t.id != id);
@@ -266,7 +276,8 @@ impl Game<'_> {
} else if let Some(rest) = self.give(filled)
&& let Some(eye) = self.eye_position()
{
- self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
+ // `player.drop(stack, false)`.
+ self.throw_from_eyes(rest, eye, false);
}
}
/// Drinking a potion while right-click is held; true when handled.
@@ -390,8 +401,28 @@ impl Game<'_> {
for action in actions {
self.apply_effect_action(action);
}
+ self.turtle_helmet_tick();
self.apply_effect_status();
}
+ /// `Player.tick` -> `turtleHelmetTick`: with a turtle helmet on the head
+ /// and the eyes out of the water, Water Breathing for 200 ticks (no
+ /// particles, an icon).
+ fn turtle_helmet_tick(&mut self) {
+ let Some(p) = self.player.as_ref() else {
+ return;
+ };
+ let eye_y = p.position.y + f64::from(p.dimensions.eye_height);
+ if !p.health.dead_or_dying()
+ && self.armor[0]
+ .as_ref()
+ .is_some_and(|s| &*s.item == "minecraft:turtle_helmet")
+ && !self.eye_in_water(p.position.x, eye_y, p.position.z)
+ {
+ let mut effect = EffectInstance::new("water_breathing", 200, 0);
+ effect.visible = false;
+ self.potions.effects.add(effect);
+ }
+ }
/// A client's own effects (`LivingEntity.tickEffects` on the client,
/// `MobEffectInstance.tickClient`): they count down, and the server
/// removes them. Their modifiers and flags move the predicted player.
@@ -484,6 +515,7 @@ impl Game<'_> {
thrown.retain_mut(|t| {
t.age += 1;
t.previous = t.position;
+ self.thrown_potion_motion(t);
let next = Vec3::new(
t.position.x + t.velocity.x,
t.position.y + t.velocity.y,
@@ -520,18 +552,6 @@ impl Game<'_> {
return false;
}
t.position = next;
- // ThrowableItemProjectile: drag 0.99 then gravity 0.05.
- // ThrownExperienceBottle.getDefaultGravity is 0.07.
- let gravity = if &*t.stack.item == "minecraft:experience_bottle" {
- 0.07
- } else {
- 0.05
- };
- t.velocity = Vec3::new(
- t.velocity.x * 0.99,
- t.velocity.y * 0.99 - gravity,
- t.velocity.z * 0.99,
- );
t.age < 1200 && t.position.y > -128.0
});
self.potions.thrown = thrown;
@@ -539,6 +559,60 @@ impl Game<'_> {
self.splash(&stack, at);
}
}
+ /// `ThrowableProjectile.tick`'s `applyGravity` and `applyInertia`, which
+ /// come before the move: gravity 0.05 (0.07 for an experience bottle),
+ /// then drag 0.99 (0.8 in water).
+ fn thrown_potion_motion(&self, t: &mut ThrownPotion) {
+ let gravity = if &*t.stack.item == "minecraft:experience_bottle" {
+ 0.07
+ } else {
+ 0.05
+ };
+ let at = t.position;
+ let water = self
+ .res
+ .facts()
+ .get(self.world.block(
+ at.x.floor() as i32,
+ at.y.floor() as i32,
+ at.z.floor() as i32,
+ ))
+ .fluid
+ == horizon_client::blocks::Fluid::Water;
+ let inertia = if water { 0.8 } else { 0.99 };
+ t.velocity = Vec3::new(
+ t.velocity.x * inertia,
+ (t.velocity.y - gravity) * inertia,
+ t.velocity.z * inertia,
+ );
+ }
+ /// `ThrowableProjectile.tick` on a server's client: it falls and moves
+ /// by itself between the server's updates and stops at a block; only
+ /// the server breaks it.
+ pub(super) fn step_remote_thrown(&mut self) {
+ let mut thrown = std::mem::take(&mut self.potions.thrown);
+ for t in &mut thrown {
+ t.previous = t.position;
+ t.age += 1;
+ self.thrown_potion_motion(t);
+ let next = Vec3::new(
+ t.position.x + t.velocity.x,
+ t.position.y + t.velocity.y,
+ t.position.z + t.velocity.z,
+ );
+ let state = self.world.block(
+ next.x.floor() as i32,
+ next.y.floor() as i32,
+ next.z.floor() as i32,
+ );
+ if self.res.facts().get(state).full_collision {
+ t.velocity = Vec3::ZERO;
+ } else {
+ t.position = next;
+ }
+ }
+ self.potions.thrown = thrown;
+ }
/// `ThrownItemRenderer` for thrown splash and lingering potions and
/// experience bottles: the item (GROUND) facing the camera at scale 1,
/// lit at the light probe (the eye, 0.85 of the 0.25 height).
diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs
index bedca5708..743f02f44 100644
--- a/crates/horizon-client/src/game/raids.rs
+++ b/crates/horizon-client/src/game/raids.rs
@@ -796,6 +796,8 @@ impl Game<'_> {
let s = m.extra.raider.get_or_insert_with(Box::default);
s.rider = has_rider;
s.in_village = in_village;
+ // Vindicator.customServerAiStep: `ServerLevel.isRaided`.
+ s.raided = species == Species::Vindicator && raids.nearby(block).is_some();
if s.raid_id.is_some_and(|id| raids.get(id).is_none()) {
s.raid_id = None;
s.ticks_outside_raid = 0;
diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs
index 1459c8dd6..945af4585 100644
--- a/crates/horizon-client/src/game/remote.rs
+++ b/crates/horizon-client/src/game/remote.rs
@@ -847,7 +847,10 @@ impl Game<'_> {
remote.quiet_commands = true;
}
}
- Event::Reconfigured(registries) => self.set_registries(registries),
+ Event::Reconfigured(registries) => {
+ self.boss_overlay.reset();
+ self.set_registries(registries);
+ }
// handleTransfer: "Cannot transfer to server from
// singleplayer" (no ServerData), so the world just closes.
Event::Transfer { host, port } => {
@@ -1266,6 +1269,9 @@ impl Game<'_> {
} else {
self.res.mob_types().get(kind).cloned()
};
+ if kind == "minecraft:ender_dragon" {
+ self.spawn_remote_dragon(id, position, yaw);
+ }
if kind == "minecraft:experience_orb" {
// Its value (ExperienceOrb.DATA_VALUE) follows in SetEntityData.
self.orbs.retain(|o| o.id != id as u32);
@@ -1277,6 +1283,8 @@ impl Game<'_> {
value: 1,
age: 0,
on_ground: false,
+ count: 1,
+ ticks: 0,
});
}
if let Some(t) = mob_type {
@@ -1372,13 +1380,17 @@ impl Game<'_> {
m.on_ground = on_ground;
return;
}
- if let Some(p) = self.creatures.projectiles.iter_mut().find(|p| {
- p.id == id as u32
- && matches!(
- p.kind,
- horizon_client::projectiles::ProjectileKind::LargeFireball { .. }
- )
- }) {
+ // Projectiles keep Entity's NO_OP InterpolationHandler too: the
+ // server's position replaces theirs at once and their own tick
+ // flies them on (`tick_remote_projectiles`). Eased towards it
+ // instead, they only moved when an update came, every 10 to 20
+ // ticks.
+ if let Some(p) = self
+ .creatures
+ .projectiles
+ .iter_mut()
+ .find(|p| p.id == id as u32)
+ {
if path.is_some() {
p.position = Vec3::new(position[0], position[1], position[2]);
}
@@ -1388,6 +1400,22 @@ impl Game<'_> {
}
return;
}
+ if path.is_some()
+ && (self.potions.move_remote_thrown(
+ id as u32,
+ Vec3::new(position[0], position[1], position[2]),
+ ) || self.end.move_remote_eye(id as u32, position))
+ {
+ return;
+ }
+ // A dragon fireball keeps Entity's NO_OP InterpolationHandler too:
+ // the server's position replaces its own at once.
+ if let Some(b) = self.dragon_fireballs.iter_mut().find(|b| b.id == id as u32) {
+ if path.is_some() {
+ b.position = Vec3::new(position[0], position[1], position[2]);
+ }
+ return;
+ }
if let Some(p) = r.pending_items.get_mut(&id) {
p.0 = position;
}
@@ -1434,6 +1462,8 @@ impl Game<'_> {
self.mobs.retain(|m| m.id != id as u32);
self.orbs.retain(|o| o.id != id as u32);
self.dropped.retain(|d| d.id != id as u32);
+ // Before the crystals go: the dragon's beam index follows them.
+ self.remove_remote_dragon(id);
self.remove_remote_object(id as u32);
self.remove_remote_projectile(id as u32);
if let Some(r) = self.remote.as_mut() {
@@ -1669,19 +1699,30 @@ impl Game<'_> {
}
}
C::BlockChangedAck(p) => self.end_predictions(p.sequence),
- // ClientLevel.blockEvent: BlockEntity.triggerEvent (chest lids,
- // shulker boxes, bells) when the block is still the one it names.
+ // Level.blockEvent on the client level: the block's triggerEvent
+ // runs on the client's copy of whatever is at pos (a piston's
+ // moveBlocks builds the moving block entities it animates, a note
+ // block plays); what it doesn't handle reaches the client copy of
+ // the block entity (chest lids, shulker boxes).
C::BlockEvent(p) => {
- let state = self.world.block(p.pos[0], p.pos[1], p.pos[2]);
- let block = &self.res.facts().get(state).name;
- let named = self.remote.as_ref().and_then(|r| {
- r.builtin
- .get("minecraft:block")?
- .name(p.block)
- .map(str::to_owned)
+ let pos = horizon_core::position::BlockPos::new(p.pos[0], p.pos[1], p.pos[2]);
+ let triggered = self.with_level(|b, level, ticks| {
+ b.client_block_event(level, ticks, pos, i32::from(p.b0), i32::from(p.b1))
});
- if named.as_deref() == Some(&**block) {
- self.block_entity_event(p.pos, i32::from(p.b0), i32::from(p.b1));
+ self.sync_moving_pistons();
+ self.process_level_events()?;
+ if !triggered {
+ let state = self.world.block(p.pos[0], p.pos[1], p.pos[2]);
+ let block = &self.res.facts().get(state).name;
+ let named = self.remote.as_ref().and_then(|r| {
+ r.builtin
+ .get("minecraft:block")?
+ .name(p.block)
+ .map(str::to_owned)
+ });
+ if named.as_deref() == Some(&**block) {
+ self.block_entity_event(p.pos, i32::from(p.b0), i32::from(p.b1));
+ }
}
}
// ClientLevel.levelEvent: LevelEventHandler, as this client's own
@@ -1966,6 +2007,7 @@ impl Game<'_> {
}
self.remote_object_data(p.id, &p.values);
self.remote_projectile_data(p.id, &p.values);
+ self.remote_dragon_data(p.id, &p.values);
}
// ClientPacketListener.handleSetEquipment: what a mob or another
// player holds and wears (EquipmentSlot ordinals).
@@ -2024,7 +2066,10 @@ impl Game<'_> {
{
self.add_pickup(super::pickups::Taken::Orb(Box::new(orb)), collector);
}
- self.remove_entity(p.item);
+ // An orb stays: the server may still hold merged ones in it.
+ if !orb {
+ self.remove_entity(p.item);
+ }
}
// ClientPacketListener.handleSetEntityMotion: knockback on this player.
C::SetEntityMotion(p) if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) => {
@@ -2047,6 +2092,8 @@ impl Game<'_> {
} else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
m.limb_speed = 1.5;
m.hurt_time = 10;
+ } else {
+ self.remote_dragon_hurt(p.id);
}
}
C::HurtAnimation(p) => {
@@ -2056,9 +2103,14 @@ impl Game<'_> {
}
} else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
m.hurt_time = 10;
+ } else {
+ self.remote_dragon_hurt(p.id);
}
}
C::EntityEvent(p) => {
+ if p.event == super::fireworks::FIREWORK_EXPLODE_EVENT {
+ self.remote_firework_explosion(p.id);
+ }
// LocalPlayer.setPermissions also refreshes an open World Options screen.
if (24..=28).contains(&p.event)
&& self.remote.as_ref().is_some_and(|r| r.entity_id == p.id)
@@ -2072,6 +2124,11 @@ impl Game<'_> {
{
horizon_client::mobs::rabbit::hop_event(m);
}
+ if p.event == 19
+ && let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32)
+ {
+ horizon_client::mobs::aquatic::squid_cycle_event(m);
+ }
// EntityEvent.DEATH: start the death animation.
if p.event == 3
&& let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32)
@@ -2944,8 +3001,12 @@ impl Game<'_> {
/// entities whose own tick moves them on a client: dropped items, falling
/// blocks and primed TNT.
fn remote_motion(&mut self, id: i32, velocity: [f64; 3]) {
+ self.remote_dragon_motion(id, velocity);
let v = Vec3::new(velocity[0], velocity[1], velocity[2]);
- if let Some(d) = self.dropped.iter_mut().find(|d| d.id == id as u32) {
+ if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id as u32) {
+ // Squid.aiStep derives its body pitch and roll from network motion.
+ m.velocity = v;
+ } else if let Some(d) = self.dropped.iter_mut().find(|d| d.id == id as u32) {
d.velocity = v;
} else if let Some(f) = self.falling.iter_mut().find(|f| f.id == id as u32) {
f.velocity = v;
@@ -2958,12 +3019,16 @@ impl Game<'_> {
.find(|p| p.id == id as u32)
{
p.velocity = v;
+ } else if let Some(b) = self.dragon_fireballs.iter_mut().find(|b| b.id == id as u32) {
+ b.velocity = v;
} else if let Some(p) = self
.remote
.as_mut()
.and_then(|r| r.pending_items.get_mut(&id))
{
p.1 = v;
+ } else if !self.potions.remote_thrown_motion(id as u32, v) {
+ self.end.remote_eye_motion(id as u32, velocity);
}
}
fn apply_remote_health(&mut self) {
@@ -3070,6 +3135,12 @@ impl Game<'_> {
fn tick_remote_level(&mut self) -> Result<()> {
self.ticks += 1;
self.track_experience_display();
+ // Player.tick's ItemCooldowns.tick: this path replaces `tick_world`'s
+ // for a server's client (multiplayer and the default single player),
+ // so the entries advance here or the slot stays shaded until the
+ // server says the entry ended. `onCooldownEnded` is the plain
+ // ItemCooldowns' no-op on a client.
+ self.cooldowns.tick();
// Options.broadcastOptions: a changed render distance or Chat option
// is sent again.
let view = client_view_distance(self.settings.render_distance);
@@ -3107,8 +3178,14 @@ impl Game<'_> {
self.border.tick();
self.player_border();
self.tick_remote_entities(running);
- // ClientLevel.tickBlockEntities: chest lids, shulker boxes, bells.
+ // ClientLevel.tickBlockEntities: chest lids, shulker boxes, bells,
+ // and the moving pistons a block event's client-side moveBlocks made
+ // (their progress advances between the server's block updates).
self.tick_block_entity_anims();
+ self.with_level(|b, level, ticks| {
+ b.client_tick_block_entities(level, ticks);
+ });
+ self.sync_moving_pistons();
self.tick_hand();
self.tick_particles();
self.tick_client_ambient();
@@ -3433,6 +3510,13 @@ impl Game<'_> {
if m.species() == horizon_client::mobs::Species::Creeper {
horizon_client::mobs::hostile::creeper_client_tick(m);
}
+ if matches!(
+ m.species(),
+ horizon_client::mobs::Species::Guardian
+ | horizon_client::mobs::Species::ElderGuardian
+ ) {
+ horizon_client::mobs::guardian::client_tick(m);
+ }
if m.hurt_time > 0 {
m.hurt_time -= 1;
}
@@ -3492,6 +3576,8 @@ impl Game<'_> {
} else if m.alive() {
m.body_rotation_tick();
}
+ // Squid.aiStep follows LivingEntity's interpolation and head turn.
+ horizon_client::mobs::aquatic::squid_client_step(m);
// WalkAnimationState.update from the horizontal distance moved.
let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
let target = (((dx * dx + dz * dz).sqrt() * 4.0) as f32).min(1.0);
@@ -3500,6 +3586,9 @@ impl Game<'_> {
if m.species() == horizon_client::mobs::Species::Rabbit {
horizon_client::mobs::rabbit::post_tick(m);
}
+ if m.species() == horizon_client::mobs::Species::Bat {
+ horizon_client::mobs::bat::setup_animation_states(m);
+ }
}
for o in self.orbs.iter_mut().filter(|_| running) {
o.previous = o.position;
@@ -3528,6 +3617,18 @@ impl Game<'_> {
self.remote_player_eating(&item, ticks, at, eye, pitch, yaw);
}
if running {
+ // The dragon: LivingEntity's interpolation, inside its aiStep.
+ let dragon_lerp = self
+ .dragon
+ .as_ref()
+ .and_then(|d| lerps.get_mut(&(d.id as i32)))
+ .filter(|l| l.steps > 0)
+ .map(|l| {
+ let steps = l.steps;
+ l.steps -= 1;
+ (l.target, l.rotation.map(|r| r.0), steps)
+ });
+ self.tick_remote_dragon(dragon_lerp);
// Boats, minecarts, armor stands, projectiles and the rest
// interpolate like mobs.
let mut step = |id: u32, at: Vec3| match lerps.get_mut(&(id as i32)) {
@@ -3690,6 +3791,15 @@ impl Game<'_> {
/// MultiPlayerGameMode.startDestroyBlock / continueDestroyBlock.
fn remote_mining(&mut self, start: bool) {
+ if !self
+ .res
+ .items()
+ .can_destroy_block(self.held(), self.creative)
+ {
+ self.stop_remote_mining();
+ self.mining = None;
+ return;
+ }
let Some(r) = self.remote.as_mut() else {
return;
};
@@ -3829,19 +3939,25 @@ impl Game<'_> {
.and_modify(|p| p.0 = sequence)
.or_insert((sequence, state.0 as i32));
}
- let s = self.res.facts().get(state).sounds.clone();
- let at = [
- f64::from(pos[0]) + 0.5,
- f64::from(pos[1]) + 0.5,
- f64::from(pos[2]) + 0.5,
- ];
- self.audio.play(
- &s.break_sound,
- Some(at),
- (s.volume + 1.0) / 2.0,
- s.pitch * 0.8,
- );
- self.destroy_particles(pos, state);
+ // Block.playerWillDestroy's destroy event (particles and the break
+ // sound), which BaseFireBlock skips: the server's extinguish sound
+ // is all a player hears.
+ let facts = self.res.facts().get(state);
+ if !facts.has_class("BaseFireBlock") {
+ let s = facts.sounds.clone();
+ let at = [
+ f64::from(pos[0]) + 0.5,
+ f64::from(pos[1]) + 0.5,
+ f64::from(pos[2]) + 0.5,
+ ];
+ self.audio.play(
+ &s.break_sound,
+ Some(at),
+ (s.volume + 1.0) / 2.0,
+ s.pitch * 0.8,
+ );
+ self.destroy_particles(pos, state);
+ }
// The server's block update follows (waterlogged blocks leave water).
let air = self.world.air;
if self.world.set(pos[0], pos[1], pos[2], air).is_ok() {
@@ -3940,15 +4056,11 @@ impl Game<'_> {
world_border: false,
sequence: seq,
}));
- let target = [
- hit.pos[0] + hit.face[0],
- hit.pos[1] + hit.face[1],
- hit.pos[2] + hit.face[2],
- ];
- let ticks = self.ticks;
+ // Only a predicted placement (predict_place) marks a cell whose
+ // resend plays a place sound: an empty hand or a non-block item
+ // places nothing (BlockItem.place is where the sound comes from).
if let Some(r) = self.remote.as_mut() {
r.use_target = Some(hit.pos);
- r.placing = Some((target, ticks));
}
if reacts {
self.predict_use(&changes, seq);
@@ -4515,6 +4627,7 @@ impl Game<'_> {
}
KeyCode::KeyE => {
// The inventory opens without telling the server.
+ self.recipe_ui.reset_screen();
self.screen = if self.creative {
Screen::Creative
} else {
@@ -4781,6 +4894,7 @@ impl Game<'_> {
self.remote_close_local();
}
fn remote_close_local(&mut self) {
+ self.recipe_ui.reset_screen();
if let Some(r) = self.remote.as_mut() {
r.menu = None;
r.menu_title = None;
@@ -4816,16 +4930,20 @@ impl Game<'_> {
if self.open_menu_name(p.container) != "minecraft:merchant" {
return;
}
- let cost = |g: &Self, c: &play::NetCost| horizon_client::merchant::ItemCost {
- stack: ItemStack::new(&g.item_name(c.item), c.count.max(0) as u32),
+ let cost = |g: &Self, c: &play::NetCost| {
+ g.to_stack(&Some(c.clone().into()))
+ .map(|stack| horizon_client::merchant::ItemCost { stack })
};
let offers: Vec<_> = p
.offers
.iter()
.filter_map(|o| {
let mut offer = horizon_client::merchant::MerchantOffer {
- base_cost_a: cost(self, &o.cost_a),
- cost_b: o.cost_b.as_ref().map(|b| cost(self, b)),
+ base_cost_a: cost(self, &o.cost_a)?,
+ cost_b: match &o.cost_b {
+ Some(b) => Some(cost(self, b)?),
+ None => None,
+ },
result: self.to_stack(&Some(o.result.clone()))?,
uses: o.uses,
max_uses: o.max_uses,
@@ -4851,6 +4969,9 @@ impl Game<'_> {
}
/// ClientboundOpenScreenPacket for the menus Horizon draws.
fn remote_open_screen(&mut self, p: play::OpenScreen) {
+ // A new RecipeBookComponent owns fresh ghost slots and an overlay,
+ // even when the server replaces a menu without a close packet.
+ self.recipe_ui.reset_screen();
let menu = self
.remote
.as_ref()
diff --git a/crates/horizon-client/src/game/remote_mob_data.rs b/crates/horizon-client/src/game/remote_mob_data.rs
index fbfc5a4fb..c6702dfb6 100644
--- a/crates/horizon-client/src/game/remote_mob_data.rs
+++ b/crates/horizon-client/src/game/remote_mob_data.rs
@@ -4,14 +4,14 @@
//! own simulation, which a client of a server doesn't run.
use super::Game;
use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES};
-use horizon_client::mobs::{Mob, Species, tame};
+use horizon_client::mobs::{Mob, Species, Who, bat, tame};
use horizon_protocol::entity_data::Value;
use horizon_protocol::registry::Builtin;
/// The values `apply` takes from one SetEntityData packet, by vanilla's entry
/// indices (Entity 0..=7, LivingEntity 8..=14, Mob 15, then the subclasses).
/// `builtin` names the ids of built-in registries.
-fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin) {
+fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_entity: i32) {
let species = m.species();
let baby = super::lan::baby_index(&m.kind.id);
for (index, _, value) in values {
@@ -46,6 +46,21 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin) {
_ => {}
}
match (species, *index, value) {
+ (Species::Guardian | Species::ElderGuardian, 16, Value::Bool(moving)) => {
+ m.extra.flag2 = *moving;
+ }
+ (Species::Guardian | Species::ElderGuardian, 17, Value::Int(target)) => {
+ // Guardian.onSyncedDataUpdated resets the visual charge clock.
+ m.extra.counter2 = 0;
+ m.extra.flag = *target != 0;
+ m.ai.target = (*target != 0).then_some(if *target == local_entity {
+ Who::Player
+ } else {
+ Who::Mob(*target as u32)
+ });
+ }
+ // Bat.DATA_ID_FLAGS: resting in bit 0.
+ (Species::Bat, 16, Value::Byte(flags)) => bat::set_resting(m, flags & 1 != 0),
// Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 sheared.
(Species::Sheep, 18, Value::Byte(wool)) => {
m.extra.color = (*wool & 15) as u8;
@@ -114,7 +129,7 @@ impl Game<'_> {
return;
};
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id as u32) {
- apply(m, values, &r.builtin);
+ apply(m, values, &r.builtin, r.entity_id);
}
}
}
@@ -126,6 +141,10 @@ pub(super) fn client_defaults(m: &mut Mob) {
if matches!(m.species(), Species::Wolf | Species::Cat) {
m.extra.color = tame::RED;
}
+ if m.species() == Species::Bat {
+ // Bat's constructor sets resting only on the server; the data default is 0.
+ bat::set_resting(m, false);
+ }
}
#[cfg(test)]
@@ -147,7 +166,7 @@ mod tests {
}
fn apply(m: &mut Mob, values: &[(u8, i32, Value)]) {
- super::apply(m, values, &builtin());
+ super::apply(m, values, &builtin(), 99);
}
fn mob(kind: &str) -> Option {
@@ -158,6 +177,49 @@ mod tests {
Some(m)
}
+ #[test]
+ fn guardian_charge_follows_target_updates_and_caps_at_its_duration() {
+ use horizon_client::mobs::guardian::{beam, client_tick};
+ for (kind, duration) in [("guardian", 80), ("elder_guardian", 60)] {
+ let Some(mut m) = mob(&format!("minecraft:{kind}")) else {
+ return;
+ };
+ assert!(beam(&m, 0.0).is_none());
+ apply(
+ &mut m,
+ &[
+ (16, s::BOOLEAN, Value::Bool(true)),
+ (17, s::INT, Value::Int(99)),
+ ],
+ );
+ assert!(m.extra.flag2);
+ assert_eq!(m.ai.target, Some(Who::Player));
+ assert_eq!(beam(&m, 0.0), Some((0.0, 0.0)));
+ for _ in 0..duration + 10 {
+ client_tick(&mut m);
+ }
+ assert_eq!(beam(&m, 0.0), Some((duration as f32, 1.0)));
+ // Another player or a mob retains its network entity id.
+ apply(&mut m, &[(17, s::INT, Value::Int(42))]);
+ assert_eq!(m.ai.target, Some(Who::Mob(42)));
+ assert_eq!(m.extra.counter2, 0);
+ client_tick(&mut m);
+ assert_eq!(m.extra.counter2, 1);
+ apply(
+ &mut m,
+ &[
+ (16, s::BOOLEAN, Value::Bool(false)),
+ (17, s::INT, Value::Int(0)),
+ ],
+ );
+ client_tick(&mut m);
+ assert!(!m.extra.flag2);
+ assert_eq!(m.ai.target, None);
+ assert_eq!(m.extra.counter2, 0);
+ assert!(beam(&m, 0.0).is_none());
+ }
+ }
+
#[test]
fn a_sheep_takes_its_wool_and_a_calf_its_size() {
let Some(mut m) = mob("minecraft:sheep") else {
@@ -174,6 +236,69 @@ mod tests {
assert!(!calf.is_baby());
}
+ #[test]
+ fn bat_flags_select_continuous_client_clocks_without_changing_motion() {
+ use horizon_client::mobs::{MobTypes, anim, keyframes::Animation};
+ use horizon_core::geometry::Vec3;
+ use serde_json::json;
+ use std::{collections::HashMap, fs, sync::Arc};
+
+ // Original minimal resources keep this regression runnable without vanilla data.
+ let root =
+ std::env::temp_dir().join(format!("horizon-bat-animation-{}", std::process::id()));
+ fs::create_dir(&root).unwrap();
+ fs::write(root.join("entity-types.json"), r#"{"minecraft:bat": {}}"#).unwrap();
+ fs::write(
+ root.join("entity-models.json"),
+ r#"{"minecraft:bat#main": {"children": {"right_wing": {}, "head": {}}}}"#,
+ )
+ .unwrap();
+ let mut types = MobTypes::load(&root).unwrap();
+ fs::remove_dir_all(root).unwrap();
+ let position = Vec3::new(1.0, 2.25, 3.0);
+ let velocity = Vec3::new(0.2, 0.3, 0.4);
+ let mut m = Mob::new(
+ 1,
+ Arc::new(types.types.remove("minecraft:bat").unwrap()),
+ position,
+ 0.0,
+ );
+ assert!(bat::resting(&m));
+ client_defaults(&mut m);
+ assert!(!bat::resting(&m));
+ m.velocity = velocity;
+ m.age = 1;
+ bat::setup_animation_states(&mut m);
+ m.age = 4;
+ apply(&mut m, &[(16, s::BYTE, Value::Byte(2))]);
+ bat::setup_animation_states(&mut m);
+ assert_eq!(m.anim.states[0].started, Some(1.0));
+
+ let curve = Animation::parse(&json!({"length": 1, "looping": true,
+ "bones": {"right_wing": [{"target": "rotation", "keyframes":
+ [[0,[0,0,0],[0,0,0],"linear"],[1,[0,1,0],[0,1,0],"linear"]]}]}}));
+ let animations = HashMap::from([("BatAnimation.BAT_FLYING".into(), curve)]);
+ let wing = |partial| {
+ let mut poses = anim::Poses::new(&m.kind.model);
+ anim::setup(&m, &anim::state(&m, partial), &mut poses, &animations);
+ poses.get("right_wing")[4]
+ };
+ assert!(wing(0.5) > wing(0.0));
+
+ m.age = 5;
+ apply(&mut m, &[(16, s::BYTE, Value::Byte(3))]);
+ bat::setup_animation_states(&mut m);
+ assert!(bat::resting(&m));
+ assert_eq!(m.anim.states[0].started, None);
+ assert_eq!(m.anim.states[1].started, Some(5.0));
+ m.age = 7;
+ apply(&mut m, &[(16, s::BYTE, Value::Byte(0))]);
+ bat::setup_animation_states(&mut m);
+ assert_eq!(m.anim.states[0].started, Some(7.0));
+ assert_eq!(m.anim.states[1].started, None);
+ assert_eq!((m.position, m.velocity), (position, velocity));
+ }
+
#[test]
fn a_wolf_takes_its_owner_flags_and_collar() {
let Some(mut m) = mob("minecraft:wolf") else {
diff --git a/crates/horizon-client/src/game/remote_objects.rs b/crates/horizon-client/src/game/remote_objects.rs
index 251d277f3..05b1a2b9e 100644
--- a/crates/horizon-client/src/game/remote_objects.rs
+++ b/crates/horizon-client/src/game/remote_objects.rs
@@ -3,7 +3,7 @@
//! `handleSetEquipment`): the server simulates them, the client places them
//! where it says and interpolates their moves like a mob's.
use super::Game;
-use horizon_client::entities::{ArmorStand, ItemFrame, Painting};
+use horizon_client::entities::{ArmorStand, Cushion, ItemFrame, Painting};
use horizon_core::geometry::Vec3;
use horizon_protocol::entity_data::Value;
use std::sync::Arc;
@@ -57,6 +57,16 @@ impl Game<'_> {
invisible: false,
check_interval: 0,
});
+ } else if kind == "minecraft:cushion" {
+ // BlockAttachedEntity.pos: `BlockPos.containing` of the spawn.
+ self.cushions.push(Cushion {
+ id,
+ position: at,
+ pos: block,
+ yaw: super::cushions::snap_yaw(yaw),
+ color: 0,
+ check_interval: 0,
+ });
} else if kind == "minecraft:lightning_bolt" {
self.spawn_remote_bolt(id, position);
} else if kind == "minecraft:painting" {
@@ -152,6 +162,11 @@ impl Game<'_> {
}
_ => {}
}
+ } else if let Some(c) = self.cushions.iter_mut().find(|c| c.id == id) {
+ // Cushion.DATA_COLOR (DyeColor, a byte-backed id).
+ if let (8, Value::Id(color)) = (index, value) {
+ c.color = (*color).clamp(0, 15) as u8;
+ }
} else if let Some(b) = self.boats.iter_mut().find(|b| b.id == id) {
// VehicleEntity's hurt, direction and damage; the paddles.
match (index, value) {
@@ -267,6 +282,12 @@ impl Game<'_> {
out.push(json!({"id": a.id, "kind": "minecraft:armor_stand", "position": at(a.position), "yaw": a.yaw,
"small": a.small, "arms": a.show_arms, "no_base_plate": a.no_base_plate, "equipment": items}));
}
+ for c in &self.cushions {
+ out.push(
+ json!({"id": c.id, "kind": "minecraft:cushion", "position": at(c.position),
+ "yaw": c.yaw, "color": c.color_name()}),
+ );
+ }
for f in &self.item_frames {
out.push(
json!({"id": f.id, "kind": f.kind(), "position": f.pos, "facing": f.facing,
@@ -286,6 +307,7 @@ impl Game<'_> {
self.carts.clear();
self.boats.clear();
self.armor_stands.clear();
+ self.cushions.clear();
self.item_frames.clear();
self.paintings.clear();
}
@@ -295,6 +317,7 @@ impl Game<'_> {
self.carts.retain(|c| c.id != id);
self.boats.retain(|b| b.id != id);
self.armor_stands.retain(|a| a.id != id);
+ self.cushions.retain(|c| c.id != id);
self.item_frames.retain(|f| f.id != id);
self.paintings.retain(|p| p.id != id);
self.bolts.retain(|b| b.id != id);
diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs
index a117b1b7c..897999c6b 100644
--- a/crates/horizon-client/src/game/remote_projectiles.rs
+++ b/crates/horizon-client/src/game/remote_projectiles.rs
@@ -3,11 +3,26 @@
//! and `handleSetEntityData`): the server simulates them, the client draws
//! them where it says and interpolates their moves.
use super::{FallStep, FallingBlock, Game, fireworks::fireworks_of, view_vector};
-use horizon_client::projectiles::{Projectile, ProjectileKind};
-use horizon_core::{geometry::Vec3, position::BlockPos};
+use horizon_client::particles::{ParticleOptions, ParticleType};
+use horizon_client::projectiles::{Hit, Projectile, ProjectileKind, ProjectileWorld};
+use horizon_core::{geometry::Vec3, position::BlockPos, random::RandomSource};
use horizon_protocol::entity_data::Value;
use horizon_world::registry::BlockStateId;
+/// An `AreaEffectCloud` a server tracks: what its client tick reads.
+pub(super) struct RemoteCloud {
+ id: u32,
+ at: [f64; 3],
+ radius: f32,
+ waiting: bool,
+ particle: ParticleOptions,
+}
+
+/// `AreaEffectCloud.DEFAULT_PARTICLE`: a white entity effect.
+fn default_cloud_particle() -> ParticleOptions {
+ ParticleOptions::colored(ParticleType::EntityEffect, [1.0; 4])
+}
+
/// The projectile a type id names, as Horizon models it.
fn projectile_kind(kind: &str) -> Option {
Some(match kind {
@@ -37,6 +52,32 @@ fn projectile_kind(kind: &str) -> Option {
})
}
+/// `AbstractArrow.tick` on a client: water drag before the move, air drag
+/// after it, then gravity; a block it reaches holds it (`inGround`).
+fn remote_arrow_tick(p: &mut Projectile, w: &impl ProjectileWorld) {
+ p.previous = p.position;
+ p.age += 1;
+ if p.stuck {
+ return;
+ }
+ let water = w.in_water(p.position);
+ if water {
+ p.velocity = p.velocity.scale(0.6);
+ }
+ let to = p.position.add_vector(p.velocity);
+ if let Some((at, _, _)) = w.clip(p.position, to) {
+ p.position = at;
+ p.velocity = Vec3::ZERO;
+ p.stuck = true;
+ return;
+ }
+ p.position = to;
+ if !water {
+ p.velocity = p.velocity.scale(0.99);
+ }
+ p.velocity.y -= 0.05;
+}
+
impl Game<'_> {
/// `handleAddEntity` for these types; false when `kind` isn't one.
pub(super) fn spawn_remote_projectile(
@@ -92,6 +133,16 @@ impl Game<'_> {
| "minecraft:experience_bottle" => {
self.potions.add_remote_thrown(id, kind, at, velocity);
}
+ "minecraft:dragon_fireball" => self
+ .dragon_fireballs
+ .push(super::dragon::DragonFireball::remote(id, at, velocity)),
+ "minecraft:area_effect_cloud" => self.potions.clouds.push(RemoteCloud {
+ id,
+ at: position,
+ radius: 3.0,
+ waiting: false,
+ particle: default_cloud_particle(),
+ }),
"minecraft:eye_of_ender" => {
self.end
.add_remote_eye(id, position, [velocity.x, velocity.y, velocity.z])
@@ -125,6 +176,31 @@ impl Game<'_> {
pub(super) fn remote_projectile_data(&mut self, id: i32, values: &[(u8, i32, Value)]) {
let id = id as u32;
self.remote_hook_data(id, values);
+ if let Some(at) = self
+ .potions
+ .clouds
+ .iter()
+ .find(|c| c.id == id)
+ .map(|c| c.at)
+ {
+ // AreaEffectCloud.DATA_RADIUS, DATA_WAITING and DATA_PARTICLE.
+ for (index, _, value) in values {
+ let particle = match (index, value) {
+ (10, Value::Particle(p)) => self.received_particle(p, at),
+ _ => None,
+ };
+ let Some(c) = self.potions.clouds.iter_mut().find(|c| c.id == id) else {
+ return;
+ };
+ match (index, value) {
+ (8, Value::Float(r)) => c.radius = *r,
+ (9, Value::Bool(w)) => c.waiting = *w,
+ (10, _) => c.particle = particle.unwrap_or_else(default_cloud_particle),
+ _ => {}
+ }
+ }
+ return;
+ }
if self.rockets.iter().any(|r| r.id == id) {
for (index, _, value) in values {
match (index, value) {
@@ -246,29 +322,34 @@ impl Game<'_> {
}
}
self.falling = falling;
- for p in &mut self.creatures.projectiles {
- p.previous = p.position;
- p.age += 1;
- if matches!(p.kind, ProjectileKind::LargeFireball { .. }) {
- // AbstractHurtingProjectile.tick advances on the client between
- // the tracker updates (ten ticks apart for a ghast's fireball).
- let at = p.position;
- let water = self
- .res
- .facts()
- .get(self.world.block(
- at.x.floor() as i32,
- at.y.floor() as i32,
- at.z.floor() as i32,
- ))
- .fluid
- == horizon_client::blocks::Fluid::Water;
- p.apply_hurting_inertia(water);
- p.position = p.position.add_vector(p.velocity);
- } else {
- p.position = step(p.id, p.position);
+ // Projectiles tick on the client too and fly on between the tracker's
+ // updates (10 to 20 ticks apart); a block stops them there, and only
+ // the server decides what they hit.
+ let mut projectiles = std::mem::take(&mut self.creatures.projectiles);
+ {
+ let w = self.mob_world_base(&[]);
+ let world = super::creatures::ProjWorld {
+ w: &w,
+ targets: Vec::new(),
+ };
+ for p in &mut projectiles {
+ match p.kind {
+ ProjectileKind::Arrow { .. } => remote_arrow_tick(p, &world),
+ // ShulkerBullet.tick: only the server steers it.
+ ProjectileKind::ShulkerBullet { .. } => {
+ p.previous = p.position;
+ p.age += 1;
+ p.position = p.position.add_vector(p.velocity);
+ }
+ _ => {
+ if !matches!(p.tick(&world).1, Hit::None) {
+ p.velocity = Vec3::ZERO;
+ }
+ }
+ }
}
}
+ self.creatures.projectiles = projectiles;
for t in &mut self.tridents {
let id = t.id;
t.remote_step(|at| step(id, at));
@@ -302,12 +383,78 @@ impl Game<'_> {
c.time += 1;
c.position = step(c.id, c.position);
}
- self.potions.step_remote_thrown(&mut step);
+ self.step_remote_thrown();
self.step_remote_hooks(&mut step);
- self.end.step_remote_eyes(|id, at| {
- let at = step(id, Vec3::new(at[0], at[1], at[2]));
- [at.x, at.y, at.z]
- });
+ self.end.step_remote_eyes();
+ self.tick_remote_clouds();
+ // The dragon's fireballs fly on between the tracker's updates, with
+ // their dragon_breath trail (`AbstractHurtingProjectile.getTrailParticle`).
+ let trail = ParticleOptions::simple(ParticleType::DragonBreath);
+ for b in &mut self.dragon_fireballs {
+ let at = b.position;
+ let water = self
+ .res
+ .facts()
+ .get(self.world.block(
+ at.x.floor() as i32,
+ at.y.floor() as i32,
+ at.z.floor() as i32,
+ ))
+ .fluid
+ == horizon_client::blocks::Fluid::Water;
+ b.remote_step(water);
+ let p = b.position;
+ self.particles.add(&trail, [p.x, p.y + 0.5, p.z], [0.0; 3]);
+ }
+ }
+
+ /// `AreaEffectCloud.clientTick`: while waiting, now and then two
+ /// particles near the middle; then about one per square block of the
+ /// disc, drifting (an entity effect stays still).
+ fn tick_remote_clouds(&mut self) {
+ for c in &self.potions.clouds {
+ let r = self.particles.random();
+ if c.waiting && r.next_boolean() {
+ continue;
+ }
+ let (count, spread) = if c.waiting {
+ (2, 0.2)
+ } else {
+ (
+ (std::f32::consts::PI * c.radius * c.radius).ceil() as i32,
+ c.radius,
+ )
+ };
+ for _ in 0..count {
+ let r = self.particles.random();
+ let angle = r.next_float() * std::f32::consts::TAU;
+ let distance = r.next_float().sqrt() * spread;
+ let at = [
+ c.at[0] + f64::from(angle.cos() * distance),
+ c.at[1],
+ c.at[2] + f64::from(angle.sin() * distance),
+ ];
+ let (options, velocity) = if c.particle.ty == ParticleType::EntityEffect {
+ let default = c.waiting && r.next_boolean();
+ let options = if default {
+ default_cloud_particle()
+ } else {
+ c.particle.clone()
+ };
+ (options, [0.0; 3])
+ } else if c.waiting {
+ (c.particle.clone(), [0.0; 3])
+ } else {
+ let v = [
+ (0.5 - r.next_double()) * 0.15,
+ f64::from(0.01f32),
+ (0.5 - r.next_double()) * 0.15,
+ ];
+ (c.particle.clone(), v)
+ };
+ self.particles.add(&options, at, velocity);
+ }
+ }
}
pub(super) fn remove_remote_projectile(&mut self, id: u32) {
@@ -318,6 +465,8 @@ impl Game<'_> {
self.rockets.retain(|r| r.id != id);
self.crystals.retain(|c| c.id != id);
self.potions.remove_remote_thrown(id);
+ self.potions.clouds.retain(|c| c.id != id);
+ self.dragon_fireballs.retain(|b| b.id != id);
self.end.remove_remote_eye(id);
self.remove_remote_hook(id);
}
@@ -330,7 +479,11 @@ impl Game<'_> {
self.tridents.clear();
self.rockets.clear();
self.crystals.clear();
+ // The dragon a server sent goes with its crystals.
+ self.dragon = None;
self.potions.clear_thrown();
+ self.potions.clouds.clear();
+ self.dragon_fireballs.clear();
self.end.clear_remote_eyes();
self.clear_remote_hooks();
}
diff --git a/crates/horizon-client/src/game/remote_vehicles.rs b/crates/horizon-client/src/game/remote_vehicles.rs
index 620aff97c..877ed66e6 100644
--- a/crates/horizon-client/src/game/remote_vehicles.rs
+++ b/crates/horizon-client/src/game/remote_vehicles.rs
@@ -56,6 +56,11 @@ impl Game<'_> {
let p = a.position;
hits.push((a.id as i32, d, [p.x, p.y, p.z]));
}
+ if let Some((i, d, _)) = self.cushion_hit() {
+ let c = &self.cushions[i];
+ let p = c.position;
+ hits.push((c.id as i32, d, [p.x, p.y, p.z]));
+ }
if let Some((i, d)) = self.boat_hit() {
let p = self.boats[i].position;
hits.push((self.boats[i].id as i32, d, [p.x, p.y, p.z]));
@@ -79,6 +84,8 @@ impl Game<'_> {
hits.push((c.id as i32, d, [p.x, p.y, p.z]));
}
}
+ // EnderDragonPart.isPickable: the server's dragon hurts by part.
+ hits.extend(self.remote_dragon_part_hit(eye, dir, reach));
}
let (id, distance, origin) = hits.into_iter().min_by(|a, b| a.1.total_cmp(&b.1))?;
let point = at(distance);
@@ -138,7 +145,10 @@ impl Game<'_> {
self.position_rider();
return true;
}
- let seat = if let Some(i) = self.boats.iter().position(|b| b.id == id) {
+ let seat = if let Some(c) = self.cushions.iter().find(|c| c.id == id) {
+ // The seat does not move; the rider sits on the cushion.
+ Some(c.seat())
+ } else if let Some(i) = self.boats.iter().position(|b| b.id == id) {
// AbstractBoat.tick on the controlling client: steer and move.
let mut b = self.boats[i].clone();
b.input = [keys.left, keys.right, keys.forward, keys.backward];
diff --git a/crates/horizon-client/src/game/render_control.rs b/crates/horizon-client/src/game/render_control.rs
index 0a2f9b715..7c5ff4b2d 100644
--- a/crates/horizon-client/src/game/render_control.rs
+++ b/crates/horizon-client/src/game/render_control.rs
@@ -19,33 +19,7 @@ pub const HELP: &[&str] = &[
impl Game<'_> {
/// Parse `name[k=v,...]` into a registry state (defaults for missing properties).
fn parse_state(&self, text: &str) -> Result {
- let (name, props) = match text.split_once('[') {
- Some((n, rest)) => (n, rest.trim_end_matches(']')),
- None => (text, ""),
- };
- let name = if name.contains(':') {
- name.to_owned()
- } else {
- format!("minecraft:{name}")
- };
- let registry = &self.pack.assets.registry;
- let default = registry
- .default_state(&name)
- .ok_or_else(|| format!("unknown block {name}"))?;
- let mut state = registry
- .state(default)
- .ok_or("missing default state")?
- .clone();
- for pair in props.split(',').filter(|p| !p.is_empty()) {
- let (k, v) = pair
- .split_once('=')
- .ok_or_else(|| format!("bad property {pair}"))?;
- if !state.properties.contains_key(k) {
- return Err(format!("{name} has no property {k}").into());
- }
- state.properties.insert(k.to_owned(), v.to_owned());
- }
- Ok(registry.resolve(&state)?)
+ parse_state(self.pack.assets.registry, text)
}
pub(super) fn render_command(&mut self, words: &[&str]) -> Result> {
let int = |i: usize| -> Result {
@@ -137,3 +111,36 @@ impl Game<'_> {
}
}
}
+
+/// Parse `name[k=v,...]` into a registry state (defaults for missing properties).
+pub(super) fn parse_state(
+ registry: &horizon_world::registry::BlockRegistry,
+ text: &str,
+) -> Result {
+ let (name, props) = match text.split_once('[') {
+ Some((n, rest)) => (n, rest.trim_end_matches(']')),
+ None => (text, ""),
+ };
+ let name = if name.contains(':') {
+ name.to_owned()
+ } else {
+ format!("minecraft:{name}")
+ };
+ let default = registry
+ .default_state(&name)
+ .ok_or_else(|| format!("unknown block {name}"))?;
+ let mut state = registry
+ .state(default)
+ .ok_or("missing default state")?
+ .clone();
+ for pair in props.split(',').filter(|p| !p.is_empty()) {
+ let (k, v) = pair
+ .split_once('=')
+ .ok_or_else(|| format!("bad property {pair}"))?;
+ if !state.properties.contains_key(k) {
+ return Err(format!("{name} has no property {k}").into());
+ }
+ state.properties.insert(k.to_owned(), v.to_owned());
+ }
+ Ok(registry.resolve(&state)?)
+}
diff --git a/crates/horizon-client/src/game/saving.rs b/crates/horizon-client/src/game/saving.rs
index 378ffe9ce..1c6632562 100644
--- a/crates/horizon-client/src/game/saving.rs
+++ b/crates/horizon-client/src/game/saving.rs
@@ -179,6 +179,7 @@ impl Game<'_> {
if keys.is_empty() {
self.prune_entity_memory();
self.save_raids();
+ self.save.save_forced_chunks(&self.streaming.forced)?;
self.save_game_metadata()?;
save.stage = Stage::Writes;
}
diff --git a/crates/horizon-client/src/game/server_mods.rs b/crates/horizon-client/src/game/server_mods.rs
new file mode 100644
index 000000000..f5ee5cdc2
--- /dev/null
+++ b/crates/horizon-client/src/game/server_mods.rs
@@ -0,0 +1,504 @@
+//! Server mods in the game (`docs/mods.md`, "Server mods"): the game that
+//! simulates the world (in-frame single player, the server thread, a LAN
+//! host, the dedicated server) runs them. At the end of each tick it tells
+//! them who joined and left, then what players said, broke and placed since
+//! the last one, then ticks them; a player's command reaches them at once.
+//! Their lines go to the players they name. With no server mod on, each hook
+//! here is one check.
+use super::{Game, lan::LanHost};
+#[cfg(not(feature = "mods"))]
+use horizon_world::registry::BlockStateId;
+
+/// Who did something a server mod hears about, resolved at the tick's end.
+#[cfg_attr(not(feature = "mods"), allow(dead_code))]
+pub(super) enum Who {
+ /// The window's own player, in-frame.
+ Local,
+ /// A connection's player (the server thread's owner is one).
+ Conn(u32),
+ Uuid(u128),
+}
+
+/// What players did during a tick, for the server mods at its end.
+#[cfg_attr(not(feature = "mods"), allow(dead_code))]
+pub(super) enum ModEvent {
+ Chat(Who, String),
+ Block {
+ who: Who,
+ pos: [i32; 3],
+ state: String,
+ placed: bool,
+ },
+}
+
+#[cfg(not(feature = "mods"))]
+impl Game<'_> {
+ pub(super) fn tick_server_mods(&mut self) {}
+ pub(super) fn mod_block_event(&mut self, _pos: [i32; 3], _state: BlockStateId, _placed: bool) {}
+ pub(super) fn mod_player_chat(&mut self, _who: Who, _text: &str) {}
+ pub(super) fn local_server_mod_command(&mut self, _line: &str) -> bool {
+ false
+ }
+ pub(super) fn guest_server_mod_command(
+ &mut self,
+ _host: &mut LanHost,
+ _conn: u32,
+ _line: &str,
+ ) -> bool {
+ false
+ }
+ pub(super) fn apply_mod_block_writes(&mut self) {}
+}
+
+#[cfg(feature = "mods")]
+mod run {
+ use super::{Game, LanHost, ModEvent, Who};
+ use horizon_client::chunk_map::ChunkMap;
+ use horizon_client::{
+ command::args::GameMode as Mode,
+ lan::data::component_nbt,
+ text::{self, Text},
+ };
+ use horizon_mods::{BlockPos, GameMode, Output, ServerPlayer, WorldView};
+ use horizon_protocol::packets::play::{self, Clientbound as C};
+ use horizon_world::registry::{BlockRegistry, BlockStateId};
+
+ /// Blocks queued for levels that don't tick (another dimension, in-frame)
+ /// are kept up to this many; the oldest go first.
+ const MAX_QUEUED_WRITES: usize = 1 << 16;
+
+ /// Capability `world`'s view during a call: the levels' chunks, moved out
+ /// of the game for the call and back after it (no copy).
+ struct LentWorld {
+ registry: &'static BlockRegistry,
+ biomes: std::sync::Arc,
+ dims: Vec<(&'static str, ChunkMap)>,
+ }
+ impl WorldView for LentWorld {
+ fn block(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option {
+ let (_, chunks) = self.dims.iter().find(|(d, _)| *d == dimension)?;
+ let chunk = chunks.get(&(x >> 4, z >> 4))?;
+ Some(state_string(self.registry, chunk.block(x & 15, y, z & 15)))
+ }
+ fn biome(&self, dimension: &str, x: i32, y: i32, z: i32) -> Option {
+ let (_, chunks) = self.dims.iter().find(|(d, _)| *d == dimension)?;
+ let chunk = chunks.get(&(x >> 4, z >> 4))?;
+ Some(self.biomes.get(chunk.biome(x, y, z)).name.clone())
+ }
+ fn has_dimension(&self, dimension: &str) -> bool {
+ matches!(
+ dimension,
+ "minecraft:overworld" | "minecraft:the_nether" | "minecraft:the_end"
+ )
+ }
+ fn check_state(&self, state: &str) -> Result<(), String> {
+ crate::game::render_control::parse_state(self.registry, state)
+ .map(drop)
+ .map_err(|e| format!("{state}: {e}"))
+ }
+ }
+
+ /// `minecraft:oak_log[axis=y]`.
+ fn state_string(registry: &BlockRegistry, state: BlockStateId) -> String {
+ let Some(s) = registry.state(state) else {
+ return "minecraft:air".into();
+ };
+ if s.properties.is_empty() {
+ return s.name.clone();
+ }
+ let props: Vec = s
+ .properties
+ .iter()
+ .map(|(k, v)| format!("{k}={v}"))
+ .collect();
+ format!("{}[{}]", s.name, props.join(","))
+ }
+
+ /// `UUID.toString()`.
+ fn uuid_string(u: u128) -> String {
+ let h = format!("{u:032x}");
+ format!(
+ "{}-{}-{}-{}-{}",
+ &h[..8],
+ &h[8..12],
+ &h[12..16],
+ &h[16..20],
+ &h[20..]
+ )
+ }
+
+ fn mode(id: i32) -> GameMode {
+ match id {
+ 1 => GameMode::Creative,
+ 2 => GameMode::Adventure,
+ 3 => GameMode::Spectator,
+ _ => GameMode::Survival,
+ }
+ }
+
+ impl Game<'_> {
+ /// The players on this game's server: the window's own player
+ /// in-frame, then every connection's. `host` is the hub when it is
+ /// out of `self.lan`.
+ pub(in crate::game) fn server_players(&self, host: Option<&LanHost>) -> Vec {
+ let mut out = Vec::new();
+ if self.options.execution_role.is_client()
+ && self.remote.is_none()
+ && let Some(p) = &self.player
+ {
+ out.push(ServerPlayer {
+ id: self.player_uuid_string(),
+ name: crate::game::chat::PLAYER_NAME.to_owned(),
+ x: p.position.x,
+ y: p.position.y,
+ z: p.position.z,
+ dimension: self.dim.id().to_owned(),
+ game_mode: match self.mode {
+ Mode::Survival => GameMode::Survival,
+ Mode::Creative => GameMode::Creative,
+ Mode::Adventure => GameMode::Adventure,
+ Mode::Spectator => GameMode::Spectator,
+ },
+ health: p.health.health(),
+ });
+ }
+ let guests = host
+ .or(self.lan.as_ref())
+ .into_iter()
+ .flat_map(|h| &h.hub.guests);
+ out.extend(guests.filter(|g| g.placed).map(|g| ServerPlayer {
+ id: uuid_string(g.uuid),
+ name: g.name.clone(),
+ x: g.position[0],
+ y: g.position[1],
+ z: g.position[2],
+ dimension: g.dimension.clone(),
+ game_mode: mode(g.game_mode),
+ health: g.health,
+ }));
+ out
+ }
+
+ /// Whether what players do now reaches server mods: one is running
+ /// and this game simulates the world.
+ fn hears_players(&self) -> bool {
+ self.mods.server && self.remote.is_none()
+ }
+
+ /// The tick's end: joins and leaves, the tick's events, the tick hook.
+ pub(in crate::game) fn tick_server_mods(&mut self) {
+ if !self.options.execution_role.is_client() {
+ // A server has no frames to check its dev mods in.
+ self.reload_dev_mods();
+ }
+ if !self.mods.server {
+ return;
+ }
+ let players = self.server_players(None);
+ let snapshot = self.mod_snapshot_with(players.clone());
+ self.mods.mods.set_snapshot(snapshot);
+ self.lend_world();
+ let before = std::mem::take(&mut self.mods.players);
+ for p in before
+ .iter()
+ .filter(|p| !players.iter().any(|q| q.id == p.id))
+ {
+ self.mods.mods.player_left(p);
+ }
+ for p in players
+ .iter()
+ .filter(|p| !before.iter().any(|q| q.id == p.id))
+ {
+ self.mods.mods.player_joined(p);
+ }
+ for event in std::mem::take(&mut self.mods.events) {
+ let who = |w: &Who| {
+ let id = match w {
+ Who::Local => self.player_uuid_string(),
+ Who::Uuid(u) => uuid_string(*u),
+ Who::Conn(c) => {
+ let guests = self.lan.iter().flat_map(|h| &h.hub.guests);
+ let g = guests.into_iter().find(|g| g.conn == *c);
+ g.map_or_else(String::new, |g| uuid_string(g.uuid))
+ }
+ };
+ players.iter().chain(&before).find(|p| p.id == id).cloned()
+ };
+ match event {
+ ModEvent::Chat(w, text) => {
+ if let Some(p) = who(&w) {
+ self.mods.mods.player_chat(&p, &text);
+ }
+ }
+ ModEvent::Block {
+ who: w,
+ pos,
+ state,
+ placed,
+ } => {
+ let Some(p) = who(&w) else { continue };
+ let pos = BlockPos {
+ x: pos[0],
+ y: pos[1],
+ z: pos[2],
+ };
+ if placed {
+ self.mods.mods.block_placed(&p, pos, &state);
+ } else {
+ self.mods.mods.block_broken(&p, pos, &state);
+ }
+ }
+ }
+ }
+ self.mods.mods.server_tick(self.ticks);
+ self.return_world();
+ self.mods.players = players;
+ self.show_mod_output();
+ self.apply_mod_block_writes();
+ }
+
+ /// Lends the levels' chunks to capability `world` for the calls up to
+ /// [`Game::return_world`], when a running server mod has it.
+ fn lend_world(&mut self) {
+ if !self.mods.world {
+ return;
+ }
+ let mut dims = vec![(self.dim.id(), std::mem::take(&mut self.world.chunks))];
+ for (dim, chunks) in self.levels.parked_chunks() {
+ dims.push((dim.id(), std::mem::take(chunks)));
+ }
+ let registry = self.pack.assets.registry;
+ let biomes = self.res.biomes().clone();
+ self.mods.mods.lend_world(Box::new(LentWorld {
+ registry,
+ biomes,
+ dims,
+ }));
+ }
+
+ /// Puts back the chunks [`Game::lend_world`] lent.
+ fn return_world(&mut self) {
+ let Some(view) = self.mods.mods.take_world() else {
+ return;
+ };
+ let view: Box = view;
+ let Ok(lent) = view.downcast::() else {
+ return;
+ };
+ let mut dims = lent.dims;
+ if let Some(i) = dims.iter().position(|(d, _)| *d == self.dim.id()) {
+ self.world.chunks = dims.swap_remove(i).1;
+ }
+ for (dim, chunks) in self.levels.parked_chunks() {
+ if let Some(i) = dims.iter().position(|(d, _)| *d == dim.id()) {
+ *chunks = dims.swap_remove(i).1;
+ }
+ }
+ }
+
+ /// Makes the blocks server mods set in the level in place, in order,
+ /// as `/setblock` does. Those of other dimensions wait for their level.
+ pub(in crate::game) fn apply_mod_block_writes(&mut self) {
+ if self.mods.block_writes.is_empty() {
+ return;
+ }
+ let dim = self.dim.id();
+ let (now, later): (Vec<_>, Vec<_>) = std::mem::take(&mut self.mods.block_writes)
+ .into_iter()
+ .partition(|(d, _)| d == dim);
+ self.mods.block_writes = later;
+ let registry = self.pack.assets.registry;
+ for (_, b) in now {
+ let state = match crate::game::render_control::parse_state(registry, &b.state) {
+ Ok(state) => state,
+ Err(e) => {
+ log::warn!("Horizon: a server mod set {}: {e}", b.state);
+ continue;
+ }
+ };
+ if let Err(e) = self.place_state([b.x, b.y, b.z], state, false) {
+ log::debug!(
+ "Horizon: a server mod's block at {} {} {}: {e:?}",
+ b.x,
+ b.y,
+ b.z
+ );
+ }
+ }
+ }
+
+ /// A player broke (or placed) `state` at `pos`: the player acting now.
+ pub(in crate::game) fn mod_block_event(
+ &mut self,
+ pos: [i32; 3],
+ state: BlockStateId,
+ placed: bool,
+ ) {
+ if !self.hears_players() {
+ return;
+ }
+ let who = self.lan_acting.map_or(Who::Local, Who::Conn);
+ let state = self.state_string(state);
+ self.mods.events.push(ModEvent::Block {
+ who,
+ pos,
+ state,
+ placed,
+ });
+ }
+
+ /// A chat message a player sent.
+ pub(in crate::game) fn mod_player_chat(&mut self, who: Who, text: &str) {
+ if self.hears_players() {
+ self.mods.events.push(ModEvent::Chat(who, text.to_owned()));
+ }
+ }
+
+ /// `/line` typed by the window's own player in-frame: true when a
+ /// server mod owns it.
+ pub(in crate::game) fn local_server_mod_command(&mut self, line: &str) -> bool {
+ if !self.hears_players() {
+ return false;
+ }
+ let players = self.server_players(None);
+ let Some(me) = players.first().cloned() else {
+ return false;
+ };
+ let snapshot = self.mod_snapshot_with(players);
+ self.mods.mods.set_snapshot(snapshot);
+ self.lend_world();
+ let owned = self.mods.mods.server_command(&me, line);
+ self.return_world();
+ self.show_mod_output();
+ self.apply_mod_block_writes();
+ owned
+ }
+
+ /// `/line` typed by a connection's player: true when a server mod
+ /// owns it, whatever the player's permission level.
+ pub(in crate::game) fn guest_server_mod_command(
+ &mut self,
+ host: &mut LanHost,
+ conn: u32,
+ line: &str,
+ ) -> bool {
+ if !self.hears_players() {
+ return false;
+ }
+ let Some(g) = host.hub.guest(conn) else {
+ return false;
+ };
+ let id = uuid_string(g.uuid);
+ let players = self.server_players(Some(host));
+ let Some(me) = players.iter().find(|p| p.id == id).cloned() else {
+ return false;
+ };
+ let snapshot = self.mod_snapshot_with(players);
+ self.mods.mods.set_snapshot(snapshot);
+ self.lend_world();
+ let owned = self.mods.mods.server_command(&me, line);
+ self.return_world();
+ if !owned {
+ return false;
+ }
+ self.route_mod_output(Some(host));
+ self.apply_mod_block_writes();
+ true
+ }
+
+ /// Sends a server mod's line to the player with this id: the
+ /// window's own chat for the local player, a system message for a
+ /// connection's. `host` is the hub when it is out of `self.lan`.
+ pub(in crate::game) fn tell_server_player(
+ &mut self,
+ host: Option<&mut LanHost>,
+ id: &str,
+ line: Text,
+ ) {
+ let local = self.options.execution_role.is_client()
+ && self.remote.is_none()
+ && self.player.is_some();
+ if local && self.player_uuid_string() == id {
+ self.add_mod_chat_line(line);
+ return;
+ }
+ let Some(host) = host.or(self.lan.as_mut()) else {
+ return;
+ };
+ let to = host
+ .hub
+ .guests
+ .iter()
+ .find(|g| g.placed && uuid_string(g.uuid) == id);
+ if let Some(conn) = to.map(|g| g.conn) {
+ host.hub.send_to(
+ conn,
+ &C::SystemChat(play::SystemChat {
+ content: component_nbt(&line.component()),
+ overlay: false,
+ }),
+ );
+ }
+ }
+
+ /// Routes a server mod's output: `Tell` and `Reply` to their player,
+ /// `Broadcast` to everyone and the log.
+ pub(in crate::game) fn route_server_output(
+ &mut self,
+ mut host: Option<&mut LanHost>,
+ output: Output,
+ ) {
+ let named = |name: &str, text: String| {
+ let mut line = Text::literal(format!("[{name}] ")).with_color(text::GRAY);
+ line.push(Text::literal(text));
+ line
+ };
+ match output {
+ Output::Tell { name, player, text } => {
+ self.tell_server_player(host, &player, named(&name, text));
+ }
+ Output::Reply {
+ player,
+ text,
+ error,
+ } => {
+ let line = Text::literal(text);
+ let line = if error {
+ line.with_color(text::RED)
+ } else {
+ line
+ };
+ self.tell_server_player(host, &player, line);
+ }
+ Output::Broadcast { name, text } => {
+ let plain = format!("[{name}] {text}");
+ if self.options.dedicated.is_some() {
+ super::super::dedicated::log("INFO", &plain);
+ } else {
+ log::info!("{plain}");
+ }
+ for p in self.server_players(host.as_deref()) {
+ let line = named(&name, text.clone());
+ self.tell_server_player(host.as_deref_mut(), &p.id, line);
+ }
+ }
+ Output::SetBlocks {
+ name,
+ dimension,
+ blocks,
+ } => {
+ let queued = &mut self.mods.block_writes;
+ queued.extend(blocks.into_iter().map(|b| (dimension.clone(), b)));
+ if queued.len() > MAX_QUEUED_WRITES {
+ let over = queued.len() - MAX_QUEUED_WRITES;
+ queued.drain(..over);
+ log::warn!(
+ "Horizon: mod {name} set more blocks than wait for their level: {over} dropped"
+ );
+ }
+ }
+ _ => {}
+ }
+ }
+ }
+}
diff --git a/crates/horizon-client/src/game/server_travel.rs b/crates/horizon-client/src/game/server_travel.rs
index 158b2301e..bcaf37a76 100644
--- a/crates/horizon-client/src/game/server_travel.rs
+++ b/crates/horizon-client/src/game/server_travel.rs
@@ -13,6 +13,7 @@ use super::respawn_anchor::RespawnConfig;
use super::{Dim, Game, lan::LanHost};
use horizon_client::{lan::hub::TickCtx, text::Text};
use horizon_core::{geometry::Vec3, position::BlockPos};
+use horizon_protocol::packets::play::{self, Clientbound as C};
/// A trip under way: the player is in the destination's level, whose
/// chunks are loading around `target`.
@@ -103,8 +104,35 @@ impl Game<'_> {
if let Some(pos) = self.nether_portal_inside(at) {
self.portals.player.set_inside(pos, PLAYER_DELAY);
}
+ // `ServerPlayer.showEndCredits`: the player stays out of the world while the
+ // poem rolls, then PERFORM_RESPAWN takes it to its respawn point.
+ let play = host.play.entry(conn).or_default();
+ if play.won_game {
+ if std::mem::take(&mut play.respawn_requested) {
+ play.won_game = false;
+ self.start_server_trip(host, conn, Dim::Overworld, None);
+ self.portals.player.cooldown = 10;
+ }
+ return;
+ }
let (end_portal, gateway) = self.inside_end_portals(at, WIDTH, HEIGHT);
if end_portal {
+ // EndPortalBlock.entityInside: the first exit from the End shows the credits.
+ if self.dim == Dim::End && !host.hub.guest(conn).is_some_and(|g| g.seen_credits) {
+ if let Some(g) = host.hub.guests.iter_mut().find(|g| g.conn == conn) {
+ g.seen_credits = true;
+ }
+ host.play.entry(conn).or_default().won_game = true;
+ // ClientboundGameEventPacket.WIN_GAME.
+ host.hub.send_to(
+ conn,
+ &C::GameEvent(play::GameEvent {
+ event: 4,
+ param: 0.0,
+ }),
+ );
+ return;
+ }
if self.portals.player.cooldown == 0 {
let target = if self.dim == Dim::End {
Dim::Overworld
diff --git a/crates/horizon-client/src/game/sign_edit.rs b/crates/horizon-client/src/game/sign_edit.rs
index 2f50ad9ab..2d010f1f5 100644
--- a/crates/horizon-client/src/game/sign_edit.rs
+++ b/crates/horizon-client/src/game/sign_edit.rs
@@ -6,9 +6,9 @@ use horizon_client::{
containers::BlockEntity,
hud::{HudBatch, rgba},
signs::wood_type,
+ ui::EditBox,
};
use horizon_protocol::packets::play::{self, Clientbound as C, Serverbound as S};
-use std::time::Instant;
use winit::{
event::{ElementState, KeyEvent},
keyboard::{KeyCode, PhysicalKey},
@@ -18,7 +18,16 @@ pub(super) struct SignEditor {
pub pos: (i32, i32, i32),
pub front: bool,
pub line: usize,
- pub opened: Instant,
+ /// The line being edited (`AbstractSignEditScreen`'s text field).
+ edit: EditBox,
+}
+
+fn sign_box() -> EditBox {
+ let mut edit = EditBox::new(0.0, 0.0, 90.0, 9.0);
+ edit.bordered = false;
+ edit.max_length = 384;
+ edit.focused = true;
+ edit
}
impl Game<'_> {
@@ -28,8 +37,9 @@ impl Game<'_> {
pos,
front,
line: 0,
- opened: Instant::now(),
+ edit: sign_box(),
});
+ self.sign_load();
self.keys.clear();
self.right = false;
self.capture(false);
@@ -140,97 +150,154 @@ impl Game<'_> {
/// A key and the text it typed on the sign being edited (the keyboard,
/// or a controller's on-screen keyboard).
pub(super) fn sign_input(&mut self, key: Option, typed: Option<&str>) {
- let Some(edit) = self.sign_edit.as_mut() else {
+ if self.sign_edit.is_none() {
return;
- };
- let front = edit.front;
- let id = sign_line_id(front, edit.line);
+ }
match key {
Some(KeyCode::Escape) => self.close_sign_editor(),
- Some(KeyCode::ArrowUp) => edit.line = (edit.line + 3) & 3,
+ Some(KeyCode::ArrowUp) => self.sign_move_line(3),
Some(KeyCode::ArrowDown | KeyCode::Enter | KeyCode::NumpadEnter) => {
- edit.line = (edit.line + 1) & 3
+ self.sign_move_line(1)
}
- Some(KeyCode::Backspace) => {
- let (line, key) = (edit.line, edit.pos);
- if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&key) {
- let text = if front {
- &mut sign.front
- } else {
- &mut sign.back
- };
- let value = &mut text.lines[line];
- if !self.text_selection.take(id, value) {
- value.pop();
- }
- }
+ Some(
+ key @ (KeyCode::ArrowLeft
+ | KeyCode::ArrowRight
+ | KeyCode::Home
+ | KeyCode::End
+ | KeyCode::Backspace
+ | KeyCode::Delete),
+ ) => {
+ let (ctrl, shift) = (self.has_control_down(), self.has_shift_down());
+ self.sign_change(|edit| {
+ edit.key(key, ctrl, shift);
+ });
}
_ => {
let Some(typed) = typed else {
return;
};
- let line = edit.line;
- let atlas = &self.gui.atlas;
- let width = |s: &str| HudBatch::text_width(atlas, s);
- let Some(key) = self.sign_edit.as_ref().map(|e| e.pos) else {
- return;
- };
- if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&key) {
- let max = sign.max_line_width();
- let text = if front {
- &mut sign.front
- } else {
- &mut sign.back
- };
- self.text_selection.take(id, &mut text.lines[line]);
- for ch in typed.chars().filter(|c| !c.is_control()) {
- let mut next = text.lines[line].clone();
- next.push(ch);
- // TextFieldHelper filter: font.width(s) <= maxTextLineWidth.
- if width(&next) <= max {
- text.lines[line] = next;
- }
- }
- }
+ self.sign_change(|edit| edit.insert_text(typed));
}
}
}
- /// `TextFieldHelper.keyPressed`'s shortcuts on the edited line: a paste
- /// (formatting and carriage returns removed) is taken whole or not at
- /// all, as the line must stay within the sign's width.
- fn sign_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
+ /// Up or down a line: the box writes the line it leaves and loads the next.
+ fn sign_move_line(&mut self, by: usize) {
+ self.sign_write();
+ if let Some(edit) = self.sign_edit.as_mut() {
+ edit.line = (edit.line + by) & 3;
+ }
+ self.sign_load();
+ }
+ /// The edited line's text.
+ fn sign_current(&self) -> Option {
+ let edit = self.sign_edit.as_ref()?;
+ let BlockEntity::Sign(sign) = self.world.block_entities.get(&edit.pos)? else {
+ return None;
+ };
+ let side = if edit.front { &sign.front } else { &sign.back };
+ Some(side.lines[edit.line].clone())
+ }
+ /// `EditBox.setValue` from the line now being edited.
+ fn sign_load(&mut self) {
+ let Some(text) = self.sign_current() else {
+ return;
+ };
+ if let Some(edit) = self.sign_edit.as_mut() {
+ edit.edit.set_value(&text);
+ }
+ }
+ /// The box's text onto the sign, when it still fits the line.
+ fn sign_write(&mut self) {
let Some(edit) = self.sign_edit.as_ref() else {
return;
};
- let (key, front, line) = (edit.pos, edit.front, edit.line);
- let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&key) else {
+ let (pos, front, line, value) = (edit.pos, edit.front, edit.line, edit.edit.value.clone());
+ if !self.sign_fits(&value) {
+ return;
+ }
+ let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&pos) else {
return;
};
- let max = sign.max_line_width();
- let text = if front {
+ let side = if front {
&mut sign.front
} else {
&mut sign.back
};
- let atlas = &self.gui.atlas;
- self.text_selection.apply(
- sign_line_id(front, line),
- &mut text.lines[line],
- shortcut,
- &mut self.clipboard,
- |value, pasted| {
- let next = format!(
- "{value}{}",
- horizon_client::clipboard::helper_clipboard_contents(pasted)
- );
- HudBatch::text_width(atlas, &next) <= max && {
- *value = next;
- true
- }
- },
- );
+ side.lines[line] = value;
}
- /// Done button (`this.width / 2 - 100, this.height / 4 + 144`, 200x20).
+ /// TextFieldHelper: `font.width(s) <= maxTextLineWidth`.
+ fn sign_fits(&self, value: &str) -> bool {
+ let Some(edit) = self.sign_edit.as_ref() else {
+ return false;
+ };
+ let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&edit.pos) else {
+ return false;
+ };
+ HudBatch::text_width(&self.gui.atlas, value) <= sign.max_line_width()
+ }
+ /// Edit the line, then keep the result only when it still fits.
+ fn sign_change(&mut self, f: impl FnOnce(&mut EditBox)) {
+ let before = self
+ .sign_edit
+ .as_ref()
+ .map(|e| (e.edit.value.clone(), e.edit.cursor, e.edit.highlight));
+ if let Some(edit) = self.sign_edit.as_mut() {
+ f(&mut edit.edit);
+ let clean = horizon_client::clipboard::strip_formatting(&edit.edit.value);
+ if clean != edit.edit.value {
+ let n = horizon_client::ui::char_len(&clean);
+ edit.edit.value = clean;
+ edit.edit.cursor = edit.edit.cursor.min(n);
+ edit.edit.highlight = edit.edit.highlight.min(n);
+ }
+ }
+ self.sign_keep(before);
+ }
+ /// Write the box when the line still fits; otherwise put the old text back.
+ fn sign_keep(&mut self, before: Option<(String, usize, usize)>) {
+ let value = self
+ .sign_edit
+ .as_ref()
+ .map(|e| e.edit.value.clone())
+ .unwrap_or_default();
+ if self.sign_fits(&value) {
+ self.sign_write();
+ } else if let (Some(edit), Some((value, cursor, highlight))) =
+ (self.sign_edit.as_mut(), before)
+ {
+ edit.edit.value = value;
+ edit.edit.cursor = cursor;
+ edit.edit.highlight = highlight;
+ }
+ }
+ /// `TextFieldHelper.keyPressed`'s shortcuts on the edited line. Paste
+ /// reads `getClipboardContents` before `insertText`. A paste that would
+ /// pass the sign's width is refused whole.
+ fn sign_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
+ if shortcut == horizon_client::clipboard::EditShortcut::Paste {
+ let raw = horizon_client::clipboard::Clipboard::get(&mut self.clipboard);
+ let text = horizon_client::clipboard::helper_clipboard_contents(&raw);
+ self.sign_change(|edit| edit.insert_text(&text));
+ return;
+ }
+ let before = self
+ .sign_edit
+ .as_ref()
+ .map(|e| (e.edit.value.clone(), e.edit.cursor, e.edit.highlight));
+ if let Some(edit) = self.sign_edit.as_mut() {
+ edit.edit.shortcut(shortcut, &mut self.clipboard);
+ let clean = horizon_client::clipboard::strip_formatting(&edit.edit.value);
+ if clean != edit.edit.value {
+ let n = horizon_client::ui::char_len(&clean);
+ edit.edit.value = clean;
+ edit.edit.cursor = edit.edit.cursor.min(n);
+ edit.edit.highlight = edit.edit.highlight.min(n);
+ }
+ }
+ self.sign_keep(before);
+ }
+ /// Done button (`this.width / 2 - 100, this.height / 4 + 144`, 200x20),
+ /// or a click on a line (`EditBox.onClick`).
pub(super) fn sign_edit_click(&mut self, size: [u32; 2]) {
let b = HudBatch::new(size);
let (x, y) = (b.width / 2.0 - 100.0, b.height / 4.0 + 144.0);
@@ -238,7 +305,56 @@ impl Game<'_> {
if mx >= x && mx < x + 200.0 && my >= y && my < y + 20.0 {
self.audio.play_button_click();
self.close_sign_editor();
+ return;
}
+ let Some((cx, top, line_height, max_width, lines)) = self.sign_lines(b.width) else {
+ return;
+ };
+ let shift = self.has_shift_down();
+ for i in 0..lines.len() {
+ let ly = top + i as f32 * line_height;
+ let left = cx - max_width / 2.0;
+ if mx < left || mx >= left + max_width || my < ly || my >= ly + line_height {
+ continue;
+ }
+ let current = self.sign_edit.as_ref().map(|e| e.line);
+ if current != Some(i) {
+ self.sign_move_line((i + 4 - current.unwrap_or(0)) & 3);
+ }
+ let value = self
+ .sign_edit
+ .as_ref()
+ .map(|e| e.edit.value.clone())
+ .unwrap_or_default();
+ let lw = HudBatch::text_width(&self.gui.atlas, &value);
+ let text_x = cx - (lw as i32 / 2) as f32;
+ if let Some(edit) = self.sign_edit.as_mut() {
+ edit.edit.x = text_x;
+ edit.edit.y = ly;
+ edit.edit.width = max_width;
+ edit.edit.click(&self.gui.atlas, mx, shift, false);
+ }
+ self.sign_write();
+ return;
+ }
+ }
+ /// Centre x, the first line's y, the line height, the width limit and the four lines.
+ fn sign_lines(&self, width: f32) -> Option<(f32, f32, f32, f32, Vec)> {
+ let edit = self.sign_edit.as_ref()?;
+ let BlockEntity::Sign(sign) = self.world.block_entities.get(&edit.pos)? else {
+ return None;
+ };
+ let text = if edit.front { &sign.front } else { &sign.back };
+ let line_height = sign.line_height();
+ let y = if sign.hanging { 125.0 } else { 90.0 };
+ let top = y - (4.0 * line_height / 2.0).floor();
+ Some((
+ width / 2.0,
+ top,
+ line_height,
+ sign.max_line_width(),
+ text.lines.to_vec(),
+ ))
}
pub(super) fn draw_sign_editor(&self, batch: &mut HudBatch) {
let Some(edit) = &self.sign_edit else { return };
@@ -304,23 +420,48 @@ impl Game<'_> {
let color = rgba((color >> 16) as u8, (color >> 8) as u8, color as u8, 255);
let line_height = sign.line_height();
let midpoint = (4.0 * line_height / 2.0).floor();
- let blink = (edit.opened.elapsed().as_millis() / 300) % 2 == 0;
for (i, line) in text.lines.iter().enumerate() {
- let lw = HudBatch::text_width(atlas, line);
+ let shown = if i == edit.line {
+ edit.edit.value.as_str()
+ } else {
+ line.as_str()
+ };
+ let lw = HudBatch::text_width(atlas, shown);
let x = cx - (lw as i32 / 2) as f32;
let ly = y + i as f32 * line_height - midpoint;
- batch.text(atlas, line, x, ly, color, false);
- if i == edit.line
- && self
- .text_selection
- .covers(sign_line_id(edit.front, i), line)
- {
- // AbstractSignEditScreen: the selection from its start to its end.
- batch.text_highlight(atlas, (x, ly, lw, line_height), true);
+ batch.text(atlas, shown, x, ly, color, false);
+ if i != edit.line {
+ continue;
}
- if i == edit.line && blink {
- // TextCursorUtils.extractAppendCursor: an underscore after the text.
- batch.text(atlas, "_", x + lw, ly, color, false);
+ let value = &edit.edit.value;
+ if edit.edit.cursor != edit.edit.highlight {
+ let (a, b) = (
+ edit.edit.cursor.min(edit.edit.highlight),
+ edit.edit.cursor.max(edit.edit.highlight),
+ );
+ let pre: String = value.chars().take(a).collect();
+ let sel: String = value.chars().skip(a).take(b - a).collect();
+ batch.text_highlight(
+ atlas,
+ (
+ x + HudBatch::text_width(atlas, &pre),
+ ly,
+ HudBatch::text_width(atlas, &sel),
+ line_height,
+ ),
+ true,
+ );
+ }
+ if edit.edit.cursor_visible() {
+ let pre: String = value.chars().take(edit.edit.cursor).collect();
+ batch.fill(
+ atlas,
+ x + HudBatch::text_width(atlas, &pre),
+ ly,
+ 1.0,
+ line_height,
+ color,
+ );
}
}
let (bx, by) = (w / 2.0 - 100.0, h / 4.0 + 144.0);
@@ -344,8 +485,3 @@ impl Game<'_> {
);
}
}
-
-/// The sign line being edited, for Select All.
-fn sign_line_id(front: bool, line: usize) -> horizon_client::clipboard::FieldId {
- (if front { "sign.front" } else { "sign.back" }, line)
-}
diff --git a/crates/horizon-client/src/game/spill.rs b/crates/horizon-client/src/game/spill.rs
index b7283c57b..b1953596b 100644
--- a/crates/horizon-client/src/game/spill.rs
+++ b/crates/horizon-client/src/game/spill.rs
@@ -171,8 +171,8 @@ pub(super) struct Spawn {
pub(super) struct Spill {
pub(super) spawns: Vec,
/// Experience orbs (`ExperienceOrb.award`): where and how much, each
- /// having drawn its merge id from the level random.
- pub(super) orbs: Vec<([f64; 3], u32)>,
+ /// and the merge id it drew from the level random.
+ pub(super) orbs: Vec<([f64; 3], u32, i32)>,
/// Block entities the behaviour removed, for the game's own follow-ups
/// (open screens, playing songs).
pub(super) removed: Vec<([i32; 3], BlockEntity)>,
@@ -342,8 +342,8 @@ impl GameLevel<'_> {
while amount > 0 {
let value = removal::orb_value(amount);
amount -= value;
- let _merge_id = self.world.random.next_int_bound(40);
- self.spill.orbs.push((at, value));
+ let merge_id = self.world.random.next_int_bound(40).unwrap_or(0);
+ self.spill.orbs.push((at, value, merge_id));
}
}
/// `BlockEntity.preRemoveSideEffects` and `removeBlockEntity` for the block
@@ -398,8 +398,12 @@ impl GameLevel<'_> {
}
}
PreRemove::Campfire => {
- for _ in 0..4 {
- self.drop_item_stack(pos, None);
+ let items = match &entity {
+ Some(BlockEntity::Campfire(c)) => c.items.clone(),
+ _ => Default::default(),
+ };
+ for stack in items {
+ self.drop_item_stack(pos, stack);
}
}
PreRemove::Jukebox => {
@@ -579,8 +583,8 @@ impl Game<'_> {
let motion = s.motion.unwrap_or_else(new_item_motion);
self.spawn_item(s.stack, s.pos, motion, s.delay);
}
- for (at, value) in spill.orbs {
- self.add_orb(at, value);
+ for (at, value, merge_id) in spill.orbs {
+ self.award_orb(at, value, merge_id);
}
for (pos, entity) in spill.removed {
let key = (pos[0], pos[1], pos[2]);
diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs
index f7f05e1c4..c5ddcf9a1 100644
--- a/crates/horizon-client/src/game/stations.rs
+++ b/crates/horizon-client/src/game/stations.rs
@@ -135,8 +135,10 @@ pub(super) struct Station {
pub(super) offers: EnchantOffers,
bookcases: i32,
pub(super) anvil: AnvilResult,
- /// Anvil rename box text.
+ /// Anvil rename box text (`AnvilMenu.itemName`).
pub(super) name: String,
+ /// The box itself (`AnvilScreen`'s `EditBox` of 50, unbordered).
+ pub(super) rename: horizon_client::ui::EditBox,
/// Stonecutter: the menu's recipe list (horizon_client::menu), its
/// `selectedRecipeIndex` and the screen's first shown index.
pub(super) stone: horizon_client::menu::Stonecutter,
@@ -146,8 +148,6 @@ pub(super) struct Station {
anvil_last: Option,
/// Anvil on a server: the name last sent (the client menu's `itemName`).
pub(super) anvil_sent: Option,
- /// When the screen opened: the rename box has the focus from then.
- opened: std::time::Instant,
pub(super) last_sound: u64,
/// Villager trading state.
pub(super) merchant: Option>,
@@ -169,12 +169,12 @@ impl Station {
bookcases: 0,
anvil: AnvilResult::default(),
name: String::new(),
+ rename: anvil_box(),
stone: Default::default(),
selected: None,
start: 0,
anvil_last: None,
anvil_sent: None,
- opened: std::time::Instant::now(),
last_sound: 0,
merchant: None,
beacon: [None; 2],
@@ -713,7 +713,8 @@ impl Game<'_> {
if let Some(rest) = self.give(stack)
&& let Some(eye) = self.eye_position()
{
- self.spawn_item(rest, [eye[0], eye[1] - 0.3, eye[2]], [0.0, 0.1, 0.0], 40);
+ // Inventory.placeItemBackInInventory: `player.drop(stack, false)`.
+ self.throw_from_eyes(rest, eye, false);
}
}
/// `Player.giveExperienceLevels`.
@@ -868,6 +869,9 @@ impl Game<'_> {
if kind == Kind::Stonecutter && self.stonecutter_click(local) {
return true;
}
+ if kind == Kind::Anvil && !right && self.anvil_name_click(ox, oy) {
+ return true;
+ }
}
let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else {
return true;
@@ -894,6 +898,8 @@ impl Game<'_> {
.as_ref()
.map(|i| stations::hover_name(&|id| self.pack.names.display_item(id), i))
.unwrap_or_default();
+ let name = s.name.clone();
+ s.rename.set_value(&name);
}
self.station_changed();
}
@@ -960,21 +966,29 @@ impl Game<'_> {
let Some(s) = self.station.as_mut() else {
return;
};
- let cleared = self.text_selection.take(ANVIL_NAME, &mut s.name);
if backspace {
- if !cleared {
- s.name.pop();
- }
+ s.rename.delete_chars(-1);
} else if let Some(t) = text {
- for c in t.chars().filter(|c| !c.is_control()) {
- if s.name.chars().count() < ANVIL_NAME_CHARS {
- s.name.push(c);
- }
- }
+ s.rename.insert_text(t);
}
+ s.name.clone_from(&s.rename.value);
self.station_changed();
self.remote_anvil_rename();
}
+ /// `AnvilScreen.keyPressed`: the rename box handles the key.
+ pub(super) fn station_key(&mut self, key: winit::keyboard::KeyCode) -> bool {
+ let (ctrl, shift) = (self.has_control_down(), self.has_shift_down());
+ let Some(s) = self.station.as_mut() else {
+ return false;
+ };
+ if !s.rename.key(key, ctrl, shift) {
+ return false;
+ }
+ s.name.clone_from(&s.rename.value);
+ self.station_changed();
+ self.remote_anvil_rename();
+ true
+ }
/// Ctrl+A/C/V/X in the anvil's rename box (an `EditBox` of 50) or the
/// recipe book's search box.
pub(super) fn station_shortcut(&mut self, shortcut: horizon_client::clipboard::EditShortcut) {
@@ -985,18 +999,52 @@ impl Game<'_> {
let Some(s) = self.station.as_mut() else {
return;
};
- if Self::append_shortcut(
- &mut self.text_selection,
- &mut self.clipboard,
- ANVIL_NAME,
- &mut s.name,
- shortcut,
- ANVIL_NAME_CHARS,
- ) {
+ if s.rename.shortcut(shortcut, &mut self.clipboard) {
+ s.name.clone_from(&s.rename.value);
self.station_changed();
self.remote_anvil_rename();
}
}
+ /// A click in the anvil's name box (`EditBox.onClick`).
+ fn anvil_name_click(&mut self, ox: f32, oy: f32) -> bool {
+ let open = self
+ .station
+ .as_ref()
+ .is_some_and(|s| s.kind == Kind::Anvil && s.inputs[0].is_some());
+ if !open {
+ return false;
+ }
+ let (x, y, w, h) = (ox + 62.0, oy + 24.0, 103.0, 12.0);
+ let (mx, my) = self.cursor;
+ if mx < x || my < y || mx >= x + w || my >= y + h {
+ return false;
+ }
+ let shift = self.has_shift_down();
+ let Some(s) = self.station.as_mut() else {
+ return false;
+ };
+ s.rename.x = x;
+ s.rename.y = y;
+ s.rename.width = w;
+ s.rename.click(&self.gui.atlas, mx, shift, false);
+ true
+ }
+ /// AnvilScreen's name box, drawn after the station picture.
+ fn draw_anvil_name(&mut self, batch: &mut HudBatch, ox: f32, oy: f32) {
+ let Some(s) = self.station.as_mut() else {
+ return;
+ };
+ let edit = &mut s.rename;
+ edit.x = ox + 62.0;
+ edit.y = oy + 24.0;
+ edit.width = 103.0;
+ edit.height = 12.0;
+ edit.bordered = false;
+ edit.focused = true;
+ edit.text_color = u32::MAX;
+ edit.max_length = ANVIL_NAME_CHARS;
+ edit.draw(batch, &self.gui.atlas, None);
+ }
// ---------------------------------------------------------------- drawing
@@ -1094,6 +1142,10 @@ impl Game<'_> {
let (ox, oy) = self.inventory_origin(batch);
let local = (self.cursor.0 - ox, self.cursor.1 - oy);
let mut tooltip: Option> = None;
+ let mut anvil_name = false;
+ // Keep item tooltips as stacks until drawing: text alone loses the
+ // bundle contents component (including in the player's inventory).
+ let mut tooltip_stack: Option = None;
{
let atlas = &self.gui.atlas;
batch.fill(
@@ -1428,18 +1480,8 @@ impl Game<'_> {
);
}
if s.inputs[0].is_some() {
- // AnvilScreen's name box: white, 103 wide, no inverted highlight.
- horizon_client::ui::append_field(
- batch,
- atlas,
- &s.name,
- (ox + 62.0, oy + 24.0, 103.0),
- (u32::MAX, true),
- ANVIL_NAME_CHARS,
- self.text_selection.covers(ANVIL_NAME, &s.name),
- false,
- s.opened.elapsed().as_millis(),
- );
+ // Drawn once this borrow of the station ends.
+ anvil_name = true;
}
let cost = s.anvil.cost;
if cost > 0 {
@@ -1579,13 +1621,16 @@ impl Game<'_> {
);
self.draw_item(batch, &result, ox + x, oy + y);
if hover {
- tooltip = Some(self.stack_tooltip(&result));
+ tooltip_stack = Some(result);
}
}
}
}
}
}
+ if anvil_name {
+ self.draw_anvil_name(batch, ox, oy);
+ }
let drag = self.drag_view();
for i in self.station_slots().unwrap_or_default() {
let Some((sx, sy)) = self.slot_position_any(i) else {
@@ -1606,13 +1651,16 @@ impl Game<'_> {
);
if self.carried.is_none()
&& tooltip.is_none()
+ && tooltip_stack.is_none()
&& let Some(stack) = self.slot_mut(slot).clone()
{
- tooltip = Some(self.stack_tooltip(&stack));
+ tooltip_stack = Some(stack);
}
}
if self.carried.is_some() {
self.draw_carried(batch);
+ } else if let Some(stack) = tooltip_stack {
+ self.draw_stack_tooltip(batch, &stack, self.cursor.0, self.cursor.1);
} else if let Some(lines) = tooltip {
self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
}
@@ -1656,6 +1704,8 @@ impl Game<'_> {
};
let name = if let Some(n) = stack.custom_name() {
n.to_owned()
+ } else if let Some(n) = stack.item_name() {
+ n
} else if stack.data().is_some_and(|d| d.ominous_banner) {
self.translate("block.minecraft.ominous_banner", "Ominous Banner")
} else if stack.data().and_then(|d| d.potion.as_ref()).is_some()
@@ -1682,7 +1732,9 @@ impl Game<'_> {
// ItemContainerContents.addToTooltip.
let hover_name = |s: &ItemStack| {
s.custom_name()
- .map_or_else(|| self.pack.names.display_item(&s.item), str::to_owned)
+ .map(str::to_owned)
+ .or_else(|| s.item_name())
+ .unwrap_or_else(|| self.pack.names.display_item(&s.item))
};
if display.shows("minecraft:container") {
for text in
@@ -1907,32 +1959,65 @@ impl Game<'_> {
if lines.is_empty() {
return;
}
- let lines: Vec<_> = lines
+ let lines = Self::resolved(lines);
+ let atlas = &self.gui.atlas;
+ let (x, y, w, h) =
+ Self::tooltip_geometry(atlas, &lines, (x, y), (batch.width, batch.height), 0.0);
+ Self::tooltip_box(batch, atlas, x, y, w, h);
+ Self::tooltip_text(batch, atlas, &lines, x, y);
+ }
+ /// A tooltip's lines with their legacy codes resolved and their colours.
+ fn resolved>(
+ lines: &[(T, u32)],
+ ) -> Vec<(horizon_client::text::Text, u32)> {
+ lines
.iter()
.map(|(text, color)| {
let text: horizon_client::text::Text = text.clone().into();
(text.resolve_legacy(), *color)
})
- .collect();
- let atlas = &self.gui.atlas;
+ .collect()
+ }
+ /// The tooltip's text's top-left corner and the box's size: beside the
+ /// cursor, kept on screen, `extra` pixels taller than the text.
+ fn tooltip_geometry(
+ atlas: &horizon_client::hud::HudAtlas,
+ lines: &[(horizon_client::text::Text, u32)],
+ (x, y): (f32, f32),
+ (width, height): (f32, f32),
+ extra: f32,
+ ) -> (f32, f32, f32, f32) {
let w = lines
.iter()
.map(|(t, _)| atlas.font.width_text(t))
- .fold(0.0, f32::max);
- let h = if lines.len() == 1 {
+ .fold(0.0, f32::max)
+ .max(if extra > 0.0 { 96.0 } else { 0.0 });
+ let text_h = if lines.len() == 1 {
8.0
} else {
8.0 + 2.0 + (lines.len() - 1) as f32 * 10.0
};
+ let h = text_h + extra;
let mut x = x + 12.0;
let mut y = y - 12.0;
- if x + w > batch.width - 4.0 {
+ if x + w > width - 4.0 {
x = (x - 28.0 - w).max(4.0);
}
- if y + h + 3.0 > batch.height {
- y = batch.height - h - 3.0;
+ if y + h + 3.0 > height {
+ y = height - h - 3.0;
}
y = y.max(4.0);
+ (x, y, w, h)
+ }
+ /// The box and its frame sprites.
+ fn tooltip_box(
+ batch: &mut HudBatch,
+ atlas: &horizon_client::hud::HudAtlas,
+ x: f32,
+ y: f32,
+ w: f32,
+ h: f32,
+ ) {
batch.fill(atlas, x - 3.0, y - 4.0, w + 6.0, 1.0, rgba(16, 0, 16, 240));
batch.fill(
atlas,
@@ -1968,12 +2053,137 @@ impl Game<'_> {
h + 4.0,
rgba(60, 0, 190, 80),
);
+ }
+ fn tooltip_text(
+ batch: &mut HudBatch,
+ atlas: &horizon_client::hud::HudAtlas,
+ lines: &[(horizon_client::text::Text, u32)],
+ x: f32,
+ y: f32,
+ ) {
let mut ty = y;
for (i, (text, color)) in lines.iter().enumerate() {
batch.text_styled(atlas, text, x, ty, *color, true);
ty += if i == 0 { 12.0 } else { 10.0 };
}
}
+ /// A stack's tooltip: its lines, and under them a bundle's contents
+ /// (`ClientBundleTooltip`: the 4 wide grid, the `+N` of what it leaves
+ /// out, and the weight bar).
+ pub(super) fn draw_stack_tooltip(
+ &mut self,
+ batch: &mut HudBatch,
+ stack: &ItemStack,
+ x: f32,
+ y: f32,
+ ) {
+ let lines = Self::resolved(&self.stack_tooltip(stack));
+ if lines.is_empty() {
+ return;
+ }
+ // The component's height does not depend on where it is drawn, so a
+ // probe at the origin gives the box its extra height.
+ let probe = horizon_client::bundle::tooltip_layout(self.res.items(), stack, 0.0, 0.0, 96.0);
+ let extra = probe.as_ref().map_or(0.0, |l| l.height + 2.0);
+ let atlas = &self.gui.atlas;
+ let (x, y, w, h) =
+ Self::tooltip_geometry(atlas, &lines, (x, y), (batch.width, batch.height), extra);
+ Self::tooltip_box(batch, atlas, x, y, w, h);
+ let text_h = h - extra;
+ Self::tooltip_text(batch, atlas, &lines, x, y);
+ let Some(layout) =
+ horizon_client::bundle::tooltip_layout(self.res.items(), stack, x, y + text_h + 2.0, w)
+ else {
+ return;
+ };
+ self.draw_bundle_tooltip(batch, &layout);
+ }
+ /// `ClientBundleTooltip.extractImage`: the slots, the count past them and
+ /// the progress bar.
+ fn draw_bundle_tooltip(
+ &mut self,
+ batch: &mut HudBatch,
+ layout: &horizon_client::bundle::TooltipLayout,
+ ) {
+ for (at, stack) in &layout.slots {
+ // Each draw takes the atlas on its own: the item's needs `&mut self`.
+ horizon_client::ui::nine_slice(
+ batch,
+ &self.gui.atlas,
+ "gui/sprites/container/bundle/slot_background",
+ at[0],
+ at[1],
+ 24.0,
+ 24.0,
+ u32::MAX,
+ );
+ let stack = stack.clone();
+ let [x, y] = *at;
+ self.draw_item(batch, &stack, x + 4.0, y + 4.0);
+ }
+ let atlas = &self.gui.atlas;
+ if let Some((at, hidden)) = layout.overflow {
+ let label = horizon_client::text::Text::literal(format!("+{hidden}"));
+ let w = atlas.font.width_text(&label);
+ batch.text_styled(
+ atlas,
+ &label,
+ at[0] + 12.0 - (w / 2.0).floor(),
+ at[1] + 10.0,
+ u32::MAX,
+ true,
+ );
+ }
+ if let Some((at, description)) = layout
+ .empty_description
+ .zip(Some("item.minecraft.bundle.empty.description"))
+ {
+ let text = horizon_client::text::Text::translate(description, &[]);
+ let mut ty = at[1];
+ for line in atlas.font.split_lines(&text, layout.width) {
+ batch.text_styled(atlas, &line.0, at[0], ty, 0xFFAA_AAAA, false);
+ ty += 9.0;
+ }
+ }
+ let [bx, by] = layout.bar;
+ let fill_sprite = if layout.full {
+ "gui/sprites/container/bundle/bundle_progressbar_full"
+ } else {
+ "gui/sprites/container/bundle/bundle_progressbar_fill"
+ };
+ horizon_client::ui::nine_slice(
+ batch,
+ atlas,
+ fill_sprite,
+ bx + 1.0,
+ by,
+ layout.fill,
+ 13.0,
+ u32::MAX,
+ );
+ horizon_client::ui::nine_slice(
+ batch,
+ atlas,
+ "gui/sprites/container/bundle/bundle_progressbar_border",
+ bx,
+ by,
+ 96.0,
+ 13.0,
+ u32::MAX,
+ );
+ if let Some(key) = layout.label {
+ let label = horizon_client::text::Text::translate(key, &[]);
+ let w = atlas.font.width_text(&label);
+ batch.text_styled(
+ atlas,
+ &label,
+ bx + 48.0 - (w / 2.0).floor(),
+ by + 3.0,
+ u32::MAX,
+ true,
+ );
+ }
+ }
/// Hovered-slot tooltip on the plain inventory, crafting and container screens.
pub(super) fn draw_slot_tooltip(&mut self, batch: &mut HudBatch) {
if self.carried.is_some() {
@@ -1984,8 +2194,7 @@ impl Game<'_> {
};
let stack = self.slot_view(slot);
if let Some(stack) = stack {
- let lines = self.stack_tooltip(&stack);
- self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
+ self.draw_stack_tooltip(batch, &stack, self.cursor.0, self.cursor.1);
} else if let Some(text) = self.crafter_tooltip(slot) {
self.draw_tooltip_lines(
batch,
@@ -2041,5 +2250,13 @@ impl Game<'_> {
}
/// The anvil's rename box (`AnvilScreen`: `setMaxLength(50)`).
-const ANVIL_NAME: horizon_client::clipboard::FieldId = ("anvil.name", 0);
const ANVIL_NAME_CHARS: usize = 50;
+
+fn anvil_box() -> horizon_client::ui::EditBox {
+ let mut edit = horizon_client::ui::EditBox::new(0.0, 0.0, 103.0, 12.0);
+ edit.bordered = false;
+ edit.max_length = ANVIL_NAME_CHARS;
+ edit.text_color = u32::MAX;
+ edit.focused = true;
+ edit
+}
diff --git a/crates/horizon-client/src/game/storage.rs b/crates/horizon-client/src/game/storage.rs
index 1bcb6a524..e5cb0ab26 100644
--- a/crates/horizon-client/src/game/storage.rs
+++ b/crates/horizon-client/src/game/storage.rs
@@ -33,6 +33,55 @@ impl Game<'_> {
self.container = Some(key);
self.ender_open = Some(key);
}
+ /// The block above `key` is a redstone conductor.
+ fn conductor_above(&self, key: (i32, i32, i32)) -> bool {
+ let above = self.world.block(key.0, key.1 + 1, key.2);
+ self.res.behaviours().facts(above).flags
+ & horizon_world::level::data::state_flags::CONDUCTOR
+ != 0
+ }
+ /// `ChestBlock.isChestBlockedAt`: a redstone conductor above the chest or
+ /// a cat sitting on it.
+ fn chest_blocked_at(&self, key: (i32, i32, i32)) -> bool {
+ if self.conductor_above(key) {
+ return true;
+ }
+ // isCatSittingOnChest: a cat whose box meets the block above.
+ let area = horizon_core::geometry::Aabb::new(
+ horizon_core::geometry::Vec3::new(
+ f64::from(key.0),
+ f64::from(key.1 + 1),
+ f64::from(key.2),
+ ),
+ horizon_core::geometry::Vec3::new(
+ f64::from(key.0 + 1),
+ f64::from(key.1 + 2),
+ f64::from(key.2 + 1),
+ ),
+ );
+ self.mobs.iter().any(|m| {
+ m.species() == horizon_client::mobs::Species::Cat
+ && m.alive()
+ && horizon_client::mobs::tame::cat_sitting(m)
+ && m.bounds().intersects(area)
+ })
+ }
+ /// `ChestBlock.getMenuProvider` (`combine(.., false)`) and
+ /// `EnderChestBlock.useWithoutItem`: a blocked chest, or a double chest
+ /// with either half blocked, opens no menu.
+ pub(super) fn chest_menu_blocked(&self, key: (i32, i32, i32), name: &str) -> bool {
+ match name {
+ "minecraft:chest" | "minecraft:trapped_chest" => {
+ self.chest_blocked_at(key)
+ || self
+ .chest_partner(key)
+ .is_some_and(|(other, _)| self.chest_blocked_at(other))
+ }
+ // The ender chest only looks at the block above (no cat check).
+ "minecraft:ender_chest" => self.conductor_above(key),
+ _ => false,
+ }
+ }
/// Closing it copies the items back and leaves no block-entity contents.
pub(super) fn close_ender_chest(&mut self) {
let Some(key) = self.ender_open.take() else {
diff --git a/crates/horizon-client/src/game/text_displays.rs b/crates/horizon-client/src/game/text_displays.rs
index f6c946bcc..45bd64fa7 100644
--- a/crates/horizon-client/src/game/text_displays.rs
+++ b/crates/horizon-client/src/game/text_displays.rs
@@ -210,6 +210,7 @@ impl Game<'_> {
if bg != 0 {
batch.fill(
atlas,
+ // submitTextBackground(-1, -1, width, height): corners, not a size.
-1.0,
-1.0,
width + 1.0,
diff --git a/crates/horizon-client/src/game/trading.rs b/crates/horizon-client/src/game/trading.rs
index 87e0c18c6..6986d8baa 100644
--- a/crates/horizon-client/src/game/trading.rs
+++ b/crates/horizon-client/src/game/trading.rs
@@ -803,8 +803,7 @@ impl Game<'_> {
text.split('\n').map(|l| (l.to_owned(), u32::MAX)).collect();
self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
} else if let Some(stack) = tooltip {
- let lines = self.stack_tooltip(&stack);
- self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
+ self.draw_stack_tooltip(batch, &stack, self.cursor.0, self.cursor.1);
}
true
}
diff --git a/crates/horizon-client/src/game/trident.rs b/crates/horizon-client/src/game/trident.rs
index c31094596..d934e85aa 100644
--- a/crates/horizon-client/src/game/trident.rs
+++ b/crates/horizon-client/src/game/trident.rs
@@ -1,7 +1,8 @@
//! Tridents: `TridentItem.releaseUsing` (throw after 10 ticks, or Riptide in
//! water or rain) and `ThrownTrident` (arrow flight with 0.99 water inertia,
//! 8 damage plus Impaling, the reversed bounce off a hit, sticking, Loyalty's
-//! return to the owner, pickup) with `ThrownTridentRenderer`.
+//! return to the owner, pickup) with `ThrownTridentRenderer`, and Channeling's
+//! lightning on a hit (`channeling.json`).
use super::{Game, view_vector};
use horizon_client::{
collisions::SceneCollisions,
@@ -10,7 +11,8 @@ use horizon_client::{
mobs::{Damage, DamageKind, Who, anim::Poses},
};
use horizon_core::{
- geometry::{Aabb, Vec3},
+ geometry::{Aabb, Vec3, traverse_blocks},
+ position::BlockPos,
random::RandomSource,
};
@@ -154,6 +156,69 @@ impl Game<'_> {
p.auto_spin_attack_dmg = 0.0;
}
}
+ /// The `summon_entity` and `play_sound` effects of `channeling.json`: in a
+ /// thunderstorm (`weather_check`) a spot that sees the sky (`can_see_sky`)
+ /// gets a lightning bolt and the thunder sound.
+ fn channel_lightning(&mut self, at: [f64; 3]) {
+ // Level.isThundering: the thunder level, in dimensions with weather.
+ if self.dim != super::Dim::Overworld || self.world.weather.levels(1.0).1 <= 0.9 {
+ return;
+ }
+ // BlockAndLightGetter.canSeeSky: full sky light.
+ let (x, y, z) = (
+ at[0].floor() as i32,
+ at[1].floor() as i32,
+ at[2].floor() as i32,
+ );
+ if self.world.light(x, y, z) >> 4 != 15 {
+ return;
+ }
+ self.spawn_bolt(at, false);
+ self.audio
+ .play("minecraft:item.trident.thunder", Some(at), 5.0, 1.0);
+ }
+ /// `minecraft:hit_block` of Channeling (`AbstractArrow.hitBlockEnchantmentEffects`):
+ /// the block the trident's path first hits, if it is a lightning rod, with
+ /// the hit location clamped into the block (`BlockPos.clampLocationWithin`).
+ fn channel_rod_hit(&mut self, from: Vec3, velocity: Vec3) {
+ let to = Vec3::new(
+ from.x + velocity.x,
+ from.y + velocity.y,
+ from.z + velocity.z,
+ );
+ let mut scene = SceneCollisions {
+ world: &self.world,
+ binding: self.collision,
+ subject: None,
+ };
+ // ClipContext.Block.COLLIDER with Fluid.NONE.
+ let hit = traverse_blocks(from, to, 1024, |p: BlockPos| {
+ let state = self.world.block(p.x, p.y, p.z);
+ if self.res.facts().is_air(state) {
+ return None;
+ }
+ let shape = self
+ .collision
+ .collision_shape(&mut scene, state, [p.x, p.y, p.z])
+ .ok()?;
+ shape.clip(from, to, p)
+ });
+ let Some(hit) = hit.ok().flatten() else {
+ return;
+ };
+ let state = self.world.block(hit.block.x, hit.block.y, hit.block.z);
+ if !self.res.facts().get(state).name.ends_with("lightning_rod") {
+ return;
+ }
+ let edge = f64::from(1.0e-5f32);
+ let clamp =
+ |v: f64, origin: i32| v.clamp(f64::from(origin) + edge, f64::from(origin) + 1.0 - edge);
+ self.channel_lightning([
+ clamp(hit.location.x, hit.block.x),
+ clamp(hit.location.y, hit.block.y),
+ clamp(hit.location.z, hit.block.z),
+ ]);
+ }
/// `TridentItem.releaseUsing`.
pub(super) fn release_trident(&mut self, ticks: u32) {
if ticks < 10 {
@@ -171,10 +236,11 @@ impl Game<'_> {
.as_ref()
.map(|p| [p.position.x, p.position.y, p.position.z]);
if riptide > 0 {
- if !self.in_water_or_rain() {
+ // `isInWaterOrRain() && !isPassenger()`.
+ if !self.in_water_or_rain() || self.riding.is_some() {
return;
}
- self.damage_held(1);
+ self.hurt_held_without_breaking(1);
// trident_spin_attack_strength: 1.5 + 0.75 per level above the first.
let strength = 1.5 + 0.75 * (riptide as f32 - 1.0);
let d = view_vector(self.yaw, self.pitch);
@@ -195,12 +261,8 @@ impl Game<'_> {
self.audio.play(&sound, at, 1.0, 1.0);
return;
}
- // hurtWithoutBreaking, then the thrown copy.
- if !self.creative
- && let Some(s) = self.held_mut().as_mut()
- {
- s.damage += 1;
- }
+ // hurtWithoutBreaking (Unbreaking applies), then the thrown copy.
+ self.hurt_held_without_breaking(1);
let thrown = self.held().cloned().unwrap_or(stack);
if !self.creative {
*self.held_mut() = None;
@@ -311,9 +373,10 @@ impl Game<'_> {
});
let damage = 8.0 + if aquatic { 2.5 * impaling } else { 0.0 };
t.dealt_damage = true;
+ let mut hurt_at = None;
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
let from = Some([t.position.x, t.position.y, t.position.z]);
- m.damage(
+ let hurt = m.damage(
damage,
Damage {
kind: DamageKind::Arrow,
@@ -321,6 +384,15 @@ impl Game<'_> {
from,
},
);
+ if hurt {
+ hurt_at = Some([m.position.x, m.position.y, m.position.z]);
+ }
+ }
+ // `minecraft:post_attack` of Channeling, on the victim.
+ if let Some(at) = hurt_at
+ && t.stack.enchantment_level("minecraft:channeling") > 0
+ {
+ self.channel_lightning(at);
}
self.audio.play(
"minecraft:item.trident.hit",
@@ -341,6 +413,7 @@ impl Game<'_> {
subject: None,
};
if let Ok(moved) = scene.resolve(bounds(t.position), t.velocity, 0.0, false) {
+ let (from, flight) = (t.position, t.velocity);
let blocked = (moved.x - t.velocity.x).abs() > 1e-7
|| (moved.y - t.velocity.y).abs() > 1e-7
|| (moved.z - t.velocity.z).abs() > 1e-7;
@@ -350,6 +423,9 @@ impl Game<'_> {
t.position.z + moved.z,
);
if blocked {
+ if t.stack.enchantment_level("minecraft:channeling") > 0 {
+ self.channel_rod_hit(from, flight);
+ }
t.in_ground = true;
t.velocity = Vec3::ZERO;
self.audio.play(
diff --git a/crates/horizon-client/src/game/villagers.rs b/crates/horizon-client/src/game/villagers.rs
index 3cfe8aa1d..c04b18604 100644
--- a/crates/horizon-client/src/game/villagers.rs
+++ b/crates/horizon-client/src/game/villagers.rs
@@ -21,6 +21,38 @@ impl Game<'_> {
fn item_max_stack(&self, item: &str) -> u32 {
self.res.items().get(item).map_or(64, |i| i.max_stack)
}
+ /// `WorkAtComposter.useWorkstation`: at a composter the farmer makes
+ /// bread, then composts seeds.
+ pub(super) fn villager_work_at_composter(&mut self, id: u32, pos: [i32; 3]) {
+ let Some(i) = self.villager_index(id) else {
+ return;
+ };
+ if self.composter_level(pos).is_none() {
+ return;
+ }
+ self.villager_make_bread(i);
+ self.villager_compost_items(i, pos);
+ }
+ /// `WorkAtComposter.makeBread`: up to three loaves from nine wheat while
+ /// the villager holds at most 36 bread; what does not fit drops.
+ fn villager_make_bread(&mut self, i: usize) {
+ let max_stack = self.item_max_stack("minecraft:bread");
+ let e = villager::ext_mut(&mut self.mobs[i]);
+ if e.count_item("minecraft:bread") > 36 {
+ return;
+ }
+ let loaves = (e.count_item("minecraft:wheat") / 3).min(3);
+ if loaves == 0 {
+ return;
+ }
+ e.remove_item("minecraft:wheat", loaves * 3);
+ let left = e.add_item(ItemStack::new("minecraft:bread", loaves), max_stack);
+ if let Some(rest) = left {
+ // spawnAtLocation(level, stack, 0.5F)
+ let p = self.mobs[i].position;
+ self.spawn_item(rest, [p.x, p.y + 0.5, p.z], [0.0, 0.2, 0.0], 10);
+ }
+ }
/// `BehaviorUtils.throwItem`: toss a stack from a villager's hand toward
/// a point.
fn villager_throw(&mut self, from: Vec3, eye: f64, to: Vec3, stack: ItemStack) {
diff --git a/crates/horizon-client/src/game/world_loading.rs b/crates/horizon-client/src/game/world_loading.rs
index 0cea31fd0..e9ee8e3e8 100644
--- a/crates/horizon-client/src/game/world_loading.rs
+++ b/crates/horizon-client/src/game/world_loading.rs
@@ -46,6 +46,10 @@ impl WorldRequest {
options: &Options,
settings: &Settings,
) -> Result {
+ // Before any chunk is read: a loaded container with a loot table is rolled as its chunk
+ // is decoded (`save::roll_loaded_loot`), and the spawn chunks are read while the world
+ // opens. Every world opens here: in-frame, on the server thread, on a dedicated server.
+ horizon_client::structure_blocks::loot_data(&options.resources);
let Self {
save_root,
folder,
@@ -261,6 +265,7 @@ pub(super) fn make_streaming(
res.threads(),
)
};
+ streaming.forced = save.load_forced_chunks();
streaming.radius = settings.render_distance;
streaming.biome_blend = settings.biome_blend;
streaming.smooth_lighting = settings.smooth_lighting;
diff --git a/crates/horizon-client/src/game/zombie_reinforcements.rs b/crates/horizon-client/src/game/zombie_reinforcements.rs
new file mode 100644
index 000000000..4c6100f43
--- /dev/null
+++ b/crates/horizon-client/src/game/zombie_reinforcements.rs
@@ -0,0 +1,134 @@
+//! `Zombie.hurtServer`'s reinforcements: a hurt zombie on Hard may call
+//! another of its kind from 7 to 40 blocks away to fight its target.
+use super::Game;
+use horizon_client::mobs::{
+ MobType, Species, Who,
+ finalize::{self, Attr, Op},
+ spawn_rules::{self, Reason},
+ spawn_selection::{self, NaturalLevel},
+ spawner::SpawnerLevel,
+};
+use horizon_core::random::{LegacyRandom, RandomSource};
+use horizon_world::food::Difficulty;
+
+/// `Zombie.REINFORCEMENT_ATTEMPTS`.
+const ATTEMPTS: usize = 50;
+/// `Zombie.REINFORCEMENT_RANGE_MIN` and `REINFORCEMENT_RANGE_MAX`.
+const RANGE_MIN: i32 = 7;
+const RANGE_MAX: i32 = 40;
+
+/// One axis of the offset: `Mth.nextInt(random, 7, 40) * Mth.nextInt(random, -1, 1)`.
+fn offset(random: &mut LegacyRandom) -> i32 {
+ let distance = random
+ .next_int_between_inclusive(RANGE_MIN, RANGE_MAX)
+ .unwrap_or(RANGE_MIN);
+ distance * random.next_int_between_inclusive(-1, 1).unwrap_or(0)
+}
+
+impl Game<'_> {
+ /// `Zombie.hurtServer` after the hit: on Hard, with the zombie's chance
+ /// and monsters spawning, a copy of it appears out of sight and takes
+ /// `target`; both then call less often.
+ pub(super) fn call_reinforcements(&mut self, caller: u32, target: Who) {
+ let Some(index) = self.mobs.iter().position(|m| m.id == caller) else {
+ return;
+ };
+ if self.world.health_rules.difficulty != Difficulty::Hard {
+ return;
+ }
+ let zombie = &mut self.mobs[index];
+ if f64::from(zombie.random.next_float()) >= zombie.attrs.spawn_reinforcements {
+ return;
+ }
+ // ServerLevel.isSpawningMonsters.
+ if !self.ui.rules.bool("spawn_mobs") || !self.ui.rules.bool("spawn_monsters") {
+ return;
+ }
+ let kind = zombie.kind.clone();
+ let from = [
+ zombie.position.x.floor() as i32,
+ zombie.position.y.floor() as i32,
+ zombie.position.z.floor() as i32,
+ ];
+ let mut own = std::mem::replace(&mut zombie.random, LegacyRandom::new(0));
+ let mut rules = std::mem::replace(&mut self.world.random, LegacyRandom::new(0));
+ let spot = self.reinforcement_spot(&kind, from, &mut own, &mut rules);
+ self.mobs[index].random = own;
+ self.world.random = rules;
+ let Some(spot) = spot else {
+ return;
+ };
+ let Some(id) = self.spawn_mob(&kind.id, spot.map(f64::from), false) else {
+ return;
+ };
+ if let Some(reinforcement) = self.mobs.iter_mut().find(|m| m.id == id) {
+ reinforcement.ai.target = Some(target);
+ // ZOMBIE_REINFORCEMENT_CALLEE_CHARGE.
+ finalize::add_modifier(
+ reinforcement,
+ Attr::SpawnReinforcements,
+ "minecraft:reinforcement_callee_charge",
+ -f64::from(0.05f32),
+ Op::AddValue,
+ );
+ }
+ // The caller's charge grows by 0.05 each time it calls.
+ let caller = &mut self.mobs[index];
+ let charged = finalize::modifier_amount(
+ caller,
+ Attr::SpawnReinforcements,
+ "minecraft:reinforcement_caller_charge",
+ )
+ .unwrap_or(0.0);
+ finalize::add_modifier(
+ caller,
+ Attr::SpawnReinforcements,
+ "minecraft:reinforcement_caller_charge",
+ charged - 0.05,
+ Op::AddValue,
+ );
+ }
+ /// The block `Zombie.hurtServer` puts the reinforcement at: the first of
+ /// 50 random offsets with a valid spawn surface, no alive player within
+ /// 7 blocks, and room for the zombie standing on the block's corner.
+ fn reinforcement_spot(
+ &self,
+ kind: &MobType,
+ from: [i32; 3],
+ own: &mut LegacyRandom,
+ rules: &mut LegacyRandom,
+ ) -> Option<[i32; 3]> {
+ let level = self.natural_level();
+ let (width, height) = (kind.width as f32, kind.height as f32);
+ for _ in 0..ATTEMPTS {
+ let [x, y, z] = from.map(|v| v + offset(own));
+ if !spawn_rules::is_spawn_position_ok(kind.species, &level, x, y, z)
+ || !spawn_rules::check_spawn_rules(
+ kind.species,
+ &level,
+ Reason::Reinforcement,
+ rules,
+ x,
+ y,
+ z,
+ )
+ {
+ continue;
+ }
+ // setPos(x, y, z): the box is centred on the block's corner.
+ let bounds =
+ spawn_selection::spawn_box(f64::from(x), f64::from(y), f64::from(z), width, height);
+ // Drowned.canSpawnInLiquids.
+ let wet_ok = kind.species == Species::Drowned
+ || !spawn_selection::contains_any_liquid(&level, bounds);
+ if !level.alive_player_near(f64::from(x), f64::from(y), f64::from(z), 7.0)
+ && level.unobstructed(bounds)
+ && level.no_collision(bounds)
+ && wet_ok
+ {
+ return Some([x, y, z]);
+ }
+ }
+ None
+ }
+}
diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs
index 08668b5ef..70d882a98 100644
--- a/crates/horizon-client/src/gfx.rs
+++ b/crates/horizon-client/src/gfx.rs
@@ -32,6 +32,8 @@ fn entity_shader() -> String {
crate::overlay::wgsl_constants() + include_str!("entity.wgsl")
}
+#[cfg(test)]
+mod crumbling_tests;
mod entity_batch;
mod weather;
use entity_batch::EntityBatch;
@@ -65,8 +67,10 @@ mod arena;
mod cull;
mod end_sky;
mod flat;
+mod hdr;
pub mod lightning;
mod lod;
+mod native_material;
mod native_pack;
mod native_post;
mod native_sky;
@@ -332,6 +336,10 @@ pub struct Renderer {
adapter: wgpu::Adapter,
/// The window's swapchain; `None` when rendering offscreen (`--offscreen`).
surface: Option>,
+ /// The surface `release_surface` set aside for the renderer that replaces
+ /// this one on the same device: reused, not created again, as a new
+ /// surface for the window can come back lost (Wayland on Mesa).
+ spare_surface: std::sync::Mutex>>,
/// The offscreen colour target, sized like `config`.
offscreen: Option,
/// Offscreen submissions still on the GPU: at most two frames run ahead.
@@ -429,6 +437,8 @@ pub struct Renderer {
/// The mipmap levels sampled (the Mipmap Levels option), at most `mip_levels - 1`.
mipmaps: u32,
terrain_layout: wgpu::BindGroupLayout,
+ /// terrain.wgsl's `SPRITE_ARRAYS` and `SPRITE_SPLIT`, for a shader pack's terrain.
+ terrain_sprites: [f64; 2],
sprite_sampler: wgpu::Sampler,
lightmap_view: wgpu::TextureView,
lightmap_sampler: wgpu::Sampler,
@@ -501,6 +511,10 @@ pub struct Renderer {
occlusion: occlusion::Occlusion,
/// Resolution scale and FXAA (Horizon settings).
world_post: world_post::Post,
+ /// HDR output (Horizon setting): `Some` while the swapchain is scRGB.
+ hdr: Option,
+ /// Whether the window's surface can present scRGB.
+ hdr_capable: bool,
/// The shader pack's post-processing, and the dimension (legacy id) it was loaded for.
pack_post: Option<(i32, Option)>,
/// The post passes of one of Horizon's own shader packs; never beside `pack_post`'s.
@@ -907,15 +921,24 @@ async fn open_device(
limits.max_storage_buffer_binding_size,
limits.max_texture_array_layers,
));
- match adapter
- .request_device(&wgpu::DeviceDescriptor {
- label: Some("Horizon device"),
- required_features: features,
- required_limits: limits,
- ..Default::default()
- })
- .await
- {
+ let desc = wgpu::DeviceDescriptor {
+ label: Some("Horizon device"),
+ required_features: features,
+ required_limits: limits,
+ ..Default::default()
+ };
+ #[cfg(not(target_os = "macos"))]
+ let opened = match info.backend {
+ wgpu::Backend::Vulkan => horizon_hdr::open_vulkan_device(&adapter, &desc),
+ _ => None,
+ };
+ #[cfg(target_os = "macos")]
+ let opened = None;
+ let opened = match opened {
+ Some(opened) => opened,
+ None => adapter.request_device(&desc).await,
+ };
+ match opened {
Ok((device, queue)) => {
return Ok(Opened {
instance,
@@ -1027,7 +1050,15 @@ impl Renderer {
surface: if offscreen {
None
} else {
- Some(renderer.instance.create_surface(window.clone())?)
+ let spare = renderer
+ .spare_surface
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .take();
+ Some(match spare {
+ Some(surface) => surface,
+ None => renderer.instance.create_surface(window.clone())?,
+ })
},
instance: renderer.instance.clone(),
adapter: renderer.adapter.clone(),
@@ -1040,7 +1071,7 @@ impl Renderer {
let info = adapter.get_info();
crate::graphics::suggest_reduced_far_detail(crate::graphics::lod_capped(&info));
let size = window.inner_size();
- let (config, present_modes) = if let Some(surface) = &surface {
+ let (config, present_modes, hdr_capable) = if let Some(surface) = &surface {
let mut config = surface
.get_default_config(&adapter, size.width.max(1), size.height.max(1))
.ok_or("surface has no supported configuration")?;
@@ -1068,7 +1099,7 @@ impl Renderer {
));
}
surface.configure(&device, &config);
- (config, caps.present_modes.clone())
+ (config, caps.present_modes.clone(), hdr::supported(&caps))
} else {
let format = wgpu::TextureFormat::Bgra8Unorm;
let config = wgpu::SurfaceConfiguration {
@@ -1082,7 +1113,7 @@ impl Renderer {
view_formats: vec![format],
color_space: wgpu::SurfaceColorSpace::default(),
};
- (config, Vec::new())
+ (config, Vec::new(), false)
};
let offscreen = surface
.is_none()
@@ -1926,14 +1957,20 @@ impl Renderer {
compilation_options: Default::default(),
targets: &[Some(wgpu::ColorTargetState {
format: config.format.remove_srgb_suffix(),
- // RenderPipelines.CELESTIAL: additive (src alpha, one).
+ // RenderPipelines.CELESTIAL: additive (src alpha, one). The
+ // alpha goes to 0: HDR output (hdr.wgsl) lets the sun and
+ // moon shine; nothing else reads the frame's alpha.
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::One,
operation: wgpu::BlendOperation::Add,
},
- alpha: wgpu::BlendComponent::OVER,
+ alpha: wgpu::BlendComponent {
+ src_factor: wgpu::BlendFactor::Zero,
+ dst_factor: wgpu::BlendFactor::Zero,
+ operation: wgpu::BlendOperation::Add,
+ },
}),
write_mask: wgpu::ColorWrites::ALL,
})],
@@ -2297,6 +2334,7 @@ impl Renderer {
instance,
adapter,
surface,
+ spare_surface: std::sync::Mutex::new(None),
offscreen,
in_flight: std::collections::VecDeque::new(),
first_frame: if previous.is_none() {
@@ -2370,6 +2408,7 @@ impl Renderer {
mip_levels,
mipmaps: mip_levels - 1,
terrain_layout: bindings,
+ terrain_sprites: sprite_constants.map(|(_, v)| v),
sprite_sampler,
lightmap_view,
lightmap_sampler,
@@ -2416,6 +2455,8 @@ impl Renderer {
block_entity_revision: next_block_entity_revision(),
occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16),
world_post,
+ hdr: None,
+ hdr_capable,
pack_post: None,
native: None,
pass_timing: pack_timing::PassTiming::logging(),
@@ -2473,19 +2514,38 @@ impl Renderer {
view_formats: &config.view_formats,
})
}
- /// Release the window surface before another renderer uses the same window.
+ /// Hand the window surface over to the renderer that replaces this one on
+ /// the same device (it takes `spare_surface`).
pub fn release_surface(&mut self) {
- self.surface = None;
+ *self
+ .spare_surface
+ .get_mut()
+ .unwrap_or_else(std::sync::PoisonError::into_inner) = self.surface.take();
}
/// Reattach a window after surface loss or a failed renderer replacement.
pub fn recreate_surface(&mut self) -> Result<()> {
if self.offscreen.is_some() {
return Ok(());
}
- // Wayland allows only one tearing-control object per window surface.
- self.release_surface();
- let surface = self.instance.create_surface(self.window.clone())?;
- surface.configure(&self.device, &self.config);
+ // The surface set aside for a replacement that failed, else a new one
+ // (Wayland allows only one tearing-control object per window surface,
+ // so the old one goes first).
+ let spare = self
+ .spare_surface
+ .get_mut()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .take();
+ self.surface = None;
+ let surface = match spare {
+ Some(surface) => surface,
+ None => self.instance.create_surface(self.window.clone())?,
+ };
+ Self::configure(
+ &self.device,
+ &surface,
+ &self.surface_config(),
+ self.hdr.as_ref(),
+ );
self.surface = Some(surface);
Ok(())
}
@@ -2548,7 +2608,12 @@ impl Renderer {
&& let Some(surface) = &self.surface
{
self.config.present_mode = mode;
- surface.configure(&self.device, &self.config);
+ Self::configure(
+ &self.device,
+ surface,
+ &self.surface_config(),
+ self.hdr.as_ref(),
+ );
}
}
pub fn resize(&mut self, width: u32, height: u32) {
@@ -2559,7 +2624,12 @@ impl Renderer {
self.config.width = width;
self.config.height = height;
if let Some(surface) = &self.surface {
- surface.configure(&self.device, &self.config);
+ Self::configure(
+ &self.device,
+ surface,
+ &self.surface_config(),
+ self.hdr.as_ref(),
+ );
} else {
self.offscreen = Some(Self::offscreen_target(&self.device, &self.config));
}
@@ -2891,6 +2961,63 @@ impl Renderer {
);
}
/// Horizon's resolution scale (world pixels per window pixel) and FXAA.
+ /// Configures `surface` and, while HDR output is on, sends its HDR metadata
+ /// again: a new swapchain starts without it.
+ fn configure(
+ device: &wgpu::Device,
+ surface: &wgpu::Surface<'_>,
+ config: &wgpu::SurfaceConfiguration,
+ hdr: Option<&hdr::Hdr>,
+ ) {
+ surface.configure(device, config);
+ if let Some(hdr) = hdr {
+ horizon_hdr::set_metadata(device, surface, hdr.paper_white, hdr.peak);
+ }
+ }
+ fn configure_surface(&self) {
+ if let Some(surface) = &self.surface {
+ Self::configure(
+ &self.device,
+ surface,
+ &self.surface_config(),
+ self.hdr.as_ref(),
+ );
+ }
+ }
+ fn send_hdr_metadata(&self) {
+ if let (Some(surface), Some(hdr)) = (&self.surface, &self.hdr) {
+ horizon_hdr::set_metadata(&self.device, surface, hdr.paper_white, hdr.peak);
+ }
+ }
+ /// The swapchain's configuration: `config` (what every pipeline draws in), or
+ /// scRGB while HDR output is on.
+ fn surface_config(&self) -> wgpu::SurfaceConfiguration {
+ let mut config = self.config.clone();
+ if self.hdr.is_some() {
+ config.format = hdr::FORMAT;
+ config.view_formats = vec![hdr::FORMAT];
+ config.color_space = hdr::COLOR_SPACE;
+ config.usage = wgpu::TextureUsages::RENDER_ATTACHMENT;
+ }
+ config
+ }
+ /// HDR output (Horizon setting): scRGB at `paper_white` nits, the world's
+ /// highlights expanded up to `peak` nits. Off where the surface can't present it.
+ pub fn set_hdr(&mut self, on: bool, paper_white: f32, peak: f32) {
+ let on = on && self.hdr_capable && self.surface.is_some();
+ if on != self.hdr.is_some() {
+ self.hdr =
+ on.then(|| hdr::Hdr::new(&self.device, self.config.format.remove_srgb_suffix()));
+ self.configure_surface();
+ }
+ if let Some(hdr) = &mut self.hdr
+ && (hdr.paper_white, hdr.peak) != (paper_white, peak)
+ {
+ hdr.paper_white = paper_white;
+ hdr.peak = peak;
+ self.send_hdr_metadata();
+ }
+ }
pub fn set_world_post(&mut self, scale: f32, antialias: bool) {
self.world_post.scale = scale.clamp(0.25, 2.0);
self.world_post.antialias = antialias;
@@ -2966,9 +3093,9 @@ impl Renderer {
self.native = None;
self.pack_atlas = None;
}
- /// Runs the sky and post stages of one of Horizon's own shader packs from now on (`None`:
- /// no pack), with its options' values; replaces a `shaders/` pack. Returns the stages'
- /// labels; on an error the pack that ran keeps running.
+ /// Runs the sky, material and post stages of one of Horizon's own shader packs from now
+ /// on (`None`: no pack), with its options' values; replaces a `shaders/` pack. Returns the
+ /// stages' labels; on an error the pack that ran keeps running.
pub fn set_native_shader_pack(
&mut self,
pack: Option<(horizon_shader_api::Report, Vec<(String, f64)>)>,
@@ -2977,14 +3104,14 @@ impl Renderer {
self.native = None;
return Ok(Vec::new());
};
- let format = self.config.format.remove_srgb_suffix();
- let (pack, labels) = native_pack::NativePack::new(
- &self.device,
- &self.terrain_layout,
- report,
- &constants,
- format,
- )?;
+ let terrain = native_material::TerrainShape {
+ globals: &self.terrain_layout,
+ flat: self.flat.as_ref().map(|f| &f.draw_layout),
+ sprites: self.terrain_sprites,
+ format: self.config.format.remove_srgb_suffix(),
+ };
+ let (pack, labels) =
+ native_pack::NativePack::new(&self.device, &terrain, report, &constants)?;
self.native = pack.draws().then_some(pack);
if self.native.is_some() {
self.pack_post = None;
@@ -3226,7 +3353,12 @@ impl Renderer {
}
Some(wgpu::CurrentSurfaceTexture::Outdated) => {
if let Some(surface) = &self.surface {
- surface.configure(&self.device, &self.config);
+ Self::configure(
+ &self.device,
+ surface,
+ &self.surface_config(),
+ self.hdr.as_ref(),
+ );
}
return Ok(false);
}
@@ -3238,9 +3370,11 @@ impl Renderer {
return Err("surface acquisition failed validation".into());
}
};
- let target_texture = match &surface_frame {
- Some(f) => f.texture.clone(),
- None => self.offscreen.clone().ok_or("no offscreen target")?,
+ let size = [self.config.width, self.config.height];
+ let target_texture = match (&surface_frame, &mut self.hdr) {
+ (Some(_), Some(hdr)) => hdr.frame(&self.device, size),
+ (Some(f), None) => f.texture.clone(),
+ (None, _) => self.offscreen.clone().ok_or("no offscreen target")?,
};
// One command buffer for the frame, after the section copies staged
// since the last one: Metal commits every command buffer wgpu-core
@@ -4208,6 +4342,21 @@ impl Renderer {
pass.set_bind_group(0, &self.group, &[]);
sky.draw(&mut pass, &native.frame);
}
+ // One of Horizon's own packs with a material stage: terrain draws with its pipelines,
+ // which read the pack's frame at group 3.
+ let material = self
+ .native
+ .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);
+ let translucent_pipeline = material.map_or(&self.translucent, |(m, _)| &m.translucent);
+ let pack_flat = material.and_then(|(m, _)| m.flat.as_ref());
+ let pack_frame = |pass: &mut wgpu::RenderPass<'_>| {
+ if let Some((_, group)) = material {
+ pass.set_bind_group(horizon_shader_api::stages::GROUP, group, &[]);
+ }
+ };
{
let attachments = [Some(wgpu::RenderPassColorAttachment {
view: world_view,
@@ -4241,6 +4390,7 @@ impl Renderer {
..Default::default()
});
pass.set_bind_group(0, &self.group, &[]);
+ pack_frame(&mut pass);
if frame.title || (sky_visible && (frame.skybox || frame.end_sky)) {
if !frame.title && frame.skybox && !pack_draws_sky && !native_sky_pass {
match self
@@ -4289,7 +4439,7 @@ impl Renderer {
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
}
Some(flat) => {
- pass.set_pipeline(&flat.solid);
+ pass.set_pipeline(pack_flat.map_or(&flat.solid, |p| &p.0));
let vertices = |p| self.arena.buffer(p);
match cull {
// As below: phase 1, the test, then phase 2's draws
@@ -4307,7 +4457,8 @@ impl Renderer {
pack_reads_world,
);
pass.set_bind_group(0, &self.group, &[]);
- pass.set_pipeline(&flat.solid);
+ pack_frame(&mut pass);
+ pass.set_pipeline(pack_flat.map_or(&flat.solid, |p| &p.0));
flat.draw_phase2(&mut pass, vertices);
}
None => flat.draw(&mut pass, &flat.calls[..flat.solid_calls], vertices),
@@ -4316,7 +4467,7 @@ impl Renderer {
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
}
None => {
- pass.set_pipeline(&self.solid);
+ pass.set_pipeline(solid_pipeline);
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
pass.set_vertex_buffer(1, self.instances.slice(..));
match cull {
@@ -4336,7 +4487,8 @@ impl Renderer {
pack_reads_world,
);
pass.set_bind_group(0, &self.group, &[]);
- pass.set_pipeline(&self.solid);
+ pack_frame(&mut pass);
+ pass.set_pipeline(solid_pipeline);
pass.set_index_buffer(
self.indices.slice(..),
wgpu::IndexFormat::Uint32,
@@ -4428,7 +4580,7 @@ impl Renderer {
// The pack draws translucent terrain after its deferred programs.
_ if pack_draws_water => {}
Some(flat) => {
- pass.set_pipeline(&flat.translucent);
+ pass.set_pipeline(pack_flat.map_or(&flat.translucent, |p| &p.1));
flat.draw(&mut pass, flat.translucent_calls(), |p| {
self.arena.buffer(p)
});
@@ -4436,7 +4588,7 @@ impl Renderer {
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
}
None => {
- pass.set_pipeline(&self.translucent);
+ pass.set_pipeline(translucent_pipeline);
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
pass.set_vertex_buffer(1, self.instances.slice(..));
self.draw_sections(
@@ -4620,6 +4772,9 @@ impl Renderer {
} else if scaled.is_some() {
self.world_post.finish(&mut encoder, &view_target);
}
+ if let Some(hdr) = &self.hdr {
+ hdr.keep_world(&mut encoder);
+ }
if hand_quads > 0 && !pack_draws_hand {
let attachments = [Some(wgpu::RenderPassColorAttachment {
view: &view_target,
@@ -4774,6 +4929,9 @@ impl Renderer {
self.section_copy_bytes = 0;
self.section_uploads.finish(&encoder);
}
+ if let (Some(hdr), Some(f)) = (&self.hdr, &surface_frame) {
+ hdr.present(&self.queue, &mut encoder, &f.texture, !frame.title);
+ }
let commands = crate::spans::time("encode", || encoder.finish());
let first_frame = self.first_frame == FirstFrame::Submit;
if first_frame {
@@ -4810,7 +4968,12 @@ impl Renderer {
}
self.queue.present(surface_frame);
if reconfigure && let Some(surface) = &self.surface {
- surface.configure(&self.device, &self.config);
+ Self::configure(
+ &self.device,
+ surface,
+ &self.surface_config(),
+ self.hdr.as_ref(),
+ );
}
} else {
// No swapchain paces offscreen frames: keep two on the GPU at most.
diff --git a/crates/horizon-client/src/gfx/crumbling_tests.rs b/crates/horizon-client/src/gfx/crumbling_tests.rs
new file mode 100644
index 000000000..620a57cf9
--- /dev/null
+++ b/crates/horizon-client/src/gfx/crumbling_tests.rs
@@ -0,0 +1,191 @@
+use wgpu::util::DeviceExt;
+
+/// Sample the production WGSL with the production nearest/no-mipmap atlas sampler.
+#[test]
+#[ignore = "requires a Vulkan/Metal/DX12 adapter"]
+fn crack_samples_stay_aligned_between_stages() {
+ let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+ let adapter =
+ pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default()))
+ .unwrap();
+ eprintln!("crack sampling adapter: {:?}", adapter.get_info());
+ let (device, queue) =
+ pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).unwrap();
+ #[repr(C)]
+ #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+ struct Case {
+ uv: [f32; 2],
+ stage: u32,
+ extent: u32,
+ }
+ let mut cases = Vec::new();
+ let mut expected = Vec::<[u32; 2]>::new();
+ // Include exact texel boundaries, their neighbours, negative projected UVs,
+ // wrapping and the far sprite edge. Origins straddle the packing error's sign change.
+ for extent in [16, 32] {
+ for x in [32, 2080, 4064] {
+ for y in [0, 32] {
+ for i in -32..=32 {
+ for delta in [-0.0001, 0.0, 0.0001] {
+ let uv = [i as f32 / 16.0 + delta, 0.5 - delta];
+ cases.push(Case {
+ uv,
+ stage: crate::breaking::stage_light([
+ x as f32 / 4096.0,
+ y as f32 / 64.0,
+ ]),
+ extent,
+ });
+ expected.push(uv.map(|v| {
+ (((v - v.floor()) * extent as f32).floor() as u32).min(extent - 1)
+ }));
+ }
+ }
+ }
+ }
+ }
+ let math = include_str!("../entity.wgsl")
+ .split("// CRUMBLING_UV_BEGIN")
+ .nth(1)
+ .unwrap()
+ .split("// CRUMBLING_UV_END")
+ .next()
+ .unwrap();
+ let source = format!(
+ "{math}\n{}",
+ r#"
+struct Case { uv: vec2, stage: u32, extent: u32 }
+@group(0) @binding(0) var cases: array;
+@group(0) @binding(1) var results: array>;
+@group(0) @binding(2) var atlas: texture_2d;
+@group(0) @binding(3) var atlas_sampler: sampler;
+@compute @workgroup_size(64) fn main(@builtin(global_invocation_id) id: vec3) {
+ if id.x >= arrayLength(&cases) { return; }
+ let c = cases[id.x];
+ let origin = vec2(f32(c.stage & 65535u), f32(c.stage >> 16u)) / 65535.0;
+ let dimensions = textureDimensions(atlas);
+ let uv = crumbling_uv(c.uv, origin, vec2(f32(c.extent)) / vec2(dimensions), dimensions);
+ // Keep the old addressing as a control: the fixture must reproduce its stage jitter.
+ let old_uv = origin + fract(c.uv) * vec2(f32(c.extent)) / vec2(dimensions);
+ results[id.x] = vec4(
+ vec2(round(textureSampleLevel(atlas, atlas_sampler, uv, 0.0).rg * 255.0)),
+ vec2(round(textureSampleLevel(atlas, atlas_sampler, old_uv, 0.0).rg * 255.0)));
+}"#
+ );
+ let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+ label: Some("Crack sampling regression"),
+ source: wgpu::ShaderSource::Wgsl(source.into()),
+ });
+ let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+ label: None,
+ layout: None,
+ module: &shader,
+ entry_point: Some("main"),
+ compilation_options: Default::default(),
+ cache: None,
+ });
+ // Every sprite repeats the same coordinate pattern, so moving a stage's
+ // atlas origin must leave every sampled local texel unchanged.
+ let pixels: Vec = (0..64)
+ .flat_map(|y| (0..4096).flat_map(move |x| [(x % 32) as u8, (y % 32) as u8, 0, 255]))
+ .collect();
+ let atlas = device.create_texture_with_data(
+ &queue,
+ &wgpu::TextureDescriptor {
+ label: None,
+ size: wgpu::Extent3d {
+ width: 4096,
+ height: 64,
+ 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,
+ view_formats: &[],
+ },
+ wgpu::util::TextureDataOrder::LayerMajor,
+ &pixels,
+ );
+ let view = atlas.create_view(&Default::default());
+ let sampler = device.create_sampler(&wgpu::SamplerDescriptor::default());
+ let input = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+ label: None,
+ contents: bytemuck::cast_slice(&cases),
+ usage: wgpu::BufferUsages::STORAGE,
+ });
+ let size = (expected.len() * 16) as u64;
+ let output = device.create_buffer(&wgpu::BufferDescriptor {
+ label: None,
+ size,
+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
+ mapped_at_creation: false,
+ });
+ let readback = device.create_buffer(&wgpu::BufferDescriptor {
+ label: None,
+ size,
+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+ mapped_at_creation: false,
+ });
+ let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: None,
+ layout: &pipeline.get_bind_group_layout(0),
+ entries: &[
+ wgpu::BindGroupEntry {
+ binding: 0,
+ resource: input.as_entire_binding(),
+ },
+ wgpu::BindGroupEntry {
+ binding: 1,
+ resource: output.as_entire_binding(),
+ },
+ wgpu::BindGroupEntry {
+ binding: 2,
+ resource: wgpu::BindingResource::TextureView(&view),
+ },
+ wgpu::BindGroupEntry {
+ binding: 3,
+ resource: wgpu::BindingResource::Sampler(&sampler),
+ },
+ ],
+ });
+ let mut encoder = device.create_command_encoder(&Default::default());
+ {
+ let mut pass = encoder.begin_compute_pass(&Default::default());
+ pass.set_pipeline(&pipeline);
+ pass.set_bind_group(0, &group, &[]);
+ pass.dispatch_workgroups((cases.len() as u32).div_ceil(64), 1, 1);
+ }
+ encoder.copy_buffer_to_buffer(&output, 0, &readback, 0, size);
+ queue.submit([encoder.finish()]);
+ let (tx, rx) = std::sync::mpsc::channel();
+ readback.map_async(wgpu::MapMode::Read, .., move |r| tx.send(r).unwrap());
+ device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+ rx.recv().unwrap().unwrap();
+ let mapped = readback.get_mapped_range(..).unwrap();
+ let actual: &[[u32; 4]] = bytemuck::cast_slice(&mapped);
+ for (i, (actual, expected)) in actual.iter().zip(&expected).enumerate() {
+ assert_eq!(
+ &actual[..2],
+ expected,
+ "case {i}, uv={:?}, stage={}, extent={}",
+ cases[i].uv,
+ cases[i].stage,
+ cases[i].extent
+ );
+ }
+ let old_mismatches = actual
+ .iter()
+ .zip(&expected)
+ .filter(|(a, e)| &a[2..] != e.as_slice())
+ .count();
+ assert!(
+ old_mismatches > 0,
+ "fixture must detect the original sampling bug"
+ );
+ eprintln!(
+ "{} crack texture samples matched; old addressing mismatched {old_mismatches}",
+ cases.len()
+ );
+}
diff --git a/crates/horizon-client/src/gfx/hdr.rs b/crates/horizon-client/src/gfx/hdr.rs
new file mode 100644
index 000000000..11deed546
--- /dev/null
+++ b/crates/horizon-client/src/gfx/hdr.rs
@@ -0,0 +1,222 @@
+//! HDR output (Horizon setting, off by default): the frame renders exactly as
+//! without it, into an 8-bit target in vanilla's gamma space, and one pass
+//! (`hdr.wgsl`) writes it to an scRGB swapchain at the player's paper white,
+//! expanding the world's highlights towards their peak brightness. The world
+//! is copied aside before the hand and HUD so only it is expanded.
+
+/// The swapchain format and colour space HDR output presents in.
+pub const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
+pub const COLOR_SPACE: wgpu::SurfaceColorSpace = wgpu::SurfaceColorSpace::ExtendedSrgbLinear;
+
+/// Whether `caps` can present scRGB.
+pub fn supported(caps: &wgpu::SurfaceCapabilities) -> bool {
+ caps.color_spaces(FORMAT)
+ .contains(wgpu::SurfaceColorSpaces::EXTENDED_SRGB_LINEAR)
+}
+
+struct Targets {
+ size: [u32; 2],
+ frame: wgpu::Texture,
+ world: wgpu::Texture,
+ group: wgpu::BindGroup,
+}
+
+pub struct Hdr {
+ layout: wgpu::BindGroupLayout,
+ pipeline: wgpu::RenderPipeline,
+ params: wgpu::Buffer,
+ /// The frame's format: what every other pipeline draws in.
+ format: wgpu::TextureFormat,
+ targets: Option,
+ /// `HORIZON_HDR_DEBUG=1`: paint expanded pixels magenta.
+ debug: bool,
+ /// Paper white and peak brightness, in nits.
+ pub paper_white: f32,
+ pub peak: f32,
+}
+
+impl Hdr {
+ pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
+ let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+ label: Some("Horizon HDR"),
+ source: wgpu::ShaderSource::Wgsl(include_str!("../hdr.wgsl").into()),
+ });
+ let texture = |binding| wgpu::BindGroupLayoutEntry {
+ binding,
+ visibility: wgpu::ShaderStages::FRAGMENT,
+ ty: wgpu::BindingType::Texture {
+ sample_type: wgpu::TextureSampleType::Float { filterable: false },
+ view_dimension: wgpu::TextureViewDimension::D2,
+ multisampled: false,
+ },
+ count: None,
+ };
+ let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+ label: Some("Horizon HDR bindings"),
+ entries: &[
+ texture(0),
+ texture(1),
+ wgpu::BindGroupLayoutEntry {
+ binding: 2,
+ visibility: wgpu::ShaderStages::FRAGMENT,
+ ty: wgpu::BindingType::Buffer {
+ ty: wgpu::BufferBindingType::Uniform,
+ has_dynamic_offset: false,
+ min_binding_size: None,
+ },
+ count: None,
+ },
+ ],
+ });
+ let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+ label: Some("Horizon HDR"),
+ bind_group_layouts: &[Some(&layout)],
+ ..Default::default()
+ });
+ let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+ label: Some("Horizon HDR"),
+ layout: Some(&pipeline_layout),
+ vertex: wgpu::VertexState {
+ module: &shader,
+ entry_point: Some("vs_hdr"),
+ compilation_options: Default::default(),
+ buffers: &[],
+ },
+ primitive: Default::default(),
+ depth_stencil: None,
+ multisample: Default::default(),
+ fragment: Some(wgpu::FragmentState {
+ module: &shader,
+ entry_point: Some("fs_hdr"),
+ compilation_options: Default::default(),
+ targets: &[Some(wgpu::ColorTargetState {
+ format: FORMAT,
+ blend: None,
+ write_mask: wgpu::ColorWrites::ALL,
+ })],
+ }),
+ multiview_mask: None,
+ cache: None,
+ });
+ let params = device.create_buffer(&wgpu::BufferDescriptor {
+ label: Some("Horizon HDR parameters"),
+ size: 16,
+ usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+ mapped_at_creation: false,
+ });
+ Self {
+ layout,
+ pipeline,
+ params,
+ format,
+ targets: None,
+ debug: std::env::var_os("HORIZON_HDR_DEBUG").is_some_and(|v| v == "1"),
+ paper_white: 200.0,
+ peak: 1000.0,
+ }
+ }
+
+ /// The 8-bit frame every pass draws into this frame, sized like the window.
+ pub fn frame(&mut self, device: &wgpu::Device, size: [u32; 2]) -> wgpu::Texture {
+ if self.targets.as_ref().is_none_or(|t| t.size != size) {
+ let texture = |label, usage| {
+ 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: self.format,
+ usage: usage | wgpu::TextureUsages::TEXTURE_BINDING,
+ view_formats: &[],
+ })
+ };
+ let frame = texture(
+ "Horizon HDR frame",
+ wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+ );
+ let world = texture("Horizon HDR world", wgpu::TextureUsages::COPY_DST);
+ let view = |t: &wgpu::Texture| t.create_view(&Default::default());
+ let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: Some("Horizon HDR bindings"),
+ layout: &self.layout,
+ entries: &[
+ wgpu::BindGroupEntry {
+ binding: 0,
+ resource: wgpu::BindingResource::TextureView(&view(&frame)),
+ },
+ wgpu::BindGroupEntry {
+ binding: 1,
+ resource: wgpu::BindingResource::TextureView(&view(&world)),
+ },
+ wgpu::BindGroupEntry {
+ binding: 2,
+ resource: self.params.as_entire_binding(),
+ },
+ ],
+ });
+ self.targets = Some(Targets {
+ size,
+ frame,
+ world,
+ group,
+ });
+ }
+ self.targets.as_ref().unwrap().frame.clone()
+ }
+
+ /// Keeps the world as drawn so far, before the hand and HUD cover it.
+ pub fn keep_world(&self, encoder: &mut wgpu::CommandEncoder) {
+ let Some(t) = &self.targets else {
+ return;
+ };
+ encoder.copy_texture_to_texture(
+ t.frame.as_image_copy(),
+ t.world.as_image_copy(),
+ t.frame.size(),
+ );
+ }
+
+ /// Writes the finished frame to the swapchain image `target`.
+ pub fn present(
+ &self,
+ queue: &wgpu::Queue,
+ encoder: &mut wgpu::CommandEncoder,
+ target: &wgpu::Texture,
+ world: bool,
+ ) {
+ let Some(t) = &self.targets else {
+ return;
+ };
+ let paper = self.paper_white.max(1.0);
+ let params = [
+ paper / 80.0,
+ (self.peak / paper).max(1.0),
+ f32::from(u8::from(world)),
+ f32::from(u8::from(self.debug)),
+ ];
+ queue.write_buffer(&self.params, 0, bytemuck::cast_slice(¶ms));
+ let view = target.create_view(&Default::default());
+ let attachments = [Some(wgpu::RenderPassColorAttachment {
+ view: &view,
+ resolve_target: None,
+ depth_slice: None,
+ ops: wgpu::Operations {
+ load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+ store: wgpu::StoreOp::Store,
+ },
+ })];
+ let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+ label: Some("Horizon HDR"),
+ color_attachments: &attachments,
+ ..Default::default()
+ });
+ pass.set_pipeline(&self.pipeline);
+ pass.set_bind_group(0, &t.group, &[]);
+ pass.draw(0..3, 0..1);
+ }
+}
diff --git a/crates/horizon-client/src/gfx/native_material.rs b/crates/horizon-client/src/gfx/native_material.rs
new file mode 100644
index 000000000..e7f8f7bf2
--- /dev/null
+++ b/crates/horizon-client/src/gfx/native_material.rs
@@ -0,0 +1,328 @@
+//! The material stage of Horizon's own shader packs (docs/shaders.md): the pack's `material`
+//! function gives the lit colour of each point of a block's surface, before the alpha test and
+//! fog. Terrain still draws with Horizon's meshes, culling and draw lists; only its pipelines
+//! change. Their shader is the pack's stage (`CheckedStage::source`), then a copy of
+//! terrain.wgsl's terrain section whose names all take a `horizon_terrain_` prefix
+//! (`wgsl_prefix.rs`), then entries that hand the pack what vanilla's `fs_solid` and
+//! `fs_translucent` combine: the texture, the vertex tint, the light levels and the lightmap's
+//! colour. They read the terrain's group 0, the flat draws' group 1 where those run, and the
+//! pack's frame at group 3.
+
+use horizon_shader_api::{check::CheckedStage, stages::GROUP};
+
+use super::native_post::{NativeFrame, present_constants};
+use super::wgsl_prefix::{TERRAIN, prefixed, section};
+
+const PREFIX: &str = "horizon_terrain_";
+
+/// The entries around the pack's `material`: vanilla's vertex work without the lightmap
+/// product, then the material, the alpha test and fog as `fs_solid` and `fs_translucent` do.
+const ENTRIES: &str = "
+struct HorizonMaterialOut {
+ @builtin(position) clip: vec4,
+ @location(0) uv: vec2,
+ @location(1) @interpolate(flat) layer: u32,
+ @location(2) tint: vec4,
+ @location(3) light: vec2,
+ @location(4) lightmap: vec3,
+ @location(5) position: vec3,
+ @location(6) spherical: f32,
+ @location(7) cylindrical: f32,
+}
+fn horizon_material_vertex(position: vec3, uv: vec2, layer: u32, color: vec4,
+ light: vec2, origin: vec3) -> HorizonMaterialOut {
+ let pos = position + origin;
+ var out: HorizonMaterialOut;
+ out.clip = horizon_terrain_globals.view_proj * vec4(pos, 1.0);
+ out.uv = uv;
+ out.layer = layer;
+ out.tint = vec4(color.rgb, 1.0);
+ let block = max(f32(light.y), horizon_terrain_dynamic_block_light(pos));
+ let sky = f32(light.x);
+ // 16 per level, 15 levels.
+ out.light = min(vec2(block, sky) / 240.0, vec2(1.0));
+ out.lightmap = horizon_terrain_sample_lightmap(sky / 16.0, block / 16.0).rgb;
+ out.position = pos;
+ out.spherical = length(pos);
+ out.cylindrical = max(length(pos.xz), abs(pos.y));
+ return out;
+}
+@vertex fn horizon_material_vs(
+ @location(0) position: vec3, @location(1) uv: vec2,
+ @location(2) layer: u32, @location(3) color: vec4, @location(4) light: vec2,
+ @location(5) origin: vec4) -> HorizonMaterialOut {
+ return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer,
+ color, light, origin.xyz);
+}
+@vertex fn horizon_material_vs_flat(
+ @builtin(vertex_index) vertex: u32,
+ @location(0) position: vec3, @location(1) uv: vec2,
+ @location(2) layer: u32, @location(3) color: vec4, @location(4) light: vec2
+) -> HorizonMaterialOut {
+ let origin = horizon_terrain_slot_origins[horizon_terrain_block_slots[vertex >> 8u]];
+ return horizon_material_vertex(position, horizon_terrain_terrain_uv(uv, origin.w), layer,
+ color, light, origin.xyz);
+}
+fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4 {
+ let albedo = horizon_terrain_sprite(in.uv, in.layer & 0x7fffu);
+ return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv,
+ translucent)).color;
+}
+@fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> @location(0) vec4 {
+ let color = horizon_material_color(in, false);
+ // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
+ if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; }
+ return horizon_terrain_apply_fog(vec4(color.rgb, 1.0), in.spherical, in.cylindrical);
+}
+@fragment fn horizon_material_fs_translucent(in: HorizonMaterialOut) -> @location(0) vec4 {
+ let color = horizon_material_color(in, true);
+ if color.a < 0.01 { discard; }
+ return horizon_terrain_apply_fog(color, in.spherical, in.cylindrical);
+}
+";
+
+/// What terrain pipelines are built against: the renderer's layouts and constants.
+pub struct TerrainShape<'a> {
+ /// The terrain's group 0.
+ pub globals: &'a wgpu::BindGroupLayout,
+ /// The flat draws' group 1, where they run (`flat.rs`).
+ pub flat: Option<&'a wgpu::BindGroupLayout>,
+ /// terrain.wgsl's `SPRITE_ARRAYS` and `SPRITE_SPLIT`.
+ pub sprites: [f64; 2],
+ /// The world target's colour format.
+ pub format: wgpu::TextureFormat,
+}
+
+/// The pack's terrain pipelines: solid (with the cutout test) and translucent, for the
+/// renderer's instanced draws and, where they run, its flat ones.
+pub struct NativeMaterial {
+ pub solid: wgpu::RenderPipeline,
+ pub translucent: wgpu::RenderPipeline,
+ pub flat: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,
+}
+
+/// terrain.wgsl's terrain section (its globals, bindings, sampling, lighting and fog), with
+/// every name it declares prefixed.
+fn vanilla_terrain() -> String {
+ prefixed(
+ section(TERRAIN, "struct Globals {", "// Sky (SkyRenderer)"),
+ PREFIX,
+ )
+}
+
+/// The terrain shader for the pack's material stage `source`.
+fn shader_source(source: &str) -> String {
+ format!(
+ "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{ENTRIES}",
+ vanilla_terrain()
+ )
+}
+
+/// The material's naga module, its errors in the stage's file.
+fn module(stage: &CheckedStage) -> Result {
+ let text = shader_source(&stage.source);
+ naga::front::wgsl::parse_str(&text)
+ .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))
+}
+
+impl NativeMaterial {
+ /// The pipelines of the pack's material `stage` with the option values `constants`.
+ pub fn new(
+ device: &wgpu::Device,
+ shape: &TerrainShape<'_>,
+ frame: &NativeFrame,
+ stage: &CheckedStage,
+ constants: &[(String, f64)],
+ ) -> Result {
+ let module = module(stage)?;
+ let mut constants = present_constants(&module, constants);
+ let sprite_names = [
+ "horizon_terrain_SPRITE_ARRAYS",
+ "horizon_terrain_SPRITE_SPLIT",
+ ];
+ constants.extend(sprite_names.into_iter().zip(shape.sprites));
+ let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
+ let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+ label: Some(&stage.label),
+ source: wgpu::ShaderSource::Naga(std::borrow::Cow::Owned(module)),
+ });
+ let layout = |flat: Option<&wgpu::BindGroupLayout>| {
+ let mut groups: [Option<&wgpu::BindGroupLayout>; GROUP as usize + 1] =
+ Default::default();
+ groups[0] = Some(shape.globals);
+ groups[1] = flat;
+ groups[GROUP as usize] = Some(&frame.layout);
+ device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+ label: Some("Native shader pack terrain"),
+ bind_group_layouts: &groups,
+ ..Default::default()
+ })
+ };
+ let instance_attributes = wgpu::vertex_attr_array![5=>Float32x4];
+ let vertices = wgpu::VertexBufferLayout {
+ array_stride: std::mem::size_of::() as u64,
+ step_mode: wgpu::VertexStepMode::Vertex,
+ attributes: &super::TERRAIN_ATTRIBUTES,
+ };
+ let instances = wgpu::VertexBufferLayout {
+ array_stride: 16,
+ step_mode: wgpu::VertexStepMode::Instance,
+ attributes: &instance_attributes,
+ };
+ // As the renderer's terrain pipelines (gfx.rs): back faces culled, reversed depth.
+ let pipeline = |layout: &wgpu::PipelineLayout,
+ vertex: &str,
+ buffers: &[Option>],
+ fragment: &str,
+ blend: Option| {
+ let options = wgpu::PipelineCompilationOptions {
+ constants: &constants,
+ ..Default::default()
+ };
+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+ label: Some(&stage.label),
+ layout: Some(layout),
+ vertex: wgpu::VertexState {
+ module: &module,
+ entry_point: Some(vertex),
+ compilation_options: options.clone(),
+ buffers,
+ },
+ primitive: wgpu::PrimitiveState {
+ cull_mode: Some(wgpu::Face::Back),
+ ..Default::default()
+ },
+ depth_stencil: Some(wgpu::DepthStencilState {
+ format: wgpu::TextureFormat::Depth32Float,
+ depth_write_enabled: Some(true),
+ depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+ stencil: Default::default(),
+ bias: Default::default(),
+ }),
+ multisample: Default::default(),
+ fragment: Some(wgpu::FragmentState {
+ module: &module,
+ entry_point: Some(fragment),
+ compilation_options: options,
+ targets: &[Some(wgpu::ColorTargetState {
+ format: shape.format,
+ blend,
+ write_mask: wgpu::ColorWrites::ALL,
+ })],
+ }),
+ multiview_mask: None,
+ cache: None,
+ })
+ };
+ let blend = Some(wgpu::BlendState::ALPHA_BLENDING);
+ let instanced = layout(None);
+ let buffers = [Some(vertices.clone()), Some(instances)];
+ let solid = pipeline(
+ &instanced,
+ "horizon_material_vs",
+ &buffers,
+ "horizon_material_fs_solid",
+ None,
+ );
+ let translucent = pipeline(
+ &instanced,
+ "horizon_material_vs",
+ &buffers,
+ "horizon_material_fs_translucent",
+ blend,
+ );
+ let flat = shape.flat.map(|group| {
+ let layout = layout(Some(group));
+ let buffers = [Some(vertices.clone())];
+ let vs = "horizon_material_vs_flat";
+ (
+ pipeline(&layout, vs, &buffers, "horizon_material_fs_solid", None),
+ pipeline(
+ &layout,
+ vs,
+ &buffers,
+ "horizon_material_fs_translucent",
+ blend,
+ ),
+ )
+ });
+ if let Some(e) = pollster::block_on(scope.pop()) {
+ return Err(format!("{}: {e}", stage.file));
+ }
+ Ok(Self {
+ solid,
+ translucent,
+ flat,
+ })
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use horizon_shader_api::{MANIFEST, Pack, StageKind, check};
+
+ fn stage(material: &str) -> CheckedStage {
+ let manifest = "schema = 1\nid = \"t\"\nname = \"T\"\nversion = \"1\"\napi = \"0.1\"\n\
+ [material]\nfile = \"material.wgsl\"\n\
+ [[options]]\nid = \"gain\"\nname = \"Gain\"\ntype = \"float\"\n\
+ default = 1.0\nmin = 0.0\nmax = 2.0\n";
+ let files = [(MANIFEST, manifest), ("material.wgsl", material)]
+ .map(|(n, t)| (n.to_owned(), t.as_bytes().to_vec()))
+ .into();
+ let mut report = check(&Pack::from_files(files).unwrap()).unwrap();
+ assert_eq!(report.stages[0].kind, StageKind::Material);
+ report.stages.remove(0)
+ }
+
+ #[test]
+ fn the_terrain_takes_a_prefix_and_validates_with_a_pack() {
+ let terrain = vanilla_terrain();
+ for name in [
+ "Globals",
+ "globals",
+ "sprites_7",
+ "sprite",
+ "SPRITE_SPLIT",
+ "block_slots",
+ "sample_lightmap",
+ "apply_fog",
+ ] {
+ assert!(terrain.contains(&format!("{PREFIX}{name}")), "{name}");
+ }
+ assert!(!terrain.contains("fs_sky"), "the sky stays out");
+ // A pack may use any name Horizon's terrain uses unprefixed.
+ let own = "override gain: f32;\nconst PI: f32 = 3.0;\n\
+ fn sprite(c: vec4) -> vec4 { return c * PI; }\n\
+ fn apply_fog(c: vec4) -> vec4 { return c * gain; }\n\
+ fn material(input: MaterialInput) -> Surface {\n \
+ let lit = input.albedo * input.tint * vec4(input.lightmap, 1.0);\n \
+ return Surface(apply_fog(sprite(lit)));\n}\n";
+ let stage = stage(own);
+ let module = module(&stage).unwrap();
+ let info = naga::valid::Validator::new(
+ naga::valid::ValidationFlags::all(),
+ naga::valid::Capabilities::all(),
+ )
+ .validate(&module)
+ .unwrap_or_else(|e| panic!("{}", e.emit_to_string(&shader_source(&stage.source))));
+ let entries: Vec<&str> = module
+ .entry_points
+ .iter()
+ .map(|e| e.name.as_str())
+ .collect();
+ for entry in [
+ "horizon_material_vs",
+ "horizon_material_vs_flat",
+ "horizon_material_fs_solid",
+ "horizon_material_fs_translucent",
+ ] {
+ assert!(entries.contains(&entry), "{entry}");
+ }
+ drop(info);
+ assert_eq!(
+ present_constants(&module, &[("gain".into(), 1.5), ("other".into(), 1.0)]),
+ [("gain", 1.5)]
+ );
+ }
+}
diff --git a/crates/horizon-client/src/gfx/native_pack.rs b/crates/horizon-client/src/gfx/native_pack.rs
index 3f9206e11..4fb5cdc59 100644
--- a/crates/horizon-client/src/gfx/native_pack.rs
+++ b/crates/horizon-client/src/gfx/native_pack.rs
@@ -1,8 +1,9 @@
//! One of Horizon's own shader packs while it runs (docs/shaders.md): the frame its stages
-//! read, its sky and post stages, and the timer of their passes.
+//! read, its sky, material and post stages, and the timer of their passes.
use horizon_shader_api::{Report, StageKind};
+use super::native_material::{NativeMaterial, TerrainShape};
use super::native_post::{NativeFrame, NativePost};
use super::native_sky::NativeSky;
use super::pack_timing::PassTiming;
@@ -10,6 +11,7 @@ use super::pack_timing::PassTiming;
pub struct NativePack {
pub frame: NativeFrame,
pub sky: Option,
+ pub material: Option,
pub post: Option,
/// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`).
pub timing: Option,
@@ -17,16 +19,16 @@ pub struct NativePack {
impl NativePack {
/// The pack of the checked stages `report` with the option values `constants`, drawing
- /// onto targets of `format`; `globals` is the terrain's group 0, which the sky reads.
+ /// onto the world's targets as `terrain` describes; the sky reads the terrain's group 0.
/// Also returns its stages' labels, in the order they draw. Errors name the stage wgpu
/// refused.
pub fn new(
device: &wgpu::Device,
- globals: &wgpu::BindGroupLayout,
+ terrain: &TerrainShape<'_>,
report: Report,
constants: &[(String, f64)],
- format: wgpu::TextureFormat,
) -> Result<(Self, Vec), String> {
+ let (globals, format) = (terrain.globals, terrain.format);
let frame = NativeFrame::new(device);
let (post, others): (Vec<_>, Vec<_>) = report
.stages
@@ -37,16 +39,28 @@ impl NativePack {
.find(|s| s.kind == StageKind::Sky)
.map(|stage| NativeSky::new(device, globals, &frame, stage, constants, format))
.transpose()?;
+ let material = others
+ .iter()
+ .find(|s| s.kind == StageKind::Material)
+ .map(|stage| NativeMaterial::new(device, terrain, &frame, stage, constants))
+ .transpose()?;
let post = (!post.is_empty())
.then(|| NativePost::new(device, post, constants, format, &frame))
.transpose()?;
let mut labels: Vec = sky.iter().map(|s| s.label.clone()).collect();
+ labels.extend(
+ others
+ .iter()
+ .filter(|s| material.is_some() && s.kind == StageKind::Material)
+ .map(|s| s.label.clone()),
+ );
if let Some(post) = &post {
labels.extend(post.labels().into_iter().map(str::to_owned));
}
let pack = Self {
frame,
sky,
+ material,
post,
timing: None,
};
@@ -55,6 +69,6 @@ impl NativePack {
/// Whether the pack draws anything the game runs today.
pub fn draws(&self) -> bool {
- self.sky.is_some() || self.post.is_some()
+ self.sky.is_some() || self.material.is_some() || self.post.is_some()
}
}
diff --git a/crates/horizon-client/src/gfx/pack_atlas.rs b/crates/horizon-client/src/gfx/pack_atlas.rs
index 42a2abee1..c7a67a50b 100644
--- a/crates/horizon-client/src/gfx/pack_atlas.rs
+++ b/crates/horizon-client/src/gfx/pack_atlas.rs
@@ -169,6 +169,7 @@ impl PackAtlas {
];
let columns = self.columns;
// UVs past a sprite (models up to 2, distant tiles) cannot repeat in an atlas: clamped.
+ // The colour's alpha holds HDR's emission level (`mesher::EMISSION_BITS`): packs get 1.
let body = format!(
" vec4 hz_origin = {origin};\n \
uint hz_layer = hz_v_layer & 32767u;\n \
@@ -178,7 +179,7 @@ impl PackAtlas {
hz_MultiTexCoord0 = vec4((hz_cell + clamp(vec2(hz_v_uv) * hz_origin.w, 0.0, 1.0)) * hz_scale, 0.0, 1.0);\n \
hz_MultiTexCoord1 = vec4(float(hz_v_light.y), float(hz_v_light.x), 0.0, 1.0);\n \
hz_MultiTexCoord2 = hz_MultiTexCoord1;\n \
- hz_Color = hz_v_color;\n \
+ hz_Color = vec4(hz_v_color.rgb, 1.0);\n \
hz_Normal = vec3(0.0, 1.0, 0.0);\n \
hz_tangent = vec4(1.0, 0.0, 0.0, 1.0);\n",
scale[0], scale[1],
diff --git a/crates/horizon-client/src/gfx/pack_uniforms.rs b/crates/horizon-client/src/gfx/pack_uniforms.rs
index c4df4377b..8f5f1a2de 100644
--- a/crates/horizon-client/src/gfx/pack_uniforms.rs
+++ b/crates/horizon-client/src/gfx/pack_uniforms.rs
@@ -399,7 +399,8 @@ impl FrameUniforms {
_ => Value::i(&[0]),
}
};
- self.values = NAMES.iter().map(|n| value(n)).collect();
+ self.values.clear();
+ self.values.extend(NAMES.iter().map(|n| value(n)));
self.frame = (self.frame + 1) % 720_720;
}
diff --git a/crates/horizon-client/src/graphics.rs b/crates/horizon-client/src/graphics.rs
index b51a586ab..4f6f04bc0 100644
--- a/crates/horizon-client/src/graphics.rs
+++ b/crates/horizon-client/src/graphics.rs
@@ -255,6 +255,12 @@ pub struct Graphics {
pub resolution_scale: u32,
/// FXAA over the world.
pub fxaa: bool,
+ /// HDR output (scRGB), where the display path offers it.
+ pub hdr: bool,
+ /// HDR paper white (where SDR white sits), in nits.
+ pub hdr_paper_white: u32,
+ /// HDR peak brightness the world's highlights reach, in nits.
+ pub hdr_peak: u32,
/// Battery mode: at most 60 frames per second in a world and 30 in menus
/// or behind other windows, and half the worker threads. Off by default;
/// it changes when frames are drawn, never what they show or the ticks.
@@ -286,6 +292,9 @@ impl Default for Graphics {
overlay: Overlay::Off,
resolution_scale: 100,
fxaa: false,
+ hdr: false,
+ hdr_paper_white: 200,
+ hdr_peak: 1000,
battery: false,
api: GraphicsApi::Auto,
shader_pack: String::new(),
@@ -337,6 +346,9 @@ impl Graphics {
"workers" => g.workers = number(g.workers).min(64),
"resolutionScale" => g.resolution_scale = number(g.resolution_scale).clamp(50, 200),
"fxaa" => g.fxaa = flag(g.fxaa),
+ "hdr" => g.hdr = flag(g.hdr),
+ "hdrPaperWhite" => g.hdr_paper_white = number(g.hdr_paper_white).clamp(80, 480),
+ "hdrPeak" => g.hdr_peak = number(g.hdr_peak).clamp(200, 2000),
"batteryMode" => g.battery = flag(g.battery),
"graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
"pickedShaderPack" => g.shader_pack = value.to_owned(),
@@ -354,7 +366,7 @@ impl Graphics {
}
pub fn serialize(&self) -> String {
format!(
- "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nbatteryMode:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
+ "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nbatteryMode:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
self.preset.name(),
self.lod_distance,
self.far_detail.name(),
@@ -379,6 +391,9 @@ impl Graphics {
},
self.resolution_scale,
bool_text(self.fxaa),
+ bool_text(self.hdr),
+ self.hdr_paper_white,
+ self.hdr_peak,
bool_text(self.battery),
self.api.name(),
self.shader_pack,
@@ -444,7 +459,7 @@ pub fn apply_preset(preset: Preset, s: &mut crate::settings::Settings) {
let g = &mut s.horizon;
g.preset = preset;
g.cave_culling = true;
- g.animated_textures = preset != Preset::Performance;
+ g.animated_textures = true;
g.chunk_updates = 0;
g.upload_budget_kib = 0;
g.sky = true;
@@ -476,6 +491,9 @@ mod tests {
overlay: Overlay::Graph,
resolution_scale: 75,
fxaa: true,
+ hdr: true,
+ hdr_paper_white: 240,
+ hdr_peak: 1400,
battery: true,
api: GraphicsApi::Dx12,
shader_pack: "Golden Hour".into(),
diff --git a/crates/horizon-client/src/graphics_ui.rs b/crates/horizon-client/src/graphics_ui.rs
index ba99f89a8..3c7a40e02 100644
--- a/crates/horizon-client/src/graphics_ui.rs
+++ b/crates/horizon-client/src/graphics_ui.rs
@@ -37,6 +37,9 @@ pub enum H {
Overlay,
ResolutionScale,
Antialiasing,
+ Hdr,
+ HdrPaperWhite,
+ HdrPeak,
BatteryMode,
GraphicsApi,
}
@@ -221,6 +224,21 @@ pub fn rows(level: Level) -> Vec
{
Medium,
"FXAA smooths jagged edges of the world; slightly softer image.",
),
+ h(
+ H::Hdr,
+ None,
+ "HDR output on an HDR display: lava, fire and sunlight shine brighter.",
+ ),
+ h(
+ H::HdrPaperWhite,
+ None,
+ "HDR: how bright white paper and menus look. Match your desktop.",
+ ),
+ h(
+ H::HdrPeak,
+ None,
+ "HDR: how bright the brightest highlights get. Your display's peak.",
+ ),
h(
H::PresentMode,
None,
@@ -324,6 +342,8 @@ impl H {
}
H::Workers => Some(g.workers as f32 / max_workers() as f32),
H::ResolutionScale => Some((g.resolution_scale as f32 - 50.0) / 150.0),
+ H::HdrPaperWhite => Some((g.hdr_paper_white as f32 - 80.0) / 400.0),
+ H::HdrPeak => Some((g.hdr_peak as f32 - 200.0) / 1800.0),
_ => None,
}
}
@@ -365,6 +385,9 @@ impl H {
},
H::ResolutionScale => labelled("Resolution Scale", format!("{}%", g.resolution_scale)),
H::Antialiasing => labelled("Anti-aliasing", if g.fxaa { "FXAA" } else { "Off" }),
+ H::Hdr => labelled("HDR", on_off(g.hdr)),
+ H::HdrPaperWhite => labelled("Paper White", format!("{} nits", g.hdr_paper_white)),
+ H::HdrPeak => labelled("Peak Brightness", format!("{} nits", g.hdr_peak)),
H::BatteryMode => labelled("Battery Mode", on_off(g.battery)),
H::GraphicsApi => labelled("Graphics API", g.api.label()),
H::Overlay => labelled(
@@ -387,6 +410,8 @@ impl H {
}
H::Workers => g.workers = (v * max_workers() as f32).round() as u32,
H::ResolutionScale => g.resolution_scale = (50.0 + (v * 30.0).round() * 5.0) as u32,
+ H::HdrPaperWhite => g.hdr_paper_white = (80.0 + (v * 40.0).round() * 10.0) as u32,
+ H::HdrPeak => g.hdr_peak = (200.0 + (v * 36.0).round() * 50.0) as u32,
_ => {}
}
}
@@ -418,6 +443,7 @@ impl H {
H::AnimatedTextures => g.animated_textures = !g.animated_textures,
H::PresentMode => g.present_mode = step(&PresentMode::ALL, g.present_mode, back),
H::Antialiasing => g.fxaa = !g.fxaa,
+ H::Hdr => g.hdr = !g.hdr,
H::BatteryMode => g.battery = !g.battery,
H::GraphicsApi => g.api = step(&GraphicsApi::ALL, g.api, back),
H::Pacing => {
@@ -453,6 +479,7 @@ impl Item {
Item::Horizon(H::Weather) => g.weather,
Item::Horizon(H::AnimatedTextures) => g.animated_textures,
Item::Horizon(H::Antialiasing) => g.fxaa,
+ Item::Horizon(H::Hdr) => g.hdr,
Item::Horizon(H::BatteryMode) => g.battery,
Item::Vanilla(Opt::ViewBobbing) => s.view_bobbing,
Item::Vanilla(Opt::Vsync) => s.vsync,
diff --git a/crates/horizon-client/src/hdr.wgsl b/crates/horizon-client/src/hdr.wgsl
new file mode 100644
index 000000000..bf6c27cca
--- /dev/null
+++ b/crates/horizon-client/src/hdr.wgsl
@@ -0,0 +1,69 @@
+// Horizon's HDR output pass: the frame, drawn as without HDR in vanilla's gamma
+// space, decoded to linear light at the paper white and written to the scRGB
+// swapchain (1.0 = 80 nits). Bright pixels of light sources that still show the
+// world as it was before the hand and HUD are expanded towards the peak.
+@group(0) @binding(0) var frame: texture_2d;
+@group(0) @binding(1) var world: texture_2d;
+
+struct Params {
+ // Paper white in scRGB units (nits / 80).
+ paper: f32,
+ // Peak brightness relative to paper white; 1 expands nothing.
+ peak: f32,
+ // 1 when this frame drew a world.
+ world: f32,
+ // 1 paints expanded pixels magenta (HORIZON_HDR_DEBUG=1).
+ debug: f32,
+};
+@group(0) @binding(2) var params: Params;
+
+// Light sources are lifted evenly rather than by a highlight curve: vanilla's
+// textures were drawn for SDR, so a curve on their brightest pixels blows out
+// near-white spots (glowstone) and leaves the rest (lava, a jack o'lantern's
+// face) nearly as it was. Pixels brighter than LIFT_FULL get STRENGTH of the
+// headroom, dimmer ones less down to none at LIFT_START (lava's crust, a
+// lantern's metal), and no channel goes past the peak. Brightness is the mean
+// of luminance and the brightest channel, so saturated light counts as bright.
+const LIFT_START: f32 = 0.18;
+const LIFT_FULL: f32 = 0.42;
+const STRENGTH: f32 = 0.7;
+
+// Whether `c` still shows the world pixel `w`: the same, or darkened evenly
+// across its channels, as the vignette and other screen-wide tints darken it.
+// The hand, HUD and text replace pixels instead, so they never pass.
+fn shows_world(c: vec3, w: vec3) -> bool {
+ if all(c == w) {
+ return true;
+ }
+ let k = c / max(w, vec3(1.0 / 255.0));
+ let mean = (k.r + k.g + k.b) / 3.0;
+ return mean <= 1.01 && mean > 0.5 && all(abs(k - vec3(mean)) < vec3(0.03));
+}
+
+@vertex fn vs_hdr(@builtin(vertex_index) i: u32) -> @builtin(position) vec4 {
+ let p = vec2(f32((i << 1u) & 2u), f32(i & 2u));
+ return vec4(p * 2.0 - 1.0, 0.0, 1.0);
+}
+
+@fragment fn fs_hdr(@builtin(position) pos: vec4) -> @location(0) vec4 {
+ let at = vec2(pos.xy);
+ let c = textureLoad(frame, at, 0).rgb;
+ // Gamma 2.2, as SDR displays and the compositors' SDR paths decode it.
+ var light = pow(max(c, vec3(0.0)), vec3(2.2));
+ let w = textureLoad(world, at, 0);
+ // The world's alpha is 0 on light-emitting blocks, the sun and the moon
+ // (terrain.wgsl, the celestial pipeline): only those shine.
+ if params.world > 0.5 && params.peak > 1.0 && w.a < 0.75 && shows_world(c, w.rgb) {
+ let y = 0.5 * (dot(light, vec3(0.2126, 0.7152, 0.0722)) + max(light.r, max(light.g, light.b)));
+ let lift = smoothstep(LIFT_START, LIFT_FULL, y);
+ if lift > 0.0 {
+ let top = max(light.r, max(light.g, light.b));
+ let gain = min(1.0 + (params.peak - 1.0) * STRENGTH * lift, params.peak / max(top, 1e-4));
+ light *= max(gain, 1.0);
+ if params.debug > 0.5 {
+ light = mix(light, vec3(gain, 0.0, gain), 0.6);
+ }
+ }
+ }
+ return vec4(light * params.paper, 1.0);
+}
diff --git a/crates/horizon-client/src/health.rs b/crates/horizon-client/src/health.rs
index 25c719bfb..46821df27 100644
--- a/crates/horizon-client/src/health.rs
+++ b/crates/horizon-client/src/health.rs
@@ -111,6 +111,12 @@ pub enum HealthEvent {
amount: f32,
},
Phase(&'static str),
+ /// `Player.hurtArmor`: a hit that doesn't bypass armor wears the worn
+ /// pieces (`LivingEntity.getDamageAfterArmorAbsorb`); the game applies it.
+ ArmorHurt {
+ source: DamageTypeId,
+ amount: f32,
+ },
/// `ServerLevel.broadcastDamageEvent`: the client's
/// `LivingEntity.handleDamageEvent` plays the source's hurt sound.
DamageBroadcast {
@@ -139,6 +145,7 @@ impl HealthEvent {
format!("record-damage {:08x}", amount.to_bits())
}
Self::Phase(name) => name.into(),
+ Self::ArmorHurt { amount, .. } => format!("hurt-armor {:08x}", amount.to_bits()),
Self::DamageBroadcast { .. } => "broadcast-damage".into(),
Self::Criterion { .. } => "hurt-criterion".into(),
}
@@ -295,6 +302,20 @@ impl PlayerMotion {
source: DamageTypeId,
amount: f32,
blocking: Option,
+ ) -> Result {
+ self.hurt_caused_by(resources, rules, source, amount, blocking, false)
+ }
+ /// `hurt_blocking` from a source whose causing entity is a living
+ /// non-player (`living_cause`), which the `when_caused_by_living_non_player`
+ /// damage types scale with the difficulty.
+ pub fn hurt_caused_by(
+ &mut self,
+ resources: &HealthResources,
+ rules: HealthRules,
+ source: DamageTypeId,
+ amount: f32,
+ blocking: Option,
+ living_cause: bool,
) -> Result {
if self.client_side {
return Ok(BlockOutcome::default());
@@ -315,6 +336,7 @@ impl PlayerMotion {
invulnerable,
rules,
source,
+ living_cause,
events: &mut self.events,
dead: &mut h.dead,
sync_velocity: &mut h.sync_velocity,
@@ -390,6 +412,8 @@ pub(crate) struct Environment<'a> {
pub(crate) invulnerable: bool,
pub(crate) rules: HealthRules,
pub(crate) source: DamageSource<'a, ()>,
+ /// The causing entity is a living non-player (a mob, or its projectile's owner).
+ pub(crate) living_cause: bool,
pub(crate) events: &'a mut Vec,
pub(crate) dead: &'a mut bool,
pub(crate) sync_velocity: &'a mut bool,
@@ -517,9 +541,14 @@ impl ServerDamageEnvironment for Environment<'_> {
fn bypasses(&mut self, kind: Bypass) -> io::Result {
Ok(self.source.bypasses(kind))
}
- fn hurt_armor(&mut self, _: &mut Attributes, _: f32) -> io::Result<()> {
+ fn hurt_armor(&mut self, _: &mut Attributes, damage: f32) -> io::Result<()> {
+ // The worn armor lives in the game, which wears it from this event.
+ self.event(HealthEvent::ArmorHurt {
+ source: self.source.type_id(),
+ amount: damage,
+ });
Ok(())
- } // empty equipment
+ }
fn has_resistance(&mut self) -> io::Result {
Ok(self.status.resistance.is_some())
}
@@ -773,8 +802,13 @@ impl PlayerHurtWorld for Environment<'_> {
Ok(())
}
fn scales_with_difficulty(&mut self, _: &mut State) -> io::Result {
- Ok(self.source.definition().scaling == Scaling::Always)
- } // no causing entity
+ // DamageSource.scalesWithDifficulty.
+ Ok(match self.source.definition().scaling {
+ Scaling::Never => false,
+ Scaling::Always => true,
+ Scaling::LivingNonPlayer => self.living_cause,
+ })
+ }
fn difficulty(&mut self, _: &mut State) -> io::Result {
Ok(self.rules.difficulty)
}
diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs
index ecc23a5ee..ebd860e08 100644
--- a/crates/horizon-client/src/hud_overlays.rs
+++ b/crates/horizon-client/src/hud_overlays.rs
@@ -1111,8 +1111,9 @@ impl SubtitleOverlay {
s.purge_old_instances(3000.0 * frame.multiplier, now);
}
if s.audible_from(position) && !s.played.is_empty() {
- width = width.max(width_of(&Text::translate(&s.key, &[])));
- audible.push(i);
+ let text_width = width_of(&Text::translate(&s.key, &[]));
+ width = width.max(text_width);
+ audible.push((i, text_width));
}
}
if audible.is_empty() {
@@ -1121,7 +1122,7 @@ impl SubtitleOverlay {
let w = |s: &str| font.width(s) as i32;
width += w("<") + w(" ") + w(">") + w(" ");
let mut row = 0;
- for i in audible {
+ for (i, text_width) in audible {
let s = &self.subtitles[i];
let text_value = Text::translate(&s.key, &[]);
let Some(closest) = s.best_candidate(position) else {
@@ -1145,7 +1146,6 @@ impl SubtitleOverlay {
let half_width = width / 2;
let height = 9;
let half_height = height / 2;
- let text_width = width_of(&text_value);
let brightness = s.brightness(closest, frame.multiplier, now);
out.push(GuiDraw::Push(vec![
PoseOp::Translate(
diff --git a/crates/horizon-client/src/hunger.rs b/crates/horizon-client/src/hunger.rs
index 15eac144f..34f414d50 100644
--- a/crates/horizon-client/src/hunger.rs
+++ b/crates/horizon-client/src/hunger.rs
@@ -151,6 +151,7 @@ impl FoodWorld for TickWorld<'_> {
.damage
.source::<()>(id, None, None, None)
.expect("validated starvation source"),
+ living_cause: false,
events: self.events,
dead: self.dead,
sync_velocity: self.sync_velocity,
diff --git a/crates/horizon-client/src/item_data.rs b/crates/horizon-client/src/item_data.rs
index c07e2f352..ac624e85b 100644
--- a/crates/horizon-client/src/item_data.rs
+++ b/crates/horizon-client/src/item_data.rs
@@ -204,6 +204,14 @@ impl ItemStack {
pub fn custom_name(&self) -> Option<&str> {
self.data().and_then(|d| d.custom_name.as_deref())
}
+ /// `minecraft:item_name` in the current language (`getItemName`'s
+ /// component). It stays in the patch as loaded, so a translatable name
+ /// saves and reaches clients unchanged; the ominous banner's is modelled
+ /// by `ominous_banner` instead.
+ pub fn item_name(&self) -> Option {
+ let name = self.data()?.other("minecraft:item_name")?;
+ Some(crate::entity_nbt::name_text(name).plain())
+ }
pub fn potion(&self) -> Option<&str> {
self.data().and_then(|d| d.potion.as_deref())
}
diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs
index c2f5c8400..4f981b874 100644
--- a/crates/horizon-client/src/item_render.rs
+++ b/crates/horizon-client/src/item_render.rs
@@ -363,6 +363,9 @@ pub struct ItemRenderer {
sprites: FileSprites,
baked: Mutex>>,
extents: Mutex