bb0ae764f9
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1689 lines
72 KiB
Rust
1689 lines
72 KiB
Rust
//! Multiplayer: the game driven by a server connection instead of the local
|
|
//! simulation. Mirrors vanilla's ClientPacketListener (chunks, entities,
|
|
//! inventory, health, time, weather, chat, respawn and dimension changes),
|
|
//! LocalPlayer.sendPosition (movement packets) and MultiPlayerGameMode
|
|
//! (block breaking with sequence numbers, use-item, attacks, container
|
|
//! clicks). The player still moves with the local physics, as the vanilla
|
|
//! client predicts its own movement; the server stays authoritative for
|
|
//! everything else.
|
|
use super::{Dim, Game, Mining, Screen};
|
|
use horizon_client::{
|
|
Result,
|
|
chunk::{Blocks, Chunk, Light, MIN_Y, SECTIONS, Section},
|
|
containers::{BlockEntity, Furnace, FurnaceKind},
|
|
entities::{Experience, ItemEntity},
|
|
hud::{HudBatch, rgba},
|
|
items::ItemStack,
|
|
mobs::{Anim, Brain, Mob, MobType},
|
|
motion::{MotionWorld, PlayerMotion},
|
|
net::{Event, Session},
|
|
save::SaveDir,
|
|
sprint::Keys,
|
|
streaming::{ChunkGenerator, Proto, Streaming},
|
|
world::World,
|
|
};
|
|
use horizon_core::{geometry::Vec3, random::RandomSource};
|
|
use horizon_protocol::{
|
|
entity_data::{ITEM_ENTITY_ITEM, Value},
|
|
item::{Hashed, Stack},
|
|
packets::{
|
|
Empty,
|
|
play::{self, Clientbound as C, Serverbound as S},
|
|
},
|
|
registry::{Builtin, DimensionType, Dynamic, ceil_log2},
|
|
text::{Language, format_java, plain},
|
|
};
|
|
use horizon_world::{nbt::Tag, registry::BlockStateId};
|
|
use std::{
|
|
collections::HashMap,
|
|
sync::Arc,
|
|
time::{Duration, Instant},
|
|
};
|
|
use winit::{event::MouseButton, keyboard::KeyCode};
|
|
|
|
/// Streaming needs a generator; a server world never generates.
|
|
struct NoTerrain;
|
|
impl ChunkGenerator for NoTerrain {
|
|
type Worker = ();
|
|
fn worker(&self) {}
|
|
fn proto(&self, _: &mut (), _: i32, _: i32) -> Proto {
|
|
Box::new(())
|
|
}
|
|
fn finish(&self, _: Proto) -> Chunk {
|
|
Chunk::empty(0, 0)
|
|
}
|
|
}
|
|
|
|
/// A server entity the client tracks (position as last sent).
|
|
struct Tracked {
|
|
kind: String,
|
|
position: [f64; 3],
|
|
}
|
|
/// Smooth an entity toward a new position over three ticks (InterpolationHandler).
|
|
#[derive(Clone, Copy)]
|
|
struct Lerp {
|
|
target: [f64; 3],
|
|
steps: u32,
|
|
}
|
|
|
|
pub(super) struct Remote {
|
|
pub session: Session,
|
|
builtin: Arc<Builtin>,
|
|
lang: Arc<Language>,
|
|
registries: Arc<Dynamic>,
|
|
joined: bool,
|
|
status: String,
|
|
entity_id: i32,
|
|
dimension: DimensionType,
|
|
biome_map: Vec<u16>,
|
|
biome_bits: u8,
|
|
view_distance: i32,
|
|
sequence: i32,
|
|
last_pos: [f64; 3],
|
|
last_rot: (f32, f32),
|
|
last_on_ground: bool,
|
|
last_collision: bool,
|
|
reminder: u32,
|
|
last_input: u8,
|
|
was_sprinting: bool,
|
|
carried: Option<usize>,
|
|
loaded_sent: bool,
|
|
/// Open container: (window id, menu name).
|
|
menu: Option<(i32, String)>,
|
|
state_id: i32,
|
|
use_target: Option<[i32; 3]>,
|
|
entities: HashMap<i32, Tracked>,
|
|
lerps: HashMap<i32, Lerp>,
|
|
/// Item entities waiting for their item data.
|
|
pending_items: HashMap<i32, [f64; 3]>,
|
|
health: (f32, i32, f32),
|
|
game_mode: i32,
|
|
pub chat: Vec<(String, Instant)>,
|
|
pub chat_input: Option<String>,
|
|
action_bar: Option<(String, Instant)>,
|
|
players: HashMap<u128, String>,
|
|
destroying: Option<([i32; 3], u8, f32)>,
|
|
destroy_delay: u32,
|
|
placing: Option<([i32; 3], u64)>,
|
|
death_message: Option<String>,
|
|
player_type: Option<Arc<MobType>>,
|
|
/// Inventory as last synchronised, for creative-mode slot updates.
|
|
synced: Vec<Option<ItemStack>>,
|
|
decode_errors: u32,
|
|
clock: Option<i32>,
|
|
clock_rate: f32,
|
|
}
|
|
|
|
fn face_direction(face: [i32; 3]) -> u8 {
|
|
match face {
|
|
[0, -1, 0] => 0,
|
|
[0, 1, 0] => 1,
|
|
[0, 0, -1] => 2,
|
|
[0, 0, 1] => 3,
|
|
[-1, 0, 0] => 4,
|
|
[1, 0, 0] => 5,
|
|
_ => 1,
|
|
}
|
|
}
|
|
|
|
impl Game<'_> {
|
|
/// Leave the title for a server (ConnectScreen): an empty world fed by the connection.
|
|
pub(super) fn connect_server(&mut self, address: &str, name: &str) -> Result<()> {
|
|
let root = self.options.resources.clone();
|
|
let builtin = Builtin::find(&root)
|
|
.and_then(|p| Builtin::load(&p).ok())
|
|
.ok_or("registries.json not found next to the resources; run the data generator reports (tools/prepare_native_client.py)")?;
|
|
let lang = Arc::new(horizon_client::net::load_language(&root));
|
|
let view = self.settings.render_distance.clamp(2, 32) as i8;
|
|
let session = Session::connect(address, name, view, lang.clone());
|
|
let player_type = horizon_client::mobs::load_model(&root, "minecraft:player#main").map(|model| {
|
|
Arc::new(MobType {
|
|
id: "minecraft:player".into(),
|
|
width: 0.6,
|
|
height: 1.8,
|
|
eye_height: 1.62,
|
|
category: "misc".into(),
|
|
max_health: 20.0,
|
|
speed: 0.1,
|
|
attack_damage: 1.0,
|
|
follow_range: 0.0,
|
|
step_height: 0.6,
|
|
model: Arc::new(model),
|
|
texture: "entity/player/wide/steve".into(),
|
|
brain: Brain::Passive,
|
|
anim: Anim::Humanoid { zombie_arms: false },
|
|
sounds: ["entity.player.hurt", "entity.player.hurt", "entity.player.death"],
|
|
})
|
|
});
|
|
let mut streaming = Streaming::new(Arc::new(NoTerrain), self.res.context.clone(), self.res.threads);
|
|
streaming.remote = true;
|
|
streaming.radius = self.settings.render_distance;
|
|
self.streaming = streaming;
|
|
self.world = World::new(self.res.facts.air, 0);
|
|
self.save = Arc::new(SaveDir::new(std::env::temp_dir().join("horizon-remote-unused")));
|
|
self.inventory = vec![None; 36];
|
|
self.armor = [None, None, None, None];
|
|
self.craft_grid = vec![None; 9];
|
|
self.craft_size = 2;
|
|
self.player = None;
|
|
self.spawn = None;
|
|
self.mobs.clear();
|
|
self.arrows.clear();
|
|
self.dropped.clear();
|
|
self.particles.clear();
|
|
self.orbs.clear();
|
|
self.falling.clear();
|
|
self.travelling = None;
|
|
self.mining = None;
|
|
self.container = None;
|
|
self.carried = None;
|
|
self.using = None;
|
|
self.creative = false;
|
|
self.experience = Experience { level: 0, progress: 0.0, total: 0 };
|
|
self.screen = Screen::Playing;
|
|
self.title = None;
|
|
self.dim = Dim::Overworld;
|
|
if let Some(r) = self.renderer.as_mut() {
|
|
r.clear_sections();
|
|
}
|
|
self.apply_settings();
|
|
self.remote = Some(Remote {
|
|
session,
|
|
builtin: Arc::new(builtin),
|
|
lang,
|
|
registries: Arc::new(Dynamic::default()),
|
|
joined: false,
|
|
status: "Connecting to the server...".into(),
|
|
entity_id: 0,
|
|
dimension: DimensionType::vanilla("minecraft:overworld"),
|
|
biome_map: Vec::new(),
|
|
biome_bits: 7,
|
|
view_distance: self.settings.render_distance,
|
|
sequence: 0,
|
|
last_pos: [0.0; 3],
|
|
last_rot: (0.0, 0.0),
|
|
last_on_ground: false,
|
|
last_collision: false,
|
|
reminder: 0,
|
|
last_input: 0,
|
|
was_sprinting: false,
|
|
carried: None,
|
|
loaded_sent: false,
|
|
menu: None,
|
|
state_id: 0,
|
|
use_target: None,
|
|
entities: HashMap::new(),
|
|
lerps: HashMap::new(),
|
|
pending_items: HashMap::new(),
|
|
health: (20.0, 20, 5.0),
|
|
game_mode: 0,
|
|
chat: Vec::new(),
|
|
chat_input: None,
|
|
action_bar: None,
|
|
players: HashMap::new(),
|
|
destroying: None,
|
|
destroy_delay: 0,
|
|
placing: None,
|
|
death_message: None,
|
|
player_type,
|
|
synced: vec![None; 36],
|
|
decode_errors: 0,
|
|
clock: None,
|
|
clock_rate: 1.0,
|
|
});
|
|
Ok(())
|
|
}
|
|
|
|
/// Disconnect and return to the multiplayer screen (DisconnectedScreen).
|
|
pub(super) fn leave_server(&mut self, reason: Option<String>) -> Result<()> {
|
|
if let Some(mut r) = self.remote.take() {
|
|
r.session.disconnect();
|
|
}
|
|
self.streaming = Streaming::new(Arc::new(NoTerrain), self.res.context.clone(), 1);
|
|
self.streaming.paused = true;
|
|
self.world = World::new(self.res.facts.air, 0);
|
|
self.player = None;
|
|
self.mobs.clear();
|
|
self.dropped.clear();
|
|
self.particles.clear();
|
|
self.screen = Screen::Playing;
|
|
self.container = None;
|
|
if let Some(r) = self.renderer.as_mut() {
|
|
r.clear_sections();
|
|
}
|
|
let saves = std::env::current_dir()?.join("saves");
|
|
let mut title = horizon_client::title::Title::new(saves.clone());
|
|
title.mode = horizon_client::title::Mode::Multiplayer(match reason {
|
|
Some(reason) => horizon_client::multiplayer::Screen::Disconnected { reason },
|
|
None => horizon_client::multiplayer::Screen::list(&saves),
|
|
});
|
|
self.title = Some(title);
|
|
self.capture(false);
|
|
Ok(())
|
|
}
|
|
|
|
fn send(&self, packet: S) {
|
|
if let Some(r) = &self.remote {
|
|
r.session.send(packet);
|
|
}
|
|
}
|
|
fn next_sequence(&mut self) -> i32 {
|
|
let r = self.remote.as_mut().expect("remote");
|
|
r.sequence += 1;
|
|
r.sequence
|
|
}
|
|
fn item_name(&self, id: i32) -> Arc<str> {
|
|
let r = self.remote.as_ref().expect("remote");
|
|
Arc::from(r.builtin.get("minecraft:item").and_then(|i| i.name(id)).unwrap_or("minecraft:air"))
|
|
}
|
|
fn item_id(&self, name: &str) -> i32 {
|
|
let r = self.remote.as_ref().expect("remote");
|
|
r.builtin.get("minecraft:item").and_then(|i| i.id(name)).unwrap_or(0)
|
|
}
|
|
fn to_stack(&self, s: &Option<Stack>) -> Option<ItemStack> {
|
|
let s = s.as_ref()?;
|
|
Some(ItemStack { item: self.item_name(s.item), count: s.count.max(0) as u32, damage: s.damage().max(0) as u32 })
|
|
}
|
|
fn to_network(&self, s: &Option<ItemStack>) -> Option<Stack> {
|
|
let s = s.as_ref()?;
|
|
let mut stack = Stack::new(self.item_id(&s.item), s.count as i32);
|
|
if s.damage > 0 {
|
|
stack.added.push((horizon_protocol::item::component::DAMAGE, horizon_protocol::item::Component::Int(s.damage as i32)));
|
|
}
|
|
Some(stack)
|
|
}
|
|
fn chat_line(&mut self, text: String) {
|
|
eprintln!("[chat] {text}");
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.chat.push((text, Instant::now()));
|
|
if r.chat.len() > 100 {
|
|
r.chat.remove(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Process everything the network thread received (once per frame, like
|
|
/// the client's packet processor).
|
|
pub(super) fn poll_remote(&mut self) -> Result<()> {
|
|
let Some(r) = &self.remote else { return Ok(()) };
|
|
let events = r.session.poll();
|
|
for event in events {
|
|
match event {
|
|
Event::Status(s) => {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.status = s;
|
|
}
|
|
}
|
|
Event::Joined { registries, name, .. } => {
|
|
self.set_registries(registries);
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.joined = true;
|
|
r.status = format!("Joined as {name}; loading terrain...");
|
|
}
|
|
}
|
|
Event::Reconfigured(registries) => self.set_registries(registries),
|
|
Event::DecodeError(e) => {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.decode_errors += 1;
|
|
if r.decode_errors <= 20 {
|
|
eprintln!("Horizon: skipped undecodable packet {e}");
|
|
}
|
|
}
|
|
}
|
|
Event::Disconnected(reason) => {
|
|
eprintln!("Horizon: disconnected: {reason}");
|
|
return self.leave_server(Some(reason));
|
|
}
|
|
Event::Packet(packet) => self.handle_packet(*packet)?,
|
|
}
|
|
if self.remote.is_none() {
|
|
break;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
fn set_registries(&mut self, registries: Arc<Dynamic>) {
|
|
let biomes: Vec<u16> = registries
|
|
.registries
|
|
.get("minecraft:worldgen/biome")
|
|
.map(|list| list.iter().map(|(name, _)| self.res.biomes.id(name)).collect())
|
|
.unwrap_or_default();
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.biome_bits = ceil_log2(biomes.len());
|
|
r.biome_map = biomes;
|
|
r.registries = registries;
|
|
}
|
|
}
|
|
/// Switch to a (possibly new) dimension: a fresh client level.
|
|
fn enter_remote_dimension(&mut self, spawn: &play::SpawnInfo, keep_world: bool) {
|
|
let Some(r) = self.remote.as_mut() else { return };
|
|
let dimension = r.registries.dimension(spawn.dimension_type);
|
|
let same = r.dimension.name == dimension.name && keep_world;
|
|
r.dimension = dimension;
|
|
r.game_mode = spawn.game_type;
|
|
r.loaded_sent = false;
|
|
self.creative = spawn.game_type == 1;
|
|
self.dim = if spawn.dimension == "minecraft:the_nether" { Dim::Nether } else { Dim::Overworld };
|
|
if !same {
|
|
let mut streaming = Streaming::new(Arc::new(NoTerrain), self.res.context.clone(), self.res.threads);
|
|
streaming.remote = true;
|
|
streaming.radius = self.streaming.radius;
|
|
self.streaming = streaming;
|
|
let (time, day, weather) = (self.world.game_time, self.world.day_time, self.world.weather);
|
|
self.world = World::new(self.res.facts.air, spawn.seed);
|
|
self.world.game_time = time;
|
|
self.world.day_time = day;
|
|
self.world.weather = weather;
|
|
self.mobs.clear();
|
|
self.dropped.clear();
|
|
self.particles.clear();
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.entities.clear();
|
|
r.lerps.clear();
|
|
r.pending_items.clear();
|
|
}
|
|
if let Some(renderer) = self.renderer.as_mut() {
|
|
renderer.clear_sections();
|
|
}
|
|
}
|
|
let has_sky = self.remote.as_ref().is_none_or(|r| r.dimension.has_skylight);
|
|
self.streaming.sky_light = has_sky;
|
|
self.streaming.nether_shading = self.dim == Dim::Nether;
|
|
self.player = None;
|
|
self.apply_settings();
|
|
}
|
|
|
|
/// LevelChunkSection data into the client's fixed -64..320 column.
|
|
fn remote_chunk(&self, p: &play::LevelChunkWithLight) -> std::result::Result<Chunk, String> {
|
|
let r = self.remote.as_ref().ok_or("no connection")?;
|
|
let sections = p.chunk.sections(r.dimension.sections(), 16, r.biome_bits).map_err(|e| e.to_string())?;
|
|
let mut chunk = Chunk::empty(p.x, p.z);
|
|
let mut biomes = vec![0u16; chunk.biomes.len()];
|
|
let offset = (r.dimension.min_y - MIN_Y).div_euclid(16);
|
|
for (i, s) in sections.iter().enumerate() {
|
|
let target = offset + i as i32;
|
|
if !(0..SECTIONS as i32).contains(&target) {
|
|
continue;
|
|
}
|
|
let blocks = if s.states.bits == 0 {
|
|
Blocks::Uniform(s.states.get(0) as u16)
|
|
} else {
|
|
let mut a = Box::new([0u16; 4096]);
|
|
for (j, v) in a.iter_mut().enumerate() {
|
|
*v = s.states.get(j) as u16;
|
|
}
|
|
Blocks::Full(a)
|
|
};
|
|
let mut section = Section { blocks, light: Light::Uniform(0xF0) };
|
|
section.compact();
|
|
chunk.sections[target as usize] = Arc::new(section);
|
|
for j in 0..64 {
|
|
let biome = r.biome_map.get(s.biomes.get(j) as usize).copied().unwrap_or(0);
|
|
if let Some(cell) = biomes.get_mut(target as usize * 64 + j) {
|
|
*cell = biome;
|
|
}
|
|
}
|
|
}
|
|
// Columns outside the dimension's range take its nearest biome.
|
|
let (lo, hi) = (offset.max(0) as usize * 64, ((offset + sections.len() as i32).min(SECTIONS as i32)) as usize * 64);
|
|
if lo < hi {
|
|
for j in 0..biomes.len() {
|
|
if j < lo {
|
|
biomes[j] = biomes[lo + j % 16];
|
|
} else if j >= hi {
|
|
biomes[j] = biomes[hi - 16 + j % 16];
|
|
}
|
|
}
|
|
}
|
|
chunk.biomes = Arc::new(biomes);
|
|
Ok(chunk)
|
|
}
|
|
/// Keep the renderable block entities (chests, furnaces) in step with blocks.
|
|
fn sync_block_entity(&mut self, pos: (i32, i32, i32), state: BlockStateId) {
|
|
let name = self.res.facts.get(state).name.clone();
|
|
match BlockEntity::for_block(&name) {
|
|
Some(entity) => {
|
|
let same = self.world.block_entities.get(&pos).is_some_and(|e| e.id() == entity.id());
|
|
if !same {
|
|
self.world.block_entities.insert(pos, entity);
|
|
}
|
|
}
|
|
None => {
|
|
self.world.block_entities.remove(&pos);
|
|
}
|
|
}
|
|
}
|
|
fn set_block(&mut self, pos: [i32; 3], state: i32) {
|
|
let state = BlockStateId(state.max(0) as u32);
|
|
if self.world.loaded(pos[0], pos[2]) && self.world.set(pos[0], pos[1], pos[2], state).is_ok() {
|
|
self.sync_block_entity((pos[0], pos[1], pos[2]), state);
|
|
}
|
|
// A block we just placed: play its place sound (the server skips the placer).
|
|
if let Some((target, _)) = self.remote.as_ref().and_then(|r| r.placing)
|
|
&& target == pos
|
|
&& !self.res.facts.is_air(state)
|
|
{
|
|
let s = self.res.facts.get(state).sounds.clone();
|
|
let at = [f64::from(pos[0]) + 0.5, f64::from(pos[1]) + 0.5, f64::from(pos[2]) + 0.5];
|
|
self.audio.play(&s.place, Some(at), (s.volume + 1.0) / 2.0, s.pitch * 0.8);
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.placing = None;
|
|
}
|
|
}
|
|
}
|
|
fn spawn_entity(&mut self, id: i32, kind: &str, position: [f64; 3], yaw: f32, head: f32) {
|
|
let at = Vec3::new(position[0], position[1], position[2]);
|
|
let mob_type = if kind == "minecraft:player" {
|
|
self.remote.as_ref().and_then(|r| r.player_type.clone())
|
|
} else {
|
|
self.res.mob_types.get(kind).cloned()
|
|
};
|
|
if let Some(t) = mob_type {
|
|
let mut mob = Mob::new(id as u32, t, at, head);
|
|
mob.body_yaw = yaw;
|
|
mob.previous_body_yaw = yaw;
|
|
mob.persistent = true;
|
|
self.mobs.retain(|m| m.id != id as u32);
|
|
self.mobs.push(mob);
|
|
}
|
|
if let Some(r) = self.remote.as_mut() {
|
|
if kind == "minecraft:item" {
|
|
r.pending_items.insert(id, position);
|
|
}
|
|
r.entities.insert(id, Tracked { kind: kind.to_owned(), position });
|
|
}
|
|
}
|
|
fn move_entity(&mut self, id: i32, position: [f64; 3], rotation: Option<(f32, f32)>, on_ground: bool) {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
if let Some(t) = r.entities.get_mut(&id) {
|
|
t.position = position;
|
|
}
|
|
r.lerps.insert(id, Lerp { target: position, steps: 3 });
|
|
if let Some(p) = r.pending_items.get_mut(&id) {
|
|
*p = position;
|
|
}
|
|
}
|
|
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id as u32) {
|
|
m.on_ground = on_ground;
|
|
if let Some((yaw, pitch)) = rotation {
|
|
m.body_yaw = yaw;
|
|
m.head_pitch = pitch;
|
|
}
|
|
}
|
|
}
|
|
fn remove_entity(&mut self, id: i32) {
|
|
self.mobs.retain(|m| m.id != id as u32);
|
|
self.dropped.retain(|d| d.id != id as u32);
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.entities.remove(&id);
|
|
r.lerps.remove(&id);
|
|
r.pending_items.remove(&id);
|
|
}
|
|
}
|
|
/// Map a menu slot to Horizon's inventory screen slot ids.
|
|
fn menu_slot(menu: &str, slot: i32) -> Option<usize> {
|
|
let s = usize::try_from(slot).ok()?;
|
|
let rows = |n: usize| -> Option<usize> {
|
|
match s {
|
|
_ if s < n * 9 => Some(300 + s),
|
|
_ if s < n * 9 + 27 => Some(9 + s - n * 9),
|
|
_ if s < n * 9 + 36 => Some(s - n * 9 - 27),
|
|
_ => None,
|
|
}
|
|
};
|
|
match menu {
|
|
"inventory" => match s {
|
|
0 => Some(200),
|
|
1..=4 => Some(100 + s - 1),
|
|
5..=8 => Some(500 + s - 5),
|
|
9..=35 => Some(s),
|
|
36..=44 => Some(s - 36),
|
|
_ => None,
|
|
},
|
|
"minecraft:crafting" => match s {
|
|
0 => Some(200),
|
|
1..=9 => Some(100 + s - 1),
|
|
10..=36 => Some(9 + s - 10),
|
|
37..=45 => Some(s - 37),
|
|
_ => None,
|
|
},
|
|
"minecraft:furnace" | "minecraft:blast_furnace" | "minecraft:smoker" => match s {
|
|
0..=2 => Some(300 + s),
|
|
3..=29 => Some(9 + s - 3),
|
|
30..=38 => Some(s - 30),
|
|
_ => None,
|
|
},
|
|
"minecraft:generic_9x1" => rows(1),
|
|
"minecraft:generic_9x2" => rows(2),
|
|
"minecraft:generic_9x3" | "minecraft:shulker_box" => rows(3),
|
|
"minecraft:generic_9x4" => rows(4),
|
|
"minecraft:generic_9x5" => rows(5),
|
|
"minecraft:generic_9x6" => rows(6),
|
|
_ => None,
|
|
}
|
|
}
|
|
fn open_menu_name(&self, container: i32) -> String {
|
|
match self.remote.as_ref().and_then(|r| r.menu.as_ref()) {
|
|
Some((id, name)) if *id == container && container != 0 => name.clone(),
|
|
_ => "inventory".into(),
|
|
}
|
|
}
|
|
fn set_menu_slot(&mut self, container: i32, slot: i32, item: Option<ItemStack>) {
|
|
let menu = self.open_menu_name(container);
|
|
if container != 0 && menu == "inventory" {
|
|
return;
|
|
}
|
|
let Some(internal) = Self::menu_slot(&menu, slot) else { return };
|
|
if internal == 200 {
|
|
return; // the result slot is recomputed from the grid
|
|
}
|
|
*self.slot_mut(internal) = item;
|
|
}
|
|
|
|
fn handle_packet(&mut self, packet: C) -> Result<()> {
|
|
match packet {
|
|
C::Login(p) => {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.entity_id = p.player_id;
|
|
r.view_distance = p.chunk_radius;
|
|
}
|
|
self.streaming.radius = self.settings.render_distance.min(p.chunk_radius + 1).max(2);
|
|
self.enter_remote_dimension(&p.spawn, false);
|
|
self.send(S::ClientInformation(horizon_protocol::packets::configuration::ClientInformation::new(self.settings.render_distance.clamp(2, 32) as i8)));
|
|
}
|
|
C::Respawn(p) => {
|
|
self.enter_remote_dimension(&p.spawn, true);
|
|
self.screen = Screen::Playing;
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.death_message = None;
|
|
r.health = (20.0, 20, 5.0);
|
|
}
|
|
self.capture(true);
|
|
}
|
|
C::PlayerPosition(p) => self.remote_teleport(&p)?,
|
|
C::PlayerRotation(p) => {
|
|
self.yaw = if p.relative_yaw { self.yaw + p.yaw } else { p.yaw };
|
|
self.pitch = (if p.relative_pitch { self.pitch + p.pitch } else { p.pitch }).clamp(-90.0, 90.0);
|
|
}
|
|
C::LevelChunkWithLight(p) => match self.remote_chunk(&p) {
|
|
Ok(chunk) => {
|
|
let (x, z) = (p.x, p.z);
|
|
self.streaming.insert_remote(&mut self.world, chunk);
|
|
self.world.block_entities.retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z));
|
|
for info in &p.chunk.block_entities {
|
|
let pos = (x * 16 + i32::from(info.packed_xz as u8 >> 4), i32::from(info.y), z * 16 + i32::from(info.packed_xz as u8 & 15));
|
|
let state = self.world.block(pos.0, pos.1, pos.2);
|
|
self.sync_block_entity(pos, state);
|
|
}
|
|
}
|
|
Err(e) => eprintln!("Horizon: chunk {} {}: {e}", p.x, p.z),
|
|
},
|
|
C::ForgetLevelChunk(p) => {
|
|
let [x, z] = p.pos;
|
|
self.streaming.forget(&mut self.world, x, z);
|
|
self.world.block_entities.retain(|k, _| (k.0 >> 4, k.2 >> 4) != (x, z));
|
|
if let Some(renderer) = self.renderer.as_mut() {
|
|
for sy in 0..SECTIONS as i32 {
|
|
renderer.remove((x, sy, z));
|
|
}
|
|
}
|
|
}
|
|
C::ChunkBatchFinished(_) => {
|
|
// ChunkBatchSizeCalculator's ceiling; meshing runs on workers.
|
|
self.send(S::ChunkBatchReceived(play::ChunkBatchReceived { chunks_per_tick: 64.0 }));
|
|
}
|
|
C::BlockUpdate(p) => self.set_block(p.pos, p.state),
|
|
C::SectionBlocksUpdate(p) => {
|
|
let [sx, sy, sz] = p.section;
|
|
for change in p.changes {
|
|
let local = (change & 0xFFF) as i32;
|
|
let pos = [sx * 16 + (local >> 8 & 15), sy * 16 + (local & 15), sz * 16 + (local >> 4 & 15)];
|
|
self.set_block(pos, (change >> 12) as i32);
|
|
}
|
|
}
|
|
C::BlockChangedAck(_) => {}
|
|
C::LevelEvent(p) if p.kind == 2001 => {
|
|
// LevelEvent.PARTICLES_DESTROY_BLOCK: someone else broke a block.
|
|
let state = BlockStateId(p.data.max(0) as u32);
|
|
let s = self.res.facts.get(state).sounds.clone();
|
|
let at = [f64::from(p.pos[0]) + 0.5, f64::from(p.pos[1]) + 0.5, f64::from(p.pos[2]) + 0.5];
|
|
self.audio.play(&s.break_sound, Some(at), (s.volume + 1.0) / 2.0, s.pitch * 0.8);
|
|
self.destroy_particles(p.pos, state);
|
|
}
|
|
C::Sound(p) => {
|
|
let name = match &p.sound.1 {
|
|
Some((location, _)) => Some(location.clone()),
|
|
None => self.remote.as_ref().and_then(|r| r.builtin.get("minecraft:sound_event")?.name(p.sound.0).map(str::to_owned)),
|
|
};
|
|
if let Some(name) = name {
|
|
let at = [f64::from(p.x) / 8.0, f64::from(p.y) / 8.0, f64::from(p.z) / 8.0];
|
|
self.audio.play(&name, Some(at), p.volume, p.pitch);
|
|
}
|
|
}
|
|
C::AddEntity(p) => {
|
|
let kind = self.remote.as_ref().and_then(|r| r.builtin.get("minecraft:entity_type")?.name(p.kind).map(str::to_owned)).unwrap_or_default();
|
|
let yaw = horizon_protocol::buf::unpack_degrees(p.yaw);
|
|
let head = horizon_protocol::buf::unpack_degrees(p.head_yaw);
|
|
self.spawn_entity(p.id, &kind, p.position, yaw, head);
|
|
}
|
|
C::RemoveEntities(p) => {
|
|
for id in p.ids {
|
|
self.remove_entity(id);
|
|
}
|
|
}
|
|
C::MoveEntityPos(play::MoveEntityPos(m)) | C::MoveEntityPosRot(play::MoveEntityPosRot(m)) | C::MoveEntityRot(play::MoveEntityRot(m)) => {
|
|
let base = self.remote.as_ref().and_then(|r| r.entities.get(&m.id)).map(|t| t.position);
|
|
let Some(base) = base else { return Ok(()) };
|
|
let position = m.delta.as_ref().map_or(base, |d| d.end(base));
|
|
let rotation = m.rotation.map(|(y, x)| (horizon_protocol::buf::unpack_degrees(y), horizon_protocol::buf::unpack_degrees(x)));
|
|
self.move_entity(m.id, position, rotation, m.on_ground);
|
|
}
|
|
C::EntityPositionSync(p) => self.move_entity(p.id, p.path.end(), Some((p.yaw, p.pitch)), p.on_ground),
|
|
C::TeleportEntity(p) => {
|
|
let base = self.remote.as_ref().and_then(|r| r.entities.get(&p.id)).map_or([0.0; 3], |t| t.position);
|
|
let rel = |bit: i32, i: usize| if p.relatives & bit != 0 { base[i] + p.position[i] } else { p.position[i] };
|
|
let position = [rel(play::relative::X, 0), rel(play::relative::Y, 1), rel(play::relative::Z, 2)];
|
|
self.move_entity(p.id, position, Some((p.yaw, p.pitch)), p.on_ground);
|
|
}
|
|
C::RotateHead(p) => {
|
|
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
|
|
m.yaw = horizon_protocol::buf::unpack_degrees(p.head_yaw);
|
|
}
|
|
}
|
|
C::SetEntityData(p) => {
|
|
for (index, _, value) in &p.values {
|
|
if *index == ITEM_ENTITY_ITEM
|
|
&& let Value::Item(stack) = value
|
|
{
|
|
self.remote_item_data(p.id, stack);
|
|
}
|
|
}
|
|
}
|
|
C::TakeItemEntity(p) => {
|
|
if self.remote.as_ref().is_some_and(|r| r.entity_id == p.player)
|
|
&& let Some(eye) = self.eye_position()
|
|
{
|
|
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(eye), 0.2, pitch);
|
|
}
|
|
self.remove_entity(p.item);
|
|
}
|
|
C::HurtAnimation(p) => {
|
|
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
|
|
m.hurt_time = 10;
|
|
}
|
|
}
|
|
C::EntityEvent(p) => {
|
|
// EntityEvent.DEATH: start the death animation.
|
|
if p.event == 3
|
|
&& let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32)
|
|
{
|
|
m.health = 0.0;
|
|
}
|
|
}
|
|
C::Animate(p) if p.action == 0 => {}
|
|
C::SetHealth(p) => {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.health = (p.health, p.food, p.saturation);
|
|
}
|
|
self.apply_remote_health();
|
|
if p.health <= 0.0 && self.screen != Screen::Dead && self.player.is_some() {
|
|
self.screen = Screen::Dead;
|
|
self.capture(false);
|
|
}
|
|
}
|
|
C::PlayerCombatKill(p) => {
|
|
let lang = self.remote.as_ref().map(|r| r.lang.clone()).unwrap_or_default();
|
|
let message = plain(&p.message, &lang);
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.death_message = Some(message);
|
|
}
|
|
}
|
|
C::SetExperience(p) => self.experience = Experience { level: p.level, progress: p.progress, total: p.total },
|
|
C::SetTime(p) => {
|
|
self.world.game_time = p.game_time;
|
|
let clock = {
|
|
let r = self.remote.as_ref();
|
|
let names = r.and_then(|r| r.registries.registries.get("minecraft:world_clock"));
|
|
let wanted = r.map(|r| r.dimension.name.clone()).unwrap_or_default();
|
|
p.clocks
|
|
.iter()
|
|
.find(|c| names.and_then(|n| n.get(c.clock as usize)).is_some_and(|(n, _)| *n == wanted))
|
|
.or_else(|| p.clocks.first())
|
|
.cloned()
|
|
};
|
|
if let Some(c) = clock {
|
|
self.world.day_time = c.total_ticks;
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.clock = Some(c.clock);
|
|
r.clock_rate = c.rate;
|
|
}
|
|
}
|
|
}
|
|
C::GameEvent(p) => match p.event {
|
|
1 => {
|
|
self.world.weather.raining = true;
|
|
self.world.weather.rain_level = (0.0, 0.0);
|
|
}
|
|
2 => {
|
|
self.world.weather.raining = false;
|
|
self.world.weather.rain_level = (1.0, 1.0);
|
|
}
|
|
3 => {
|
|
let mode = p.param as i32;
|
|
self.creative = mode == 1;
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.game_mode = mode;
|
|
}
|
|
}
|
|
7 => {
|
|
self.world.weather.rain_level = (p.param, p.param);
|
|
self.world.weather.raining = p.param > 0.0;
|
|
}
|
|
8 => {
|
|
self.world.weather.thunder_level = (p.param, p.param);
|
|
self.world.weather.thundering = p.param > 0.0;
|
|
}
|
|
_ => {}
|
|
},
|
|
C::PlayerAbilities(p) => self.creative = p.flags & 8 != 0,
|
|
C::SetHeldSlot(p) => {
|
|
self.selected = p.slot.clamp(0, 8) as usize;
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.carried = Some(self.selected);
|
|
}
|
|
}
|
|
C::ContainerSetContent(p) => {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.state_id = p.state;
|
|
}
|
|
for (slot, item) in p.items.iter().enumerate() {
|
|
let stack = self.to_stack(item);
|
|
self.set_menu_slot(p.container, slot as i32, stack);
|
|
}
|
|
self.carried = self.to_stack(&p.carried);
|
|
self.remote_synced();
|
|
}
|
|
C::ContainerSetSlot(p) => {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.state_id = p.state;
|
|
}
|
|
let stack = self.to_stack(&p.item);
|
|
self.set_menu_slot(p.container, i32::from(p.slot), stack);
|
|
self.remote_synced();
|
|
}
|
|
C::SetCursorItem(p) => self.carried = self.to_stack(&p.item),
|
|
C::SetPlayerInventory(p) => {
|
|
let stack = self.to_stack(&p.item);
|
|
match p.slot {
|
|
0..=35 => self.inventory[p.slot as usize] = stack,
|
|
36..=39 => self.armor[3 - (p.slot - 36) as usize] = stack,
|
|
_ => {}
|
|
}
|
|
self.remote_synced();
|
|
}
|
|
C::ContainerSetData(p) => {
|
|
if let Some(key) = self.container
|
|
&& let Some(BlockEntity::Furnace(f)) = self.world.block_entities.get_mut(&key)
|
|
{
|
|
let v = i32::from(p.value);
|
|
match p.id {
|
|
0 => f.lit_remaining = v,
|
|
1 => f.lit_total = v,
|
|
2 => f.cooking_timer = v,
|
|
3 => f.cooking_total = v,
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
C::OpenScreen(p) => self.remote_open_screen(p),
|
|
C::ContainerClose(_) => {
|
|
if self.screen == Screen::Inventory {
|
|
self.remote_close_local();
|
|
self.screen = Screen::Playing;
|
|
self.capture(true);
|
|
}
|
|
}
|
|
C::SystemChat(p) => {
|
|
let text = plain(&p.content, &self.remote.as_ref().map(|r| r.lang.clone()).unwrap_or_default());
|
|
if p.overlay {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.action_bar = Some((text, Instant::now()));
|
|
}
|
|
} else {
|
|
self.chat_line(text);
|
|
}
|
|
}
|
|
C::PlayerChat(p) => {
|
|
let lang = self.remote.as_ref().map(|r| r.lang.clone()).unwrap_or_default();
|
|
let content = p.unsigned_content.as_ref().map_or_else(|| p.content.clone(), |t| plain(t, &lang));
|
|
let line = self.format_chat(&p.chat_type, &content);
|
|
self.chat_line(line);
|
|
}
|
|
C::DisguisedChat(p) => {
|
|
let lang = self.remote.as_ref().map(|r| r.lang.clone()).unwrap_or_default();
|
|
let content = plain(&p.message, &lang);
|
|
let line = self.format_chat(&p.chat_type, &content);
|
|
self.chat_line(line);
|
|
}
|
|
C::PlayerInfoUpdate(p) => {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
for e in p.entries {
|
|
if let Some(name) = e.name {
|
|
r.players.insert(e.uuid, name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
C::PlayerInfoRemove(p) => {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
for u in p.uuids {
|
|
r.players.remove(&u);
|
|
}
|
|
}
|
|
}
|
|
C::SetChunkCacheRadius(p) => {
|
|
self.streaming.radius = self.settings.render_distance.min(p.distance + 1).max(2);
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.view_distance = p.distance;
|
|
}
|
|
}
|
|
C::SetActionBarText(p) | C::SetTitleText(p) => {
|
|
let lang = self.remote.as_ref().map(|r| r.lang.clone()).unwrap_or_default();
|
|
let text = plain(&p.text, &lang);
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.action_bar = Some((text, Instant::now()));
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
Ok(())
|
|
}
|
|
/// ChatType decoration: `chat.translation_key` with sender/content parameters.
|
|
fn format_chat(&self, bound: &play::ChatTypeBound, content: &str) -> String {
|
|
let Some(r) = self.remote.as_ref() else { return content.to_owned() };
|
|
let sender = plain(&bound.name, &r.lang);
|
|
let decoration = r.registries.data("minecraft:chat_type", bound.chat_type).and_then(|t| t.get("chat"));
|
|
let key = match decoration.and_then(|d| d.get("translation_key")) {
|
|
Some(Tag::String(s)) => s.to_string_lossy(),
|
|
_ => "chat.type.text".into(),
|
|
};
|
|
let params: Vec<String> = match decoration.and_then(|d| d.get("parameters")) {
|
|
Some(Tag::List(list)) => list
|
|
.iter()
|
|
.map(|p| match p {
|
|
Tag::String(s) => match s.to_string_lossy().as_str() {
|
|
"sender" => sender.clone(),
|
|
"target" => bound.target.as_ref().map(|t| plain(t, &r.lang)).unwrap_or_default(),
|
|
_ => content.to_owned(),
|
|
},
|
|
_ => String::new(),
|
|
})
|
|
.collect(),
|
|
_ => vec![sender, content.to_owned()],
|
|
};
|
|
let pattern = r.lang.get(&key).cloned().unwrap_or_else(|| "<%s> %s".into());
|
|
format_java(&pattern, ¶ms)
|
|
}
|
|
fn remote_item_data(&mut self, id: i32, stack: &Option<Stack>) {
|
|
let Some(stack) = self.to_stack(stack) else { return };
|
|
let position = self.remote.as_mut().and_then(|r| r.pending_items.remove(&id));
|
|
if let Some(item) = self.dropped.iter_mut().find(|d| d.id == id as u32) {
|
|
item.stack = stack;
|
|
return;
|
|
}
|
|
let Some(p) = position else { return };
|
|
let at = Vec3::new(p[0], p[1], p[2]);
|
|
let bob_offset = self.world.random.next_float() * std::f32::consts::PI * 2.0;
|
|
self.dropped.push(ItemEntity {
|
|
id: id as u32,
|
|
stack,
|
|
position: at,
|
|
previous: at,
|
|
velocity: Vec3::ZERO,
|
|
on_ground: false,
|
|
age: 0,
|
|
pickup_delay: 0,
|
|
bob_offset,
|
|
});
|
|
}
|
|
fn apply_remote_health(&mut self) {
|
|
let Some((health, food, saturation)) = self.remote.as_ref().map(|r| r.health) else { return };
|
|
if let Some(p) = self.player.as_mut() {
|
|
if (p.health.health() - health).abs() > f32::EPSILON {
|
|
let _ = p.set_health(health.max(0.0), false);
|
|
}
|
|
p.health.food.food = food;
|
|
p.health.food.saturation = saturation;
|
|
}
|
|
}
|
|
/// ClientPacketListener.handleMovePlayer.
|
|
fn remote_teleport(&mut self, p: &play::PlayerPosition) -> Result<()> {
|
|
use play::relative as rel;
|
|
let current = self.player.as_ref().map(|pl| pl.position).unwrap_or(Vec3::ZERO);
|
|
let velocity = self.player.as_ref().map(|pl| pl.velocity).unwrap_or(Vec3::ZERO);
|
|
let pick = |bit: i32, base: f64, v: f64| if p.relatives & bit != 0 { base + v } else { v };
|
|
let position = Vec3::new(pick(rel::X, current.x, p.position[0]), pick(rel::Y, current.y, p.position[1]), pick(rel::Z, current.z, p.position[2]));
|
|
let yaw = if p.relatives & rel::Y_ROT != 0 { self.yaw + p.yaw } else { p.yaw };
|
|
let pitch = (if p.relatives & rel::X_ROT != 0 { self.pitch + p.pitch } else { p.pitch }).clamp(-90.0, 90.0);
|
|
let delta = Vec3::new(
|
|
pick(rel::DELTA_X, velocity.x, p.delta[0]),
|
|
pick(rel::DELTA_Y, velocity.y, p.delta[1]),
|
|
pick(rel::DELTA_Z, velocity.z, p.delta[2]),
|
|
);
|
|
match self.player.as_mut() {
|
|
Some(player) => {
|
|
player.position = position;
|
|
player.velocity = delta;
|
|
}
|
|
None => {
|
|
let mut player = PlayerMotion::new(self.motion, position)?;
|
|
player.velocity = delta;
|
|
self.player = Some(player);
|
|
self.eye = 1.62;
|
|
self.previous_eye = 1.62;
|
|
self.clock.reset();
|
|
self.apply_remote_health();
|
|
}
|
|
}
|
|
self.previous_position = position;
|
|
self.yaw = yaw;
|
|
self.pitch = pitch;
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.last_pos = [position.x, position.y, position.z];
|
|
r.last_rot = (yaw, pitch);
|
|
r.destroying = None;
|
|
}
|
|
self.mining = None;
|
|
self.send(S::AcceptTeleportation(play::AcceptTeleportation { id: p.teleport, x: position.x, y: position.y, z: position.z, yaw, pitch }));
|
|
Ok(())
|
|
}
|
|
|
|
/// One client tick while connected (Minecraft.tick with a ClientLevel).
|
|
pub(super) fn tick_remote(&mut self) -> Result<()> {
|
|
self.ticks += 1;
|
|
self.world.game_time += 1;
|
|
let rate = self.remote.as_ref().map_or(1.0, |r| r.clock_rate);
|
|
if rate > 0.0 {
|
|
self.world.day_time += rate.round() as i64;
|
|
}
|
|
// Weather levels drift toward their targets between server updates.
|
|
let w = &mut self.world.weather;
|
|
w.rain_level.0 = w.rain_level.1;
|
|
w.thunder_level.0 = w.thunder_level.1;
|
|
if self.use_delay > 0 {
|
|
self.use_delay -= 1;
|
|
}
|
|
self.tick_remote_entities();
|
|
self.tick_hand();
|
|
let facts = &self.res.facts;
|
|
let world = &self.world;
|
|
self.particles.retain_mut(|p| p.tick(world, |id| facts.states[id as usize].full_collision));
|
|
let Some(player) = self.player.as_mut() else { return Ok(()) };
|
|
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(());
|
|
}
|
|
if self.remote.as_ref().is_some_and(|r| !r.loaded_sent) {
|
|
// ClientPacketListener: the level around the player is ready.
|
|
self.send(S::PlayerLoaded(Empty));
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.loaded_sent = true;
|
|
}
|
|
}
|
|
let Some(player) = self.player.as_mut() else { return Ok(()) };
|
|
let chatting = self.remote.as_ref().is_some_and(|r| r.chat_input.is_some());
|
|
let playing = self.screen == Screen::Playing && !chatting;
|
|
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),
|
|
};
|
|
let input = u8::from(keys.forward)
|
|
| u8::from(keys.backward) << 1
|
|
| u8::from(keys.left) << 2
|
|
| u8::from(keys.right) << 3
|
|
| u8::from(keys.jump) << 4
|
|
| u8::from(keys.shift) << 5
|
|
| u8::from(keys.sprint) << 6;
|
|
self.previous_position = player.position;
|
|
player.yaw = self.yaw;
|
|
let dead = self.screen == Screen::Dead;
|
|
if !dead {
|
|
MotionWorld { player, scene: &mut self.world, assets: &self.res.assets, collision_binding: self.collision, resources: self.motion }
|
|
.controlled_simulation_tick(keys)?;
|
|
}
|
|
let events = std::mem::take(&mut player.events);
|
|
self.previous_eye = self.eye;
|
|
self.eye += (player.dimensions.eye_height - self.eye) * 0.5;
|
|
let crouching = player.pose == horizon_client::pose::Pose::Crouching;
|
|
let feet = [player.position.x, player.position.y, player.position.z];
|
|
for event in events {
|
|
if let horizon_client::motion::MotionEvent::Emission { state, .. } = event
|
|
&& !crouching
|
|
{
|
|
let sounds = self.res.facts.get(state).sounds.clone();
|
|
self.audio.play(&sounds.step, Some(feet), sounds.volume * 0.15, sounds.pitch);
|
|
}
|
|
}
|
|
// The server owns health and hunger: undo local food/fall changes.
|
|
self.apply_remote_health();
|
|
if let Some(p) = &self.player {
|
|
let (dx, dz) = (p.position.x - self.previous_position.x, p.position.z - self.previous_position.z);
|
|
let speed = ((dx * dx + dz * dz).sqrt() as f32).min(0.1);
|
|
self.walk.0 = self.walk.1;
|
|
self.walk.1 += (dx * dx + dz * dz).sqrt() as f32 * 0.6;
|
|
self.bob.0 = self.bob.1;
|
|
let target = if p.ground.on_ground { speed } else { 0.0 };
|
|
self.bob.1 += (target - self.bob.1) * 0.4;
|
|
}
|
|
if !dead {
|
|
self.remote_mining();
|
|
if self.right && self.use_delay == 0 && playing {
|
|
self.remote_use();
|
|
self.use_delay = 4;
|
|
}
|
|
}
|
|
self.remote_send_state(input);
|
|
self.send(S::ClientTickEnd(Empty));
|
|
Ok(())
|
|
}
|
|
fn tick_remote_entities(&mut self) {
|
|
let Some(r) = self.remote.as_mut() else { return };
|
|
let mut lerps = std::mem::take(&mut r.lerps);
|
|
for m in &mut self.mobs {
|
|
m.previous = m.position;
|
|
m.previous_yaw = m.yaw;
|
|
m.previous_body_yaw = m.body_yaw;
|
|
m.previous_limb_speed = m.limb_speed;
|
|
m.age += 1;
|
|
if m.hurt_time > 0 {
|
|
m.hurt_time -= 1;
|
|
}
|
|
if !m.alive() {
|
|
m.death_time += 1;
|
|
}
|
|
if let Some(l) = lerps.get_mut(&(m.id as i32))
|
|
&& l.steps > 0
|
|
{
|
|
let n = f64::from(l.steps);
|
|
m.position = Vec3::new(
|
|
m.position.x + (l.target[0] - m.position.x) / n,
|
|
m.position.y + (l.target[1] - m.position.y) / n,
|
|
m.position.z + (l.target[2] - m.position.z) / n,
|
|
);
|
|
l.steps -= 1;
|
|
}
|
|
// WalkAnimationState.update from the horizontal distance moved.
|
|
let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
|
|
let target = (((dx * dx + dz * dz).sqrt() * 4.0) as f32).min(1.0);
|
|
m.limb_speed += (target - m.limb_speed) * 0.4;
|
|
m.limb_position += m.limb_speed;
|
|
}
|
|
for d in &mut self.dropped {
|
|
d.previous = d.position;
|
|
d.age += 1;
|
|
if let Some(l) = lerps.get_mut(&(d.id as i32))
|
|
&& l.steps > 0
|
|
{
|
|
let n = f64::from(l.steps);
|
|
d.position = Vec3::new(
|
|
d.position.x + (l.target[0] - d.position.x) / n,
|
|
d.position.y + (l.target[1] - d.position.y) / n,
|
|
d.position.z + (l.target[2] - d.position.z) / n,
|
|
);
|
|
l.steps -= 1;
|
|
}
|
|
}
|
|
lerps.retain(|_, l| l.steps > 0);
|
|
if let Some(r) = self.remote.as_mut() {
|
|
for (id, l) in lerps {
|
|
r.lerps.entry(id).or_insert(l);
|
|
}
|
|
}
|
|
}
|
|
/// LocalPlayer.sendPosition plus input, sprint and held-slot updates.
|
|
fn remote_send_state(&mut self, input: u8) {
|
|
let Some(p) = self.player.as_ref() else { return };
|
|
let (pos, on_ground, collision, sprinting) = ([p.position.x, p.position.y, p.position.z], p.ground.on_ground, p.collision.horizontal, p.sprinting);
|
|
let (yaw, pitch, selected) = (self.yaw, self.pitch, self.selected);
|
|
let Some(r) = self.remote.as_mut() else { return };
|
|
let mut out = Vec::new();
|
|
if r.carried != Some(selected) {
|
|
r.carried = Some(selected);
|
|
out.push(S::SetCarriedItem(play::SetCarriedItem { slot: selected as i16 }));
|
|
}
|
|
if input != r.last_input {
|
|
r.last_input = input;
|
|
out.push(S::PlayerInput(play::PlayerInput { flags: input }));
|
|
}
|
|
if sprinting != r.was_sprinting {
|
|
r.was_sprinting = sprinting;
|
|
out.push(S::PlayerCommand(play::PlayerCommand { id: r.entity_id, action: if sprinting { 1 } else { 2 }, data: 0 }));
|
|
}
|
|
r.reminder += 1;
|
|
let d = [pos[0] - r.last_pos[0], pos[1] - r.last_pos[1], pos[2] - r.last_pos[2]];
|
|
let moved = d[0] * d[0] + d[1] * d[1] + d[2] * d[2] > 2.0e-4 * 2.0e-4 || r.reminder >= 20;
|
|
let rotated = yaw != r.last_rot.0 || pitch != r.last_rot.1;
|
|
let flags = u8::from(on_ground) | u8::from(collision) << 1;
|
|
let [x, y, z] = pos;
|
|
if moved && rotated {
|
|
out.push(S::MovePlayerPosRot(play::MovePlayerPosRot { x, y, z, yaw, pitch, flags }));
|
|
} else if moved {
|
|
out.push(S::MovePlayerPos(play::MovePlayerPos { x, y, z, flags }));
|
|
} else if rotated {
|
|
out.push(S::MovePlayerRot(play::MovePlayerRot { yaw, pitch, flags }));
|
|
} else if r.last_on_ground != on_ground || r.last_collision != collision {
|
|
out.push(S::MovePlayerStatus(play::MovePlayerStatus { flags }));
|
|
}
|
|
if moved {
|
|
r.last_pos = pos;
|
|
r.reminder = 0;
|
|
}
|
|
if rotated {
|
|
r.last_rot = (yaw, pitch);
|
|
}
|
|
r.last_on_ground = on_ground;
|
|
r.last_collision = collision;
|
|
// Creative inventory edits are sent slot by slot (SetCreativeModeSlot).
|
|
let mut creative_slots = Vec::new();
|
|
if self.creative {
|
|
for i in 0..36 {
|
|
if self.inventory[i] != r.synced[i] {
|
|
r.synced[i] = self.inventory[i].clone();
|
|
creative_slots.push(i);
|
|
}
|
|
}
|
|
}
|
|
for packet in out {
|
|
self.send(packet);
|
|
}
|
|
for i in creative_slots {
|
|
let slot = if i < 9 { 36 + i } else { i } as i16;
|
|
let item = self.to_network(&self.inventory[i]);
|
|
self.send(S::SetCreativeModeSlot(play::SetCreativeModeSlot { slot, item }));
|
|
}
|
|
}
|
|
/// Inventory as the server last described it.
|
|
fn remote_synced(&mut self) {
|
|
let inventory = self.inventory.clone();
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.synced = inventory;
|
|
}
|
|
}
|
|
|
|
/// MultiPlayerGameMode.startDestroyBlock / continueDestroyBlock.
|
|
fn remote_mining(&mut self) {
|
|
let Some(r) = self.remote.as_mut() else { return };
|
|
if r.destroy_delay > 0 {
|
|
r.destroy_delay -= 1;
|
|
}
|
|
let chatting = r.chat_input.is_some();
|
|
if !self.left || self.screen != Screen::Playing || chatting {
|
|
if let Some((pos, _, _)) = r.destroying.take() {
|
|
self.send(S::PlayerAction(play::PlayerAction { action: 2, pos, direction: 0, sequence: 0 }));
|
|
}
|
|
self.mining = None;
|
|
return;
|
|
}
|
|
let Some(hit) = self.pick() else {
|
|
self.mining = None;
|
|
return;
|
|
};
|
|
let face = face_direction(hit.face);
|
|
let state = self.world.block(hit.pos[0], hit.pos[1], hit.pos[2]);
|
|
if self.res.facts.is_air(state) {
|
|
return;
|
|
}
|
|
if self.remote.as_ref().is_some_and(|r| r.destroy_delay > 0) {
|
|
return;
|
|
}
|
|
self.swing_arm();
|
|
self.send(S::Punch(Empty));
|
|
if self.creative {
|
|
let seq = self.next_sequence();
|
|
self.predict_break(hit.pos, state);
|
|
self.send(S::PlayerAction(play::PlayerAction { action: 0, pos: hit.pos, direction: face, sequence: seq }));
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.destroy_delay = 5;
|
|
}
|
|
return;
|
|
}
|
|
let facts = self.res.facts.get(state).clone();
|
|
let held = self.held().cloned();
|
|
let mut speed = self.res.items.mining_speed(held.as_ref(), &facts.name);
|
|
if self.player.as_ref().is_some_and(|p| !p.ground.on_ground) {
|
|
speed /= 5.0;
|
|
}
|
|
let harvest = !facts.requires_tool || self.res.items.correct_for_drops(held.as_ref(), &facts.name);
|
|
let progress = if facts.hardness < 0.0 {
|
|
0.0
|
|
} else if facts.hardness == 0.0 {
|
|
1.0
|
|
} else {
|
|
speed / facts.hardness / if harvest { 30.0 } else { 100.0 }
|
|
};
|
|
let same = self.remote.as_ref().and_then(|r| r.destroying).is_some_and(|(p, _, _)| p == hit.pos);
|
|
if !same {
|
|
if let Some((old, _, _)) = self.remote.as_mut().and_then(|r| r.destroying.take()) {
|
|
self.send(S::PlayerAction(play::PlayerAction { action: 2, pos: old, direction: face, sequence: 0 }));
|
|
}
|
|
let seq = self.next_sequence();
|
|
self.send(S::PlayerAction(play::PlayerAction { action: 0, pos: hit.pos, direction: face, sequence: seq }));
|
|
if progress >= 1.0 {
|
|
self.predict_break(hit.pos, state);
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.destroy_delay = 5;
|
|
}
|
|
return;
|
|
}
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.destroying = Some((hit.pos, face, 0.0));
|
|
}
|
|
self.mining = Some(Mining { pos: hit.pos, progress: 0.0, ticks: 0 });
|
|
return;
|
|
}
|
|
let Some((pos, last_face, done)) = self.remote.as_ref().and_then(|r| r.destroying) else { return };
|
|
let done = done + progress;
|
|
let ticks = self.mining.as_ref().map_or(0, |m| m.ticks) + 1;
|
|
if ticks % 4 == 1 {
|
|
let c = [f64::from(pos[0]) + 0.5, f64::from(pos[1]) + 0.5, f64::from(pos[2]) + 0.5];
|
|
self.audio.play(&facts.sounds.hit, Some(c), (facts.sounds.volume + 1.0) / 8.0, facts.sounds.pitch * 0.5);
|
|
}
|
|
self.crack_particle(pos, hit.face, state);
|
|
if done >= 1.0 {
|
|
let seq = self.next_sequence();
|
|
self.predict_break(pos, state);
|
|
self.send(S::PlayerAction(play::PlayerAction { action: 3, pos, direction: face, sequence: seq }));
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.destroying = None;
|
|
r.destroy_delay = 5;
|
|
}
|
|
self.mining = None;
|
|
} else {
|
|
if last_face != face {
|
|
self.send(S::PlayerAction(play::PlayerAction { action: 1, pos, direction: face, sequence: 0 }));
|
|
}
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.destroying = Some((pos, face, done));
|
|
}
|
|
self.mining = Some(Mining { pos, progress: done, ticks });
|
|
}
|
|
}
|
|
/// MultiPlayerGameMode.destroyBlock: the predicted break.
|
|
fn predict_break(&mut self, pos: [i32; 3], state: BlockStateId) {
|
|
let s = self.res.facts.get(state).sounds.clone();
|
|
let at = [f64::from(pos[0]) + 0.5, f64::from(pos[1]) + 0.5, f64::from(pos[2]) + 0.5];
|
|
self.audio.play(&s.break_sound, Some(at), (s.volume + 1.0) / 2.0, s.pitch * 0.8);
|
|
self.destroy_particles(pos, state);
|
|
// The server's block update follows (waterlogged blocks leave water).
|
|
let air = self.world.air;
|
|
if self.world.set(pos[0], pos[1], pos[2], air).is_ok() {
|
|
self.world.block_entities.remove(&(pos[0], pos[1], pos[2]));
|
|
}
|
|
self.mining = None;
|
|
}
|
|
/// Minecraft.startUseItem: use on the targeted block, then the item itself.
|
|
fn remote_use(&mut self) {
|
|
let held_block = self.held().and_then(|h| self.res.items.get(&h.item)).is_some_and(|i| i.block.is_some());
|
|
let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
|
|
// Entities first (interact), like the hit result order.
|
|
if let Some((i, _)) = self.mob_hit() {
|
|
let id = self.mobs[i].id as i32;
|
|
self.send(S::Interact(play::Interact { id, hand: 0, location: [0.0, 1.0, 0.0], secondary: sneaking }));
|
|
self.swing_arm();
|
|
return;
|
|
}
|
|
if let Some(hit) = self.pick() {
|
|
let seq = self.next_sequence();
|
|
let cursor = [
|
|
(hit.point[0] - f64::from(hit.pos[0])) as f32,
|
|
(hit.point[1] - f64::from(hit.pos[1])) as f32,
|
|
(hit.point[2] - f64::from(hit.pos[2])) as f32,
|
|
];
|
|
self.send(S::UseItemOn(play::UseItemOn {
|
|
hand: 0,
|
|
pos: hit.pos,
|
|
face: i32::from(face_direction(hit.face)),
|
|
cursor,
|
|
inside: hit.face == [0; 3],
|
|
world_border: false,
|
|
sequence: seq,
|
|
}));
|
|
let target = [hit.pos[0] + hit.face[0], hit.pos[1] + hit.face[1], hit.pos[2] + hit.face[2]];
|
|
let ticks = self.ticks;
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.use_target = Some(hit.pos);
|
|
r.placing = Some((target, ticks));
|
|
}
|
|
if held_block {
|
|
self.swing_arm();
|
|
return;
|
|
}
|
|
}
|
|
if self.held().is_some() {
|
|
let seq = self.next_sequence();
|
|
self.send(S::UseItem(play::UseItem { hand: 0, sequence: seq, yaw: self.yaw, pitch: self.pitch }));
|
|
}
|
|
}
|
|
/// Left click: attack the targeted entity (MultiPlayerGameMode.attack).
|
|
pub(super) fn remote_mouse(&mut self, button: MouseButton, pressed: bool) -> Result<()> {
|
|
if self.remote.as_ref().is_some_and(|r| r.chat_input.is_some()) {
|
|
return Ok(());
|
|
}
|
|
match button {
|
|
MouseButton::Left => {
|
|
if pressed && let Some((i, _)) = self.mob_hit() {
|
|
let id = self.mobs[i].id as i32;
|
|
self.send(S::Attack(play::Attack { id }));
|
|
self.send(S::Punch(Empty));
|
|
self.swing_arm();
|
|
return Ok(());
|
|
}
|
|
if pressed && self.pick().is_none() {
|
|
self.send(S::Punch(Empty));
|
|
self.swing_arm();
|
|
}
|
|
self.left = pressed;
|
|
}
|
|
MouseButton::Right => {
|
|
self.right = pressed;
|
|
if pressed {
|
|
self.remote_use();
|
|
self.use_delay = 4;
|
|
} else {
|
|
self.send(S::PlayerAction(play::PlayerAction { action: 6, pos: [0; 3], direction: 0, sequence: 0 }));
|
|
}
|
|
}
|
|
MouseButton::Middle if pressed => {
|
|
if let Some(hit) = self.pick() {
|
|
self.send(S::PickItemFromBlock(play::PickItemFromBlock { pos: hit.pos, include_data: false }));
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
Ok(())
|
|
}
|
|
/// Keys with a multiplayer meaning; returns true when consumed.
|
|
pub(super) fn remote_key(&mut self, key: KeyCode) -> Result<bool> {
|
|
if self.screen != Screen::Playing {
|
|
if key == KeyCode::KeyE && self.screen == Screen::Inventory || key == KeyCode::Escape && self.screen == Screen::Inventory {
|
|
self.remote_close_container();
|
|
self.screen = Screen::Playing;
|
|
self.capture(true);
|
|
return Ok(true);
|
|
}
|
|
return Ok(false);
|
|
}
|
|
match key {
|
|
KeyCode::KeyT | KeyCode::Slash | KeyCode::Enter => {
|
|
let text = if key == KeyCode::Slash { "/" } else { "" };
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.chat_input = Some(text.to_owned());
|
|
}
|
|
self.keys.clear();
|
|
self.left = false;
|
|
self.right = false;
|
|
self.capture(false);
|
|
Ok(true)
|
|
}
|
|
KeyCode::KeyQ => {
|
|
let all = self.keys.contains(&KeyCode::ControlLeft);
|
|
self.send(S::PlayerAction(play::PlayerAction { action: if all { 4 } else { 5 }, pos: [0; 3], direction: 0, sequence: 0 }));
|
|
// Inventory.removeFromSelected (prediction).
|
|
let slot = &mut self.inventory[self.selected];
|
|
if let Some(s) = slot {
|
|
if all || s.count <= 1 {
|
|
*slot = None;
|
|
} else {
|
|
s.count -= 1;
|
|
}
|
|
}
|
|
self.swing_arm();
|
|
Ok(true)
|
|
}
|
|
KeyCode::KeyE => {
|
|
// The inventory opens without telling the server.
|
|
self.screen = if self.creative { Screen::Creative } else { Screen::Inventory };
|
|
self.craft_size = 2;
|
|
self.capture(false);
|
|
Ok(true)
|
|
}
|
|
_ => Ok(false),
|
|
}
|
|
}
|
|
pub(super) fn remote_chat_open(&self) -> bool {
|
|
self.remote.as_ref().is_some_and(|r| r.chat_input.is_some())
|
|
}
|
|
/// ChatScreen: typing, Enter to send, Escape to cancel.
|
|
pub(super) fn remote_chat_key(&mut self, event: &winit::event::KeyEvent) {
|
|
use winit::keyboard::{Key, NamedKey};
|
|
if event.state != winit::event::ElementState::Pressed {
|
|
return;
|
|
}
|
|
let Some(r) = self.remote.as_mut() else { return };
|
|
let Some(input) = r.chat_input.as_mut() else { return };
|
|
// Logical keys: the text, not the scancode, decides (layouts, virtual keyboards).
|
|
match &event.logical_key {
|
|
Key::Named(NamedKey::Escape) => {
|
|
r.chat_input = None;
|
|
self.capture(true);
|
|
}
|
|
Key::Named(NamedKey::Backspace) => {
|
|
input.pop();
|
|
}
|
|
Key::Named(NamedKey::Enter) => {
|
|
let message = r.chat_input.take().unwrap_or_default();
|
|
self.send_chat(&message);
|
|
self.capture(true);
|
|
}
|
|
_ => {
|
|
if let Some(text) = &event.text {
|
|
for c in text.chars().filter(|c| !c.is_control()) {
|
|
if input.chars().count() < 256 {
|
|
input.push(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// ClientPacketListener.sendChat / sendCommand (unsigned).
|
|
pub(super) fn send_chat(&mut self, message: &str) {
|
|
let message = message.trim();
|
|
if message.is_empty() {
|
|
return;
|
|
}
|
|
if let Some(command) = message.strip_prefix('/') {
|
|
self.send(S::ChatCommand(play::ChatCommand { command: command.to_owned() }));
|
|
} else {
|
|
let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.as_millis() as i64);
|
|
self.send(S::Chat(play::Chat {
|
|
message: message.chars().take(256).collect(),
|
|
timestamp,
|
|
salt: 0,
|
|
signature: None,
|
|
last_seen: play::LastSeenUpdate { offset: 0, acknowledged: [0; 3], checksum: 0 },
|
|
}));
|
|
}
|
|
}
|
|
/// A container click: the server answers with the authoritative slots.
|
|
pub(super) fn remote_click(&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 Some(internal) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else { return };
|
|
let (container, menu) = match self.remote.as_ref().and_then(|r| r.menu.clone()) {
|
|
Some((id, name)) => (id, name),
|
|
None => (0, "inventory".to_owned()),
|
|
};
|
|
let slot = (0..64).find(|&s| Self::menu_slot(&menu, s) == Some(internal));
|
|
let Some(slot) = slot else { return };
|
|
let shift = self.keys.contains(&KeyCode::ShiftLeft) || self.keys.contains(&KeyCode::ShiftRight);
|
|
let carried = self.to_network(&self.carried).map(|s| Hashed::of(&s));
|
|
let state = self.remote.as_ref().map_or(0, |r| r.state_id);
|
|
self.send(S::ContainerClick(play::ContainerClick {
|
|
container,
|
|
state,
|
|
slot: slot as i16,
|
|
button: i8::from(right),
|
|
input: if shift { 1 } else { 0 },
|
|
changed: Vec::new(),
|
|
carried,
|
|
}));
|
|
}
|
|
pub(super) fn remote_close_container(&mut self) {
|
|
let id = self.remote.as_ref().and_then(|r| r.menu.as_ref().map(|m| m.0)).unwrap_or(0);
|
|
self.send(S::ContainerClose(play::ContainerClose { container: id }));
|
|
self.remote_close_local();
|
|
}
|
|
fn remote_close_local(&mut self) {
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.menu = None;
|
|
}
|
|
self.craft_size = 2;
|
|
if let Some(key) = self.container.take() {
|
|
// Server containers stay renderable but lose their copied slots.
|
|
if let Some(entity) = self.world.block_entities.get_mut(&key) {
|
|
for s in entity.slots_mut() {
|
|
*s = None;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// ClientboundOpenScreenPacket for the menus Horizon draws.
|
|
fn remote_open_screen(&mut self, p: play::OpenScreen) {
|
|
let menu = self.remote.as_ref().and_then(|r| r.builtin.get("minecraft:menu")?.name(p.menu).map(str::to_owned)).unwrap_or_default();
|
|
let target = self.remote.as_ref().and_then(|r| r.use_target).map(|t| (t[0], t[1], t[2]));
|
|
let entity = match menu.as_str() {
|
|
"minecraft:crafting" => None,
|
|
"minecraft:furnace" | "minecraft:blast_furnace" | "minecraft:smoker" => {
|
|
let kind = match menu.as_str() {
|
|
"minecraft:blast_furnace" => FurnaceKind::BlastFurnace,
|
|
"minecraft:smoker" => FurnaceKind::Smoker,
|
|
_ => FurnaceKind::Furnace,
|
|
};
|
|
Some(BlockEntity::Furnace(Furnace {
|
|
kind,
|
|
items: [None, None, None],
|
|
lit_remaining: 0,
|
|
lit_total: 0,
|
|
cooking_timer: 0,
|
|
cooking_total: 0,
|
|
speed: 1.0,
|
|
}))
|
|
}
|
|
m if m.starts_with("minecraft:generic_9x") || m == "minecraft:shulker_box" => {
|
|
let rows = m.strip_prefix("minecraft:generic_9x").and_then(|r| r.parse::<usize>().ok()).unwrap_or(3);
|
|
Some(BlockEntity::Chest(vec![None; rows * 9]))
|
|
}
|
|
_ => {
|
|
// Unsupported menu: tell the server we closed it.
|
|
self.send(S::ContainerClose(play::ContainerClose { container: p.container }));
|
|
self.chat_line(format!("(Horizon cannot show {menu} screens yet)"));
|
|
return;
|
|
}
|
|
};
|
|
if let Some(r) = self.remote.as_mut() {
|
|
r.menu = Some((p.container, menu.clone()));
|
|
}
|
|
self.craft_size = if menu == "minecraft:crafting" { 3 } else { 2 };
|
|
self.container = None;
|
|
if let Some(entity) = entity {
|
|
let key = target.unwrap_or((i32::MIN, 0, 0));
|
|
self.world.block_entities.insert(key, entity);
|
|
self.container = Some(key);
|
|
}
|
|
self.screen = Screen::Inventory;
|
|
self.capture(false);
|
|
}
|
|
pub(super) fn remote_respawn(&mut self) {
|
|
self.send(S::ClientCommand(play::ClientCommand { action: 0 }));
|
|
}
|
|
|
|
/// Connecting / loading screens; true when it covered the frame.
|
|
pub(super) fn remote_overlay(&self, batch: &mut HudBatch) -> bool {
|
|
let Some(r) = &self.remote else { return false };
|
|
if self.player.is_some() {
|
|
return false;
|
|
}
|
|
let atlas = &self.res.atlas;
|
|
let (w, h) = (batch.width, batch.height);
|
|
batch.fill(atlas, 0.0, 0.0, w, h, rgba(20, 20, 20, 255));
|
|
for (i, line) in [r.status.as_str(), r.session.address.as_str()].iter().enumerate() {
|
|
let tw = HudBatch::text_width(atlas, line);
|
|
batch.text(atlas, line, (w - tw) / 2.0, h / 2.0 - 12.0 + i as f32 * 12.0, if i == 0 { u32::MAX } else { rgba(160, 160, 160, 255) }, true);
|
|
}
|
|
let _ = r.joined;
|
|
true
|
|
}
|
|
/// Chat (ChatComponent), the chat input line and the action bar.
|
|
pub(super) fn remote_hud(&self, batch: &mut HudBatch) {
|
|
let Some(r) = &self.remote else { return };
|
|
let atlas = &self.res.atlas;
|
|
let (w, h) = (batch.width, batch.height);
|
|
let open = r.chat_input.is_some();
|
|
let now = Instant::now();
|
|
let mut y = h - 48.0;
|
|
// Container screens cover the chat (vanilla draws them over the HUD).
|
|
let shown = if matches!(self.screen, Screen::Playing | Screen::Dead) { if open { 20 } else { 10 } } else { 0 };
|
|
for (text, at) in r.chat.iter().rev().take(shown) {
|
|
let age = now.duration_since(*at);
|
|
// Lines fade out after ten seconds unless the chat is open.
|
|
let alpha = if open { 1.0 } else { (1.0 - (age.as_secs_f32() - 9.0).max(0.0)).clamp(0.0, 1.0) };
|
|
if alpha <= 0.0 {
|
|
break;
|
|
}
|
|
let a = (alpha * 255.0) as u8;
|
|
batch.fill(atlas, 2.0, y - 1.0, 320.0, 9.0, rgba(0, 0, 0, (alpha * 128.0) as u8));
|
|
batch.text(atlas, text, 4.0, y, rgba(255, 255, 255, a), true);
|
|
y -= 9.0;
|
|
}
|
|
if let Some(input) = &r.chat_input {
|
|
batch.fill(atlas, 2.0, h - 14.0, w - 4.0, 12.0, rgba(0, 0, 0, 128));
|
|
let blink = (self.started.elapsed().as_millis() / 300).is_multiple_of(2);
|
|
let shown = if blink { format!("{input}_") } else { input.clone() };
|
|
batch.text(atlas, &shown, 4.0, h - 12.0, rgba(224, 224, 224, 255), true);
|
|
}
|
|
if let Some((text, at)) = &r.action_bar
|
|
&& now.duration_since(*at) < Duration::from_secs(3)
|
|
{
|
|
let tw = HudBatch::text_width(atlas, text);
|
|
batch.text(atlas, text, (w - tw) / 2.0, h - 68.0, u32::MAX, true);
|
|
}
|
|
if self.screen == Screen::Dead
|
|
&& let Some(message) = &r.death_message
|
|
{
|
|
let tw = HudBatch::text_width(atlas, message);
|
|
batch.text(atlas, message, (w - tw) / 2.0, 85.0, u32::MAX, true);
|
|
}
|
|
}
|
|
/// Status for `horizon-ctl status`.
|
|
pub(super) fn remote_status(&self) -> Option<serde_json::Value> {
|
|
let r = self.remote.as_ref()?;
|
|
Some(serde_json::json!({
|
|
"address": r.session.address,
|
|
"name": r.session.name,
|
|
"joined": r.joined,
|
|
"status": r.status,
|
|
"entity_id": r.entity_id,
|
|
"dimension": r.dimension.name,
|
|
"game_mode": r.game_mode,
|
|
"chunks": self.world.chunks.len(),
|
|
"entities": r.entities.values().fold(std::collections::BTreeMap::<&str, u32>::new(), |mut m, t| {
|
|
*m.entry(t.kind.as_str()).or_default() += 1;
|
|
m
|
|
}),
|
|
"players": r.players.values().collect::<Vec<_>>(),
|
|
"health": r.health.0,
|
|
"food": r.health.1,
|
|
"decode_errors": r.decode_errors,
|
|
"chat": r.chat.iter().rev().take(10).rev().map(|(t, _)| t.clone()).collect::<Vec<_>>(),
|
|
}))
|
|
}
|
|
}
|