Files
horizon-airdef/crates/horizon-client/src/game.rs
T
levzzz b71623dfd7 Item cooldowns: the sweep on a slot, and no use while one runs
Nothing tracked `ItemCooldowns`: `draw_item_decorations` passed a cooldown of
0.0 with a note that there was none to shade, and ender pearls were held back
by an ad-hoc `pearl_cooldown` counter.

`horizon_client::cooldowns` keeps the `use_cooldown` component's entries by
cooldown group the way `Player.getCooldowns` does (start and end ticks, the
percent `getCooldownPercent` returns), `ItemInfo` now carries the item's
`use_cooldown`, and the game uses it where vanilla does:
`ServerPlayerGameMode.useItem`/useItemOn refuse a stack on cooldown,
`ItemStack.applyAfterUseComponentSideEffects` starts the entry when a use
finishes (a thrown pearl, a wind charge, an eaten chorus fruit),
`GuiGraphicsExtractor.itemCooldown` shades the slot, and a server's guests
keep their own and are sent `ClientboundCooldownPacket` (started, and 0 when
it ends), which a client applies.

Fixes #1763

Co-Authored-By: [CC] <deepseek-v4.1-flash> <noreply@deepseek.com>
2026-10-26 01:50:22 +05:00

13696 lines
544 KiB
Rust

//! The playable game loop: streaming world, player simulation at 20 ticks/s,
//! block interaction, inventory and HUD.
mod advancements;
mod advancements_screen;
mod agent;
mod agent_settings;
mod allays;
mod armor_stands;
mod banners;
mod beacon;
mod beehives;
mod block_entity_anims;
mod block_entity_ticks;
mod block_items;
mod blockctl;
mod boat_passengers;
mod boats;
mod books;
mod bossbars;
mod breezes;
mod cartography;
mod chat;
mod clipboard;
mod combat;
mod command_blocks;
mod command_harness;
mod commands;
mod composter;
mod consume;
mod control;
mod copper_golems;
mod creaking;
mod creatures;
mod crossbow;
mod debug_keys;
mod decorated_pot;
mod dedicated;
mod deflect;
mod discord;
mod dispense_fixture;
mod dispenser;
mod dragon;
mod dynamic_lights;
mod enchant_effects;
mod end;
mod entity_culling;
mod events;
mod execution_role;
mod explosion;
mod extras;
mod falling_damage;
mod fangs;
mod fireworks;
mod fishing;
mod fov;
mod frames;
mod friends;
mod functions;
mod game_mode;
mod game_rules_screen;
mod gamemode_switcher;
mod ghasts;
mod golems;
mod growth;
mod hand;
mod initial_spawn;
mod integrated;
mod item_draw;
mod item_particles;
mod jukebox;
mod lan;
mod lan_actions;
mod lan_attributes;
mod lan_chat;
mod lan_crafting;
mod lan_entities;
mod lan_mobs;
mod lan_mount_menu;
mod lan_particles;
mod lan_pvp;
mod lan_screen;
mod lan_stations;
mod lan_trading;
mod lan_vehicles;
mod lan_waypoints;
mod leads;
mod level_particles;
mod levels;
mod lightning;
mod llamas;
mod locator_bar;
mod loom;
mod mace;
mod machines;
mod maps;
mod minecarts;
mod mob_blocks;
mod mob_gear;
mod mods;
mod mount_menu;
mod mounts;
mod moving_pistons;
mod music;
mod names;
mod natural_spawning;
mod nautili;
mod net_harness;
mod nether_portal;
mod ominous_item_spawner;
mod options;
mod packs;
mod pad;
mod pad_menu;
mod paintings;
mod passengers;
mod persist;
mod perspective;
mod pickups;
mod piglins;
mod player_equip;
mod postprocess;
mod potions;
mod powder_snow;
mod pumpkin;
mod raids;
mod recipe_book;
mod remote;
mod remote_mob_data;
mod remote_mob_use;
mod remote_objects;
mod remote_projectiles;
mod remote_stations;
mod remote_vehicles;
mod render_control;
mod render_tick;
mod respawn_anchor;
mod saves_control;
mod saving;
mod scoreboard;
mod screens;
mod sculk;
mod sculk_fixture;
mod server_packs;
mod server_travel;
mod shader_packs;
mod shield;
mod sign_edit;
mod sniffers;
mod spawner;
mod spill;
mod startup_menu;
mod station_control;
mod stations;
mod stats;
mod stats_screen;
mod storage;
mod structures;
mod subtitle_hud;
mod sulfur_cubes;
mod text_displays;
mod titles;
mod tnt;
mod totem;
mod trading;
mod trial_spawner;
mod trial_visuals;
mod trident;
mod tweaks;
mod ui_control;
mod vault;
mod villagers;
mod wandering_trader;
mod win;
mod wind;
mod wither;
mod world_loading;
mod zombie_villagers;
use horizon_client::{
Result,
assets::{Assets, RenderAssets},
audio::Audio,
biome::Biomes,
blocks::{BlockFacts, Fluid},
chunk::{HEIGHT, MIN_Y},
clock::FixedStep,
collisions,
containers::{BlockEntity, Providers},
crafting::Recipes,
creative::{Creative, Names},
entities::{Experience, ExperienceOrb, ItemEntity},
environment::Environment,
first_person::{Hand, SwingAnimation},
gfx::{Frame, Renderer},
hud::{HudAtlas, HudBatch, rgba},
hud_layout, hud_overlays,
items::{ItemStack, Items},
keymapping::KeyAction,
light::LightTables,
mesher::{MeshTables, Vertex},
mobs::{Mob, MobType, MobTypes},
models,
motion::{MotionEvent, MotionResources, MotionWorld, PlayerMotion},
mouse::{LookOptions, MouseLook, Rotation},
particles::Particle,
save::{Level, Persistent, SaveDir},
settings::Settings,
sprint::Keys,
streaming::{Streaming, WorkerContext},
testgen::TestTerrain,
title::{Action, Title},
vanillagen::VanillaTerrain,
world::World,
};
use horizon_core::{
biome::{BiomeZoom, obfuscate_seed},
geometry::{Aabb, Direction},
position::BlockPos,
};
use horizon_core::{geometry::Vec3, random::RandomSource};
use horizon_world::{
block_collision::BlockCollisionRegistry,
collision_context::{CollisionContext, CollisionEntity, CollisionItem},
entity_obstruction::{EntityIdentity, EntityObstructionWorld, ObstructionEntity},
level::{
Behaviours, Dimension as LevelDimension, EntityQuery, Landing, LevelAccess, LevelEvent,
PlaceContext, PlaceOutcome, PlayerContext, PlayerEffect, Ticks, flags as level_flags,
},
registry::BlockStateId,
};
use std::{
cell::RefCell,
collections::{HashMap, HashSet},
path::PathBuf,
sync::{
Arc,
atomic::{AtomicU32, Ordering},
mpsc::{Receiver, TryRecvError},
},
thread::JoinHandle,
time::{Duration, Instant},
};
use winit::{
application::ApplicationHandler,
event::{DeviceEvent, DeviceId, ElementState, MouseButton, MouseScrollDelta, WindowEvent},
event_loop::{ActiveEventLoop, ControlFlow, EventLoop},
keyboard::{KeyCode, PhysicalKey},
window::{CursorGrabMode, Window, WindowId},
};
#[derive(Clone)]
struct Options {
resources: PathBuf,
distance: i32,
distance_override: Option<i32>,
seed: i64,
creative: bool,
test_terrain: bool,
frames: Option<u64>,
/// `--world-frames N`: exit after N frames drawn in the world (smoke runs; the world may load slowly).
world_frames: Option<u64>,
screenshot_after: Option<u64>,
timeout: Duration,
report: Option<PathBuf>,
world: Option<String>,
look: Option<(f32, f32)>,
time: Option<i64>,
weather: Option<String>,
dimension: Option<String>,
/// Options.pauseOnLostFocus off (F3+P), for scripted testing.
no_pause: bool,
/// Control socket path (`--control`), for `horizon-ctl`.
control: Option<PathBuf>,
/// `HORIZON_SPIKES=MS`: print the timed spans of frames slower than MS.
spikes: Option<f32>,
/// Render into a texture instead of the window (`--offscreen`), so a
/// GPU the display cannot present from can still be benchmarked.
offscreen: bool,
/// `--width` and `--height` (vanilla's own arguments): the window's
/// starting size, 1280x720 by default.
window_size: [u32; 2],
/// Multiplayer: `--server HOST[:PORT]` joins at start; `--name` is the offline player name.
server: Option<String>,
/// `--name`, `HORIZON_PLAYER_NAME` or the signed-in account's name; else
/// [`Options::player_name`] uses the kept offline name.
player_name: Option<String>,
/// `--dedicated`: run as a dedicated server; vanilla's server arguments
/// (`--nogui`, `--port`, `--world`, `--universe`, `--initSettings`) follow.
dedicated: Option<Vec<String>>,
/// `--benchmark SCENARIO`: run the benchmark, write its report and quit.
benchmark: Option<String>,
/// `--dev-mod PATH` (repeatable): mods always on and reloaded when rebuilt.
dev_mods: Vec<PathBuf>,
/// Single player runs on an integrated server thread (game/integrated.rs),
/// as vanilla's does: the default. `--in-frame` (or `--no-server-thread`,
/// or `HORIZON_SERVER_THREAD=0`) runs the world in the frame instead.
server_thread: bool,
/// What this Game executes; independent of its current server connection.
execution_role: execution_role::ExecutionRole,
}
impl Options {
/// The name to join servers with: the one given, else the offline name kept
/// next to options.txt (created on first use).
fn player_name(&self) -> String {
self.player_name.clone().unwrap_or_else(|| {
std::env::current_dir().map_or_else(
|_| horizon_client::offline_name::generate(0),
|dir| horizon_client::offline_name::load_or_create(&dir),
)
})
}
fn read() -> Result<Option<Self>> {
let sibling = std::env::current_exe()?
.parent()
.ok_or("missing executable directory")?
.join("resources");
let mut o = Self {
resources: if sibling.join("horizon-resources.json").exists() {
sibling
} else {
std::path::Path::new(".local/horizon-client").join(horizon_core::VANILLA_VERSION)
},
distance: 12,
distance_override: None,
seed: 0,
creative: false,
test_terrain: false,
frames: None,
world_frames: None,
screenshot_after: None,
timeout: Duration::from_secs(120),
report: None,
world: None,
look: None,
time: None,
weather: None,
dimension: None,
no_pause: false,
control: None,
offscreen: false,
window_size: [1280, 720],
spikes: std::env::var("HORIZON_SPIKES")
.ok()
.and_then(|v| v.parse().ok()),
server: None,
player_name: std::env::var("HORIZON_PLAYER_NAME")
.ok()
.filter(|n| !n.is_empty()),
dedicated: None,
benchmark: None,
dev_mods: Vec::new(),
// The command harness (HORIZON_COMMAND_SCRIPT) drives the world
// itself, without the event loop: it stays in the frame.
server_thread: std::env::var("HORIZON_SERVER_THREAD").map_or(true, |v| v != "0")
&& std::env::var_os("HORIZON_COMMAND_SCRIPT").is_none(),
execution_role: execution_role::ExecutionRole::Client,
};
let mut session_file = std::env::var("HORIZON_SESSION_FILE").ok();
let mut args = std::env::args().skip(1);
while let Some(arg) = args.next() {
match arg.as_str() {
"--help" | "-h" => {
println!(
"Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --width N, --height N Window size (default 1280 x 720)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --in-frame Run single player's world in the frame, not on its server thread\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
horizon_core::VANILLA_VERSION
);
return Ok(None);
}
"--dedicated" => {
o.execution_role = execution_role::ExecutionRole::DedicatedServer;
o.dedicated = Some(args.by_ref().collect());
break;
}
"--creative" => o.creative = true,
"--test-terrain" => o.test_terrain = true,
"--no-pause" => o.no_pause = true,
"--offscreen" => o.offscreen = true,
"--control" => o.control = Some(horizon_client::control::default_path()),
"--server-thread" => o.server_thread = true,
"--in-frame" | "--no-server-thread" => o.server_thread = false,
_ => {
let value = args
.next()
.ok_or_else(|| format!("missing value after {arg}"))?;
match arg.as_str() {
"--resources" => o.resources = value.into(),
"--render-distance" | "--radius" => {
o.distance = value.parse()?;
o.distance_override = Some(o.distance);
if !(2..=64).contains(&o.distance) {
return Err("render distance must be 2..64".into());
}
}
"--seed" => {
o.seed = value.parse().unwrap_or_else(|_| {
// Text seeds hash like String.hashCode.
value
.encode_utf16()
.fold(0i32, |h, c| {
h.wrapping_mul(31).wrapping_add(i32::from(c))
})
.into()
})
}
"--frames" => o.frames = Some(value.parse()?),
"--world-frames" => {
o.world_frames = Some(value.parse()?);
// A frame-limited run in every other respect; --timeout-seconds still applies.
o.frames.get_or_insert(u64::MAX);
}
"--timeout-seconds" => o.timeout = Duration::from_secs(value.parse()?),
"--smoke-report" => o.report = Some(value.into()),
"--screenshot-after" => o.screenshot_after = Some(value.parse()?),
"--width" => o.window_size[0] = value.parse::<u32>()?.max(1),
"--height" => o.window_size[1] = value.parse::<u32>()?.max(1),
"--world" => o.world = Some(value),
"--dev-mod" => o.dev_mods.push(std::path::absolute(&value)?),
"--benchmark" => {
if horizon_client::benchmark::scenes(&value).is_none() {
return Err(format!(
"unknown benchmark {value}: standard, village, forest, ocean or mountain"
)
.into());
}
o.benchmark = Some(value);
}
"--server" => o.server = Some(value),
"--name" => o.player_name = Some(value),
"--session-file" => session_file = Some(value),
"--control-socket" => o.control = Some(value.into()),
"--time" => o.time = Some(value.parse()?),
"--weather" => o.weather = Some(value),
"--dimension" => {
o.dimension = Some(if value.contains(':') {
value
} else {
format!("minecraft:{value}")
})
}
"--look" => {
let (y, p) = value.split_once(',').ok_or("--look takes YAW,PITCH")?;
o.look = Some((y.parse()?, p.parse()?));
}
_ => return Err(format!("unknown option {arg}").into()),
}
}
}
}
// The launcher's account: online-mode servers need it. A bad file
// only leaves the game offline.
if let Some(path) = session_file.filter(|p| !p.is_empty()) {
match horizon_client::auth::AuthSession::load(path.as_ref()) {
Ok(session) => {
o.player_name = Some(session.name.clone());
horizon_client::auth::set_current(session);
}
Err(e) => eprintln!("Horizon: not signed in: {e}"),
}
}
Ok(Some(o))
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Screen {
Playing,
GameModeSwitcher,
Paused,
Options,
Chat,
Creative,
Inventory,
Dead,
/// The Statistics screen.
Stats,
/// The Advancements screen.
Advancements,
/// WorldOptionsScreen (game/lan_screen.rs).
WorldOptions,
/// Play with Friends, from the pause menu's Friends button
/// (`friends_screen`, game/friends.rs).
Friends,
/// CommandBlockEditScreen (game/command_blocks.rs).
CommandBlock,
/// WinScreen: the end poem and the credits (game/win.rs).
Win,
}
struct Mining {
pos: [i32; 3],
progress: f32,
ticks: u32,
}
struct Hit {
pos: [i32; 3],
face: [i32; 3],
point: [f64; 3],
}
/// What a falling block's tick did (`FallingBlockEntity.tick`).
enum FallStep {
Falling,
Gone,
/// Gave up falling: drops itself as an item here.
Dropped(Vec3),
/// Hit the ground in this block.
Landed([i32; 3]),
}
/// A guest's right click comes as one packet per hand and part
/// (`Minecraft.startUseItem`): `ServerGamePacketListenerImpl.handleUseItemOn`
/// does the block's and `ItemStack.useOn`'s part, `handleUseItem` the
/// item's own (`Item.use`). Running both for either would use the item twice.
#[derive(Clone, Copy)]
enum GuestUse {
OnBlock(Hand),
Item(Hand),
/// `handleInteract`: `Player.interactOn` with the hand, nothing else (the
/// client sends UseItem itself when the entity passed).
Entity(Hand),
}
/// The client world as seen by the vanilla block-behaviour library.
struct GameLevel<'w> {
world: &'w mut World,
facts: &'w BlockFacts,
collision: &'w BlockCollisionRegistry<'w>,
events: &'w mut Vec<LevelEvent>,
dimension: LevelDimension,
darken: i32,
raining: bool,
thundering: bool,
player_box: Option<([f64; 3], [f64; 3])>,
/// The LAN guests in this level who trigger blocks (not spectators).
guest_boxes: Vec<([f64; 3], [f64; 3])>,
player_collision: Option<PlayerCollision>,
/// Minecart boxes (detector rails).
cart_boxes: Vec<([f64; 3], [f64; 3])>,
/// The other entities that keep blocks from being placed into them.
blockers: Blockers<'w>,
biomes: &'w Biomes,
seed: i64,
behaviours: &'w Behaviours,
items: &'w Items,
/// Container loot tables (`unpackLootTable`).
loot: Option<std::sync::Arc<horizon_world::loot::LootData>>,
registry: &'static horizon_world::registry::BlockRegistry,
rules: horizon_world::level::GameRules,
/// Block loot random sequences (`ServerLevel.getRandomSequence`).
rand_sequences: &'w mut horizon_client::random_sequences::RandomSequences,
pending: &'w mut spill::Pending,
spill: &'w mut spill::Spill,
/// Where the chunk tickets let blocks tick.
tickets: horizon_client::ticket_levels::Levels,
random_tick_sections: &'w mut horizon_client::random_tick_sections::RandomTickSections,
}
struct PlayerCollision {
y: f64,
descending: bool,
fall_distance: f64,
main_hand_item: Arc<str>,
main_hand_count: i32,
leather_boots: bool,
}
/// The entities `Entity.blocksBuilding` sets besides the players and
/// minecarts, borrowed for `Level.isUnobstructed`: living entities (mobs,
/// armor stands), boats, end crystals, primed TNT and falling blocks.
#[derive(Clone, Copy)]
struct Blockers<'w> {
mobs: &'w [Mob],
armor_stands: &'w [horizon_client::entities::ArmorStand],
boats: &'w [boats::Boat],
crystals: &'w [dragon::Crystal],
tnts: &'w [tnt::PrimedTnt],
falling: &'w [FallingBlock],
}
/// The boxes of the entities that block building, as obstruction candidates.
struct BuildingObstruction(Vec<Aabb>);
impl EntityObstructionWorld for BuildingObstruction {
type Error = std::convert::Infallible;
fn obstruction_candidates(
&mut self,
_excluded: Option<EntityIdentity>,
bounds: Aabb,
) -> std::result::Result<Vec<ObstructionEntity>, Self::Error> {
Ok(self
.0
.iter()
.filter(|b| b.intersects(bounds))
.enumerate()
.map(|(i, &bounds)| ObstructionEntity {
identity: EntityIdentity(i as u64),
root_vehicle: EntityIdentity(i as u64),
bounds,
removed: false,
spectator: false,
blocks_building: true,
})
.collect())
}
}
impl GameLevel<'_> {
/// Every entity box that blocks building: the players who aren't
/// spectators, the minecarts and the `Blockers` (a removed mob or a marker
/// armor stand, whose box is empty, doesn't).
fn building_blocker_boxes(&self) -> Vec<Aabb> {
let boxed = |(lo, hi): &([f64; 3], [f64; 3])| {
Aabb::new(
Vec3::new(lo[0], lo[1], lo[2]),
Vec3::new(hi[0], hi[1], hi[2]),
)
};
let b = self.blockers;
self.player_box
.iter()
.chain(&self.guest_boxes)
.chain(&self.cart_boxes)
.map(boxed)
.chain(b.mobs.iter().filter(|m| !m.removed).map(Mob::bounds))
.chain(
b.armor_stands
.iter()
.filter(|s| !s.marker)
.map(|s| s.bounds()),
)
.chain(b.boats.iter().map(boats::Boat::bounds))
.chain(b.crystals.iter().map(|c| {
// EntityType.END_CRYSTAL: 2 x 2.
let p = c.position;
Aabb::new(
Vec3::new(p.x - 1.0, p.y, p.z - 1.0),
Vec3::new(p.x + 1.0, p.y + 2.0, p.z + 1.0),
)
}))
.chain(b.tnts.iter().map(tnt::PrimedTnt::bounds))
.chain(
b.falling
.iter()
.map(|f| horizon_client::falling_block::bounds(f.position)),
)
.collect()
}
}
impl LevelAccess for GameLevel<'_> {
fn world_surface(&self, x: i32, z: i32) -> i32 {
self.world.world_surface(x, z, |s| self.facts.is_air(s))
}
fn precipitation(&self, pos: BlockPos) -> Option<horizon_world::level::Precipitation> {
self.behaviours.precipitation_info(self, pos)
}
fn is_raining_at(&self, pos: BlockPos) -> bool {
self.behaviours.is_raining_at(self, pos)
}
fn block_entity_analog_signal(
&self,
pos: BlockPos,
state: BlockStateId,
_direction: Direction,
) -> i32 {
if let Some(signal) = command_blocks::analog_signal(self.world, (pos.x, pos.y, pos.z)) {
return signal;
}
if let Some(signal) = sculk::sensor_signal(self.world, self.behaviours, state, pos) {
return signal;
}
if let Some((_, comparator)) = jukebox::jukebox_signals(self.world, self.items, pos) {
return comparator;
}
if let Some(signal) = creaking::heart_signal(self.world, pos) {
return if self.registry.state(state).is_some_and(|s| {
s.properties
.get("creaking_heart_state")
.is_some_and(|v| v == "uprooted")
}) {
0
} else {
signal
};
}
if let Some(signal) = books::lectern_signal(self.world, pos) {
return signal;
}
machines::container_signal(self.world, self.behaviours, self.items, self.registry, pos)
}
fn block_entity_signal(
&self,
pos: BlockPos,
_state: BlockStateId,
_direction: Direction,
) -> i32 {
jukebox::jukebox_signals(self.world, self.items, pos).map_or(0, |(signal, _)| signal)
}
fn biome_name(&self, pos: BlockPos) -> Option<&str> {
let chunk = self.world.chunks.get(&(pos.x >> 4, pos.z >> 4))?;
Some(&self.biomes.get(chunk.biome(pos.x, pos.y, pos.z)).name)
}
fn world_seed(&self) -> i64 {
self.seed
}
fn day_time(&self) -> i64 {
self.world.day_time
}
fn game_rules(&self) -> horizon_world::level::GameRules {
self.rules
}
fn block_state(&self, pos: BlockPos) -> BlockStateId {
self.world.block(pos.x, pos.y, pos.z)
}
fn set_raw(&mut self, pos: BlockPos, state: BlockStateId) -> Option<BlockStateId> {
if !self.world.loaded(pos.x, pos.z) || pos.y < MIN_Y || pos.y >= MIN_Y + HEIGHT {
return None;
}
let previous = self.world.block(pos.x, pos.y, pos.z);
self.world.set(pos.x, pos.y, pos.z, state).ok()?;
Some(previous)
}
fn is_loaded(&self, pos: BlockPos) -> bool {
self.world.loaded(pos.x, pos.z)
}
fn min_y(&self) -> i32 {
if self.dimension != LevelDimension::Overworld {
0
} else {
MIN_Y
}
}
fn max_y(&self) -> i32 {
// Exclusive, as LevelAccess::max_y documents.
if self.dimension != LevelDimension::Overworld {
256
} else {
MIN_Y + HEIGHT
}
}
fn random(&mut self) -> &mut horizon_core::random::LegacyRandom {
&mut self.world.random
}
fn game_time(&self) -> i64 {
self.world.game_time
}
fn block_light(&self, pos: BlockPos) -> i32 {
i32::from(self.world.light(pos.x, pos.y, pos.z) & 15)
}
fn sky_light(&self, pos: BlockPos) -> i32 {
i32::from(self.world.light(pos.x, pos.y, pos.z) >> 4)
}
fn sky_darken(&self) -> i32 {
self.darken
}
fn is_raining(&self) -> bool {
self.raining
}
fn is_thundering(&self) -> bool {
self.thundering
}
fn dimension(&self) -> LevelDimension {
self.dimension
}
/// `Level.isUnobstructed`: the placed state's collision shape against the player.
/// `Level.isUnobstructed(state, pos, CollisionContext.of(player))`: no
/// entity that blocks building is in the state's collision shape.
fn is_unobstructed(&self, pos: BlockPos, state: BlockStateId) -> bool {
let player = self.player_collision.as_ref();
let context = player.map_or_else(
|| CollisionContext::empty(false),
|player| {
CollisionContext::for_entity(
CollisionEntity {
identity: EntityIdentity(0),
y: player.y,
descending: player.descending,
main_hand: Some(CollisionItem {
item: &player.main_hand_item,
count: player.main_hand_count,
}),
},
false,
)
},
);
let mut scene = collisions::SceneCollisions {
world: &*self.world,
binding: self.collision,
subject: player.map(|player| horizon_client::collisions::PowderSnowSubject {
fall_distance: player.fall_distance,
falling_block: false,
leather_boots: player.leather_boots,
walkable_type: false,
lava_walker: false,
}),
};
let Ok(shape) = self
.collision
.collision_shape_with_context(&mut scene, state, pos, &context)
else {
return false;
};
if shape.is_empty() {
return true;
}
let shape = shape.moved(horizon_core::geometry::Vec3::new(
f64::from(pos.x),
f64::from(pos.y),
f64::from(pos.z),
));
horizon_world::entity_obstruction::is_unobstructed(
&mut BuildingObstruction(self.building_blocker_boxes()),
None,
&shape,
)
.unwrap_or(false)
}
/// `ServerLevel.isPositionTickingWithEntitiesLoaded`: block ticking, and
/// a ticking chunk.
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.
fn count_entities(&self, area: Aabb, query: EntityQuery) -> usize {
let hit = |(lo, hi): &([f64; 3], [f64; 3])| {
area.intersects(Aabb::new(
Vec3::new(lo[0], lo[1], lo[2]),
Vec3::new(hi[0], hi[1], hi[2]),
))
};
let carts = || self.cart_boxes.iter().filter(|b| hit(b)).count();
let players = || {
self.player_box
.iter()
.chain(&self.guest_boxes)
.filter(|b| hit(b))
.count()
};
match query {
EntityQuery::Minecart => carts(),
EntityQuery::Mobs => players(),
EntityQuery::Everything => players() + carts(),
}
}
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),
// Block.popResource of the block's own item (tall flowers, flower beds).
LevelEvent::BlockEvent {
pos,
state,
kind: "pop_block_item",
} => self.pop_block_item(pos, state),
// ComposterBlock.extractProduce: bone meal above the composter.
LevelEvent::Player {
pos,
effect: PlayerEffect::DropItem(item),
..
} => self.pop_above(pos, item),
// Picking a sweet berry bush or cave vines: the harvest loot,
// popped before the pick sound draws its pitch.
LevelEvent::Player {
pos,
state,
effect: PlayerEffect::InteractLoot(table),
} => self.drop_interact_loot(pos, state, table),
event => self.events.push(event),
}
}
fn remove_block_entity(&mut self, pos: BlockPos, old: BlockStateId, side_effects: bool) -> u8 {
self.remove_entity(pos, old, side_effects)
}
fn load_block_entity(&mut self, pos: BlockPos, mut nbt: horizon_world::nbt::Compound) {
use horizon_world::nbt::Tag;
for (k, v) in [("x", pos.x), ("y", pos.y), ("z", pos.z)] {
nbt.insert(k.into(), Tag::Int(v));
}
if let Some((key, entity)) = horizon_client::save::decode_block_entity(&Tag::Compound(nbt))
{
self.world.block_entities.insert(key, entity);
}
}
fn set_command_block_powered(&mut self, pos: BlockPos, powered: bool) -> Option<(bool, bool)> {
command_blocks::set_powered(self.world, self.registry, (pos.x, pos.y, pos.z), powered)
}
}
/// FallingBlockEntity carrying a block state.
#[derive(Clone, Debug)]
struct FallingBlock {
/// The entity id a server tracks it by (0 until it is tracked).
id: u32,
state: BlockStateId,
/// `DATA_START_POS`: spawn position used to select weighted block models.
start_pos: BlockPos,
position: Vec3,
previous: Vec3,
velocity: Vec3,
/// `FallingBlockEntity.time`: signed, a save can start it below zero.
age: i32,
/// `Entity.isNoGravity`.
no_gravity: bool,
/// `FallingBlockEntity.dropItem`.
drop_item: bool,
/// `Entity.fallDistance` (powder snow holds a block that fell far at 0.9).
fall_distance: f64,
/// `Entity.stuckSpeedMultiplier`: a cobweb it is in scales its next move.
stuck: Vec3,
damage: horizon_client::falling_block::Damage,
/// The UUID and compound it was loaded with, kept while it moves.
saved: Option<Box<([i32; 4], horizon_world::nbt::Tag)>>,
}
/// The data loaded once at startup and never changed: blocks, items,
/// recipes, biomes, mobs, collision and motion. Read-only and `Send + Sync`,
/// so the client and an integrated server thread can share one copy.
pub struct Resources {
core: WorldCore,
rest: std::sync::OnceLock<WorldRest>,
}
struct WorldCore {
facts: BlockFacts,
biomes: Arc<Biomes>,
environment: Environment,
collision: BlockCollisionRegistry<'static>,
motion: MotionResources,
threads: usize,
}
struct WorldRest {
items: Items,
recipes: Recipes,
transformers: horizon_client::block_transform::Transformers,
mob_types: HashMap<String, Arc<MobType>>,
mob_data: horizon_client::mobs::MobData,
providers: Providers,
block_entity_render: horizon_client::block_entity_render::BlockEntityRenderer,
animate: horizon_client::animate_tick::AnimateTables,
fog: horizon_client::fog::FogTables,
music: horizon_client::music::MusicTables,
ambient: horizon_client::ambience::AmbientTables,
nether_environment: Environment,
end_environment: Environment,
behaviours: Behaviours,
player_arm: Option<horizon_client::mobs::Part>,
player_type: Option<Arc<horizon_client::mobs::MobType>>,
/// `SpinAttackEffectModel` (Riptide's spinning boxes).
spin_attack: Option<horizon_client::mobs::Part>,
stations: horizon_client::stations::StationData,
}
impl Resources {
fn rest(&self) -> &WorldRest {
self.rest
.get()
.expect("world resources joined before entry")
}
fn facts(&self) -> &BlockFacts {
&self.core.facts
}
fn items(&self) -> &Items {
&self.rest().items
}
fn recipes(&self) -> &Recipes {
&self.rest().recipes
}
fn transformers(&self) -> &horizon_client::block_transform::Transformers {
&self.rest().transformers
}
fn biomes(&self) -> &Arc<Biomes> {
&self.core.biomes
}
fn environment(&self) -> &Environment {
&self.core.environment
}
fn mob_types(&self) -> &HashMap<String, Arc<MobType>> {
&self.rest().mob_types
}
fn mob_data(&self) -> &horizon_client::mobs::MobData {
&self.rest().mob_data
}
fn providers(&self) -> &Providers {
&self.rest().providers
}
fn block_entity_render(&self) -> &horizon_client::block_entity_render::BlockEntityRenderer {
&self.rest().block_entity_render
}
fn animate(&self) -> &horizon_client::animate_tick::AnimateTables {
&self.rest().animate
}
fn fog(&self) -> &horizon_client::fog::FogTables {
&self.rest().fog
}
fn music(&self) -> &horizon_client::music::MusicTables {
&self.rest().music
}
fn ambient(&self) -> &horizon_client::ambience::AmbientTables {
&self.rest().ambient
}
fn nether_environment(&self) -> &Environment {
&self.rest().nether_environment
}
fn end_environment(&self) -> &Environment {
&self.rest().end_environment
}
fn behaviours(&self) -> &Behaviours {
&self.rest().behaviours
}
fn collision(&self) -> &BlockCollisionRegistry<'static> {
&self.core.collision
}
fn motion(&self) -> &MotionResources {
&self.core.motion
}
fn threads(&self) -> usize {
self.core.threads
}
fn player_arm(&self) -> &Option<horizon_client::mobs::Part> {
&self.rest().player_arm
}
fn player_type(&self) -> &Option<Arc<horizon_client::mobs::MobType>> {
&self.rest().player_type
}
fn spin_attack(&self) -> &Option<horizon_client::mobs::Part> {
&self.rest().spin_attack
}
fn stations(&self) -> &horizon_client::stations::StationData {
&self.rest().stations
}
}
/// Everything the title and menus draw: the GUI atlas with its font and the
/// title panorama. Kept apart from the world bundle so the title can appear
/// before the block sprites, models and gameplay tables are ready.
pub struct UiResources {
/// The GUI, font, particle, map and skin atlas.
pub atlas: HudAtlas,
/// The title screen's panorama faces.
pub panorama: Arc<horizon_client::gfx::panorama::Faces>,
}
impl UiResources {
/// From a resource root layering packs over `defaults`, the game's own
/// resources (`root` itself when no pack is on).
pub fn load(root: &std::path::Path, defaults: &std::path::Path) -> Result<Self> {
Ok(Self {
atlas: HudAtlas::build_over(root, defaults)?,
panorama: Arc::new(horizon_client::gfx::panorama::Faces::load(root)),
})
}
}
/// What a resource pack reload replaces (`Minecraft.reloadResourcePacks`):
/// block models and sprites with their meshing tables, item models,
/// translations and the textures read on the CPU. Each game holds its own;
/// cloning shares the loaded data.
#[derive(Clone)]
pub struct PackResources {
assets: Arc<Assets>,
render: Arc<RenderAssets>,
context: Arc<WorkerContext>,
layer_names: Arc<HashMap<u32, String>>,
/// Item definitions, baked item models and special renderers.
item_renderer: Arc<horizon_client::item_render::ItemRenderer>,
names: Arc<Names>,
/// clouds.png: (width, height, filled cells).
clouds: Arc<(u32, u32, Vec<bool>)>,
/// misc/forcefield.png: (width, height, RGBA) for the world border wall.
forcefield: Arc<(u32, u32, Vec<u8>)>,
}
impl PackResources {
/// Everything a pack overlay at `root` provides, over `assets` and `render`
/// loaded from it.
fn load(
root: &std::path::Path,
assets: Arc<Assets>,
render: Arc<RenderAssets>,
facts: &BlockFacts,
biomes: Arc<Biomes>,
light: Arc<LightTables>,
) -> Result<Self> {
let visibility = models::load_visibility(root, assets.registry)?;
let tables = Arc::new(MeshTables::new(&assets, &render, facts, visibility)?);
let item_renderer = horizon_client::item_render::ItemRenderer::load_with_library(
root,
render.model_library.clone(),
)?;
Ok(Self {
layer_names: Arc::new(
render
.sprite_layers
.iter()
.map(|(name, layer)| (*layer, name.trim_start_matches("minecraft:").to_owned()))
.collect(),
),
context: Arc::new(WorkerContext {
assets: assets.clone(),
render: render.clone(),
tables,
biomes,
light,
}),
assets,
render,
item_renderer: Arc::new(item_renderer),
names: Arc::new(Names::load(root)),
clouds: Arc::new(load_clouds(root)),
forcefield: Arc::new(load_forcefield(root)),
})
}
}
/// A quick craft drag as the screen draws it: each dragged slot's count and
/// whether the slot caps it (None: hidden), and what stays in hand.
struct DragView {
slots: HashMap<usize, Option<(u32, bool)>>,
left: Option<u32>,
}
/// Ctrl+Q reads the physical keyboard, independently of sprint key mappings.
/// A chunk whose ticking future can complete (`ChunkMap.prepareTickingChunk`):
/// lit, with its neighbours loaded, as `postprocess_chunks` waits for.
fn ticking_chunk(world: &World, x: i32, z: i32) -> bool {
world.chunks.get(&(x, z)).is_some_and(|c| c.lit)
&& (-1..=1).all(|dz| (-1..=1).all(|dx| world.chunks.contains_key(&(x + dx, z + dz))))
}
fn drop_whole_stack(physical_keys: &HashSet<KeyCode>) -> bool {
physical_keys.contains(&KeyCode::ControlLeft) || physical_keys.contains(&KeyCode::ControlRight)
}
fn select_creative_tab(
creative: &mut Creative,
clicks: &mut horizon_client::container_screen::Clicks,
tab: usize,
) {
creative.select(tab);
*clicks = Default::default();
// Tabs are outside the panel; their release must not drop a carried stack.
clicks.skip_release();
}
struct Game<'a> {
/// Shared with an integrated server; `collision` and `motion` borrow from it.
res: Arc<Resources>,
rest_loader: Option<WorldRestLoader>,
pending_entry: Option<PendingWorldEntry>,
world_loader: Option<world_loading::WorldLoader>,
pending_pack_reload: bool,
/// A server's resource packs (game/server_packs.rs).
server_packs: server_packs::ServerPackState,
world_renderer_ready: bool,
collision: &'a BlockCollisionRegistry<'a>,
motion: &'a MotionResources,
/// This game's resource packs (`reload_packs` replaces them).
pack: PackResources,
/// The title and menu bundle (GUI atlas, font and panorama).
gui: UiResources,
/// `FogRenderer`'s evolving state.
fog: horizon_client::fog::FogState,
screen_fx: horizon_client::screen_effects::ScreenEffects,
weather_parameters: horizon_client::weather::ParameterCache,
panorama_rotation: horizon_client::gfx::panorama::Rotation,
world: World,
streaming: Streaming,
lod: Option<horizon_client::lod::Lod>,
lod_source_attempted: bool,
lod_observe: horizon_client::fast_hash::FxHashSet<(i32, i32)>,
/// The detail revision, centre and radius `Lod::update` last had covered for.
lod_covered_at: Option<(u64, (i32, i32), i32)>,
options: Options,
player: Option<PlayerMotion>,
spawn: Option<Vec3>,
clock: FixedStep,
previous_position: Vec3,
eye: f32,
previous_eye: f32,
yaw: f32,
pitch: f32,
inventory: Vec<Option<ItemStack>>,
selected: usize,
carried: Option<ItemStack>,
craft_grid: Vec<Option<ItemStack>>,
craft_size: usize,
/// The crafting table the 3x3 grid belongs to (`CraftingMenu.access`).
craft_table: Option<[i32; 3]>,
/// A quick craft drag over inventory slots: (button, game slots so far).
inv_drag: Option<(i32, Vec<usize>)>,
/// `AbstractContainerScreen`'s quick craft and skip-release state.
inv_clicks: horizon_client::container_screen::Clicks,
/// The Mouse Tweaks extra's drag and wheel (`tweaks`).
tweaks: tweaks::Tweaks,
/// The last inventory click, for the double click that gathers a stack.
last_inv_click: Option<(std::time::Instant, usize, bool)>,
/// `lastQuickMoved`: what the last Shift click moved, which a Shift
/// double click moves every stack of.
last_quick_moved: Option<ItemStack>,
/// Open container block entity, if any.
container: Option<(i32, i32, i32)>,
/// Open workstation menu (enchanting table, anvil, ...).
station: Option<stations::Station>,
/// Status effects and thrown potions (game/potions.rs).
potions: potions::PotionState,
scratch_slot: Option<ItemStack>,
mining: Option<Mining>,
/// The other players' cracks (`LevelRenderer.destroyingBlocks`): breaker id to the block,
/// the stage (0..=9) and the game time it last changed.
destroying: HashMap<i32, ([i32; 3], u8, i64)>,
destroy_delay: u32,
use_delay: u32,
creative: bool,
/// The game mode; `creative` mirrors `mode == Creative`.
mode: horizon_client::command::args::GameMode,
keys: HashSet<KeyCode>,
// Physical input is separate from remapped and toggled movement keys.
physical_keys: HashSet<KeyCode>,
left: bool,
right: bool,
cursor: (f32, f32),
captured: bool,
focused: bool,
/// The keyboard's modifier state (`KeyEvent.modifiers`).
modifiers: winit::keyboard::ModifiersState,
/// The window's fullscreen request and reported state.
fullscreen: horizon_client::window::FullscreenState,
/// MouseHandler's accumulated look and wheel state.
mouse: MouseLook,
/// An agent moved the mouse (`mouse-move`) since the pointer was last
/// grabbed or released: its motion turns the view like a grabbed pointer.
agent_pointer: bool,
/// `Options.smoothCamera` (cinematic camera), not persisted.
smooth_camera: bool,
/// Sneak, sprint, attack and use as ToggleKeyMappings.
toggles: horizon_client::keymapping::ToggleKeys,
/// A world screen with the pointer captured was open last frame.
was_playing: bool,
/// Minecraft.pause: a single-player screen that pauses the game is open.
pause: bool,
debug: bool,
screen: Screen,
window: Option<Arc<Window>>,
renderer: Option<Renderer>,
/// CPU geometry storage retained across frames, including empty/title frames.
entity_vertices: Vec<Vertex>,
/// Horizon Extras' dynamic lights this frame (`dynamic_lights.rs`), and how brightly each
/// item glows (built the first time the extra is on).
dynamic_lights: Vec<[f32; 4]>,
luminance: Option<horizon_client::dynamic_light::Luminance>,
/// Name tags drawn over everything (`RenderPipelines.TEXT_SEE_THROUGH`).
see_through_vertices: Vec<Vertex>,
started: Instant,
previous: Instant,
/// FramerateLimitTracker.latestInputTime.
last_input: Instant,
/// Controllers (Horizon's own).
pad: pad::Pads,
frames: u64,
/// Frames drawn with the player in the world, for `--world-frames`.
world_frames: u64,
fps: f32,
fps_frames: u64,
fps_at: Instant,
ticks: u64,
health_hud: hud_layout::HealthHud,
/// What ends the game with an error; kept as it is, so main can tell a debug crash.
error: Option<Box<dyn std::error::Error>>,
message: Option<(String, Instant)>,
save: Arc<SaveDir>,
level: Level,
session_lock: Option<horizon_client::save::SessionLock>,
audio: Audio,
music: horizon_client::music::MusicManager,
ambience: horizon_client::ambience::Ambience,
/// The sound engine was told the game paused (pauseAllExcept).
sound_paused: bool,
/// Minecarts whose `MinecartSoundInstance` is playing.
cart_sounds: HashSet<u32>,
/// The minecart the riding sounds were started for (`LocalPlayer.startRiding`).
riding_cart_sounds: Option<u32>,
dropped: Vec<ItemEntity>,
next_entity: u32,
particles: horizon_client::particles::ParticleEngine,
/// `ItemPickupParticle`s: taken items, orbs and arrows flying to their collector.
pickups: pickups::Pickups,
/// Sign text being edited (`SignEditScreen`).
sign_edit: Option<sign_edit::SignEditor>,
/// An open book, book and quill or lectern screen.
book: Option<books::BookScreen>,
/// Lecterns whose page-turn pulse is running (ticks left).
lectern_pulses: Vec<((i32, i32, i32), i32)>,
/// LevelLoadingScreen.smoothedProgress while the player is not placed yet.
loading_progress: f32,
/// The world spawn search's origin chunk and fallback height, once known.
spawn_origin: Option<((i32, i32), i32)>,
spawn_spiral: horizon_client::world_spawn::ChunkSpiral,
/// A new player's spawn search, while its candidates' chunks load.
player_spawn: Option<horizon_client::world_spawn::PlayerSpawnFinder>,
mobs: Vec<Mob>,
creatures: creatures::Creatures,
sculk: sculk::SculkState,
raiding: raids::Raiding,
attack_ticks: u32,
/// The main hand's item at the last player tick, whose attack damage and
/// speed modifiers apply (`LivingEntity.detectEquipmentUpdates`): a hotbar
/// swap just before an attack keeps them, with the new item's enchantments
/// (attribute swapping).
attack_item: Option<Arc<str>>,
/// Mobs a player hurt (`LivingEntity.lastHurtByPlayer`), with the guest
/// it was by connection (None: the host).
last_hurt_by_player: HashMap<u32, Option<u32>>,
/// Mobs whose death (`LivingEntity.die`) has been handled.
died: HashSet<u32>,
/// Client-ticked block-entity animation state (`game/block_entity_anims.rs`).
be_anims: horizon_client::block_entity_anim::BlockEntityAnims,
/// Item being used (eaten): hotbar slot and ticks used.
using: Option<(usize, u32)>,
/// Camera.oldFovModifier / fovModifier.
/// `Camera` (eye height and field-of-view easing, view placement).
view: horizon_client::camera::Camera,
/// `FramerateLimiter` and its clock.
limiter: horizon_client::window::FramerateLimiter,
frame_clock: horizon_client::window::SystemClock,
/// Hud.scopeScale (spyglass overlay size).
scope_scale: f32,
/// Duration of the last frame in ticks (GUI easing).
frame_ticks: f32,
title: Option<Title>,
/// Armor slots: head, chest, legs, feet.
armor: [Option<ItemStack>; 4],
/// The off hand (Inventory slot 40, saved as slot 150; menu slot 504 here).
offhand: Option<ItemStack>,
/// The hand an item use acts with (`InteractionHand`): the off hand only
/// for its turn in `use_item` and while its item is being used.
hand: Hand,
/// The shield's item cooldown after an axe disabled it (ticks).
shield_cooldown: u32,
/// `Player.getCooldowns()`: the `use_cooldown` component's entries, what
/// `itemDecorations` shades a slot by. A server's players have their own
/// (`GuestPlay::cooldowns`), swapped in for their turn.
cooldowns: horizon_client::cooldowns::Cooldowns,
/// The source of a command run through /execute (the player otherwise).
command_source: Option<commands::execute::Source>,
titles: titles::Titles,
/// `Hud.toolHighlightTimer`: the selected item name.
tool_highlight: horizon_client::hud_overlays::ToolHighlight,
applied_modifiers: Vec<(String, String)>,
experience: Experience,
orbs: Vec<ExperienceOrb>,
xp_delay: u32,
last_level_up: u64,
/// The arm swing (`LivingEntity.SwingState`) and how many swings started.
swing: horizon_client::first_person::SwingState,
swings_started: u32,
/// The first-person equip heights and the items the hands show (with
/// the slot each came from).
heights: horizon_client::first_person::HandHeights,
/// The hands' lag behind the view (`LocalPlayer.xBob`, `yBob`); a new
/// LocalPlayer (joining, respawning, changing dimension) starts at 0.
sway: horizon_client::first_person::HandSway,
visible_hands: [(usize, Option<ItemStack>); 2],
/// `Minecraft`'s attack handling, attack clicks since the last tick and
/// the attack strength tickers the hand reads.
clicks: horizon_client::first_person::Clicks,
attack_clicks: u32,
hand_strength: horizon_client::attack_strength::AttackStrength,
settings: Settings,
/// Where the options screen returns: true = title, false = pause menu.
options_from_title: bool,
dragging: bool,
/// `ClientAvatarState`: walked distance and view bob.
avatar: horizon_client::camera::AvatarBob,
flash: u32,
/// Bolts that struck here and sky flashes they made, in total (`status`).
lightning_seen: [u32; 2],
/// The head of the bed while sleeping; the visual timer also survives waking.
sleeping: Option<[i32; 3]>,
sleep_timer: u32,
dim: Dim,
world_root: PathBuf,
/// A player carried through a portal, re-placed once the destination loads.
travelling: Option<(PlayerMotion, Vec3)>,
/// A server's players on their way to another level, each waiting for
/// the destination to load around them.
server_trips: Vec<server_travel::Trip>,
/// Players a command sends to another level, once it has run.
level_teleports: Vec<server_travel::LevelTeleport>,
/// A server's levels other than the one in place (game/levels.rs).
levels: levels::Levels,
/// Which pass of a server tick runs (`tick_server`): the first one reads
/// the network, the last one ends the players' tick.
level_pass: levels::Pass,
/// Nether portals: the player's, items' and mobs' (game/nether_portal.rs).
portals: nether_portal::Portals,
/// The pending travel goes through an End portal (EndPortalBlock destinations).
end_travel: bool,
/// The respawn point when it is not the world spawn or a bed: a respawn
/// anchor (`game/respawn_anchor.rs`).
respawn_config: Option<respawn_anchor::RespawnConfig>,
/// A respawn travelling to its anchor's dimension and chunks.
respawn_travel: Option<respawn_anchor::RespawnConfig>,
/// The next enter_dimension call comes from an End portal.
end_portal_travel: bool,
/// The open WinScreen (game/win.rs).
win: Option<win::Win>,
end: end::EndState,
block_ticks: Ticks,
tick_chunks: horizon_client::tick_chunk_membership::TickChunkMembership,
tickets: horizon_client::ticket_levels::ChunkTickets,
random_tick_sections: horizon_client::random_tick_sections::RandomTickSections,
level_events: Vec<LevelEvent>,
falling: Vec<FallingBlock>,
paintings: Vec<horizon_client::entities::Painting>,
painting_variants: paintings::PaintingVariants,
item_frames: Vec<horizon_client::entities::ItemFrame>,
frame_model: frames::FrameModel,
glow_frame_model: frames::FrameModel,
/// The `map=true` frame variants.
map_frame_model: frames::FrameModel,
glow_map_frame_model: frames::FrameModel,
armor_stands: Vec<horizon_client::entities::ArmorStand>,
/// Entities of types Horizon does not simulate.
others: Vec<commands::OtherEntity>,
armor_stand_assets: armor_stands::ArmorStandAssets,
/// `WaypointStyleManager`.
waypoint_styles: horizon_client::locator_bar::WaypointStyles,
/// `ClientWaypointManager`: the locator bar's waypoints.
waypoints: horizon_client::locator_bar::ClientWaypoints,
/// The camera the last frame drew from (position, yaw, pitch, fov), for the locator bar.
locator_camera: Option<([f64; 3], f32, f32, f32)>,
/// `LocalPlayer.experienceDisplayStartTick`: (last progress, seen a change, tick).
experience_display: (f32, bool, u64),
boats: Vec<boats::Boat>,
boat_models: boats::BoatModels,
/// EndCrystalModel's baked layer.
crystal_model: Option<horizon_client::mobs::Part>,
carts: Vec<minecarts::Minecart>,
/// Songs playing from jukeboxes (tracked sound handles).
jukebox_sounds: HashMap<(i32, i32, i32), u64>,
bolts: Vec<lightning::Bolt>,
maps: maps::Maps,
/// The ender dragon fight (game/dragon.rs).
fight: dragon::Fight,
dragon: Option<dragon::Dragon>,
crystals: Vec<dragon::Crystal>,
dragon_fireballs: Vec<dragon::DragonFireball>,
breath_clouds: Vec<dragon::Breath>,
dragon_model: Option<horizon_client::mobs::Part>,
/// Map textures waiting for the next HUD batch to upload them.
map_patches: Vec<horizon_client::font::Patch>,
text_displays: std::collections::HashMap<i32, text_displays::RemoteTextDisplay>,
text_display_vertices: usize,
/// Player skin downloads, and which skin each atlas skin slot holds
/// (least recently shown first).
skin_downloads: RefCell<horizon_client::skins::Downloader>,
skin_slots: Vec<(String, usize)>,
/// Atlas trim slots in use: (sprite name, slot), least recently drawn first.
trim_slots: Vec<(String, usize)>,
cart_models: minecarts::CartModels,
/// The boat the player rides.
riding: Option<u32>,
/// The ender inventory (27 slots) and the ender chest showing it.
ender_items: Vec<Option<ItemStack>>,
ender_open: Option<(i32, i32, i32)>,
/// Block entity data of broken blocks waiting for their dropped item.
pending: spill::Pending,
/// Item entities spawned and block entities removed while the block
/// behaviour ran (spilled contents, popped resources).
spill: spill::Spill,
/// The recipe book of the open screen (game/recipe_book.rs).
recipe_ui: recipe_book::RecipeUi,
/// The horse inventory (game/mount_menu.rs).
mount_menu: mount_menu::MountMenu,
/// The player's fishing hook.
hook: Option<fishing::Hook>,
/// The other players' hooks a server tracks to this client.
remote_hooks: Vec<fishing::RemoteHook>,
tridents: Vec<trident::ThrownTrident>,
rockets: Vec<fireworks::Rocket>,
/// Ominous trial spawners' item spawners.
ominous_spawners: Vec<ominous_item_spawner::OminousItemSpawner>,
creaking: creaking::CreakingState,
/// Monster spawners' display mobs (`game/spawner.rs`).
spawners: spawner::SpawnerState,
trident_model: Option<horizon_client::mobs::Part>,
arrow_model: Option<horizon_client::mobs::Part>,
tnts: Vec<tnt::PrimedTnt>,
hoppers: HashMap<(i32, i32, i32), machines::HopperState>,
/// Where item entities are, while the block entities tick (hoppers).
item_columns: Option<machines::ItemColumns>,
creative_screen: Creative,
control: Option<horizon_client::control::Server>,
/// The Agent Control setting the socket was last opened or closed for (`agent_settings`).
agent_control_on: bool,
/// When an agent's last command came.
agent_last: Option<Instant>,
frame_stats: horizon_client::control::FrameStats,
/// This play session's frame and tick times, for opt-in performance statistics.
perf: horizon_client::telemetry::Session,
/// Control replies waiting for a rendered frame or a benchmark deadline.
pending_screenshot: Option<std::sync::mpsc::Sender<String>>,
pending_bench: Option<(Instant, std::sync::mpsc::Sender<String>)>,
/// Recent frame times for the performance overlay.
frame_graph: horizon_client::perf_overlay::FrameGraph,
/// Horizon's extras (zoom, FPS counter, keystrokes): `game/extras.rs`.
extras: extras::ExtrasState,
/// Horizon mods (`game/mods.rs`), none running unless turned on.
mods: mods::ModsState,
/// Meshed sections waiting for an upload budget (Horizon settings).
pending_uploads: Vec<((i32, i32, i32), horizon_client::mesher::SectionMesh)>,
/// This frame's view frustum, for culling entities and block entities.
view_frustum: Option<horizon_client::gfx::Frustum>,
entity_culler: Option<horizon_client::entity_culling::Culler>,
/// A scripted flight from the control socket (`fly`).
flight: Option<control::Flight>,
/// The running agent action from the control socket (game/agent.rs).
agent: agent::Agent,
/// Widget commands waiting for the frame after a click (game/ui_control.rs).
ui_wait: ui_control::UiWait,
/// What happened, for `events` and `wait-for` (game/events.rs).
events: events::Events,
/// The overworld's last `sky_darken` and its inputs (time, rain, thunder).
sky_darken_memo: std::cell::Cell<Option<((i64, u32, u32), i32)>>,
persist: persist::EntityMemory,
/// Connected to a server: the world comes from the network (game/remote.rs).
remote: Option<remote::Remote>,
/// This world is open to the network (game/lan.rs).
lan: Option<lan::LanHost>,
/// Single player's server thread, which `remote` is connected to.
integrated: Option<integrated::Integrated>,
/// This game is that server thread's (game/integrated.rs).
serving: Option<integrated::Serving>,
/// The open world is shared behind an invite code (game/friends.rs).
friends: Option<friends::Sharing>,
world_options: Option<lan_screen::WorldOptions>,
/// Chat Settings opened from RestrictionsScreen: Done returns to World Options.
options_to_world_options: bool,
command_block_screen: Option<command_blocks::CommandBlockScreen>,
/// KeyboardHandler's debug key state (game/debug_keys.rs), the physical
/// keys held, and the debug renderers F3+B and F3+G switch on.
debug_keys: horizon_client::debug_keys::DebugKeys,
/// The F3 overlay's charts (F3+2, F3+3).
debug_charts: horizon_client::debug_chart::DebugCharts,
show_hitboxes: bool,
show_chunk_borders: bool,
/// PauseScreen.showPauseMenu (false after F3+Escape).
pause_menu: bool,
/// MultiPlayerGameMode.previousLocalPlayerMode (F3+N goes back to it).
previous_mode: Option<horizon_client::command::args::GameMode>,
gamemode_switcher: Option<horizon_client::game_mode_switcher::GameModeSwitcher>,
/// The system clipboard (`KeyboardHandler.clipboardManager`).
clipboard: horizon_client::clipboard::SystemClipboard,
/// Select All in the append-only text fields.
text_selection: horizon_client::clipboard::AppendSelection,
/// The world was saved for the application ending (`save_for_exit`).
saved_for_exit: bool,
pending_save: Option<saving::ClosingSave>,
/// The block a guest is acting on (game/lan_actions.rs).
forced_hit: Option<Hit>,
/// The part of a right click a guest's packet asks for (game/lan_actions.rs).
guest_use: Option<GuestUse>,
/// Level events of this tick for the guests, and the guest acting now.
lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
/// Block events (position, b0, b1, state) and entity events (id, event,
/// position) for the guests.
lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
lan_entity_events: Vec<(i32, i8, [f64; 3])>,
/// `ContainerOpenersCounter`: how many players (the host and the guests)
/// have each chest open.
lid_openers: HashMap<(i32, i32, i32), i32>,
lan_acting: Option<u32>,
/// The name of the guest `lan_acting` acts for (`Player.getName`).
lan_acting_name: Option<String>,
/// Their UUID (`Player.getUUID`).
lan_acting_uuid: Option<u128>,
/// Command feedback to forward to a guest.
chat_capture: Option<Vec<horizon_client::text::Text>>,
/// Packets for the guest acting now, sent once its action returns.
guest_packets: Vec<horizon_protocol::packets::play::Clientbound>,
/// The acting guest's cooldowns, as (item, ticks): their packet needs the
/// hub's item registry, which the guest's turn does not hold.
guest_cooldowns: Vec<(Arc<str>, i32)>,
/// `broadcastToAdmins` lines a guest's command queued, sent once it
/// returns: the line, whether operators get it and whether the console
/// logs it.
admin_feedback: Vec<(horizon_client::text::Text, bool, bool)>,
/// The server console is running a command: whether its feedback goes to
/// the operators (`DedicatedServer.shouldInformAdmins`,
/// `broadcast-console-to-ops`).
console_broadcast: Option<bool>,
/// State of `/spectate`, `/posteffect`, `/debug`, `/waypoint` and friends.
cmds: commands::extra::CommandExtras,
ui: chat::UiState,
combat: combat::CombatTracker,
mount: mounts::MountState,
stats: stats::Stats,
score: scoreboard::ScoreState,
fns: functions::FnState,
bosses: bossbars::BossState,
/// `Hud.bossOverlay`: the bars this window is showing.
boss_overlay: horizon_client::boss_overlay::BossOverlay,
exec: commands::execute::ExecState,
rand_sequences: horizon_client::random_sequences::RandomSequences,
border: horizon_client::worldborder::WorldBorder,
/// `WorldBorderRenderer` and its render state.
border_renderer: horizon_client::border_render::BorderRenderer,
border_state: horizon_client::border_render::BorderRenderState,
/// `Hud.tabList`: the player list's header, footer and heart states.
tab_list: horizon_client::tab_list::TabList,
subtitles: subtitle_hud::SubtitleState,
adv: advancements::AdvState,
restore_player_state: bool,
stats_ui: stats_screen::StatsUi,
adv_ui: advancements_screen::AdvUi,
camera_type: perspective::CameraType,
fangs: fangs::FangState,
/// The local player as a model (third person, the inventory).
player_model: Option<Mob>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Dim {
Overworld,
Nether,
End,
}
impl Dim {
fn id(self) -> &'static str {
match self {
Self::Overworld => "minecraft:overworld",
Self::Nether => "minecraft:the_nether",
Self::End => "minecraft:the_end",
}
}
fn from_id(id: &str) -> Self {
match id {
"minecraft:the_nether" => Self::Nether,
"minecraft:the_end" => Self::End,
_ => Self::Overworld,
}
}
/// `Level.getMinY`: the dimension type's minimum y.
fn min_y(self) -> i32 {
match self {
Self::Overworld => MIN_Y,
Self::Nether | Self::End => 0,
}
}
/// `DimensionType.logicalHeight`.
fn logical_height(self) -> i32 {
match self {
Self::Overworld => HEIGHT,
Self::Nether => 128,
Self::End => 256,
}
}
/// `Level.getMaxY`: the dimension type's minimum y plus height, less one.
fn max_y(self) -> i32 {
match self {
Self::Overworld => MIN_Y + HEIGHT - 1,
Self::Nether | Self::End => 255,
}
}
}
fn facing_offset(facing: &str) -> [i32; 3] {
match facing {
"north" => [0, 0, -1],
"south" => [0, 0, 1],
"west" => [-1, 0, 0],
"east" => [1, 0, 0],
"up" => [0, 1, 0],
_ => [0, -1, 0],
}
}
/// How far along `dir` (within `reach`) a ray from `eye` enters `b`.
fn ray_box(eye: [f64; 3], dir: [f64; 3], reach: f64, b: Aabb) -> Option<f64> {
let (min, max) = (b.min_position(), b.max_position());
let (lo, hi) = ([min.x, min.y, min.z], [max.x, max.y, max.z]);
let (mut t0, mut t1) = (0.0f64, reach);
for a in 0..3 {
if dir[a].abs() < 1e-9 {
if eye[a] < lo[a] || eye[a] > hi[a] {
return None;
}
continue;
}
let (mut ta, mut tb) = ((lo[a] - eye[a]) / dir[a], (hi[a] - eye[a]) / dir[a]);
if ta > tb {
std::mem::swap(&mut ta, &mut tb);
}
t0 = t0.max(ta);
t1 = t1.min(tb);
}
(t0 <= t1).then_some(t0)
}
fn view_vector(yaw: f32, pitch: f32) -> [f64; 3] {
let (y, p) = (f64::from(yaw).to_radians(), f64::from(pitch).to_radians());
[-y.sin() * p.cos(), -p.sin(), y.cos() * p.cos()]
}
impl Game<'_> {
fn eye_position(&self) -> Option<[f64; 3]> {
let p = self.player.as_ref()?;
Some([
p.position.x,
p.position.y + f64::from(p.dimensions.eye_height),
p.position.z,
])
}
fn reach(&self) -> f64 {
if self.creative { 5.0 } else { 4.5 }
}
/// A block's outline boxes in world space (`getShape` plus the random offset).
fn outline_boxes(&self, pos: [i32; 3]) -> Vec<[f64; 6]> {
let state = self.world.block(pos[0], pos[1], pos[2]);
let f = self.res.facts().get(state);
let o = if f.outline_offset {
self.pack
.context
.tables
.offset(state, pos[0], pos[2])
.unwrap_or([0.0; 3])
} else {
[0.0; 3]
};
let base = [
f64::from(pos[0]) + o[0],
f64::from(pos[1]) + o[1],
f64::from(pos[2]) + o[2],
];
f.outline
.iter()
.map(|b| std::array::from_fn(|i| base[i % 3] + b[i]))
.collect()
}
/// Voxel traversal against non-air, non-fluid blocks, clipped against
/// each block's outline shape (`BlockGetter.clip` with `ClipContext.Block.OUTLINE`).
fn pick(&self) -> Option<Hit> {
// A guest of a hosted world acts on the block their client targeted.
if let Some(hit) = &self.forced_hit {
return Some(Hit {
pos: hit.pos,
face: hit.face,
point: hit.point,
});
}
let origin = self.eye_position()?;
self.clip_ray(origin, view_vector(self.yaw, self.pitch), self.reach())
}
/// The first block outline hit within `reach` along the unit `dir`.
fn clip_ray(&self, origin: [f64; 3], dir: [f64; 3], reach: f64) -> Option<Hit> {
let mut pos = origin.map(|v| v.floor() as i32);
let step = dir.map(|d| if d > 0.0 { 1 } else { -1 });
let delta = dir.map(|d| {
if d == 0.0 {
f64::INFINITY
} else {
(1.0 / d).abs()
}
});
let mut t_max = [0.0; 3];
for i in 0..3 {
let boundary = if dir[i] > 0.0 {
f64::from(pos[i]) + 1.0
} else {
f64::from(pos[i])
};
t_max[i] = if dir[i] == 0.0 {
f64::INFINITY
} else {
(boundary - origin[i]) / dir[i]
};
}
let mut face = [0; 3];
let mut t = 0.0;
while t <= reach {
let state = self.world.block(pos[0], pos[1], pos[2]);
let f = self.res.facts().get(state);
if !self.res.facts().is_air(state)
&& (f.fluid == Fluid::None
|| f.waterlogged
|| &*f.name == "minecraft:kelp"
|| f.render_shape == horizon_client::blocks::RenderShape::Model)
&& !matches!(
&*f.name,
"minecraft:water" | "minecraft:lava" | "minecraft:bubble_column"
)
{
// The nearest entry into one of the outline's boxes (slab method).
let mut best: Option<(f64, [i32; 3])> = None;
for b in self.outline_boxes(pos) {
let (mut t0, mut t1, mut axis_in, mut sign) = (0.0f64, f64::INFINITY, None, 0);
let mut miss = false;
for a in 0..3 {
if dir[a] == 0.0 {
miss |= origin[a] < b[a] || origin[a] > b[a + 3];
continue;
}
let (lo, hi) =
((b[a] - origin[a]) / dir[a], (b[a + 3] - origin[a]) / dir[a]);
let (near, far) = if lo < hi { (lo, hi) } else { (hi, lo) };
if near > t0 {
t0 = near;
axis_in = Some(a);
sign = if dir[a] > 0.0 { -1 } else { 1 };
}
t1 = t1.min(far);
}
if miss || t0 > t1 || t0 > reach {
continue;
}
let mut normal = face;
if let Some(a) = axis_in {
normal = [0; 3];
normal[a] = sign;
}
if best.is_none_or(|(bt, _)| t0 < bt) {
best = Some((t0, normal));
}
}
if let Some((t, face)) = best {
return Some(Hit {
pos,
face,
point: [
origin[0] + dir[0] * t,
origin[1] + dir[1] * t,
origin[2] + dir[2] * t,
],
});
}
}
let axis = if t_max[0] < t_max[1] {
if t_max[0] < t_max[2] { 0 } else { 2 }
} else if t_max[1] < t_max[2] {
1
} else {
2
};
t = t_max[axis];
t_max[axis] += delta[axis];
pos[axis] += step[axis];
face = [0; 3];
face[axis] = -step[axis];
}
None
}
/// The stack in the hand that acts (`getItemInHand(hand)`).
fn held(&self) -> Option<&ItemStack> {
self.stack_in(self.held_slot())
}
fn held_mut(&mut self) -> &mut Option<ItemStack> {
self.stack_in_mut(self.held_slot())
}
/// The slot of the hand that acts: the selected one, or `OFFHAND_SLOT`.
/// `LivingEntity.canGlideUsing`: a glider in the chest slot that will
/// not break with its next point of wear.
fn glider_worn(&self) -> bool {
self.armor[1].as_ref().is_some_and(|s| {
self.res
.items()
.get(&s.item)
.is_some_and(|i| i.glider && (i.max_damage == 0 || s.damage + 1 < i.max_damage))
})
}
/// `LivingEntity.canFreeze`'s armor half: any worn piece in
/// `freeze_immune_wearables`.
pub(crate) fn wears_freeze_immune(&self) -> bool {
let immune = self
.res
.items()
.item_tags
.get("minecraft:freeze_immune_wearables");
self.armor
.iter()
.flatten()
.any(|s| immune.is_some_and(|t| t.contains(&*s.item)))
}
/// What the window decides for its player's body every tick, in frame and
/// on a server alike: the look (Player.travel steers sprint-swimming by
/// the pitch), Auto Jump (LocalPlayer.sendPosition), the slowdown of an
/// item in use (LocalPlayer.modifyInput), the helmet's Respiration
/// (decreaseAirSupply), the wings, leather boots on powder snow
/// (PowderSnowBlock.canEntityWalkOnPowderSnow), freeze-immune wear
/// (LivingEntity.canFreeze) and the dimension's FAST_LAVA.
pub(crate) fn sync_player_body(&mut self) {
let glider = self.glider_worn();
let item_use_speed = self
.using
.and_then(|(slot, _)| {
if slot == shield::OFFHAND_SLOT {
self.offhand.as_ref()
} else {
self.inventory.get(slot)?.as_ref()
}
})
.and_then(|s| self.res.items().get(&s.item))
.map(|i| i.use_speed);
let respiration = self.armor[0]
.as_ref()
.map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
let leather_boots = self.armor[3]
.as_ref()
.is_some_and(|s| &*s.item == "minecraft:leather_boots");
let freeze_immune = self.wears_freeze_immune();
let Some(player) = self.player.as_mut() else {
return;
};
player.yaw = self.yaw;
player.pitch = self.pitch;
player.auto_jump_enabled = self.settings.auto_jump;
player.item_use_speed = item_use_speed;
player.respiration = respiration;
player.glider = glider;
player.leather_boots = leather_boots;
player.freeze_immune = freeze_immune;
player.fluids.fast_lava = self.dim == Dim::Nether;
}
fn held_slot(&self) -> usize {
match self.hand {
Hand::Main => self.selected,
Hand::Off => shield::OFFHAND_SLOT,
}
}
/// `LivingEntity.getUsedItemHand`: the hand of the item in use.
fn used_hand(&self) -> Option<Hand> {
self.using.map(|(slot, _)| {
if slot == shield::OFFHAND_SLOT {
Hand::Off
} else {
Hand::Main
}
})
}
/// Run `f` with `hand` acting (`held`, `consume_held`, `swing_arm`).
fn with_hand<T>(&mut self, hand: Hand, f: impl FnOnce(&mut Self) -> T) -> T {
let prior = std::mem::replace(&mut self.hand, hand);
let out = f(self);
self.hand = prior;
out
}
/// Inventory.add: returns the stack that did not fit.
fn give(&mut self, mut stack: ItemStack) -> Option<ItemStack> {
let max = self
.res
.items()
.get(&stack.item)
.map_or(64, |i| i.max_stack);
// Prefer the selected slot, then the hotbar, then the main inventory.
let order: Vec<usize> = std::iter::once(self.selected)
.chain((0..36).filter(|&i| i != self.selected))
.collect();
for &i in &order {
if let Some(slot) = &mut self.inventory[i]
&& slot.same_item_same_components(&stack)
&& slot.count < max
{
let moved = (max - slot.count).min(stack.count);
slot.count += moved;
stack.count -= moved;
if stack.count == 0 {
return None;
}
}
}
for i in 0..36 {
if self.inventory[i].is_none() {
let moved = stack.count.min(max);
self.inventory[i] = Some(ItemStack {
count: moved,
..stack.clone()
});
stack.count -= moved;
if stack.count == 0 {
return None;
}
}
}
Some(stack)
}
/// The block's first up face (or any face) and its fixed tint, for block
/// models drawn as entities (falling blocks, carried blocks).
fn block_face_sprite(&self, state: BlockStateId) -> Option<(String, u32)> {
let pack = &self.pack;
let models = pack
.render
.model_catalog
.collect(state, horizon_core::position::BlockPos::new(0, 0, 0))
.ok()?;
let face = models
.iter()
.flat_map(|(_, m)| m.faces.iter())
.find(|f| f.quad.facing == horizon_assets::model::Direction::Up)
.or_else(|| models.iter().flat_map(|(_, m)| m.faces.iter()).next())?;
let name = pack.layer_names.get(&face.layer)?.clone();
let tint = if face.quad.tint_index >= 0 {
let n = &self.res.facts().get(state).name;
if n.contains("leaves") || n.contains("vine") {
0x48B518
} else {
0x91BD59
}
} else {
0xFFFFFF
};
Some((name, tint))
}
/// `TerrainParticle` at `pos`: the model's particle sprite and tint source
/// 0's `colorAsTerrainParticle` (white when the block has none).
fn particle_sprite(&self, state: BlockStateId, pos: [i32; 3]) -> Option<(String, u32)> {
let sprite = Self::block_particle_sprite(&self.pack, state)?;
let chunks = &self.world.chunks;
let (cx, cz) = (pos[0] >> 4, pos[2] >> 4);
let region: [[Option<&horizon_client::chunk::Chunk>; 3]; 3] = std::array::from_fn(|dz| {
std::array::from_fn(|dx| {
chunks
.get(&(cx + dx as i32 - 1, cz + dz as i32 - 1))
.map(|c| &**c)
})
});
let tint = self
.pack
.context
.tables
.terrain_particle_tint(
state,
pos,
&region,
self.res.biomes(),
self.streaming.biome_zoom,
self.streaming.biome_blend,
)
.unwrap_or(0xFFFFFF);
Some((sprite, tint))
}
/// `BlockStateModelSet.getParticleMaterial`: the sprite of the model's
/// `particle` texture, else its first face (entity-rendered blocks may
/// have a particle texture without faces, and faces without one).
fn block_particle_sprite(pack: &PackResources, state: BlockStateId) -> Option<String> {
let catalog = &pack.render.model_catalog;
let layer = catalog.particle(state).or_else(|| {
let models = catalog
.collect(state, horizon_core::position::BlockPos::new(0, 0, 0))
.ok()?;
models
.iter()
.flat_map(|(_, m)| m.faces.iter())
.next()
.map(|f| f.layer)
})?;
pack.layer_names.get(&layer).cloned()
}
fn particle_shape(&self, pos: [i32; 3], state: BlockStateId) -> Vec<[f64; 6]> {
let f = self.res.facts().get(state);
let offset = if f.outline_offset {
self.pack
.context
.tables
.offset(state, pos[0], pos[2])
.unwrap_or([0.0; 3])
} else {
[0.0; 3]
};
f.outline
.iter()
.map(|b| std::array::from_fn(|i| b[i] + offset[i % 3]))
.collect()
}
/// ClientLevel.addDestroyBlockEffect: a burst per outline box.
fn destroy_particles(&mut self, pos: [i32; 3], state: BlockStateId) {
let Some((sprite, tint)) = self.particle_sprite(state, pos) else {
return;
};
let boxes = self.particle_shape(pos, state);
horizon_client::particles::destroy_positions(pos, &boxes, |p, v| {
let particle = Particle::terrain(self.particles.random(), p, v, sprite.clone(), tint);
self.particles.push(particle);
});
}
/// ClientLevel.addBreakingParticles: one crumb on the face being mined.
fn crack_particle(&mut self, pos: [i32; 3], face: [i32; 3], state: BlockStateId) {
let Some((sprite, tint)) = self.particle_sprite(state, pos) else {
return;
};
let boxes = self.particle_shape(pos, state);
// Keep client effects separate from the authoritative world RNG.
let r = self.particles.random();
let Some(p) = horizon_client::particles::breaking_position(r, pos, face, &boxes) else {
return;
};
let mut particle = Particle::terrain(r, p, [0.0; 3], sprite, tint);
particle.set_power(0.2);
particle.scale(0.6);
self.particles.push(particle);
}
/// `Player.dropEquipment` for the player who died: unless keep_inventory
/// is on, `destroyVanishingCursedItems`, then `Inventory.dropAll` from
/// `at` (the eyes less 0.3): slots 0..36, armor feet to head (36..39),
/// the off hand (40), each thrown in a random direction.
fn drop_inventory(&mut self, at: [f64; 3]) {
if self.ui.rules.bool("keep_inventory") {
return;
}
let mut stacks: Vec<ItemStack> =
self.inventory.iter_mut().filter_map(Option::take).collect();
stacks.extend(self.armor.iter_mut().rev().filter_map(Option::take));
stacks.extend(self.offhand.take());
stacks.retain(|s| s.enchantment_level("minecraft:vanishing_curse") == 0);
self.apply_equipment();
for stack in stacks {
let r = &mut self.world.random;
let strength = f64::from(r.next_float()) * 0.5;
let angle = f64::from(r.next_float()) * std::f64::consts::TAU;
let v = [-angle.sin() * strength, 0.2, angle.cos() * strength];
self.spawn_item(stack, at, v, 40);
}
}
fn spawn_item(
&mut self,
stack: ItemStack,
position: [f64; 3],
velocity: [f64; 3],
pickup_delay: u32,
) {
self.next_entity += 1;
let p = Vec3::new(position[0], position[1], position[2]);
// ItemEntity.bobOffs comes from the entity's own random, not the level's.
let bob = self.particles.random().next_float() * std::f32::consts::PI * 2.0;
self.dropped.push(ItemEntity {
health: 5,
fire_ticks: 0,
thrower: None,
id: self.next_entity,
stack,
position: p,
previous: p,
velocity: Vec3::new(velocity[0], velocity[1], velocity[2]),
on_ground: false,
age: 0,
pickup_delay,
bob_offset: bob,
ticks: 0,
});
}
/// `Block.getDrops`: the block's loot table, drawing from its server random
/// sequence (`LootContext.Builder.create`), else the level random.
fn block_loot_at(
&mut self,
pos: [i32; 3],
state: BlockStateId,
held: Option<&ItemStack>,
) -> Vec<ItemStack> {
let registry = self.pack.assets.registry;
let dynamic = self.pending.dynamic(pos);
match self.res.items().block_loot_sequence(registry, state) {
Some(sequence) => {
let random = self.rand_sequences.get(&sequence, self.level.seed);
self.res
.items()
.block_drops_with(registry, state, held, &dynamic, random)
}
None => self.res.items().block_drops_with(
registry,
state,
held,
&dynamic,
&mut self.world.random,
),
}
}
/// Block.popResource
fn pop_resource(&mut self, pos: [i32; 3], mut stack: ItemStack) {
self.pending.attach(pos, &mut stack);
// Block.popResource: Mth.nextDouble offsets from the level random; the
// motion is `new ItemEntity(..)`'s own, from the item's random.
let p = spill::pop_position(&mut self.world.random, pos);
let v = dispenser::new_item_motion();
self.spawn_item(stack, p, v, 10);
}
/// Player.drop: thrown from the eyes along the view direction.
fn drop_held(&mut self, all: bool) {
if self.eye_position().is_none() {
return;
}
let spectator = self.spectator();
let Some(thrown) = horizon_client::items::take_held_drop(
&mut self.inventory[self.selected],
all,
spectator,
) else {
return;
};
self.player_drop(thrown);
}
/// `Player.drop`: the statistics and a thrown item entity in front of the player.
fn player_drop(&mut self, thrown: ItemStack) {
let Some(eye) = self.eye_position() else {
return;
};
// LivingEntity.drop: every drop swings the main hand, a menu's
// THROW and a creative tab's drop included.
self.swing_hand(Hand::Main, SwingAnimation::DEFAULT);
// 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);
}
/// `Player.createItemStackToDrop`: an item entity thrown from the eyes
/// along the view direction.
fn throw_from_eyes(&mut self, thrown: ItemStack, eye: [f64; 3]) {
let (yaw, pitch) = (
f64::from(self.yaw).to_radians(),
f64::from(self.pitch).to_radians(),
);
let r = &mut self.world.random;
let spread = f64::from(r.next_float()) * std::f64::consts::TAU;
let strength = 0.02 * f64::from(r.next_float());
let v = [
-yaw.sin() * pitch.cos() * 0.3 + spread.cos() * strength,
-pitch.sin() * 0.3 + 0.1 + f64::from(r.next_float() - r.next_float()) * 0.1,
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() {
let uuid = self.level.ensure_player_uuid();
self.dropped.last_mut().unwrap().thrower = Some(uuid);
}
}
fn tick_items(&mut self) {
let mut items = std::mem::take(&mut self.dropped);
// ServerLevel.tick: only entities in entity-ticking chunks tick.
let ticking = self.entity_ticking_area();
let mut removed = vec![false; items.len()];
let mut cells = horizon_client::entities::ItemCells::new(&items);
let catalog = self.res.items();
let max_stack =
|stack: &ItemStack| catalog.get(&stack.item).map_or(64, |i| i.max_stack).max(1);
// A LAN or server guest only shows the host's items.
let merging = self.remote.is_none();
for i in 0..items.len() {
if removed[i] {
continue;
}
let item = &mut items[i];
if !ticking(
item.position.x.floor() as i32,
item.position.z.floor() as i32,
) {
continue;
}
// ItemEntity.tick's noPhysics (servers only): out of a block
// placed on it, towards the closest open side (#1252).
let no_physics = merging && item.inside_block(&self.world, self.collision);
if no_physics {
let speed = self.world.random.next_float() * 0.2 + 0.1;
item.move_towards_closest_space(&self.world, self.res.facts(), speed);
}
let alive = item.tick(&self.world, self.res.facts(), self.collision, no_physics);
cells.moved(i, item.previous, item.position);
// ItemEntity.tick: merge every 2 ticks while moving between
// blocks, every 40 otherwise, before the lifetime check.
let block = |v: Vec3| (v.x.floor(), v.y.floor(), v.z.floor());
let rate = if block(item.previous) == block(item.position) {
40
} else {
2
};
if merging
&& (alive || item.age == 6000 && item.position.y > -128.0)
&& item.ticks.is_multiple_of(rate)
{
horizon_client::entities::merge_with_neighbours(
&mut items,
&mut removed,
&mut cells,
i,
&max_stack,
);
}
let item = &mut items[i];
if !alive || removed[i] {
removed[i] = true;
cells.remove(i, item.position);
continue;
}
let environment = item.environment_tick(
&self.world,
self.res.facts(),
self.pack.assets.registry,
self.res.items(),
);
// shortcut: age is the fresh-drop clock; use entity ticks for saved/frozen-age phase parity.
if environment.should_play_lava_hurt_sound(item.age) {
let pitch = 2.0 + self.world.random.next_float() * 0.4;
self.audio.play(
"minecraft:entity.generic.burn",
Some([item.position.x, item.position.y, item.position.z]),
0.4,
pitch,
);
}
if !environment.alive {
removed[i] = true;
cells.remove(i, item.position);
}
}
let mut removed = removed.into_iter();
items.retain(|_| !removed.next().unwrap_or(false));
let Some(p) = self.player.as_ref() else {
self.dropped = items;
return;
};
if p.health.dead_or_dying() || self.spectator() {
self.dropped = items;
return;
}
let w = f64::from(p.dimensions.width) / 2.0;
let (min, max) = (
[
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 feet = [p.position.x, p.position.y, p.position.z];
let mut kept = Vec::with_capacity(items.len());
for mut item in items {
let b = item.bounds();
let touching = b.min_position().x < max[0]
&& b.max_position().x > min[0]
&& b.min_position().y < max[1]
&& b.max_position().y > min[1]
&& b.min_position().z < max[2]
&& b.max_position().z > min[2];
if touching && item.pickup_delay == 0 {
let before = item.stack.count;
let kind = item.stack.item.clone();
match self.give(item.stack.clone()) {
None => {
self.stats.add("picked_up", &kind, before as i32);
self.add_pickup(
pickups::Taken::Item(Box::new(item)),
pickups::Collector::Player,
);
let pitch = ((self.world.random.next_float()
- self.world.random.next_float())
* 0.7
+ 1.0)
* 2.0;
self.audio
.play("minecraft:entity.item.pickup", Some(feet), 0.2, pitch);
continue;
}
Some(rest) => {
if rest.count < before {
self.stats
.add("picked_up", &kind, (before - rest.count) as i32);
self.add_pickup(
pickups::Taken::Item(Box::new(item.clone())),
pickups::Collector::Player,
);
self.audio
.play("minecraft:entity.item.pickup", Some(feet), 0.2, 1.0);
}
item.stack = rest;
}
}
}
kept.push(item);
}
self.dropped = kept;
}
/// Run vanilla block behaviour against the world through `LevelAccess`.
fn with_level<R>(
&mut self,
f: impl FnOnce(&Behaviours, &mut GameLevel<'_>, &mut Ticks) -> R,
) -> R {
let darken = self.sky_darken();
let (rain, thunder) = self.world.weather.levels(1.0);
// Spectators ignore block triggers (Entity.isIgnoringBlockTriggers).
let spectator = self.spectator();
let player_box = self.player.as_ref().filter(|_| !spectator).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,
],
)
});
let player_collision = self.player.as_ref().filter(|_| !spectator).map(|p| {
let main_hand = self.inventory.get(self.selected).and_then(Option::as_ref);
PlayerCollision {
y: p.position.y,
descending: p.velocity.y < 0.0,
fall_distance: p.fall_distance,
main_hand_item: main_hand.map_or_else(
|| Arc::from("minecraft:air"),
|stack| Arc::clone(&stack.item),
),
main_hand_count: main_hand.map_or(0, |stack| stack.count as i32),
leather_boots: self.armor[3]
.as_ref()
.is_some_and(|stack| stack.item.as_ref() == "minecraft:leather_boots"),
}
});
let cart_boxes = self
.carts
.iter()
.map(|c| {
let p = c.position;
(
[p.x - 0.49, p.y, p.z - 0.49],
[p.x + 0.49, p.y + 0.7, p.z + 0.49],
)
})
.collect();
let guest_boxes = self.lan_block_trigger_boxes();
let dimension = match self.dim {
Dim::Overworld => LevelDimension::Overworld,
Dim::Nether => LevelDimension::Nether,
Dim::End => LevelDimension::End,
};
let rules = self.level_rules();
let blockers = Blockers {
mobs: &self.mobs,
armor_stands: &self.armor_stands,
boats: &self.boats,
crystals: &self.crystals,
tnts: &self.tnts,
falling: &self.falling,
};
let mut level = GameLevel {
cart_boxes,
blockers,
world: &mut self.world,
facts: self.res.facts(),
collision: self.collision,
events: &mut self.level_events,
dimension,
darken,
raining: rain > 0.2,
thundering: thunder > 0.9,
player_box,
guest_boxes,
player_collision,
biomes: self.res.biomes(),
seed: self.level.seed,
behaviours: self.res.behaviours(),
items: self.res.items(),
loot: horizon_client::structure_blocks::loot_data(&self.options.resources),
registry: self.pack.assets.registry,
rules,
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,
};
let result = f(self.res.behaviours(), &mut level, &mut self.block_ticks);
self.flush_spill();
result
}
/// Level.setBlock(pos, state, UPDATE_ALL) with neighbour/shape updates.
fn level_set(&mut self, pos: [i32; 3], state: BlockStateId) -> Result<()> {
self.with_level(|b, level, ticks| {
b.set_block(
level,
ticks,
BlockPos::new(pos[0], pos[1], pos[2]),
state,
level_flags::UPDATE_ALL,
);
});
self.process_level_events()
}
fn attack_block(&mut self, pos: [i32; 3]) -> Result<()> {
self.with_level(|b, level, ticks| {
b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]));
});
self.process_level_events()
}
/// Track which chunks are ticking (Ticks needs chunk load/unload).
fn sync_tick_chunks(&mut self) {
if !self.tick_chunks.synchronize(&self.world.chunks) {
return;
}
// Move only the added keys out so registration can borrow all of Game.
let added = self.tick_chunks.take_added();
for &key in &added {
self.register_chunk_ticks(key);
}
for &key in self.tick_chunks.removed() {
self.random_tick_sections.remove(&key);
self.portals.sections.remove(&key);
self.block_ticks
.remove_chunk(horizon_core::position::ChunkPos::new(key.0, key.1));
}
self.tick_chunks.recycle_added(added);
}
/// `DistanceManager`'s tickets of the level in place, from every player in
/// it (the local player, LAN guests, a server's players) and its forced
/// chunks. A game with neither a server nor a player (the headless
/// fixtures) ticks everywhere.
fn update_chunk_tickets(&mut self) {
let mut players: Vec<(i32, i32)> = self.lan.as_ref().map_or_else(Vec::new, |h| {
h.hub
.guests
.iter()
.filter(|g| h.hub.here(g))
.map(|g| g.chunk())
.collect()
});
if let Some(p) = &self.player {
players.push((
(p.position.x.floor() as i32) >> 4,
(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),
}
});
self.tickets.update(sources);
}
/// `ServerLevel.startTickingChunk`: a loaded chunk's saved ticks are
/// scheduled from the game time at which it becomes a ticking chunk
/// (block ticking, with its neighbours loaded). Chunks become ticking
/// between ticks in vanilla: before this tick's clock advanced.
fn start_ticking_chunks(&mut self) {
let levels = self.tickets.levels();
let world = &self.world;
let started = self
.tick_chunks
.start_ticking(|(x, z)| levels.loaded_ticking(x, z) && ticking_chunk(world, x, z));
let time = self.world.game_time - 1;
for (x, z) in started {
let pos = horizon_core::position::ChunkPos::new(x, z);
self.block_ticks.blocks.unpack_chunk(pos, time);
self.block_ticks.fluids.unpack_chunk(pos, time);
}
}
/// ServerLevel.tick block phases: scheduled ticks, random ticks in the
/// chunks the tickets simulate, block events and moving pistons.
fn tick_blocks(&mut self) -> Result<()> {
self.sync_tick_chunks();
self.start_ticking_chunks();
let levels = self.tickets.levels();
// Keep the world map's chunk order, including empty chunks
// (tick_chunk_random still draws for precipitation in those).
let ticking: Vec<_> = self
.world
.chunks
.keys()
.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.
let mut inside = Vec::new();
let guests = self.lan_block_trigger_boxes();
let boxes = self
.player
.iter()
.filter(|_| !self.spectator())
.map(|p| {
let w = f64::from(p.dimensions.width) / 2.0;
let h = f64::from(p.dimensions.height);
(
[p.position.x - w, p.position.y, p.position.z - w],
[p.position.x + w, p.position.y + h, p.position.z + w],
)
})
.chain(self.carts.iter().map(|c| {
let p = c.position;
(
[p.x - 0.49, p.y, p.z - 0.49],
[p.x + 0.49, p.y + 0.7, p.z + 0.49],
)
}))
.chain(guests);
for (lo, hi) in boxes {
for x in (lo[0] + 1e-7).floor() as i32..=(hi[0] - 1e-7).floor() as i32 {
for y in (lo[1] + 1e-7).floor() as i32..=(hi[1] - 1e-7).floor() as i32 {
for z in (lo[2] + 1e-7).floor() as i32..=(hi[2] - 1e-7).floor() as i32 {
inside.push(BlockPos::new(x, y, z));
}
}
}
}
self.with_level(|b, level, ticks| {
for pos in inside {
b.entity_inside(level, ticks, pos);
}
});
self.process_level_events()?;
self.tick_scheduled()?;
self.with_level(|b, level, ticks| {
for (x, z) in ticking {
// The sections are read again only after a block changed.
let mut read = None;
let mut sections = Default::default();
let pos = horizon_core::position::ChunkPos::new(x, z);
b.tick_chunk_random(level, ticks, pos, |level, from| {
if read != Some(level.world.revision) {
read = Some(level.world.revision);
sections = level
.world
.chunks
.get(&(x, z))
.map_or_else(Default::default, |chunk| {
level.random_tick_sections.get((x, z), chunk, level.facts)
});
}
sections.from(from)
});
}
b.run_block_events(level, ticks);
b.tick_block_entities(level, ticks);
});
self.sync_moving_pistons();
self.process_level_events()
}
/// Copies the moving-piston block entities into the world, where the
/// collision queries and the renderer read them.
fn sync_moving_pistons(&mut self) {
let pistons = &mut self.world.moving_pistons;
pistons.clear();
pistons.extend(
self.block_ticks
.moving_pistons
.iter()
.map(|(p, piston)| ([p.x, p.y, p.z], piston.shape_state())),
);
}
/// `ServerLevel.tick`'s scheduled block then fluid ticks, one at a time:
/// the side effects of each (a shrieker summoning a warden, drops, game
/// events) happen before the next tick runs, as they do inline in vanilla.
pub(super) fn tick_scheduled(&mut self) -> Result<()> {
for fluids in [false, true] {
if !self.with_level(|b, level, ticks| b.scheduled_begin(level, ticks, fluids)) {
continue;
}
loop {
let more =
self.with_level(|b, level, ticks| b.scheduled_step(level, ticks, fluids));
if !self.level_events.is_empty() {
self.process_level_events()?;
}
if !more {
break;
}
}
self.with_level(|b, _, ticks| b.scheduled_finish(ticks, fluids));
}
Ok(())
}
/// Side effects reported by the behaviour library, in vanilla order.
fn process_level_events(&mut self) -> Result<()> {
let events = std::mem::take(&mut self.level_events);
self.lan_record_events(&events);
dispense_fixture::record_events(&events);
for event in events {
match event {
LevelEvent::LevelEvent {
id: 2001,
pos,
data,
} => {
// LevelEventHandler: destroy particles and the block's
// break sound (none for air).
let state = BlockStateId(data as u32);
let p = [pos.x, pos.y, pos.z];
self.destroy_particles(p, state);
if self.res.facts().is_air(state) {
continue;
}
let sounds = self.res.facts().get(state).sounds.clone();
let c = [
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 0.5,
f64::from(pos.z) + 0.5,
];
self.audio.play(
&sounds.break_sound,
Some(c),
(sounds.volume + 1.0) / 2.0,
sounds.pitch * 0.8,
);
}
LevelEvent::LevelEvent {
id: 3006,
pos,
data,
} => self.sculk_charge_event(pos, data),
LevelEvent::LevelEvent { id: 3007, pos, .. } => self.shriek_event(pos),
LevelEvent::LevelEvent { id: 2004, pos, .. } => {
self.spawner_burst([pos.x, pos.y, pos.z])
}
// LevelEventHandler 1505: the growth particles, then the sound.
LevelEvent::LevelEvent {
id: 1505,
pos,
data,
} => {
self.growth_particles(pos, data);
let at = [pos.x, pos.y, pos.z].map(|v| f64::from(v) + 0.5);
self.audio
.play("minecraft:item.bone_meal.use", Some(at), 1.0, 1.0);
}
LevelEvent::LevelEvent {
id: 2015,
pos,
data,
} => self.dragon_egg_particles([pos.x, pos.y, pos.z], data),
LevelEvent::LevelEvent {
id: 2017,
pos,
data,
} => self.consume_teleport_particles([pos.x, pos.y, pos.z], data),
LevelEvent::LevelEvent {
id: 2013,
pos,
data,
} => self.smash_dust(pos, data),
LevelEvent::LevelEvent {
id: id @ 3002..=3005,
pos,
data,
} => self.block_particle_event(id, pos, data),
LevelEvent::LevelEvent {
id: 1500,
pos,
data,
} => self.composter_fill_event(pos, data == 1),
LevelEvent::LevelEvent {
id: id @ 3011..=3021,
pos,
data,
} => self.trial_level_event(id, [pos.x, pos.y, pos.z], data),
LevelEvent::LevelEvent { id, pos, .. } => {
let c = Some([
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 0.5,
f64::from(pos.z) + 0.5,
]);
let sound = match id {
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)),
1030 => Some(("minecraft:block.anvil.use", 1.0)),
1029 => Some(("minecraft:block.anvil.destroy", 1.0)),
1031 => Some(("minecraft:block.anvil.land", 0.3)),
1042 => Some(("minecraft:block.grindstone.use", 1.0)),
1044 => Some(("minecraft:block.smithing_table.use", 1.0)),
// LevelEvent.SOUND_PAGE_TURN (a lectern's page).
1043 => Some(("minecraft:item.book.page_turn", 1.0)),
_ => None,
};
if let Some((name, volume)) = sound {
let pitch = match id {
1009 => {
2.6 + (self.world.random.next_float()
- self.world.random.next_float())
* 0.8
}
1029 | 1030 | 1042 | 1043 | 1044 => {
self.world.random.next_float() * 0.1 + 0.9
}
_ => 1.0,
};
self.audio.play(name, c, volume, pitch);
}
}
LevelEvent::Sound {
pos,
sound,
volume,
pitch,
} => {
let c = [
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 0.5,
f64::from(pos.z) + 0.5,
];
let name = if sound.contains(':') {
sound.to_string()
} else {
format!("minecraft:{sound}")
};
self.audio.play(&name, Some(c), volume, pitch);
}
// Handled as the behaviour emits it (GameLevel::emit).
LevelEvent::DropResources { pos, state } => {
self.with_level(|_, level, _| level.drop_resources_now(pos, state));
}
LevelEvent::FallingBlock { pos, state } => {
let p = Vec3::new(
f64::from(pos.x) + 0.5,
f64::from(pos.y),
f64::from(pos.z) + 0.5,
);
self.falling.push(FallingBlock {
id: 0,
state,
start_pos: pos,
position: p,
previous: p,
velocity: Vec3::ZERO,
age: 0,
no_gravity: false,
drop_item: true,
fall_distance: 0.0,
stuck: Vec3::ZERO,
damage: if self.res.facts().get(state).name.ends_with("anvil") {
horizon_client::falling_block::Damage::anvil()
} else {
Default::default()
},
saved: None,
});
}
LevelEvent::Player { pos, effect, .. } => match effect {
PlayerEffect::OpenMenu => self.open_menu([pos.x, pos.y, pos.z]),
PlayerEffect::Sleep if self.beds_destroy_on_use() => {
self.destroy_bed_on_use([pos.x, pos.y, pos.z])?
}
PlayerEffect::Sleep => self.try_sleep([pos.x, pos.y, pos.z]),
PlayerEffect::GiveItem(item) => {
if let Some(rest) = self.give(ItemStack {
item,
count: 1,
damage: 0,
extra: None,
}) {
self.pop_resource([pos.x, pos.y, pos.z], rest);
}
}
// Popped as the behaviour emits it (GameLevel::emit).
PlayerEffect::DropItem(_) => {}
PlayerEffect::EatCake => {
if let Some(p) = self.player.as_mut() {
let food = &mut p.health.food;
food.food = (food.food + 2).min(20);
food.saturation = (food.saturation + 0.4).min(food.food as f32);
}
}
PlayerEffect::RespawnAnchor => {
self.respawn_anchor_used([pos.x, pos.y, pos.z])?
}
PlayerEffect::InteractLoot(_) => {}
},
LevelEvent::PrimeTnt { pos, rot } => self.add_primed_tnt(pos, rot, 80),
LevelEvent::BlockEvent {
pos,
state,
kind: "dispense",
} => self.dispense_from(pos, state)?,
LevelEvent::BlockEvent {
pos,
kind: "command_block",
..
} => self.command_block_tick(pos),
LevelEvent::BlockEvent {
pos, kind: "hatch", ..
} => {
// FrogspawnBlock.hatchFrogspawn: 2-5 tadpoles.
let at = [
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 0.5,
f64::from(pos.z) + 0.5,
];
self.audio
.play("minecraft:block.frogspawn.hatch", Some(at), 1.0, 1.0);
let count = 2 + self.world.random.next_int_bound(4).unwrap_or(0);
for _ in 0..count {
// getRandomTadpolePositionOffset: 0.2..0.8 inside the block.
let r = &mut self.world.random;
let off = |r: &mut horizon_core::random::LegacyRandom| {
f64::from(r.next_float()) * 0.6 + 0.2
};
let (dx, dz) = (off(r), off(r));
let spawn = [
f64::from(pos.x) + dx,
f64::from(pos.y) - 0.5,
f64::from(pos.z) + dz,
];
let _ = self.spawn_mob("minecraft:tadpole", spawn, true);
}
}
LevelEvent::BlockEvent {
pos,
kind: "hatch_sniffer",
..
} => self.hatch_sniffer([pos.x, pos.y, pos.z]),
LevelEvent::BlockEvent {
pos,
kind: "portal_spawn",
..
} => self.portal_spawn([pos.x, pos.y, pos.z]),
LevelEvent::BlockEvent {
pos,
state,
kind: "spawn_ghastling",
} => self.spawn_ghastling([pos.x, pos.y, pos.z], state),
LevelEvent::GameEvent { pos, event, state } => {
self.sculk_level_event(pos, event, state)
}
LevelEvent::BlockEvent {
pos,
state,
kind: "shrieker_respond",
} => self.shrieker_block_event(pos, state),
LevelEvent::BlockEntityEvent { pos, a, b, .. } => {
self.block_entity_event([pos.x, pos.y, pos.z], a, b)
}
LevelEvent::GrowTree { .. }
| LevelEvent::PlaceFeature { .. }
| LevelEvent::BlockEvent { .. } => {}
}
}
Ok(())
}
/// Menus opened by PlayerEffect::OpenMenu.
fn open_menu(&mut self, pos: [i32; 3]) {
let name = self
.res
.facts()
.get(self.world.block(pos[0], pos[1], pos[2]))
.name
.clone();
let key = (pos[0], pos[1], pos[2]);
if &*name == "minecraft:lectern" {
self.open_lectern(pos);
return;
}
if horizon_client::command_block::Mode::of_block(&name).is_some() {
self.open_command_block(key);
return;
}
if &*name == "minecraft:crafting_table" {
self.craft_size = 3;
self.craft_table = Some(pos);
} else if &*name == "minecraft:ender_chest" {
self.open_ender_chest(key);
self.container_opener_event(key, true);
let at = [
f64::from(key.0) + 0.5,
f64::from(key.1) + 0.5,
f64::from(key.2) + 0.5,
];
let pitch = self.world.random.next_float() * 0.1 + 0.9;
self.audio
.play("minecraft:block.ender_chest.open", Some(at), 0.5, pitch);
} else if &*name == "minecraft:beacon" && self.open_station(pos, &name) {
self.world.block_entities.get_or_insert_with(key, || {
BlockEntity::for_block(&name).unwrap_or(BlockEntity::Chest(Vec::new()))
});
} else if storage::is_shulker_box(&name) && !self.shulker_can_open(pos) {
// ShulkerBoxBlock.canOpen: the lid has no room; nothing opens.
} else if let Some(entity) = BlockEntity::for_block(&name) {
self.world.block_entities.get_or_insert_with(key, || entity);
let centre = [
f64::from(key.0) + 0.5,
f64::from(key.1) + 0.5,
f64::from(key.2) + 0.5,
];
self.resolve_container_maps(key, centre);
self.container = Some(key);
self.container_opener_event(key, true);
self.post_block_game_event(
"minecraft:container_open",
[key.0, key.1, key.2],
Some(horizon_client::mobs::Who::Player),
None,
);
let stat = match &*name {
"minecraft:chest" => "open_chest",
"minecraft:trapped_chest" => "trigger_trapped_chest",
"minecraft:barrel" => "open_barrel",
"minecraft:hopper" => "inspect_hopper",
"minecraft:dropper" => "inspect_dropper",
"minecraft:dispenser" => "inspect_dispenser",
n if storage::is_shulker_box(n) => "open_shulker_box",
_ => "",
};
if !stat.is_empty() {
self.stats.custom(stat, 1);
}
// Opening a piglin-guarded container angers the piglins who see it.
if self.guarded_by_piglins(&name) {
self.anger_piglins(true);
}
let sound = if storage::is_shulker_box(&name) {
Some("minecraft:block.shulker_box.open")
} else if name.contains("chest") {
Some("minecraft:block.chest.open")
} else if &*name == "minecraft:barrel" {
Some("minecraft:block.barrel.open")
} else {
None
};
if let Some(sound) = sound {
self.audio.play(
sound,
Some([
f64::from(key.0) + 0.5,
f64::from(key.1) + 0.5,
f64::from(key.2) + 0.5,
]),
0.5,
1.0,
);
}
} else if self.open_station(pos, &name) {
// Workstation menus: game/stations.rs.
} else {
self.message = Some((
format!(
"{} is not available yet",
name.trim_start_matches("minecraft:").replace('_', " ")
),
Instant::now(),
));
return;
}
self.screen = Screen::Inventory;
self.capture(false);
self.right = false;
}
/// FallingBlockEntity.tick: fall with 0.04 gravity and 0.98 drag, then land.
fn tick_falling(&mut self) -> Result<()> {
let falling = std::mem::take(&mut self.falling);
let mut kept = Vec::with_capacity(falling.len());
let mut collision_error = None;
let entity_drops = self.ui.rules.bool("entity_drops");
// ServerLevel.tick: only entities in entity-ticking chunks tick.
let ticking = self.entity_ticking_area();
// FallingBlockEntity.tick places or drops each block in its own tick,
// so a block falling onto one that just landed lands on top of it.
for mut f in falling {
if !ticking(f.position.x.floor() as i32, f.position.z.floor() as i32) {
kept.push(f);
continue;
}
let original = f.clone();
match self.fall_step(&mut f, entity_drops) {
Ok(FallStep::Falling) => kept.push(f),
Ok(FallStep::Gone) => {}
Ok(FallStep::Dropped(at)) => self.drop_falling_block(f.state, at),
Ok(FallStep::Landed(pos)) => self.finish_falling_block(f, pos),
Err(error) => {
kept.push(original);
collision_error.get_or_insert(error);
}
}
}
// Blocks that started falling meanwhile tick from the next tick on.
let started = std::mem::replace(&mut self.falling, kept);
self.falling.extend(started);
self.process_level_events()?;
if let Some(error) = collision_error {
return Err(error);
}
Ok(())
}
/// One `FallingBlockEntity.tick` move of `f`.
fn fall_step(&self, f: &mut FallingBlock, entity_drops: bool) -> Result<FallStep> {
f.previous = f.position;
f.age = f.age.wrapping_add(1);
if !f.no_gravity {
f.velocity.y -= 0.04;
}
let mut wanted = f.velocity;
// Entity.move: a cobweb it was in scales this move, which then
// starts from rest.
if f.stuck.length_squared() > 1.0e-7 {
wanted = wanted.multiply(f.stuck);
f.stuck = Vec3::ZERO;
f.velocity = Vec3::ZERO;
}
let mut scene = collisions::SceneCollisions {
world: &self.world,
binding: self.collision,
subject: Some(collisions::PowderSnowSubject {
fall_distance: f.fall_distance,
falling_block: true,
..Default::default()
}),
};
let context = CollisionContext::for_entity(
CollisionEntity {
identity: EntityIdentity(0),
y: f.position.y,
descending: wanted.y < 0.0,
main_hand: None,
},
false,
);
// On an error the caller keeps the block as it was before this tick.
let movement = scene.resolve_with_context(
horizon_client::falling_block::bounds(f.position),
wanted,
0.0,
false,
context,
)?;
let next = Vec3::new(
f.position.x + movement.x,
f.position.y + movement.y,
f.position.z + movement.z,
);
let on_ground = wanted.y < 0.0 && movement.y != wanted.y;
// FallingBlockEntity.tick: off the ground, it gives up after 600
// ticks (100 outside the world) and drops itself as an item.
let y = next.y.floor() as i32;
let outside = y <= horizon_client::chunk::MIN_Y || y >= horizon_client::chunk::MIN_Y + 384;
if !on_ground && (f.age > 100 && outside || f.age > 600) {
return Ok(if f.drop_item && entity_drops {
FallStep::Dropped(next)
} else {
FallStep::Gone
});
}
if next.y < f.position.y {
f.fall_distance += f.position.y - next.y;
}
let from = f.position;
f.position = next;
if on_ground {
let pos = [
f.position.x.floor() as i32,
f.position.y.floor() as i32,
f.position.z.floor() as i32,
];
return Ok(FallStep::Landed(pos));
}
// applyEffectsFromBlocks: WebBlock.entityInside makes it stuck
// (Entity.makeStuckInBlock, which forgets the fall). Entity.move
// records the move unless it was blocked short of a tiny one.
let moved = movement.length_squared();
let recorded = moved > 1.0e-7 || wanted.length_squared() - moved < 1.0e-7;
let world = &self.world;
let facts = self.res.facts();
if horizon_client::falling_block::passes_cobweb(
from,
f.position,
recorded.then_some(wanted),
|p| &*facts.get(world.block(p.x, p.y, p.z)).name == "minecraft:cobweb",
) {
f.fall_distance = 0.0;
f.stuck = horizon_client::falling_block::web_multiplier();
}
if movement.x != wanted.x {
f.velocity.x = 0.0;
}
if movement.y != wanted.y {
f.velocity.y = 0.0;
}
if movement.z != wanted.z {
f.velocity.z = 0.0;
}
f.velocity = Vec3::new(
f.velocity.x * 0.98,
f.velocity.y * 0.98,
f.velocity.z * 0.98,
);
Ok(FallStep::Falling)
}
/// `Entity.spawnAtLocation`: an item entity where the block was.
fn drop_falling_block(&mut self, state: BlockStateId, at: Vec3) {
// Entity.spawnAtLocation: an item entity where the block was.
let item = self.res.facts().get(state).item.clone();
if &*item != "minecraft:air" {
let r = &mut self.world.random;
let v = [
r.next_double() * 0.2 - 0.1,
0.2,
r.next_double() * 0.2 - 0.1,
];
let stack = ItemStack {
item,
count: 1,
damage: 0,
extra: None,
};
self.spawn_item(stack, [at.x, at.y, at.z], v, 10);
}
}
/// `DecoratedPotBlock.playerWillDestroy`: a pot mined with an item in
/// `breaks_decorated_pots`, unless an enchantment prevents shattering, is
/// cracked first (flags 260), so it shatters into its sherds.
fn crack_mined_pot(&mut self, pos: [i32; 3], state: BlockStateId) -> BlockStateId {
let registry = &self.pack.assets.registry;
let Some(mut pot) = registry
.state(state)
.filter(|s| s.name == "minecraft:decorated_pot")
.cloned()
else {
return state;
};
let Some(held) = self.held() else {
return state;
};
let breaks = self
.res
.items()
.item_tags
.get("minecraft:breaks_decorated_pots")
.is_some_and(|t| t.contains(&*held.item));
let enchantments = &self.res.stations().enchantments;
let kept = held
.enchantments()
.iter()
.any(|(e, _)| enchantments.in_tag("minecraft:prevents_decorated_pot_shattering", e));
if !breaks || kept {
return state;
}
pot.properties.insert("cracked".into(), "true".into());
let Ok(cracked) = registry.resolve(&pot) else {
return state;
};
let at = BlockPos::new(pos[0], pos[1], pos[2]);
self.with_level(|b, level, ticks| b.set_block(level, ticks, at, cracked, 260));
cracked
}
/// `ItemStack.mineBlock` for the held stack once a survival player has
/// mined the block `name`: an item with a `tool` component counts as used
/// and loses its `damage_per_block` on a block that doesn't break
/// instantly (`ShearsItem`: on any block but fire).
fn mine_block_with_held(&mut self, name: &str, hardness: f32) {
let Some(stack) = self.inventory[self.selected].clone() else {
return;
};
let Some((per_block, max)) = self
.res
.items()
.get(&stack.item)
.and_then(|i| Some((i.tool_damage_per_block?, i.max_damage)))
else {
return;
};
let wears = if &*stack.item == "minecraft:shears" {
!self.res.items().block_in_tag("minecraft:fire", name)
} else {
hardness != 0.0
};
if wears && per_block > 0 && max > 0 {
let loss = self.durability_loss(&stack, per_block);
if let Some(held) = self.inventory[self.selected].as_mut() {
held.damage += loss;
if held.damage >= max {
self.inventory[self.selected] = None;
}
}
}
self.stats.add("used", &stack.item, 1);
}
fn break_block(&mut self, pos: [i32; 3]) -> Result<()> {
self.with_player_actor(|game| game.break_block_as_player(pos))
}
fn break_block_as_player(&mut self, pos: [i32; 3]) -> Result<()> {
self.pad_rumble(horizon_client::gamepad::Rumble::BlockBroken);
// ServerPlayerGameMode.destroyBlock.
let state = self.world.block(pos[0], pos[1], pos[2]);
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.
if self.guarded_by_piglins(&facts.name) {
self.anger_piglins(false);
}
// The block entity as it was, for what the drops copy from it.
let key = (pos[0], pos[1], pos[2]);
if let Some(entity) = self.world.block_entities.get(&key).cloned() {
let name = self.world.block_names.get(&key).cloned();
self.pending.record(pos, &entity, &facts.name, name);
} else if let Some(tag) = spill::saved_entity(&self.world, pos) {
self.pending.record_saved(pos, &tag);
}
self.creaking_heart_broken(pos);
let hive = match self.world.block_entities.get(&key) {
Some(BlockEntity::Beehive(h)) => self.hive_state(pos).map(|s| ((**h).clone(), s)),
_ => None,
};
// playerWillDestroy and Level.removeBlock through the vanilla behaviour
// library: the block entity's side effects (containers spill), neighbour
// and shape updates, and the destroy event (particles, sound).
let creative = self.creative;
let removed = self.with_level(|b, level, ticks| {
b.player_destroy_block(
level,
ticks,
BlockPos::new(pos[0], pos[1], pos[2]),
creative,
)
});
if removed && !creative {
let held = self.held().cloned();
self.mine_block_with_held(&facts.name, facts.hardness);
let harvest = !facts.requires_tool
|| self
.res
.items()
.correct_for_drops(held.as_ref(), &facts.name);
if harvest {
// Block.playerDestroy: the mined statistic, the exhaustion and the drops.
self.stats.add("mined", &facts.name, 1);
if let Some(p) = self.player.as_mut() {
p.cause_food_exhaustion(0.005);
}
let drops = self.block_loot_at(pos, state, held.as_ref());
let silk = held
.as_ref()
.is_some_and(|h| h.enchantment_level("minecraft:silk_touch") > 0);
for d in drops {
if &*d.item != "minecraft:air" {
self.pop_resource(pos, d);
}
}
// BeehiveBlock.playerDestroy: silk touch keeps the bees in.
if let Some((hive, (honey, facing))) = hive
&& !silk
{
self.hive_broken_by_player(pos, hive, honey, facing);
}
// SpawnerBlock.spawnAfterBreak pops its experience whatever the tool.
let xp = if silk && &*facts.name != "minecraft:spawner" {
0
} else {
self.block_experience(&facts.name)
};
if xp > 0 {
self.spawn_orbs(
[
f64::from(pos[0]) + 0.5,
f64::from(pos[1]) + 0.5,
f64::from(pos[2]) + 0.5,
],
xp,
);
}
}
}
self.pending.clear(pos);
self.process_level_events()?;
Ok(())
}
/// The hand whose use ended the click, if any.
fn use_item(&mut self) -> Result<Option<Hand>> {
self.with_player_actor(|game| game.use_item_as_player())
}
/// `Minecraft.startUseItem`: the main hand, then the off hand.
fn use_item_as_player(&mut self) -> Result<Option<Hand>> {
// Spectators only look (MultiPlayerGameMode.useItemOn/useItem pass).
if self.spectator() {
return Ok(None);
}
// A carrot or warped fungus on a stick boosts the ridden pig or strider.
// A guest's use packets name one hand and touch no entity: the client
// sends one per hand and part of its click, and Interact for entities.
let guest = self.guest_use;
if let Some(GuestUse::Entity(hand)) = guest {
return Ok(self.with_hand(hand, Game::interact_entity)?.then_some(hand));
}
let on_block = matches!(guest, Some(GuestUse::OnBlock(_)));
if !on_block
&& self.riding.is_some()
&& let Some(item) = self.held().map(|s| s.item.clone())
&& self.use_steering_stick(&item)
{
return Ok(Some(Hand::Main));
}
if guest.is_none() && self.interact_entity()? {
return Ok(Some(Hand::Main));
}
// An EntityHitResult may fall through to Item.use, never to useItemOn.
let block_hit = if matches!(guest, Some(GuestUse::Item(_))) || self.entity_targeted() {
None
} else {
self.pick()
};
let hands = match guest {
Some(GuestUse::OnBlock(hand) | GuestUse::Item(hand) | GuestUse::Entity(hand)) => {
vec![hand]
}
None => Hand::BOTH.to_vec(),
};
let entity = guest.is_none() && self.entity_targeted();
for hand in hands {
// The off hand's turn starts on the entity too (Minecraft.startUseItem).
if entity && hand == Hand::Off && self.with_hand(hand, Game::interact_entity)? {
return Ok(Some(hand));
}
if self.with_hand(hand, |game| game.use_hand(block_hit.as_ref()))? {
return Ok(Some(hand));
}
}
Ok(None)
}
/// `Player.interactOn` for the entity under the crosshair with the
/// acting hand: whether it took the click.
fn interact_entity(&mut self) -> Result<bool> {
Ok(self.interact_frame()
|| self.interact_armor_stand()
|| self.interact_boat()
|| self.interact_cart()
|| self.interact_mob()?
|| self.interact_knot())
}
/// `ItemStack.applyAfterUseComponentSideEffects`: a used stack with a
/// `use_cooldown` component starts its entry (`UseCooldown.apply`). A
/// server's guest also gets `ClientboundCooldownPacket`
/// (`ServerItemCooldowns.onCooldownStarted`), queued for their turn's end.
pub(super) fn apply_use_cooldown(&mut self, stack: &ItemStack) {
let default = self
.res
.items()
.get(&stack.item)
.and_then(|i| i.use_cooldown.clone());
let Some(component) = horizon_client::cooldowns::component(stack, default.as_ref()) else {
return;
};
let group = horizon_client::cooldowns::group(stack, default.as_ref());
self.cooldowns.add(Arc::clone(&group), component.ticks());
if self.lan_acting.is_some() {
self.guest_cooldowns.push((group, component.ticks()));
}
}
/// One hand's turn in `startUseItem`: `useItemOn` the block aimed at,
/// then `useItem`. Whether the click ends here (it acted or failed).
fn use_hand(&mut self, block_hit: Option<&Hit>) -> Result<bool> {
// isSecondaryUseActive with something in either hand keeps blocks
// from reacting.
let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some();
let mut anchor_passed = false;
// MultiPlayerGameMode.useItemOn: blocks react first.
if !(sneaking && hands_full)
&& let Some(hit) = block_hit
{
let held = self.held().cloned();
if self.use_lectern(hit.pos, held.as_ref()) {
self.swing_arm();
return Ok(true);
}
if self.use_jukebox(hit.pos, held.as_ref()) {
self.swing_arm();
return Ok(true);
}
if self.use_composter(hit.pos, held.as_ref()) {
self.swing_arm();
return Ok(true);
}
if self.use_vault(hit.pos, held.as_ref())? {
self.swing_arm();
return Ok(true);
}
if self.use_decorated_pot(hit.pos, held.as_ref()) {
self.swing_arm();
return Ok(true);
}
if self.use_pumpkin(hit.pos, hit.face, 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();
return Ok(true);
}
// The main hand passes; its item is used, then the off hand's glowstone.
respawn_anchor::AnchorUse::Pass => anchor_passed = true,
respawn_anchor::AnchorUse::Other => {}
}
// TRY_WITH_EMPTY_HAND: only the main hand's turn uses the block
// itself (useWithoutItem).
if !anchor_passed && self.hand == Hand::Main {
let face = match hit.face {
[0, 1, 0] => Direction::Up,
[0, -1, 0] => Direction::Down,
[0, 0, -1] => Direction::North,
[0, 0, 1] => Direction::South,
[-1, 0, 0] => Direction::West,
_ => Direction::East,
};
let player = self.use_context();
let at = Vec3::new(hit.point[0], hit.point[1], hit.point[2]);
let item = held.as_ref().map(|s| s.item.to_string());
let result = self.with_level(|b, level, ticks| {
b.use_item_on(
level,
ticks,
BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
face,
at,
player,
item.as_deref(),
)
});
self.process_level_events()?;
if result.consumes_action() {
self.swing_arm();
return Ok(true);
}
}
}
let Some(stack) = self.held().cloned() else {
return Ok(false);
};
let Some(info) = self.res.items().get(&stack.item).cloned() else {
return Ok(false);
};
// ServerPlayerGameMode.useItem and useItemOn: an item on cooldown is
// not used (PASS, so the other hand may still act).
if self
.cooldowns
.is_on_cooldown(&horizon_client::cooldowns::group(
&stack,
info.use_cooldown.as_ref(),
))
{
return Ok(false);
}
if block_hit.is_some() && (self.use_bone_meal(&stack)? || self.ignite_tnt(&stack)?) {
return Ok(true);
}
// A guest's UseItemOn stops at ItemStack.useOn: what Item.use does
// (throw, drink, eat, raise, equip) waits for its UseItem.
let on_block = matches!(self.guest_use, Some(GuestUse::OnBlock(_)));
let spawn_egg = stack.item.ends_with("_spawn_egg");
use horizon_client::first_person::UseResult;
let swings = self.swings_started;
match self.use_tool(&stack, block_hit.is_some())? {
UseResult::Success { swing } => {
if (UseResult::Success { swing }).should_swing(swings, self.swings_started) {
self.swing_arm();
}
return Ok(true);
}
UseResult::Fail => return Ok(true),
UseResult::Pass => {}
}
if (!on_block && self.use_potion_item(&stack)?)
|| ((block_hit.is_some() || !spawn_egg)
&& (!on_block || spawn_egg)
&& self.throw_item(&stack)?)
{
return Ok(true);
}
if !on_block
&& (self.raise_shield(self.held_slot())
|| self.use_fishing_rod(&stack)
|| self.use_crossbow(&stack)
|| self.use_trident(&stack)
|| self.boost_firework(&stack)
|| self.use_empty_map(&stack)
|| self.use_book(&stack)
// Block items (heads, carved pumpkins) aimed at a block are
// placed first (useItemOn before useItem).
|| (!(info.block.is_some() && block_hit.is_some())
&& self.equip_from_hand(&stack)))
{
return Ok(true);
}
if !on_block && &*stack.item == "minecraft:spyglass" {
self.use_spyglass();
return Ok(true);
}
if !on_block && &*stack.item == "minecraft:bow" {
if self.using.is_none()
&& (self.creative || self.projectile_slot("minecraft:bow").is_some())
{
self.using = Some((self.held_slot(), 0));
}
return Ok(true);
}
// Block foods attempt placement before starting consumption.
if !on_block && (info.block.is_none() || block_hit.is_none()) && self.start_eating(&info) {
return Ok(true);
}
// BoatItem.use also performs its own fluid/block raycast.
if !on_block && self.place_boat(&stack) {
return Ok(true);
}
if let Some(hit) = block_hit
&& (self.launch_firework(hit, &stack)
|| self.place_minecart(hit, &stack)
|| self.place_painting(hit, &stack)
|| self.place_item_frame(hit, &stack)
|| self.place_armor_stand(hit, &stack)
|| self.place_end_crystal(hit, &stack))
{
return Ok(true);
}
if self.use_ender_eye(&stack, block_hit.is_some())? {
return Ok(true);
}
let Some(hit) = block_hit else {
return Ok(false);
};
if info.block.is_none() {
return Ok(false);
}
if !self.may_build() {
// ItemStack.useOn passes in adventure mode; useItem eats.
return Ok(!on_block && self.start_eating(&info));
}
let face = match hit.face {
[0, 1, 0] => Direction::Up,
[0, -1, 0] => Direction::Down,
[0, 0, -1] => Direction::North,
[0, 0, 1] => Direction::South,
[-1, 0, 0] => Direction::West,
_ => Direction::East,
};
// BlockItem.place through the vanilla placement rules.
let ctx = PlaceContext {
clicked_pos: BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
face,
hit: Vec3::new(hit.point[0], hit.point[1], hit.point[2]),
inside: false,
yaw: self.yaw,
pitch: self.pitch,
sneaking: self.keys.contains(&KeyCode::ShiftLeft),
item: stack.item.to_string(),
can_use_game_master_blocks: self.can_use_game_master_blocks(),
};
let outcome = self.with_level(|b, level, ticks| b.place_block(level, ticks, &ctx));
let PlaceOutcome::Placed { pos, state } = outcome else {
self.process_level_events()?;
// BlockItem.useOn: a consumable that could not be placed is used,
// which ItemStack.useOn counts as a use of the item.
if self.start_eating(&info) {
self.stats.add("used", &stack.item, 1);
}
return Ok(true);
};
let target = [pos.x, pos.y, pos.z];
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);
let game_master = self.can_use_game_master_blocks();
self.apply_placed_item(target, &stack, game_master);
// Block.setPlacedBy.
match self.world.block_entities.get(&key) {
Some(BlockEntity::CommandBlock(_)) => {
let data = stack.data().is_some_and(|d| {
d.other(horizon_client::block_entity_item::BLOCK_ENTITY_DATA)
.is_some()
});
self.command_block_placed(key, !data);
}
Some(BlockEntity::Sign(sign)) if !sign.waxed => self.open_sign_editor(key, true),
_ => {}
}
}
self.swing_arm();
// BlockItem.place's sound is among the level events;
// SolidBucketItem.getPlaceSound replaces it with the bucket's own.
let solid_bucket = &*stack.item == "minecraft:powder_snow_bucket";
if solid_bucket {
for event in &mut self.level_events {
if let LevelEvent::Sound { pos: at, sound, .. } = event
&& *at == pos
{
*sound = "minecraft:item.bucket.empty_powder_snow".into();
}
}
}
self.process_level_events()?;
// BlockItem.place: the used statistic and the placed_block trigger.
self.stats.add("used", &stack.item, 1);
self.trigger_block("minecraft:placed_block", target, &stack);
self.check_wither_spawn(target)?;
self.check_golem_spawn(target)?;
self.consume_held();
// SolidBucketItem.useOn: BucketItem.getEmptySuccessItem in hand.
if solid_bucket && !self.creative {
*self.held_mut() = Some(ItemStack::new("minecraft:bucket", 1));
}
Ok(true)
}
/// The player as a block's `useItemOn` / `useWithoutItem` sees them.
fn use_context(&self) -> PlayerContext {
PlayerContext {
yaw: self.yaw,
pitch: self.pitch,
may_build: self.may_build(),
can_eat: self.creative
|| self
.player
.as_ref()
.is_some_and(|p| p.health.food.food < 20),
game_master: self.can_use_game_master_blocks(),
}
}
/// `Consumable.startConsuming` for a held consumable: food needs
/// `Player.canEat` (`Consumable.canConsume`), anything else is always
/// consumed. The right click is held for `consume_seconds`.
fn start_eating(&mut self, info: &horizon_client::items::ItemInfo) -> bool {
if info.consumable.is_none()
|| (info.food.is_some()
&& !self.player.as_ref().is_some_and(|p| {
info.can_always_eat || p.health.food.food < 20 || self.creative
}))
{
return false;
}
if self.using.is_none() {
self.using = Some((self.held_slot(), 0));
}
true
}
fn apply_consume_effect(&mut self, effect: &horizon_client::items::ConsumeEffect) {
use horizon_client::items::ConsumeEffect;
match effect {
ConsumeEffect::ApplyEffects {
effects,
probability,
} => {
// ApplyStatusEffectsConsumeEffect.apply: the user's random
// (the level's stands in, as for every player draw) is drawn
// even at probability 1.
if self.world.random.next_float() < *probability {
for eff in effects {
if let Some(def) = horizon_client::brewing::effect(&eff.id) {
if def.instant {
if let Some(a) =
horizon_client::effects::instant(def.id, eff.amplifier, 1.0)
{
self.apply_effect_action(a);
}
} else {
self.add_player_effect(
horizon_client::effects::EffectInstance::new(
def.id,
eff.duration,
eff.amplifier,
),
);
}
}
}
}
}
ConsumeEffect::ClearAllEffects => {
self.potions.effects.clear();
self.apply_effect_status();
}
ConsumeEffect::RemoveEffects(to_remove) => {
for target in to_remove {
let id = target.trim_start_matches("minecraft:");
self.potions.effects.list.retain(|e| e.id != id);
}
self.apply_effect_status();
}
ConsumeEffect::TeleportRandomly(teleport) => self.teleport_randomly(teleport),
ConsumeEffect::PlaySound(sound) => {
// PlaySoundConsumeEffect: at the user's block position.
let at = self.player.as_ref().map(|p| {
let b = horizon_core::position::BlockPos::containing(p.position);
[b.x, b.y, b.z].map(|v| f64::from(v) + 0.5)
});
self.audio.play(sound, at, 1.0, 1.0);
}
}
}
fn consume_held(&mut self) {
if self.creative {
return;
}
let cell = self.held_mut();
if let Some(s) = cell.as_mut() {
s.count -= 1;
if s.count == 0 {
*cell = None;
}
}
}
fn tick_using(&mut self) {
let Some(hand) = self.used_hand() else {
return;
};
self.with_hand(hand, Self::tick_used_item);
}
/// `LivingEntity.updatingUsingItem` for the item in use, its hand acting.
fn tick_used_item(&mut self) {
let Some((slot, ticks)) = self.using else {
return;
};
let Some(stack) = self.stack_in(slot).cloned() else {
self.using = None;
return;
};
// Switching hotbar slots only ends a main-hand use.
let hand_changed = slot != self.selected && slot != shield::OFFHAND_SLOT;
if !self.right || hand_changed || self.screen != Screen::Playing {
self.using = None;
self.release_used_item(&stack, ticks, hand_changed);
return;
}
let Some(info) = self.res.items().get(&stack.item).cloned() else {
self.using = None;
return;
};
if info.blocks_attacks.is_some() {
// ShieldItem: used for 72000 ticks, i.e. until released.
self.using = Some((slot, ticks + 1));
return;
}
if self.tick_drinking(slot, ticks, &stack) {
return;
}
if &*stack.item == "minecraft:bow" {
self.using = Some((slot, ticks + 1));
return;
}
if &*stack.item == "minecraft:crossbow" {
self.tick_crossbow(slot, ticks, &stack);
return;
}
if &*stack.item == "minecraft:trident" {
self.using = Some((slot, ticks + 1));
return;
}
if &*stack.item == "minecraft:spyglass" {
// SpyglassItem.USE_DURATION, then finishUsingItem.
if ticks + 1 >= 1200 {
self.stop_spyglass();
self.using = None;
} else {
self.using = Some((slot, ticks + 1));
}
return;
}
let Some(consumable) = info.consumable.as_ref() else {
self.using = None;
return;
};
// ItemStack.onUseTick: Consumable.shouldEmitParticlesAndSounds with
// the remaining ticks before this tick counts them down.
let duration = consumable.ticks().max(0) as u32;
let remaining = duration - ticks.min(duration);
let ticks = ticks + 1;
if consumable.should_emit(remaining as i32) {
self.emit_consume(consumable, &stack, 5);
}
if ticks >= duration {
self.using = None;
// ItemStack.finishUsingItem's applyAfterUseComponentSideEffects.
self.apply_use_cooldown(&stack);
self.finish_consuming(&info, consumable, &stack);
} else {
self.using = Some((slot, ticks));
}
}
/// `LivingEntity.releaseUsingItem` (`Item.releaseUsing`) for `stack`,
/// used for `ticks`, its hand acting: a bow or a trident lets go (not
/// when its hand changed), a spyglass stops scoping.
pub(super) fn release_used_item(&mut self, stack: &ItemStack, ticks: u32, hand_changed: bool) {
match &*stack.item {
"minecraft:bow" if !hand_changed => self.release_bow(ticks),
"minecraft:trident" if !hand_changed => self.release_trident(ticks),
"minecraft:spyglass" => self.stop_spyglass(),
_ => {}
}
}
fn tick_mining(&mut self) -> Result<()> {
if self.destroy_delay > 0 {
self.destroy_delay -= 1;
}
if !self.left || self.screen != Screen::Playing {
self.mining = None;
return Ok(());
}
let Some(hit) = self.pick() else {
self.mining = None;
return Ok(());
};
// GameType.isBlockPlacingRestricted: adventure and spectator.
if !self.may_build() {
self.mining = None;
return Ok(());
}
if self.creative {
if self.destroy_delay == 0 {
self.break_block(hit.pos)?;
self.destroy_delay = 5;
}
return Ok(());
}
if self.destroy_delay > 0 {
return Ok(());
}
if self.mining.as_ref().is_none_or(|m| m.pos != hit.pos) {
self.attack_block(hit.pos)?;
self.mining = Some(Mining {
pos: hit.pos,
progress: 0.0,
ticks: 0,
});
}
let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
let facts = self.res.facts().get(state);
if facts.hardness < 0.0 {
return Ok(());
}
// Player.getDestroySpeed / BlockBehaviour.getDestroyProgress.
let held = self.held();
let mut speed = self.res.items().mining_speed(held, &facts.name);
speed = self.modify_destroy_speed(speed);
let player = self.player.as_ref().ok_or("no player")?;
if !player.ground.on_ground {
speed /= 5.0;
}
let eye = self.eye_position().unwrap_or_default();
if self
.res
.facts()
.get(self.world.block(
eye[0].floor() as i32,
eye[1].floor() as i32,
eye[2].floor() as i32,
))
.fluid
== Fluid::Water
{
speed *= self.submerged_mining_speed();
}
let harvest = !facts.requires_tool || self.res.items().correct_for_drops(held, &facts.name);
let progress = if facts.hardness == 0.0 {
1.0
} else {
speed / facts.hardness / if harvest { 30.0 } else { 100.0 }
};
let hit_sound = facts.sounds.clone();
self.swing_arm();
let m = self.mining.as_mut().ok_or("mining")?;
m.progress += progress;
m.ticks += 1;
let crack = (m.pos, hit.face);
if m.ticks % 4 == 1 {
let c = [
f64::from(m.pos[0]) + 0.5,
f64::from(m.pos[1]) + 0.5,
f64::from(m.pos[2]) + 0.5,
];
self.audio.play(
&hit_sound.hit,
Some(c),
(hit_sound.volume + 1.0) / 8.0,
hit_sound.pitch * 0.5,
);
}
self.crack_particle(crack.0, crack.1, state);
let m = self.mining.as_mut().ok_or("mining")?;
// ServerPlayerGameMode breaks a player's block at once only when it is instant (START's
// insta-mine); otherwise it waits for the client's STOP_DESTROY_BLOCK
// (`guest_stop_digging`), never breaking it on its own count. Breaking it here would
// take the block from under the player's crack before the player's client predicts the
// break, so it gets neither particles nor sound.
if m.progress >= 1.0 && (self.lan_acting.is_none() || m.ticks == 1) {
let pos = m.pos;
self.mining = None;
self.break_block(pos)?;
self.destroy_delay = 5;
}
Ok(())
}
/// A column whose surface is a full solid, non-fluid, non-leaf block open to the sky.
fn land_column(&self, x: i32, z: i32) -> Option<i32> {
if self.dim == Dim::Nether {
// Below the bedrock ceiling: a solid floor with two air blocks above.
for y in (32..120).rev() {
let floor = self.res.facts().get(self.world.block(x, y - 1, z));
if floor.full_collision
&& floor.fluid == Fluid::None
&& self.res.facts().is_air(self.world.block(x, y, z))
&& self.res.facts().is_air(self.world.block(x, y + 1, z))
{
return Some(y);
}
}
return None;
}
let mut y = MIN_Y + HEIGHT - 1;
while y > MIN_Y {
let s = self.world.block(x, y, z);
if !self.res.facts().is_air(s) {
let f = self.res.facts().get(s);
let ok = f.full_collision
&& f.fluid == Fluid::None
&& !f.name.contains("leaves")
&& f.hardness >= 0.0;
return ok.then_some(y + 1);
}
y -= 1;
}
None
}
fn spawn_player(&mut self) -> Result<()> {
if self.player.is_some() || self.remote.is_some() {
return Ok(());
}
if let Some((_, target)) = &self.travelling {
if self.win_screen_holds_arrival() {
return Ok(());
}
let (cx, cz) = (
(target.x.floor() as i32) >> 4,
(target.z.floor() as i32) >> 4,
);
self.streaming.center = (cx, cz);
if (-2..=2).all(|dz| (-2..=2).all(|dx| self.streaming.is_lit(cx + dx, cz + dz))) {
let (player, target) = self.travelling.take().ok_or("travel")?;
if let Some(config) = self.respawn_travel.take() {
drop(player);
self.place_respawned(config)?;
} else if self.end_travel {
self.place_after_end_travel(player, target)?;
} else {
self.place_after_travel(player, target)?;
}
}
return Ok(());
}
let saved = self.level.position.map(|p| Vec3::new(p[0], p[1], p[2]));
if self.spawn.is_none() {
self.spawn = self
.level
.spawn
.map(|s| Vec3::new(s[0] + 0.5, s[1], s[2] + 0.5));
}
let feet = if let Some(p) = saved {
let (cx, cz) = ((p.x.floor() as i32) >> 4, (p.z.floor() as i32) >> 4);
self.streaming.center = (cx, cz);
if !(-1..=1).all(|dz| (-1..=1).all(|dx| self.streaming.is_lit(cx + dx, cz + dz))) {
return Ok(());
}
self.level.position = None;
p
} else if self.spawn.is_none() || self.player_spawn.is_some() {
// A new world: its spawn, then the first player around it.
if self.spawn.is_none() {
let Some([x, y, z]) = self.find_world_spawn()? else {
return Ok(());
};
self.spawn = Some(Vec3::new(
f64::from(x) + 0.5,
f64::from(y),
f64::from(z) + 0.5,
));
self.level.spawn = Some([f64::from(x), f64::from(y), f64::from(z)]);
// The world's spawn from the start, not only once saved: a bed set
// before the first save must not become it.
self.level.world_spawn.get_or_insert([x, y, z]);
}
let s = self
.level
.spawn
.unwrap_or_default()
.map(|v| v.floor() as i32);
let Some(feet) = self.find_player_spawn(s)? else {
return Ok(());
};
feet
} else {
let s = self.spawn.unwrap_or_default();
let (cx, cz) = ((s.x.floor() as i32) >> 4, (s.z.floor() as i32) >> 4);
self.streaming.center = (cx, cz);
if !(-1..=1).all(|dz| (-1..=1).all(|dx| self.streaming.is_lit(cx + dx, cz + dz))) {
return Ok(());
}
// WorldSpawn: the stored column, lifted onto its current surface.
let y = self
.land_column(s.x.floor() as i32, s.z.floor() as i32)
.map_or(s.y, f64::from);
Vec3::new(s.x, y.max(s.y), s.z)
};
let mut player = PlayerMotion::new(self.motion, feet)?;
player.yaw = self.yaw;
player.load_saved_state_once(&mut self.restore_player_state, &self.level)?;
let spectator = self.mode == horizon_client::command::args::GameMode::Spectator;
player.may_fly = self.creative || spectator;
player.invulnerable = self.creative || spectator;
player.spectator = spectator;
if spectator {
player.flying = true;
} else if !player.may_fly {
player.flying = false;
}
player.respiration = self.armor[0]
.as_ref()
.map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
player.pitch = self.pitch;
player.glider = self.glider_worn();
// A saved death already dropped inventory/XP and counted the death.
if player.health.dead_or_dying() {
self.screen = Screen::Dead;
self.ui.died_at = Some(Instant::now());
self.ui.death_text = None;
self.capture(false);
}
self.previous_position = feet;
self.player = Some(player);
self.pad.player_replaced();
self.sway = Default::default();
self.apply_equipment();
self.eye = 1.62;
self.previous_eye = 1.62;
self.clock.reset();
self.capture_loaded_world();
Ok(())
}
/// Landing rules (farmland trampling, turtle eggs) wrote or removed the block
/// raw: finish `Level.setBlock`'s neighbour updates, so a crop on trampled
/// farmland breaks. The local player's and every server player's landings.
fn landing_block_updates(&mut self, event: &horizon_client::landing::FallEvent) {
use horizon_client::landing::FallEvent;
let (position, flags) = match *event {
FallEvent::Write {
position, flags, ..
} => (position, flags as i32),
FallEvent::Destroy { position, .. } => (position, level_flags::UPDATE_ALL),
_ => return,
};
self.with_level(|b, level, ticks| b.notify_written(level, ticks, position, flags));
}
fn tick(&mut self) -> Result<()> {
self.tick_debug_keys()?;
self.tick_debug_charts();
if self.remote.is_some() {
return self.tick_remote();
}
// LevelLoadingScreen.tick.
self.loading_progress = match self.loading_reason() {
Some(_) => horizon_client::level_loading::smooth(
self.loading_progress,
self.level_load_progress(),
),
None => 0.0,
};
self.ticks += 1;
self.track_experience_display();
// `/tick freeze` stops the world but not the player.
let running = self.clock.world_runs();
// GameRenderer.tick: a wither's bar darkens the world, then fades.
self.boss_overlay.tick_darken(running);
if running {
self.world.game_time += 1;
if self.ui.rules.bool("advance_weather") {
self.world.weather.tick(&mut self.world.random);
}
self.tick_weather_effects();
}
if self.ticks.is_multiple_of(6000) {
self.save_game_with(false)?;
}
if running {
self.advance_clock();
}
if self.use_delay > 0 {
self.use_delay -= 1;
}
self.tick_totem();
self.update_totem_ready();
self.tick_command_extras();
self.tick_mods();
let camera_eye = self.camera_eye_height();
let stick = self.pad_move();
if self.riding.is_some() && self.player.is_some() {
let playing = self.screen == Screen::Playing;
let held = |k| playing && self.keys.contains(&k);
let keys = Keys {
forward: held(KeyCode::KeyW),
backward: held(KeyCode::KeyS),
left: held(KeyCode::KeyA),
right: held(KeyCode::KeyD),
jump: held(KeyCode::Space),
shift: held(KeyCode::ShiftLeft),
sprint: false,
analog: None,
}
.with_stick(stick.filter(|_| playing));
self.tick_riding(keys)?;
}
let riding = self.riding.is_some();
let entity_collisions = self.player_entity_collisions();
let spin_targets = self.spin_targets();
self.sync_player_body();
let Some(player) = self.player.as_mut() else {
// A dedicated server has no local player: the world still runs.
if self.options.dedicated.is_some() {
return self.tick_world(running);
}
return Ok(());
};
// Hold position until the surrounding terrain exists.
let (cx, cz) = (
(player.position.x.floor() as i32) >> 4,
(player.position.z.floor() as i32) >> 4,
);
if !self.streaming.is_lit(cx, cz) {
return Ok(());
}
let playing = self.screen == Screen::Playing && self.sleeping.is_none();
let held = |k| playing && self.keys.contains(&k);
let keys = Keys {
forward: held(KeyCode::KeyW),
backward: held(KeyCode::KeyS),
left: held(KeyCode::KeyA),
right: held(KeyCode::KeyD),
jump: held(KeyCode::Space),
shift: held(KeyCode::ShiftLeft),
sprint: held(KeyCode::ControlLeft),
analog: None,
}
.with_stick(stick.filter(|_| playing));
if !riding {
self.previous_position = player.position;
}
let spectator = self.mode == horizon_client::command::args::GameMode::Spectator;
player.may_fly = self.creative || spectator;
player.invulnerable = self.creative || spectator;
player.spectator = spectator;
player.spin_targets = spin_targets;
let grounded = player.ground.on_ground;
let before = (
grounded,
[player.velocity.x, player.velocity.y, player.velocity.z],
[player.position.x, player.position.y, player.position.z],
);
if !riding {
MotionWorld {
entities: &entity_collisions,
player,
scene: &mut self.world,
assets: &self.pack.assets,
collision_binding: self.collision,
resources: self.motion,
}
.controlled_simulation_tick(keys)?;
// Player.jumpFromGround: the jump statistic.
if grounded && keys.jump && !player.flying && player.velocity.y > 0.2 {
self.stats.custom("jump", 1);
}
}
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;
let eye_height = if self.sleeping.is_some() {
0.2
} else {
player.dimensions.eye_height
};
self.eye += (camera_eye.unwrap_or(eye_height) - self.eye) * 0.5;
let crouching = player.pose == horizon_client::pose::Pose::Crouching;
self.tick_avatar(before, riding);
self.end_spin_attack(spin_hit);
self.record_combat(&events);
for event in events {
match event {
MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, feet),
MotionEvent::Emission {
state, in_water, ..
} if !crouching => {
let sounds = self.res.facts().get(state).sounds.clone();
// Entity.playStepSound: the block's step sound at 0.15 volume,
// muffled under the swim sound in water.
let (volume, pitch) = if in_water {
(sounds.volume * 0.05, sounds.pitch * 0.8)
} else {
(sounds.volume * 0.15, sounds.pitch)
};
self.audio.play(&sounds.step, Some(feet), volume, pitch);
}
MotionEvent::Swim { volume, pitch } => {
self.audio
.play("minecraft:entity.player.swim", Some(feet), volume, pitch);
}
MotionEvent::Drown => {
// LivingEntity.makeDrownParticles: eight bubbles moving
// with the player.
use horizon_client::particles::{ParticleOptions, ParticleType};
for _ in 0..8 {
let mut triangle = || {
let r = self.particles.random();
r.next_double() - r.next_double()
};
let p = [
feet[0] + triangle(),
feet[1] + triangle(),
feet[2] + triangle(),
];
self.particles.add(
&ParticleOptions::simple(ParticleType::Bubble),
p,
player_velocity,
);
}
}
MotionEvent::BubbleColumnParticle { bubble, position } => {
// ServerLevel.sendParticles: SPLASH (speed 1) or BUBBLE
// (y spread 0.01, speed 0.2), one each.
use horizon_client::particles::{ParticleOptions, ParticleType};
let (kind, spread, speed) = if bubble {
(ParticleType::Bubble, [0.0, 0.01, 0.0], 0.2)
} else {
(ParticleType::Splash, [0.0; 3], 1.0)
};
self.particles.send_particles(
&ParticleOptions::simple(kind),
[position.x, position.y, position.z],
spread,
speed,
1,
);
}
MotionEvent::Fall(horizon_client::landing::FallEvent::Sound {
sound,
volume,
pitch,
..
}) => {
let name = match sound {
horizon_client::landing::SceneSound::BigFall => {
"minecraft:entity.player.big_fall"
}
horizon_client::landing::SceneSound::SmallFall => {
"minecraft:entity.player.small_fall"
}
_ => continue,
};
self.audio.play(name, Some(feet), volume, pitch);
}
MotionEvent::Fall(event) => self.landing_block_updates(&event),
MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
MotionEvent::InsidePortal { pos } => self.player_inside_nether_portal(pos),
MotionEvent::SmashLanding {
state,
position,
fall_distance,
} => self.smash_landing_particles(state, position, fall_distance),
MotionEvent::Splash {
high_speed,
volume,
pitch,
} => {
let name = if high_speed {
"minecraft:entity.player.splash.high_speed"
} else {
"minecraft:entity.player.splash"
};
self.audio.play(name, Some(feet), volume, pitch);
}
MotionEvent::SplashParticle {
bubble,
position,
velocity,
} => {
use horizon_client::particles::{ParticleOptions, ParticleType};
let kind = if bubble {
ParticleType::Bubble
} else {
ParticleType::Splash
};
self.particles.add(
&ParticleOptions::simple(kind),
[position.x, position.y, position.z],
[velocity.x, velocity.y, velocity.z],
);
}
_ => {}
}
}
self.powder_snow_fire()?;
self.tick_totem();
let Some(player) = self.player.as_mut() else {
return Ok(());
};
if player.position.y < f64::from(MIN_Y - 64) {
// Out of the world.
let _ = player.set_health(0.0, false);
}
let dead = player.health.dead_or_dying();
if dead && self.screen != Screen::Dead {
// Inventory.dropAll: every stack thrown in a random direction.
let feet = [player.position.x, player.position.y, player.position.z];
let at = [feet[0], feet[1] + 1.32, feet[2]];
let killer = self.combat_killer_kind();
self.death_message();
// ServerPlayer.die: deaths, and the time-since counters restart.
self.stats.custom("deaths", 1);
self.score_player_died();
if let Some(kind) = killer {
self.stats.add("killed_by", &kind, 1);
let view = horizon_client::advancements::EntityView {
kind,
..Default::default()
};
self.trigger_entity("minecraft:entity_killed_player", "entity", &view);
}
self.stats.reset("custom", "minecraft:time_since_death");
self.stats.reset("custom", "minecraft:time_since_rest");
let reward = self
.experience
.death_reward(self.ui.rules.bool("keep_inventory") || self.spectator());
self.spawn_orbs(feet, reward);
if !self.spectator() {
self.drop_inventory(at);
}
self.audio
.play("minecraft:entity.player.death", Some(at), 1.0, 1.0);
// LivingEntity.die: the LAN guests see the host's death animation.
if let Some(host) = &self.lan {
host.hub.entity_event(host.host_entity, 3, feet);
}
self.screen = Screen::Dead;
self.capture(false);
self.ui.death_time = 0;
} else if dead {
// LivingEntity.tickDeath: 20 ticks after dying the player is
// removed, and Player.remove's inventoryMenu.removed drops what
// the cursor held.
self.ui.death_time += 1;
if self.ui.death_time >= 20
&& let Some(stack) = self.carried.take()
&& let Some(eye) = self.eye_position()
{
self.throw_from_eyes(stack, eye);
}
}
self.tick_world(running)
}
/// What the tick runs after the local player's own update: effects, the
/// world's entities and blocks, and the network hub.
fn tick_world(&mut self, running: bool) -> Result<()> {
self.update_chunk_tickets();
horizon_client::spans::time("tick_effects", || self.tick_effects(running));
// Player.tick's ItemCooldowns.tick for the window's player (a
// server's players count theirs down in `tick_guests`).
self.shield_cooldown = self.shield_cooldown.saturating_sub(1);
self.cooldowns.tick();
horizon_client::spans::time("tick_using", || self.tick_using());
horizon_client::spans::time("tick_hud", || self.tick_hud());
// The player's digging comes in with its packets, before the level
// ticks; ServerLevel.tick then runs the scheduled and random block
// ticks before any entity, so what they drop or spawn (dispensed
// items, popped crops) moves on the tick it appears, as in vanilla.
horizon_client::spans::time("tick_local_hand", || self.tick_local_hand())?;
horizon_client::spans::time("postprocess_chunks", || self.postprocess_chunks())?;
if running {
horizon_client::spans::time("tick_blocks", || self.tick_blocks())?;
}
if running {
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_boats", || self.tick_boats());
horizon_client::spans::time("tick_carts", || self.tick_carts());
horizon_client::spans::time("tick_thunder", || self.tick_thunder());
horizon_client::spans::time("tick_lecterns", || self.tick_lecterns());
horizon_client::spans::time("tick_maps", || self.tick_maps());
horizon_client::spans::time("tick_bolts", || self.tick_bolts());
horizon_client::spans::time("tick_fishing", || self.tick_fishing());
horizon_client::spans::time("tick_tridents", || self.tick_tridents());
horizon_client::spans::time("tick_rockets", || self.tick_rockets());
horizon_client::spans::time("tick_ominous_item_spawners", || {
self.tick_ominous_item_spawners()
});
}
if running {
horizon_client::spans::time("entity_portals", || self.handle_entity_portals());
horizon_client::spans::time("tick_items", || self.tick_items());
horizon_client::spans::time("touch_arrows", || self.touch_arrows());
}
horizon_client::spans::time("spawn_loaded_entities", || self.spawn_loaded_entities());
if running {
horizon_client::spans::time("tick_mobs", || self.tick_mobs())?;
horizon_client::spans::time("recheck_golem_openers", || self.recheck_golem_openers());
horizon_client::spans::time("tick_experience", || self.tick_experience());
horizon_client::spans::time("entity_portals", || {
self.find_entity_portals();
self.resolve_arrivals();
});
}
horizon_client::spans::time("tick_lan", || self.tick_lan(false));
self.tick_friends();
horizon_client::spans::time("tick_hand", || self.tick_hand());
horizon_client::spans::time("tick_sleep", || self.tick_sleep());
horizon_client::spans::time("tick_portal", || self.tick_nether_portal())?;
if running {
horizon_client::spans::time("tick_end", || self.tick_end())?;
}
if running {
horizon_client::spans::time("tick_falling", || self.tick_falling())?;
horizon_client::spans::time("tick_tnt", || self.tick_tnt())?;
}
if running {
horizon_client::spans::time("tick_block_entities", || self.tick_block_entities())?;
horizon_client::spans::time("tick_sculk_entities", || self.tick_sculk_entities());
horizon_client::spans::time("tick_sculk_blocks", || self.tick_sculk_blocks())?;
}
if running {
// ClientLevel.tickBlockEntities (not while paused or frozen):
// chest lids, books, shulker boxes, bells, conduits, heads.
horizon_client::spans::time("tick_block_entity_anims", || {
self.tick_block_entity_anims()
});
horizon_client::spans::time("tick_particles", || self.tick_particles());
}
// ServerBossEvent broadcasts, after this level's entities have ticked.
self.publish_boss_bars();
// Minecraft.handleKeybinds: held use repeats only while no item is in
// use (a raised shield or a drawn bow places and uses nothing).
if self.right
&& self.use_delay == 0
&& self.using.is_none()
&& self.screen == Screen::Playing
&& self.sleeping.is_none()
{
self.use_with_hand()?;
self.use_delay = 4;
}
Ok(())
}
/// Keep the held-key state of toggled sneak and sprint in step with their mapping.
fn sync_toggle(&mut self, slot: usize) {
let key = [KeyCode::ShiftLeft, KeyCode::ControlLeft][slot];
if self.toggles.is_down(slot) {
self.keys.insert(key);
} else {
self.keys.remove(&key);
}
}
/// A key event after rebinding, as the default key of its mapping (the
/// keyboard and controllers both end here).
fn mapped_key(&mut self, key: KeyCode, pressed: bool, repeat: bool) -> Result<()> {
// Sneak and sprint are ToggleKeyMappings: a press (or a key
// repeat) flips them when toggling; only releases reach them
// behind a screen (KeyboardHandler.keyPress).
let toggle = match key {
KeyCode::ShiftLeft => Some((0, self.settings.toggle_crouch)),
KeyCode::ControlLeft => Some((1, self.settings.toggle_sprint)),
_ => None,
};
if let Some((slot, option)) = toggle {
let action = match (pressed, repeat) {
(false, _) => KeyAction::Release,
(_, false) => KeyAction::Press,
(_, true) => KeyAction::Repeat,
};
let screen_open = self.screen != Screen::Playing || self.title.is_some();
self.toggles.key(slot, action, screen_open, option);
self.sync_toggle(slot);
if !pressed {
return Ok(());
}
} else if !pressed {
self.keys.remove(&key);
return Ok(());
} else {
self.keys.insert(key);
}
// KeyboardHandler.keyPress: a repeat (InputConstants.REPEAT) reaches
// Screen.keyPressed and KeyMapping.click like a press, so holding
// key.drop keeps throwing, in game and over a menu slot.
if repeat && key != KeyCode::KeyQ {
return Ok(());
}
self.key_pressed(key)
}
/// `KeyMapping.releaseAll` when a screen opens and
/// `restoreToggleStatesOnScreenClosed` when it closes.
fn track_toggle_screens(&mut self) {
let playing = self.screen == Screen::Playing && self.title.is_none();
if playing == self.was_playing {
return;
}
self.was_playing = playing;
let options = [
self.settings.toggle_crouch,
self.settings.toggle_sprint,
self.settings.toggle_attack,
self.settings.toggle_use,
];
if playing {
self.toggles.screen_closed(options);
} else {
self.toggles.screen_opened(options);
}
self.sync_toggle(0);
self.sync_toggle(1);
self.left = self.toggles.is_down(2);
self.right = self.toggles.is_down(3);
}
/// The options `MouseHandler.turnPlayer` reads.
fn look_options(&self) -> LookOptions {
LookOptions {
sensitivity: f64::from(self.settings.sensitivity),
smooth_camera: self.smooth_camera,
scoping: self.scoping(),
invert_x: self.settings.invert_x,
invert_y: self.settings.invert_y,
}
}
/// `MouseHandler.handleAccumulatedMovement` and `Entity.turn`, once per frame.
/// An agent moving the mouse (`mouse-move`) counts as a grabbed pointer in
/// an active window, as it cannot grab the real one.
fn apply_mouse_look(&mut self) {
let look = self.look_options();
let time = self.started.elapsed().as_secs_f64();
let pointer = self.captured || self.agent_pointer;
let grabbed = pointer && self.screen == Screen::Playing && self.player.is_some();
let active = self.focused || self.agent_pointer;
if let Some((xo, yo)) = self
.mouse
.handle_accumulated_movement(time, active, grabbed, look)
{
let mut rotation = Rotation {
x_rot: self.pitch,
y_rot: self.yaw,
x_rot_o: self.pitch,
y_rot_o: self.yaw,
};
let zoom = self.zoom_turn_scale();
rotation.turn(xo * zoom, yo * zoom);
self.yaw = rotation.y_rot;
self.pitch = rotation.x_rot;
}
}
/// `Minecraft.pause`: a single-player game with a pausing screen open.
fn pauses_game(&self) -> bool {
self.has_singleplayer_server()
&& !self.is_published()
&& self.title.is_none()
&& (matches!(
self.screen,
Screen::Paused
| Screen::Options
| Screen::Stats
| Screen::Advancements
| Screen::WorldOptions
| Screen::Friends
| Screen::CommandBlock
) || self.book.is_some()
|| self.win_screen_pauses())
}
/// `MouseHandler.grabMouse` / `releaseMouse`. Both put the pointer at
/// the window's centre, so a screen opened from gameplay (inventory,
/// chest, pause, chat, sign, book, death) starts with the cursor in the
/// middle instead of wherever the system last left it. Releasing when
/// already released does nothing, so moving from screen to screen keeps
/// the cursor where it is. Like GLFW's `glfwSetCursorPos`, nothing warps
/// while the window is unfocused (losing focus releases the pointer).
fn capture(&mut self, capture: bool) {
// A guest's action (`as_guest`) opens and closes screens on the
// guest's own client: the window's pointer stays the host's (#687).
if self.lan_acting.is_some() {
return;
}
// MouseHandler.grabMouse never captures an inactive window.
if capture && !self.focused {
return;
}
if !capture {
self.stop_mining();
}
// The real pointer takes over from an agent's.
self.agent_pointer = false;
let Some(window) = &self.window else { return };
let size = self.renderer.as_ref().map_or_else(
|| window.inner_size().into(),
|r| [r.config.width, r.config.height],
);
let centre =
winit::dpi::PhysicalPosition::new(f64::from(size[0]) / 2.0, f64::from(size[1]) / 2.0);
let warp = |window: &Window| {
let _ = window.set_cursor_position(centre);
};
if capture {
self.mouse.set_ignore_first_move();
// macOS warps by re-associating the mouse with the pointer,
// which undoes a Locked grab and leaves the pointer free: warp
// first there. Wayland moves a pointer only while it is locked,
// so everywhere else warp after grabbing.
#[cfg(target_os = "macos")]
warp(window);
self.captured = window
.set_cursor_grab(CursorGrabMode::Locked)
.or_else(|_| window.set_cursor_grab(CursorGrabMode::Confined))
.is_ok();
#[cfg(not(target_os = "macos"))]
if self.captured && self.focused {
warp(window);
}
} else {
if self.captured {
// Wayland moves a pointer only as the locked pointer's
// position hint, which the compositor applies as the lock
// goes (sway and Hyprland do): set it before ungrabbing.
// X11, Windows and macOS warp, so warp again once free
// (Wayland refuses that one).
if self.focused {
warp(window);
}
let _ = window.set_cursor_grab(CursorGrabMode::None);
if self.focused {
warp(window);
}
let scale = HudBatch::new(size).scale;
self.cursor = (size[0] as f32 / 2.0 / scale, size[1] as f32 / 2.0 / scale);
} else {
let _ = window.set_cursor_grab(CursorGrabMode::None);
}
self.captured = false;
}
window.set_cursor_visible(!self.captured);
}
/// LevelLoadingScreen.onClose -> Gui.setScreen(null) -> grabMouse.
fn capture_loaded_world(&mut self) {
// Loading may finish after focus was lost or another screen opened.
if self.title.is_none() && self.screen == Screen::Playing {
self.capture(true);
}
}
fn draw_item(&mut 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);
self.draw_item_decorations(batch, stack, x, y, None);
}
/// `extractSlot` of slot `slot` holding `stack` at (x, y): during a quick
/// craft drag a dragged slot shows what it would hold over a white
/// highlight (its count yellow when the slot caps it), and hides while
/// it is the drag's only slot.
fn draw_slot_item(
&mut self,
batch: &mut HudBatch,
drag: Option<&DragView>,
slot: usize,
stack: Option<ItemStack>,
x: f32,
y: f32,
) {
let (stack, capped) = match drag.and_then(|d| d.slots.get(&slot)) {
Some(None) => return,
Some(Some((count, capped))) => {
batch.fill(&self.gui.atlas, x, y, 16.0, 16.0, rgba(255, 255, 255, 128));
let carried = self
.carried
.clone()
.map(|c| ItemStack { count: *count, ..c });
(carried, *capped)
}
None => (stack, false),
};
if let Some(stack) = stack {
self.draw_item_model(batch, &stack, x, y);
let text = capped.then(|| format!("\u{a7}e{}", stack.count));
self.draw_item_decorations(batch, &stack, x, y, text);
}
}
/// `extractCarriedItem`: the carried stack at the cursor, showing what a
/// quick craft drag over several slots leaves in hand.
fn draw_carried(&mut self, batch: &mut HudBatch) {
let Some(mut stack) = self.carried.clone() else {
return;
};
if let Some(left) = self.drag_view().and_then(|d| d.left) {
if left == 0 {
return;
}
stack.count = left;
}
self.draw_item(batch, &stack, self.cursor.0 - 8.0, self.cursor.1 - 8.0);
}
/// The quick craft drag in progress, as the menu engine previews it.
fn drag_view(&mut self) -> Option<DragView> {
let (ty, slots) = self.inv_drag.clone()?;
let mut view = None;
self.menu_session(|menu, env, to_menu| {
let menu_slots: Option<Vec<usize>> = slots.iter().map(|&g| to_menu(g)).collect();
let shown = match menu.quick_craft_preview(env, ty, &menu_slots?) {
Some((shown, left)) => {
let slots = slots.iter().copied().zip(shown).collect();
DragView {
slots,
left: Some(left),
}
}
// A single dragged slot is hidden.
None => DragView {
slots: slots.iter().map(|&g| (g, None)).collect(),
left: None,
},
};
view = Some(shown);
Some(false)
});
view
}
/// Whether a quick craft drag takes `slot`
/// (`shouldAddSlotToQuickCraft`); screens the menu engine doesn't
/// model take every slot.
fn quick_craft_accepts(&mut self, slot: usize, ty: i32, dragged: usize) -> bool {
let mut accepts = true;
self.menu_session(|menu, env, to_menu| {
accepts = to_menu(slot).is_some_and(|s| menu.quick_craft_accepts(env, s, ty, dragged));
Some(false)
});
accepts
}
/// `GuiGraphicsExtractor.itemDecorations`: the count (or `count_text`)
/// and damage bar.
fn draw_item_decorations(
&mut self,
batch: &mut HudBatch,
stack: &ItemStack,
x: f32,
y: f32,
count_text: Option<String>,
) {
// GuiGraphicsExtractor.itemDecorations, laid out at the origin and
// moved to (x, y): the damage bar, the cooldown shade and the count.
let info = self.res.items().get(&stack.item);
let max_damage = info.map_or(0, |info| info.max_damage as i32);
let cooldown =
horizon_client::cooldowns::group(stack, info.and_then(|i| i.use_cooldown.as_ref()));
let partial = self.clock.fraction() as f32;
let decorations = hud_overlays::ItemDecorations {
count: stack.count,
count_text,
bar: hud_overlays::damage_bar(stack.damage as i32, max_damage),
cooldown: self.cooldowns.percent(&cooldown, partial),
};
let mut draws = vec![hud_layout::GuiDraw::Push(vec![
hud_layout::PoseOp::Translate(x, y),
])];
draws.extend(hud_overlays::item_decorations(
0,
0,
&decorations,
&self.gui.atlas.font,
));
draws.push(hud_layout::GuiDraw::Pop);
hud_layout::paint(batch, &self.gui.atlas, &draws);
}
fn hud(&mut self, size: [u32; 2]) -> HudBatch {
// The pack prompt replaces the connecting screen (setScreen), but
// in game it opens over the world.
let mut batch = if self.server_packs.prompt.is_some() && self.player.is_none() {
HudBatch::new(size)
} else {
self.hud_layers(size)
};
self.draw_pack_prompt(&mut batch);
// Gui.extractRenderState: the debug overlay comes after the screen
// and the toasts, so it is over everything, menus included.
self.draw_debug_overlay(&mut batch, size);
self.frame_graph
.draw(self.settings.horizon.overlay, &mut batch, &self.gui.atlas);
self.draw_pad_cursor(&mut batch);
batch
}
fn hud_layers(&mut self, size: [u32; 2]) -> HudBatch {
let mut batch = HudBatch::new(size);
let (w, h) = (batch.width, batch.height);
if self.screen == Screen::Win {
self.draw_win_screen(&mut batch);
return batch;
}
if self.screen == Screen::Options {
self.draw_options(&mut batch);
return batch;
}
if let Some(title) = &mut self.title {
title.poll_backup();
if let Some(sound) = title.update_toast(self.settings.notification_display_time) {
self.audio.play(sound, None, 1.0, 1.0);
}
}
if let Some(title) = &self.title {
title.draw(
&self.gui.atlas,
&mut batch,
self.cursor,
self.settings.file.bool("hideSplashTexts"),
);
return batch;
}
let atlas_ptr: *const HudAtlas = &self.gui.atlas;
let _ = atlas_ptr;
// The ToastManager draws over every screen: a server's packs
// download while the connection screen shows.
if self.remote_overlay(&mut batch) {
self.draw_pack_toasts(&mut batch);
return batch;
}
if let Some(reason) = self.loading_reason() {
self.draw_level_loading(&mut batch, reason);
self.draw_pack_toasts(&mut batch);
return batch;
}
// Hud.extractRenderState: F1 (keyToggleGui) hides camera overlays, the
// crosshair, hotbar, effects, bars, sidebar, action bar, titles and chat;
// the sleep overlay, debug screen and open screens still draw.
let spectator = self.spectator();
let (wi, hi) = (w as i32, h as i32);
let show_hud = !self.ui.hide_gui;
if show_hud {
self.draw_spyglass(&mut batch);
// Hud.extractCrosshair / extractItemHotbar / extractPlayerHealth /
// extractVehicleHealth and the experience bar, laid out by hud_layout.
let indicator = self.settings.attack_indicator;
let delay = horizon_client::attack_strength::delay(self.main_hand_attack_speed());
let strength = self.hand_strength.scale(0.0, self.main_hand_attack_speed());
// The 3D crosshair (F3) takes the 2D one's place.
if self.camera_type.first_person() && !spectator && !self.debug_crosshair() {
let attack = (indicator == 1).then_some(strength);
let full = attack.is_some_and(|a| {
hud_layout::full_attack_indicator(a, delay, self.crosshair_living())
});
let draws = hud_layout::crosshair(wi, hi, attack, full);
hud_layout::paint(&mut batch, &self.gui.atlas, &draws);
}
if !spectator {
let inputs = hud_layout::HotbarInputs {
selected: self.selected as i32,
right_handed: !self.settings.main_hand_left,
offhand: self.offhand.is_some(),
slots: std::array::from_fn(|i| self.inventory[i].as_ref().map(|_| 0.0)),
offhand_pop: 0.0,
attack: (indicator == 2).then_some(strength),
};
let draws = hud_layout::hotbar(wi, hi, &inputs);
hud_layout::paint(&mut batch, &self.gui.atlas, &draws);
for d in &draws {
if let hud_layout::GuiDraw::Item { slot, x, y, .. } = *d {
let stack = if slot == 40 {
self.offhand.clone()
} else {
self.inventory[slot as usize].clone()
};
if let Some(stack) = stack {
self.draw_item(&mut batch, &stack, x as f32, y as f32);
}
}
}
}
self.draw_effect_icons(&mut batch);
// Hud: the action bar and titles draw over the hotbar (nextStratum).
self.draw_boss_bars(&mut batch);
self.draw_extras(&mut batch);
}
if show_hud {
// Hud.nextContextualInfoState: the jump bar, the experience bar or
// the locator bar above the hotbar.
let has_experience = !self.creative && !spectator;
let contextual = horizon_client::locator_bar::ContextualBar::next(
self.waypoints.has_waypoints(),
!spectator && self.jumpable_mount(),
self.mount_jumping(),
has_experience,
self.experience_recent(),
);
use horizon_client::locator_bar::ContextualBar;
// The mount's hearts (and the jump bar).
let vehicle_hearts = if spectator {
0
} else {
self.draw_mount_hud(
&mut batch,
wi,
hi,
contextual == ContextualBar::JumpableVehicle,
)
};
if contextual == ContextualBar::Locator {
let (sprite, [x, y, w, h]) = horizon_client::locator_bar::background(wi, hi);
horizon_client::ui::nine_slice(
&mut batch,
&self.gui.atlas,
sprite,
x as f32,
y as f32,
w as f32,
h as f32,
u32::MAX,
);
}
if !self.creative
&& !spectator
&& let Some(p) = &mut self.player
{
let atlas = &self.gui.atlas;
let width = |s: &str| HudBatch::text_width(atlas, s) as i32;
let draws = hud_layout::experience(
wi,
hi,
self.experience.progress,
self.experience.level,
contextual == ContextualBar::Experience,
&width,
);
hud_layout::paint(&mut batch, atlas, &draws);
let effects = &self.potions.effects;
let kind = if effects.get("poison").is_some() {
hud_layout::HeartKind::Poisoned
} else if effects.get("wither").is_some() {
hud_layout::HeartKind::Withered
} else if p.is_fully_frozen() {
hud_layout::HeartKind::Frozen
} else {
hud_layout::HeartKind::Normal
};
let eye = p.position.y + f64::from(p.dimensions.eye_height);
let under_water = self
.res
.facts()
.get(self.world.block(
p.position.x.floor() as i32,
eye.floor() as i32,
p.position.z.floor() as i32,
))
.fluid
== horizon_client::blocks::Fluid::Water;
let inputs = hud_layout::HealthInputs {
tick: self.ticks as i32,
millis: self.started.elapsed().as_millis() as i64,
health: p.health.health(),
max_health: p.attribute("minecraft:max_health").unwrap_or(20.0) as f32,
absorption: p.health.absorption(),
armor: p
.attribute("minecraft:armor")
.or_else(|_| p.attribute("armor"))
.unwrap_or(0.0) as i32,
food: p.health.food.food,
saturation: p.health.food.saturation,
kind,
regeneration: effects.get("regeneration").is_some(),
hunger: effects.get("hunger").is_some(),
hardcore: self.level.hardcore,
damage_cooldown: p.health.hurt.cooldown > 0,
air: p.air,
max_air: 300,
under_water,
vehicle_hearts,
};
let draws = self.health_hud.layout(&inputs, wi, hi);
hud_layout::paint(&mut batch, atlas, &draws);
}
if contextual == ContextualBar::Locator {
let draws = self.locator_bar_draws(wi, hi);
hud_layout::paint(&mut batch, &self.gui.atlas, &draws);
}
if !spectator {
self.draw_selected_name(&mut batch, !self.creative);
}
}
// Hud.extractSleepOverlay: over all health/food bars, under titles and chat.
let draws = hud_overlays::sleep_overlay(wi, hi, self.sleep_timer as i32);
hud_layout::paint(&mut batch, &self.gui.atlas, &draws);
if show_hud {
self.draw_titles(&mut batch);
self.draw_scoreboard(&mut batch);
self.draw_subtitles(&mut batch);
}
let atlas = &self.gui.atlas;
if show_hud
&& let Some((text, at)) = &self.message
&& at.elapsed() < Duration::from_secs(3)
{
let tw = HudBatch::text_width(atlas, text);
batch.text(atlas, text, (w - tw) / 2.0, h - 59.0, u32::MAX, true);
}
self.draw_chat(&mut batch);
self.draw_tab_list(&mut batch);
// Screen.extractBlurredBackground blurs the world and HUD, while the
// screen's background, widgets, toasts and debug overlay stay sharp.
batch.blur_at = batch.vertices.len() as u32;
match self.screen {
Screen::Paused if self.pause_menu => self.draw_pause_menu(&mut batch),
// PauseScreen(false): only its title, at the top.
Screen::Paused => {
let title = self.translate("menu.paused", "Game Paused");
let tw = HudBatch::text_width(&self.gui.atlas, &title);
batch.text(
&self.gui.atlas,
&title,
((batch.width / 2.0).floor() - (tw / 2.0).floor()).floor(),
10.0,
u32::MAX,
true,
);
}
Screen::GameModeSwitcher => self.draw_gamemode_switcher(&mut batch),
Screen::Dead => self.draw_death_screen(&mut batch),
Screen::Stats => self.draw_stats(&mut batch),
Screen::Advancements => self.draw_advancements(&mut batch),
Screen::WorldOptions => self.draw_world_options(&mut batch),
Screen::Friends => self.draw_friends_screen(&mut batch),
Screen::CommandBlock => self.draw_command_block(&mut batch),
Screen::Inventory => {
self.draw_inventory(&mut batch);
}
Screen::Creative => {
self.draw_creative(&mut batch);
}
Screen::Chat => self.draw_chat_screen(&mut batch),
Screen::Playing | Screen::Options | Screen::Win => {}
}
self.draw_toasts(&mut batch);
self.draw_pack_toasts(&mut batch);
self.remote_hud(&mut batch);
self.draw_sign_editor(&mut batch);
self.draw_book(&mut batch);
batch
}
fn creative_inventory_open(&self) -> bool {
self.screen == Screen::Creative && self.creative_screen.tab().inventory
}
/// An item tab of the creative screen (its ItemPickerMenu).
fn creative_tab_open(&self) -> bool {
self.screen == Screen::Creative && !self.creative_screen.tab().inventory
}
fn inventory_origin(&self, batch: &HudBatch) -> (f32, f32) {
if self.screen == Screen::Creative {
return Self::creative_origin(batch);
}
let (x, y) = batch.centered_origin(176.0, self.screen_height());
(x + self.recipe_book_shift(batch.width), y)
}
/// Slot ids: 0..36 player inventory, 100..109 crafting grid, 200 result.
fn container_kind(&self) -> Option<&BlockEntity> {
self.container
.and_then(|k| self.world.block_entities.get(&k))
}
/// 300.. are the open container's slots.
fn slots(&self) -> Vec<usize> {
if self.creative_inventory_open() {
return Creative::inventory_slots().collect();
}
if self.creative_tab_open() {
return Creative::tab_slots().collect();
}
if let Some(v) = self.station_slots().or_else(|| self.mount_slots()) {
return v;
}
let mut v: Vec<usize> = (0..36).collect();
match self.container_kind() {
Some(BlockEntity::Chest(_)) => v.extend((0..self.container_size()).map(|i| 300 + i)),
Some(BlockEntity::Furnace(_)) => v.extend(300..303),
Some(BlockEntity::Brewing(_)) => v.extend(300..305),
Some(BlockEntity::Crafter(_)) => v.extend(300..310),
Some(
BlockEntity::Sign(_)
| BlockEntity::Jukebox(_)
| BlockEntity::Beacon(_)
| BlockEntity::Lectern(_)
| BlockEntity::Sculk(_)
| BlockEntity::Banner(_)
| BlockEntity::CreakingHeart(_)
| BlockEntity::Spawner(_)
| BlockEntity::TrialSpawner(_)
| BlockEntity::Vault(_)
| BlockEntity::Beehive(_)
| BlockEntity::CommandBlock(_),
) => {}
None => {
v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i));
v.push(200);
if self.craft_size == 2 {
v.extend(500..505);
}
}
}
v
}
/// InventoryMenu / CraftingMenu slot layouts.
fn slot_position(&self, i: usize) -> (f32, f32) {
if self.creative_inventory_open()
&& let Some(position) = Creative::inventory_slot_position(i)
{
return position;
}
if self.creative_tab_open()
&& let Some(position) = Creative::tab_slot_position(i)
{
return position;
}
if let Some(p) = self
.station_slot_position(i)
.or_else(|| self.machine_slot_position(i))
.or_else(|| self.crafter_slot_position(i))
.or_else(|| self.mount_slot_position(i))
{
return p;
}
let table = self.craft_size == 3;
// ContainerScreen (3 rows) shifts the player inventory down by one pixel.
// ChestMenu: the inventory sits `18 * (rows - 3) + 1` lower than the
// 3-row layout of the other menus.
let shift = match self.chest_rows() {
Some(rows) => 1.0 + (rows as f32 - 3.0) * 18.0,
None => 0.0,
};
match i {
0..9 => (8.0 + i as f32 * 18.0, 142.0 + shift),
9..36 => (
8.0 + ((i - 9) % 9) as f32 * 18.0,
84.0 + shift + ((i - 9) / 9) as f32 * 18.0,
),
500..504 => (8.0, 8.0 + (i - 500) as f32 * 18.0),
// InventoryMenu: the shield slot.
504 => (77.0, 62.0),
300..500 => match self.container_kind() {
Some(BlockEntity::Furnace(_)) => {
[(56.0, 17.0), (56.0, 53.0), (116.0, 35.0)][(i - 300).min(2)]
}
_ => (
8.0 + ((i - 300) % 9) as f32 * 18.0,
18.0 + ((i - 300) / 9) as f32 * 18.0,
),
},
200 => {
if table {
(124.0, 35.0)
} else {
(154.0, 28.0)
}
}
_ => {
let g = i - 100;
let (r, c) = (g / self.craft_size, g % self.craft_size);
if table {
(30.0 + c as f32 * 18.0, 17.0 + r as f32 * 18.0)
} else {
(98.0 + c as f32 * 18.0, 18.0 + r as f32 * 18.0)
}
}
}
}
fn slot_at(&self, batch: &HudBatch, x: f32, y: f32) -> Option<usize> {
let (ox, oy) = self.inventory_origin(batch);
self.slots().into_iter().find(|&i| {
let (sx, sy) = self.slot_position(i);
x >= ox + sx && x < ox + sx + 16.0 && y >= oy + sy && y < oy + sy + 16.0
})
}
fn slot_mut(&mut self, i: usize) -> &mut Option<ItemStack> {
if i >= mount_menu::SADDLE {
return self.mount_slot_mut(i);
}
if i >= stations::INPUT {
return self.station_slot_mut(i);
}
if (500..504).contains(&i) {
return &mut self.armor[i - 500];
}
if i == 504 {
return &mut self.offhand;
}
if i >= 300 {
return self.container_slot_mut(i - 300);
}
if (100..109).contains(&i) {
&mut self.craft_grid[i - 100]
} else {
&mut self.inventory[i]
}
}
/// What a slot shows: the crafting result slots are computed.
fn slot_view(&mut self, i: usize) -> Option<ItemStack> {
match i {
200 => self.craft_result(),
309 if matches!(self.container_kind(), Some(BlockEntity::Crafter(_))) => {
self.crafter_result()
}
_ => self.slot_mut(i).clone(),
}
}
fn craft_result(&self) -> Option<ItemStack> {
self.craft_recipe().map(|(_, result)| result)
}
/// The recipe id and result of the crafting grid.
/// `RecipeCraftingHolder.awardUsedRecipes`: a crafted recipe becomes known
/// (special ones never do).
fn award_crafted(&mut self, recipes: &[String]) {
let index = &self.res.stations().recipe_index;
let (_, unlocked) = self.level.recipe_book.add_recipes(index, recipes);
self.recipe_unlocked(&unlocked);
}
fn craft_recipe(&self) -> Option<(String, ItemStack)> {
let n = self.craft_size;
let grid: Vec<Option<ItemStack>> = (0..n * n).map(|i| self.craft_grid[i].clone()).collect();
let scale = |id: i32| self.maps.data.get(&id).map(|m| m.scale);
self.res
.recipes()
.find_with(&grid, n, &scale)
.map(|(name, result)| (name.to_owned(), result))
}
fn draw_inventory_slots(&mut self, batch: &mut HudBatch, ox: f32, oy: f32) {
let drag = self.drag_view();
for i in self.slots() {
let (sx, sy) = self.slot_position(i);
if i == 504 && self.offhand.is_none() {
batch.sprite(
&self.gui.atlas,
"gui/sprites/container/slot/shield",
ox + sx,
oy + sy,
);
}
if (500..504).contains(&i) && self.armor[i - 500].is_none() {
let icon = ["helmet", "chestplate", "leggings", "boots"][i - 500];
batch.sprite(
&self.gui.atlas,
&format!("gui/sprites/container/slot/{icon}"),
ox + sx,
oy + sy,
);
}
let stack = self.slot_view(i);
self.draw_slot_item(batch, drag.as_ref(), i, stack, ox + sx, oy + sy);
}
}
fn draw_inventory(&mut self, batch: &mut HudBatch) {
if self.draw_station(batch) {
return;
}
let (ox, oy) = self.inventory_origin(batch);
{
let atlas = &self.gui.atlas;
batch.fill(
atlas,
0.0,
0.0,
batch.width,
batch.height,
rgba(16, 16, 16, 160),
);
let part = |batch: &mut HudBatch,
name: &str,
sx: f32,
sy: f32,
w: f32,
h: f32,
dx: f32,
dy: f32| {
if let Some(mut r) = atlas.sprites.get(name).copied() {
let (du, dv) = ((r.u1 - r.u0) / r.w as f32, (r.v1 - r.v0) / r.h as f32);
r.u0 += sx * du;
r.v0 += sy * dv;
r.u1 = r.u0 + w * du;
r.v1 = r.v0 + h * dv;
batch.rect_uv(dx, dy, w, h, r, u32::MAX);
}
};
let grey = rgba(64, 64, 64, 255);
match self
.container
.and_then(|k| self.world.block_entities.get(&k))
{
Some(BlockEntity::Chest(_)) if self.draw_machine_screen(batch, ox, oy) => {}
Some(BlockEntity::Chest(_)) => self.draw_chest_screen(batch, ox, oy),
Some(BlockEntity::Furnace(f)) => {
let (tex, title) = match f.kind {
horizon_client::containers::FurnaceKind::Furnace => {
("gui/container/furnace", "Furnace")
}
horizon_client::containers::FurnaceKind::BlastFurnace => {
("gui/container/blast_furnace", "Blast Furnace")
}
horizon_client::containers::FurnaceKind::Smoker => {
("gui/container/smoker", "Smoker")
}
};
part(batch, tex, 0.0, 0.0, 176.0, 166.0, ox, oy);
let title = &self.container_title(title.to_owned());
let tw = HudBatch::text_width(atlas, title);
batch.text(atlas, title, ox + (176.0 - tw) / 2.0, oy + 6.0, grey, false);
batch.text(atlas, "Inventory", ox + 8.0, oy + 72.0, grey, false);
if f.lit_remaining > 0 {
// AbstractFurnaceScreen: flame height ceil(lit * 13) + 1.
let total = if f.lit_total == 0 { 200 } else { f.lit_total };
let h = ((f.lit_remaining as f32 / total as f32) * 13.0).ceil() + 1.0;
part(
batch,
"gui/sprites/container/furnace/lit_progress",
0.0,
14.0 - h,
14.0,
h,
ox + 56.0,
oy + 36.0 + 14.0 - h,
);
}
if f.cooking_timer > 0 && f.cooking_total > 0 {
let w = ((f.cooking_timer as f32 / f.cooking_total as f32) * 24.0).ceil();
part(
batch,
"gui/sprites/container/furnace/burn_progress",
0.0,
0.0,
w,
16.0,
ox + 79.0,
oy + 34.0,
);
}
}
Some(BlockEntity::Brewing(_)) => {}
Some(BlockEntity::Crafter(_)) => self.draw_crafter_screen(batch, ox, oy),
Some(
BlockEntity::Sign(_)
| BlockEntity::Jukebox(_)
| BlockEntity::Beacon(_)
| BlockEntity::Lectern(_)
| BlockEntity::Sculk(_)
| BlockEntity::Banner(_)
| BlockEntity::CreakingHeart(_)
| BlockEntity::Spawner(_)
| BlockEntity::TrialSpawner(_)
| BlockEntity::Vault(_)
| BlockEntity::Beehive(_)
| BlockEntity::CommandBlock(_),
) => {}
None if self.mount_active() => self.draw_mount_background(batch, ox, oy),
None => {
let texture = if self.craft_size == 3 {
"gui/container/crafting_table"
} else {
"gui/container/inventory"
};
part(batch, texture, 0.0, 0.0, 176.0, 166.0, ox, oy);
let (title, tx) = if self.craft_size == 3 {
("Crafting", 29.0)
} else {
("Crafting", 97.0)
};
batch.text(atlas, title, ox + tx, oy + 6.0, grey, false);
if self.craft_size == 3 {
batch.text(atlas, "Inventory", ox + 8.0, oy + 72.0, grey, false);
}
}
}
}
if self.container.is_none() && self.craft_size != 3 && !self.mount_active() {
self.draw_inventory_player(batch, ox, oy);
}
self.draw_inventory_slots(batch, ox, oy);
self.draw_sort_buttons(batch, ox, oy);
self.draw_recipe_book(batch);
if let Some(slot) = self.slot_at(batch, self.cursor.0, self.cursor.1) {
let (sx, sy) = self.slot_position(slot);
batch.fill(
&self.gui.atlas,
ox + sx,
oy + sy,
16.0,
16.0,
rgba(255, 255, 255, 128),
);
}
self.draw_carried(batch);
self.draw_slot_tooltip(batch);
if self.container.is_none() && self.craft_size == 2 && !self.mount_active() {
self.draw_inventory_effects(batch, (ox, oy), 176);
}
}
pub(super) fn close_container(&mut self) {
self.close_station();
self.mount_closed();
self.recipe_ui.reset_screen();
if self.remote.is_some() {
return self.remote_close_container();
}
let mut returned: Vec<ItemStack> = self.carried.take().into_iter().collect();
returned.extend(self.craft_grid.iter_mut().filter_map(Option::take));
for stack in returned {
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);
}
}
self.craft_size = 2;
self.craft_table = None;
if let Some(key) = self.container.take() {
self.container_opener_event(key, false);
self.post_block_game_event(
"minecraft:container_close",
[key.0, key.1, key.2],
Some(horizon_client::mobs::Who::Player),
None,
);
let name = self
.res
.facts()
.get(self.world.block(key.0, key.1, key.2))
.name
.clone();
let sound = if storage::is_shulker_box(&name) {
Some("minecraft:block.shulker_box.close")
} else if &*name == "minecraft:ender_chest" {
Some("minecraft:block.ender_chest.close")
} else if name.contains("chest") {
Some("minecraft:block.chest.close")
} else if &*name == "minecraft:barrel" {
Some("minecraft:block.barrel.close")
} else {
None
};
if let Some(sound) = sound {
self.audio.play(
sound,
Some([
f64::from(key.0) + 0.5,
f64::from(key.1) + 0.5,
f64::from(key.2) + 0.5,
]),
0.5,
1.0,
);
}
self.world.modified.insert((key.0 >> 4, key.2 >> 4));
}
self.close_ender_chest();
self.close_cart_container();
}
/// `quickMoveStack` of the open plain menu for a shift-click.
fn inventory_quick_move(&mut self, slot: usize) -> bool {
self.menu_click(Some(slot), 0, horizon_client::menu::Input::QuickMove)
}
/// `AbstractContainerMenu.clicked` on the open inventory, crafting table,
/// chest, hopper, dispenser or furnace menu, run by the verified menu
/// engine (`horizon_client::menu`). `slot` None is outside the window.
/// False when the open screen is not one the engine models.
fn menu_click(
&mut self,
slot: Option<usize>,
button: i32,
input: horizon_client::menu::Input,
) -> bool {
if let Some(slot) = slot
&& slot >= Creative::DISPLAY
&& self.creative_tab_open()
{
self.creative_display_click(slot, button, input);
return true;
}
self.menu_ops(&[(slot, button, input)])
}
/// A click on an item tab's display slot: the screen's own handling
/// (`creative::click_display`), never the menu's.
fn creative_display_click(
&mut self,
slot: usize,
button: i32,
input: horizon_client::menu::Input,
) {
use horizon_client::creative::{DisplayClick, click_display};
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 items = self.creative_screen.items(&self.pack.names);
let first = self.creative_screen.first_row(&self.pack.names);
let shown = items.get(first * 9 + slot - Creative::DISPLAY);
let catalog = self.res.items();
let max = |s: &ItemStack| catalog.get(&s.item).map_or(64, |i| i.max_stack);
match click_display(&mut self.carried, shown, max, button, input) {
DisplayClick::Hotbar(i, stack) => self.inventory[i] = Some(stack),
DisplayClick::Drop(stack) => self.player_drop(stack),
DisplayClick::Nothing => {}
}
}
/// Several clicks on one menu instance (a quick craft drag is three).
fn menu_ops(&mut self, ops: &[(Option<usize>, i32, horizon_client::menu::Input)]) -> bool {
use horizon_client::menu::Input;
if self.remote.is_some() && self.screen == Screen::Inventory {
// On a server the clicks are the server's: predicted and sent.
return self.remote_menu_ops(ops);
}
if let [(Some(slot), button, input)] = ops {
self.crafter_slot_clicked(*slot, *button, *input);
}
let ops = ops.to_vec();
self.menu_session(move |menu, env, to_menu| {
let mut clicks = Vec::new();
for &(slot, button, input) in &ops {
let menu_slot = match slot {
Some(g) => {
if g == 200 && input != Input::QuickMove {
return None;
}
match to_menu(g) {
Some(i) => i as i32,
None => return None,
}
}
None => -999,
};
clicks.push((menu_slot, button, input));
}
for (menu_slot, button, input) in clicks {
if menu.click(env, menu_slot, button, input).is_err() {
// Vanilla's server throws: nothing of this click is kept.
return Some(false);
}
}
Some(true)
})
}
/// A sound a menu click made the player play (a bundle's insert or
/// remove): `Entity.playSound` at the player.
pub(super) fn player_menu_sound(&mut self, sound: &str) {
let Some(p) = self.player.as_ref() else {
return;
};
let at = [p.position.x, p.position.y, p.position.z];
let (volume, pitch) = if sound == horizon_client::bundle::INSERT_FAIL {
(1.0, 1.0)
} else {
(0.8, 0.8 + self.world.random.next_float() * 0.4)
};
self.audio.play(sound, Some(at), volume, pitch);
}
/// The open menu as the verified engine (`horizon_client::menu`): the
/// game's slots are copied in, `run` acts on it, and the slots, carried
/// stack, menu data and drops are copied back when it returns Some(true)
/// (Some(false): handled, nothing kept; None: not handled). False when the
/// open screen is not one the engine models or `run` did not handle it.
pub(super) fn menu_session(
&mut self,
run: impl FnOnce(
&mut horizon_client::menu::Menu,
&horizon_client::menu::Env,
&dyn Fn(usize) -> Option<usize>,
) -> Option<bool>,
) -> bool {
use horizon_client::menu::{Env, Kind, Menu};
#[derive(Clone, Copy)]
struct Map {
container: usize,
table: bool,
cells: usize,
plain: bool,
}
impl Map {
fn main(&self) -> usize {
match (self.plain, self.table) {
(false, _) => self.container,
(true, true) => 10,
(true, false) => 9,
}
}
fn to_menu(self, g: usize) -> Option<usize> {
let main = self.main();
if self.plain {
match g {
200 => Some(0),
100..109 if g - 100 < self.cells => Some(1 + g - 100),
500..504 if !self.table => Some(5 + g - 500),
504 if !self.table => Some(45),
9..36 => Some(main + g - 9),
0..9 => Some(main + 27 + g),
_ => None,
}
} else {
match g {
300.. if g < 300 + self.container => Some(g - 300),
9..36 => Some(main + g - 9),
0..9 => Some(main + 27 + g),
_ => None,
}
}
}
fn to_game(self, i: usize) -> Option<usize> {
let main = self.main();
if self.plain {
match i {
0 => None,
1..=9 if i - 1 < self.cells => Some(100 + i - 1),
5..9 if !self.table => Some(500 + i - 5),
45 if !self.table => Some(504),
_ if i >= main && i < main + 27 => Some(9 + i - main),
_ if i >= main + 27 && i < main + 36 => Some(i - main - 27),
_ => None,
}
} else if i < self.container {
Some(300 + i)
} else if i < self.container + 27 {
Some(9 + i - self.container)
} else {
Some(i - self.container - 27)
}
}
}
// Menu slot -> game slot, for every menu slot.
let mut plain_map = None;
let crafter_open = matches!(self.container_kind(), Some(BlockEntity::Crafter(_)));
let loom_open = self
.station
.as_ref()
.is_some_and(|s| s.kind == stations::Kind::Loom);
let merchant_open = self
.station
.as_ref()
.is_some_and(|s| s.kind == stations::Kind::Merchant);
let stonecutter_open = self
.station
.as_ref()
.is_some_and(|s| s.kind == stations::Kind::Stonecutter);
let station_kind = self.station.as_ref().map(|s| s.kind);
let grindstone_open = station_kind == Some(stations::Kind::Grindstone);
let cartography_open = station_kind == Some(stations::Kind::Cartography);
let anvil_open = station_kind == Some(stations::Kind::Anvil);
let smithing_open = station_kind == Some(stations::Kind::Smithing);
let enchanting_open = station_kind == Some(stations::Kind::Enchanting);
let beacon_open = station_kind == Some(stations::Kind::Beacon);
let (kind, game_of): (Kind, Vec<Option<usize>>) = if self.creative_tab_open() {
// ItemPickerMenu: the display slots (clicked by the screen), then the hotbar.
let mut v = vec![None; 45];
v.extend((0..9).map(Some));
(Kind::ItemPicker, v)
} else if let Some(columns) = self
.mount_menu_columns()
.filter(|_| self.remote.is_some() && self.mount_active())
{
// A server's HorseInventoryMenu: the saddle, the body armour,
// the chest, then the inventory.
let mut v = vec![Some(mount_menu::SADDLE), Some(mount_menu::ARMOR)];
v.extend((0..columns * 3).map(|i| Some(mount_menu::CHEST + i)));
v.extend((9..36).chain(0..9).map(Some));
(Kind::Mount(columns), v)
} else if merchant_open {
// MerchantMenu: two payment slots, the result, then the inventory.
let mut v: Vec<Option<usize>> = vec![
Some(stations::INPUT),
Some(stations::INPUT + 1),
Some(stations::RESULT),
];
v.extend((9..36).chain(0..9).map(Some));
(Kind::Merchant, v)
} else if crafter_open {
// CrafterMenu: the grid, the inventory, then the result.
let mut v: Vec<Option<usize>> = (300..309).map(Some).collect();
v.extend((9..36).chain(0..9).map(Some));
v.push(None);
(Kind::CrafterBlock, v)
} else if loom_open {
// LoomMenu: banner, dye, pattern, result, then the inventory.
let mut v: Vec<Option<usize>> = (0..3).map(|i| Some(stations::INPUT + i)).collect();
v.push(Some(stations::RESULT));
v.extend((9..36).chain(0..9).map(Some));
(Kind::Loom, v)
} else if stonecutter_open {
// StonecutterMenu: the input, the result, then the inventory.
let mut v = vec![Some(stations::INPUT), Some(stations::RESULT)];
v.extend((9..36).chain(0..9).map(Some));
(Kind::Stonecutter, v)
} else if grindstone_open || cartography_open {
// GrindstoneMenu and CartographyTableMenu: the two inputs, the
// result, then the inventory.
let mut v = vec![
Some(stations::INPUT),
Some(stations::INPUT + 1),
Some(stations::RESULT),
];
v.extend((9..36).chain(0..9).map(Some));
let kind = if grindstone_open {
Kind::Grindstone
} else {
Kind::Cartography
};
(kind, v)
} else if enchanting_open {
// EnchantmentMenu: the item, the lapis, then the inventory.
let mut v = vec![Some(stations::INPUT), Some(stations::INPUT + 1)];
v.extend((9..36).chain(0..9).map(Some));
(Kind::Enchanting, v)
} else if beacon_open {
// BeaconMenu: the payment, then the inventory.
let mut v = vec![Some(stations::INPUT)];
v.extend((9..36).chain(0..9).map(Some));
(Kind::Beacon, v)
} else if anvil_open || smithing_open {
// ItemCombinerMenu: the inputs, the result, then the inventory.
let inputs = if anvil_open { 2 } else { 3 };
let mut v: Vec<Option<usize>> =
(0..inputs).map(|i| Some(stations::INPUT + i)).collect();
v.push(Some(stations::RESULT));
v.extend((9..36).chain(0..9).map(Some));
(
if anvil_open {
Kind::Anvil
} else {
Kind::Smithing
},
v,
)
} else {
let (kind, map) = if self.container.is_some() {
let size = self.container_size();
let (kind, count) = match self.container_kind() {
Some(BlockEntity::Chest(_)) => {
let shulker = self.container.is_some_and(|k| {
let id = self.world.block(k.0, k.1, k.2);
storage::is_shulker_box(&self.res.facts().get(id).name)
});
let kind = match size {
5 => Kind::Hopper,
9 => Kind::Dispenser,
27 if shulker => Kind::Shulker,
n => Kind::Chest((n / 9).clamp(1, 6)),
};
(kind, size)
}
Some(BlockEntity::Brewing(_)) => (Kind::Brewing, 5),
Some(BlockEntity::Furnace(f)) => (
Kind::Furnace(
match f.kind.recipe_type().trim_start_matches("minecraft:") {
"blasting" => "blasting",
"smoking" => "smoking",
_ => "smelting",
},
),
3,
),
_ => return false,
};
let map = Map {
container: count,
table: false,
cells: 0,
plain: false,
};
(kind, map)
} else if self.station.is_none() && !self.mount_active() {
let table = self.craft_size == 3;
let map = Map {
container: 0,
table,
cells: self.craft_size * self.craft_size,
plain: true,
};
(
if table {
Kind::Crafting
} else {
Kind::Inventory
},
map,
)
} else {
return false;
};
let total = Menu::new(kind).slot_count();
plain_map = Some(map);
(kind, (0..total).map(|i| map.to_game(i)).collect())
};
// The plain map also takes the crafting result slot (a shift-click on it).
let to_menu = |g: usize| match plain_map {
Some(map) => map.to_menu(g),
None => game_of.iter().position(|x| *x == Some(g)),
};
let mut menu = Menu::new(kind);
if matches!(kind, Kind::Mount(_)) {
menu.mount = self.mount_menu_entity();
}
let total = menu.slot_count();
let before: Vec<Option<ItemStack>> = game_of
.iter()
.map(|g| g.and_then(|g| self.slot_mut(g).clone()))
.collect();
let carried = self.carried.clone();
let creative = self.creative;
// CreativeModeInventoryScreen clicks the menu itself and sends every
// changed slot, which the server sets by player.
let equipment_before = (self.screen == Screen::Creative).then(|| self.player_equipment());
let station_menu = self.station.as_ref().map(|s| {
(
s.loom.selected.map_or(-1, |i| i as i32),
s.loom.patterns.clone(),
)
});
let stone = self
.station
.as_ref()
.map(|s| (s.selected.map_or(-1, |i| i as i32), s.stone.clone()));
let crafter_data = match self.container_kind() {
Some(BlockEntity::Crafter(c)) => Some((c.disabled, c.triggered)),
_ => None,
};
// The merchant's session, lent to the menu for this click.
let mut session = self
.station
.as_ref()
.and_then(|s| s.merchant.as_ref())
.map(|m| (m.session.clone(), m.mob));
if let Some((s, mob)) = session.as_mut() {
self.merchant_sync_in(s, *mob);
}
// The cartography table reads and makes the level's maps; a
// server's (the client menu's ContainerLevelAccess.NULL) doesn't.
let level_maps = (kind == Kind::Cartography && self.remote.is_none()).then(|| {
let held: Vec<ItemStack> = before
.iter()
.flatten()
.chain(self.inventory.iter().flatten())
.chain(self.carried.iter())
.cloned()
.collect();
self.level_maps(&held)
});
let next_map = if merchant_open { self.peek_map_id() } else { 0 };
let tag = |t: &str| self.structure_tag(t);
let maps = trading::GameMaps {
terrain: self.end.locator(),
structure_tag: &tag,
made: Default::default(),
next_id: std::cell::Cell::new(next_map),
};
let trade_env = horizon_client::merchant::TradeEnv {
trades: &self.res.stations().trades,
enchantments: &self.res.stations().enchantments,
maps: Some(&maps),
};
let env = Env {
items: self.res.items(),
recipes: self.res.recipes(),
brewing: &self.res.stations().brewing,
banners: &self.res.stations().banners,
station_recipes: &self.res.stations().recipes,
enchantments: &self.res.stations().enchantments,
names: &self.pack.names,
trade: Some(&trade_env),
maps: level_maps
.as_ref()
.map(|m| m as &dyn horizon_client::menu::Maps),
};
menu.creative = creative;
menu.selected = self.selected;
menu.levels = self.experience.level;
if anvil_open {
// The rename box as AnvilScreen.onNameChanged gives it to the menu.
menu.anvil.name = self.station.as_ref().map(|s| self.anvil_item_name(s));
}
for (i, stack) in before.iter().enumerate() {
menu.set_slot(&env, i, stack.clone());
}
// The off hand is part of the inventory even when the menu has no slot for it.
let offhand_mapped = game_of.contains(&Some(504));
if !offhand_mapped {
menu.set_player_item(40, self.offhand.clone());
}
menu.settle(&env);
if kind == Kind::Loom
&& let Some((selected, patterns)) = station_menu
{
// The menu's state between clicks: what set_slot recomputed is replaced.
menu.data[0] = selected;
menu.loom_patterns = patterns;
menu.set_slot(&env, 3, before[3].clone());
}
if kind == Kind::Stonecutter
&& let Some((selected, state)) = stone
{
// The same: the list and selection between clicks, then the result.
menu.data[0] = selected;
menu.stone = state;
menu.set_slot(&env, 1, before[1].clone());
}
if kind == Kind::Enchanting
&& let Some(s) = self.station.as_ref()
{
// The offers between clicks (what copying the slots in flagged is not a change).
menu.enchant_changed = false;
for i in 0..3 {
menu.data[i] = s.offers.costs[i];
menu.data[7 + i] = s.offers.clues[i].as_ref().map_or(-1, |(_, l)| *l as i32);
}
menu.data[3] = self.level.xp_seed;
}
if let Some((disabled, triggered)) = crafter_data {
for (i, d) in disabled.iter().enumerate() {
menu.data[i] = i32::from(*d);
}
menu.data[9] = i32::from(triggered);
}
menu.carried = carried;
menu.drops.clear();
if kind == Kind::Merchant {
// Attached after the slots were set: setting them is not a click.
menu.merchant = session.map(|(s, _)| s);
}
let outcome = run(&mut menu, &env, &to_menu);
let made = maps.made.take();
match outcome {
None => return false,
Some(false) => return true,
Some(true) => {}
}
// On a server the clicks only predict: the server drops, crafts and
// makes maps itself.
let predicting = self.remote.is_some();
if !predicting {
self.register_exploration_maps(made);
}
if let Some(s) = menu.merchant.take() {
self.merchant_sync_out(s);
}
let after: Vec<Option<ItemStack>> = (0..total).map(|i| menu.slot(i).cloned()).collect();
let carried = menu.carried.take();
let dropped = std::mem::take(&mut menu.dropped);
let sounds = std::mem::take(&mut menu.sounds);
// A bundle's sounds are the player's own (`Entity.playSound`): the
// client plays them as it clicks, predicting or not.
for sound in std::mem::take(&mut menu.player_sounds) {
self.player_menu_sound(sound);
}
let crafted = std::mem::take(&mut menu.crafted);
let equipped = std::mem::take(&mut menu.equipped);
for (i, stack) in after.into_iter().enumerate() {
if let Some(g) = game_of[i] {
*self.slot_mut(g) = stack;
}
}
self.carried = carried;
if !offhand_mapped {
self.offhand = menu.player_item(40).cloned();
}
if !predicting {
for stack in dropped {
self.player_drop(stack);
}
self.award_crafted(&crafted);
}
if kind == Kind::Loom {
if let Some(s) = self.station.as_mut() {
s.loom.selected = usize::try_from(menu.data[0]).ok();
s.loom.patterns = std::mem::take(&mut menu.loom_patterns);
}
// A server's loom plays its own sounds (the client's menu has no level).
for sound in sounds.into_iter().filter(|_| !predicting) {
self.station_sound(sound);
}
self.loom_screen_changed();
} else if kind == Kind::Cartography {
for sound in sounds.into_iter().filter(|_| !predicting) {
self.station_sound(sound);
}
} else if kind == Kind::Stonecutter {
if let Some(s) = self.station.as_mut() {
s.selected = usize::try_from(menu.data[0]).ok();
s.stone = std::mem::take(&mut menu.stone);
s.stonecutter_changed();
}
for sound in sounds.into_iter().filter(|_| !predicting) {
self.station_sound(sound);
}
}
if let Some(amount) = menu.ground.take().filter(|_| !predicting)
&& let Some(pos) = self.station.as_ref().map(|s| s.pos)
{
self.grindstone_taken(pos, amount);
}
if kind == Kind::Anvil || kind == Kind::Smithing {
self.combiner_session_end(&menu, predicting);
}
if kind == Kind::Enchanting && (menu.enchant_changed || before[0] != menu.slot(0).cloned())
{
// EnchantmentMenu.slotsChanged: new offers for the item.
self.station_changed();
}
if kind == Kind::CrafterBlock
&& let Some(BlockEntity::Crafter(c)) = self
.container
.and_then(|k| self.world.block_entities.get_mut(&k))
{
for (i, d) in c.disabled.iter_mut().enumerate() {
*d = menu.data[i] == 1;
}
}
if matches!(kind, Kind::Furnace(_))
&& let Some(BlockEntity::Furnace(f)) = self
.container
.and_then(|k| self.world.block_entities.get_mut(&k))
{
// AbstractFurnaceBlockEntity.setItem: only a new input restarts cooking.
f.input_clicked(self.res.recipes(), before[0].clone());
}
match equipment_before {
Some(before) => self.player_equipment_changed(&before),
None => {
for (slot, stack) in equipped {
self.player_equipped(slot, stack.as_ref());
}
}
}
self.apply_equipment();
if let Some(maps) = level_maps {
self.register_made_maps(maps);
}
true
}
/// `CreativeModeInventoryScreen.keyPressed` on the search tab: a hotbar
/// key over a slot swaps before the search box sees it.
fn search_tab_hotbar_key(&mut self, code: KeyCode) -> bool {
use horizon_client::creative::{Hover, search_key_swaps};
let hotbar_key = HOTBAR_DIGITS.contains(&code);
let numeric = hotbar_key || NUMERIC_KEYS.contains(&code);
if !numeric {
return false;
}
let Some(size) = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
else {
return false;
};
let batch = HudBatch::new(size);
let hover = match self.slot_at(&batch, self.cursor.0, self.cursor.1) {
None => Hover::Nothing,
Some(slot) if slot >= Creative::DISPLAY => {
let first = self.creative_screen.first_row(&self.pack.names);
let shown = self.creative_screen.items(&self.pack.names).len();
Hover::Display {
filled: first * 9 + slot - Creative::DISPLAY < shown,
}
}
Some(_) => Hover::Slot,
};
search_key_swaps(numeric, hotbar_key, hover, self.carried.is_some())
&& self.inventory_hotkey(code)
}
/// Number keys, F and Q over a slot of the open menu: SWAP with a hotbar
/// slot or the off hand, THROW one or the whole stack.
fn inventory_hotkey(&mut self, key: KeyCode) -> bool {
use horizon_client::menu::Input;
let Some(size) = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
else {
return false;
};
let batch = HudBatch::new(size);
let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else {
return false;
};
let digit = HOTBAR_DIGITS.iter().position(|k| *k == key);
let done = match (digit, key) {
(Some(n), _) => self.menu_click(Some(slot), n as i32, Input::Swap),
(None, KeyCode::KeyF) => self.menu_click(Some(slot), 40, Input::Swap),
(None, KeyCode::KeyQ) => {
let all = drop_whole_stack(&self.physical_keys);
self.menu_click(Some(slot), i32::from(all), Input::Throw)
}
_ => false,
};
if done && let Some(key) = self.container {
self.container_changed(key);
}
done
}
/// The plain inventory mouse press: starts a quick craft drag when a
/// stack is held, gathers on a double click, else the normal click.
fn inventory_press(&mut self, right: bool) {
use horizon_client::container_screen::Target;
use horizon_client::menu::Input;
if !right && self.sort_press() {
return;
}
let (slot, outside) = self.inventory_target();
let shift = self.has_shift_down();
let target = Target::of(slot, outside);
let input = self.inv_clicks.press(
&target,
Self::screen_button(right),
self.carried.is_none(),
shift,
false,
);
if outside {
// slotId -999: an empty hand throws nothing; a carried stack
// starts a drag whose release drops it.
match input {
Some(input) => self.throw_click(right, input),
None if self.inv_clicks.quick_crafting().is_some() => {
self.inv_drag = Some((i32::from(right), Vec::new()));
}
None => {}
}
return;
}
if self.tweak_press(slot, right, shift) {
return;
}
if let Some(slot) = slot
&& shift
&& slot != 200
{
let now = std::time::Instant::now();
let double = self.last_inv_click.is_some_and(|(at, last, was_right)| {
last == slot && was_right == right && now.duration_since(at).as_millis() < 250
});
self.last_inv_click = Some((now, slot, right));
// mouseClicked's QUICK_MOVE (and Horizon's at-press QUICK_MOVE
// of a carried stack, mouseReleased's in vanilla) remember the
// stack it moves.
if input == Some(Input::QuickMove) || (self.carried.is_some() && !double) {
self.last_quick_moved = self.slot_view(slot);
}
if double && !right {
// mouseReleased: every stack of lastQuickMoved's item in the
// clicked slot's container is quick-moved.
if let Some(input) = input
&& !self.menu_click(Some(slot), 0, input)
{
// A screen the menu engine doesn't model: its own click.
self.click_inventory(right);
return;
}
if let Some(moved) = self.last_quick_moved.clone() {
if self.remote.is_some() {
self.remote_quick_move_all(slot, &moved);
} else {
self.menu_session(|menu, env, to_menu| {
Some(menu.quick_move_all(env, to_menu(slot)?, &moved).is_ok())
});
}
}
self.last_inv_click = None;
self.inv_clicks.skip_release();
return;
}
}
if let Some(slot) = slot
&& !shift
&& slot != 200
{
// An item tab's display slots take no drags or PICKUP_ALL.
let display = slot >= Creative::DISPLAY;
let now = std::time::Instant::now();
let double = !right
&& !display
&& self.carried.is_some()
&& self.last_inv_click.is_some_and(|(at, last, was_right)| {
last == slot && !was_right && now.duration_since(at).as_millis() < 250
});
self.last_inv_click = Some((now, slot, right));
if double && self.menu_click(Some(slot), 0, Input::PickupAll) {
self.last_inv_click = None;
// The double click's own release (`mouseReleased`'s PICKUP_ALL).
self.inv_clicks.skip_release();
return;
}
if self.carried.is_some() {
let ty = i32::from(right);
let first = if !display && self.quick_craft_accepts(slot, ty, 0) {
vec![slot]
} else {
Vec::new()
};
self.inv_drag = Some((ty, first));
return;
}
}
if self.creative_tab_open() {
// CreativeModeInventoryScreen goes through the same mouseClicked:
// a click now, or a drag that its release ends.
match input {
Some(input) => {
self.menu_click(slot, i32::from(right), input);
}
None if self.inv_clicks.quick_crafting().is_some() => {
self.inv_drag = Some((i32::from(right), Vec::new()));
}
None => {}
}
return;
}
// mouseClicked: an empty hand's PICKUP is the menu's click at once
// (a right click on a bundle takes its first stack out).
if let (Some(input), Some(_)) = (input, slot)
&& self.remote.is_none()
&& self.menu_click(slot, i32::from(right), input)
{
if let Some(key) = self.container {
self.container_changed(key);
}
return;
}
self.click_inventory(right);
}
/// Mouse movement while a quick craft drag is running.
fn inventory_drag_move(&mut self) {
if self.tweaks_on() && self.tweak_drag_move(self.inventory_target().0) {
return;
}
let Some((ty, slots)) = self.inv_drag.clone() else {
return;
};
let Some(r) = self.renderer.as_ref() else {
return;
};
let batch = HudBatch::new([r.config.width, r.config.height]);
if let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1)
&& slot != 200
&& slot < Creative::DISPLAY
&& !slots.contains(&slot)
&& self.quick_craft_accepts(slot, ty, slots.len())
&& let Some((_, slots)) = self.inv_drag.as_mut()
{
slots.push(slot);
}
}
/// The hovered slot and whether the cursor is outside the window.
fn inventory_target(&self) -> (Option<usize>, bool) {
let Some(r) = self.renderer.as_ref() else {
return (None, false);
};
let batch = HudBatch::new([r.config.width, r.config.height]);
(
self.slot_at(&batch, self.cursor.0, self.cursor.1),
self.clicked_outside(&batch),
)
}
fn screen_button(right: bool) -> horizon_client::container_screen::Button {
use horizon_client::container_screen::Button;
if right { Button::Right } else { Button::Left }
}
/// `Screen.hasShiftDown` / `InputWithModifiers.hasShiftDown`: the
/// physical Shift keys, whatever the sneak key is bound or toggled to.
pub(super) fn has_shift_down(&self) -> bool {
self.physical_keys.contains(&KeyCode::ShiftLeft)
|| self.physical_keys.contains(&KeyCode::ShiftRight)
}
/// `Minecraft.hasControlDown`: the physical Control keys, whatever the
/// sprint key is bound or toggled to.
pub(super) fn has_control_down(&self) -> bool {
self.physical_keys.contains(&KeyCode::ControlLeft)
|| self.physical_keys.contains(&KeyCode::ControlRight)
}
/// `hasClickedOutside` of the open screen at the cursor.
fn clicked_outside(&self, batch: &HudBatch) -> bool {
use horizon_client::container_screen::{Book, Image, clicked_outside};
let (ox, oy) = self.inventory_origin(batch);
let (shift, width, height) = if self.screen == Screen::Creative {
(0.0, Creative::WIDTH as i32, Creative::HEIGHT as i32)
} else {
let (shift, width) = match self.station.as_ref().map(|s| s.kind) {
Some(stations::Kind::Merchant) => (-50.0, 276),
Some(stations::Kind::Beacon) => (beacon::SHIFT, 230),
_ => (0.0, 176),
};
(shift, width, self.screen_height() as i32)
};
let image = Image {
left: (ox + shift) as i32,
top: oy as i32,
width,
height,
};
let book = self
.recipe_book_area(batch)
.map(|(visible, tab_hovered)| Book {
visible,
selected_tab_hovered: tab_hovered,
});
clicked_outside(
f64::from(self.cursor.0),
f64::from(self.cursor.1),
image,
book,
)
}
/// A click outside the window (slot id -999): `THROW` does nothing; a
/// `PICKUP` drops the carried stack (left) or one of it (right), thrown
/// from the hand (`AbstractContainerMenu.doClick`, `LivingEntity.drop`).
fn throw_click(&mut self, right: bool, input: horizon_client::menu::Input) {
use horizon_client::menu::Input;
let button = i32::from(right);
if self.remote.is_some() {
self.remote_throw(right, input);
return;
}
let before = self.carried.clone();
if !self.menu_click(None, button, input) && input == Input::Pickup {
// A screen the menu engine doesn't model: the same doClick.
if let Some(c) = self.carried.as_mut() {
let thrown = if right {
let one = ItemStack {
count: 1,
..c.clone()
};
c.count -= 1;
if c.count == 0 {
self.carried = None;
}
one
} else {
self.carried.take().expect("some")
};
self.player_drop(thrown);
}
}
if self.carried != before {
self.swing_arm();
}
if let Some(key) = self.container {
self.container_changed(key);
}
}
/// Mouse release over an inventory screen: `mouseReleased` ends or
/// cancels the drag, drops a stack released outside, or clicks.
fn inventory_mouse_release(&mut self, right: bool) {
use horizon_client::container_screen::{Release, Target};
self.tweak_release();
let (slot, outside) = self.inventory_target();
let dragged = self.inv_drag.as_ref().is_some_and(|(_, s)| !s.is_empty());
let release = self.inv_clicks.release(
&Target::of(slot, outside),
Self::screen_button(right),
self.carried.is_none(),
dragged,
self.has_shift_down(),
false,
);
match (release, Target::of(slot, outside)) {
(Release::QuickCraft, _) => self.inventory_release(),
(Release::Click(input), Target::Outside) => {
self.inv_drag = None;
self.throw_click(right, input);
}
(Release::Click(input), Target::Slot(slot)) if self.inv_drag.is_some() => {
// The drag never reached a slot: a plain click where it ends.
self.inv_drag = None;
if !self.menu_click(Some(slot), i32::from(right), input) {
self.click_inventory(right);
}
if let Some(key) = self.container {
self.container_changed(key);
}
}
_ => self.inv_drag = None,
}
}
/// A press of the pick block button (`keyPickItem`, the middle button by
/// default) over an inventory screen: `mouseClicked` with `cloning`
/// (infinite materials). An empty hand clones the hovered stack at its
/// full size (`CLONE`), a carried stack starts a quick craft drag of type
/// 2 that fills every slot it crosses; without infinite materials the
/// press does nothing.
fn inventory_pick_press(&mut self) {
use horizon_client::container_screen::{Button, Target};
let (slot, outside) = self.inventory_target();
let was_crafting = self.inv_clicks.quick_crafting().is_some();
let input = self.inv_clicks.press(
&Target::of(slot, outside),
Button::Middle,
self.carried.is_none(),
self.has_shift_down(),
self.creative,
);
match (input, slot) {
// Slot -999 (outside the window) clones nothing.
(Some(input), Some(slot)) if !outside => {
self.menu_click(Some(slot), 2, input);
}
(None, _) if !was_crafting && self.inv_clicks.quick_crafting().is_some() => {
// Item tab display slots take no drags.
let first = slot.filter(|&s| {
s != 200 && s < Creative::DISPLAY && self.quick_craft_accepts(s, 2, 0)
});
self.inv_drag = Some((2, first.into_iter().collect()));
}
_ => {}
}
}
/// The pick block button's release (`mouseReleased`): ends its quick
/// craft drag, cancels another button's, or clones onto the slot under a
/// carried stack (`CLONE`, which only an item tab's display slot takes).
fn inventory_pick_release(&mut self) {
use horizon_client::container_screen::{Button, Release, Target};
let (slot, outside) = self.inventory_target();
let dragged = self.inv_drag.as_ref().is_some_and(|(_, s)| !s.is_empty());
let release = self.inv_clicks.release(
&Target::of(slot, outside),
Button::Middle,
self.carried.is_none(),
dragged,
self.has_shift_down(),
true,
);
match (release, slot) {
(Release::QuickCraft, _) => self.inventory_release(),
(Release::Click(input), Some(slot)) if !outside => {
self.inv_drag = None;
self.menu_click(Some(slot), 2, input);
}
_ => self.inv_drag = None,
}
}
/// Mouse release: finishes a quick craft drag (one slot is a plain click).
fn inventory_release(&mut self) {
use horizon_client::menu::Input;
let Some((ty, slots)) = self.inv_drag.take() else {
return;
};
if slots.len() == 1 {
if !self.menu_click(Some(slots[0]), ty, Input::Pickup) {
self.click_inventory(ty == 1);
}
} else {
let mask = |header: i32| header | (ty << 2);
let mut ops = vec![(None, mask(0), Input::QuickCraft)];
ops.extend(
slots
.into_iter()
.map(|slot| (Some(slot), mask(1), Input::QuickCraft)),
);
ops.push((None, mask(2), Input::QuickCraft));
if !self.menu_ops(&ops) {
// Not a menu the engine models: the drag is a plain click.
self.click_inventory(ty == 1);
}
}
if let Some(key) = self.container {
self.container_changed(key);
}
}
fn click_inventory(&mut self, right: bool) {
if self.mount_click(right) {
return;
}
if self.recipe_book_click(right) {
return;
}
if self.station_click(right) {
return;
}
if self.remote.is_some() {
return self.remote_click(right);
}
let Some(size) = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
else {
return;
};
let batch = HudBatch::new(size);
let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else {
return;
};
let held_shift = self.has_shift_down();
if self.crafter_click(slot, held_shift, right) {
return;
}
if held_shift && self.container.is_some() && self.container_quick_move(slot) {
if let Some(key) = self.container {
self.world.modified.insert((key.0 >> 4, key.2 >> 4));
}
return;
}
if let Some(c) = &self.carried
&& self.refuses(slot, c)
{
return;
}
let max = |items: &Items, s: &ItemStack| items.get(&s.item).map_or(64, |i| i.max_stack);
let shift = held_shift;
if slot >= 300
&& let Some(key) = self.container
{
self.world.modified.insert((key.0 >> 4, key.2 >> 4));
}
let is_furnace = matches!(self.container_kind(), Some(BlockEntity::Furnace(_)));
if is_furnace && slot == 302 {
// FurnaceResultSlot: take only.
let Some(result) = self.slot_mut(302).take() else {
return;
};
match &mut self.carried {
None => self.carried = Some(result),
Some(c)
if c.item == result.item
&& c.count + result.count <= max(self.res.items(), c) =>
{
c.count += result.count
}
_ => *self.slot_mut(302) = Some(result),
}
return;
}
// Changing the input restarts cooking (AbstractFurnaceBlockEntity.setItem).
let furnace_input = (is_furnace && slot == 300).then(|| self.slot_mut(300).clone());
if slot == 200 {
// ResultSlot: take the crafted stack and consume one of each ingredient.
let mut crafted = 0;
while let Some((recipe, result)) = self.craft_recipe() {
let made = (result.item.clone(), result.count);
let cells = self.craft_size * self.craft_size;
let remainders = self.res.recipes().remainders(
&recipe,
&self.craft_grid[..cells],
self.craft_size,
);
if shift {
if self.give(result).is_some() {
break;
}
} else {
match &mut self.carried {
None => self.carried = Some(result),
Some(c)
if c.item == result.item
&& c.count + result.count <= max(self.res.items(), c) =>
{
c.count += result.count
}
_ => return,
}
}
for cell in self.craft_grid.iter_mut() {
if let Some(s) = cell {
s.count -= 1;
if s.count == 0 {
*cell = None;
}
}
}
for (i, rest) in remainders.into_iter().enumerate() {
let Some(rest) = rest else { continue };
match &mut self.craft_grid[i] {
cell @ None => *cell = Some(rest),
Some(c) if c.same_item_same_components(&rest) => c.count += rest.count,
_ => self.give_or_drop(rest),
}
}
crafted += 1;
self.stats.add("crafted", &made.0, made.1 as i32);
self.award_crafted(&[format!("minecraft:{recipe}")]);
if !shift || crafted >= 64 {
break;
}
}
return;
}
if shift
&& (slot < 36 || (500..504).contains(&slot) || (100..109).contains(&slot))
&& self.inventory_quick_move(slot)
{
return;
}
if (500..504).contains(&slot) {
let wanted = ["head", "chest", "legs", "feet"][slot - 500];
let fits = self.carried.as_ref().is_none_or(|c| {
self.res
.items()
.get(&c.item)
.and_then(|i| i.equip_slot.as_deref())
== Some(wanted)
});
if !fits {
return;
}
std::mem::swap(&mut self.carried, &mut self.armor[slot - 500]);
self.apply_equipment();
return;
}
let carried = self.carried.take();
let current = self.slot_mut(slot).take();
let items = self.res.items();
let (new_slot, new_carried) = match (carried, current) {
(None, Some(mut s)) if right => {
let half = s.count.div_ceil(2);
s.count -= half;
let taken = ItemStack {
count: half,
..s.clone()
};
((s.count > 0).then_some(s), Some(taken))
}
(None, s) => (None, s),
(Some(mut c), None) if right => {
let one = ItemStack {
count: 1,
..c.clone()
};
c.count -= 1;
(Some(one), (c.count > 0).then_some(c))
}
(Some(c), None) => (Some(c), None),
(Some(mut c), Some(mut s)) if c.same_item_same_components(&s) => {
let room = max(items, &s).saturating_sub(s.count);
let moved = if right {
1.min(room).min(c.count)
} else {
room.min(c.count)
};
s.count += moved;
c.count -= moved;
(Some(s), (c.count > 0).then_some(c))
}
(Some(c), Some(s)) => (Some(c), Some(s)),
};
self.carried = new_carried;
*self.slot_mut(slot) = new_slot;
if let Some(before) = furnace_input
&& let Some(BlockEntity::Furnace(f)) = self
.container
.and_then(|k| self.world.block_entities.get_mut(&k))
{
f.input_clicked(self.res.recipes(), before);
}
}
/// `Camera.setRotation`: the camera's orientation, turned round in
/// third-person front view.
pub(super) fn camera_orientation(&self) -> glam::Quat {
let (view_yaw, view_pitch) =
if self.camera_type == perspective::CameraType::ThirdPersonFront {
(self.yaw + 180.0, -self.pitch)
} else {
(self.yaw, self.pitch)
};
glam::Quat::from_euler(
glam::EulerRot::YXZ,
std::f32::consts::PI - view_yaw.to_radians(),
-view_pitch.to_radians(),
0.0,
)
}
/// ItemEntityRenderer: items bob and spin; blocks render as small cubes.
fn entity_geometry(
&mut self,
camera: glam::DVec3,
alpha: f64,
mut out: Vec<Vertex>,
) -> Vec<Vertex> {
self.prepare_entity_culling(camera);
self.prepare_trims();
let fire_yaw = if self.camera_type == perspective::CameraType::ThirdPersonFront {
self.yaw + 180.0
} else {
self.yaw
};
for m in &self.mobs {
if m.fire_ticks > 0 && !m.removed {
let at = m.previous.lerp(m.position, alpha);
horizon_client::fire_render::flames(
[at.x, at.y, at.z],
m.width(),
m.height(),
camera,
fire_yaw,
&self.gui.atlas.sprites,
self.world.light(
at.x.floor() as i32,
at.y.floor() as i32,
at.z.floor() as i32,
),
&mut out,
);
}
}
if !self.camera_type.first_person()
&& let Some(p) = &self.player
&& p.fire_ticks > 0
&& !p.spectator
{
let feet = self
.previous_position
.lerp(p.position, self.clock.camera_fraction());
horizon_client::fire_render::flames(
[feet.x, feet.y, feet.z],
p.dimensions.width,
p.dimensions.height,
camera,
fire_yaw,
&self.gui.atlas.sprites,
self.world.light(
feet.x.floor() as i32,
feet.y.floor() as i32,
feet.z.floor() as i32,
),
&mut out,
);
}
for item in &self.dropped {
if item.fire_ticks > 0
&& !self
.res
.items()
.resists_fire(&item.stack, "minecraft:in_fire")
{
let at = item.previous.lerp(item.position, alpha);
horizon_client::fire_render::flames(
[at.x, at.y, at.z],
0.25,
0.25,
camera,
fire_yaw,
&self.gui.atlas.sprites,
self.world.light(
at.x.floor() as i32,
at.y.floor() as i32,
at.z.floor() as i32,
),
&mut out,
);
}
}
for stand in &self.armor_stands {
if stand.fire_ticks > 0 && !stand.marker {
let scale = if stand.small { 0.5 } else { 1.0 };
horizon_client::fire_render::flames(
[stand.position.x, stand.position.y, stand.position.z],
0.5 * scale,
1.975 * scale,
camera,
fire_yaw,
&self.gui.atlas.sprites,
self.world.light(
stand.position.x.floor() as i32,
stand.position.y.floor() as i32,
stand.position.z.floor() as i32,
),
&mut out,
);
}
}
// `ItemEntityRenderer`.
self.dropped_item_geometry(camera, alpha, &mut out);
// `VaultRenderer`.
self.vault_geometry(camera, alpha, &mut out);
self.ominous_item_spawner_geometry(camera, alpha, &mut out);
// Mobs and their projectiles.
self.mob_geometry(camera, alpha, &mut out);
self.player_model_geometry(camera, self.clock.camera_fraction(), &mut out);
self.guest_model_geometry(camera, alpha, &mut out);
self.fangs_geometry(camera, alpha, &mut out);
let mut see_through = std::mem::take(&mut self.see_through_vertices);
see_through.clear();
self.name_tag_geometry(camera, alpha, &mut out, &mut see_through);
self.text_display_geometry(camera, alpha, &mut out, &mut see_through);
self.see_through_vertices = see_through;
// Entity shadows (EntityRenderer.extractShadow).
if let Some(sprite) = self.gui.atlas.sprites.get("misc/shadow").copied() {
let ambient = if self.dim == Dim::Nether { 0.1 } else { 0.0 };
let darken = self.sky_darken();
let a = alpha;
let lerp = |p: Vec3, q: Vec3| {
glam::DVec3::new(
p.x + (q.x - p.x) * a,
p.y + (q.y - p.y) * a,
p.z + (q.z - p.z) * a,
)
};
let mut casters: Vec<(glam::DVec3, &str)> = self
.mobs
.iter()
.map(|m| (lerp(m.previous, m.position), m.kind.id.as_str()))
.collect();
casters.extend(
self.dropped
.iter()
.map(|i| (lerp(i.previous, i.position), "minecraft:item")),
);
casters.extend(
self.orbs
.iter()
.map(|o| (lerp(o.previous, o.position), "minecraft:experience_orb")),
);
for (pos, id) in casters {
let (radius, strength) = horizon_client::shadows::shadow_params(id);
horizon_client::shadows::shadow(
&self.world,
self.res.facts(),
sprite,
camera,
pos,
radius,
strength,
ambient,
darken,
&mut out,
);
}
}
// Block entities (BlockEntityRenderers): chests, shulker boxes, banners, skulls...
if let Some(r) = &self.renderer {
let lid = |p: [i32; 3]| self.chest_lid(p, alpha as f32);
let anim = |p: [i32; 3]| self.block_anim(p, alpha as f32);
let scene = horizon_client::block_entity_render::Scene {
camera,
orientation: self.camera_orientation(),
anim: &anim,
texts: None,
partial: alpha as f32,
game_time: self.world.game_time,
max_y: self.dim.max_y(),
world: &self.world,
sprites: &self.gui.atlas.sprites,
nether: self.dim == Dim::Nether,
lid: &lid,
sign: &|p| match self.world.block_entities.get(&(p[0], p[1], p[2])) {
Some(BlockEntity::Sign(sign)) => Some(sign),
_ => None,
},
banner: &|p| self.banner_layers_at(p),
glyph: &|c| self.gui.atlas.glyph_cell(c),
};
// Block entities outside the view frustum are skipped (with a
// block of margin for models larger than their block).
let view = self.view_frustum;
// Beams and structure outlines reach far outside their block
// (BlockEntityRenderer.shouldRenderOffScreen): never culled.
let off_screen = |state: u32| {
let name = &*self.res.facts().get(BlockStateId(state)).name;
matches!(
name,
"minecraft:beacon"
| "minecraft:end_gateway"
| "minecraft:structure_block"
| "minecraft:test_instance_block"
)
};
let visible = r.block_entities().filter(|(p, state)| {
if !self.res.block_entity_render().renders(*state) {
return false;
}
off_screen(*state)
|| view.is_none_or(|v| {
let o =
(glam::DVec3::new(f64::from(p[0]), f64::from(p[1]), f64::from(p[2]))
- camera)
.as_vec3();
v.intersects(o - glam::Vec3::ONE, o + glam::Vec3::splat(2.0))
})
});
if self.entity_culler.is_some() {
for block in visible {
let start = out.len();
self.res
.block_entity_render()
.render(&scene, std::iter::once(block), &mut out);
if !off_screen(block.1) {
self.cull_entity_vertices(&mut out, start);
}
}
} else {
self.res
.block_entity_render()
.render(&scene, visible, &mut out);
}
for (pos, stage) in self.cracks(camera) {
let state = self.world.block(pos[0], pos[1], pos[2]);
self.res
.block_entity_render()
.render_breaking(&scene, pos, state.0, stage, &mut out);
}
}
// Experience orbs (ExperienceOrbRenderer): pulsing billboards from a 4x4 icon sheet.
if let Some(r) = self
.gui
.atlas
.sprites
.get("entity/experience/experience_orb")
.copied()
{
let (yaw, pitch) = (self.yaw.to_radians(), self.pitch.to_radians());
let forward = glam::Vec3::new(
-yaw.sin() * pitch.cos(),
-pitch.sin(),
yaw.cos() * pitch.cos(),
);
let right = forward.cross(glam::Vec3::Y).normalize_or_zero();
let up = right.cross(forward).normalize_or_zero();
let live = self.orbs.iter().map(|o| {
let at = [
o.previous.x + (o.position.x - o.previous.x) * alpha,
o.previous.y + (o.position.y - o.previous.y) * alpha,
o.previous.z + (o.position.z - o.previous.z) * alpha,
];
(o, at, alpha as f32)
});
// ItemPickupParticle: the render state extracted at partial tick 1.
let taken = self.pickups.live.iter().filter_map(|p| match &p.taken {
pickups::Taken::Orb(o) => Some((&**o, pickups::position(p, alpha), 1.0)),
_ => None,
});
for (o, at, partial) in live.chain(taken) {
let p = glam::DVec3::new(at[0], at[1] + 0.1, at[2]) - camera;
let icon = o.icon();
let (du, dv) = ((r.u1 - r.u0) / 4.0, (r.v1 - r.v0) / 4.0);
let (u0, v0) = (r.u0 + (icon % 4) as f32 * du, r.v0 + (icon / 4) as f32 * dv);
let t = (o.age as f32 + partial) / 2.0;
let red = ((t.sin() + 1.0) * 0.5 * 255.0) as u32;
let blue = (((t + 4.188_79).sin() + 1.0) * 0.1 * 255.0) as u32;
let color = 0x8000_0000 | blue << 16 | 255 << 8 | red;
let light = self.world.light(
o.position.x.floor() as i32,
o.position.y.floor() as i32,
o.position.z.floor() as i32,
);
let packed = (u32::from(light >> 4).max(10) * 16)
| ((u32::from(light & 15).max(10) * 16) << 8);
let c = p.as_vec3();
let s = 0.15;
for (k, uv) in [(-1.0, -1.0), (1.0, -1.0), (1.0, 1.0), (-1.0, 1.0)]
.iter()
.zip([[u0, v0 + dv], [u0 + du, v0 + dv], [u0 + du, v0], [u0, v0]])
{
let v = c + right * (k.0 * s) + up * (k.1 * s);
out.push(Vertex {
normal: [0; 4],
pos: v.to_array(),
uv,
layer: 0,
color,
light: packed,
});
}
}
}
// Falling blocks use their baked model, including non-cubic shapes.
for f in &self.falling {
let Some((_, tint)) = self.block_face_sprite(f.state) else {
continue;
};
let p = glam::DVec3::new(
f.previous.x + (f.position.x - f.previous.x) * alpha - 0.5,
f.previous.y + (f.position.y - f.previous.y) * alpha,
f.previous.z + (f.position.z - f.previous.z) * alpha - 0.5,
) - camera;
let o = p.as_vec3();
let light = self.world.light(
f.position.x.floor() as i32,
f.position.y.floor() as i32 + 1,
f.position.z.floor() as i32,
);
let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
let start = out.len();
self.block_model_vertices(
f.state,
horizon_core::random::position_seed(f.start_pos),
glam::Mat4::from_translation(o),
packed,
false,
&mut out,
);
let tint = horizon_client::mobs::render::abgr(tint);
for vertex in &mut out[start..] {
vertex.color = horizon_client::hud_layout::multiply(vertex.color, tint);
}
}
self.moving_piston_geometry(camera, alpha, &mut out);
self.tnt_geometry(camera, alpha, &mut out);
self.painting_geometry(camera, &mut out);
self.frame_geometry(camera, &mut out);
self.armor_stand_geometry(camera, alpha, &mut out);
self.boat_geometry(camera, alpha, &mut out);
self.cart_geometry(camera, alpha, &mut out);
self.beacon_geometry(camera, alpha, &mut out);
self.fishing_geometry(camera, alpha, &mut out);
self.leash_geometry(camera, alpha, &mut out);
self.trident_geometry(camera, alpha, &mut out);
self.rocket_geometry(camera, alpha, &mut out);
self.thrown_potion_geometry(camera, alpha, &mut out);
// Particles (ParticleEngine.extract): camera-facing quads.
let world = &self.world;
self.particles.render(
camera,
self.yaw,
self.pitch,
alpha as f32,
&|b| world.light(b[0], b[1], b[2]),
&mut out,
);
// Breaking progress overlays (destroy_stage_0..9): ours and the other players'.
for (pos, stage) in self.cracks(camera) {
let o = (glam::DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
- camera)
.as_vec3();
let state = self.world.block(pos[0], pos[1], pos[2]);
if self.res.facts().get(state).render_shape
== horizon_client::blocks::RenderShape::Model
&& let Ok(models) = self
.pack
.render
.model_catalog
.collect(state, BlockPos::new(pos[0], pos[1], pos[2]))
{
let offset = self
.pack
.context
.tables
.offset(state, pos[0], pos[2])
.unwrap_or([0.0; 3]);
let origin = o + glam::DVec3::from(offset).as_vec3();
let translucent = models
.iter()
.any(|(_, model)| model.faces.iter().any(|f| f.translucent));
for (_, model) in models {
horizon_client::breaking::geometry(model, origin, translucent, stage, &mut out);
}
}
}
out
}
/// `LevelRenderer.destroyBlockProgress`: a player's crack on a block (0..=9), or none
/// (any other progress). Cracks not updated for 400 ticks are dropped.
pub(crate) fn destroy_block_progress(&mut self, breaker: i32, pos: [i32; 3], progress: i32) {
let now = self.world.game_time;
self.destroying
.retain(|_, c| now.saturating_sub(c.2) <= 400);
if (0..10).contains(&progress) {
self.destroying.insert(breaker, (pos, progress as u8, now));
} else {
self.destroying.remove(&breaker);
}
}
/// The cracks to draw and their stage sprite's atlas origin: our own mining and the
/// 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])> {
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),
None => stages.push((pos, stage)),
};
if let Some(m) = &self.mining
&& m.progress > 0.0
{
add(m.pos, ((m.progress * 10.0) as u32).min(9));
}
let now = self.world.game_time;
for (pos, stage, at) in self.destroying.values() {
if now.saturating_sub(*at) <= 400 {
add(*pos, u32::from(*stage));
}
}
stages
.into_iter()
.filter(|(pos, _)| {
let d = glam::DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
+ 0.5
- camera;
d.length_squared() <= 1024.0
})
.filter_map(|(pos, stage)| {
let r = self
.gui
.atlas
.sprites
.get(&format!("block/destroy_stage_{stage}"))?;
Some((pos, [r.u0, r.v0]))
})
.collect()
}
fn sky_darken(&self) -> i32 {
if self.dim == Dim::Nether {
return 11;
}
if self.dim == Dim::End {
let sky = self
.res
.end_environment()
.sample(self.world.day_time, None, None);
return (15.0 - 15.0 * sky.sky_light_level).round() as i32;
}
let (rain, thunder) = self.world.weather.levels(1.0);
// Sampled once per (time, weather): every mob asks each tick.
let key = (self.world.day_time, rain.to_bits(), thunder.to_bits());
if let Some((k, darken)) = self.sky_darken_memo.get()
&& k == key
{
return darken;
}
let mut sky = self
.res
.environment()
.sample(self.world.day_time, None, None);
horizon_client::environment::apply_weather(&mut sky, rain, thunder);
// Level.updateSkyBrightness: darkening from the sky light level.
let darken = (15.0 - 15.0 * sky.sky_light_level).round() as i32;
self.sky_darken_memo.set(Some((key, darken)));
darken
}
fn mob_hit(&self) -> Option<(usize, f64)> {
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)> = None;
for (i, m) in self.mobs.iter().enumerate() {
if !m.alive() {
continue;
}
if let Some(t) = ray_box(eye, dir, reach, m.bounds())
&& best.is_none_or(|b| t < b.1)
{
best = Some((i, t));
}
}
best
}
/// `Player.attack`'s damage against `target_kind` (with the attack
/// strength and whether it is a critical hit): the weapon and effects
/// scaled by the attack strength, a mace's smash, the critical hit, then
/// enchantments.
pub(super) fn melee_damage(&mut self, target_kind: &str) -> (f32, f32, bool) {
let hand_damage = 1.0 + self.attack_item_info().map_or(0.0, |i| i.attack_damage);
// Riptide's spin replaces the attack damage attribute.
let spin = self.player.as_ref().map_or(0.0, |p| p.auto_spin_attack_dmg);
let damage = if spin > 0.0 {
spin
} else {
hand_damage + self.effect_attack_bonus()
};
let scale = self.attack_strength_scale();
let mut amount = damage * (0.2 + scale * scale * 0.8);
// Item.getAttackDamageBonus (a mace's smash), before the critical hit.
amount += self.smash_damage_bonus(target_kind);
let player = self.player.as_ref();
// Player.canCriticalAttack: falling, off the ground, not in water,
// not blind (isMobilityRestricted), not riding, not sprinting.
let falling = player.is_some_and(|p| {
!p.ground.on_ground
&& p.fall_distance > 0.0
&& !p.fluids.was_touching_water
&& !p.sprinting
});
let restricted = self.potions.effects.get("blindness").is_some() || self.riding.is_some();
let crit = scale > 0.9 && falling && !restricted;
if crit {
amount *= 1.5;
}
// Enchantment damage (sharpness, smite, bane) scaled by the attack strength.
amount += self.enchant_damage_bonus(target_kind) * scale;
(amount, scale, crit)
}
/// `Player.getAttackStrengthScale(0.5)`.
fn attack_strength_scale(&self) -> f32 {
let speed = self.attack_item_info().map_or(0.0, |i| i.attack_speed);
let delay = 20.0 / (4.0 + speed).max(0.1);
((self.attack_ticks as f32 + 0.5) / delay).clamp(0.0, 1.0)
}
/// `Player.isSweepAttack`: a charged, grounded sword hit below the movement limit.
pub(super) fn sweep_attack_position(&self, scale: f32, crit: bool) -> Option<[f64; 3]> {
let p = self.player.as_ref()?;
let sword = self.held().is_some_and(|s| {
self.res
.items()
.item_tags
.get("minecraft:swords")
.is_some_and(|tag| tag.contains(&*s.item))
});
if !p.is_sweep_attack(scale, crit, sword) {
return None;
}
let yaw = f64::from(self.yaw.to_radians());
Some([
p.position.x - yaw.sin(),
p.position.y + f64::from(p.dimensions.height) * 0.5,
p.position.z + yaw.cos(),
])
}
/// The visual and sound part of `Player.doSweepAttack` after a successful hit.
pub(super) fn sweep_attack(&mut self, at: [f64; 3], from: Option<[f64; 3]>) {
self.particles.add(
&horizon_client::particles::ParticleOptions::simple(
horizon_client::particles::ParticleType::SweepAttack,
),
at,
[0.0; 3],
);
self.audio
.play("minecraft:entity.player.attack.sweep", from, 1.0, 1.0);
}
/// `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.
pub(super) fn vehicle_attack_sounds(&mut self) {
let full = self.attack_strength_scale() > 0.9;
let player = self.player.as_ref();
let from = player.map(|p| [p.position.x, p.position.y, p.position.z]);
if full && player.is_some_and(|p| p.sprinting) {
self.audio
.play("minecraft:entity.player.attack.knockback", from, 1.0, 1.0);
}
let sound = if full {
"minecraft:entity.player.attack.strong"
} else {
"minecraft:entity.player.attack.weak"
};
if let Some(at) = self.sweep_attack_position(self.attack_strength_scale(), false) {
self.sweep_attack(at, from);
} else {
self.audio.play(sound, from, 1.0, 1.0);
}
}
/// Player.attack with the attack-strength charge, crits and knockback.
fn attack(&mut self) -> bool {
if self.spectator() {
return false;
}
// A painting nearer than the targeted block and mob breaks instead.
if let Some((i, d)) = self.painting_hit()
&& self.mob_hit().is_none_or(|m| d < m.1)
&& self.pick().is_none_or(|h| {
let eye = self.eye_position().unwrap_or_default();
(0..3)
.map(|a| (h.point[a] - eye[a]).powi(2))
.sum::<f64>()
.sqrt()
> d
})
{
self.break_painting(i, true);
return true;
}
// A ghast's fireball or a wind charge in front: turned back.
if self.attack_redirectable() {
return true;
}
let hand_damage = 1.0
+ self
.held()
.and_then(|h| self.res.items().get(&h.item))
.map_or(0.0, |i| i.attack_damage);
if self.attack_frame()
|| self.attack_armor_stand()
|| self.attack_boat(hand_damage)
|| self.attack_cart(hand_damage)
|| self.attack_dragon()
|| self.attack_guest()
{
return true;
}
let Some((index, distance)) = self.mob_hit() else {
return false;
};
if let Some(hit) = self.pick() {
let eye = self.eye_position().unwrap_or_default();
let d = ((hit.point[0] - eye[0]).powi(2)
+ (hit.point[1] - eye[1]).powi(2)
+ (hit.point[2] - eye[2]).powi(2))
.sqrt();
if d < distance {
return false;
}
}
self.attack_mob(index);
// Minecraft.startAttack swings after the attack.
self.swing_arm();
true
}
/// `Player.attack` on a mob: the damage, knockback, sweep, particles and
/// sounds.
pub(super) fn attack_mob(&mut self, index: usize) {
let target_kind = self.mobs[index].kind.id.clone();
let target_kind = format!("minecraft:{}", target_kind.trim_start_matches("minecraft:"));
let (amount, scale, crit) = self.melee_damage(&target_kind);
let sweep = self.sweep_attack_position(scale, crit);
let (knockback, knockback_attack) = self.extra_knockback(&target_kind, scale);
self.attack_ticks = 0;
if let Some(p) = self.player.as_mut()
&& !self.creative
{
p.cause_food_exhaustion(0.1);
}
let player = self.player.as_ref();
let from = player.map(|p| [p.position.x, p.position.y, p.position.z]);
if knockback_attack {
self.audio
.play("minecraft:entity.player.attack.knockback", from, 1.0, 1.0);
}
// LivingEntity.setLastHurtMob (tamed wolves join in).
self.combat.last_hurt_mob = Some((self.mobs[index].id, self.world.game_time));
let old_health = self.mobs[index].health;
let source = match from {
Some(f) => self.attack_source(f),
None => horizon_client::mobs::Damage::of(horizon_client::mobs::DamageKind::Generic),
};
let landed = self.hurt_by_player(index, amount, source);
if let Some(p) = self.player.as_mut() {
if p.attack_log.len() >= 64 {
p.attack_log.remove(0);
}
p.attack_log.push(horizon_client::health::AttackRecord {
game_time: p.health.game_time(),
target: target_kind.clone(),
id: self.mobs[index].id,
killed: landed && !self.mobs[index].alive(),
amount,
scale,
crit,
landed,
dealt: old_health - self.mobs[index].health,
});
}
if landed {
if knockback > 0.0 {
let (xd, zd) = self.extra_knockback_direction();
self.mobs[index].knockback(f64::from(knockback), xd, zd);
self.stop_sprint_after_extra_knockback();
}
let mob = &self.mobs[index];
// Player.damageStatsAndHearts: the damage the hit actually did.
let actual = old_health - mob.health;
// Player.attack: crit emitter and damage indicator hearts.
let (feet, width, height) = (
[mob.position.x, mob.position.y, mob.position.z],
mob.kind.width,
mob.kind.height,
);
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,
),
feet,
width,
height,
);
}
if actual > 2.0 {
let indicator = horizon_client::particles::ParticleOptions::simple(
horizon_client::particles::ParticleType::DamageIndicator,
);
self.particles.send_particles(
&indicator,
[feet[0], feet[1] + height * 0.5, feet[2]],
[0.1, 0.0, 0.1],
0.2,
(actual * 0.5) as u32,
);
}
self.last_hurt_by_player
.insert(self.mobs[index].id, self.lan_acting);
let sound = if crit {
"minecraft:entity.player.attack.crit"
} else if scale > 0.9 {
"minecraft:entity.player.attack.strong"
} else {
"minecraft:entity.player.attack.weak"
};
// Player.playServerSideSound: at the player.
if let Some(at) = sweep {
self.sweep_attack(at, from);
} else {
self.audio.play(sound, from, 1.0, 1.0);
}
// The hurt or death sound the mob raised (getHurtSound / getDeathSound,
// its voice pitch from its own random).
let queued = std::mem::take(&mut self.mobs[index].outbox);
for event in queued {
if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event {
self.audio
.play(&format!("minecraft:{s}"), Some(at), volume, pitch);
}
}
self.weapon_hit(index);
} else {
self.audio
.play("minecraft:entity.player.attack.nodamage", from, 1.0, 1.0);
}
}
/// 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).
fn explode(&mut self, center: [f64; 3], radius: f32) -> Result<()> {
self.server_explode(
center,
radius,
explosion::BlockInteraction::DestroyWithDecay,
false,
)
}
/// Copies of a save batch carrying its live block entities and save data.
fn with_entities<'a>(
&self,
chunks: impl IntoIterator<Item = &'a Arc<horizon_client::chunk::Chunk>>,
) -> Vec<Arc<horizon_client::chunk::Chunk>> {
horizon_client::save::chunks_with_block_entities(
chunks,
&self.world.block_entities,
&self.world.block_names,
)
.into_iter()
.map(|mut c| {
self.attach_save_data(&mut c);
Arc::new(c)
})
.collect()
}
fn tick_mobs(&mut self) -> Result<()> {
self.tick_creatures()?;
self.position_rider();
self.tick_stats();
self.tick_scoreboard();
self.load_bossbars();
self.tick_functions();
self.tick_worldborder();
self.tick_subtitles();
self.spawn_phantoms();
self.tick_advancements();
self.tick_player_model();
Ok(())
}
/// SkyRenderer.renderSunMoonAndStars: bodies on a frame rotated Y -90 then X by angle.
/// Returns the sun and moon quads, and the stars' frame and brightness
/// (the renderer keeps their geometry, built once).
fn celestial_geometry(
&self,
sky: &horizon_client::environment::Sky,
) -> (Vec<Vertex>, Option<(glam::Mat4, f32)>) {
let mut out = Vec::new();
let atlas = &self.gui.atlas;
let frame = |angle: f32| {
glam::Mat4::from_rotation_y((-90.0f32).to_radians())
* glam::Mat4::from_rotation_x(angle.to_radians())
};
let mut body = |name: &str, angle: f32, size: f32, color: u32| {
let Some(r) = atlas.sprites.get(name).copied() else {
return;
};
let m = frame(angle);
let corners = [(-size, -size), (size, -size), (size, size), (-size, size)];
let uv = [[r.u0, r.v0], [r.u1, r.v0], [r.u1, r.v1], [r.u0, r.v1]];
for ((x, z), uv) in corners.iter().zip(uv) {
let p = m.transform_point3(glam::Vec3::new(*x, 100.0, *z));
out.push(Vertex {
normal: [0; 4],
pos: p.to_array(),
uv,
layer: 2,
color,
light: 0,
});
}
};
body(
"environment/celestial/sun",
sky.sun_angle,
30.0,
0xFFFF_FFFF,
);
let phases = [
"full_moon",
"waning_gibbous",
"third_quarter",
"waning_crescent",
"new_moon",
"waxing_crescent",
"first_quarter",
"waxing_gibbous",
];
let phase = phases[(self.world.day_time / 24000).rem_euclid(8) as usize];
body(
&format!("environment/celestial/moon/{phase}"),
sky.moon_angle,
20.0,
0xFFFF_FFFF,
);
// SkyRenderer.renderStars: the static star buffer on the same frame.
let stars =
(sky.star_brightness > 0.0).then(|| (frame(sky.star_angle), sky.star_brightness));
(out, stars)
}
/// Enter a local world from the client, selecting its simulation mode.
fn open_world(
&mut self,
folder: &str,
name: Option<&str>,
seed: Option<i64>,
creative: bool,
create: Option<&horizon_client::title::WorldOptions>,
) -> Result<()> {
if self.defer_world_entry(PendingWorldEntry::Local {
folder: folder.to_owned(),
name: name.map(str::to_owned),
seed,
creative,
create: create.cloned().map(Box::new),
})? {
return Ok(());
}
self.join_world_rest()?;
if self
.options
.execution_role
.starts_integrated_server(self.options.server_thread)
{
return self.open_integrated(folder, name, seed, creative, create);
}
let request = world_loading::WorldRequest::new(folder, name, seed, creative, create)?;
if self.window.is_some() {
self.perf.world_opening();
if self.title.is_none() {
self.title = Some(Title::new(
std::env::current_dir()?.join("saves"),
&self.options.resources,
));
}
self.world_loader = Some(world_loading::WorldLoader::start(
request,
self.res.clone(),
self.pack.clone(),
self.options.clone(),
self.settings.clone(),
)?);
return Ok(());
}
self.load_world(request)
}
/// Load authoritative world state synchronously, without client entry or
/// integrated-server selection. Server startup must use this entry point.
fn load_world(&mut self, request: world_loading::WorldRequest) -> Result<()> {
self.join_world_rest()?;
self.perf.world_opening();
let prepared = request.prepare(&self.res, &self.pack, &self.options, &self.settings)?;
self.finish_open_world(prepared)
}
fn finish_open_world(&mut self, prepared: world_loading::PreparedWorld) -> Result<()> {
let world_loading::PreparedWorld {
save_root,
level,
world,
streaming,
save,
session_lock,
rand_sequences,
locator,
} = prepared;
let dim = Dim::from_id(&level.dimension);
horizon_client::crash::set_detail(
"World",
format!("{} ({})", level.name, save_root.display()),
);
self.session_lock = Some(session_lock);
self.end.set_locator(locator);
self.score = Default::default();
self.fns = Default::default();
self.bosses = Default::default();
reset_world_progress(&mut self.adv, &mut self.stats);
self.prefetch_advancement_tree();
self.restore_player_state = true;
self.rand_sequences = rand_sequences;
self.border = Default::default();
self.set_mode_id(level.mode());
let mut inventory = vec![None; 36];
self.armor = [None, None, None, None];
self.offhand = None;
self.ender_items = if level.ender_items.len() == 27 {
level.ender_items.clone()
} else {
vec![None; 27]
};
for (slot, id, count, damage) in &level.inventory {
let stack = ItemStack {
item: Arc::from(id.as_str()),
count: *count,
damage: *damage,
extra: level.inventory_components.get(slot).cloned(),
};
if (100..104).contains(slot) {
self.armor[usize::from(103 - slot)] = Some(stack);
} else if *slot == 150 {
self.offhand = Some(stack);
} else if let Some(cell) = inventory.get_mut(usize::from(*slot)) {
*cell = Some(stack);
}
}
if self.creative && level.inventory.is_empty() && level.position.is_none() {
for (i, name) in [
"minecraft:grass_block",
"minecraft:stone",
"minecraft:oak_planks",
"minecraft:glass",
"minecraft:torch",
"minecraft:oak_log",
"minecraft:chest",
"minecraft:furnace",
"minecraft:diamond_pickaxe",
]
.iter()
.enumerate()
{
inventory[i] = Some(ItemStack {
item: Arc::from(*name),
count: 1,
damage: 0,
extra: None,
});
}
}
let (yaw, pitch) = self
.options
.look
.unwrap_or((level.rotation[0], level.rotation[1]));
self.yaw = yaw;
self.pitch = pitch;
self.selected = level.selected_slot.clamp(0, 8) as usize;
self.streaming = streaming;
self.world = world;
self.inventory = inventory;
self.save = save;
self.level = level;
// ServerRecipeBook.loadUntrusted: recipes the manager does not have are dropped.
let index = &self.res.stations().recipe_index;
let book = &mut self.level.recipe_book;
book.recipes.retain(|r| index.contains(r));
book.to_be_displayed.retain(|r| index.contains(r));
self.dim = dim;
self.world_root = save_root.clone();
self.block_ticks = Ticks::new(self.level.seed as i32);
self.tick_chunks.clear();
self.clear_entities();
self.travelling = None;
self.player = None;
self.sleeping = None;
self.sleep_timer = 0;
self.spawn = None;
self.respawn_travel = None;
self.respawn_config = self
.level
.respawn_elsewhere
.as_ref()
.map(respawn_anchor::RespawnConfig::from_saved);
self.spawn_origin = None;
self.spawn_spiral = Default::default();
self.player_spawn = None;
self.creatures.reset_trader();
self.portals = Default::default();
self.experience = Experience {
level: self.level.xp_level,
progress: self.level.xp_progress,
total: self.level.xp_total,
};
self.restore_effects();
self.mining = None;
self.container = None;
let kinds = std::mem::take(&mut self.be_anims.kinds);
self.be_anims = horizon_client::block_entity_anim::BlockEntityAnims {
kinds,
..Default::default()
};
self.carried = None;
self.using = None;
self.screen = Screen::Playing;
self.title = None;
self.clear_lod();
self.pending_uploads.clear();
if let Some(r) = self.renderer.as_mut() {
r.clear_sections();
}
self.apply_settings();
self.streaming.sky_light = dim != Dim::Nether;
self.streaming.nether_shading = dim == Dim::Nether;
self.load_world_state();
Ok(())
}
/// Streaming and region storage for one dimension of a world.
fn make_streaming(
&self,
world_root: &std::path::Path,
dim: Dim,
seed: i64,
) -> Result<(Streaming, Arc<SaveDir>)> {
let (streaming, save, locator) = world_loading::make_streaming(
&self.res,
&self.pack,
&self.options,
&self.settings,
world_root,
dim,
seed,
)?;
self.end.set_locator(locator);
Ok((streaming, save))
}
/// Change dimension through a portal (Entity.changeDimension with
/// PortalForcer placement once the destination has loaded).
fn enter_dimension(&mut self, target: Dim) -> Result<()> {
let Some(player) = self.player.take() else {
return Ok(());
};
let from = self.dim;
let destination = self.switch_level(target, player.position)?;
self.trigger_dimension(from, target);
self.travelling = Some((player, destination));
self.end_travel = (target == Dim::End || from == Dim::End) && self.end_portal_travel;
Ok(())
}
/// The level swap under a dimension change: save the departing level,
/// open `target`'s, and return where a player leaving from `from` goes
/// (scaled coordinates, or the End portal's fixed destination).
pub(super) fn switch_level(&mut self, target: Dim, from: Vec3) -> Result<Vec3> {
// Save the departing dimension's changed chunks.
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)));
self.save
.save(&chunks, self.pack.assets.registry, self.res.biomes())?;
self.save_dimension_entities()?;
// Coordinates scale by 8 between the Overworld and the Nether.
let scale = match (self.dim, target) {
(Dim::Overworld, Dim::Nether) => 1.0 / 8.0,
(Dim::Nether, Dim::Overworld) => 8.0,
(Dim::End, Dim::Nether) => 1.0 / 8.0,
_ => 1.0,
};
let destination = self.end_destination(target).unwrap_or(Vec3::new(
from.x * scale,
from.y,
from.z * scale,
));
let (streaming, save) =
self.make_streaming(&self.world_root.clone(), target, self.level.seed)?;
let mut world = World::new(self.res.facts().air, self.level.seed);
world.fast_lava = target == Dim::Nether;
world.game_time = self.world.game_time;
world.day_time = self.world.day_time;
world.weather = self.world.weather;
// The game rules and the difficulty hold in every dimension.
world.health_rules = self.world.health_rules;
// An open hub keeps hearing the new level's block changes.
world.block_log = self.world.block_log.as_ref().map(|_| Vec::new());
world.light_log = self.world.light_log.as_ref().map(|_| Default::default());
// The sculk tables' watched blocks are built once per game.
world.watched = std::mem::take(&mut self.world.watched);
self.streaming = streaming;
self.world = world;
self.save = save;
self.dim = target;
self.level.dimension = target.id().to_owned();
self.block_ticks = Ticks::new(self.level.seed as i32);
self.tick_chunks.clear();
self.falling.clear();
self.tnts.clear();
self.mobs.clear();
self.creatures.projectiles.clear();
self.dropped.clear();
self.particles.clear();
self.pickups.clear();
self.orbs.clear();
self.mining = None;
self.clear_lod();
self.pending_uploads.clear();
if let Some(r) = self.renderer.as_mut() {
r.clear_sections();
}
self.apply_settings();
Ok(destination)
}
/// PortalShape: an obsidian frame around 2..=21 by 3..=21 empty blocks.
fn portal_shape(&self, start: [i32; 3], x_axis: bool) -> Option<([i32; 3], i32, i32)> {
let name = |p: [i32; 3]| {
self.res
.facts()
.get(self.world.block(p[0], p[1], p[2]))
.name
.clone()
};
let empty = |p: [i32; 3]| {
let n = name(p);
matches!(
&*n,
"minecraft:air"
| "minecraft:cave_air"
| "minecraft:fire"
| "minecraft:soul_fire"
| "minecraft:nether_portal"
)
};
let frame = |p: [i32; 3]| &*name(p) == "minecraft:obsidian";
let d = if x_axis { [1, 0, 0] } else { [0, 0, 1] };
let mut bottom = start;
let mut n = 0;
while empty([bottom[0], bottom[1] - 1, bottom[2]]) && n < 21 {
bottom[1] -= 1;
n += 1;
}
if !frame([bottom[0], bottom[1] - 1, bottom[2]]) {
return None;
}
let mut left = bottom;
n = 0;
while empty([left[0] - d[0], left[1], left[2] - d[2]]) && n < 21 {
left = [left[0] - d[0], left[1], left[2] - d[2]];
n += 1;
}
if !frame([left[0] - d[0], left[1], left[2] - d[2]]) {
return None;
}
let mut width = 0;
while width <= 21 {
let p = [left[0] + d[0] * width, left[1], left[2] + d[2] * width];
if !empty(p) || !frame([p[0], p[1] - 1, p[2]]) {
break;
}
width += 1;
}
if !(2..=21).contains(&width)
|| !frame([left[0] + d[0] * width, left[1], left[2] + d[2] * width])
{
return None;
}
let mut height = 0;
'rows: while height <= 21 {
let y = left[1] + height;
if !frame([left[0] - d[0], y, left[2] - d[2]])
|| !frame([left[0] + d[0] * width, y, left[2] + d[2] * width])
{
break;
}
for i in 0..width {
if !empty([left[0] + d[0] * i, y, left[2] + d[2] * i]) {
break 'rows;
}
}
height += 1;
}
let top_ok =
(0..width).all(|i| frame([left[0] + d[0] * i, left[1] + height, left[2] + d[2] * i]));
((3..=21).contains(&height) && top_ok).then_some((left, width, height))
}
/// BaseFireBlock.onPlace: lighting fire inside a frame creates a portal,
/// only in the Overworld and the Nether (`inPortalDimension`).
fn try_light_portal(&mut self, at: [i32; 3]) -> Result<bool> {
if !matches!(self.dim, Dim::Overworld | Dim::Nether) {
return Ok(false);
}
for x_axis in [true, false] {
if let Some((origin, width, height)) = self.portal_shape(at, x_axis) {
let d = if x_axis { [1, 0, 0] } else { [0, 0, 1] };
let registry = &self.pack.assets.registry;
let Some(default) = registry.default_state("minecraft:nether_portal") else {
return Ok(false);
};
let mut portal = registry.state(default).cloned().ok_or("portal state")?;
portal
.properties
.insert("axis".into(), if x_axis { "x" } else { "z" }.into());
let id = registry.resolve(&portal).unwrap_or(default);
for h in 0..height {
for w in 0..width {
self.world.set(
origin[0] + d[0] * w,
origin[1] + h,
origin[2] + d[2] * w,
id,
)?;
}
}
return Ok(true);
}
}
Ok(false)
}
/// Arrival through a nether portal, once the destination is loaded.
fn place_after_travel(&mut self, player: PlayerMotion, target: Vec3) -> Result<()> {
self.arrive_through_nether_portal(player, target)
}
/// Leaving the game with a world open (window closed, Quit, `quit`):
/// menu items go back (Player.closeContainer), then the world is saved,
/// once.
/// Keeps this play session's performance summary for the launcher to send, if the player
/// allows performance statistics (`horizon_client::telemetry`), and starts the next one.
pub(super) fn finish_perf(&mut self) {
let s = &self.settings;
let settings = horizon_telemetry::payload::Settings {
render_distance: s.render_distance.clamp(0, 255) as u8,
simulation_distance: s.simulation_distance.clamp(0, 255) as u8,
// 260 is the slider's "unlimited".
max_fps: if s.max_fps >= 260 {
0
} else {
s.max_fps.min(u32::from(u16::MAX)) as u16
},
vsync: s.vsync,
fullscreen: s.fullscreen,
graphics: s.graphics_preset.clone(),
};
// Again now: on Wayland the window is on a screen only once it has been shown.
if let Some(window) = &self.window {
horizon_client::telemetry::note_display(window);
}
self.perf
.finish(&horizon_client::logging::game_home(), settings);
}
pub(super) fn save_for_exit(&mut self) -> Result<()> {
// Native application termination can bypass CloseRequested. Finish any
// save screen synchronously here, before the process can go away.
while self.pending_save.is_some() {
self.poll_closing_save()?;
if self.pending_save.is_some() {
std::thread::sleep(Duration::from_millis(1));
}
}
if self.title.is_some() || self.saved_for_exit {
return Ok(());
}
if let Some(server) = self.integrated.take() {
// The server thread saves the world.
server.stop()?;
self.saved_for_exit = true;
return Ok(());
}
self.close_container();
if self.remote.is_none() {
self.stats.custom("leave_game", 1);
}
self.lan_close(false);
self.save_game()?;
self.saved_for_exit = true;
Ok(())
}
fn close_world(&mut self) -> Result<()> {
self.clear_waypoints();
self.begin_closing_save(false)
}
fn finish_close_world(&mut self) -> Result<()> {
self.ambience.clear(&mut self.audio);
// updateLevelInEngines(null): every sound stops; the music manager
// lets go of its track.
self.music.stop_playing(None, &mut self.audio);
self.audio.stop_all();
if self.remote.is_some() {
return self.leave_server(None);
}
// The save screen has finished every write before releasing storage.
self.session_lock = None;
horizon_client::crash::clear_detail("World");
self.debug_charts.reset();
self.boss_overlay.reset();
self.bosses = Default::default();
self.streaming.paused = true;
self.world = World::new(self.res.facts().air, 0);
self.player = None;
self.sleeping = None;
self.sleep_timer = 0;
self.clear_entities();
self.screen = Screen::Playing;
self.clear_lod();
self.pending_uploads.clear();
if let Some(r) = self.renderer.as_mut() {
r.clear_sections();
}
self.title = Some(Title::new(
std::env::current_dir()?.join("saves"),
&self.options.resources,
));
if let Some(title) = &mut self.title {
title.last_server = self.settings.file.string("lastServer");
}
self.capture(false);
Ok(())
}
/// Let go of every entity of the level (saved first): the next world
/// opened must not inherit them, nor save them as its own.
fn clear_entities(&mut self) {
self.mobs.clear();
self.dropped.clear();
self.orbs.clear();
self.creatures.projectiles.clear();
self.falling.clear();
self.tnts.clear();
self.boats.clear();
self.carts.clear();
self.armor_stands.clear();
self.item_frames.clear();
self.paintings.clear();
self.others.clear();
self.dragon = None;
self.crystals.clear();
self.dragon_fireballs.clear();
self.breath_clouds.clear();
self.tridents.clear();
self.rockets.clear();
self.bolts.clear();
self.particles.clear();
self.pickups.clear();
self.riding = None;
self.persist = Default::default();
}
/// Equipment attribute modifiers (LivingEntity.collectEquipmentChanges).
fn apply_equipment(&mut self) {
let Some(player) = self.player.as_mut() else {
return;
};
for (attribute, id) in std::mem::take(&mut self.applied_modifiers) {
let _ = player.set_modifier(&attribute, &id, 0.0, "add_value", false);
}
let slots = ["head", "chest", "legs", "feet"];
let mut equipped: Vec<(Option<&ItemStack>, &str)> = self
.armor
.iter()
.zip(slots)
.map(|(s, n)| (s.as_ref(), n))
.collect();
equipped.push((self.inventory[self.selected].as_ref(), "mainhand"));
for (stack, slot) in equipped {
let Some(info) = stack.and_then(|s| self.res.items().get(&s.item)) else {
continue;
};
for (attribute, id, amount, op, group) in &info.modifiers {
let matches = group == slot
|| group == "any"
|| (group == "armor" && slot != "mainhand")
|| (group == "hand" && slot == "mainhand");
// Main-hand attack modifiers are read by the attack code directly.
if !matches || slot == "mainhand" {
continue;
}
if player
.set_modifier(attribute, id, *amount, op, true)
.is_ok()
{
self.applied_modifiers.push((attribute.clone(), id.clone()));
}
}
}
self.apply_enchantment_attributes();
}
/// Inventory.hurtArmor: each piece loses max(1, damage / 4) durability.
fn hurt_armor(&mut self, damage: f32) {
let amount = ((damage / 4.0) as u32).max(1);
let mut broke = false;
let losses: Vec<u32> = (0..4)
.map(|i| {
self.armor[i]
.clone()
.map_or(amount, |s| self.durability_loss(&s, amount))
})
.collect();
for (slot, amount) in self.armor.iter_mut().zip(losses) {
if let Some(stack) = slot.as_mut()
&& let Some(info) = self.res.items().get(&stack.item)
&& info.max_damage > 0
{
stack.damage += amount;
if stack.damage >= info.max_damage {
*slot = None;
broke = true;
}
}
}
if broke {
if let Some(eye) = self.eye_position() {
self.audio.play(
"minecraft:entity.item.break",
Some(eye),
0.8,
0.8 + self.world.random.next_float() * 0.4,
);
}
self.apply_equipment();
}
}
/// Voxel traversal that also stops at fluid source blocks (bucket pick).
fn pick_fluid(&self) -> Option<Hit> {
let origin = self.eye_position()?;
let dir = view_vector(self.yaw, self.pitch);
let mut t = 0.0;
let mut last = origin.map(|v| v.floor() as i32);
while t <= self.reach() {
let p = [
origin[0] + dir[0] * t,
origin[1] + dir[1] * t,
origin[2] + dir[2] * t,
];
let b = p.map(|v| v.floor() as i32);
if b != last {
let state = self.world.block(b[0], b[1], b[2]);
let f = self.res.facts().get(state);
let face = [last[0] - b[0], last[1] - b[1], last[2] - b[2]];
if f.fluid != Fluid::None
&& f.fluid_level == 8
&& !f.fluid_falling
&& !f.waterlogged
&& f.render_shape != horizon_client::blocks::RenderShape::Model
{
return Some(Hit {
pos: b,
face,
point: p,
});
}
if !self.res.facts().is_air(state) && f.fluid == Fluid::None {
return Some(Hit {
pos: b,
face,
point: p,
});
}
last = b;
}
t += 0.05;
}
None
}
/// `CauldronInteractions` for the held item aimed at a cauldron.
fn use_on_cauldron(&mut self, pos: [i32; 3]) -> Result<bool> {
use horizon_client::cauldron::{self, Outcome};
struct Hand<'g, 'a>(&'g mut Game<'a>);
impl cauldron::Player for Hand<'_, '_> {
fn creative(&self) -> bool {
self.0.creative
}
fn hand(&mut self) -> &mut Option<ItemStack> {
self.0.held_mut()
}
fn add(&mut self, stack: &mut ItemStack) -> bool {
let before = stack.count;
match self.0.give(stack.clone()) {
None => stack.count = 0,
Some(rest) => stack.count = rest.count,
}
stack.count < before
}
fn contains(&self, stack: &ItemStack) -> bool {
self.0
.inventory
.iter()
.flatten()
.any(|have| have.same_item_same_components(stack))
}
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);
}
}
}
let registry = self.pack.assets.registry;
let id = self.world.block(pos[0], pos[1], pos[2]);
let Some(state) = registry
.state(id)
.filter(|s| s.name.ends_with("cauldron"))
.cloned()
else {
return Ok(false);
};
let Some(held) = self.held() else {
return Ok(false);
};
let removes_dye = cauldron::removes_dye(self.res.items(), &held.item);
let above = self.world.block(pos[0], pos[1] + 1, pos[2]);
let under_water = registry
.state(above)
.is_some_and(|s| s.name == "minecraft:water");
let result = cauldron::interact(&state, under_water, removes_dye, &mut Hand(self));
if result.outcome == Outcome::Pass {
return Ok(false);
}
if let Some(block) = result.block
&& let Ok(new) = registry.resolve(&block)
{
self.level_set(pos, new)?;
}
if let Some(sound) = result.sound {
self.audio.play(
sound,
Some([
f64::from(pos[0]) + 0.5,
f64::from(pos[1]) + 0.5,
f64::from(pos[2]) + 0.5,
]),
1.0,
1.0,
);
}
Ok(true)
}
/// What `BlockTransformer.transformBlock` would do with a held axe, hoe
/// or shovel on the block at `pos`, without doing it: the new state, its
/// sound, loot table, the durability it costs and its particle.
pub(super) fn block_transform(
&self,
stack: &ItemStack,
pos: [i32; 3],
face: [i32; 3],
) -> Option<(BlockStateId, String, Option<String>, u32, String)> {
use horizon_client::block_transform::Around;
struct Column<'w> {
world: &'w World,
registry: &'w horizon_world::registry::BlockRegistry,
pos: [i32; 3],
}
impl Around for Column<'_> {
fn state(&self, o: [i32; 3]) -> horizon_world::chunk::BlockState {
let id =
self.world
.block(self.pos[0] + o[0], self.pos[1] + o[1], self.pos[2] + o[2]);
self.registry.state(id).cloned().unwrap_or_else(|| {
horizon_world::chunk::BlockState {
name: "minecraft:air".into(),
properties: Default::default(),
}
})
}
}
let id = self
.res
.items()
.get(&stack.item)
.and_then(|i| i.block_transformer.clone())?;
// playerHasBlockingItemUseIntent: a shield in the off hand is raised
// instead, unless sneaking.
let shield = self
.offhand
.as_ref()
.and_then(|s| self.res.items().get(&s.item))
.is_some_and(|i| i.blocks_attacks.is_some());
if shield && !self.keys.contains(&KeyCode::ShiftLeft) {
return None;
}
let face_name = match face {
[0, -1, 0] => "down",
[0, 1, 0] => "up",
[0, 0, -1] => "north",
[0, 0, 1] => "south",
[-1, 0, 0] => "west",
_ => "east",
};
let registry = self.pack.assets.registry;
let around = Column {
world: &self.world,
registry,
pos,
};
let (_, t, state) =
self.res
.transformers()
.apply(self.res.items(), registry, &id, face_name, &around)?;
let new = registry.resolve(&state).ok()?;
Some((
new,
t.sound.clone(),
t.loot.clone(),
t.damage,
t.particle.clone(),
))
}
/// `BlockTransformer.TransformParticle.send`: its level event.
pub(super) fn transform_particle(&mut self, particle: &str, pos: [i32; 3]) {
match particle {
"scrape" => self.level_event_at(3005, pos, 0),
"wax_on" => self.level_event_at(3003, pos, 0),
"wax_off" => self.level_event_at(3004, pos, 0),
_ => {}
}
}
/// `BlockTransformer.transformBlock` for a held axe, hoe or shovel.
fn use_block_transformer(
&mut self,
stack: &ItemStack,
pos: [i32; 3],
face: [i32; 3],
) -> Result<bool> {
let Some((new, sound, loot, damage, particle)) = self.block_transform(stack, pos, face)
else {
return Ok(false);
};
self.level_set(pos, new)?;
// BlockTransformer.TransformParticle.send.
self.transform_particle(&particle, pos);
if loot.as_deref() == Some("minecraft:till/rooted_dirt") {
self.pop_resource(
[pos[0] + face[0], pos[1] + face[1], pos[2] + face[2]],
ItemStack::new("minecraft:hanging_roots", 1),
);
}
self.audio.play(
&sound,
Some([
f64::from(pos[0]) + 0.5,
f64::from(pos[1]) + 0.5,
f64::from(pos[2]) + 0.5,
]),
1.0,
1.0,
);
self.damage_held(damage);
self.post_block_game_event("minecraft:block_change", pos, self.sculk_actor(), Some(new));
Ok(true)
}
fn set_state_named(&mut self, pos: [i32; 3], name: &str, keep: &[&str]) -> Result<bool> {
let registry = &self.pack.assets.registry;
let old = self.world.block(pos[0], pos[1], pos[2]);
let Some(default) = registry.default_state(name) else {
return Ok(false);
};
let mut state = registry.state(default).cloned().ok_or("state")?;
if let Some(previous) = registry.state(old) {
for k in keep {
if let Some(v) = previous.properties.get(*k) {
state.properties.insert((*k).to_owned(), v.clone());
}
}
}
let id = registry.resolve(&state).unwrap_or(default);
self.level_set(pos, id)?;
Ok(true)
}
fn damage_held(&mut self, amount: u32) {
if self.creative {
return;
}
let amount = match self.held().cloned() {
Some(held) => self.durability_loss(&held, amount),
None => amount,
};
let max = self
.held()
.and_then(|s| self.res.items().get(&s.item))
.map_or(0, |i| i.max_damage);
let cell = self.held_mut();
if let Some(stack) = cell.as_mut()
&& max > 0
{
stack.damage += amount;
if stack.damage >= max {
let broken = stack.item.clone();
*cell = None;
self.stats.add("broken", &broken, 1);
if let Some(eye) = self.eye_position() {
self.audio.play(
"minecraft:entity.item.break",
Some(eye),
0.8,
0.8 + self.world.random.next_float() * 0.4,
);
}
}
}
}
/// Block tool use: distinguish success, failure and fall-through for hand feedback.
fn use_tool(
&mut self,
stack: &ItemStack,
allow_block_actions: bool,
) -> Result<horizon_client::first_person::UseResult> {
use horizon_client::first_person::UseResult;
let item = stack.item.trim_start_matches("minecraft:").to_owned();
let at = |p: [i32; 3]| {
[
f64::from(p[0]) + 0.5,
f64::from(p[1]) + 0.5,
f64::from(p[2]) + 0.5,
]
};
if allow_block_actions
&& let Some(hit) = self.pick()
&& self.use_on_cauldron(hit.pos)?
{
return Ok(UseResult::Success { swing: true });
}
// 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(_)))
&& (item == "bucket" || bucket.is_some())
{
return Ok(UseResult::Pass);
}
if item == "bucket" {
// getPlayerPOVHitResult(SOURCE_ONLY): powder snow's outline before
// a fluid source behind it.
if let Some(hit) = self.pick()
&& self.is_powder_snow(hit.pos)
{
let eye = self.eye_position().unwrap_or(hit.point);
let d = |p: [f64; 3]| {
(p[0] - eye[0]).powi(2) + (p[1] - eye[1]).powi(2) + (p[2] - eye[2]).powi(2)
};
if self
.pick_fluid()
.is_none_or(|fluid| d(fluid.point) >= d(hit.point))
{
self.pick_up_powder_snow(hit.pos)?;
return Ok(UseResult::Success { swing: true });
}
}
let Some(hit) = self.pick_fluid() else {
return Ok(UseResult::Pass);
};
let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
let f = self.res.facts().get(state).clone();
if f.fluid == Fluid::None || f.fluid_level != 8 || f.fluid_falling {
return Ok(UseResult::Pass);
}
let sound = match f.fluid {
Fluid::Water => "minecraft:item.bucket.fill",
_ => "minecraft:item.bucket.fill_lava",
};
let pos = BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]);
let Some(filled) =
self.with_level(|b, level, ticks| b.bucket_pickup(level, ticks, pos))
else {
return Ok(UseResult::Pass);
};
self.process_level_events()?;
self.audio.play(sound, Some(at(hit.pos)), 1.0, 1.0);
self.trigger_item("minecraft:filled_bucket", &ItemStack::new(filled, 1));
if !self.creative {
self.consume_held();
let filled = ItemStack {
item: Arc::from(filled),
count: 1,
damage: 0,
extra: None,
};
if self.held().is_none() {
*self.held_mut() = Some(filled);
} 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);
}
}
return Ok(UseResult::Success { swing: true });
}
// BucketItem.use has its own ray, even when the crosshair hits an entity.
if !allow_block_actions && bucket.is_none() {
return Ok(UseResult::Pass);
}
let Some(hit) = self.pick() else {
return Ok(UseResult::Pass);
};
let clicked = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
if let Some((content, sound, mob)) = bucket {
if !self.may_build() {
return Ok(UseResult::Fail);
}
let target = if self.res.facts().get(clicked).replaceable {
hit.pos
} else {
[
hit.pos[0] + hit.face[0],
hit.pos[1] + hit.face[1],
hit.pos[2] + hit.face[2],
]
};
let pos = BlockPos::new(target[0], target[1], target[2]);
let emptied = self
.with_level(|b, level, ticks| b.bucket_empty(level, ticks, pos, content, sound));
self.process_level_events()?;
if !emptied {
return Ok(UseResult::Fail);
}
if let Some(kind) = mob {
if let Some(id) = self.spawn_mob_at(kind, (target[0], target[1], target[2]), true) {
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
horizon_client::entity_nbt::load_bucket_data(m, stack);
}
self.mob_placed(id)?;
}
self.post_block_game_event(
"minecraft:entity_place",
target,
self.sculk_actor(),
None,
);
}
self.trigger_block("minecraft:placed_block", target, stack);
if !self.creative {
*self.held_mut() = Some(ItemStack::new("minecraft:bucket", 1));
}
return Ok(UseResult::Success { swing: true });
}
if self.use_block_transformer(stack, hit.pos, hit.face)? {
return Ok(UseResult::Success { swing: true });
}
if item == "honeycomb" {
let registry = self.pack.assets.registry;
let old = registry.state(clicked).cloned();
if let Some(waxed) = old.and_then(|old| self.res.transformers().waxed(registry, &old))
&& let Ok(state) = registry.resolve(&waxed)
{
self.level_set(hit.pos, state)?;
self.level_event_at(3003, hit.pos, 0);
self.audio.play(
"minecraft:item.honeycomb.wax_on",
Some(at(hit.pos)),
1.0,
1.0,
);
if !self.creative {
self.consume_held();
}
return Ok(UseResult::Success { swing: true });
}
}
if item == "flint_and_steel" || item == "fire_charge" {
if !self.may_build() {
return Ok(UseResult::Fail);
}
let name = self.res.facts().get(clicked).name.clone();
if self.can_light(clicked, &name) {
let registry = self.pack.assets.registry;
let mut state = registry
.state(clicked)
.cloned()
.ok_or("missing lit block state")?;
state.properties.insert("lit".into(), "true".into());
self.level_set(hit.pos, registry.resolve(&state)?)?;
self.audio.play(
if item == "fire_charge" {
"minecraft:item.firecharge.use"
} else {
"minecraft:item.flintandsteel.use"
},
Some(at(hit.pos)),
1.0,
horizon_client::items::fire_starter_pitch(
item == "fire_charge",
&mut self.world.random,
),
);
if item == "fire_charge" {
self.consume_held();
} else {
self.damage_held(1);
}
return Ok(UseResult::Success { swing: true });
}
let target = [
hit.pos[0] + hit.face[0],
hit.pos[1] + hit.face[1],
hit.pos[2] + hit.face[2],
];
if self.can_place_used_fire(target) {
if !self.try_light_portal(target)? {
self.place_used_fire(target)?;
}
let sound = horizon_client::items::fire_starter_sound(item == "fire_charge");
let pitch = horizon_client::items::fire_starter_pitch(
item == "fire_charge",
&mut self.world.random,
);
self.audio.play(sound, Some(at(target)), 1.0, pitch);
if item == "fire_charge" {
self.consume_held();
} else {
self.damage_held(1);
}
return Ok(UseResult::Success { swing: true });
}
return Ok(UseResult::Fail);
}
Ok(UseResult::Pass)
}
/// `ExperienceOrb.award`: orbs of the largest sizes; each draws the id
/// `tryMergeToExisting` compares from the level random, then moves with
/// its own random.
fn spawn_orbs(&mut self, at: [f64; 3], mut value: u32) {
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);
}
}
/// `new ExperienceOrb(level, pos, Vec3.ZERO, value)`: yaw and motion from
/// the orb's own random.
fn add_orb(&mut self, at: [f64; 3], value: u32) {
let mut r = dispenser::entity_random();
let _yaw = r.next_float();
let p = Vec3::new(at[0], at[1], at[2]);
self.next_entity += 1;
self.orbs.push(ExperienceOrb {
id: self.next_entity,
position: p,
previous: p,
velocity: Vec3::new(
(r.next_double() * 0.2 - 0.1) * 2.0,
r.next_double() * 0.2 * 2.0,
(r.next_double() * 0.2 - 0.1) * 2.0,
),
value,
age: 0,
on_ground: false,
});
}
fn can_place_used_fire(&mut self, target: [i32; 3]) -> bool {
let pos = BlockPos::new(target[0], target[1], target[2]);
let direction = match ((self.yaw / 90.0 + 0.5).floor() as i32).rem_euclid(4) {
0 => Direction::South,
1 => Direction::West,
2 => Direction::North,
_ => Direction::East,
};
self.with_level(|b, level, ticks| b.fire_can_be_placed_at(level, ticks, pos, direction))
}
fn place_used_fire(&mut self, target: [i32; 3]) -> Result<()> {
let pos = BlockPos::new(target[0], target[1], target[2]);
let state = self.with_level(|b, level, ticks| b.fire_state_for(level, ticks, pos));
self.level_set(target, state)
}
/// DropExperienceBlock / RedStoneOreBlock / SculkBlock experience ranges.
fn block_experience(&mut self, name: &str) -> u32 {
let (min, max) = match name.trim_start_matches("minecraft:") {
"coal_ore" | "deepslate_coal_ore" => (0, 2),
"nether_gold_ore" => (0, 1),
"lapis_ore" | "deepslate_lapis_ore" | "nether_quartz_ore" => (2, 5),
"diamond_ore" | "deepslate_diamond_ore" | "emerald_ore" | "deepslate_emerald_ore" => {
(3, 7)
}
"redstone_ore" | "deepslate_redstone_ore" => (1, 5),
"sculk" => (1, 1),
"sculk_catalyst" | "sculk_sensor" | "calibrated_sculk_sensor" | "sculk_shrieker" => {
(5, 5)
}
// SpawnerBlock.spawnAfterBreak: 15 + nextInt(15) + nextInt(15).
"spawner" => {
let r = &mut self.world.random;
let a = r.next_int_bound(15).unwrap_or(0);
return (15 + a + r.next_int_bound(15).unwrap_or(0)) as u32;
}
_ => (0, 0),
};
if max == 0 {
return 0;
}
(min + self.world.random.next_int_bound(max - min + 1).unwrap_or(0)) as u32
}
fn tick_experience(&mut self) {
if self.xp_delay > 0 {
self.xp_delay -= 1;
}
let spectator = self.spectator();
let player = self
.player
.as_ref()
.filter(|p| !p.health.dead_or_dying() && !spectator);
// ExperienceOrb.followNearbyPlayer: each orb goes for the nearest
// living player within 8 blocks, the host's own or a guest.
let mut followed: Vec<([f64; 3], [f64; 3])> = player
.map(|p| {
let feet = [p.position.x, p.position.y, p.position.z];
let eye = f64::from(p.dimensions.eye_height);
(feet, [feet[0], feet[1] + eye / 2.0, feet[2]])
})
.into_iter()
.collect();
if let Some(host) = self.lan.as_ref() {
followed.extend(
host.hub
.guests
.iter()
.filter(|g| g.placed && g.loaded && !g.dead && g.health > 0.0)
.filter(|g| !g.spectator())
.map(|g| {
let p = g.position;
(p, [p[0], p[1] + g.eye_height() / 2.0, p[2]])
}),
);
}
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,
],
)
});
let mut orbs = std::mem::take(&mut self.orbs);
orbs.retain_mut(|o| {
let distance = |feet: &[f64; 3]| -> f64 {
(feet[0] - o.position.x).powi(2)
+ (feet[1] - o.position.y).powi(2)
+ (feet[2] - o.position.z).powi(2)
};
let target = followed
.iter()
.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)
});
let mut gained = 0;
let mut taken = Vec::new();
if let Some((min, max)) = bounds {
orbs.retain(|o| {
let touching = o.position.x + 0.25 > min[0]
&& o.position.x - 0.25 < max[0]
&& o.position.y + 0.5 > min[1]
&& o.position.y < max[1]
&& 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.
self.xp_delay = 2;
gained += o.value;
taken.push(o.clone());
return false;
}
true
});
}
self.orbs = orbs;
for o in taken {
self.add_pickup(pickups::Taken::Orb(Box::new(o)), pickups::Collector::Player);
}
if gained > 0 {
gained = self.mending(gained);
}
if gained > 0 {
let at = self.eye_position();
let pitch =
(self.world.random.next_float() - self.world.random.next_float()) * 0.35 + 0.9;
self.audio
.play("minecraft:entity.experience_orb.pickup", at, 0.1, pitch);
self.give_orb_points(gained);
}
}
/// `Player.giveExperiencePoints`, and `giveExperienceLevels`' level-up
/// sound every fifth level (at most every 100 ticks).
pub(super) fn give_orb_points(&mut self, gained: u32) {
let at = self.eye_position();
if self.experience.give(gained as i32)
&& self.experience.level % 5 == 0
&& self.ticks > self.last_level_up + 100
{
self.last_level_up = self.ticks;
let volume = if self.experience.level > 30 {
1.0
} else {
self.experience.level as f32 / 30.0
};
self.audio
.play("minecraft:entity.player.levelup", at, volume * 0.75, 1.0);
}
}
/// BowItem.releaseUsing: power from charge time, arrows at power * 3.
fn release_bow(&mut self, ticks: u32) {
let f = ticks as f32 / 20.0;
let power = ((f * f + f * 2.0) / 3.0).min(1.0);
if power < 0.1 {
return;
}
let arrow_slot = self.projectile_slot("minecraft:bow");
if arrow_slot.is_none() && !self.creative {
return;
}
let Some(eye) = self.eye_position() else {
return;
};
// 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 kind = horizon_client::projectiles::ProjectileKind::Arrow {
base_damage: 2.0 + power_bonus,
critical: power >= 1.0,
effect: None,
};
let mut arrow = horizon_client::projectiles::Projectile::new(
kind,
p,
Some(horizon_client::mobs::Who::Player),
);
// 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,
self.creative || infinity,
));
a.set_owner(Some(horizon_client::mobs::Who::Player));
}
// Flame: the arrow is spawned burning (EnchantmentHelper.onProjectileSpawned).
if let Some(seconds) = self.bow_projectile_ignite()
&& let Some(a) = arrow.arrow.as_mut()
{
a.ignite_for_seconds(seconds);
}
let (velocity, on_ground) = self
.player
.as_ref()
.map_or((Vec3::ZERO, true), |pl| (pl.velocity, pl.ground.on_ground));
arrow.shoot_from_rotation(
&mut self.world.random,
self.pitch,
self.yaw,
0.0,
power * 3.0,
1.0,
velocity,
on_ground,
);
self.creatures.projectiles.push(arrow);
self.player_projectile_shot();
let pitch = 1.0 / (self.world.random.next_float() * 0.4 + 1.2) + power * 0.5;
self.audio
.play("minecraft:entity.arrow.shoot", Some(eye), 1.0, pitch);
if !self.creative
&& !infinity
&& let Some(i) = arrow_slot
{
let cell = self.stack_in_mut(i);
if let Some(s) = cell.as_mut() {
s.count -= 1;
if s.count == 0 {
*cell = None;
}
}
}
self.damage_held(1);
}
/// FirstPersonHandsAndItemsRenderer: the right arm or the held items of
/// both hands in view space, converted to camera-relative world space.
fn hand_geometry(&mut self, alpha: f64) -> Vec<Vertex> {
let mut out = Vec::new();
// GameRenderer.renderItemInHand: F1 hides the hand with the HUD.
if self.spectator()
|| self.ui.hide_gui
|| self.sleeping.is_some()
|| !self.camera_type.first_person()
|| self
.player
.as_ref()
.is_none_or(|p| p.health.dead_or_dying())
|| self.screen == Screen::Dead
{
return out;
}
let a = alpha as f32;
// FirstPersonHandsAndItemsRenderer: the swing goes to the hand that
// swings; each hand has its inverse arm height (the swap scale is 1
// for every item but spears).
let swing = self.swing.animation(a);
let attacks = Hand::BOTH.map(|h| {
if self.swing.attack_hand() == h {
swing
} else {
0.0
}
});
let inverse_heights = self.heights.interpolated(a).map(|h| 1.0 - h);
let view = horizon_client::camera::view_matrix(self.yaw, self.pitch);
// The hand sway: both hands turn by a tenth of the bobs' lag.
let [sway_x, sway_y] = self.sway.rotation(a, self.pitch, self.yaw);
let to_world = view.inverse()
* glam::Mat4::from_rotation_x(sway_x.to_radians())
* glam::Mat4::from_rotation_y(sway_y.to_radians());
let eye = self.eye_position().unwrap_or_default();
let light = self.world.light(
eye[0].floor() as i32,
eye[1].floor() as i32,
eye[2].floor() as i32,
);
let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
let deg = |d: f32| d.to_radians();
let shown = self.hands_to_render();
let used_hand = self.used_hand();
let spinning = self
.player
.as_ref()
.is_some_and(|p| p.auto_spin_attack_ticks > 0);
let items = self.visible_hand_items();
let off_hand_empty = items[1].is_none();
for (i, (hand, item)) in Hand::BOTH.into_iter().zip(items).enumerate() {
if !shown[i] {
continue;
}
let (attack, inverse_height) = (attacks[i], inverse_heights[i]);
let sqrt_attack = attack.sqrt();
// The main hand on its arm, the off hand on the other one.
let left = self.settings.main_hand_left != (hand == Hand::Off);
let Some(stack) = item else {
// Only the main hand's empty arm shows.
if hand == Hand::Off {
continue;
}
let Some(arm) = self.res.player_arm().clone() else {
continue;
};
let Some(r) = self
.gui
.atlas
.sprites
.get("entity/player/wide/steve")
.copied()
else {
continue;
};
// renderPlayerArm (right arm)
let x_swing = -0.3 * (sqrt_attack * std::f32::consts::PI).sin();
let y_swing = 0.4 * (sqrt_attack * std::f32::consts::TAU).sin();
let z_swing = -0.4 * (attack * std::f32::consts::PI).sin();
let z_rot = (attack * attack * std::f32::consts::PI).sin();
let y_rot = (sqrt_attack * std::f32::consts::PI).sin();
let m = to_world
* glam::Mat4::from_translation(glam::Vec3::new(
x_swing + 0.64,
y_swing - 0.6 + inverse_height * -0.6,
z_swing - 0.72,
))
* glam::Mat4::from_rotation_y(deg(45.0))
* glam::Mat4::from_rotation_y(deg(y_rot * 70.0))
* glam::Mat4::from_rotation_z(deg(z_rot * -20.0))
* glam::Mat4::from_translation(glam::Vec3::new(-1.0, 3.6, 3.5))
* glam::Mat4::from_rotation_z(deg(120.0))
* glam::Mat4::from_rotation_x(deg(200.0))
* glam::Mat4::from_rotation_y(deg(-135.0))
* glam::Mat4::from_translation(glam::Vec3::new(5.6, 0.0, 0.0));
let pose = |p: &horizon_client::mobs::Part| {
let mut pose = p.pose;
pose[3] = 0.0;
pose[4] = 0.0;
pose[5] = 0.0;
pose
};
horizon_client::mobs::render_model(
&arm,
m,
&pose,
[r.u0, r.v0, r.u1, r.v1],
packed,
0,
&mut out,
);
continue;
};
if let Some(id) = maps::map_id(&stack) {
use horizon_client::first_person::{MapHold, one_handed_map_pose};
match MapHold::of(hand, off_hand_empty) {
MapHold::TwoHanded => self.two_handed_map_geometry(
to_world,
attack,
inverse_height,
id,
packed,
&mut out,
),
MapHold::OneHanded => self.held_map(
to_world * one_handed_map_pose(left, inverse_height, attack),
id,
packed,
&mut out,
),
}
continue;
}
let mut owner = self.player_owner(Some(&stack));
// The other hand may hold an equal stack: only the used
// hand's item is in use, only the main hand's selected.
owner.using_this_item &= used_hand == Some(hand);
if hand == Hand::Off {
owner.is_selected = false;
owner.is_carried = false;
}
// The hand renderer's copy of the main hand stack.
owner.fishing_cast_with_this_item =
self.main_hand_rod() && self.cast_rod() == Some(&stack);
let using = owner.using_this_item && owner.use_item_remaining_ticks > 0;
let ticks_used =
owner.use_duration as f32 - (owner.use_item_remaining_ticks as f32 - a + 1.0);
use horizon_client::first_person::ItemPose;
let pose = match &*stack.item {
"minecraft:bow" if using => ItemPose::Bow { ticks_used },
"minecraft:crossbow" => {
let charged = stack.data().is_some_and(|d| !d.charged.is_empty());
ItemPose::Crossbow {
ticks_used: (using && !charged).then_some(ticks_used),
charge_duration: owner.crossbow_charge_duration as f32,
// Only the main hand turns a charged crossbow aside.
charged: charged && hand == Hand::Main,
}
}
"minecraft:trident" if using => ItemPose::Trident { ticks_used },
_ if using => {
let components = self
.pack
.item_renderer
.models
.components(&horizon_client::item_render::stack_view(&stack));
let animation = components
.get("minecraft:consumable")
.map(horizon_client::first_person::consumable_animation);
if matches!(
animation,
Some(
horizon_world::consumable::UseAnimation::Eat
| horizon_world::consumable::UseAnimation::Drink
)
) {
ItemPose::Eat {
remaining: owner.use_item_remaining_ticks as f32,
duration: owner.use_duration as f32,
partial: a,
}
} else {
ItemPose::Using
}
}
_ if spinning => ItemPose::SpinAttack,
_ => ItemPose::Swing,
};
let m = to_world
* horizon_client::first_person::item_pose(left, inverse_height, attack, pose);
// Seeded by the player id plus the context ordinal.
let (context, seed) = if left {
(
horizon_assets::item_model::DisplayContext::FirstPersonLeftHand,
3,
)
} else {
(
horizon_assets::item_model::DisplayContext::FirstPersonRightHand,
4,
)
};
let state = self.resolve_item(&stack, context, Some(&owner), seed);
let light = self.world.light(
eye[0].floor() as i32,
eye[1].floor() as i32,
eye[2].floor() as i32,
);
self.submit_item_world(
&state,
m,
horizon_client::block_entity_render::vertex_light(light),
&mut out,
);
}
out
}
/// The renderer for the window, with the current block sprites, GUI
/// atlas and world border texture.
fn new_renderer(&self, window: Arc<Window>) -> Result<Renderer> {
self.renderer_for(window, &self.pack, &self.gui)
}
fn renderer_for(
&self,
window: Arc<Window>,
pack: &PackResources,
gui: &UiResources,
) -> Result<Renderer> {
build_renderer(
window,
self.options.offscreen,
pack,
gui,
self.renderer.as_ref(),
None,
self.settings.horizon.api,
)
}
fn apply_settings(&mut self) {
if let Some(r) = &self.renderer {
self.settings
.clamp_gui_scale([r.config.width as i32, r.config.height as i32]);
}
self.streaming.radius = self.settings.render_distance;
// Options.biomeBlendRadius, ambientOcclusion and cutoutLeaves:
// LevelExtractor.allChanged when they change.
let (s, st) = (&self.settings, &self.streaming);
let remesh = (s.biome_blend, s.smooth_lighting, s.cutout_leaves)
!= (st.biome_blend, st.smooth_lighting, st.cutout_leaves);
self.streaming.biome_blend = self.settings.biome_blend;
self.streaming.smooth_lighting = self.settings.smooth_lighting;
self.streaming.cutout_leaves = self.settings.cutout_leaves;
if remesh {
self.all_sections_changed();
}
self.audio.master = self.settings.master_volume;
horizon_client::hud::GUI_SCALE.store(
self.settings.gui_scale,
std::sync::atomic::Ordering::Relaxed,
);
self.apply_ui_settings();
}
/// `LevelExtractor.allChanged`: every loaded section is rebuilt.
fn all_sections_changed(&mut self) {
for &(x, z) in self.world.chunks.keys() {
for sy in 0..horizon_client::chunk::HEIGHT / 16 {
self.world.dirty_sections.insert((x, sy, z));
}
}
}
/// Whether precipitation at a column is snow (Biome.coldEnoughToSnow:
/// base temperature lowered above y 80) or none (no precipitation).
fn precipitation(&self, x: i32, y: i32, z: i32) -> Option<bool> {
let chunk = self.world.chunks.get(&(x >> 4, z >> 4))?;
let b = self.res.biomes().get(chunk.biome(x, y, z));
if !b.precipitation {
return None;
}
let t = if y > 80 {
b.temperature - (y - 80) as f32 * 0.05 / 40.0
} else {
b.temperature
};
Some(t < 0.15)
}
/// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)`: one above the
/// highest block in `blocks_motion_in_heightmap` or holding a fluid.
fn rain_height(&self, x: i32, z: i32) -> i32 {
use horizon_world::{heightmap::HeightmapType, worldgen::terrain::TerrainBlockStates};
let properties = &self.pack.assets.properties;
self.world.motion_blocking(x, z, |s| {
HeightmapType::MotionBlocking.is_opaque(properties.heightmap_state(s))
})
}
fn tick_weather_effects(&mut self) {
if self.flash > 0 {
self.flash -= 1;
}
let (rain, _) = self.world.weather.levels(1.0);
let Some(eye) = self.eye_position() else {
return;
};
// WeatherEffectRenderer.tickRainParticles: occasional rain sounds.
if rain > 0.0 && self.world.random.next_int_bound(3).unwrap_or(1) < (rain * 3.0) as i32 {
let r = &mut self.world.random;
let (dx, dz) = (
r.next_int_bound(21).unwrap_or(10) - 10,
r.next_int_bound(21).unwrap_or(10) - 10,
);
let (x, z) = (eye[0].floor() as i32 + dx, eye[2].floor() as i32 + dz);
let top = self.rain_height(x, z);
if self.precipitation(x, top, z) == Some(false)
&& (top - eye[1] as i32).abs() < 10
&& self.world.random.next_int_bound(5).unwrap_or(1) == 0
{
let above = f64::from(top) > eye[1] + 1.0;
let (name, volume, pitch) = if above {
("minecraft:weather.rain.above", 0.1, 0.5)
} else {
("minecraft:weather.rain", 0.2, 1.0)
};
self.audio.play(
name,
Some([f64::from(x) + 0.5, f64::from(top), f64::from(z) + 0.5]),
volume,
pitch,
);
}
}
}
/// WeatherEffectRenderer: rain and snow columns within the weather radius.
fn weather_geometry(
&mut self,
camera: glam::DVec3,
alpha: f64,
) -> Vec<horizon_client::weather::Vertex> {
use horizon_client::weather;
let (intensity, _) = self.world.weather.levels(alpha as f32);
if intensity <= 0.0 {
return Vec::new();
}
let atlas = &self.gui.atlas;
let (Some(rain_tex), Some(snow_tex)) = (
atlas.sprites.get("environment/rain").copied(),
atlas.sprites.get("environment/snow").copied(),
) else {
return Vec::new();
};
let (cx, cy, cz) = (
camera.x.floor() as i32,
camera.y.floor() as i32,
camera.z.floor() as i32,
);
// The 32x32 direction table supports at most a 15-block radius.
let radius = self.settings.weather_radius.clamp(0, 15);
let eye = camera.to_array();
let mut rain = Vec::new();
let mut snow_vertices = Vec::new();
// Saturation keeps extreme camera coordinates from overflowing the loop.
for z in cz.saturating_sub(radius)..=cz.saturating_add(radius) {
for x in cx.saturating_sub(radius)..=cx.saturating_add(radius) {
let top = self.rain_height(x, z);
let y0 = cy.saturating_sub(radius).max(top);
let y1 = cy.saturating_add(radius).max(top);
if y1 == y0 {
continue;
}
let Some(snow) = self.precipitation(x, cy, z) else {
continue;
};
let parameters = self.weather_parameters.get(x, z);
let light = self.world.light(x, top.max(cy), z);
let coords = i32::from(light & 15) << 4 | i32::from(light >> 4) << 20;
// Only light brightening is needed here; UV phases stay zero.
let lc = if snow {
let (block, sky) = (coords >> 4 & 15, coords >> 20 & 15);
((block * 3 + 15) / 4) << 4 | ((sky * 3 + 15) / 4) << 20
} else {
coords
};
let column = weather::Column {
x,
z,
bottom_y: y0,
top_y: y1,
u_offset: 0.0,
v_offset: 0.0,
light_coords: lc,
};
let r = if snow { snow_tex } else { rain_tex };
let vertices = weather::vertices(
&column,
parameters,
snow,
eye,
radius,
intensity,
[r.u0, r.v0, r.u1 - r.u0, r.v1 - r.v0],
);
if snow {
snow_vertices.extend(vertices);
} else {
rain.extend(vertices);
}
}
}
// Vanilla draws every rain column before the snow ones.
rain.extend(snow_vertices);
rain
}
/// Player.startSleepInBed: night or thunder, 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;
};
let time = self.world.day_time.rem_euclid(24000);
let night = (12542..23460).contains(&time) || self.world.weather.thundering;
let state = self.world.block(pos[0], pos[1], pos[2]);
let props = self
.pack
.assets
.registry
.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]]
} else {
pos
};
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 {
self.message = Some((
"You may not rest now; the bed is too far away".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
// and finds where to stand up (findRespawnAndUseSpawnBlock).
// Straw beds never set it (`straw_bed_rule`).
if self.bed_sets_spawn(state) {
self.respawn_config = Some(respawn_anchor::RespawnConfig::wrapped(
self.dim, head, p.yaw, false,
));
// The fallback becomes the world spawn: a guest's is none of its
// own, so it follows `setworldspawn`.
self.spawn = if self.lan_acting.is_some() {
None
} else {
self.level
.world_spawn
.map(|[x, y, z]| {
Vec3::new(f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5)
})
.or(self.spawn)
};
}
if !night {
self.message = Some((
"You can sleep only at night or during thunderstorms".into(),
Instant::now(),
));
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
});
if monsters {
self.message = Some((
"You may not rest now; there are monsters nearby".into(),
Instant::now(),
));
return;
}
self.message = Some(("Respawn point set".into(), Instant::now()));
self.stop_mining();
self.left = false;
self.right = false;
self.using = None;
self.sleeping = Some(head);
self.sleep_timer = 0;
self.stats.custom("sleep_in_bed", 1);
self.trigger_player("minecraft:slept_in_bed");
self.stats.reset("custom", "minecraft:time_since_rest");
}
fn wake_up(&mut self) {
if self.remote.is_some() {
// InBedChatScreen.sendWakeUp: the server wakes the player.
self.remote_stop_sleeping();
return;
}
self.sleeping = None;
self.sleep_timer = 100;
}
fn tick_sleep(&mut self) {
self.sleep_timer = tick_sleep_timer(self.sleep_timer, self.sleeping.is_some());
if let Some(head) = self.sleeping {
if self.keys.contains(&KeyCode::ShiftLeft)
|| self
.player
.as_ref()
.is_none_or(|p| p.health.dead_or_dying())
{
self.wake_up();
return;
}
if let Some(p) = self.player.as_mut() {
p.position = Vec3::new(
f64::from(head[0]) + 0.5,
f64::from(head[1]) + 0.5625,
f64::from(head[2]) + 0.5,
);
p.velocity = Vec3::ZERO;
}
}
// ServerLevel.tick: once enough of the players have slept 100 ticks,
// skip to morning, clear the weather and wake everyone.
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.sleeping.is_some() {
self.wake_up();
}
self.wake_guests();
}
}
fn creative_origin(batch: &HudBatch) -> (f32, f32) {
batch.centered_origin(Creative::WIDTH, Creative::HEIGHT)
}
/// Vanilla tooltip: dark box with a purple gradient border.
fn tooltip(&self, batch: &mut HudBatch, text: &str, x: f32, y: f32) {
let atlas = &self.gui.atlas;
let w = HudBatch::text_width(atlas, text);
let (x, y) = (x + 12.0, y - 12.0);
batch.fill(atlas, x - 3.0, y - 4.0, w + 6.0, 16.0, rgba(16, 0, 16, 240));
batch.fill(atlas, x - 3.0, y - 3.0, w + 6.0, 1.0, rgba(80, 0, 255, 80));
batch.fill(atlas, x - 3.0, y + 10.0, w + 6.0, 1.0, rgba(40, 0, 127, 80));
batch.text(atlas, text, x, y, u32::MAX, true);
}
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();
let tab_sprite = |t: &horizon_client::creative::Tab, on: bool| {
format!(
"gui/sprites/container/creative_inventory/tab_{}_{}_{}",
if t.top { "top" } else { "bottom" },
if on { "selected" } else { "unselected" },
t.column + 1
)
};
batch.fill(
&self.gui.atlas,
0.0,
0.0,
batch.width,
batch.height,
rgba(16, 16, 16, 160),
);
// Unselected tabs behind the panel, then the panel, then the selected tab.
for (i, t) in tabs.iter().enumerate() {
if i != selected {
let (tx, ty) = Creative::tab_position(t);
batch.sprite(&self.gui.atlas, &tab_sprite(t, false), ox + tx, oy + ty);
}
}
let background = if tab.search {
"gui/container/creative_inventory/tab_item_search"
} else if tab.inventory {
"gui/container/creative_inventory/tab_inventory"
} else {
"gui/container/creative_inventory/tab_items"
};
if let Some(mut r) = self.gui.atlas.sprites.get(background).copied() {
r.u1 = r.u0 + (r.u1 - r.u0) * Creative::WIDTH / r.w as f32;
r.v1 = r.v0 + (r.v1 - r.v0) * Creative::HEIGHT / r.h as f32;
batch.rect_uv(ox, oy, Creative::WIDTH, Creative::HEIGHT, r, u32::MAX);
}
let (tx, ty) = Creative::tab_position(&tab);
batch.sprite(&self.gui.atlas, &tab_sprite(&tab, true), ox + tx, oy + ty);
for t in &tabs {
let (tx, ty) = Creative::tab_position(t);
let stack = ItemStack {
item: Arc::from(t.icon.as_str()),
count: 1,
damage: 0,
extra: None,
};
self.draw_item(
batch,
&stack,
ox + tx + 5.0,
oy + ty + if t.top { 9.0 } else { 7.0 },
);
}
let atlas = &self.gui.atlas;
if !tab.inventory {
batch.text(
atlas,
&tab.title,
ox + 8.0,
oy + 6.0,
rgba(64, 64, 64, 255),
false,
);
}
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(),
);
}
let mut hovered: Option<ItemStack> = None;
if tab.inventory {
self.draw_player_preview(
batch,
ox + 73.0,
oy + 6.0,
ox + 105.0,
oy + 49.0,
20.0,
0.0625,
);
self.draw_inventory_slots(batch, ox, oy);
if Self::creative_trash_hovered(batch, self.cursor) {
let (x, y) = Creative::TRASH_POSITION;
batch.fill(
&self.gui.atlas,
ox + x,
oy + y,
16.0,
16.0,
rgba(255, 255, 255, 128),
);
}
if let Some(slot) = self.slot_at(batch, self.cursor.0, self.cursor.1) {
let (x, y) = self.slot_position(slot);
batch.fill(
&self.gui.atlas,
ox + x,
oy + y,
16.0,
16.0,
rgba(255, 255, 255, 128),
);
}
} else {
let items = self.creative_screen.items(&self.pack.names);
let first = self.creative_screen.first_row(&self.pack.names);
for r in 0..5 {
for c in 0..9 {
let Some(stack) = items.get((first + r) * 9 + c) else {
continue;
};
let (x, y) = (ox + 9.0 + c as f32 * 18.0, oy + 18.0 + r as f32 * 18.0);
self.draw_item(batch, stack, x, y);
if self.cursor.0 >= x
&& self.cursor.0 < x + 16.0
&& self.cursor.1 >= y
&& self.cursor.1 < y + 16.0
{
batch.fill(&self.gui.atlas, x, y, 16.0, 16.0, rgba(255, 255, 255, 128));
hovered = Some(stack.clone());
}
}
}
let drag = self.drag_view();
for c in 0..9 {
let (x, y) = (ox + 9.0 + c as f32 * 18.0, oy + 112.0);
let stack = self.inventory[c].clone();
self.draw_slot_item(batch, drag.as_ref(), c, stack.clone(), x, y);
if self.cursor.0 >= x
&& self.cursor.0 < x + 16.0
&& self.cursor.1 >= y
&& self.cursor.1 < y + 16.0
{
batch.fill(&self.gui.atlas, x, y, 16.0, 16.0, rgba(255, 255, 255, 128));
hovered = stack;
}
}
let scrollable = self.creative_screen.rows(&self.pack.names) > 5;
let scroller = if scrollable {
"gui/sprites/container/creative_inventory/scroller"
} else {
"gui/sprites/container/creative_inventory/scroller_disabled"
};
batch.sprite(
&self.gui.atlas,
scroller,
ox + Creative::SCROLL_X,
oy + Creative::SCROLL_Y + self.creative_screen.scroller_offset(),
);
}
for t in &tabs {
let (tx, ty) = Creative::tab_position(t);
if self.cursor.0 >= ox + tx
&& self.cursor.0 < ox + tx + 26.0
&& self.cursor.1 >= oy + ty
&& self.cursor.1 < oy + ty + 32.0
{
self.tooltip(batch, &t.title, self.cursor.0, self.cursor.1);
}
}
self.draw_carried(batch);
if tab.inventory {
if Self::creative_trash_hovered(batch, self.cursor) {
self.tooltip(batch, "Destroy Item", self.cursor.0, self.cursor.1);
} else {
self.draw_slot_tooltip(batch);
}
} 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_inventory_effects(batch, (ox, oy), Creative::WIDTH as i32);
}
fn creative_trash_hovered(batch: &HudBatch, cursor: (f32, f32)) -> bool {
let (ox, oy) = Self::creative_origin(batch);
let (x, y) = Creative::TRASH_POSITION;
cursor.0 >= ox + x
&& cursor.0 < ox + x + 16.0
&& cursor.1 >= oy + y
&& cursor.1 < oy + y + 16.0
}
fn click_creative(&mut self, right: bool) {
let Some(size) = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
else {
return;
};
let batch = HudBatch::new(size);
let (ox, oy) = Self::creative_origin(&batch);
let (cx, cy) = self.cursor;
let tabs = self.creative_screen.tabs.clone();
for (i, t) in tabs.iter().enumerate() {
let (tx, ty) = Creative::tab_position(t);
if cx >= ox + tx && cx < ox + tx + 26.0 && cy >= oy + ty && cy < oy + ty + 32.0 {
select_creative_tab(&mut self.creative_screen, &mut self.inv_clicks, i);
self.inv_drag = None;
self.last_inv_click = None;
return;
}
}
if self.creative_inventory_open() {
if Self::creative_trash_hovered(&batch, self.cursor) {
if self.has_shift_down() {
let before = self.player_equipment();
self.inventory.fill(None);
self.armor.fill(None);
self.offhand = None;
self.craft_grid[..4].fill(None);
self.player_equipment_changed(&before);
self.apply_equipment();
} else {
self.carried = None;
}
self.inv_drag = None;
self.inv_clicks = Default::default();
} else if self.slot_at(&batch, cx, cy).is_some() || self.clicked_outside(&batch) {
self.inventory_press(right);
}
return;
}
// Holding the scrollbar scrolls as the mouse moves (mouseDragged).
if !right
&& self
.creative_screen
.press_scrollbar(cx - ox, cy - oy, &self.pack.names)
{
return;
}
if self.slot_at(&batch, cx, cy).is_some() || self.clicked_outside(&batch) {
self.inventory_press(right);
}
}
/// 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.
self.level.game_rules = self.ui.rules.by_name();
self.level.selected_slot = self.selected as i32;
let mode = self.mode_id();
let level = &mut self.level;
level.creative = self.creative;
level.game_mode = mode;
level.time = self.world.game_time;
level.weather = self.world.weather;
level.day_time = self.world.day_time;
level.spawn = self.spawn.map(|s| [s.x, s.y, s.z]);
level.respawn_elsewhere = self.respawn_config.map(|c| c.saved());
level.rotation = [self.yaw, self.pitch];
level.xp_level = self.experience.level;
level.xp_progress = self.experience.progress;
level.xp_total = self.experience.total;
if let Some(p) = &self.player {
level.position = Some([p.position.x, p.position.y, p.position.z]);
level.health = p.health.health();
level.absorption = p.health.absorption();
let extra = level
.player_extra
.get_or_insert_with(|| horizon_world::nbt::Tag::Compound(Default::default()));
if let horizon_world::nbt::Tag::Compound(map) = extra {
map.insert(
"Fire".into(),
horizon_world::nbt::Tag::Short(
p.fire_ticks.clamp(i32::from(i16::MIN), i32::from(i16::MAX)) as i16,
),
);
map.insert("Air".into(), horizon_world::nbt::Tag::Short(p.air as i16));
}
level.fall_distance = p.fall_distance;
level.food = p.health.food.food;
level.saturation = p.health.food.saturation;
level.flying = p.flying;
}
level.inventory = self
.inventory
.iter()
.enumerate()
.filter_map(|(i, s)| {
s.as_ref()
.map(|s| (i as u8, s.item.to_string(), s.count, s.damage))
})
.collect();
level.inventory_components = self
.inventory
.iter()
.enumerate()
.filter_map(|(i, s)| Some((i as u8, s.as_ref()?.extra.clone()?)))
.collect();
if let Some(s) = &self.offhand {
level
.inventory
.push((150, s.item.to_string(), s.count, s.damage));
if let Some(extra) = s.extra.clone() {
level.inventory_components.insert(150, extra);
}
}
// Vanilla stores armor in slots 100 (feet) to 103 (head).
for (i, s) in self.armor.iter().enumerate() {
if let Some(s) = s {
level
.inventory
.push((103 - i as u8, s.item.to_string(), s.count, s.damage));
if let Some(extra) = s.extra.clone() {
level.inventory_components.insert(103 - i as u8, extra);
}
}
}
level.dimension = self.dim.id().to_owned();
// An open ender chest holds the live copy.
if let Some(key) = self.ender_open
&& let Some(BlockEntity::Chest(items)) = self.world.block_entities.get(&key)
{
self.ender_items = items.clone();
}
level.ender_items = self.ender_items.clone();
level.active_effects = self.potions.effects.saved();
}
fn save_game(&mut self) -> Result<()> {
self.save_game_with(true)
}
/// The autosave doesn't `wait` for the chunks to be on disk: every
/// generated chunk is saved, hundreds at a time, encoded and written on
/// the region writer meanwhile.
fn save_game_with(&mut self, wait: bool) -> Result<()> {
if self.remote.is_some() {
return Ok(());
}
self.save_level(wait)?;
self.save_parked_levels(wait)?;
self.save_game_metadata()
}
fn save_game_metadata(&mut self) -> Result<()> {
self.save_maps();
self.save_random_sequences();
self.save_fight();
self.save_wandering_trader();
self.save_portal_arrivals();
self.save_stats();
self.save_advancements();
self.save_scoreboard();
self.save_bossbars();
self.save_schedule();
self.save_warden_tracker();
self.sync_level();
self.store_owner();
self.level.write(&self.world_root)?;
self.save_world_state();
self.message = Some(("Saved the game".into(), Instant::now()));
Ok(())
}
/// Save the level in place: its changed chunks, its entities and its raids.
fn save_level(&mut self, wait: bool) -> Result<()> {
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)));
self.save
.save_later(&chunks, self.pack.assets.registry, self.res.biomes())?;
// Prepare entities while the chunk writer runs, then use one barrier.
self.save_entities(false)?;
self.save_raids();
if wait {
self.save.flush()?;
}
Ok(())
}
fn render(&mut self) -> Result<bool> {
if let Some(loader) = &self.world_loader {
if let Some(renderer) = &mut self.renderer {
let mut hud = HudBatch::new([renderer.config.width, renderer.config.height]);
horizon_client::level_loading::draw_progress(
&mut hud,
&self.gui.atlas,
if loader.cancelled {
"Cancelling world"
} else {
"Opening world"
},
0.0,
);
return renderer.render(&loading_frame(&hud));
}
return Ok(false);
}
if self.pending_entry.is_some() {
if let (Some(renderer), Some(loader)) = (&mut self.renderer, &self.rest_loader) {
let mut hud = HudBatch::new([renderer.config.width, renderer.config.height]);
horizon_client::level_loading::draw_progress(
&mut hud,
&self.gui.atlas,
loader.progress.line(),
loader.progress.fraction(),
);
return renderer.render(&loading_frame(&hud));
}
return Ok(false);
}
let Some(size) = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
else {
return Ok(false);
};
let alpha = self.clock.fraction();
// Camera.getCameraEntityPartialTicks: the view, the hand and the
// player's own model stay smooth while the level is frozen.
let camera_alpha = self.clock.camera_fraction();
let view = self.camera_view(camera_alpha as f32);
let (camera, underwater, view_yaw, view_pitch) = match view {
Some((c, yaw, pitch)) => {
let s =
self.world
.block(c.x.floor() as i32, c.y.floor() as i32, c.z.floor() as i32);
(c, self.res.facts().get(s).fluid == Fluid::Water, yaw, pitch)
}
None => (
glam::DVec3::new(0.5, 100.0, 0.5),
false,
self.yaw,
self.pitch,
),
};
self.audio
.set_listener([camera.x, camera.y, camera.z], view_yaw, view_pitch);
let block = [
camera.x.floor() as i32,
camera.y.floor() as i32,
camera.z.floor() as i32,
];
// The camera inside an opaque block sees nothing through it: disable.
let cave_culling = self.settings.horizon.cave_culling
&& !self
.res
.facts()
.get(self.world.block(block[0], block[1], block[2]))
.solid_render;
// The cave culling search runs on its worker while the frame is prepared.
if cave_culling
&& self.title.is_none()
&& let Some(renderer) = self.renderer.as_mut()
{
horizon_client::spans::time("occlusion", || {
renderer.start_occlusion(camera, (self.streaming.radius * 16) as f32)
});
}
let biome = self
.world
.chunks
.get(&(block[0] >> 4, block[2] >> 4))
.map(|c| c.biome(block[0], block[1], block[2]))
.unwrap_or(0);
let environment = self.dim_environment();
// EnvironmentAttributeProbe: the spatially interpolated biome colours,
// Gaussian-weighted over the noise biomes around the camera (plains
// where no chunk is loaded, as ClientLevel.getUncachedNoiseBiome).
let biomes = self.res.biomes();
let weights = {
let chunks = &self.world.chunks;
let plains = biomes.id("minecraft:plains");
horizon_client::biome::gaussian_weights(camera.to_array(), |qx, qy, qz| {
chunks
.get(&(qx >> 2, qz >> 2))
.map_or(plains, |c| c.biome(qx * 4, qy * 4, qz * 4))
})
};
let blend = |pick: fn(&horizon_client::biome::BiomeInfo) -> Option<u32>, base: [f32; 3]| {
horizon_client::biome::blend_rgb(&weights, |b| {
pick(biomes.get(b)).map_or(base, horizon_client::biome::rgb)
})
};
let biome_sky = blend(
|b| b.sky,
environment.base_rgb("minecraft:visual/sky_color"),
);
let biome_fog = blend(
|b| b.fog,
environment.base_rgb("minecraft:visual/fog_color"),
);
// visual/water_fog_color: no dimension sets it, its default is #050533.
let water_fog = blend(|b| Some(b.water_fog), [0.0; 3]);
let mut sky = environment.sample(self.world.day_time, Some(biome_sky), Some(biome_fog));
let (rain, thunder) = if self.dim == Dim::Overworld {
self.world.weather.levels(alpha as f32)
} else {
(0.0, 0.0)
};
horizon_client::environment::apply_weather(&mut sky, rain, thunder);
self.end_flash_sky(&mut sky, alpha);
if self.flash > 0 && !self.settings.file.bool("hideLightningFlashes") {
// Lightning flash brightens the sky (LevelRenderer skyFlashTime).
sky.sky_color = [0.9, 0.9, 1.0];
sky.sky_light_factor = 1.0;
}
// FishingHookRenderer's line, then DebugRenderer: chunk borders and
// hitboxes (F3+G, F3+B).
let mut lines = self.fishing_line(alpha, size);
let mut on_top = Vec::new();
if self.show_hitboxes || self.show_chunk_borders {
let g = self.debug_gizmos(alpha as f32);
lines.extend(g.lines);
on_top = g.on_top;
}
let view = horizon_client::camera::view_matrix(view_yaw, view_pitch);
let at = camera.to_array();
// GameRenderer.render3dHud: the debug crosshair, first person with the HUD shown.
let mut crosshair = horizon_client::gizmos::Gizmos::default();
if self.debug_crosshair() && self.camera_type.first_person() && !self.ui.hide_gui {
let scale = HudBatch::new(size).scale;
crosshair.debug_crosshair(at, view_pitch, view_yaw, scale);
}
let debug_lines = horizon_client::gizmos::camera_relative(&lines, at, view);
let debug_lines_on_top = horizon_client::gizmos::camera_relative(&on_top, at, view);
let debug_crosshair = horizon_client::gizmos::camera_relative(&crosshair.on_top, at, view);
// LevelExtractor.extractBlockOutline: model translucency controls draw order.
let mut outline_after_terrain = false;
let outline = if self.screen == Screen::Playing && !self.spectator() {
self.pick()
.map(|h| {
let state = self.world.block(h.pos[0], h.pos[1], h.pos[2]);
let f = self.res.facts().get(state);
outline_after_terrain = self
.pack
.render
.model_catalog
.collect(state, BlockPos::new(h.pos[0], h.pos[1], h.pos[2]))
.is_ok_and(|models| {
models
.iter()
.any(|(_, model)| model.faces.iter().any(|f| f.translucent))
});
let o = if f.outline_offset {
self.pack
.context
.tables
.offset(state, h.pos[0], h.pos[2])
.unwrap_or([0.0; 3])
} else {
[0.0; 3]
};
let p = h.pos.map(f64::from);
f.outline_edges
.iter()
.map(|e| std::array::from_fn(|i| p[i % 3] + o[i % 3] + e[i]))
.collect()
})
.unwrap_or_default()
} else {
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);
let (yaw, pitch) = if title {
// PanoramaRenderer: the title cube spins at 0.1 degrees per tick, pitched 10 degrees.
(
self.panorama_rotation.update(
self.started.elapsed().as_secs_f32(),
self.settings.file.double("panoramaScrollSpeed") as f32,
),
10.0,
)
} else {
(view_yaw, view_pitch)
};
let fov_degrees = if title {
85.0
} else {
self.fov_degrees(camera_alpha as f32, camera.to_array())
};
self.locator_camera =
(!title).then_some((camera.to_array(), view_yaw, view_pitch, fov_degrees));
let bob = if title {
glam::Mat4::IDENTITY
} else {
self.bob_matrix(camera_alpha as f32)
};
let terrain_distance = self.terrain_distance();
let distance = (terrain_distance * 16) as f32;
let depth_far =
horizon_client::camera::depth_far(terrain_distance, self.settings.cloud_range);
self.view_frustum = self
.renderer
.as_ref()
.map(|r| r.camera_frustum(fov_degrees, yaw, pitch, bob, depth_far));
// Keep the buffer local while builders need mutable access to the game.
let mut entities = std::mem::take(&mut self.entity_vertices);
entities.clear();
self.see_through_vertices.clear();
if !title {
entities = horizon_client::spans::time("entity_geometry", || {
self.entity_geometry(camera, alpha, entities)
});
}
let bolts = if title {
Vec::new()
} else {
self.bolt_instances()
};
let mut additive = Vec::new();
if !title && self.dim == Dim::End {
let mut dragon = Vec::new();
self.dragon_geometry(camera, alpha, &mut dragon, &mut additive);
self.dragon_fireball_geometry(camera, alpha, &mut dragon);
entities.extend(dragon);
}
let (celestial, stars) = if title {
(Vec::new(), None)
} else if self.dim == Dim::Overworld
&& self.potions.effects.get("darkness").is_none()
&& self.potions.effects.get("blindness").is_none()
{
// Camera.doesMobEffectBlockSky: no sun, moon or stars.
self.celestial_geometry(&sky)
} else if self.dim == Dim::End && self.settings.horizon.sky {
(self.end_flash_geometry(), None)
} else {
(Vec::new(), None)
};
let hand = if title || self.scoping() {
Vec::new()
} else {
self.hand_geometry(camera_alpha)
};
let screen = if title {
Vec::new()
} else {
self.screen_quads(alpha as f32, size)
};
if !title {
self.end_geometry(camera, &mut entities);
}
let weather = if !title && self.dim == Dim::Overworld && self.settings.horizon.weather {
horizon_client::spans::time("weather", || self.weather_geometry(camera, alpha))
} else {
Vec::new()
};
let border = (!title)
.then(|| self.border_draw(camera.to_array(), alpha as f32))
.flatten();
let see_through = std::mem::take(&mut self.see_through_vertices);
if title {
self.dynamic_lights.clear();
} else {
self.gather_dynamic_lights(camera, alpha);
}
let pack_inputs = if title {
Default::default()
} else {
self.shader_pack_inputs(camera, alpha as f32)
};
let frame = Frame {
weather: &weather,
weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32),
nether_lighting: self.dim == Dim::Nether,
camera,
yaw,
pitch,
fov_degrees,
bob,
sky,
distance,
detail_distance: (self.streaming.radius * 16) as f32,
depth_far,
underwater,
title,
skybox: self.dim == Dim::Overworld && self.settings.horizon.sky,
end_sky: self.dim == Dim::End && self.settings.horizon.sky,
end_sky_sprite: self
.gui
.atlas
.sprites
.get("environment/end_sky")
.map(|r| [r.u0, r.v0, r.u1, r.v1]),
environment_fog: (self.dim == Dim::Nether).then_some((sky.fog_start, sky.fog_end)),
cave_culling,
water_fog,
fog: Some({
let mut fog = self.frame_fog(camera, &sky, biome, water_fog);
// Horizon's fog setting: no distance fog (fluids keep theirs).
if !self.settings.horizon.fog
&& !underwater
&& self.darkness_fog().is_none()
&& !self.boss_overlay.should_create_world_fog()
&& self.potions.effects.get("blindness").is_none()
&& fog.environmental_end >= (self.streaming.radius * 16) as f32
{
(fog.render_distance_start, fog.render_distance_end) = (1e9, 2e9);
(fog.environmental_start, fog.environmental_end) = (1e9, 2e9);
}
fog
}),
dark_disc: self.dark_disc(camera),
outline,
outline_after_terrain,
debug_lines: &debug_lines,
debug_lines_on_top: &debug_lines_on_top,
debug_crosshair: &debug_crosshair,
hud: &hud,
clouds: (!title
&& self.dim == Dim::Overworld
&& horizon_client::clouds::visible(&self.settings.clouds, sky.cloud_color[3]))
.then(|| self.gui.atlas.sprites.get("horizon/white"))
.flatten()
.map(|white| horizon_client::clouds::Input {
texture: &self.pack.clouds,
uv: [(white.u0 + white.u1) / 2.0, (white.v0 + white.v1) / 2.0],
camera,
time: self.world.game_time,
partial_tick: alpha,
range: self.settings.cloud_range,
fast: self.settings.clouds == "fast",
color: sky.cloud_color,
}),
entities: &entities,
dynamic_lights: &self.dynamic_lights,
lightning: horizon_client::gfx::lightning::Input {
bolts: &bolts,
uv: [
self.gui.atlas.font.white().u0,
self.gui.atlas.font.white().v0,
],
},
additive: &additive,
see_through: &see_through,
celestial: if self.settings.horizon.sky || title {
&celestial
} else {
&[]
},
stars: stars.filter(|_| self.settings.horizon.sky || title),
hand: &hand,
hand_fov_degrees: self.hud_fov_degrees(camera_alpha as f32, camera.to_array()),
screen: &screen,
pack: pack_inputs,
border,
game_time: self.world.game_time as f32,
shader_game_time: ((self.world.game_time % 24000) as f32 + alpha as f32) / 24000.0,
crumbling_sprite: self
.gui
.atlas
.sprites
.get("block/destroy_stage_0")
.map_or([0.0; 4], |r| [r.u0, r.v0, r.u1 - r.u0, r.v1 - r.v0]),
end_portal_sprites: ["environment/end_sky", "entity/end_portal/end_portal"].map(|n| {
self.gui
.atlas
.sprites
.get(n)
.map_or([0.0; 4], |r| [r.u0, r.v0, r.u1 - r.u0, r.v1 - r.v0])
}),
ticks: self.ticks,
darkness: self.darkness_lighting(alpha as f32),
night_vision: self.night_vision_intensity(),
block_flicker: self.fog.block_light_flicker,
boss_darken: self
.boss_overlay
.darken_amount(self.clock.fraction() as f32),
menu_blur: self.menu_blur(),
};
let result = match self.renderer.as_mut() {
Some(renderer) => horizon_client::spans::time("renderer", || renderer.render(&frame)),
None => Err("renderer".into()),
};
// Restore storage even when rendering fails (for example, a lost surface).
self.entity_vertices = entities;
self.see_through_vertices = see_through;
result
}
/// The LevelLoadingScreen shown while the player waits for its chunks:
/// opening a world, or after a portal or a respawn into another dimension.
fn loading_reason(&self) -> Option<horizon_client::level_loading::Reason> {
use horizon_client::level_loading::Reason;
if self.title.is_some() || self.remote.is_some() || self.player.is_some() {
return None;
}
Some(
if self.travelling.is_none() || self.respawn_travel.is_some() {
Reason::Other
} else if self.end_travel {
Reason::EndPortal
} else {
Reason::NetherPortal
},
)
}
/// `LevelLoadTracker.serverProgress`: the player's 7x7 chunks loaded.
fn level_load_progress(&self) -> f32 {
let (cx, cz) = self.streaming.center;
let ready = (-3..=3)
.flat_map(|dz| (-3..=3).map(move |dx| (cx + dx, cz + dz)))
.filter(|&(x, z)| self.streaming.is_lit(x, z))
.count();
horizon_client::level_loading::progress(ready)
}
/// `LevelLoadingScreen.extractBackground` and `extractRenderState`.
fn draw_level_loading(
&self,
batch: &mut HudBatch,
reason: horizon_client::level_loading::Reason,
) {
use horizon_client::level_loading::{self, Reason, STATUS_RADIUS};
let atlas = &self.gui.atlas;
let (w, h) = (batch.width, batch.height);
match reason {
// The panorama and its blur are drawn by the renderer.
Reason::Other => {
horizon_client::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false)
}
Reason::NetherPortal => {
let overlay = hud_overlays::portal_overlay(w as i32, h as i32, 1.0);
hud_layout::paint(batch, atlas, &[overlay]);
}
Reason::EndPortal => batch.fill(atlas, 0.0, 0.0, w, h, rgba(20, 20, 20, 255)),
}
let (cx, cz) = self.streaming.center;
let status = |x: i32, z: i32| {
self.streaming.latest_status(
&self.world,
cx + x - STATUS_RADIUS,
cz + z - STATUS_RADIUS,
)
};
level_loading::draw(batch, atlas, Some(&status), Some(self.loading_progress));
}
/// `Screen.extractBlurredBackground` over the panorama or the world and
/// HUD, when `menuBackgroundBlurriness` is at least 1.
fn menu_blur(&self) -> Option<f32> {
let loading = self.loading_reason() == Some(horizon_client::level_loading::Reason::Other);
let blurred = loading
|| self.title.as_ref().is_some_and(|t| {
matches!(self.screen, Screen::Options | Screen::Win)
|| !matches!(t.mode, horizon_client::title::Mode::Main)
})
|| (self.title.is_none()
&& self.player.is_some()
&& (self.screen.blurs_background(self.pause_menu)
|| (self.screen == Screen::Win && self.win_screen_pauses())));
let radius = self.settings.menu_blur as f32;
(blurred && radius >= 1.0).then_some(radius)
}
/// `LevelExtractor` / `LevelRenderer`: the world border wall this frame.
fn border_draw(
&mut self,
camera: [f64; 3],
partial: f32,
) -> Option<horizon_client::gfx::BorderDraw> {
use horizon_client::border_render::{self, BorderRenderer};
let distance = f64::from(self.streaming.radius * 16);
border_render::extract(
&self.border,
partial,
camera,
distance,
&mut self.border_state,
);
// Camera.depthFar, as the renderer's far plane.
let depth_far =
horizon_client::camera::depth_far(self.terrain_distance(), self.settings.cloud_range);
if !self
.border_renderer
.prepare(&self.border_state, camera, distance, depth_far)
{
return None;
}
let millis = self.started.elapsed().as_millis() as i64;
Some(horizon_client::gfx::BorderDraw {
vertices: self.border_renderer.vertices,
rebuilt: self.border_renderer.take_rebuilt(),
transforms: self
.border_renderer
.transforms(&self.border_state, camera, millis),
sides: BorderRenderer::sides(&self.border_state, camera, distance),
})
}
/// A key press while a world is open (keyboard or control socket).
fn key_pressed(&mut self, key: KeyCode) -> Result<()> {
if self.sleeping.is_some()
&& self.screen == Screen::Playing
&& !matches!(
key,
KeyCode::F1 | KeyCode::F2 | KeyCode::F11 | KeyCode::KeyT | KeyCode::Slash
)
{
if matches!(key, KeyCode::Escape | KeyCode::ShiftLeft) {
self.wake_up();
}
return Ok(());
}
if self.sort_key_press(key) {
return Ok(());
}
if self.remote.is_some() && self.remote_key(key)? {
return Ok(());
}
match key {
KeyCode::Escape => match self.screen {
Screen::Options => self.options_key(KeyCode::Escape, None)?,
Screen::Playing => {
self.screen = Screen::Paused;
self.pause_menu = true;
self.capture(false);
}
Screen::Creative => {
self.carried = None;
self.screen = Screen::Playing;
self.capture(true);
}
Screen::Paused | Screen::Inventory => {
self.close_container();
self.screen = Screen::Playing;
self.pause_menu = true;
self.capture(true);
}
Screen::GameModeSwitcher => self.close_gamemode_switcher(false),
Screen::Dead => {}
Screen::Stats | Screen::Friends => self.screen = Screen::Paused,
Screen::Advancements => self.close_advancements(),
Screen::WorldOptions => self.world_options_escape(),
Screen::CommandBlock => self.close_command_block(),
Screen::Chat => self.close_chat(),
Screen::Win => self.close_win_screen()?,
},
KeyCode::Digit1
| KeyCode::Digit2
| KeyCode::Digit3
| KeyCode::Digit4
| KeyCode::Digit5
| KeyCode::Digit6
| KeyCode::Digit7
| KeyCode::Digit8
| KeyCode::Digit9
| KeyCode::KeyF
| KeyCode::KeyQ
if (self.screen == Screen::Inventory
|| (self.screen == Screen::Creative && !self.creative_screen.tab().search))
&& self.inventory_hotkey(key) => {}
// The search tab's number keys (scripted presses; the window's
// keys reach search_tab_hotbar_key before the search box).
_ if self.screen == Screen::Creative
&& self.creative_screen.tab().search
&& self.search_tab_hotbar_key(key) => {}
KeyCode::KeyT if self.screen == Screen::Inventory => self.recipe_focus_search(),
KeyCode::KeyT if self.screen == Screen::Playing => self.open_chat(""),
// key.advancements.
KeyCode::KeyL if self.screen == Screen::Playing => self.open_advancements(false),
KeyCode::KeyL if self.screen == Screen::Advancements => self.close_advancements(),
KeyCode::Slash if self.screen == Screen::Playing => self.open_chat("/"),
KeyCode::F1 => self.toggle_hide_gui(),
KeyCode::F11 => self.toggle_fullscreen(),
KeyCode::F2 => self.take_screenshot(),
KeyCode::F5 if self.screen == Screen::Playing => self.cycle_camera(),
KeyCode::KeyE
if self.screen == Screen::Creative && self.creative_screen.tab().search => {}
KeyCode::KeyE => match self.screen {
Screen::Playing if self.spectator() => {}
Screen::Playing => {
// key.inventory while riding a tamed mount opens its inventory.
if !self.open_ridden_mount_menu() {
self.screen = if self.creative {
Screen::Creative
} else {
Screen::Inventory
};
self.capture(false);
}
}
Screen::Creative => {
if let Some(c) = self.carried.take() {
let _ = self.give(c);
}
self.screen = Screen::Playing;
self.capture(true);
}
Screen::Inventory => {
self.close_container();
self.screen = Screen::Playing;
self.capture(true);
}
_ => {}
},
// key.swapOffhand: on a server, ServerboundPlayerActionPacket SWAP_ITEM_WITH_OFFHAND
// (the server swaps the hands and sends both slots back; spectators can't).
KeyCode::KeyF if self.screen == Screen::Playing && self.remote.is_some() => {
if !self.spectator() {
self.remote_swap_hands();
}
}
KeyCode::KeyF if self.screen == Screen::Playing => {
// handlePlayerAction SWAP_ITEM_WITH_OFFHAND: setItemInHand for
// the off hand, then the main hand.
std::mem::swap(&mut self.offhand, &mut self.inventory[self.selected]);
let (offhand, main) = (self.offhand.clone(), self.inventory[self.selected].clone());
self.player_on_equip("offhand", main.as_ref(), offhand.as_ref());
self.player_on_equip("mainhand", offhand.as_ref(), main.as_ref());
self.using = None;
}
KeyCode::KeyQ if self.screen == Screen::Playing => {
let all = drop_whole_stack(&self.physical_keys);
self.drop_held(all);
}
KeyCode::Digit1
| KeyCode::Digit2
| KeyCode::Digit3
| KeyCode::Digit4
| KeyCode::Digit5
| KeyCode::Digit6
| KeyCode::Digit7
| KeyCode::Digit8
| KeyCode::Digit9
if self.screen == Screen::Playing =>
{
self.selected = match key {
KeyCode::Digit1 => 0,
KeyCode::Digit2 => 1,
KeyCode::Digit3 => 2,
KeyCode::Digit4 => 3,
KeyCode::Digit5 => 4,
KeyCode::Digit6 => 5,
KeyCode::Digit7 => 6,
KeyCode::Digit8 => 7,
_ => 8,
};
}
_ => {}
}
Ok(())
}
/// A mouse button while playing (window or control socket).
fn play_mouse(&mut self, button: MouseButton, pressed: bool) -> Result<()> {
if self.sleeping.is_some() {
return Ok(());
}
if self.remote.is_some() {
return self.remote_mouse(button, pressed);
}
match button {
MouseButton::Left => {
// KeyMapping.click: Minecraft.tick starts the attack.
if pressed {
self.attack_clicks += 1;
}
self.toggles
.button(2, pressed, false, self.settings.toggle_attack);
self.left = self.toggles.is_down(2);
}
MouseButton::Right => {
self.toggles
.button(3, pressed, false, self.settings.toggle_use);
self.right = self.toggles.is_down(3);
// handleKeybinds consumes use clicks without acting while an
// item is in use.
if pressed && self.using.is_none() {
self.use_with_hand()?;
self.use_delay = 4;
}
}
MouseButton::Middle if pressed => {
// Minecraft.pickBlockOrEntity -> the server's handlePickItemFromBlock:
// the block's clone item, with its block entity's data on Ctrl in
// creative, picked from the inventory (`pick_item`).
if let Some(hit) = self.pick() {
let include_data = self.creative && self.has_control_down();
if let Some(stack) = self.picked_stack(hit.pos, include_data) {
let infinite = self.creative;
horizon_client::pick_item::pick(
&mut self.inventory[..36],
&mut self.selected,
&stack,
infinite,
);
}
}
}
_ => {}
}
Ok(())
}
/// LOD Distance as far terrain uses it (`Graphics::lod_distance_on`).
fn lod_distance(&self) -> u32 {
match &self.renderer {
Some(renderer) => self.settings.horizon.lod_distance_on(&renderer.info),
None => self.settings.horizon.lod_distance.min(1024),
}
}
/// Only enabled LOD worlds extend the renderer's range, never simulation.
fn terrain_distance(&self) -> i32 {
if self.lod.is_some() {
self.streaming.radius.max(self.lod_distance() as i32)
} else {
self.streaming.radius
}
}
fn clear_lod(&mut self) {
self.lod = None;
self.lod_source_attempted = false;
self.lod_observe.clear();
self.lod_covered_at = None;
if let Some(renderer) = &mut self.renderer {
renderer.clear_lods();
}
}
fn prepare_lod(&mut self) {
let enabled = self.settings.horizon.lod_distance > 0
&& self.renderer.is_some()
&& self.player.is_some()
&& self.title.is_none()
&& (self.remote.is_none() || self.integrated.is_some());
if !enabled {
if self.lod.is_some() || self.lod_source_attempted {
self.clear_lod();
}
return;
}
if self.lod_source_attempted {
return;
}
self.lod_source_attempted = true;
let source = match &self.integrated {
Some(server) => server.call(|game| game.streaming.lod_source()),
None => Some(self.streaming.lod_source()),
};
if let Some(source) = source {
self.lod = Some(horizon_client::lod::Lod::new(
source,
self.pack.context.clone(),
));
self.lod_observe.extend(self.world.chunks.keys().copied());
}
}
fn update_world(&mut self) {
if let Err(e) = self.poll_remote() {
log::warn!("Horizon: {e}");
}
self.prepare_lod();
if self.lod.is_some() {
for &((x, _, z), _, _) in &self.world.light_edits {
self.lod_observe.insert((x >> 4, z >> 4));
}
}
if let Some(p) = &self.player {
self.streaming.center = (
(p.position.x.floor() as i32) >> 4,
(p.position.z.floor() as i32) >> 4,
);
}
// The loading screen's chunk map fills ring by ring, as vanilla's.
self.streaming.loading =
self.options.execution_role.is_client() && self.loading_reason().is_some();
let (uploads, unloaded) =
horizon_client::spans::time("streaming", || self.streaming.update(&mut self.world));
if let Some(lod) = &mut self.lod {
self.lod_observe
.extend(uploads.iter().map(|(key, _)| (key.0, key.2)));
for chunk in &unloaded {
self.lod_observe.remove(&(chunk.x, chunk.z));
}
// Unloaded columns first (their summaries are all that remains),
// then a few resident ones (an edit copies a chunk the worker
// still holds). The worker summarizes them.
horizon_client::spans::time("lod_observe", || {
for chunk in &unloaded {
lod.observe(chunk.clone(), self.res.facts());
}
while lod.observing() < horizon_client::lod::OBSERVE_AHEAD
&& let Some(&key) = self.lod_observe.iter().next()
{
self.lod_observe.remove(&key);
if let Some(chunk) = self.world.chunks.get(&key) {
lod.observe(chunk.clone(), self.res.facts());
}
}
});
}
let dirty: Vec<_> = unloaded
.iter()
.filter(|c| self.world.modified.remove(&(c.x, c.z)))
.cloned()
.collect();
let modified = horizon_client::spans::time("with_entities", || self.with_entities(&dirty));
horizon_client::spans::time("unload_entities", || self.unload_entities(&unloaded));
if !unloaded.is_empty() {
let gone: horizon_client::fast_hash::FxHashSet<(i32, i32)> =
unloaded.iter().map(|c| (c.x, c.z)).collect();
self.world
.block_entities
.retain(|p, _| !gone.contains(&(p.0 >> 4, p.2 >> 4)));
self.world
.block_names
.retain(|p, _| !gone.contains(&(p.0 >> 4, p.2 >> 4)));
}
if !modified.is_empty()
&& let Err(e) = horizon_client::spans::time("save_chunks", || {
self.save
.save_later(&modified, self.pack.assets.registry, self.res.biomes())
})
{
log::warn!("Horizon: failed to save unloaded chunks: {e}");
}
if let Some(renderer) = self.renderer.as_mut() {
let g = &self.settings.horizon;
let budgeted = g.chunk_updates > 0 || g.upload_budget_kib > 0;
if !budgeted && self.pending_uploads.is_empty() {
horizon_client::spans::time("upload", || {
for (key, mesh) in uploads {
renderer.upload(key, &mesh);
}
});
} else {
// Horizon's chunk-update and upload budgets: the nearest
// sections go first, the rest wait for later frames; a newer
// mesh of a waiting section replaces it, and sections of
// chunks no longer loaded are dropped.
let pending = &mut self.pending_uploads;
let fresh: horizon_client::fast_hash::FxHashSet<(i32, i32, i32)> =
uploads.iter().map(|(k, _)| *k).collect();
let chunks = &self.world.chunks;
pending.retain(|(k, _)| !fresh.contains(k) && chunks.contains_key(&(k.0, k.2)));
pending.extend(
uploads
.into_iter()
.filter(|(k, _)| chunks.contains_key(&(k.0, k.2))),
);
let centre = self.streaming.center;
let far = |k: &(i32, i32, i32)| (k.0 - centre.0).pow(2) + (k.2 - centre.1).pow(2);
pending.sort_unstable_by_key(|(k, _)| std::cmp::Reverse(far(k)));
let (limit, budget) = if budgeted {
(
g.chunk_updates as usize,
u64::from(g.upload_budget_kib) * 1024,
)
} else {
(0, 0)
};
let (mut count, mut bytes) = (0, 0u64);
while let Some((_, mesh)) = pending.last() {
let size = ((mesh.solid.len() + mesh.translucent.len())
* std::mem::size_of::<horizon_client::mesher::TerrainVertex>())
as u64;
if (limit > 0 && count >= limit)
|| (budget > 0 && bytes > 0 && bytes + size > budget)
{
break;
}
let (key, mesh) = pending.pop().expect("checked above");
renderer.upload(key, &mesh);
count += 1;
bytes += size;
}
}
for c in unloaded {
for sy in 0..(HEIGHT / 16) {
renderer.remove((c.x, sy, c.z));
}
}
if let (Some(lod), Some(player)) = (&mut self.lod, &self.player) {
let lod_distance = self.settings.horizon.lod_distance_on(&renderer.info);
lod.set_near_loading(self.streaming.busy());
lod.set_reduced_detail(
self.settings.horizon.far_detail
== horizon_client::graphics::FarDetail::Reduced,
);
// The covered columns change only with the complete ones and
// the render area: rebuilt then, not every frame.
let at = (
renderer.lod_detail_revision(),
self.streaming.center,
self.streaming.radius,
);
let covered = (self.lod_covered_at != Some(at)).then(|| {
self.lod_covered_at = Some(at);
horizon_client::spans::time("lod_covered_set", || {
renderer
.lod_detail_columns()
.filter(|&(x, z)| {
horizon_client::streaming::in_view_distance(at.1, at.2, x, z)
})
.collect()
})
});
let meshes = horizon_client::spans::time("lod_update", || {
lod.update(
[player.position.x, player.position.y, player.position.z],
self.yaw,
self.streaming.radius,
lod_distance,
covered,
)
});
renderer.queue_lods(meshes, lod.removed(), lod.take_cutout());
// A finished job can hold hundreds of tiles: spread them
// over frames rather than stall one.
horizon_client::spans::time("lod_upload", || {
renderer.upload_lods(std::time::Duration::from_millis(2))
});
}
}
}
}
impl ApplicationHandler for Game<'_> {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
if self.window.is_some() {
return;
}
// The Window constructor: created fullscreen when options.txt says so.
let fullscreen = self.settings.fullscreen;
let size = self.options.window_size.map(f64::from);
self.fullscreen = horizon_client::window::FullscreenState::new(fullscreen);
let attributes = Window::default_attributes()
.with_title("Horizon")
.with_window_icon(horizon_client::window::icon());
// Wayland names the window by its app id, which the horizon.desktop entry matches.
#[cfg(target_os = "linux")]
let attributes = winit::platform::wayland::WindowAttributesExtWayland::with_name(
attributes, "horizon", "horizon",
);
let window = match event_loop.create_window(
attributes
.with_inner_size(winit::dpi::LogicalSize::new(size[0], size[1]))
.with_fullscreen(fullscreen.then_some(winit::window::Fullscreen::Borderless(None))),
) {
Ok(w) => Arc::new(w),
Err(e) => {
self.error = Some(e.into());
event_loop.exit();
return;
}
};
horizon_client::telemetry::note_display(&window);
match self.new_renderer(window.clone()) {
Ok(r) => {
self.renderer = Some(r);
self.world_renderer_ready = true;
}
Err(e) => {
self.error = Some(e);
event_loop.exit();
return;
}
}
self.window = Some(window);
self.apply_settings();
self.previous = Instant::now();
}
fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
if self.window.as_ref().is_none_or(|w| w.id() != id) {
return;
}
if let WindowEvent::KeyboardInput { event, .. } = &event
&& let PhysicalKey::Code(key) = event.physical_key
{
if event.state == ElementState::Pressed {
self.physical_keys.insert(key);
} else {
self.physical_keys.remove(&key);
}
}
if let WindowEvent::Focused(false) = &event {
self.physical_keys.clear();
}
if let WindowEvent::ModifiersChanged(m) = &event {
self.modifiers = m.state();
}
// Fullscreen is a window shortcut, before screens consume keyboard input.
if let WindowEvent::KeyboardInput { event, .. } = &event
&& event.state == ElementState::Pressed
&& let PhysicalKey::Code(key) = event.physical_key
&& horizon_client::keybinds::key_name(key)
== Some(self.settings.keys.get("key.fullscreen"))
&& !(self.screen == Screen::Options && self.options_waiting_for_key())
{
self.last_input = Instant::now();
if !event.repeat {
self.toggle_fullscreen();
}
return;
}
// KeyboardHandler.keyPress: the debug keys come before the game's.
if let WindowEvent::KeyboardInput {
event: key_event, ..
} = &event
&& let PhysicalKey::Code(key) = key_event.physical_key
{
use horizon_client::debug_keys::KeyAction;
let action = match (key_event.state, key_event.repeat) {
(ElementState::Released, _) => KeyAction::Release,
(_, false) => KeyAction::Press,
(_, true) => KeyAction::Repeat,
};
if self.debug_key(key, action) {
return;
}
}
if matches!(
event,
WindowEvent::KeyboardInput { .. }
| WindowEvent::MouseInput { .. }
| WindowEvent::MouseWheel { .. }
| WindowEvent::CursorMoved { .. }
) {
self.last_input = Instant::now();
}
if (self.pending_entry.is_some() || self.world_loader.is_some())
&& matches!(&event, WindowEvent::KeyboardInput { event, .. }
if event.state == ElementState::Pressed
&& event.physical_key == PhysicalKey::Code(KeyCode::Escape))
{
self.pending_entry = None;
if let Some(loader) = self.world_loader.take() {
self.world_loader = Some(if loader.cancelled {
loader
} else {
loader.cancel()
});
}
self.perf.cancel_world_opening();
return;
}
if (self.pending_entry.is_some() || self.world_loader.is_some())
&& !matches!(
&event,
WindowEvent::CloseRequested
| WindowEvent::Resized(_)
| WindowEvent::RedrawRequested
)
{
return;
}
if self.pending_save.is_some() {
match event {
WindowEvent::CloseRequested => {
self.pending_save.as_mut().unwrap().quit = true;
}
WindowEvent::Focused(focused) => {
self.focused = focused;
if !focused {
self.capture(false);
}
}
WindowEvent::Resized(size) => {
if let Some(r) = &mut self.renderer {
r.resize(size.width, size.height);
}
}
WindowEvent::RedrawRequested => {
if let Err(error) = self.render_closing_save() {
self.error = Some(error);
event_loop.exit();
}
}
_ => {}
}
return;
}
let result: Result<()> = (|| {
match event {
WindowEvent::CloseRequested => {
self.begin_closing_save(true)?;
}
WindowEvent::Resized(size) => {
if let Some(r) = &mut self.renderer {
r.resize(size.width, size.height);
}
self.observe_fullscreen();
}
WindowEvent::Focused(focused) => {
self.focused = focused;
if !focused && self.control.is_none() {
self.keys.clear();
self.left = false;
self.right = false;
self.capture(false);
// Screens (books, signs) stay open instead of pausing.
if self.screen == Screen::Playing
&& self.player.is_some()
&& !self.options.no_pause
&& self.settings.file.bool("pauseOnLostFocus")
&& self.book.is_none()
&& self.sign_edit.is_none()
{
self.screen = Screen::Paused;
}
}
}
WindowEvent::CursorMoved { position, .. } => {
if let Some(r) = &self.renderer {
let b = HudBatch::new([r.config.width, r.config.height]);
self.cursor = (position.x as f32 / b.scale, position.y as f32 / b.scale);
if self.screen == Screen::Advancements {
self.advancements_drag();
}
if self.screen == Screen::Creative {
let (_, oy) = Self::creative_origin(&b);
self.creative_screen.drag_scrollbar(self.cursor.1 - oy);
}
if self.screen == Screen::Inventory {
self.loom_drag();
}
if matches!(self.screen, Screen::Inventory | Screen::Creative) {
self.inventory_drag_move();
}
if let Some(title) = &mut self.title {
title.drag(self.cursor, (b.width, b.height));
title.drag_field(&self.gui.atlas, self.cursor.0);
}
if self.dragging && self.screen == Screen::Options {
let _ = b;
self.options_drag()?;
}
}
}
WindowEvent::MouseWheel { delta, .. } => {
let (raw_x, raw_y) = match delta {
MouseScrollDelta::LineDelta(x, y) => (f64::from(x), f64::from(y)),
MouseScrollDelta::PixelDelta(p) => (p.x / 30.0, p.y / 30.0),
};
// MouseHandler.onScroll: discrete scrolling and the wheel sensitivity.
let discrete = self.settings.discrete_scroll;
let wheel_sensitivity = f64::from(self.settings.mouse_wheel_sensitivity);
let scaled = |v: f64| {
(if discrete {
horizon_client::mouse::java_signum(v)
} else {
v
}) * wheel_sensitivity
};
let d = scaled(raw_y) as f32;
if let Some(title) = &mut self.title
&& self.screen != Screen::Win
{
let size = self
.window
.as_ref()
.map(|w| w.inner_size())
.unwrap_or_default();
let batch = HudBatch::new([size.width, size.height]);
title.scroll_worlds(d, self.cursor, (batch.width, batch.height));
}
if self.screen == Screen::Playing
&& self.sleeping.is_none()
&& self.player.is_some()
&& !self.extras_scroll(d)
&& let Some((wheel, (_, vertical_steps))) =
self.mouse
.on_scroll(raw_x, raw_y, discrete, wheel_sensitivity)
{
if self.spectator() {
if let Some(player) = &mut self.player {
player.flying_speed = horizon_client::mouse::spectator_flying_speed(
player.flying_speed,
vertical_steps,
);
}
} else {
self.selected =
horizon_client::mouse::ScrollWheelHandler::next_selection(
f64::from(wheel),
self.selected as i32,
9,
) as usize;
}
}
if self.screen == Screen::Chat && d != 0.0 {
self.chat_scroll(d);
}
if self.screen == Screen::Options && d != 0.0 {
self.options_scroll(d);
}
if self.screen == Screen::Creative && d != 0.0 {
self.creative_screen.wheel(f64::from(d), &self.pack.names);
}
if self.screen == Screen::Inventory
&& d != 0.0
&& !self.tweak_scroll(d, self.inventory_target().0)
{
self.station_scroll(d);
}
if self.screen == Screen::Stats && d != 0.0 {
self.stats_scroll(d);
}
if self.screen == Screen::WorldOptions && d != 0.0 {
self.world_options_scroll(d);
}
if self.screen == Screen::Advancements {
self.advancements_scroll(scaled(raw_x) as f32, d);
}
}
WindowEvent::MouseInput { state, button, .. }
if self.server_packs.prompt.is_some() =>
{
if state == ElementState::Pressed && button == MouseButton::Left {
self.pack_prompt_click()?;
}
}
WindowEvent::MouseInput { .. } if self.screen == Screen::Win => {}
WindowEvent::MouseInput { state, button, .. } if self.screen == Screen::Options => {
if self.options_waiting_for_key() && state == ElementState::Pressed {
self.options_bind_mouse(button)?;
} else if matches!(button, MouseButton::Left | MouseButton::Right) {
self.options_mouse(
state == ElementState::Pressed,
button == MouseButton::Right,
)?;
}
}
WindowEvent::MouseInput {
state: ElementState::Released,
button: MouseButton::Left,
..
} if self.title.is_some() && self.screen != Screen::Options => {
if let Some(title) = &mut self.title {
title.release();
title.release_field();
}
}
WindowEvent::MouseInput {
state,
button: MouseButton::Left,
..
} if self.title.is_some() && state == ElementState::Pressed => {
let size = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
.unwrap_or([1, 1]);
let b = HudBatch::new(size);
let atlas = &self.gui.atlas;
let shift = self.has_shift_down();
let (action, sound) = self.title.as_mut().map_or((Action::None, false), |t| {
let clicked = t.click(self.cursor.0, self.cursor.1, (b.width, b.height));
t.press_field(atlas, self.cursor, (b.width, b.height), shift);
clicked
});
self.save_title_options();
if sound {
self.audio.play_button_click();
}
match action {
Action::Quit => event_loop.exit(),
Action::Options => self.open_options(true),
Action::Accessibility => self
.open_options_at(true, horizon_client::options_ui::Page::Accessibility),
Action::Language => {
self.open_options_at(true, horizon_client::options_ui::Page::Language)
}
Action::Play { folder } => {
self.open_world(&folder, None, None, false, None)?
}
Action::Create {
folder,
name,
seed,
creative,
options,
} => {
self.open_world(&folder, Some(&name), seed, creative, Some(&options))?
}
Action::Connect { address } => {
self.connect_server(&address, &self.options.player_name())?
}
Action::None => {}
}
}
WindowEvent::MouseInput { .. } if self.title.is_some() => {}
WindowEvent::MouseInput { state, button, .. } if self.book.is_some() => {
if state == ElementState::Pressed && button == MouseButton::Left {
let size = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
.unwrap_or([1, 1]);
self.book_click(size);
}
}
WindowEvent::MouseInput { state, button, .. } if self.sign_edit.is_some() => {
if state == ElementState::Pressed && button == MouseButton::Left {
let size = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
.unwrap_or([1, 1]);
self.sign_edit_click(size);
}
}
WindowEvent::MouseInput { state, button, .. } => {
let pressed = state == ElementState::Pressed;
if matches!(self.screen, Screen::Inventory | Screen::Creative)
&& let Some(key) = self
.settings
.keys
.container_mouse_key(button, self.creative)
{
if pressed && self.carried.is_none() {
self.inventory_hotkey(key);
}
// Neither edge of a bound button is an ordinary slot click.
return Ok(());
}
if pressed && self.sort_mouse_press(button) {
return Ok(());
}
match self.screen {
Screen::Playing => {
if pressed && !self.captured {
self.capture(true);
return Ok(());
}
self.extras_mouse(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)?;
}
Some(Ok(k)) => {
self.keys.remove(&k);
}
None => {}
}
}
Screen::Inventory | Screen::Creative
if !matches!(button, MouseButton::Left | MouseButton::Right) =>
{
// AbstractContainerScreen: another button clicks
// a slot only as the pick block key (its hotbar
// keys were handled above).
if self.settings.keys.get("key.pickItem")
== horizon_client::keybinds::mouse_name(button)
{
if pressed {
self.inventory_pick_press();
} else {
self.inventory_pick_release();
}
if let Some(key) = self.container {
self.container_changed(key);
}
}
}
Screen::Inventory if pressed => {
self.inventory_press(button == MouseButton::Right);
if let Some(key) = self.container {
self.container_changed(key);
}
}
Screen::Inventory => {
self.inventory_mouse_release(button == MouseButton::Right);
self.loom_release();
}
Screen::Chat if pressed && button == MouseButton::Left => self.chat_click(),
Screen::Creative if pressed => {
self.click_creative(button == MouseButton::Right);
}
Screen::Creative => {
if button == MouseButton::Left {
self.creative_screen.release();
}
self.inventory_mouse_release(button == MouseButton::Right);
}
Screen::Paused
if pressed && button == MouseButton::Left && self.pause_menu =>
{
self.pause_click()?
}
Screen::WorldOptions if pressed && button == MouseButton::Left => {
self.world_options_click()
}
Screen::Friends if pressed && button == MouseButton::Left => {
self.friends_screen_click()
}
Screen::CommandBlock if pressed && button == MouseButton::Left => {
self.command_block_click()
}
Screen::Dead if pressed && button == MouseButton::Left => {
self.death_click()?
}
Screen::Advancements if button == MouseButton::Left => {
let size = self
.renderer
.as_ref()
.map_or([1, 1], |r| [r.config.width, r.config.height]);
self.advancements_mouse(pressed, size);
}
Screen::Stats if pressed && button == MouseButton::Left => {
let size = self
.renderer
.as_ref()
.map_or([1, 1], |r| [r.config.width, r.config.height]);
self.stats_click(size);
}
_ => {}
}
}
// ConfirmScreen.keyPressed: Escape answers no.
WindowEvent::KeyboardInput { event, .. } if self.server_packs.prompt.is_some() => {
if event.state == ElementState::Pressed
&& event.physical_key == PhysicalKey::Code(KeyCode::Escape)
{
self.answer_pack_prompt(false)?;
}
}
WindowEvent::KeyboardInput { event, .. }
if self.screen == Screen::Chat && self.title.is_none() =>
{
if let PhysicalKey::Code(key) = event.physical_key {
if event.state == ElementState::Pressed {
self.keys.insert(key);
self.chat_key(&event);
} else {
self.keys.remove(&key);
}
}
}
WindowEvent::KeyboardInput { event, .. } if self.sign_edit.is_some() => {
self.sign_edit_key(&event)
}
WindowEvent::KeyboardInput { event, .. } if self.book.is_some() => {
self.book_key(&event)
}
WindowEvent::KeyboardInput { event, .. }
if self.screen == Screen::Creative
&& self.creative_screen.tab().search
&& event.state == ElementState::Pressed
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
{
if let PhysicalKey::Code(key) = event.physical_key
&& self.search_tab_hotbar_key(key)
{
// The hovered slot took the key (`ignoreTextInput`).
} else if let Some(shortcut) = self.edit_shortcut(&event) {
self.creative_search_shortcut(shortcut);
} else {
let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
self.creative_search_edit(event.text.as_deref(), backspace);
}
}
WindowEvent::KeyboardInput { event, .. }
if self.recipe_search_focused()
&& event.state == ElementState::Pressed
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
{
// The recipe book's search box takes every key but Escape.
self.recipe_key(&event);
}
WindowEvent::KeyboardInput { event, .. }
if self.station_typing()
&& event.state == ElementState::Pressed
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
{
// The anvil rename box takes every key but Escape (AnvilScreen.keyPressed).
if let Some(shortcut) = self.edit_shortcut(&event) {
self.station_shortcut(shortcut);
} else {
let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
self.station_text(event.text.as_deref(), backspace);
}
}
WindowEvent::KeyboardInput { event, .. }
if self.screen == Screen::WorldOptions
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
{
self.world_options_key(&event)
}
WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::Win => {
self.win_key(&event)?
}
WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::CommandBlock => {
self.command_block_key(&event)
}
// Options consumes presses; releases still reach the bound
// gameplay mapping below, including sneak/sprint toggles.
WindowEvent::KeyboardInput { event, .. }
if self.screen == Screen::Options && event.state == ElementState::Pressed =>
{
if let Some(shortcut) = self.edit_shortcut(&event)
&& self.options_shortcut(shortcut)
{
return Ok(());
}
if let PhysicalKey::Code(key) = event.physical_key {
self.options_key(key, event.text.as_deref())?;
}
}
WindowEvent::KeyboardInput { event, .. } if self.title.is_some() => {
if event.state == ElementState::Pressed {
if let Some(shortcut) = self.edit_shortcut(&event) {
self.title_shortcut(shortcut);
return Ok(());
}
match event.physical_key {
PhysicalKey::Code(KeyCode::Enter | KeyCode::NumpadEnter) => {
if let Some(t) = self.title.as_mut() {
t.confirm_edit();
}
}
PhysicalKey::Code(
key @ (KeyCode::Backspace
| KeyCode::Delete
| KeyCode::ArrowLeft
| KeyCode::ArrowRight
| KeyCode::Home
| KeyCode::End),
) if self.title.as_mut().is_some_and(|t| t.has_caret_field()) => {
let (ctrl, shift) =
(self.has_control_down(), self.has_shift_down());
if let Some(t) = self.title.as_mut() {
t.field_key(key, ctrl, shift);
}
}
PhysicalKey::Code(KeyCode::Backspace) => self.title_edit(None, true),
PhysicalKey::Code(KeyCode::Tab) => {
if let Some(t) = self.title.as_mut() {
t.tab();
}
}
PhysicalKey::Code(KeyCode::Escape) => {
if let Some(t) = self.title.as_mut() {
t.escape();
}
self.save_title_options();
}
_ => self.title_edit(event.text.as_deref(), false),
}
}
}
WindowEvent::KeyboardInput { event, .. } => {
let PhysicalKey::Code(key) = event.physical_key else {
return Ok(());
};
self.extras_key(key, event.state == ElementState::Pressed, event.repeat);
// key.smoothCamera toggles the cinematic camera.
if self.screen == Screen::Playing
&& event.state == ElementState::Pressed
&& !event.repeat
&& horizon_client::keybinds::key_name(key)
.is_some_and(|n| self.settings.keys.get("key.smoothCamera") == n)
{
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)?;
}
return Ok(());
}
None => return Ok(()),
};
self.mapped_key(key, event.state == ElementState::Pressed, event.repeat)?;
}
WindowEvent::RedrawRequested => {
self.observe_fullscreen();
let now = Instant::now();
let frame_cpu = self
.options
.spikes
.and_then(|_| horizon_client::spans::thread_cpu());
let elapsed = now.duration_since(self.previous);
self.frame_ticks = elapsed.as_secs_f32() * 20.0;
self.previous = now;
// Arrow-key camera controls belong to gameplay; chat and
// other screens use the same keys for their own navigation.
if self.screen == Screen::Playing
&& self.title.is_none()
&& self.sign_edit.is_none()
&& self.book.is_none()
{
let turn = |k| f32::from(u8::from(self.keys.contains(&k)));
let secs = elapsed.as_secs_f32().min(0.1);
self.yaw +=
(turn(KeyCode::ArrowRight) - turn(KeyCode::ArrowLeft)) * 90.0 * secs;
self.pitch = (self.pitch
+ (turn(KeyCode::ArrowDown) - turn(KeyCode::ArrowUp)) * 90.0 * secs)
.clamp(-90.0, 90.0);
}
if self.title.is_none() {
horizon_client::spans::time("update_world", || self.update_world());
horizon_client::spans::time("spawn_player", || self.spawn_player())?;
}
let updated = Instant::now();
self.track_toggle_screens();
// For the "I'm playing" ping: an atomic, sent on when it changes.
horizon_client::heartbeat::set_lan(self.is_published());
self.update_discord_presence();
let steps = self.clock.advance(elapsed);
// The world ticking in the frame: once its ticks took a
// tick's length, the rest are dropped (`FixedStep::tick_fits`).
let in_frame = self.remote.is_none();
let mut spent = Duration::ZERO;
for step in 0..steps {
if in_frame && !self.clock.tick_fits(spent) {
if let Some(warning) = self.clock.drop_ticks(steps - step) {
log::warn!("{warning}");
}
break;
}
let started = Instant::now();
if self.title.is_none() && !self.pause {
let tick = Instant::now();
horizon_client::spans::time("tick", || self.tick())?;
// In single player the tick is the integrated server's.
if self.remote.is_none() {
self.perf.tick(tick.elapsed().as_secs_f32() * 1000.0);
self.debug_charts.log_tick(tick, tick.elapsed());
}
self.tick_ambience();
self.tick_fov();
}
self.tick_win_screen()?;
self.tick_music();
self.tick_sound_engine();
self.clock.record(started.elapsed());
spent += started.elapsed();
if let Some(report) = self.clock.take_sprint_report() {
self.sprint_report(&report);
}
}
self.extras_frame(elapsed);
self.mods_frame(elapsed);
self.extras_retry()?;
self.apply_mouse_look();
self.pad_look(elapsed.as_secs_f32());
self.advance_flight();
let ticked = Instant::now();
let rendered = self.render()?;
if let Some(threshold) = self.options.spikes
&& let Some(r) = self.renderer.as_ref()
{
let cpu = now.elapsed().saturating_sub(r.last_wait).as_secs_f32() * 1000.0;
let spans = horizon_client::spans::take();
if cpu > threshold {
// The render thread's own CPU time in the frame:
// far below the wall time, the frame waited.
let worked = horizon_client::spans::thread_cpu()
.zip(frame_cpu)
.map_or_else(String::new, |(end, start)| {
format!(", cpu {:.1} ms", (end - start).as_secs_f32() * 1000.0)
});
log::info!(
"Horizon: slow frame {cpu:.1} ms{worked} ({steps} ticks): {}",
horizon_client::spans::describe(&spans)
);
}
}
if let Some(r) = self.renderer.as_mut() {
let cpu = now.elapsed().saturating_sub(r.last_wait);
if rendered {
let ms = |d: Duration| d.as_secs_f32() * 1000.0;
self.frame_graph.record(
ms(elapsed),
ms(cpu),
r.gpu_times.last().copied(),
);
self.frame_stats.record_cpu(ms(cpu));
let render = r.last_encode;
self.frame_stats.record_phases([
ms(updated - now),
ms(ticked - updated),
ms(ticked.elapsed().saturating_sub(r.last_wait + render)),
ms(render),
]);
}
self.frame_stats.record_gpu(&r.gpu_times);
r.gpu_times.clear();
}
self.limit_frame();
self.pause = self.pauses_game();
if let Some(server) = &self.integrated {
server.set_paused(self.pause);
server.set_distances(
self.settings.render_distance,
self.settings.simulation_distance,
);
}
self.clock.end_frame(self.pause);
let finished = self
.renderer
.as_mut()
.and_then(|r| r.screenshot_result.take());
if let Some(result) = &finished
&& self.ui.screenshot_message.is_some()
{
self.finish_screenshot(result);
}
if let Some(result) = finished
&& let Some(reply) = self.pending_screenshot.take()
{
let _ = reply.send(
match result {
Ok([w, h]) => {
serde_json::json!({ "ok": true, "width": w, "height": h })
}
Err(e) => serde_json::json!({ "error": e }),
}
.to_string(),
);
}
if rendered {
self.frame_stats.record(elapsed.as_secs_f32() * 1000.0);
self.debug_charts.frame_times.log(elapsed.as_nanos() as i64);
if self.frames == 0 {
// The launcher times Play to this line (launcher/src/perf.rs).
log::info!(
"Horizon: first frame after {} ms",
self.started.elapsed().as_millis()
);
}
if self.title.is_some() {
self.perf.title_shown();
} else if self.screen == Screen::Playing && self.player.is_some() {
self.perf.frame(elapsed.as_secs_f32() * 1000.0);
self.world_frames += 1;
}
self.frames += 1;
self.fps_frames += 1;
horizon_client::crash::debug_crash_tick();
if self.fps_at.elapsed() >= Duration::from_secs(1) {
self.fps = self.fps_frames as f32 / self.fps_at.elapsed().as_secs_f32();
self.fps_frames = 0;
self.fps_at = Instant::now();
}
if self.options.frames.is_some_and(|f| self.frames >= f)
|| self
.options
.world_frames
.is_some_and(|f| self.world_frames >= f)
{
event_loop.exit();
}
}
}
_ => {}
}
Ok(())
})();
if let Err(e) = result {
self.error = Some(e);
event_loop.exit();
}
}
fn device_event(&mut self, _: &ActiveEventLoop, _: DeviceId, event: DeviceEvent) {
if self.pending_save.is_none()
&& self.captured
&& self.focused
&& self.screen == Screen::Playing
&& let DeviceEvent::MouseMotion { delta: (x, y) } = event
{
// MouseHandler.onMove with the pointer grabbed; applied once per frame.
self.mouse.on_move(0.0, 0.0, x, y, true, true);
self.last_input = Instant::now();
}
}
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
if self.pending_save.is_some() {
match self.poll_closing_save() {
Ok(true) => event_loop.exit(),
Ok(false) => {
if let Some(window) = &self.window {
window.request_redraw();
}
// Yield between polls even when disk I/O is slow.
event_loop.set_control_flow(ControlFlow::WaitUntil(
Instant::now() + Duration::from_millis(4),
));
}
Err(error) => {
self.error = Some(error);
event_loop.exit();
}
}
return;
}
if let Err(error) = self.resume_world_entry() {
self.error = Some(error);
event_loop.exit();
return;
}
self.tick_server_packs();
self.poll_control(event_loop);
if self.pending_save.is_some() {
return;
}
self.poll_pads(event_loop);
if self.options.frames.is_some() && self.started.elapsed() > self.options.timeout {
self.error = Some("frame-limited run timed out".into());
event_loop.exit();
return;
}
if let Some(w) = &self.window {
if self.options.offscreen {
// Offscreen frames don't wait for the window to be drawn: an
// occluded window (a locked macOS session) gets no redraws.
let id = w.id();
self.window_event(event_loop, id, WindowEvent::RedrawRequested);
} else {
w.request_redraw();
}
}
event_loop.set_control_flow(ControlFlow::Poll);
}
/// The application is ending. On macOS, Quit (Cmd+Q) ends it through
/// applicationWillTerminate without a CloseRequested; vanilla's GLFW
/// window turns it into a window close, so Minecraft.stop saves the world.
fn exiting(&mut self, _event_loop: &ActiveEventLoop) {
self.pad_close_output();
if let Err(e) = self.save_for_exit() {
log::warn!("Horizon: failed to save the world on exit: {e}");
}
self.finish_perf();
}
}
/// clouds.png as filled cells (`CloudRenderer.prepare`: alpha 10 or more).
fn load_clouds(root: &std::path::Path) -> (u32, u32, Vec<bool>) {
horizon_client::hud::decode(&root.join("assets/minecraft/textures/environment/clouds.png"))
.map(|(w, h, px)| {
(
w,
h,
px.as_chunks::<4>().0.iter().map(|p| p[3] >= 10).collect(),
)
})
.unwrap_or((1, 1, vec![false]))
}
/// misc/forcefield.png for the world border wall (square, power of two).
fn load_forcefield(root: &std::path::Path) -> (u32, u32, Vec<u8>) {
horizon_client::hud::decode(&root.join("assets/minecraft/textures/misc/forcefield.png"))
.ok()
.filter(|(w, h, _)| w == h && w.is_power_of_two())
.unwrap_or((1, 1, vec![0; 4]))
}
impl<'a> Game<'a> {
/// A game with no world open, over the loaded resources: the window's,
/// or an integrated server's on its own thread.
fn new(
res: &'a Arc<Resources>,
pack: PackResources,
gui: UiResources,
options: Options,
settings: Settings,
audio: Audio,
prepared: Option<GameCpuResources>,
) -> Result<Self> {
let root = options.resources.clone();
let registry = pack.assets.registry;
// Until a world is opened the streamer is idle.
let mut streaming = Streaming::new(
Arc::new(TestTerrain::new(registry, res.biomes())?),
pack.context.clone(),
1,
);
streaming.paused = true;
let level = Level::default();
let save = Arc::new(SaveDir::new(
std::env::current_dir()?
.join("saves")
.join(".horizon-title"),
));
let prepared = prepared
.map(Ok)
.unwrap_or_else(|| GameCpuResources::load(&root))?;
let world = World::new(res.facts().air, 0);
let creative = options.creative;
let inventory = vec![None; 36];
let now = Instant::now();
let look = options.look;
let particles = horizon_client::particles::ParticleEngine::new(
&root,
&gui.atlas.sprites,
&gui.atlas.translucent,
);
Ok(Game {
res: res.clone(),
rest_loader: None,
pending_entry: None,
world_loader: None,
pending_pack_reload: false,
server_packs: Default::default(),
world_renderer_ready: false,
collision: res.collision(),
motion: res.motion(),
pack,
gui,
fog: Default::default(),
screen_fx: Default::default(),
weather_parameters: Default::default(),
panorama_rotation: Default::default(),
world,
streaming,
lod: None,
lod_source_attempted: false,
lod_observe: Default::default(),
lod_covered_at: None,
options,
player: None,
spawn: None,
clock: FixedStep::default(),
previous_position: Vec3::ZERO,
eye: 1.62,
previous_eye: 1.62,
yaw: look.map_or(level.rotation[0], |l| l.0),
pitch: look.map_or(level.rotation[1], |l| l.1),
inventory,
selected: 0,
carried: None,
craft_grid: vec![None; 9],
craft_size: 2,
craft_table: None,
inv_drag: None,
tweaks: Default::default(),
inv_clicks: Default::default(),
last_inv_click: None,
last_quick_moved: None,
container: None,
station: None,
potions: Default::default(),
scratch_slot: None,
mining: None,
destroying: HashMap::new(),
destroy_delay: 0,
use_delay: 0,
creative,
mode: if creative {
horizon_client::command::args::GameMode::Creative
} else {
horizon_client::command::args::GameMode::Survival
},
keys: HashSet::new(),
physical_keys: HashSet::new(),
left: false,
right: false,
cursor: (0.0, 0.0),
captured: false,
focused: true,
modifiers: winit::keyboard::ModifiersState::empty(),
fullscreen: horizon_client::window::FullscreenState::new(false),
mouse: MouseLook::default(),
agent_pointer: false,
smooth_camera: false,
toggles: Default::default(),
was_playing: false,
pause: false,
debug: false,
screen: Screen::Playing,
window: None,
renderer: None,
entity_vertices: Vec::new(),
dynamic_lights: Vec::new(),
luminance: None,
see_through_vertices: Vec::new(),
health_hud: hud_layout::HealthHud::default(),
started: now,
previous: now,
last_input: now,
pad: Default::default(),
frames: 0,
world_frames: 0,
fps: 0.0,
fps_frames: 0,
fps_at: now,
ticks: 0,
error: None,
message: None,
save,
level,
session_lock: None,
audio,
music: Default::default(),
ambience: Default::default(),
sound_paused: false,
cart_sounds: HashSet::new(),
riding_cart_sounds: None,
dropped: Vec::new(),
next_entity: 0,
particles,
pickups: Default::default(),
sign_edit: None,
book: None,
lectern_pulses: Vec::new(),
loading_progress: 0.0,
spawn_origin: None,
spawn_spiral: Default::default(),
player_spawn: None,
mobs: Vec::new(),
creatures: Default::default(),
sculk: Default::default(),
raiding: Default::default(),
attack_ticks: 100,
attack_item: None,
last_hurt_by_player: HashMap::new(),
died: HashSet::new(),
be_anims: {
let mut anims = horizon_client::block_entity_anim::BlockEntityAnims::default();
anims.classify(registry);
anims
},
using: None,
view: Default::default(),
limiter: horizon_client::window::FramerateLimiter::new(0),
frame_clock: Default::default(),
scope_scale: 0.5,
frame_ticks: 0.0,
title: None,
armor: [None, None, None, None],
offhand: None,
hand: Hand::Main,
shield_cooldown: 0,
cooldowns: Default::default(),
command_source: None,
titles: Default::default(),
tool_highlight: Default::default(),
applied_modifiers: Vec::new(),
experience: Experience::default(),
orbs: Vec::new(),
xp_delay: 0,
last_level_up: 0,
swing: Default::default(),
swings_started: 0,
heights: Default::default(),
sway: Default::default(),
visible_hands: [(0, None), (0, None)],
clicks: Default::default(),
attack_clicks: 0,
hand_strength: Default::default(),
settings,
options_from_title: false,
dragging: false,
avatar: Default::default(),
flash: 0,
lightning_seen: [0; 2],
sleeping: None,
sleep_timer: 0,
dim: Dim::Overworld,
world_root: PathBuf::new(),
travelling: None,
server_trips: Vec::new(),
level_teleports: Vec::new(),
levels: Default::default(),
level_pass: Default::default(),
portals: Default::default(),
end_travel: false,
respawn_config: None,
respawn_travel: None,
end_portal_travel: false,
win: None,
end: Default::default(),
block_ticks: Ticks::new(0),
tick_chunks: Default::default(),
tickets: Default::default(),
random_tick_sections: Default::default(),
level_events: Vec::new(),
falling: Vec::new(),
paintings: Vec::new(),
painting_variants: prepared.painting_variants,
item_frames: Vec::new(),
frame_model: prepared.frame_model,
glow_frame_model: prepared.glow_frame_model,
map_frame_model: prepared.map_frame_model,
glow_map_frame_model: prepared.glow_map_frame_model,
armor_stands: Vec::new(),
others: Vec::new(),
armor_stand_assets: prepared.armor_stand_assets,
waypoint_styles: prepared.waypoint_styles,
waypoints: Default::default(),
locator_camera: None,
experience_display: Default::default(),
boats: Vec::new(),
boat_models: prepared.boat_models,
crystal_model: prepared.crystal_model,
carts: Vec::new(),
jukebox_sounds: HashMap::new(),
bolts: Vec::new(),
maps: maps::Maps::default(),
fight: dragon::Fight::default(),
dragon: None,
crystals: Vec::new(),
dragon_fireballs: Vec::new(),
breath_clouds: Vec::new(),
dragon_model: prepared.dragon_model,
map_patches: Vec::new(),
text_displays: Default::default(),
text_display_vertices: 0,
skin_downloads: RefCell::new(horizon_client::skins::Downloader::new(
std::env::current_dir()
.unwrap_or_default()
.join("assets/skins"),
)),
skin_slots: Vec::new(),
trim_slots: Vec::new(),
cart_models: prepared.cart_models,
riding: None,
ender_items: vec![None; 27],
ender_open: None,
pending: Default::default(),
spill: Default::default(),
recipe_ui: Default::default(),
mount_menu: Default::default(),
hook: None,
remote_hooks: Vec::new(),
tridents: Vec::new(),
rockets: Vec::new(),
ominous_spawners: Vec::new(),
creaking: Default::default(),
spawners: Default::default(),
trident_model: prepared.trident_model,
arrow_model: prepared.arrow_model,
tnts: Vec::new(),
hoppers: HashMap::new(),
item_columns: None,
creative_screen: prepared.creative_screen,
control: None,
agent_control_on: false,
agent_last: None,
frame_stats: Default::default(),
perf: Default::default(),
pending_screenshot: None,
pending_bench: None,
flight: None,
ui_wait: Default::default(),
events: Default::default(),
agent: agent::Agent::default(),
view_frustum: None,
entity_culler: None,
pending_uploads: Vec::new(),
frame_graph: Default::default(),
extras: Default::default(),
mods: Default::default(),
sky_darken_memo: Default::default(),
persist: Default::default(),
remote: None,
lan: None,
integrated: None,
serving: None,
world_options: None,
options_to_world_options: false,
command_block_screen: None,
friends: None,
debug_keys: Default::default(),
debug_charts: Default::default(),
show_hitboxes: false,
show_chunk_borders: false,
pause_menu: true,
previous_mode: None,
gamemode_switcher: None,
clipboard: Default::default(),
text_selection: Default::default(),
saved_for_exit: false,
pending_save: None,
forced_hit: None,
guest_use: None,
lan_events: Vec::new(),
lan_block_events: Vec::new(),
lan_entity_events: Vec::new(),
lid_openers: HashMap::new(),
lan_acting: None,
guest_packets: Vec::new(),
guest_cooldowns: Vec::new(),
lan_acting_name: None,
lan_acting_uuid: None,
chat_capture: None,
admin_feedback: Vec::new(),
console_broadcast: None,
cmds: Default::default(),
ui: Default::default(),
combat: Default::default(),
mount: Default::default(),
stats: Default::default(),
score: Default::default(),
fns: Default::default(),
bosses: Default::default(),
boss_overlay: Default::default(),
exec: Default::default(),
rand_sequences: Default::default(),
border: Default::default(),
border_renderer: Default::default(),
border_state: Default::default(),
tab_list: Default::default(),
subtitles: Default::default(),
adv: Default::default(),
restore_player_state: true,
stats_ui: Default::default(),
adv_ui: Default::default(),
camera_type: Default::default(),
fangs: Default::default(),
player_model: None,
})
}
}
/// CPU-only startup data, owned by one loader generation. No file reads or
/// model baking are needed when the event loop installs this bundle.
struct GameCpuResources {
painting_variants: paintings::PaintingVariants,
frame_model: frames::FrameModel,
glow_frame_model: frames::FrameModel,
map_frame_model: frames::FrameModel,
glow_map_frame_model: frames::FrameModel,
armor_stand_assets: armor_stands::ArmorStandAssets,
waypoint_styles: horizon_client::locator_bar::WaypointStyles,
boat_models: boats::BoatModels,
cart_models: minecarts::CartModels,
crystal_model: Option<horizon_client::mobs::Part>,
dragon_model: Option<horizon_client::mobs::Part>,
arrow_model: Option<horizon_client::mobs::Part>,
trident_model: Option<horizon_client::mobs::Part>,
creative_screen: Creative,
}
impl GameCpuResources {
fn load(root: &std::path::Path) -> Result<Self> {
let document = horizon_client::mobs::EntityModelDocument::load(root).ok();
let model = |key| document.as_ref().and_then(|document| document.model(key));
Ok(Self {
painting_variants: paintings::PaintingVariants::load(root),
frame_model: frames::bake_frame(root, "item_frame"),
glow_frame_model: frames::bake_frame(root, "glow_item_frame"),
map_frame_model: frames::bake_frame(root, "item_frame_map"),
glow_map_frame_model: frames::bake_frame(root, "glow_item_frame_map"),
armor_stand_assets: armor_stands::ArmorStandAssets::load(root, document.as_ref()),
waypoint_styles: horizon_client::locator_bar::WaypointStyles::load(root),
boat_models: boats::BoatModels::load(document.as_ref()),
cart_models: minecarts::CartModels::load(document.as_ref()),
crystal_model: model("minecraft:end_crystal#main"),
dragon_model: model("minecraft:ender_dragon#main"),
arrow_model: model("minecraft:arrow#main"),
trident_model: model("minecraft:trident#main"),
creative_screen: Creative::load(root)?,
})
}
}
/// The data the background loader produces for `Game::new`.
struct Loaded {
game_cpu: Option<GameCpuResources>,
renderer_cpu: Option<horizon_client::gfx::PreparedTextures>,
root: PathBuf,
pack_error: Option<String>,
resources: Arc<Resources>,
rest_loader: Option<WorldRestLoader>,
pack: PackResources,
/// The menu bundle, for the synchronous launch; the loading screen receives
/// it earlier through its own channel.
gui: Option<UiResources>,
}
/// What the background loader publishes: the menu bundle as soon as it is
/// ready, then the core bundle with a handle to the rest worker.
enum LoaderMsg {
Ui(UiResources, PathBuf),
Done(std::result::Result<Loaded, String>),
}
enum PendingWorldEntry {
Local {
folder: String,
name: Option<String>,
seed: Option<i64>,
creative: bool,
create: Option<Box<horizon_client::title::WorldOptions>>,
},
Server {
address: String,
name: String,
/// A transfer's carried-over server cookies (`TransferState`).
cookies: Option<horizon_client::net::Cookies>,
},
}
struct WorldRestLoader {
progress: Progress,
handle: JoinHandle<std::result::Result<(), String>>,
}
impl WorldRestLoader {
fn ready(&self) -> Result<bool> {
// No time limit: the title stays usable while this loads, and a slow
// disk or a debug build can take minutes. A failure ends the thread
// and is reported by `finish`.
Ok(self.handle.is_finished())
}
fn finish(self) -> Result<()> {
self.handle
.join()
.map_err(|_| "world resource loader panicked")?
.map_err(Into::into)
}
}
impl Game<'_> {
fn defer_world_entry(&mut self, entry: PendingWorldEntry) -> Result<bool> {
self.poll_world_rest()?;
if self.rest_loader.is_none() && self.world_loader.is_none() {
return Ok(false);
}
self.perf.world_opening();
if self.title.is_none() {
self.title = Some(Title::new(
std::env::current_dir()?.join("saves"),
&self.options.resources,
));
}
self.pending_entry = Some(entry);
log::info!("Horizon: world entry waiting for world resources");
Ok(true)
}
fn resume_world_entry(&mut self) -> Result<()> {
self.poll_world_rest()?;
if let Some(loader) = &self.world_loader {
if !loader.ready() {
return Ok(());
}
let loader = self
.world_loader
.take()
.ok_or("missing world initialization worker")?;
let cancelled = loader.cancelled;
let prepared = loader.finish();
if !cancelled {
self.finish_open_world(prepared?)?;
}
}
if self.rest_loader.is_some() {
return Ok(());
}
if std::mem::take(&mut self.pending_pack_reload) {
self.reload_packs();
}
match self.pending_entry.take() {
Some(PendingWorldEntry::Local {
folder,
name,
seed,
creative,
create,
}) => {
self.open_world(&folder, name.as_deref(), seed, creative, create.as_deref())?;
}
Some(PendingWorldEntry::Server {
address,
name,
cookies,
}) => {
self.connect_server_with_cookies(&address, &name, cookies)?;
}
None => {}
}
Ok(())
}
fn poll_world_rest(&mut self) -> Result<()> {
if let Some(loader) = &self.rest_loader
&& loader.ready()?
{
self.rest_loader
.take()
.ok_or("missing world loader")?
.finish()?;
}
Ok(())
}
fn join_world_rest(&mut self) -> Result<()> {
if self.rest_loader.is_some() {
let waited = Instant::now();
log::info!("Horizon: waiting for world resources");
while self.rest_loader.is_some() {
self.poll_world_rest()?;
if self.rest_loader.is_some() {
std::thread::sleep(Duration::from_millis(10));
}
}
log::info!(
"Horizon: world resources joined after {} ms",
waited.elapsed().as_millis()
);
}
if self.res.rest.get().is_none() {
return Err("world resources are unavailable".into());
}
Ok(())
}
}
/// `key.hotbar.1` to `key.hotbar.9` in a menu.
const HOTBAR_DIGITS: [KeyCode; 9] = [
KeyCode::Digit1,
KeyCode::Digit2,
KeyCode::Digit3,
KeyCode::Digit4,
KeyCode::Digit5,
KeyCode::Digit6,
KeyCode::Digit7,
KeyCode::Digit8,
KeyCode::Digit9,
];
/// The other keys `InputConstants.Key.getNumericKeyValue` gives a digit.
const NUMERIC_KEYS: [KeyCode; 11] = [
KeyCode::Digit0,
KeyCode::Numpad0,
KeyCode::Numpad1,
KeyCode::Numpad2,
KeyCode::Numpad3,
KeyCode::Numpad4,
KeyCode::Numpad5,
KeyCode::Numpad6,
KeyCode::Numpad7,
KeyCode::Numpad8,
KeyCode::Numpad9,
];
const STAGES: u32 = 10;
const STAGE_LINES: [&str; 10] = [
"Loading menu",
"Loading assets",
"Loading block facts",
"Loading biomes",
"Loading pack tables",
"Loading collision",
"Loading items",
"Loading recipes",
"Loading world resources",
"World resources ready",
];
/// The background loader's checkpoint, read by the loading screen each frame.
#[derive(Clone)]
struct Progress(Arc<AtomicU32>);
impl Progress {
fn new() -> Self {
Self(Arc::new(AtomicU32::new(0)))
}
fn set(&self, stage: u32) {
self.0.store(stage, Ordering::Relaxed);
}
fn fraction(&self) -> f32 {
self.0.load(Ordering::Relaxed) as f32 / (STAGES - 1) as f32
}
fn line(&self) -> &'static str {
STAGE_LINES[(self.0.load(Ordering::Relaxed) as usize).min(STAGE_LINES.len() - 1)]
}
}
/// Harness and dedicated runs keep the fully-synchronous startup so their
/// output stays byte-identical; only an ordinary launch shows the window first.
fn synchronous_startup(options: &Options) -> bool {
options.frames.is_some()
|| options.world_frames.is_some()
|| options.benchmark.is_some()
|| options.control.is_some()
|| !options.execution_role.is_client()
|| std::env::var_os("HORIZON_DISPENSE_FIXTURE").is_some()
|| std::env::var_os("HORIZON_SCULK_FIXTURE").is_some()
|| std::env::var_os("HORIZON_COMMAND_SCRIPT").is_some()
|| std::env::var_os("HORIZON_NET_REPORT").is_some()
}
/// The synchronous launch loads both phases; an ordinary launch returns the
/// core bundle while the rest worker keeps loading.
fn load_resources(
mut root: PathBuf,
vanilla_root: &std::path::Path,
settings: &Settings,
started: Instant,
menu: bool,
progress: &Progress,
publish: &mut dyn FnMut(UiResources, &std::path::Path),
) -> Result<Loaded> {
let requested_root = root.clone();
let threads = settings.horizon.worker_threads();
// Stage A: the menu bundle (atlas and panorama). With a loading screen it is
// published at once so the title screen can appear while the world bundle
// loads; the synchronous launch instead carries it in `Loaded`.
let mut loaded_gui = None;
let mut ui_ready = false;
let mut pack_error = None;
let ui = match UiResources::load(&root, vanilla_root) {
Ok(ui) => Some(ui),
// Minecraft.rollbackResourcePacks: the packs' textures don't fit, start
// with the game's own resources.
Err(e) if root != vanilla_root => {
log::warn!("Horizon: resource packs failed to load ({e}); using the default resources");
pack_error = Some(e.to_string());
root = vanilla_root.to_path_buf();
None
}
Err(_) => None,
};
if let Some(ui) = ui {
if menu {
horizon_client::telemetry::mark_ui_ready();
log::info!(
"Horizon: UI bundle ready after {} ms",
started.elapsed().as_millis()
);
publish(ui, &root);
} else {
loaded_gui = Some(ui);
}
ui_ready = true;
}
progress.set(0);
let (assets, render) = match Assets::load(&root).and_then(|assets| {
let render = assets.reload(&root)?;
Ok((assets, render))
}) {
Ok(bundle) => bundle,
// Minecraft.rollbackResourcePacks: the packs break loading, start
// with the game's own resources.
Err(e) if root != vanilla_root => {
log::warn!("Horizon: resource packs failed to load ({e}); using the default resources");
pack_error = Some(e.to_string());
root = vanilla_root.to_path_buf();
let assets = Assets::load(vanilla_root)?;
let render = assets.reload(vanilla_root)?;
(assets, render)
}
Err(e) => {
return Err(format!(
"{e}\nPrepare resources with the launcher, or: horizon-prepare --prepare"
)
.into());
}
};
let assets = Arc::new(assets);
let render = Arc::new(render);
// The menu bundle must come from the same root as the world bundle.
if !ui_ready || root != requested_root {
let ui = UiResources::load(&root, vanilla_root)?;
if menu {
horizon_client::telemetry::mark_ui_ready();
log::info!(
"Horizon: UI bundle ready after {} ms",
started.elapsed().as_millis()
);
publish(ui, &root);
} else {
loaded_gui = Some(ui);
}
}
log::info!("load assets: {:.2}s", started.elapsed().as_secs_f32());
progress.set(1);
let behaviour_json: serde_json::Value = serde_json::from_reader(std::io::BufReader::new(
std::fs::File::open(root.join("block-behaviours.json"))?,
))?;
// The block facts, the biomes and the environment are independent reads:
// run them together, within the worker budget the settings allow.
let registry = assets.registry;
let load_facts = || {
BlockFacts::load_with_projection(&root, registry, &behaviour_json)
.map_err(|e| e.to_string())
};
let load_biomes = || Biomes::load(&root).map_err(|e| e.to_string());
let load_environment = || Environment::load(&root).map_err(|e| e.to_string());
let (facts, biomes, environment) = if threads > 1 {
std::thread::scope(|scope| {
let facts = scope.spawn(load_facts);
let biomes = scope.spawn(load_biomes);
let environment = scope.spawn(load_environment);
(
facts.join().unwrap(),
biomes.join().unwrap(),
environment.join().unwrap(),
)
})
} else {
(load_facts(), load_biomes(), load_environment())
};
let (facts, gameplay_projection) =
facts.map_err(|e| -> Box<dyn std::error::Error> { e.into() })?;
let biomes = Arc::new(biomes.map_err(|e| -> Box<dyn std::error::Error> { e.into() })?);
let environment = environment.map_err(|e| -> Box<dyn std::error::Error> { e.into() })?;
log::info!("load facts: {:.2}s", started.elapsed().as_secs_f32());
progress.set(2);
log::info!("load biomes+env: {:.2}s", started.elapsed().as_secs_f32());
progress.set(3);
let light = Arc::new(LightTables::load(&root, assets.registry, &facts)?);
let pack = PackResources::load(&root, assets.clone(), render, &facts, biomes.clone(), light)?;
log::info!("load pack tables: {:.2}s", started.elapsed().as_secs_f32());
progress.set(4);
if !menu {
horizon_client::ui::load_metadata(&root);
horizon_client::lang::set(horizon_client::lang::Language::load(
&[&root],
&settings.language,
));
}
let registry_owner = assets.clone();
let collision = collisions::load(&root, registry_owner.registry)?;
let motion = MotionResources::load_with_facts(&root, &registry_owner, &facts)?;
log::info!(
"load collision+motion: {:.2}s",
started.elapsed().as_secs_f32()
);
progress.set(5);
let resources = Resources {
core: WorldCore {
facts,
biomes: biomes.clone(),
environment,
collision,
motion,
threads,
},
rest: std::sync::OnceLock::new(),
};
let resources = Arc::new(resources);
if menu {
horizon_client::telemetry::mark_core_ready();
log::info!(
"Horizon: core-ready after {} ms",
started.elapsed().as_millis()
);
}
// Finish fallible CPU preparation before starting the tail, so an error
// cannot detach a tail worker that races the next pack-loader generation.
let prepared_at = Instant::now();
let game_cpu = menu.then(|| GameCpuResources::load(&root)).transpose()?;
let renderer_cpu = menu.then(|| prepare_renderer_textures(&pack));
if menu {
log::info!(
"Horizon: handoff CPU resources prepared on worker in {} ms",
prepared_at.elapsed().as_millis()
);
}
let rest_loader = if menu {
let resources = resources.clone();
let root = root.clone();
let rest_progress = progress.clone();
let progress = progress.clone();
let handle = std::thread::Builder::new()
.name("world-rest-loader".into())
.spawn(move || {
let rest = load_world_rest(
&root,
&resources,
&assets,
&behaviour_json,
&gameplay_projection,
&progress,
started,
)
.map_err(|error| error.to_string())?;
resources
.rest
.set(rest)
.map_err(|_| "world resources already loaded".to_owned())?;
progress.set(9);
horizon_client::telemetry::mark_rest_ready();
log::info!(
"Horizon: rest-ready after {} ms",
started.elapsed().as_millis()
);
Ok(())
})?;
Some(WorldRestLoader {
progress: rest_progress,
handle,
})
} else {
let rest = load_world_rest(
&root,
&resources,
&assets,
&behaviour_json,
&gameplay_projection,
progress,
started,
)?;
resources
.rest
.set(rest)
.map_err(|_| "world resources already loaded")?;
None
};
Ok(Loaded {
game_cpu,
renderer_cpu,
root,
pack_error,
resources,
rest_loader,
pack,
gui: loaded_gui,
})
}
fn load_world_rest(
root: &std::path::Path,
resources: &Resources,
assets: &Assets,
behaviour_json: &serde_json::Value,
gameplay_projection: &[horizon_client::blocks::GameplayProjection],
progress: &Progress,
started: Instant,
) -> Result<WorldRest> {
let facts = resources.facts();
let biomes = resources.biomes();
let threads = resources.threads();
let registry_owner = assets;
progress.set(6);
let mob_data = horizon_client::mobs::MobData::load(root, facts);
horizon_client::mobs::trial_spawner::load_registry(root);
let items = Items::load(root, assets.registry, facts)?;
log::info!("load items: {:.2}s", started.elapsed().as_secs_f32());
progress.set(7);
let recipes = Recipes::load(root, &items)?;
let transformers = horizon_client::block_transform::Transformers::load(root, assets.registry)?;
log::info!(
"Horizon: resources loaded in {:.1}s; {} block states, {} items, {} biomes; {} worker threads",
started.elapsed().as_secs_f32(),
facts.states.len(),
items.items.len(),
biomes.list.len(),
threads
);
progress.set(8);
let stations = horizon_client::stations::StationData::load(root, &items);
let animate =
horizon_client::animate_tick::AnimateTables::load(root, registry_owner.registry, biomes)?;
let fog = horizon_client::fog::FogTables::load(root, biomes);
Ok(WorldRest {
stations,
items,
recipes,
transformers,
providers: Providers::load(root),
block_entity_render: horizon_client::block_entity_render::BlockEntityRenderer::load(
root,
registry_owner.registry,
)?,
animate,
fog,
music: horizon_client::music::MusicTables::load(root),
ambient: horizon_client::ambience::AmbientTables::load(root),
nether_environment: Environment::load_dimension(root, "the_nether", false)?,
end_environment: Environment::load_dimension(root, "the_end", false)?,
behaviours: Behaviours::load_with_gameplay(
registry_owner.registry,
root,
behaviour_json,
gameplay_projection,
)?,
mob_types: MobTypes::load(root)?
.types
.into_iter()
.map(|(k, v)| (k, Arc::new(v)))
.collect(),
mob_data,
player_type: perspective::player_type(root),
player_arm: horizon_client::mobs::load_model(root, "minecraft:player#main")
.and_then(|m| m.children.into_iter().find(|c| c.name == "right_arm")),
spin_attack: horizon_client::mobs::load_model(root, "minecraft:spin_attack#main"),
})
}
/// CPU mip chains for the block sprites and world border.
fn prepare_renderer_textures(pack: &PackResources) -> horizon_client::gfx::PreparedTextures {
let assets = &pack.render;
horizon_client::gfx::PreparedTextures::new(
&assets.pixels,
assets.sprite_size,
assets.texture_layers,
&assets.sprite_mips,
(&pack.forcefield.2, pack.forcefield.0),
)
}
/// Upload pack textures and create the renderer on the window's device.
fn build_renderer(
window: Arc<Window>,
offscreen: bool,
pack: &PackResources,
gui: &UiResources,
previous: Option<&Renderer>,
prepared: Option<horizon_client::gfx::PreparedTextures>,
api: horizon_client::graphics::GraphicsApi,
) -> Result<Renderer> {
let assets = &pack.render;
let atlas = &gui.atlas;
let mut renderer = pollster::block_on(Renderer::new(
window,
offscreen,
&assets.pixels,
assets.sprite_size,
assets.sprite_minimum_size,
assets.texture_layers,
&assets.sprite_mips,
&assets.animations,
(&atlas.pixels, atlas.width, atlas.height),
(&pack.forcefield.2, pack.forcefield.0),
&gui.panorama,
prepared,
previous,
api,
))?;
renderer.hud.fire_animations = atlas
.fire_animations
.iter()
.map(|(rect, animation)| (*rect, animation.clone(), usize::MAX))
.collect();
Ok(renderer)
}
/// The loading screen's renderer: the real HUD atlas and font over one opaque
/// white block-sprite layer, an empty border texture and the title panorama
/// once the menu bundle is ready.
fn loading_renderer(
window: Arc<Window>,
offscreen: bool,
gui: Option<&UiResources>,
previous: Option<&Renderer>,
api: horizon_client::graphics::GraphicsApi,
) -> Result<Renderer> {
static FORCEFIELD: [u8; 4] = [0; 4];
static EMPTY_HUD: [u8; 4] = [0, 0, 0, 255];
let empty_panorama = horizon_client::gfx::panorama::Faces {
size: 1,
pixels: [0u8; 4].repeat(6),
};
let panorama = gui.map_or(&empty_panorama, |gui| gui.panorama.as_ref());
let atlas = gui.map(|gui| &gui.atlas);
let (pixels, width, height) = match atlas {
Some(atlas) => (atlas.pixels.as_slice(), atlas.width, atlas.height),
None => (EMPTY_HUD.as_slice(), 1, 1),
};
let mut renderer = pollster::block_on(Renderer::new(
window,
offscreen,
&[255, 255, 255, 255],
1,
1,
1,
&[],
&[],
(pixels, width, height),
(&FORCEFIELD[..], 1),
panorama,
None,
previous,
api,
))?;
if let Some(atlas) = atlas {
renderer.hud.fire_animations = atlas
.fire_animations
.iter()
.map(|(rect, animation)| (*rect, animation.clone(), usize::MAX))
.collect();
}
Ok(renderer)
}
/// A title-shaped frame: black clear and panorama, only the HUD is drawn.
fn loading_frame(hud: &HudBatch) -> Frame<'_> {
Frame {
weather: &[],
weather_time: horizon_client::weather::Time::new(0, 0.0),
camera: glam::DVec3::new(0.5, 100.0, 0.5),
yaw: 0.0,
pitch: 10.0,
fov_degrees: 85.0,
bob: glam::Mat4::IDENTITY,
sky: horizon_client::environment::Sky::default(),
distance: 12.0,
detail_distance: 12.0,
depth_far: 1000.0,
underwater: false,
cave_culling: false,
title: true,
skybox: false,
end_sky: false,
end_sky_sprite: None,
environment_fog: None,
water_fog: [0.0; 3],
fog: None,
dark_disc: false,
outline: Vec::new(),
outline_after_terrain: false,
debug_lines: &[],
debug_lines_on_top: &[],
debug_crosshair: &[],
hud,
nether_lighting: false,
entities: &[],
dynamic_lights: &[],
clouds: None,
lightning: Default::default(),
additive: &[],
see_through: &[],
celestial: &[],
stars: None,
hand: &[],
hand_fov_degrees: 70.0,
screen: &[],
pack: Default::default(),
border: None,
game_time: 0.0,
shader_game_time: 0.0,
end_portal_sprites: [[0.0; 4]; 2],
crumbling_sprite: [0.0; 4],
ticks: 0,
darkness: (0.0, 0.0),
night_vision: 0.0,
block_flicker: 0.0,
boss_darken: 0.0,
menu_blur: None,
}
}
/// The post-load setup once the resources are ready: `Game::new` and the
/// options, packs, mods, control socket, benchmark and world selection the
/// old `run` did after loading. `None` means a harness or dedicated run
/// finished here instead.
#[allow(clippy::too_many_arguments)]
fn start_game<'a>(
res: &'a Arc<Resources>,
pack: PackResources,
gui: UiResources,
options: Options,
pack_error: Option<String>,
audio: Audio,
vanilla_root: PathBuf,
started: Instant,
rest_loader: Option<WorldRestLoader>,
settings: Option<Settings>,
prepared: Option<GameCpuResources>,
) -> Result<Option<Game<'a>>> {
let handoff = prepared.is_some();
let mut settings = match settings {
Some(settings) => settings,
None => Settings::load(&std::env::current_dir()?.join("options.txt")),
};
if let Some(d) = options.distance_override {
settings.render_distance = d;
}
let mut game = Game::new(res, pack, gui, options, settings, audio, prepared)?;
game.rest_loader = rest_loader;
game.ui.vanilla_root = vanilla_root;
if let Some(error) = pack_error {
// Minecraft.clearResourcePacksOnError: the selection is cleared and
// saved, so the next launch starts without the packs.
game.settings.resource_packs.clear();
game.settings.save(&Game::options_path());
game.open_options_at(true, horizon_client::options_ui::Page::Packs);
game.ui.options.resource_error = Some(error);
}
if game.options.benchmark.is_some() {
// The same conditions on every machine: no VSync, no frame cap, no
// pause or idle limit without focus. In memory only, never saved.
game.settings.vsync = false;
game.settings.max_fps = 260;
game.settings.inactivity_fps_limit = "minimized".into();
game.options.no_pause = true;
}
game.apply_settings();
// Benchmarks measure the game alone.
if game.options.benchmark.is_none() {
game.mods.dev = game.options.dev_mods.clone();
game.start_mods();
}
game.start_agent_control()?;
if let Some(scenario) = game.options.benchmark.clone() {
let control = game
.control
.get_or_insert_with(horizon_client::control::Server::local);
horizon_client::benchmark::start(
control.sender(),
horizon_client::benchmark::Setup {
scenario,
started,
app: horizon_bench::App {
name: "horizon-client".into(),
version: horizon_client::crash::version(),
commit: option_env!("HORIZON_COMMIT").map(str::to_owned),
mods: Vec::new(),
},
simulation_distance: game.settings.simulation_distance as u32,
vsync: false,
fps_cap: None,
offscreen: game.options.offscreen,
game_dir: std::env::current_dir()?,
},
);
}
if let Ok(spec) = std::env::var("HORIZON_DISPENSE_FIXTURE") {
game.dispense_fixture(&spec)?;
return Ok(None);
}
if let Ok(spec) = std::env::var("HORIZON_SCULK_FIXTURE") {
game.sculk_fixture(&spec)?;
return Ok(None);
}
if game.options.execution_role == execution_role::ExecutionRole::DedicatedServer {
game.run_dedicated()?;
return Ok(None);
}
match game.options.world.clone() {
_ if game.options.server.is_some() => {
let (address, name) = (
game.options.server.clone().unwrap_or_default(),
game.options.player_name(),
);
game.connect_server(&address, &name)?;
if let Some(report) = std::env::var_os("HORIZON_NET_REPORT") {
game.run_net_harness(report.as_ref())?;
return Ok(None);
}
}
Some(folder) => {
let (seed, creative) = (game.options.seed, game.options.creative);
if std::env::var_os("HORIZON_COMMAND_SCRIPT").is_some() {
// The command harness runs before entering the window loop.
game.open_world(&folder, None, Some(seed), creative, None)?;
} else {
// Start after the window is handed over, so --world uses the
// same responsive initialization path as the title screen.
game.title = Some(Title::new(
std::env::current_dir()?.join("saves"),
&game.options.resources,
));
game.pending_entry = Some(PendingWorldEntry::Local {
folder,
name: None,
seed: Some(seed),
creative,
create: None,
});
}
}
None if handoff => {}
None => {
let mut title = Title::new(
std::env::current_dir()?.join("saves"),
&game.options.resources,
);
title.last_server = game.settings.file.string("lastServer");
game.title = Some(title);
}
}
if let (Some(script), Some(output)) = (
std::env::var_os("HORIZON_COMMAND_SCRIPT"),
std::env::var_os("HORIZON_COMMAND_OUTPUT"),
) {
game.run_command_harness(script.as_ref(), output.as_ref())?;
return Ok(None);
}
Ok(Some(game))
}
fn write_report(game: &Game<'_>) -> Result<()> {
if let Some(path) = &game.options.report {
let report = serde_json::json!({
"frames": game.frames,
"elapsed_seconds": game.started.elapsed().as_secs_f64(),
"chunks": game.world.chunks.len(),
"generated": game.streaming.generated_total,
"meshed_sections": game.streaming.meshed_total,
"player": game.player.as_ref().map(|p| [p.position.x, p.position.y, p.position.z]),
"error": game.error.as_ref().map(|e| e.to_string()),
});
std::fs::write(path, serde_json::to_vec_pretty(&report)?)?;
}
Ok(())
}
fn run_event_loop(mut game: Game<'_>) -> Result<()> {
EventLoop::new()?.run_app(&mut game)?;
horizon_client::discord_presence::stop();
write_report(&game)?;
if let Some(e) = game.error.take() {
return Err(e);
}
Ok(())
}
/// The loading screen's state while the worker loads the resources.
struct Loading {
window: Option<Arc<Window>>,
renderer: Option<Renderer>,
gui: Option<UiResources>,
settings: Settings,
fullscreen: horizon_client::window::FullscreenState,
options: Option<Options>,
vanilla_root: PathBuf,
pack_error: Option<String>,
started: Instant,
panorama_rotation: horizon_client::gfx::panorama::Rotation,
progress: Progress,
receiver: Receiver<LoaderMsg>,
loaded: Option<std::result::Result<Loaded, String>>,
handle: Option<JoinHandle<()>>,
shown: bool,
menu: startup_menu::StartupMenu,
error: Option<Box<dyn std::error::Error>>,
}
impl Loading {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
if self.window.is_some() {
return;
}
// The Window constructor: created fullscreen when options.txt says so.
let fullscreen = self.settings.fullscreen;
let size = self
.options
.as_ref()
.map_or([1280, 720], |o| o.window_size)
.map(f64::from);
self.fullscreen = horizon_client::window::FullscreenState::new(fullscreen);
let attributes = Window::default_attributes()
.with_title("Horizon")
.with_window_icon(horizon_client::window::icon());
// Wayland names the window by its app id, which the horizon.desktop entry matches.
#[cfg(target_os = "linux")]
let attributes = winit::platform::wayland::WindowAttributesExtWayland::with_name(
attributes, "horizon", "horizon",
);
let window = match event_loop.create_window(
attributes
.with_inner_size(winit::dpi::LogicalSize::new(size[0], size[1]))
.with_fullscreen(fullscreen.then_some(winit::window::Fullscreen::Borderless(None))),
) {
Ok(w) => Arc::new(w),
Err(e) => {
self.error = Some(e.into());
event_loop.exit();
return;
}
};
horizon_client::telemetry::note_display(&window);
let offscreen = self.options.as_ref().is_some_and(|o| o.offscreen);
match loading_renderer(
window.clone(),
offscreen,
self.gui.as_ref(),
None,
self.settings.horizon.api,
) {
Ok(r) => self.renderer = Some(r),
Err(e) => {
self.error = Some(e);
event_loop.exit();
return;
}
}
if let Some(r) = &self.renderer {
self.settings
.clamp_gui_scale([r.config.width as i32, r.config.height as i32]);
}
horizon_client::hud::GUI_SCALE.store(self.settings.gui_scale, Ordering::Relaxed);
self.window = Some(window);
}
fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
if self.window.as_ref().is_none_or(|w| w.id() != id) {
return;
}
if let Err(error) = self.menu_event(event_loop, event) {
self.error = Some(error);
event_loop.exit();
}
}
/// The menu bundle arrived: rebuild the loading screen with the real atlas
/// and title panorama.
fn set_ui(&mut self, gui: UiResources, root: PathBuf) {
log::info!(
"Horizon: loading the title artwork after {} ms",
self.started.elapsed().as_millis()
);
self.menu.set_root(root, &self.settings);
self.gui = Some(gui);
horizon_client::ui_theme::reset_atlas();
self.apply_menu_settings();
let Some(window) = self.window.clone() else {
return;
};
let offscreen = self.options.as_ref().is_some_and(|o| o.offscreen);
if let Some(renderer) = &mut self.renderer {
renderer.release_surface();
}
match loading_renderer(
window,
offscreen,
self.gui.as_ref(),
self.renderer.as_ref(),
self.settings.horizon.api,
) {
Ok(r) => {
self.settings
.clamp_gui_scale([r.config.width as i32, r.config.height as i32]);
horizon_client::hud::GUI_SCALE.store(self.settings.gui_scale, Ordering::Relaxed);
self.renderer = Some(r);
}
Err(e) => self.error = Some(e),
}
}
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
if let Err(error) = self.poll_menu_resources() {
self.error = Some(error);
event_loop.exit();
return;
}
if let Some(w) = &self.window {
if self.options.as_ref().is_some_and(|o| o.offscreen) {
self.draw();
} else {
w.request_redraw();
}
}
event_loop.set_control_flow(ControlFlow::Poll);
}
fn draw(&mut self) {
let Some(size) = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
else {
return;
};
let mut batch = HudBatch::new(size);
self.draw_menu(&mut batch);
let mut frame = loading_frame(&batch);
frame.yaw = self.panorama_rotation.update(
self.started.elapsed().as_secs_f32(),
self.settings.file.double("panoramaScrollSpeed") as f32,
);
if let Some(renderer) = &mut self.renderer {
match renderer.render(&frame) {
Ok(true) if self.gui.is_some() && self.menu.pending.is_none() => {
self.menu.perf.title_shown()
}
Ok(_) => {}
Err(e) => log::warn!("Horizon: loading screen frame failed: {e}"),
}
}
if !self.shown {
self.shown = true;
log::info!(
"Horizon: loading screen shown after {} ms",
self.started.elapsed().as_millis()
);
}
}
fn finish(&mut self, loaded: Loaded) -> Result<Option<Game<'static>>> {
let handoff_at = Instant::now();
let mut options = self.options.take().ok_or("loading already finished")?;
options.resources = loaded.root.clone();
// StartupMenu owns world selection until it can hand it to Game.
options.world = None;
options.server = None;
let gui = self.gui.take().ok_or("missing menu bundle")?;
let window = self.window.clone().ok_or("window closed")?;
// Keep the loader's device and swap in the real textures in one step.
if let Some(renderer) = &mut self.renderer {
renderer.release_surface();
}
let renderer_at = Instant::now();
let renderer = build_renderer(
window.clone(),
options.offscreen,
&loaded.pack,
&gui,
self.renderer.as_ref(),
loaded.renderer_cpu,
self.settings.horizon.api,
)?;
log::info!(
"Horizon: world renderer ready after {} ms",
self.started.elapsed().as_millis()
);
let renderer_ms = renderer_at.elapsed().as_millis();
// Audio is created on the main thread, after the core is ready.
let audio = if !options.execution_role.is_client() {
Audio::silent(&options.resources)
} else {
Audio::new(&options.resources)
};
let pack_error = loaded.pack_error.or_else(|| self.pack_error.take());
// The game borrows its shared resources for the process's lifetime,
// like the single copy an integrated server would share.
let res: &'static Arc<Resources> = Box::leak(Box::new(loaded.resources));
let game_at = Instant::now();
let Some(mut game) = start_game(
res,
loaded.pack,
gui,
options,
pack_error,
audio,
self.vanilla_root.clone(),
self.started,
loaded.rest_loader,
Some(self.settings.clone()),
loaded.game_cpu,
)?
else {
return Ok(None);
};
let game_ms = game_at.elapsed().as_millis();
game.window = Some(window);
game.renderer = Some(renderer);
game.world_renderer_ready = true;
game.fullscreen = self.fullscreen;
game.panorama_rotation = self.panorama_rotation;
self.menu.handoff(&mut game);
game.apply_settings();
game.previous = Instant::now();
log::info!(
"Horizon: startup handoff {} ms (renderer {} ms, start_game {} ms)",
handoff_at.elapsed().as_millis(),
renderer_ms,
game_ms
);
Ok(Some(game))
}
}
/// The application: the loading screen until the resources are ready, then
/// the game itself, on the same event loop and window.
enum App {
Loading(Box<Loading>),
Ready(Box<Game<'static>>),
}
impl ApplicationHandler for App {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
match self {
App::Loading(loading) => loading.resumed(event_loop),
App::Ready(game) => game.resumed(event_loop),
}
}
fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
match self {
App::Loading(loading) => loading.window_event(event_loop, id, event),
App::Ready(game) => game.window_event(event_loop, id, event),
}
}
fn device_event(&mut self, event_loop: &ActiveEventLoop, id: DeviceId, event: DeviceEvent) {
if let App::Ready(game) = self {
game.device_event(event_loop, id, event);
}
}
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
enum Step {
Waiting,
Ready(Box<Game<'static>>),
Done,
Failed(Box<dyn std::error::Error>),
}
let step = match self {
App::Ready(game) => {
game.about_to_wait(event_loop);
return;
}
App::Loading(loading) => {
loading.about_to_wait(event_loop);
if loading.error.is_some() {
event_loop.exit();
return;
}
match if loading.menu.reload_packs {
None
} else {
loading.loaded.take()
} {
None => Step::Waiting,
Some(Err(e)) => Step::Failed(e.into()),
Some(Ok(loaded)) => match loading.finish(loaded) {
Ok(Some(game)) => Step::Ready(Box::new(game)),
Ok(None) => Step::Done,
Err(e) => Step::Failed(e),
},
}
}
};
match step {
Step::Waiting => {}
Step::Ready(game) => *self = App::Ready(game),
Step::Done => event_loop.exit(),
Step::Failed(e) => {
if let App::Loading(loading) = self {
loading.error = Some(e);
}
event_loop.exit();
}
}
}
fn exiting(&mut self, event_loop: &ActiveEventLoop) {
if let App::Ready(game) = self {
game.exiting(event_loop);
}
}
}
/// The ordinary launch: load the resources on a worker while the window shows
/// the loading screen, then swap in the game on the main thread.
fn run_loading(
options: Options,
settings: Settings,
vanilla_root: PathBuf,
pack_error: Option<String>,
started: Instant,
) -> Result<()> {
let progress = Progress::new();
let (receiver, loader) =
startup_menu::spawn_loader(&options, &settings, &vanilla_root, started, &progress)?;
let menu = startup_menu::StartupMenu::new(&options, pack_error.as_deref())?;
let loading = Loading {
window: None,
renderer: None,
gui: None,
settings,
fullscreen: horizon_client::window::FullscreenState::new(false),
options: Some(options),
vanilla_root,
pack_error,
started,
panorama_rotation: Default::default(),
progress,
receiver,
loaded: None,
handle: Some(loader),
shown: false,
menu,
error: None,
};
let mut app = App::Loading(Box::new(loading));
EventLoop::new()?.run_app(&mut app)?;
horizon_client::discord_presence::stop();
match app {
App::Ready(mut game) => {
write_report(&game)?;
if let Some(e) = game.error.take() {
return Err(e);
}
}
App::Loading(loading) => {
if let Some(e) = loading.error {
return Err(e);
}
}
}
Ok(())
}
pub fn run() -> Result<()> {
let Some(mut options) = Options::read()? else {
return Ok(());
};
if options.execution_role == execution_role::ExecutionRole::DedicatedServer
&& !dedicated::preflight(&mut options)?
{
return Ok(());
}
// Before any worker starts: on Linux they go behind the server thread
// and the render thread.
horizon_threads::put_helpers_behind();
if options.execution_role.is_client() {
// The render thread, like the server thread, ahead of the workers on
// macOS and Windows. While terrain loads, the worker pools (two with
// single player's server thread) and other programs outnumber the
// cores, and a frame that gave its core up (in a GPU submit) waited
// 10 to 200 ms to get one back.
horizon_threads::favour_current();
}
// Someone is playing: the anonymous ping behind the launcher's "N playing now". Not for a
// server, a benchmark or a run that quits by itself.
if options.execution_role.is_client()
&& options.benchmark.is_none()
&& !options.offscreen
&& options.frames.is_none()
&& options.world_frames.is_none()
{
horizon_client::heartbeat::start();
}
let started = Instant::now();
horizon_client::spans::enable(options.spikes.is_some());
let vanilla_root = options.resources.clone();
let early_settings = Settings::load(&std::env::current_dir()?.join("options.txt"));
// "Playing Horizon" on Discord: never for a server; an automated run only talks to a test's fake Discord.
if options.dedicated.is_none() {
let automated = options.benchmark.is_some()
|| options.offscreen
|| options.frames.is_some()
|| options.world_frames.is_some();
horizon_client::discord_presence::start(early_settings.extras.discord_presence, automated);
}
// Snapshots of derived tables live in the game folder, never beside the
// shared resources.
Behaviours::set_cache_dir(std::env::current_dir()?.join(".horizon-cache"));
if !synchronous_startup(&options) {
return run_loading(options, early_settings, vanilla_root, None, started);
}
let mut pack_error = None;
options.resources = packs::startup_root(&vanilla_root, &early_settings.resource_packs, &[])
.unwrap_or_else(|e| {
log::warn!("Horizon: resource packs not applied: {e}");
pack_error = Some(e.to_string());
vanilla_root.clone()
});
options.resources = mods::content_root(
&options.resources,
&early_settings.mods.enabled,
&options.dev_mods,
);
let loaded = load_resources(
options.resources.clone(),
&vanilla_root,
&early_settings,
started,
false,
&Progress::new(),
&mut |_, _| {},
)?;
let gui = loaded.gui.ok_or("missing menu bundle")?;
options.resources = loaded.root.clone();
let audio = if !options.execution_role.is_client() {
Audio::silent(&options.resources)
} else {
Audio::new(&options.resources)
};
let resources = loaded.resources;
let game = start_game(
&resources,
loaded.pack,
gui,
options,
loaded.pack_error.or(pack_error),
audio,
vanilla_root,
started,
loaded.rest_loader,
None,
None,
)?;
if let Some(game) = game {
run_event_loop(game)?;
}
Ok(())
}
// Player.tick: cap the sleeping fade at 100, then fade out over 10 waking ticks.
fn tick_sleep_timer(timer: u32, sleeping: bool) -> u32 {
if sleeping {
(timer + 1).min(100)
} else if (1..109).contains(&timer) {
timer + 1
} else {
0
}
}
fn reset_world_progress(adv: &mut advancements::AdvState, stats: &mut stats::Stats) {
*adv = Default::default();
*stats = Default::default();
}
#[cfg(test)]
mod startup_cpu_tests {
use super::*;
#[test]
fn worker_prepares_owned_models_and_inventory_before_handoff() {
let root = std::env::temp_dir().join(format!("horizon-startup-cpu-{}", std::process::id()));
std::fs::create_dir_all(&root).unwrap();
std::fs::write(
root.join("entity-models.json"),
r#"{
"minecraft:end_crystal#main": {}, "minecraft:ender_dragon#main": {},
"minecraft:arrow#main": {}, "minecraft:trident#main": {},
"minecraft:armor_stand#main": {}
}"#,
)
.unwrap();
std::fs::write(
root.join("creative-tabs.json"),
r#"[{
"id":"minecraft:building_blocks", "items":["minecraft:stone"]
}]"#,
)
.unwrap();
let worker_root = root.clone();
let prepared = std::thread::spawn(move || {
GameCpuResources::load(&worker_root).map_err(|error| error.to_string())
})
.join()
.unwrap()
.unwrap();
std::fs::remove_dir_all(&root).unwrap();
assert!(prepared.crystal_model.is_some());
assert!(prepared.dragon_model.is_some());
assert!(prepared.arrow_model.is_some());
assert!(prepared.trident_model.is_some());
assert!(prepared.armor_stand_assets.main.is_some());
assert_eq!(
prepared.creative_screen.tabs[0].items[0].item.as_ref(),
"minecraft:stone"
);
// No documents from the old generation remain available to reload.
assert!(GameCpuResources::load(&root).is_err());
}
}
#[cfg(test)]
mod runtime_reset_tests {
use super::*;
#[test]
fn world_entry_invalidates_loaded_progress() {
let mut adv = advancements::AdvState::default();
let mut stats = stats::Stats::default();
adv.loaded = true;
stats.loaded = true;
adv.progress
.criteria
.insert("minecraft:story/root".into(), Default::default());
stats.add("mined", "minecraft:stone", 4);
reset_world_progress(&mut adv, &mut stats);
assert!(!adv.loaded && !stats.loaded);
assert!(adv.progress.criteria.is_empty());
assert!(stats.values.is_empty());
}
}
#[cfg(test)]
mod entity_model_loading_tests;
#[cfg(test)]
mod tests {
use super::*;
use horizon_client::container_screen::{Button, Clicks, Release, Target};
use horizon_client::keymapping::{KeyAction, SPRINT, ToggleKeys};
#[test]
fn sleep_fade_lasts_ten_ticks_after_waking() {
let alpha = |timer| match hud_overlays::sleep_overlay(320, 240, timer).first() {
Some(hud_layout::GuiDraw::Fill { color, .. }) => color >> 24,
None => 0,
_ => panic!("sleep overlay must be a full-screen fill"),
};
assert_eq!(tick_sleep_timer(0, false), 0);
let mut timer = 0;
for _ in 0..50 {
timer = tick_sleep_timer(timer, true);
}
assert_eq!(alpha(timer as i32), 110);
for _ in 0..100 {
timer = tick_sleep_timer(timer, true);
}
assert_eq!(timer, 100);
assert_eq!(alpha(timer as i32), 220);
for _ in 0..5 {
timer = tick_sleep_timer(timer, false);
}
assert_eq!(alpha(timer as i32), 110);
for _ in 0..5 {
timer = tick_sleep_timer(timer, false);
}
assert_eq!(timer, 0);
assert!(hud_overlays::sleep_overlay(320, 240, timer as i32).is_empty());
}
#[test]
fn world_rest_poll_does_not_wait_for_a_blocked_worker() {
let (release, wait) = std::sync::mpsc::channel();
let loader = WorldRestLoader {
progress: Progress::new(),
handle: std::thread::spawn(move || {
wait.recv().unwrap();
Ok(())
}),
};
assert!(!loader.ready().unwrap());
release.send(()).unwrap();
loader.finish().unwrap();
}
#[test]
fn world_rest_poll_waits_for_a_slow_worker() {
let (release, wait) = std::sync::mpsc::channel();
let loader = WorldRestLoader {
progress: Progress::new(),
handle: std::thread::spawn(move || {
wait.recv().unwrap();
Ok(())
}),
};
// However long it takes, a worker still loading is not an error.
assert!(!loader.ready().unwrap());
release.send(()).unwrap();
while !loader.ready().unwrap() {
std::thread::sleep(Duration::from_millis(1));
}
loader.finish().unwrap();
}
#[test]
fn world_rest_worker_failure_reaches_the_client() {
let loader = WorldRestLoader {
progress: Progress::new(),
handle: std::thread::spawn(|| Err("missing world table".to_owned())),
};
assert_eq!(
loader.finish().unwrap_err().to_string(),
"missing world table"
);
}
#[test]
fn world_rest_worker_panic_reaches_the_client() {
let loader = WorldRestLoader {
progress: Progress::new(),
handle: std::thread::spawn(|| panic!("broken loader")),
};
assert_eq!(
loader.finish().unwrap_err().to_string(),
"world resource loader panicked"
);
}
/// An integrated server thread shares the loaded resources with the client.
#[test]
fn shared_resources_can_cross_threads() {
fn shared<T: Send + Sync>() {}
shared::<Resources>();
shared::<PackResources>();
}
#[test]
fn selecting_creative_tabs_does_not_drop_the_carried_stack_on_release() {
let mut creative = Creative::from_json(&serde_json::json!({
"schema": 2,
"tabs": [{"type": "CATEGORY"}, {"type": "INVENTORY"}]
}))
.unwrap();
for button in [Button::Left, Button::Right] {
let mut clicks = Clicks::default();
for tab in [1, 1, 0, 1] {
select_creative_tab(&mut creative, &mut clicks, tab);
assert_eq!(creative.selected, tab);
assert_eq!(creative.tab().inventory, tab == 1);
assert_eq!(
clicks.release(
&Target::<usize>::Outside,
button,
false,
false,
false,
false
),
Release::Nothing
);
}
}
}
#[test]
fn stack_drop_requires_physical_ctrl_even_with_sprint_latched() {
for sprint in [false, true] {
let mut toggles = ToggleKeys::default();
if sprint {
toggles.key(SPRINT, KeyAction::Press, false, true);
toggles.key(SPRINT, KeyAction::Release, false, true);
}
assert_eq!(toggles.is_down(SPRINT), sprint);
for held in 0..4 {
let mut physical_keys = HashSet::from([KeyCode::ShiftLeft, KeyCode::KeyQ]);
if held & 1 != 0 {
physical_keys.insert(KeyCode::ControlLeft);
}
if held & 2 != 0 {
physical_keys.insert(KeyCode::ControlRight);
}
assert_eq!(drop_whole_stack(&physical_keys), held != 0);
physical_keys.remove(&KeyCode::ControlLeft);
physical_keys.remove(&KeyCode::ControlRight);
assert!(!drop_whole_stack(&physical_keys));
assert_eq!(toggles.is_down(SPRINT), sprint);
}
}
}
}