Merge main into the mobs work

Merged local main into the mobs branch. Conflicts were in the mob event
enum (kept both LeashBreak and CureZombieVillager), the LAN and leads
module lists (kept all), horse NBT (chests are written for llamas,
donkeys and mules, with llama data kept), and chunk saving, which now
goes through mob_tree_nbt (main's passenger trees) with write_leash
applied inside it so leashes are still saved.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-10 07:25:16 +02:00
54 changed files with 10685 additions and 312 deletions
+137
View File
@@ -0,0 +1,137 @@
//! Serve a small flat world on the LAN server without the game, for joining
//! with a real client while developing the protocol:
//! `cargo run --release --example lan_flat -- RESOURCES PORT`.
use horizon_client::{
assets::Assets,
blocks::BlockFacts,
chunk::{Chunk, MIN_Y},
lan::{
Lan,
chunks::ChunkEncoder,
data::SyncData,
hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
},
world::World,
};
use horizon_protocol::packets::play::Serverbound as S;
use std::{path::PathBuf, sync::Arc, time::Duration};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut args = std::env::args().skip(1);
let root = PathBuf::from(args.next().ok_or("RESOURCES PORT")?);
let port: u16 = args.next().ok_or("port")?.parse()?;
let assets = Assets::load(&root)?;
let facts = BlockFacts::load(&root, assets.registry)?;
let state = |name: &str| {
assets
.registry
.default_state(name)
.map_or(0, |s| s.0 as u16)
};
let sync = Arc::new(SyncData::load(&root)?);
let biomes: Vec<String> = sync
.dynamic
.registries
.get("minecraft:worldgen/biome")
.map(|v| v.iter().map(|(n, _)| n.clone()).collect())
.unwrap_or_default();
let encoder = ChunkEncoder::new(
facts
.states
.iter()
.map(|s| (s.name.clone(), s.fluid_level > 0 || s.waterlogged)),
&sync.builtin,
&biomes,
&biomes,
);
let (stone, dirt, grass) = (
state("minecraft:stone"),
state("minecraft:dirt"),
state("minecraft:grass_block"),
);
let mut world = World::new(facts.air, 0);
for cz in -8..=8 {
for cx in -8..=8 {
let mut chunk = Chunk::empty(cx, cz);
for z in 0..16 {
for x in 0..16 {
for y in MIN_Y..60 {
let v = if y == 59 {
grass
} else if y > 55 {
dirt
} else {
stone
};
chunk.set(x, y, z, v);
}
}
}
chunk.lit = true;
world.chunks.insert((cx, cz), Arc::new(chunk));
}
}
let lan = Lan::start(sync.clone(), port, "Flat - Example".into(), 8)?;
println!("listening on {}", lan.port);
let mut hub = Hub::new(
lan,
sync,
encoder,
HubConfig {
default_game_mode: 1,
guest_commands: true,
force_game_mode: false,
hardcore: false,
view_distance: 8,
simulation_distance: 8,
dimension: "minecraft:overworld".into(),
seed: 0,
max_players: 8,
},
);
let mut next_entity = 100u32;
let host = HostState {
uuid: 42,
name: "Host".into(),
entity_id: 1,
position: [0.5, 60.0, 0.5],
yaw: 0.0,
pitch: 0.0,
head_yaw: 0.0,
on_ground: true,
game_mode: 1,
sneaking: false,
sprinting: false,
equipment: Default::default(),
health: 20.0,
};
loop {
world.game_time += 1;
world.day_time += 1;
let mut ctx = TickCtx {
world: &mut world,
host: &host,
entities: &[],
next_entity: &mut next_entity,
spawn: [8.5, 60.0, 8.5],
difficulty: 2,
difficulty_locked: false,
clock_rate: 1.0,
};
for event in hub.tick(&mut ctx) {
match event {
HostEvent::Joined(conn) => hub.place_new_player(conn, &mut ctx),
HostEvent::Packet(_, packet) => {
if std::env::var_os("HORIZON_NET_DEBUG").is_some()
&& !matches!(*packet, S::ClientTickEnd(_))
{
eprintln!("[lan] {packet:?}");
}
}
HostEvent::Chat(line) => println!("{line}"),
HostEvent::Left(_) => {}
}
}
std::thread::sleep(Duration::from_millis(50));
}
}
+7
View File
@@ -84,6 +84,9 @@ pub struct Audio {
next_tracked: u64,
/// A `SoundSource` index the next sound plays on (`/playsound`).
source_override: Option<usize>,
/// Positional sounds played since the last drain, kept while the world
/// is open to the network so guests hear them too.
pub capture: Option<Vec<(String, [f64; 3], f32, f32)>>,
}
fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
use symphonia::core::{
@@ -192,6 +195,7 @@ impl Audio {
music: None,
next_tracked: 0,
source_override: None,
capture: None,
}
}
fn open(mixer: Arc<Mutex<Mixer>>) -> Result<(cpal::Stream, u32)> {
@@ -309,6 +313,9 @@ impl Audio {
}
/// Play a sound event at a world position (None = non-positional UI sound).
pub fn play(&mut self, event: &str, at: Option<[f64; 3]>, volume: f32, pitch: f32) {
if let (Some(capture), Some(at)) = (self.capture.as_mut(), at) {
capture.push((event.to_owned(), at, volume, pitch));
}
let Some(variant) = self.resolve(event, 0) else {
return;
};
@@ -0,0 +1,962 @@
//! Vanilla 26.3 block entity NBT for every block entity type.
//!
//! [`canonical`] is `loadAdditional` followed by `saveWithFullMetadata` for each of
//! the 47 `BlockEntityType`s: it reads the fields the type reads (with vanilla's
//! defaults and clamps), drops everything else and writes the fields `saveAdditional`
//! writes (including its omit-when-empty rules). Nested codec values that Horizon does
//! not simulate (spawner entity data, vibration listeners, trial spawner configuration,
//! vault data, sculk cursors, sign and banner components, profiles) are carried as
//! loaded. The common `BaseContainerBlockEntity` fields (`CustomName`, `lock`) and the
//! `RandomizableContainer` loot table fields are handled for every container type.
//!
//! [`overlay`] merges a block entity Horizon models (and re-encodes from its own,
//! partial state) with the NBT it was loaded from, so fields Horizon does not model
//! survive and only what the game changed is replaced.
use horizon_world::nbt::{Compound, Tag};
fn string(s: &str) -> Tag {
Tag::String(s.into())
}
fn text(tag: Option<&Tag>) -> Option<String> {
match tag {
Some(Tag::String(s)) => Some(s.to_string_lossy()),
_ => None,
}
}
/// `CompoundTag.getIntOr`: any numeric tag (floats floor).
fn int(tag: Option<&Tag>) -> Option<i32> {
Some(match tag? {
Tag::Byte(v) => i32::from(*v),
Tag::Short(v) => i32::from(*v),
Tag::Int(v) => *v,
Tag::Long(v) => *v as i32,
Tag::Float(b) => f32::from_bits(*b).floor() as i32,
Tag::Double(b) => f64::from_bits(*b).floor() as i32,
_ => return None,
})
}
fn long(tag: Option<&Tag>) -> Option<i64> {
Some(match tag? {
Tag::Long(v) => *v,
Tag::Float(b) => f32::from_bits(*b).floor() as i64,
Tag::Double(b) => f64::from_bits(*b).floor() as i64,
other => i64::from(int(Some(other))?),
})
}
fn float(tag: Option<&Tag>) -> Option<f32> {
Some(match tag? {
Tag::Float(b) => f32::from_bits(*b),
Tag::Double(b) => f64::from_bits(*b) as f32,
Tag::Long(v) => *v as f32,
other => int(Some(other))? as f32,
})
}
fn flag(tag: Option<&Tag>) -> Option<bool> {
Some(int(tag)? != 0)
}
fn boolean(v: bool) -> Tag {
Tag::Byte(i8::from(v))
}
fn f32_tag(v: f32) -> Tag {
Tag::Float(v.to_bits())
}
/// What a block entity reads and writes, in `saveAdditional` order.
struct Fields<'a> {
input: &'a Tag,
out: Compound,
}
impl<'a> Fields<'a> {
fn put(&mut self, key: &str, value: Tag) {
self.out.insert(key.into(), value);
}
fn int(&mut self, key: &str, default: i32) {
let v = int(self.input.get(key)).unwrap_or(default);
self.put(key, Tag::Int(v));
}
fn int_clamped(&mut self, key: &str, default: i32, min: i32, max: i32) {
let v = int(self.input.get(key)).unwrap_or(default).clamp(min, max);
self.put(key, Tag::Int(v));
}
fn short(&mut self, key: &str, default: i16) {
let v = int(self.input.get(key)).map_or(default, |v| v as i16);
self.put(key, Tag::Short(v));
}
fn long(&mut self, key: &str, default: i64) {
let v = long(self.input.get(key)).unwrap_or(default);
self.put(key, Tag::Long(v));
}
fn float(&mut self, key: &str, default: f32) {
let v = float(self.input.get(key)).unwrap_or(default);
self.put(key, f32_tag(v));
}
fn flag(&mut self, key: &str, default: bool) {
let v = flag(self.input.get(key)).unwrap_or(default);
self.put(key, boolean(v));
}
fn string(&mut self, key: &str, default: &str) {
let v = text(self.input.get(key)).unwrap_or_else(|| default.to_owned());
self.put(key, string(&v));
}
/// An optional value written as loaded, when it has the expected shape.
fn keep(&mut self, key: &str, valid: impl Fn(&Tag) -> bool) {
if let Some(t) = self.input.get(key).filter(|t| valid(t)) {
self.put(key, t.clone());
}
}
fn keep_compound(&mut self, key: &str) {
self.keep(key, |t| matches!(t, Tag::Compound(_)));
}
/// A compound that is always written (`default` when absent).
fn compound_or(&mut self, key: &str, default: Compound) {
let v = match self.input.get(key) {
Some(Tag::Compound(c)) => c.clone(),
_ => default,
};
self.put(key, Tag::Compound(v));
}
/// An optional text component (`storeNullable("CustomName", ComponentSerialization.CODEC)`).
fn component(&mut self, key: &str) {
if let Some(c) = self.input.get(key).and_then(component) {
self.put(key, c);
}
}
/// `LockCode.addToTag`.
fn lock(&mut self) {
self.keep_compound("lock");
}
/// `BaseContainerBlockEntity`: the custom name and the lock.
fn base_container(&mut self) {
self.component("CustomName");
self.lock();
}
/// `RandomizableContainer.tryLoadLootTable` / `trySaveLootTable`; true when the
/// block entity has a loot table (and so saves no items).
fn loot_table(&mut self) -> bool {
let Some(table) = text(self.input.get("LootTable")) else {
return false;
};
self.put("LootTable", string(&table));
let seed = long(self.input.get("LootTableSeed")).unwrap_or(0);
if seed != 0 {
self.put("LootTableSeed", Tag::Long(seed));
}
true
}
/// `ContainerHelper.loadAllItems` + `saveAllItems`.
fn items(&mut self, size: usize, also_when_empty: bool) {
let items = items(self.input.get("Items"), size);
if !items.is_empty() || also_when_empty {
self.put("Items", Tag::List(items));
}
}
/// A container: loot table or items.
fn container(&mut self, size: usize, also_when_empty: bool) {
if !self.loot_table() {
self.items(size, also_when_empty);
}
}
/// An optional `ItemStack` (`RecordItem`, `Book`, `item`).
fn item(&mut self, key: &str) -> bool {
match self.input.get(key).and_then(stack) {
Some(item) => {
self.put(key, item);
true
}
None => false,
}
}
}
/// `ComponentSerialization.CODEC` on loaded NBT: a literal without style is a plain
/// string; anything else is kept as loaded.
pub fn component(tag: &Tag) -> Option<Tag> {
match tag {
Tag::String(_) | Tag::List(_) => Some(tag.clone()),
Tag::Compound(c) => {
if c.len() == 1
&& let Some(t @ Tag::String(_)) = c.get(&"text".into())
{
return Some(t.clone());
}
Some(tag.clone())
}
_ => None,
}
}
/// `ItemStack.CODEC`: `id`, `count` (1..=99, default 1) and a non-empty `components`
/// patch kept as loaded. None for the empty stack and for invalid stacks.
pub fn stack(tag: &Tag) -> Option<Tag> {
let id = text(tag.get("id"))?;
if id.is_empty() || id == "minecraft:air" {
return None;
}
let count = int(tag.get("count")).unwrap_or(1);
if !(1..=99).contains(&count) {
return None;
}
let mut out = vec![("id", string(&id)), ("count", Tag::Int(count))];
if let Some(c @ Tag::Compound(map)) = tag.get("components")
&& !map.is_empty()
{
out.push(("components", c.clone()));
}
Some(Tag::compound(out))
}
/// `ItemStackTemplate.CODEC`: an item id or `{id, count?, components?}`.
fn template(tag: &Tag) -> Option<Tag> {
match tag {
Tag::String(_) => Some(tag.clone()),
Tag::Compound(_) => {
let mut out = vec![("id", string(&text(tag.get("id"))?))];
if let Some(count) = int(tag.get("count")).filter(|c| *c != 1) {
out.push(("count", Tag::Int(count)));
}
if let Some(c @ Tag::Compound(map)) = tag.get("components")
&& !map.is_empty()
{
out.push(("components", c.clone()));
}
Some(Tag::compound(out))
}
_ => None,
}
}
/// `ItemStackWithSlot` entries of a container of `size` slots, by ascending slot.
fn items(tag: Option<&Tag>, size: usize) -> Vec<Tag> {
let mut slots: Vec<Option<Tag>> = vec![None; size];
if let Some(Tag::List(list)) = tag {
for entry in list {
let (Some(slot), Some(item)) = (int(entry.get("Slot")), stack(entry)) else {
continue;
};
if (0..size as i32).contains(&slot) {
slots[slot as usize] = Some(item);
}
}
}
slots
.into_iter()
.enumerate()
.filter_map(|(i, item)| {
let Tag::Compound(mut c) = item? else {
return None;
};
c.insert("Slot".into(), Tag::Byte(i as i8));
Some(Tag::Compound(c))
})
.collect()
}
fn int_array(tag: Option<&Tag>) -> Option<&Vec<i32>> {
match tag {
Some(Tag::IntArray(v)) => Some(v),
_ => None,
}
}
/// A saved `BlockPos` (`[I; x, y, z]`).
fn is_pos(tag: &Tag) -> bool {
matches!(tag, Tag::IntArray(v) if v.len() == 3)
}
/// The loaded `SignText` of one side, or the empty text.
fn sign_side(tag: Option<&Tag>) -> Tag {
let empty = || string("");
let mut messages: Vec<Tag> = match tag.and_then(|t| t.get("messages")) {
Some(Tag::List(list)) => list.iter().filter_map(component).collect(),
_ => Vec::new(),
};
messages.resize_with(4, empty);
messages.truncate(4);
let mut out = vec![
("messages", Tag::List(messages)),
(
"color",
string(
&tag.and_then(|t| text(t.get("color")))
.unwrap_or_else(|| "black".into()),
),
),
(
"has_glowing_text",
boolean(
tag.and_then(|t| flag(t.get("has_glowing_text")))
.unwrap_or(false),
),
),
];
if let Some(filtered @ Tag::List(list)) = tag.and_then(|t| t.get("filtered_messages"))
&& list.len() == 4
{
out.push(("filtered_messages", filtered.clone()));
}
Tag::compound(out)
}
/// The id of a block entity compound.
pub fn id(tag: &Tag) -> Option<String> {
text(tag.get("id"))
}
/// Every `BlockEntityType` id this module knows.
pub const TYPES: [&str; 47] = [
"minecraft:furnace",
"minecraft:chest",
"minecraft:trapped_chest",
"minecraft:ender_chest",
"minecraft:jukebox",
"minecraft:dispenser",
"minecraft:dropper",
"minecraft:sign",
"minecraft:hanging_sign",
"minecraft:mob_spawner",
"minecraft:creaking_heart",
"minecraft:piston",
"minecraft:brewing_stand",
"minecraft:enchanting_table",
"minecraft:end_portal",
"minecraft:beacon",
"minecraft:skull",
"minecraft:daylight_detector",
"minecraft:hopper",
"minecraft:comparator",
"minecraft:banner",
"minecraft:structure_block",
"minecraft:end_gateway",
"minecraft:command_block",
"minecraft:shulker_box",
"minecraft:conduit",
"minecraft:barrel",
"minecraft:smoker",
"minecraft:blast_furnace",
"minecraft:lectern",
"minecraft:bell",
"minecraft:jigsaw",
"minecraft:campfire",
"minecraft:beehive",
"minecraft:sculk_sensor",
"minecraft:calibrated_sculk_sensor",
"minecraft:sculk_catalyst",
"minecraft:sculk_shrieker",
"minecraft:chiseled_bookshelf",
"minecraft:shelf",
"minecraft:brushable_block",
"minecraft:decorated_pot",
"minecraft:crafter",
"minecraft:trial_spawner",
"minecraft:vault",
"minecraft:test_block",
"minecraft:test_instance_block",
];
/// The two types added after the ones above in 26.3.
pub const NEWEST: [&str; 2] = ["minecraft:copper_golem_statue", "minecraft:potent_sulfur"];
/// The block entity as vanilla would save it after loading `tag` (a full block
/// entity compound with `id`, `x`, `y`, `z`); None for an unknown type or a tag
/// without a position.
pub fn canonical(tag: &Tag) -> Option<Tag> {
let id = id(tag)?;
let (x, y, z) = (int(tag.get("x"))?, int(tag.get("y"))?, int(tag.get("z"))?);
let mut f = Fields {
input: tag,
out: Compound::new(),
};
match id.as_str() {
"minecraft:furnace" | "minecraft:smoker" | "minecraft:blast_furnace" => {
f.base_container();
f.int("cooking_time_spent", 0);
f.int("cooking_total_time", 0);
f.int("lit_time_remaining", 0);
f.int("lit_total_time", 0);
f.float("speed_multiplier", 1.0);
f.items(3, true);
let used: Compound = match tag.get("RecipesUsed") {
Some(Tag::Compound(c)) => c
.iter()
.filter_map(|(k, v)| Some((k.clone(), Tag::Int(int(Some(v))?))))
.collect(),
_ => Compound::new(),
};
f.put("RecipesUsed", Tag::Compound(used));
}
"minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => {
f.base_container();
f.container(27, true);
}
"minecraft:dispenser" | "minecraft:dropper" => {
f.base_container();
f.container(9, true);
}
"minecraft:hopper" => {
f.base_container();
f.container(5, true);
f.int("TransferCooldown", -1);
}
"minecraft:shulker_box" => {
f.base_container();
f.container(27, false);
}
"minecraft:crafter" => {
f.base_container();
f.int("crafting_ticks_remaining", 0);
f.container(9, true);
let disabled: Vec<i32> = int_array(tag.get("disabled_slots"))
.map(|v| v.iter().copied().filter(|s| (0..9).contains(s)).collect())
.unwrap_or_default();
// `addDisabledSlots`: the slots whose container data is 1, ascending.
let mut slots = disabled;
slots.sort_unstable();
slots.dedup();
f.put("disabled_slots", Tag::IntArray(slots));
f.put(
"triggered",
Tag::Int(int(tag.get("triggered")).unwrap_or(0)),
);
}
"minecraft:ender_chest"
| "minecraft:end_portal"
| "minecraft:daylight_detector"
| "minecraft:bell"
| "minecraft:conduit"
| "minecraft:copper_golem_statue" => {
if id == "minecraft:conduit" {
f.keep("Target", |t| matches!(t, Tag::IntArray(v) if v.len() == 4));
}
}
"minecraft:end_gateway" => {
f.long("Age", 0);
f.keep("exit_portal", |t| {
is_pos(t)
&& matches!(t, Tag::IntArray(v) if v[1].abs() <= 30_000_000 && v[0].abs() <= 30_000_000 && v[2].abs() <= 30_000_000)
});
if flag(tag.get("ExactTeleport")) == Some(true) {
f.put("ExactTeleport", boolean(true));
}
}
"minecraft:jukebox" => {
let has_song = f.item("RecordItem");
if has_song
&& let Some(ticks) = tag
.get("ticks_since_song_started")
.and_then(|t| long(Some(t)))
&& let Some(Tag::Compound(c)) = f.out.get(&"RecordItem".into())
&& is_record(c)
{
f.put("ticks_since_song_started", Tag::Long(ticks));
}
}
"minecraft:sign" | "minecraft:hanging_sign" => {
if flag(tag.get("allow_op_features")) == Some(true) {
f.put("allow_op_features", boolean(true));
}
f.put("front_text", sign_side(tag.get("front_text")));
f.put("back_text", sign_side(tag.get("back_text")));
f.flag("is_waxed", false);
}
"minecraft:mob_spawner" => {
f.short("Delay", 20);
f.short("MinSpawnDelay", 200);
f.short("MaxSpawnDelay", 800);
f.short("SpawnCount", 4);
f.short("MaxNearbyEntities", 6);
f.short("RequiredPlayerRange", 16);
f.short("SpawnRange", 4);
f.keep_compound("SpawnData");
let potentials = match tag.get("SpawnPotentials") {
Some(t @ Tag::List(_)) => t.clone(),
_ => match f.out.get(&"SpawnData".into()) {
Some(data) => Tag::List(vec![Tag::compound([
("data", data.clone()),
("weight", Tag::Int(1)),
])]),
None => Tag::List(Vec::new()),
},
};
f.put("SpawnPotentials", potentials);
}
"minecraft:creaking_heart" => {
f.keep(
"creaking",
|t| matches!(t, Tag::IntArray(v) if v.len() == 4),
);
}
"minecraft:piston" => {
f.put(
"blockState",
match tag.get("blockState") {
Some(t @ (Tag::String(_) | Tag::Compound(_))) => t.clone(),
_ => string("minecraft:air"),
},
);
f.put("facing", Tag::Int(int(tag.get("facing")).unwrap_or(0)));
f.float("progress", 0.0);
f.flag("extending", false);
f.flag("source", false);
}
"minecraft:brewing_stand" => {
f.base_container();
f.int("BrewTime", 0);
f.int("total_brew_time", 400);
f.items(5, true);
f.int("Fuel", 0);
f.int("total_fuel", 20);
f.float("speed_multiplier", 1.0);
}
"minecraft:enchanting_table" => f.component("CustomName"),
"minecraft:beacon" => {
for key in ["primary_effect", "secondary_effect"] {
if let Some(effect) = text(tag.get(key)) {
f.put(key, string(&effect));
}
}
f.int("Levels", 0);
f.component("CustomName");
f.lock();
}
"minecraft:skull" => {
f.keep("profile", |t| {
matches!(t, Tag::Compound(_) | Tag::String(_))
});
if let Some(sound) = text(tag.get("note_block_sound")) {
f.put("note_block_sound", string(&sound));
}
f.component("custom_name");
}
"minecraft:comparator" => f.int("OutputSignal", 0),
"minecraft:banner" => {
if let Some(patterns @ Tag::List(list)) = tag.get("patterns")
&& !list.is_empty()
{
f.put("patterns", patterns.clone());
}
f.component("CustomName");
}
"minecraft:structure_block" => {
f.string("name", "");
f.string("author", "");
f.string("metadata", "");
f.int_clamped("posX", 0, -48, 48);
f.int_clamped("posY", 1, -48, 48);
f.int_clamped("posZ", 0, -48, 48);
f.int_clamped("sizeX", 0, 0, 48);
f.int_clamped("sizeY", 0, 0, 48);
f.int_clamped("sizeZ", 0, 0, 48);
f.string("rotation", "NONE");
f.string("mirror", "NONE");
f.string("mode", "DATA");
f.flag("ignoreEntities", true);
f.flag("strict", false);
f.flag("powered", false);
f.flag("showair", false);
f.flag("showboundingbox", true);
f.float("integrity", 1.0);
f.long("seed", 0);
}
"minecraft:command_block" => {
f.string("Command", "");
f.int("SuccessCount", 0);
f.component("CustomName");
let track = flag(tag.get("TrackOutput")).unwrap_or(true);
f.put("TrackOutput", boolean(track));
if track {
f.component("LastOutput");
}
let update = flag(tag.get("UpdateLastExecution")).unwrap_or(true);
f.put("UpdateLastExecution", boolean(update));
if update && let Some(last) = long(tag.get("LastExecution")).filter(|l| *l != -1) {
f.put("LastExecution", Tag::Long(last));
}
f.flag("powered", false);
f.flag("conditionMet", false);
f.flag("auto", false);
}
"minecraft:lectern" => {
if f.item("Book") {
f.int("Page", 0);
}
}
"minecraft:jigsaw" => {
f.string("name", "minecraft:empty");
f.string("target", "minecraft:empty");
f.string("pool", "minecraft:empty");
f.string("final_state", "minecraft:air");
f.string("joint", "rollable");
f.int("placement_priority", 0);
f.int("selection_priority", 0);
}
"minecraft:campfire" => {
f.items(4, true);
for key in ["CookingTimes", "CookingTotalTimes"] {
let mut times = [0; 4];
if let Some(v) = int_array(tag.get(key)) {
for (slot, t) in times.iter_mut().zip(v) {
*slot = *t;
}
}
f.put(key, Tag::IntArray(times.to_vec()));
}
}
"minecraft:beehive" => {
let bees = match tag.get("bees") {
Some(Tag::List(list)) => list
.iter()
.filter_map(|bee| {
let data = bee
.get("entity_data")
.filter(|d| matches!(d, Tag::Compound(_)))?;
Some(Tag::compound([
("entity_data", data.clone()),
("ticks_in_hive", Tag::Int(int(bee.get("ticks_in_hive"))?)),
(
"min_ticks_in_hive",
Tag::Int(int(bee.get("min_ticks_in_hive"))?),
),
]))
})
.collect(),
_ => Vec::new(),
};
f.put("bees", Tag::List(bees));
f.keep("flower_pos", is_pos);
}
"minecraft:sculk_sensor" | "minecraft:calibrated_sculk_sensor" => {
f.int("last_vibration_frequency", 0);
f.compound_or("listener", listener());
}
"minecraft:sculk_shrieker" => {
f.int("warning_level", 0);
f.compound_or("listener", listener());
}
"minecraft:sculk_catalyst" => {
let cursors = match tag.get("cursors") {
Some(t @ Tag::List(_)) => t.clone(),
_ => Tag::List(Vec::new()),
};
f.put("cursors", cursors);
}
"minecraft:chiseled_bookshelf" => {
f.items(6, true);
f.int("last_interacted_slot", -1);
}
"minecraft:shelf" => {
f.items(3, true);
f.flag("align_items_to_bottom", false);
}
"minecraft:brushable_block" => {
if !f.loot_table() {
f.item("item");
}
}
"minecraft:decorated_pot" => {
if let Some(Tag::Compound(sherds)) = tag.get("sherds") {
let kept: Compound = ["back", "left", "right", "front"]
.iter()
.filter_map(|side| {
Some(((*side).into(), template(sherds.get(&(*side).into())?)?))
})
.collect();
if !kept.is_empty() {
f.put("sherds", Tag::Compound(kept));
}
}
if !f.loot_table() {
f.item("item");
}
}
"minecraft:trial_spawner" => {
// `TrialSpawnerStateData.Packed` and `FullConfig`: every key is optional
// and defaulted by vanilla; they are kept as loaded.
if let Tag::Compound(c) = tag {
for (k, v) in c {
let key = k.to_string_lossy();
if !matches!(
key.as_str(),
"id" | "x" | "y" | "z" | "keepPacked" | "components"
) {
f.out.insert(k.clone(), v.clone());
}
}
}
if !f.out.contains_key(&"spawn_data".into()) {
f.put(
"spawn_data",
Tag::compound([("entity", Tag::Compound(Compound::new()))]),
);
}
}
"minecraft:vault" => {
// `VaultConfig.DEFAULT` (when the config is absent): the trial key and the
// default reward table, which is not saved.
f.compound_or(
"config",
[(
"key_item".into(),
Tag::compound([
("count", Tag::Int(1)),
("id", string("minecraft:trial_key")),
]),
)]
.into_iter()
.collect(),
);
f.compound_or("shared_data", Compound::new());
f.compound_or("server_data", Compound::new());
}
"minecraft:test_block" => {
f.string("mode", "fail");
f.string("message", "");
f.flag("powered", false);
}
"minecraft:test_instance_block" => {
f.compound_or(
"data",
[
("ignore_entities".into(), boolean(false)),
("rotation".into(), string("none")),
("size".into(), Tag::IntArray(vec![0, 0, 0])),
("status".into(), string("cleared")),
]
.into_iter()
.collect(),
);
if let Some(errors @ Tag::List(list)) = tag.get("errors")
&& !list.is_empty()
{
f.put("errors", errors.clone());
}
}
"minecraft:potent_sulfur" => f.int("countdown", -1),
_ => return None,
}
let mut out = f.out;
out.insert("id".into(), string(&id));
out.insert("x".into(), Tag::Int(x));
out.insert("y".into(), Tag::Int(y));
out.insert("z".into(), Tag::Int(z));
out.insert("keepPacked".into(), Tag::Byte(0));
out.insert(
"components".into(),
match tag.get("components") {
Some(c @ Tag::Compound(_)) => c.clone(),
_ => Tag::Compound(Compound::new()),
},
);
Some(Tag::Compound(out))
}
/// `VibrationSystem.Data` for a sensor with no pending vibration.
fn listener() -> Compound {
[
("event_delay".into(), Tag::Int(0)),
("selector".into(), Tag::compound([("tick", Tag::Long(-1))])),
]
.into_iter()
.collect()
}
/// Whether a stack plays a song (`JukeboxSong.fromStack`): a music disc or an item
/// with the `jukebox_playable` component.
fn is_record(item: &Compound) -> bool {
let id = match item.get(&"id".into()) {
Some(Tag::String(s)) => s.to_string_lossy(),
_ => return false,
};
id.starts_with("minecraft:music_disc_")
|| matches!(item.get(&"components".into()), Some(Tag::Compound(c)) if c.contains_key(&"minecraft:jukebox_playable".into()))
}
/// Three-way merge of a block entity: `original` is the NBT it was loaded from,
/// `loaded` what Horizon encodes right after decoding it, and `current` what Horizon
/// encodes now. Whatever the game left unchanged since loading keeps its original
/// form (including the detail Horizon does not model, such as styled text), what it
/// changed takes the current value, and keys Horizon never models stay.
pub fn overlay(original: &Tag, loaded: &Tag, current: &Tag) -> Tag {
if current == loaded {
return original.clone();
}
match (original, loaded, current) {
(Tag::Compound(o), Tag::Compound(l), Tag::Compound(c)) => {
let mut out = Compound::new();
for (key, cv) in c {
let value = match (o.get(key), l.get(key)) {
(Some(ov), Some(lv)) => overlay(ov, lv, cv),
_ => cv.clone(),
};
out.insert(key.clone(), value);
}
// Keys the game never models (or models only when present) survive;
// keys it removed are gone.
for (key, ov) in o {
if !c.contains_key(key) && !l.contains_key(key) {
out.insert(key.clone(), ov.clone());
}
}
Tag::Compound(out)
}
(Tag::List(o), Tag::List(l), Tag::List(c)) if keyed_by_slot(c) && keyed_by_slot(l) => {
let slot = |t: &Tag| int(t.get("Slot"));
Tag::List(
c.iter()
.map(|cv| {
let s = slot(cv);
fn find(list: &[Tag], slot: Option<i32>) -> Option<&Tag> {
list.iter().find(|t| int(t.get("Slot")) == slot)
}
match (find(o, s), find(l, s)) {
(Some(ov), Some(lv)) => overlay(ov, lv, cv),
_ => cv.clone(),
}
})
.collect(),
)
}
_ => current.clone(),
}
}
fn keyed_by_slot(list: &[Tag]) -> bool {
list.iter().all(|t| t.get("Slot").is_some())
}
#[cfg(test)]
mod tests {
use super::*;
use horizon_world::nbt::parse_snbt;
fn snbt(s: &str) -> Tag {
parse_snbt(s).expect("snbt").0
}
fn canon(s: &str) -> Tag {
canonical(&snbt(s)).expect("known type")
}
#[test]
fn every_type_has_defaults() {
for id in TYPES.iter().chain(NEWEST.iter()) {
let tag = snbt(&format!("{{id:\"{id}\",x:1,y:2,z:3}}"));
let out = canonical(&tag).unwrap_or_else(|| panic!("{id}"));
assert_eq!(out.get("id"), tag.get("id"));
assert_eq!(out.get("keepPacked"), Some(&Tag::Byte(0)), "{id}");
assert_eq!(
out.get("components"),
Some(&Tag::Compound(Compound::new())),
"{id}"
);
}
assert!(canonical(&snbt("{id:\"minecraft:nope\",x:1,y:2,z:3}")).is_none());
}
#[test]
fn furnace_defaults_match_vanilla() {
let out = canon("{id:\"minecraft:furnace\",x:1,y:2,z:3}");
assert_eq!(out.get("cooking_total_time"), Some(&Tag::Int(0)));
assert_eq!(out.get("speed_multiplier"), Some(&f32_tag(1.0)));
assert_eq!(out.get("Items"), Some(&Tag::List(vec![])));
assert_eq!(
out.get("RecipesUsed"),
Some(&Tag::Compound(Compound::new()))
);
}
#[test]
fn loot_table_replaces_items_and_zero_seed_is_omitted() {
let out = canon(
"{id:\"minecraft:chest\",x:1,y:2,z:3,LootTable:\"minecraft:chests/x\",LootTableSeed:0L,\
Items:[{Slot:0b,id:\"minecraft:stone\",count:1}]}",
);
assert!(out.get("Items").is_none());
assert!(out.get("LootTableSeed").is_none());
assert_eq!(out.get("LootTable"), Some(&string("minecraft:chests/x")));
}
#[test]
fn items_are_validated_and_sorted_by_slot() {
let out = canon(
"{id:\"minecraft:hopper\",x:1,y:2,z:3,Items:[\
{Slot:4b,id:\"minecraft:stone\",count:2},{Slot:5b,id:\"minecraft:stone\",count:1},\
{Slot:0b,id:\"minecraft:air\",count:1},{Slot:1b,id:\"minecraft:dirt\"},\
{Slot:2b,id:\"minecraft:dirt\",count:100}]}",
);
let Some(Tag::List(items)) = out.get("Items") else {
panic!("items")
};
let slots: Vec<_> = items.iter().map(|i| i.get("Slot").cloned()).collect();
assert_eq!(slots, vec![Some(Tag::Byte(1)), Some(Tag::Byte(4))]);
assert_eq!(items[0].get("count"), Some(&Tag::Int(1)));
assert_eq!(out.get("TransferCooldown"), Some(&Tag::Int(-1)));
}
#[test]
fn plain_text_components_become_strings() {
let out =
canon("{id:\"minecraft:banner\",x:1,y:2,z:3,CustomName:{text:\"Flag\"},patterns:[]}");
assert_eq!(out.get("CustomName"), Some(&string("Flag")));
assert!(out.get("patterns").is_none());
let styled =
canon("{id:\"minecraft:banner\",x:1,y:2,z:3,CustomName:{text:\"F\",color:\"red\"}}");
assert!(matches!(styled.get("CustomName"), Some(Tag::Compound(_))));
}
#[test]
fn shulker_box_omits_empty_items_and_structure_block_clamps() {
let shulker = canon("{id:\"minecraft:shulker_box\",x:1,y:2,z:3}");
assert!(shulker.get("Items").is_none());
let structure = canon("{id:\"minecraft:structure_block\",x:1,y:2,z:3,posX:99,sizeY:-4}");
assert_eq!(structure.get("posX"), Some(&Tag::Int(48)));
assert_eq!(structure.get("sizeY"), Some(&Tag::Int(0)));
assert_eq!(structure.get("posY"), Some(&Tag::Int(1)));
assert_eq!(structure.get("showboundingbox"), Some(&Tag::Byte(1)));
}
#[test]
fn canonical_is_idempotent() {
for id in TYPES.iter().chain(NEWEST.iter()) {
let once = canonical(&snbt(&format!("{{id:\"{id}\",x:1,y:2,z:3}}"))).expect("known");
assert_eq!(canonical(&once).as_ref(), Some(&once), "{id}");
}
}
#[test]
fn overlay_keeps_unchanged_detail_and_takes_changes() {
let original = snbt(
"{id:\"minecraft:sign\",front_text:{messages:[{text:\"a\",color:\"red\"},\"\",\"\",\"\"]},\
back_text:{messages:[\"x\",\"\",\"\",\"\"]},extra:1b}",
);
let loaded = snbt(
"{id:\"minecraft:sign\",front_text:{messages:[\"a\",\"\",\"\",\"\"]},\
back_text:{messages:[\"x\",\"\",\"\",\"\"]}}",
);
let current = snbt(
"{id:\"minecraft:sign\",front_text:{messages:[\"a\",\"\",\"\",\"\"]},\
back_text:{messages:[\"y\",\"\",\"\",\"\"]}}",
);
let merged = overlay(&original, &loaded, &current);
assert_eq!(merged.get("front_text"), original.get("front_text"));
assert_eq!(merged.get("back_text"), current.get("back_text"));
assert_eq!(merged.get("extra"), original.get("extra"));
}
#[test]
fn overlay_merges_container_slots() {
let item = |slot: i8, count: i32, extra: &str| {
snbt(&format!(
"{{Slot:{slot}b,id:\"minecraft:stone\",count:{count}{extra}}}"
))
};
let original = Tag::compound([(
"Items",
Tag::List(vec![
item(0, 1, ",components:{\"minecraft:lore\":[\"x\"]}"),
item(1, 1, ""),
]),
)]);
let loaded = Tag::compound([("Items", Tag::List(vec![item(0, 1, ""), item(1, 1, "")]))]);
let current = Tag::compound([("Items", Tag::List(vec![item(0, 1, ""), item(1, 5, "")]))]);
let merged = overlay(&original, &loaded, &current);
let Some(Tag::List(items)) = merged.get("Items") else {
panic!("items")
};
assert!(
items[0].get("components").is_some(),
"slot 0 keeps its lore"
);
assert_eq!(items[1].get("count"), Some(&Tag::Int(5)));
}
}
+1 -1
View File
@@ -170,7 +170,7 @@ impl BlockEntity {
lit_remaining: 0,
lit_total: 0,
cooking_timer: 0,
cooking_total: 200,
cooking_total: 0,
speed: 1.0,
}));
}
+12 -1
View File
@@ -41,7 +41,7 @@ struct Out {
// Overlay 6 (beacon beams): the light bytes carry the sprite's v range.
out.wrap = vec2(f32(light.x | (light.y << 8u)), f32(light.z | (light.w << 8u))) / 65535.0;
// Hurt overlay (OverlayTexture red tint).
if overlay == 1u { c = vec4(mix(c.rgb, vec3(1.0, 0.0, 0.0), 0.3), c.a); }
if overlay == 1u || overlay == 8u { c = vec4(mix(c.rgb, vec3(1.0, 0.0, 0.0), 0.3), c.a); }
out.color = c;
// Overlay 5: OverlayTexture white flash (primed TNT), applied after texturing.
out.flash = select(0.0, 0.75, overlay == 5u);
@@ -67,6 +67,17 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 {
}
if color.a < 0.1 { discard; }
color = vec4(mix(color.rgb, vec3(1.0), in.flash), color.a);
if in.overlay == 7u || in.overlay == 8u {
// Enchantment glint (overlay 7, 8 with the hurt tint): the purple
// enchanted_glint sheen drifting diagonally over the item's shape.
let px = in.uv * vec2<f32>(textureDimensions(atlas));
let t = globals.misc.y * 0.05;
let band = sin((px.x + px.y) * 0.9 - t * 6.0) * 0.5 + 0.5;
let band2 = sin((px.x - px.y) * 0.6 + t * 4.0) * 0.5 + 0.5;
let shimmer = pow(band * 0.6 + band2 * 0.4, 2.0);
let glint = vec3(0.50, 0.25, 0.80) * (0.25 + 0.75 * shimmer);
color = vec4(min(color.rgb + glint * 0.6, vec3(1.0)), color.a);
}
let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
+111 -33
View File
@@ -108,10 +108,15 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
Tag::Short(m.death_time.clamp(0, i32::from(i16::MAX)) as i16),
),
("PersistenceRequired", Tag::Byte(i8::from(m.persistent))),
("CustomNameVisible", Tag::Byte(i8::from(m.name_visible))),
] {
put(&mut tag, key, value);
}
// `Entity.saveWithoutId` writes the flag only when set.
if m.name_visible {
put(&mut tag, "CustomNameVisible", Tag::Byte(1));
} else if let Tag::Compound(map) = &mut tag {
map.remove(&"CustomNameVisible".into());
}
// A styled name from the save stays unless the name changed.
if custom_name(&tag) != m.custom_name
&& let Some(name) = &m.custom_name
@@ -145,7 +150,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
map.entry(key.into()).or_insert(value);
}
let id = m.kind.id.as_str();
if m.kind.category == "creature" {
// Only breedable animals have an age; a loaded creature that was saved without
// one (a frog) stays without.
let aged = raw.is_none_or(|r| r.get("Age").is_some());
if m.kind.category == "creature" && aged {
map.insert("Age".into(), Tag::Int(m.extra.age));
map.insert("AgeLocked".into(), Tag::Byte(i8::from(m.extra.age_locked)));
for (key, value) in [
@@ -217,10 +225,14 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
let v = i32::from(m.extra.variant) | i32::from(m.extra.variant2) << 8;
map.insert("Variant".into(), Tag::Int(v));
}
if crate::mobs::llama::is_llama(m.species()) {
let llama = crate::mobs::llama::is_llama(m.species());
if llama {
crate::mobs::llama::to_nbt(m, map);
}
map.insert("ChestedHorse".into(), Tag::Byte(i8::from(m.extra.chested)));
// Only llamas, donkeys and mules carry chests.
if llama || matches!(id, "minecraft:donkey" | "minecraft:mule") {
map.insert("ChestedHorse".into(), Tag::Byte(i8::from(m.extra.chested)));
}
if m.extra.chested && !m.extra.items.is_empty() {
map.insert("Items".into(), crate::save::encode_items(&m.extra.items));
} else {
@@ -239,7 +251,11 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
Tag::compound([("id", string(armor)), ("count", Tag::Int(1))]),
));
}
map.insert("equipment".into(), Tag::compound(equipment));
if equipment.is_empty() {
map.remove(&"equipment".into());
} else {
map.insert("equipment".into(), Tag::compound(equipment));
}
let attr = |id: &str, v: f64| {
Tag::compound([("id", string(id)), ("base", Tag::Double(v.to_bits()))])
};
@@ -275,26 +291,16 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
map.remove(&"home_pos".into());
}
}
"minecraft:zombie_villager" => {
map.insert("VillagerData".into(), villager_data(m));
map.insert("VillagerDataFinalized".into(), Tag::Byte(1));
let xp = m.extra.trade.as_deref().map_or(0, |t| t.xp);
map.insert("Xp".into(), Tag::Int(xp));
put_offers(map, m);
crate::mobs::zombie_villager::write_nbt(m, map);
}
"minecraft:villager" => {
use crate::mobs::render::{PROFESSIONS, VILLAGER_TYPES};
let data = Tag::compound([
(
"type",
string(&format!(
"minecraft:{}",
VILLAGER_TYPES[m.extra.variant as usize % VILLAGER_TYPES.len()]
)),
),
(
"profession",
string(&format!(
"minecraft:{}",
PROFESSIONS[m.extra.variant2 as usize % PROFESSIONS.len()]
)),
),
("level", Tag::Int(i32::from(m.extra.variant3.max(1)))),
]);
map.insert("VillagerData".into(), data);
map.insert("VillagerData".into(), villager_data(m));
let t = m.extra.trade.as_deref().cloned().unwrap_or_default();
map.insert("Xp".into(), Tag::Int(t.xp));
map.insert("LastRestock".into(), Tag::Long(t.last_restock));
@@ -378,7 +384,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
}
// Skeletons are spawned holding a bow (finalizeSpawn); a mob loaded
// from NBT keeps only its saved equipment.
"minecraft:skeleton" | "minecraft:stray" | "minecraft:bogged" => {
"minecraft:skeleton" | "minecraft:stray" | "minecraft:bogged" if raw.is_none() => {
map.entry("equipment".into()).or_insert_with(|| {
Tag::compound([(
"mainhand",
@@ -404,13 +410,14 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
_ => {}
}
crate::mobs::raider::write_nbt(m, map);
crate::mobs::riders::write_nbt(m, map);
// LivingEntity equipment: what the mob holds now.
if !crate::mobs::equine::is_equine(m.species()) {
let mut equipment = match map.get(&"equipment".into()) {
Some(Tag::Compound(c)) => c.clone(),
_ => horizon_world::nbt::Compound::new(),
};
for (slot, item) in [
for (index, (slot, item)) in [
("mainhand", &m.extra.main_hand),
("offhand", &m.extra.off_hand),
(
@@ -425,7 +432,19 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
("chest", &m.extra.chest),
("legs", &m.extra.legs),
("feet", &m.extra.feet),
] {
]
.into_iter()
.enumerate()
{
// Enchanted gear is saved with its `minecraft:enchantments`.
if let (Some(id), Some(g)) = (item, crate::mobs::gear::gear(m))
&& !g.slots[index].is_empty()
{
let mut stack = crate::items::ItemStack::new(id, 1);
stack.data_mut().enchantments = g.slots[index].clone();
equipment.insert(slot.into(), crate::save::item_to_nbt(&stack));
continue;
}
match item {
Some(id) => {
let keep = matches!(
@@ -462,7 +481,12 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
}
}
}
map.insert("equipment".into(), Tag::Compound(equipment));
// Vanilla saves `equipment` only when something is equipped.
if equipment.is_empty() {
map.remove(&"equipment".into());
} else {
map.insert("equipment".into(), Tag::Compound(equipment));
}
}
tag
}
@@ -511,6 +535,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
m.extra.legs = slot("legs");
m.extra.feet = slot("feet");
}
// Their enchantments.
for (index, key) in crate::mobs::gear::KEYS.iter().enumerate() {
if let Some(stack) = eq.get(key).and_then(crate::save::item_from_nbt) {
crate::mobs::gear::set(&mut m, index, stack.enchantments().to_vec());
}
}
}
m.death_time = number(tag.get("DeathTime")).unwrap_or(0) as i32;
m.persistent = flag(tag, "PersistenceRequired");
@@ -621,6 +651,14 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
) {
read_villager(&mut m, tag);
}
if m.species() == crate::mobs::Species::ZombieVillager {
read_villager(&mut m, tag);
let xp = number(tag.get("Xp")).unwrap_or(0) as i32;
if xp != 0 {
m.extra.trade.get_or_insert_with(Default::default).xp = xp;
}
crate::mobs::zombie_villager::read_nbt(&mut m, tag);
}
if m.species() == crate::mobs::Species::Allay {
if let Some(Tag::List(inv)) = tag.get("Inventory")
&& let Some(first) = inv.first()
@@ -698,6 +736,7 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
m.extra.flag2 = flag(tag, "wasOnGround");
}
crate::mobs::raider::read_nbt(&mut m, tag);
crate::mobs::riders::read_nbt(&mut m, tag);
// A mob saved mid-death finishes dying; one saved dead is dropped.
if m.health <= 0.0 && m.death_time == 0 {
return None;
@@ -998,16 +1037,27 @@ pub fn armor_stand_to_nbt(a: &ArmorStand, uuid: [i32; 4], raw: Option<&Tag>) ->
.zip(&a.equipment)
.filter_map(|(slot, stack)| Some((*slot, item_to_nbt(stack.as_ref()?))))
.collect();
put(&mut tag, "equipment", Tag::compound(equipment));
// `equipment` is saved only when something is worn, `Marker` only when set.
if equipment.is_empty() {
if let Tag::Compound(map) = &mut tag {
map.remove(&"equipment".into());
}
} else {
put(&mut tag, "equipment", Tag::compound(equipment));
}
for (key, value) in [
("Small", a.small),
("ShowArms", a.show_arms),
("NoBasePlate", a.no_base_plate),
("Invisible", a.invisible),
("Marker", a.marker),
] {
put(&mut tag, key, Tag::Byte(i8::from(value)));
}
if a.marker {
put(&mut tag, "Marker", Tag::Byte(1));
} else if let Tag::Compound(map) = &mut tag {
map.remove(&"Marker".into());
}
if let Tag::Compound(map) = &tag
&& !map.contains_key(&horizon_world::nbt::JavaString::from("Health"))
{
@@ -1080,6 +1130,27 @@ pub fn boat_from_nbt(tag: &Tag) -> Option<(Vec3, Vec3, f32)> {
Some((position(tag)?, motion(tag), rotation(tag)[0]))
}
/// `VillagerData`: type, profession and level.
fn villager_data(m: &Mob) -> Tag {
use crate::mobs::render::{PROFESSIONS, VILLAGER_TYPES};
Tag::compound([
(
"type",
string(&format!(
"minecraft:{}",
VILLAGER_TYPES[m.extra.variant as usize % VILLAGER_TYPES.len()]
)),
),
(
"profession",
string(&format!(
"minecraft:{}",
PROFESSIONS[m.extra.variant2 as usize % PROFESSIONS.len()]
)),
),
("level", Tag::Int(i32::from(m.extra.variant3.max(1)))),
])
}
/// `AbstractVillager` "Offers" (`MerchantOffers.CODEC`).
fn put_offers(map: &mut Compound, m: &Mob) {
let Some(t) = &m.extra.trade else { return };
@@ -1092,12 +1163,19 @@ fn put_offers(map: &mut Compound, m: &Mob) {
("sell", item_to_nbt(&o.result)),
("uses", Tag::Int(o.uses)),
("maxUses", Tag::Int(o.max_uses)),
("rewardExp", Tag::Byte(i8::from(o.reward_exp))),
("specialPrice", Tag::Int(o.special_price_diff)),
("demand", Tag::Int(o.demand)),
("priceMultiplier", Tag::Float(o.price_multiplier.to_bits())),
("xp", Tag::Int(o.xp)),
];
// `MerchantOffer.CODEC` omits fields at their defaults.
if !o.reward_exp {
entries.push(("rewardExp", Tag::Byte(0)));
}
if o.special_price_diff != 0 {
entries.push(("specialPrice", Tag::Int(o.special_price_diff)));
}
if o.demand != 0 {
entries.push(("demand", Tag::Int(o.demand)));
}
if let Some(b) = &o.cost_b {
entries.push(("buyB", item_to_nbt(&b.stack)));
}
+51
View File
@@ -35,6 +35,9 @@ mod ghasts;
mod golems;
mod growth;
mod jukebox;
mod lan;
mod lan_actions;
mod lan_screen;
mod leads;
mod lightning;
mod llamas;
@@ -42,6 +45,8 @@ mod loom;
mod machines;
mod maps;
mod minecarts;
mod mob_blocks;
mod mob_gear;
mod mount_menu;
mod mounts;
mod music;
@@ -49,6 +54,7 @@ mod names;
mod options;
mod packs;
mod paintings;
mod passengers;
mod persist;
mod perspective;
mod piglins;
@@ -81,6 +87,7 @@ mod villagers;
mod wandering_trader;
mod wind;
mod wither;
mod zombie_villagers;
use horizon_client::{
Result,
assets::Assets,
@@ -271,6 +278,8 @@ enum Screen {
Stats,
/// The Advancements screen.
Advancements,
/// WorldOptionsScreen (game/lan_screen.rs).
WorldOptions,
}
#[derive(Clone)]
enum Icon {
@@ -536,6 +545,7 @@ struct Game<'a> {
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,
@@ -667,6 +677,18 @@ struct Game<'a> {
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>,
world_options: Option<lan_screen::WorldOptions>,
/// The block a guest is acting on (game/lan_actions.rs).
forced_hit: Option<Hit>,
/// Level events of this tick for the guests, and the guest acting now.
lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
lan_acting: Option<u32>,
/// Command feedback to forward to a guest.
chat_capture: Option<Vec<String>>,
/// Allow Cheats: whether guests may be given commands.
cheats: bool,
ui: chat::UiState,
combat: combat::CombatTracker,
mount: mounts::MountState,
@@ -763,6 +785,14 @@ impl Game<'_> {
/// 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())
}
@@ -1254,6 +1284,7 @@ impl Game<'_> {
/// 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);
for event in events {
match event {
LevelEvent::LevelEvent {
@@ -2551,6 +2582,7 @@ impl Game<'_> {
self.tick_mobs()?;
self.tick_experience();
}
self.tick_lan();
self.tick_hand();
self.tick_sleep();
self.tick_portal()?;
@@ -3122,6 +3154,7 @@ impl Game<'_> {
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::Inventory => {
self.draw_inventory(&mut batch);
}
@@ -3890,6 +3923,7 @@ impl Game<'_> {
// Mobs and their projectiles.
self.mob_geometry(camera, alpha, &mut out);
self.player_model_geometry(camera, alpha, &mut out);
self.guest_model_geometry(camera, alpha, &mut out);
self.fangs_geometry(camera, alpha, &mut out);
self.name_tag_geometry(camera, alpha, &mut out);
// Arrows: two crossed quads along the flight direction.
@@ -4710,6 +4744,8 @@ impl Game<'_> {
) -> Result<()> {
let save_root = std::env::current_dir()?.join("saves").join(folder);
horizon_client::save::migrate_legacy(&save_root)?;
self.session_lock = None;
self.session_lock = Some(horizon_client::save::SessionLock::acquire(&save_root)?);
self.persist = Default::default();
self.score = Default::default();
self.fns = Default::default();
@@ -6972,6 +7008,7 @@ impl Game<'_> {
Screen::Dead => {}
Screen::Stats => self.screen = Screen::Paused,
Screen::Advancements => self.close_advancements(),
Screen::WorldOptions => self.close_world_options(),
Screen::Chat => self.close_chat(),
},
KeyCode::KeyT if self.screen == Screen::Inventory => self.recipe_focus_search(),
@@ -7356,6 +7393,9 @@ impl ApplicationHandler for Game<'_> {
self.click_creative(button == MouseButton::Right);
}
Screen::Paused if pressed => self.pause_click()?,
Screen::WorldOptions if pressed && button == MouseButton::Left => {
self.world_options_click()
}
Screen::Dead if pressed => self.death_click()?,
Screen::Advancements if button == MouseButton::Left => {
let size = self
@@ -7432,6 +7472,9 @@ impl ApplicationHandler for Game<'_> {
WindowEvent::KeyboardInput { event, .. } if self.remote_chat_open() => {
self.remote_chat_key(&event)
}
WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::WorldOptions => {
self.world_options_key(&event)
}
WindowEvent::KeyboardInput { event, .. } if self.screen == Screen::Options => {
if event.state == ElementState::Pressed
&& let PhysicalKey::Code(key) = event.physical_key
@@ -7781,6 +7824,7 @@ pub fn run() -> Result<()> {
message: None,
save,
level,
session_lock: None,
audio,
music: Default::default(),
ambience: Default::default(),
@@ -7881,6 +7925,13 @@ pub fn run() -> Result<()> {
pending_bench: None,
persist: Default::default(),
remote: None,
lan: None,
world_options: None,
forced_hit: None,
lan_events: Vec::new(),
lan_acting: None,
chat_capture: None,
cheats: true,
ui: Default::default(),
combat: Default::default(),
mount: Default::default(),
+43 -19
View File
@@ -367,6 +367,10 @@ impl Game<'_> {
}
/// A chat message from the game (ChatComponent.addServerSystemMessage).
pub(super) fn system_message(&mut self, text: Text) {
if let Some(capture) = self.chat_capture.as_mut() {
capture.push(text.plain());
return;
}
let focused = self.screen == Screen::Chat;
self.ui.chat.add(
&self.res.atlas,
@@ -462,6 +466,7 @@ impl Game<'_> {
self.ui
.chat
.add(&self.res.atlas, line, None, self.ticks, focused);
self.lan_host_chat(message);
}
}
pub(super) fn chat_scroll(&mut self, amount: f32) {
@@ -593,28 +598,47 @@ impl Game<'_> {
if let Err(e) = self.ui.rules.save(&self.world_root) {
eprintln!("Horizon: failed to save game rules: {e}");
}
use horizon_world::nbt::{Limits, NamedTag, Tag};
use horizon_world::nbt::Tag;
let c = self.ui.clock;
let clock = Tag::compound([
("total_ticks", Tag::Long(self.world.day_time)),
("partial_tick", Tag::Float(c.partial.to_bits())),
("rate", Tag::Float(c.rate.to_bits())),
("paused", Tag::Byte(i8::from(c.paused))),
]);
let root = NamedTag {
name: "".into(),
tag: Tag::compound([
("data", Tag::compound([("minecraft:overworld", clock)])),
("DataVersion", Tag::Int(horizon_world::DATA_VERSION)),
]),
// The other clocks stay as saved; the overworld one keeps the fields Horizon
// does not model, and (like vanilla's codec) omits rate, partial tick and
// pause while they have their defaults.
let path = self.world_root.join("data/minecraft/world_clocks.dat");
let existing = horizon_client::save::read_dat(&path);
let mut data = match existing.as_ref().and_then(|r| r.get("data")) {
Some(d @ Tag::Compound(_)) => d.clone(),
_ => Tag::Compound(Default::default()),
};
if let Ok(bytes) = horizon_world::nbt::write_named(&root, Limits::default())
&& let Ok(gz) = horizon_world::compression::Compression::Gzip.encode(&bytes)
{
let dir = self.world_root.join("data/minecraft");
let _ = std::fs::create_dir_all(&dir);
let _ = std::fs::write(dir.join("world_clocks.dat"), gz);
let mut clock = match data.get("minecraft:overworld") {
Some(c @ Tag::Compound(_)) => c.clone(),
_ => Tag::Compound(Default::default()),
};
if let Tag::Compound(map) = &mut clock {
map.insert("total_ticks".into(), Tag::Long(self.world.day_time));
for (key, value, default) in [
(
"partial_tick",
Tag::Float(c.partial.to_bits()),
c.partial == 0.0,
),
("rate", Tag::Float(c.rate.to_bits()), c.rate == 1.0),
("paused", Tag::Byte(i8::from(c.paused)), !c.paused),
] {
if default {
map.remove(&key.into());
} else {
map.insert(key.into(), value);
}
}
}
if let Tag::Compound(map) = &mut data {
map.insert("minecraft:overworld".into(), clock);
}
let root = Tag::compound([
("data", data),
("DataVersion", Tag::Int(horizon_world::DATA_VERSION)),
]);
let _ = horizon_client::save::write_dat(&path, root);
let _ = write_difficulty(&self.world_root, self.ui.difficulty);
}
/// Death message in chat (CombatTracker.getDeathMessage, as far as the
@@ -485,6 +485,12 @@ impl Game<'_> {
let Some(Arg::GameMode(m)) = ctx.get("gamemode") else {
return Ok(0);
};
self.set_default_game_mode(match m {
horizon_client::command::args::GameMode::Survival => 0,
horizon_client::command::args::GameMode::Creative => 1,
horizon_client::command::args::GameMode::Adventure => 2,
horizon_client::command::args::GameMode::Spectator => 3,
});
self.feedback(Text::translate(
"commands.defaultgamemode.success",
&[Text::translate(&format!("gameMode.{}", m.name()), &[])],
+15
View File
@@ -34,6 +34,7 @@ const HELP: &[&str] = &[
"bench SECONDS reset stats, wait, then reply with the summary",
"open WORLD [SEED] [creative] open or create a world from the title screen",
"save save the world",
"save-all save the world, rewriting every resident chunk",
"connect HOST[:PORT] [NAME] join a multiplayer server (offline mode) from the title screen",
"chat MESSAGE send chat or a /command to the server",
"disconnect leave the server for the server list",
@@ -78,11 +79,15 @@ impl Game<'_> {
if let Some(value) = self.block_command(&words)? {
return Ok(Some(value));
}
if let Some(value) = self.lan_control(&words)? {
return Ok(Some(value));
}
match words[0] {
"help" => Ok(Some(json!({ "commands": HELP
.iter()
.chain(super::station_control::HELP)
.chain(super::blockctl::HELP)
.chain(super::lan::HELP)
.chain(super::render_control::HELP)
.chain(super::sculk::HELP)
.collect::<Vec<_>>() }))),
@@ -391,6 +396,15 @@ impl Game<'_> {
self.save_game()?;
ok()
}
"save-all" => {
// Like `save-all flush`: also rewrite chunks that were not modified
// (the save round-trip harness compares them with vanilla's files).
self.require_world()?;
let keys: Vec<_> = self.world.chunks.keys().copied().collect();
self.world.modified.extend(keys);
self.save_game()?;
ok()
}
"dragon-hurt" => {
// Test hook: damage the dragon's head as the player would.
let amount: f32 = arg(1)?.parse()?;
@@ -451,6 +465,7 @@ impl Game<'_> {
Screen::Chat => "chat",
Screen::Stats => "stats",
Screen::Advancements => "advancements",
Screen::WorldOptions => "world-options",
}
}
+61 -15
View File
@@ -256,6 +256,10 @@ impl Game<'_> {
}
let id = mob.id;
self.mobs.push(mob);
self.enchant_spawn_equipment(id);
if !persistent && !scripted {
self.spawn_jockeys(id, true);
}
Some(id)
}
/// The `summon` command: spawn a mob in front of the player or at a position.
@@ -282,6 +286,7 @@ impl Game<'_> {
-24000
};
}
self.spawn_jockeys(id, false);
Ok(id)
}
/// The `mobs` command: nearby mobs with position, health and running goals.
@@ -301,6 +306,9 @@ impl Game<'_> {
"target": m.ai.target.map(|t| format!("{t:?}")),
"goals": m.ai.goals.running_names(),
"held": m.extra.main_hand.as_deref(),
"mount": m.extra.mount,
"rider": m.extra.rider,
"enchants": horizon_client::mobs::gear::gear(m).map(|g| g.slots.iter().map(|s| s.iter().map(|(e, l)| format!("{e}:{l}")).collect::<Vec<_>>()).collect::<Vec<_>>()),
"ints": m.extra.ints,
"pois": [m.extra.home, m.extra.bed, m.extra.meeting],
"profession": m.extra.variant2,
@@ -328,7 +336,7 @@ impl Game<'_> {
"leader": s.patrol_leader,
"patrolling": s.patrolling,
"patrol_target": s.patrol_target,
"vehicle": s.vehicle,
"vehicle": m.extra.mount,
})),
})
})
@@ -702,6 +710,9 @@ impl Game<'_> {
}
self.mobs.append(&mut mobs);
self.sync_riders();
self.tick_skeleton_traps();
self.cache_mob_icons();
self.tick_apparition();
self.villager_reputation_tick();
self.villager_pickups();
for m in dead {
@@ -804,7 +815,16 @@ impl Game<'_> {
m.extra.feet.clone(),
]
};
for item in std::iter::once(m.extra.main_hand.clone()).chain(worn) {
for (index, item) in std::iter::once(m.extra.main_hand.clone())
.chain(worn)
.enumerate()
{
// Main hand, then head to feet (the enchantment slots).
let slot = if index == 0 {
horizon_client::mobs::gear::MAIN
} else {
horizon_client::mobs::gear::HEAD + index - 1
};
// Equipment drop chance 8.5% (+ player kill only).
// Vexes never drop their sword.
if let Some(item) = &item
@@ -813,17 +833,13 @@ impl Game<'_> {
&& m.species() != Species::Vex
&& self.world.random.next_float() < 0.085
{
self.spawn_item(
ItemStack {
item: item.clone(),
count: 1,
damage: 0,
extra: None,
},
pos,
[0.0, 0.2, 0.0],
10,
);
let mut stack = ItemStack::new(item, 1);
if let Some(g) = horizon_client::mobs::gear::gear(m) {
for (e, l) in &g.slots[slot] {
stack.enchant(e, *l);
}
}
self.spawn_item(stack, pos, [0.0, 0.2, 0.0], 10);
}
}
}
@@ -919,10 +935,12 @@ impl Game<'_> {
amount,
source,
} => {
let mut killed = false;
if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) {
let hit = t.damage(amount, source);
if hit {
let (kind, center, dead) = (t.kind.clone(), t.center(), !t.alive());
killed = dead;
let pitch = (self.world.random.next_float()
- self.world.random.next_float())
* 0.2
@@ -938,6 +956,9 @@ impl Game<'_> {
}
}
}
if killed && let Some(Who::Mob(killer)) = source.attacker {
self.zombie_killed(killer, target);
}
}
MobEvent::FinishAdmiring { mob } => self.finish_admiring(mob),
MobEvent::Hiss { mob } => {
@@ -1095,6 +1116,7 @@ impl Game<'_> {
MobEvent::CreakingTearDown { center, spread } => {
self.creaking_tear_down(center, spread)
}
MobEvent::CureZombieVillager { mob } => self.cure_zombie_villager(mob),
MobEvent::VillagerMeet { mob, other } => self.villager_meet(mob, other),
MobEvent::VillagerBirth { parent, partner } => self.villager_birth(parent, partner),
MobEvent::GolemCheck { mob, needed } => self.villager_golem_check(mob, needed),
@@ -1322,7 +1344,7 @@ impl Game<'_> {
self.give_player_effect("minecraft:mining_fatigue", 6000, 2);
self.audio
.play("minecraft:entity.elder_guardian.curse", Some(at), 1.0, 1.0);
self.creatures.elder_apparition = 30;
self.creatures.elder_apparition = super::mob_blocks::APPARITION_TICKS;
}
/// Damage of a given type to the player from a point.
pub(super) fn mob_hits_player_kind(&mut self, amount: f32, from: [f64; 3], kind: &str) {
@@ -1562,7 +1584,22 @@ impl Game<'_> {
};
match (&p.kind, hit) {
(ProjectileKind::Arrow { effect, .. }, Hit::Entity { who, .. }) => {
let amount = p.arrow_damage(&mut self.world.random);
let amount = p.arrow_damage(&mut self.world.random) + p.bonus.damage;
// Punch pushes along the flight, Flame burns for five seconds.
let flight = (p.velocity.x * p.velocity.x + p.velocity.z * p.velocity.z).sqrt();
if p.bonus.punch > 0 && flight > 1e-6 {
let k = f64::from(p.bonus.punch) * 0.6 / flight;
self.handle_mob_events(vec![MobEvent::Push {
target: who,
velocity: [p.velocity.x * k, 0.1, p.velocity.z * k],
}])?;
}
if p.bonus.flame {
self.handle_mob_events(vec![MobEvent::Ignite {
target: who,
seconds: 5,
}])?;
}
match who {
Who::Player => {
if !self.creative {
@@ -1895,6 +1932,9 @@ impl Game<'_> {
.unwrap_or_default();
let creative = self.creative;
let selected = self.selected;
if self.interact_zombie_villager(index, &item) {
return Ok(true);
}
if self.interact_trader(index, &item)? {
self.swing_arm();
return Ok(true);
@@ -2388,6 +2428,7 @@ impl Game<'_> {
&self.res.mob_data,
out,
);
self.mob_block_geometry(mob, camera, alpha, packed, out);
// GuardianRenderer: the laser to the locked target.
if let Some((time, scale)) = horizon_client::mobs::guardian::beam(mob, alpha as f32)
&& let Some(target) = self.beam_target(mob.ai.target, alpha)
@@ -2409,6 +2450,7 @@ impl Game<'_> {
);
}
}
self.elder_apparition_geometry(alpha, out);
// Projectiles: arrows as crossed quads, the rest as item billboards.
let (yaw, pitch) = (self.yaw.to_radians(), self.pitch.to_radians());
let forward = glam::Vec3::new(
@@ -2602,6 +2644,10 @@ fn push_apart(mobs: &mut [Mob]) {
if !mobs[j].alive() || !bi.intersects(mobs[j].bounds()) {
continue;
}
// A rider and its vehicle do not push each other.
if mobs[i].extra.mount == Some(mobs[j].id) || mobs[j].extra.mount == Some(mobs[i].id) {
continue;
}
let (dx, dz) = (
mobs[j].position.x - mobs[i].position.x,
mobs[j].position.z - mobs[i].position.z,
+620
View File
@@ -0,0 +1,620 @@
//! Hosting the open world on the local network ("Open to LAN"): starts the
//! server threads and the play-state hub, feeds it the world's entities each
//! tick and turns what the guests do into gameplay. A world that is not open
//! costs one `Option` check per tick.
use super::{Game, chat::PLAYER_NAME};
use horizon_client::{
Result,
items::ItemStack,
lan::{
self, Lan, MAX_PLAYERS,
chunks::ChunkEncoder,
data::SyncData,
entity::EntityState,
hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
playerdata,
},
mobs::Mob,
text::Text,
};
use horizon_core::geometry::Vec3;
use horizon_protocol::{
crypto::offline_uuid,
entity_data::{Value, serializer},
};
use std::{
collections::HashMap,
sync::{Arc, OnceLock},
};
/// The registries and tags are the same for every world: load them once.
static SYNC: OnceLock<std::result::Result<Arc<SyncData>, String>> = OnceLock::new();
/// The settings of the open world (WorldOptionsScreen's multiplayer section).
#[derive(Clone, Debug)]
pub struct LanSettings {
pub port: u16,
pub guest_commands: bool,
pub force_game_mode: bool,
}
pub(super) struct LanHost {
pub hub: Hub,
pub settings: LanSettings,
pub host_entity: i32,
pub host_uuid: u128,
/// The guests' models in the host's world.
pub models: HashMap<u32, Mob>,
host_mode: i32,
pub play: HashMap<u32, super::lan_actions::GuestPlay>,
/// Blocks broken this tick (their sound is a level event for the guests).
pub broken: Vec<[f64; 3]>,
/// Hurt and death state of the mobs guests see.
mob_state: HashMap<u32, (i32, bool)>,
}
/// A stable UUID for an entity that has none.
fn entity_uuid(id: u32) -> u128 {
0x4856_5a4e_0000_0000_0000_0000_0000_0000u128 | u128::from(id)
}
/// Species that are AgeableMob (or have a baby flag at the same index).
fn ageable(kind: &str) -> bool {
matches!(
kind,
"minecraft:cow"
| "minecraft:mooshroom"
| "minecraft:pig"
| "minecraft:sheep"
| "minecraft:chicken"
| "minecraft:horse"
| "minecraft:donkey"
| "minecraft:mule"
| "minecraft:llama"
| "minecraft:cat"
| "minecraft:wolf"
| "minecraft:fox"
| "minecraft:rabbit"
| "minecraft:panda"
| "minecraft:villager"
| "minecraft:zombie"
| "minecraft:husk"
| "minecraft:drowned"
| "minecraft:zombie_villager"
| "minecraft:piglin"
| "minecraft:hoglin"
| "minecraft:goat"
| "minecraft:ocelot"
| "minecraft:turtle"
| "minecraft:strider"
| "minecraft:camel"
| "minecraft:axolotl"
)
}
pub const HELP: &[&str] = &[
"lan open [PORT] [commands] [force] open the world to the network (PORT 0 picks one)",
"lan close stop hosting",
"lan status the hosting state and the guests",
];
impl Game<'_> {
/// `horizon-ctl lan ...`.
pub(super) fn lan_control(&mut self, words: &[&str]) -> Result<Option<serde_json::Value>> {
use serde_json::json;
if words[0] != "lan" {
return Ok(None);
}
match words.get(1).copied() {
Some("open") => {
if self.title.is_some() {
return Err("open a world first".into());
}
let port = words.get(2).map_or(Ok(0), |p| p.parse::<u16>())?;
self.lan_open(LanSettings {
port: if port == 0 {
lan::available_port()
} else {
port
},
guest_commands: words.contains(&"commands"),
force_game_mode: words.contains(&"force"),
})?;
Ok(Some(json!({ "ok": true, "port": self.lan_port() })))
}
Some("close") => {
self.lan_close(true);
Ok(Some(json!({ "ok": true })))
}
Some("status") => Ok(Some(match &self.lan {
Some(h) => json!({
"open": true,
"port": h.settings.port,
"guests": h.hub.guests.iter().map(|g| json!({
"name": g.name,
"position": g.position,
"placed": g.placed,
"loaded": g.loaded,
"game_mode": g.game_mode,
"chunks": g.sent_chunks.len(),
"tracked": g.tracker.len(),
})).collect::<Vec<_>>(),
}),
None => json!({ "open": false }),
})),
_ => Err("lan open|close|status".into()),
}
}
pub(super) fn lan_open(&mut self, settings: LanSettings) -> Result<()> {
if self.lan.is_some() || self.remote.is_some() || self.title.is_some() {
return Err("already open".into());
}
let root = self.options.resources.clone();
let sync = SYNC
.get_or_init(|| SyncData::load(&root).map(Arc::new))
.clone()?;
let biome_names: Vec<String> = self
.res
.biomes
.list
.iter()
.map(|b| b.name.clone())
.collect();
let registry: Vec<String> = sync
.dynamic
.registries
.get("minecraft:worldgen/biome")
.map(|v| v.iter().map(|(n, _)| n.clone()).collect())
.unwrap_or_default();
let encoder = ChunkEncoder::new(
self.res
.facts
.states
.iter()
.map(|s| (s.name.clone(), s.fluid_level > 0 || s.waterlogged)),
&sync.builtin,
&biome_names,
&registry,
);
let motd = format!("{PLAYER_NAME} - {}", self.level.name);
let lan = Lan::start(sync.clone(), settings.port, motd, MAX_PLAYERS)?;
let host_uuid = self.level.player_uuid.map_or_else(
|| offline_uuid(PLAYER_NAME),
|u| {
u128::from(u[0] as u32) << 96
| u128::from(u[1] as u32) << 64
| u128::from(u[2] as u32) << 32
| u128::from(u[3] as u32)
},
);
lan.reserve(host_uuid);
self.next_entity += 1;
let host_entity = self.next_entity as i32;
let hub = Hub::new(
lan,
sync,
encoder,
HubConfig {
default_game_mode: self.level.mode(),
guest_commands: settings.guest_commands,
force_game_mode: settings.force_game_mode,
hardcore: self.level.hardcore,
view_distance: self.settings.render_distance.clamp(2, 32),
simulation_distance: self.settings.render_distance.clamp(2, 32),
dimension: self.dim.id().to_owned(),
seed: self.level.seed,
max_players: MAX_PLAYERS,
},
);
let port = hub.lan.port;
self.world.block_log = Some(Vec::new());
self.lan = Some(LanHost {
hub,
settings: LanSettings { port, ..settings },
host_entity,
host_uuid,
models: HashMap::new(),
host_mode: self.mode_id(),
play: HashMap::new(),
broken: Vec::new(),
mob_state: HashMap::new(),
});
self.audio.capture = Some(Vec::new());
self.system_message(Text::translate(
"menu.multiplayerOptions.publish.started.lan",
&[Text::literal(port.to_string())],
));
Ok(())
}
/// IntegratedServer.unpublishServer: the guests are sent away.
pub(super) fn lan_close(&mut self, announce: bool) {
let Some(mut host) = self.lan.take() else {
return;
};
for g in &host.hub.guests {
playerdata::save(g, &self.world_root);
}
host.hub.disconnect_all();
// Give the writer threads a moment to flush the disconnect packets.
std::thread::sleep(std::time::Duration::from_millis(100));
self.world.block_log = None;
self.audio.capture = None;
self.lan_events.clear();
self.streaming.extra.clear();
if announce {
self.system_message(Text::translate(
"menu.multiplayerOptions.publish.stopped",
&[],
));
}
}
/// The world's default game mode (`defaultgamemode`).
pub(super) fn set_default_game_mode(&mut self, mode: i32) {
self.level.game_mode = mode;
self.level.creative = mode == 1;
if let Some(host) = self.lan.as_mut() {
host.hub.config.default_game_mode = mode;
}
}
/// New command access and game mode forcing settings of the open world.
pub(super) fn lan_apply_settings(&mut self, guest_commands: bool, force: bool) {
if let Some(host) = self.lan.as_mut() {
host.settings.guest_commands = guest_commands;
host.settings.force_game_mode = force;
host.hub.config.guest_commands = guest_commands;
host.hub.config.force_game_mode = force;
host.hub.resend_commands();
}
}
pub(super) fn lan_port(&self) -> Option<u16> {
self.lan.as_ref().map(|h| h.settings.port)
}
/// The host as the guests see them.
fn lan_host_state(&self, host: &LanHost) -> Option<HostState> {
let p = self.player.as_ref()?;
let mut equipment: [Option<ItemStack>; 6] = Default::default();
equipment[0] = self.inventory.get(self.selected).cloned().flatten();
equipment[1] = self.offhand.clone();
// Feet, legs, chest, head are slots 2..=5; armor is stored head first.
equipment[2] = self.armor[3].clone();
equipment[3] = self.armor[2].clone();
equipment[4] = self.armor[1].clone();
equipment[5] = self.armor[0].clone();
Some(HostState {
uuid: host.host_uuid,
name: PLAYER_NAME.to_owned(),
entity_id: host.host_entity,
position: [p.position.x, p.position.y, p.position.z],
yaw: self.yaw,
pitch: self.pitch,
head_yaw: self.yaw,
on_ground: p.ground.on_ground,
game_mode: self.mode_id(),
sneaking: p.pose == horizon_client::pose::Pose::Crouching,
sprinting: p.sprinting,
equipment,
health: p.health.health(),
})
}
/// Mobs and items as the entities guests track.
fn lan_entities(&self, hub: &mut Hub) -> Vec<EntityState> {
let mut out = Vec::with_capacity(self.mobs.len() + self.dropped.len());
for m in self.mobs.iter().filter(|m| !m.removed) {
let mut meta = Vec::new();
if let Some(name) = &m.custom_name {
meta.push((
2,
serializer::OPTIONAL_COMPONENT,
Value::OptText(Some(horizon_protocol::text::literal(name))),
));
if m.name_visible {
meta.push((3, serializer::BOOLEAN, Value::Bool(true)));
}
}
if m.fire_ticks > 0 {
meta.push((0, serializer::BYTE, Value::Byte(1)));
}
if m.health < m.kind.max_health {
meta.push((9, serializer::FLOAT, Value::Float(m.health.max(0.0))));
}
let kind = m.kind.id.as_str();
if ageable(kind) && m.is_baby() {
meta.push((16, serializer::BOOLEAN, Value::Bool(true)));
}
if kind == "minecraft:sheep" {
let value = (m.extra.color & 15) | if m.extra.sheared { 16 } else { 0 };
meta.push((17, serializer::BYTE, Value::Byte(value as i8)));
}
let (yaw, pitch) = (m.yaw, m.head_pitch);
out.push(EntityState {
id: m.id as i32,
uuid: entity_uuid(m.id),
kind: kind.to_owned(),
position: [m.position.x, m.position.y, m.position.z],
yaw,
pitch,
head_yaw: m.head_yaw,
on_ground: m.on_ground,
velocity: [m.velocity.x, m.velocity.y, m.velocity.z],
data: 0,
meta,
equipment: Vec::new(),
send_velocity: false,
});
}
for d in &self.dropped {
let stack = hub.stack(&Some(d.stack.clone()));
out.push(EntityState {
id: d.id as i32,
uuid: entity_uuid(d.id),
kind: "minecraft:item".to_owned(),
position: [d.position.x, d.position.y, d.position.z],
yaw: 0.0,
pitch: 0.0,
head_yaw: 0.0,
on_ground: d.on_ground,
velocity: [d.velocity.x, d.velocity.y, d.velocity.z],
data: 0,
meta: vec![(8, serializer::ITEM_STACK, Value::Item(stack))],
equipment: Vec::new(),
send_velocity: true,
});
}
out
}
/// Run the hub for this tick and apply what the guests did.
pub(super) fn tick_lan(&mut self) {
let Some(mut host) = self.lan.take() else {
return;
};
if let Some(state) = self.lan_host_state(&host) {
let has_guests = !host.hub.guests.is_empty();
let entities = if has_guests {
self.lan_entities(&mut host.hub)
} else {
Vec::new()
};
let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]);
let events = {
let mut ctx = TickCtx {
world: &mut self.world,
host: &state,
entities: &entities,
next_entity: &mut self.next_entity,
spawn,
difficulty: i32::from(self.ui.difficulty),
difficulty_locked: false,
clock_rate: if self.ui.rules.bool("advance_time") {
self.ui.clock.rate
} else {
0.0
},
};
host.hub.tick(&mut ctx)
};
if host.host_mode != state.game_mode {
host.host_mode = state.game_mode;
host.hub.set_host_game_mode(state.uuid, state.game_mode);
}
for event in events {
match event {
HostEvent::Joined(conn) => {
self.lan_guest_joined(&mut host, conn, &state, &entities, spawn)
}
HostEvent::Left(guest) => {
playerdata::save(&guest, &self.world_root);
host.models.remove(&guest.conn);
}
HostEvent::Chat(line) => self.system_message(Text::literal(line)),
HostEvent::Packet(conn, packet) => {
self.lan_guest_packet(&mut host, conn, *packet);
}
}
}
}
self.lan_flush_effects(&mut host);
self.tick_guests(&mut host);
self.lan_swings(&mut host);
self.lan_update_streaming(&host);
self.lan_update_models(&mut host);
self.lan = Some(host);
}
fn lan_guest_joined(
&mut self,
host: &mut LanHost,
conn: u32,
state: &HostState,
entities: &[EntityState],
spawn: [f64; 3],
) {
let default_mode = host.hub.config.default_game_mode;
let force = host.hub.config.force_game_mode;
let root = self.world_root.clone();
let Some(g) = host.hub.guest_mut(conn) else {
return;
};
let known = playerdata::load(g, &root);
if !known || force {
g.game_mode = default_mode;
}
if !known {
g.position = spawn;
g.previous_position = spawn;
g.health = 20.0;
g.food = 20;
}
let mut ctx = TickCtx {
world: &mut self.world,
host: state,
entities,
next_entity: &mut self.next_entity,
spawn,
difficulty: i32::from(self.ui.difficulty),
difficulty_locked: false,
clock_rate: self.ui.clock.rate,
};
host.hub.place_new_player(conn, &mut ctx);
}
/// Level events the game queued, for the guests (`process_level_events`).
pub(super) fn lan_record_events(&mut self, events: &[horizon_world::level::LevelEvent]) {
if self.audio.capture.is_none() {
return;
}
for e in events {
if let horizon_world::level::LevelEvent::LevelEvent { id, pos, data } = e {
self.lan_events
.push((*id, [pos.x, pos.y, pos.z], *data, self.lan_acting));
}
}
}
/// Send the tick's level events, sounds and mob animations.
fn lan_flush_effects(&mut self, host: &mut LanHost) {
for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) {
if kind == 2001 {
host.broken
.push([f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])]);
}
host.hub.level_event(kind, pos, data, acting);
}
self.lan_broadcast_effects(host);
if host.hub.guests.is_empty() {
host.mob_state.clear();
return;
}
// Hurt and death animations of mobs.
let mut seen = HashMap::new();
for m in &self.mobs {
let dead = !m.alive();
let old = host.mob_state.get(&m.id).copied();
let at = [m.position.x, m.position.y, m.position.z];
if m.hurt_time > old.map_or(0, |o| o.0) && !dead {
host.hub.entity_event(m.id as i32, 2, at);
}
if dead && !old.is_some_and(|o| o.1) {
host.hub.entity_event(m.id as i32, 3, at);
}
seen.insert(m.id, (m.hurt_time, dead));
}
host.mob_state = seen;
}
/// Keep the chunks around every guest loaded.
fn lan_update_streaming(&mut self, host: &LanHost) {
self.streaming.extra = host
.hub
.guests
.iter()
.filter(|g| g.placed)
.map(|g| (g.chunk(), g.view_distance + 1))
.collect();
}
/// The guests' models, for the host to see them.
fn lan_update_models(&mut self, host: &mut LanHost) {
let Some(kind) = self.res.player_type.clone() else {
return;
};
host.models
.retain(|conn, _| host.hub.guest(*conn).is_some_and(|g| g.placed));
for g in host.hub.guests.iter().filter(|g| g.placed) {
let at = Vec3::new(
g.position[0],
g.position[1] - if g.sneaking { 0.125 } else { 0.0 },
g.position[2],
);
let m = host
.models
.entry(g.conn)
.or_insert_with(|| Mob::new(g.entity_id as u32, kind.clone(), at, g.yaw));
let (dx, dy, dz) = (
at.x - m.position.x,
at.y - m.position.y,
at.z - m.position.z,
);
m.previous = m.position;
m.position = at;
if dx * dx + dy * dy + dz * dz > 100.0 {
m.previous = at;
}
m.previous_yaw = m.yaw;
m.previous_body_yaw = m.body_yaw;
m.previous_head_yaw = m.head_yaw;
m.previous_head_pitch = m.head_pitch;
m.yaw = g.yaw;
m.head_yaw = g.head_yaw;
m.head_pitch = g.pitch;
let mut target = m.body_yaw;
if dx * dx + dz * dz > 0.002_500_000_2 {
target = (dz.atan2(dx) as f32).to_degrees() - 90.0;
}
let wrap = |a: f32| (a + 180.0).rem_euclid(360.0) - 180.0;
m.body_yaw += wrap(target - m.body_yaw) * 0.3;
let diff = wrap(g.yaw - m.body_yaw);
if diff.abs() > 50.0 {
m.body_yaw += diff - diff.signum() * 50.0;
}
let dist = (dx * dx + dz * dz).sqrt() as f32;
m.previous_limb_speed = m.limb_speed;
m.limb_speed += ((dist * 4.0).min(1.0) - m.limb_speed) * 0.4;
m.limb_position += m.limb_speed;
m.age = m.age.wrapping_add(1);
m.extra.main_hand = g
.inventory
.get(g.selected)
.and_then(|s| s.as_ref())
.map(|s| s.item.clone());
m.extra.off_hand = g.offhand.as_ref().map(|s| s.item.clone());
m.extra.crouching = g.sneaking;
}
}
/// The guests' models for the entity pass.
pub(super) fn guest_model_geometry(
&self,
camera: glam::DVec3,
alpha: f64,
out: &mut Vec<horizon_client::mesher::Vertex>,
) {
let Some(host) = &self.lan else {
return;
};
let atlas = &self.res.atlas;
let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]);
for m in host.models.values() {
let light = self.world.light(
m.position.x.floor() as i32,
(m.position.y + 1.62).floor() as i32,
m.position.z.floor() as i32,
);
let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
horizon_client::mobs::render::render_with(
m,
alpha as f32,
camera,
&lookup,
packed,
&self.res.mob_data,
&self.player_armor_layers(),
out,
);
}
}
/// A chat line the host typed, for the guests.
pub(super) fn lan_host_chat(&mut self, message: &str) {
if let Some(host) = &self.lan {
host.hub.chat(PLAYER_NAME, message);
}
}
}
@@ -0,0 +1,723 @@
//! What guests do in a hosted world. The host's gameplay code is written for
//! the one local player, so a guest's action runs through it with the guest's
//! state swapped in for the duration of the call (position, inventory, game
//! mode, experience, mining and item use): digging, placing, using items and
//! blocks, attacking and the commands all behave exactly as they do for the
//! host, and every world change they cause reaches all players through the
//! block log, the level events and the entity tracker.
use super::{Game, Hit, Mining, Screen, lan::LanHost};
use horizon_client::{
containers::BlockEntity,
entities::Experience,
items::ItemStack,
lan::{guest::SPECTATOR, menu::Rules},
motion::PlayerMotion,
};
use horizon_core::geometry::Vec3;
use horizon_protocol::{
packets::play::{self, Clientbound as C, Serverbound as S},
text::literal,
};
use winit::keyboard::KeyCode;
/// Per-guest state of the gameplay code that lives outside `Guest`.
#[derive(Default)]
pub(super) struct GuestPlay {
mining: Option<Mining>,
destroy_delay: u32,
using: Option<(usize, u32)>,
use_delay: u32,
attack_ticks: u32,
swing: Option<u32>,
swing_anim: (f32, f32),
/// The block being dug and the face the client aimed at.
digging: Option<([i32; 3], [i32; 3])>,
last_progress: i32,
/// Hand movements the client announced and the host animated.
swung: bool,
}
struct ItemRules<'a>(&'a horizon_client::items::Items);
impl Rules for ItemRules<'_> {
fn max_stack(&self, item: &str) -> u32 {
self.0.get(item).map_or(64, |i| i.max_stack)
}
fn armor_index(&self, item: &str) -> Option<usize> {
match self.0.get(item)?.equip_slot.as_deref()? {
"head" => Some(0),
"chest" => Some(1),
"legs" => Some(2),
"feet" => Some(3),
_ => None,
}
}
}
fn direction(face: i32) -> [i32; 3] {
match face {
0 => [0, -1, 0],
1 => [0, 1, 0],
2 => [0, 0, -1],
3 => [0, 0, 1],
4 => [-1, 0, 0],
_ => [1, 0, 0],
}
}
impl Game<'_> {
/// Run `f` as the guest `conn`: the host's player state is swapped for theirs.
pub(super) fn as_guest<R>(
&mut self,
host: &mut LanHost,
conn: u32,
f: impl FnOnce(&mut Self) -> R,
) -> Option<R> {
let i = host.hub.guests.iter().position(|g| g.conn == conn)?;
if host.hub.guests[i].motion.is_none() {
let p = Vec3::new(
host.hub.guests[i].position[0],
host.hub.guests[i].position[1],
host.hub.guests[i].position[2],
);
host.hub.guests[i].motion = PlayerMotion::new(self.motion, p).ok().map(Box::new);
}
let mut play = host.play.remove(&conn).unwrap_or_default();
let g = &mut host.hub.guests[i];
// The guest's body.
let mut motion = g.motion.take()?;
motion.position = Vec3::new(g.position[0], g.position[1], g.position[2]);
motion.ground.on_ground = g.on_ground;
motion.yaw = g.yaw;
motion.pitch = g.pitch;
motion.sprinting = g.sprinting;
motion.may_fly = g.creative() || g.game_mode == SPECTATOR;
motion.invulnerable = motion.may_fly;
let _ = motion.set_health(g.health, false);
motion.health.food.food = g.food;
motion.health.food.saturation = g.saturation;
let mut player = Some(*motion);
std::mem::swap(&mut self.player, &mut player);
let eye = (g.eye_height() as f32, self.eye);
self.eye = eye.0;
let (yaw, pitch) = (self.yaw, self.pitch);
self.yaw = g.yaw;
self.pitch = g.pitch;
std::mem::swap(&mut self.inventory, &mut g.inventory);
std::mem::swap(&mut self.armor, &mut g.armor);
std::mem::swap(&mut self.offhand, &mut g.offhand);
std::mem::swap(&mut self.carried, &mut g.carried);
let selected = std::mem::replace(&mut self.selected, g.selected);
let (mode, creative) = (self.mode, self.creative);
self.set_mode_raw(g.game_mode);
let xp = std::mem::replace(
&mut self.experience,
Experience {
level: g.xp_level,
progress: g.xp_progress,
total: g.xp_total,
},
);
let sneak = self.keys.contains(&KeyCode::ShiftLeft);
if g.sneaking {
self.keys.insert(KeyCode::ShiftLeft);
} else {
self.keys.remove(&KeyCode::ShiftLeft);
}
let screen = std::mem::replace(&mut self.screen, Screen::Playing);
let container = self.container.take();
let mining = std::mem::replace(&mut self.mining, play.mining.take());
let destroy_delay = std::mem::replace(&mut self.destroy_delay, play.destroy_delay);
let using = std::mem::replace(&mut self.using, play.using.take());
let use_delay = std::mem::replace(&mut self.use_delay, play.use_delay);
let attack_ticks = std::mem::replace(&mut self.attack_ticks, play.attack_ticks);
let swing = std::mem::replace(&mut self.swing, play.swing.take());
let swing_anim = std::mem::replace(&mut self.swing_anim, play.swing_anim);
let (left, right) = (self.left, self.right);
self.left = play.digging.is_some();
self.right = play.using.is_some() || self.using.is_some();
let riding = self.riding.take();
self.lan_acting = Some(conn);
let result = f(self);
self.lan_acting = None;
// What the action opened: handed to the guest instead of the host.
let opened = self.container.take();
self.riding = riding;
self.left = left;
self.right = right;
play.mining = std::mem::replace(&mut self.mining, mining);
play.destroy_delay = std::mem::replace(&mut self.destroy_delay, destroy_delay);
play.using = std::mem::replace(&mut self.using, using);
play.use_delay = std::mem::replace(&mut self.use_delay, use_delay);
play.attack_ticks = std::mem::replace(&mut self.attack_ticks, attack_ticks);
play.swing = std::mem::replace(&mut self.swing, swing);
play.swing_anim = std::mem::replace(&mut self.swing_anim, swing_anim);
self.container = container;
self.screen = screen;
if sneak {
self.keys.insert(KeyCode::ShiftLeft);
} else {
self.keys.remove(&KeyCode::ShiftLeft);
}
let g = &mut host.hub.guests[i];
let new_xp = std::mem::replace(&mut self.experience, xp);
g.xp_level = new_xp.level;
g.xp_progress = new_xp.progress;
g.xp_total = new_xp.total;
let new_mode = self.mode_id();
self.mode = mode;
self.creative = creative;
self.selected = std::mem::replace(&mut g.selected, selected);
// `g.selected` now holds the host's value: swap the inventories back.
std::mem::swap(&mut self.selected, &mut g.selected);
std::mem::swap(&mut self.inventory, &mut g.inventory);
std::mem::swap(&mut self.armor, &mut g.armor);
std::mem::swap(&mut self.offhand, &mut g.offhand);
std::mem::swap(&mut self.carried, &mut g.carried);
self.yaw = yaw;
self.pitch = pitch;
self.eye = eye.1;
std::mem::swap(&mut self.player, &mut player);
if let Some(mut m) = player {
g.health = m.health.health();
g.food = m.health.food.food;
g.saturation = m.health.food.saturation;
// A teleport (commands) moves the guest.
let at = [m.position.x, m.position.y, m.position.z];
m.sprinting = false;
let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum();
g.motion = Some(Box::new(m));
if moved > 0.0001 {
host.hub.teleport(i, Some(at));
}
}
let g = &mut host.hub.guests[i];
if new_mode != g.game_mode {
let conn = g.conn;
host.hub.set_game_mode(conn, new_mode);
}
host.play.insert(conn, play);
if let Some(pos) = opened {
self.lan_open_container(host, conn, pos);
}
Some(result)
}
/// The game mode fields without `set_mode`'s side effects on the host.
fn set_mode_raw(&mut self, id: i32) {
use horizon_client::command::args::GameMode;
self.mode = match id {
1 => GameMode::Creative,
2 => GameMode::Adventure,
3 => GameMode::Spectator,
_ => GameMode::Survival,
};
self.creative = self.mode == GameMode::Creative;
}
/// Hand a container the guest opened over (ServerPlayer.openMenu).
fn lan_open_container(&mut self, host: &mut LanHost, conn: u32, pos: (i32, i32, i32)) {
let Some(entity) = self.world.block_entities.get(&pos) else {
return;
};
let (menu, title) = match entity {
BlockEntity::Chest(items) => match items.len() {
27 => ("minecraft:generic_9x3", "container.chest"),
9 => ("minecraft:generic_3x3", "container.dispenser"),
5 => ("minecraft:hopper", "container.hopper"),
_ => return,
},
_ => return,
};
let name = &self
.res
.facts
.get(self.world.block(pos.0, pos.1, pos.2))
.name;
let title = match &**name {
"minecraft:barrel" => "container.barrel",
"minecraft:dropper" => "container.dropper",
n if n.ends_with("shulker_box") => "container.shulkerBox",
_ => title,
};
let items = entity.slots().to_vec();
host.hub.open_container(
conn,
menu,
horizon_protocol::text::translatable(title, &[]),
pos,
items,
);
}
/// A packet from a guest that the hub does not handle itself.
pub(super) fn lan_guest_packet(&mut self, host: &mut LanHost, conn: u32, packet: S) {
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
return;
};
if host.hub.guests[gi].dead && !matches!(packet, S::ClientCommand(_)) {
return;
}
let spectator = host.hub.guests[gi].spectator();
match packet {
S::PlayerAction(a) => match a.action {
0 => {
host.hub.ack(conn, a.sequence);
if spectator {
return;
}
let face = direction(i32::from(a.direction));
let play = host.play.entry(conn).or_default();
play.digging = Some((a.pos, face));
play.last_progress = -1;
}
1 => {}
2 | 3 => {
host.hub.ack(conn, a.sequence);
let play = host.play.entry(conn).or_default();
play.digging = None;
play.mining = None;
if a.action == 2 {
let state = self.world.block(a.pos[0], a.pos[1], a.pos[2]).0 as i32;
host.hub.send_to(
conn,
&C::BlockUpdate(play::BlockUpdate { pos: a.pos, state }),
);
host.hub.broadcast_near(
[
f64::from(a.pos[0]),
f64::from(a.pos[1]),
f64::from(a.pos[2]),
],
64.0,
&C::BlockDestruction(play::BlockDestruction {
id: host.hub.guests[gi].entity_id,
pos: a.pos,
progress: 255,
}),
Some(conn),
);
}
}
4 | 5 => {
if !spectator {
self.as_guest(host, conn, |g| g.drop_held(a.action == 4));
}
}
6 => {
self.as_guest(host, conn, |g| {
if let Some((slot, ticks)) = g.using.take()
&& g.stack_in(slot)
.is_some_and(|s| &*s.item == "minecraft:bow")
{
g.release_bow(ticks);
}
});
}
7 => {
let g = &mut host.hub.guests[gi];
let slot = g.selected;
std::mem::swap(&mut g.inventory[slot], &mut g.offhand);
}
_ => {}
},
S::SetCarriedItem(p) => {
if (0..9).contains(&p.slot) {
host.hub.guests[gi].selected = p.slot as usize;
if let Some(play) = host.play.get_mut(&conn) {
play.using = None;
}
}
}
S::UseItemOn(p) => {
host.hub.ack(conn, p.sequence);
if spectator {
return;
}
let face = direction(p.face);
let hit = Hit {
pos: p.pos,
face,
point: [
f64::from(p.pos[0]) + f64::from(p.cursor[0]),
f64::from(p.pos[1]) + f64::from(p.cursor[1]),
f64::from(p.pos[2]) + f64::from(p.cursor[2]),
],
};
self.as_guest(host, conn, |g| {
g.forced_hit = Some(hit);
let _ = g.use_item();
g.forced_hit = None;
});
// The client predicted a result: correct it with what really is.
for pos in [
p.pos,
[p.pos[0] + face[0], p.pos[1] + face[1], p.pos[2] + face[2]],
] {
let state = self.world.block(pos[0], pos[1], pos[2]).0 as i32;
host.hub
.send_to(conn, &C::BlockUpdate(play::BlockUpdate { pos, state }));
}
}
S::UseItem(p) => {
host.hub.ack(conn, p.sequence);
if spectator {
return;
}
self.as_guest(host, conn, |g| {
let _ = g.use_item();
});
}
S::Attack(p) => self.guest_attack(host, conn, p.id),
S::Interact(p) => {
if let Some((position, eye)) = self.look_at_entity(host, gi, p.id) {
let _ = (position, eye);
self.as_guest(host, conn, |g| {
let _ = g.use_item();
});
}
}
S::SetCreativeModeSlot(p) => {
let g = &mut host.hub.guests[gi];
if !g.creative() || !(0..46).contains(&p.slot) {
return;
}
let item = self.item_from_network(host, &p.item);
host.hub.guests[gi].set_menu_slot(p.slot as usize, item);
}
S::ContainerClick(p) => {
let rules = ItemRules(&self.res.items);
let drops = host.hub.container_click(conn, p, &mut self.world, &rules);
self.drop_guest_items(host, gi, drops);
}
S::ContainerClose(p) => {
host.hub.container_closed(conn, p.container);
let g = &mut host.hub.guests[gi];
if let Some(c) = g.carried.take() {
self.drop_guest_items(host, gi, vec![c]);
}
}
S::ChatCommand(c) => self.guest_command(host, conn, &c.command),
S::Unknown(8, payload) => {
// A signed command: the text comes first.
if let Ok(text) = horizon_protocol::buf::Reader::new(&payload).string(32767) {
self.guest_command(host, conn, &text);
}
}
S::ClientCommand(c) if c.action == 0 => self.guest_respawn(host, conn),
S::PickItemFromBlock(p) => {
let state = self.world.block(p.pos[0], p.pos[1], p.pos[2]);
let item = self.res.facts.get(state).item.clone();
let g = &mut host.hub.guests[gi];
if g.creative() && &*item != "minecraft:air" {
let slot = g.selected;
g.inventory[slot] = Some(ItemStack::new(&item, 1));
}
}
_ => {}
}
}
fn item_from_network(
&self,
host: &LanHost,
stack: &Option<horizon_protocol::item::Stack>,
) -> Option<ItemStack> {
use horizon_protocol::item::{Component, component};
let s = stack.as_ref()?;
let name = host
.hub
.item_name(s.item)
.unwrap_or_else(|| "minecraft:air".into());
let mut out = ItemStack::new(&name, s.count.max(1) as u32);
out.damage = s.damage().max(0) as u32;
if let Some(Component::Enchantments(list)) = s.component(component::ENCHANTMENTS) {
for (id, level) in list {
if let Some(e) = host.hub.enchantment_name(*id) {
out.enchant(&e, *level as u32);
}
}
}
Some(out)
}
fn drop_guest_items(&mut self, host: &LanHost, gi: usize, stacks: Vec<ItemStack>) {
let g = &host.hub.guests[gi];
let eye = [
g.position[0],
g.position[1] + g.eye_height() - 0.3,
g.position[2],
];
let (yaw, pitch) = (
f64::from(g.yaw).to_radians(),
f64::from(g.pitch).to_radians(),
);
for stack in stacks {
let v = [
-yaw.sin() * pitch.cos() * 0.3,
-pitch.sin() * 0.3 + 0.1,
yaw.cos() * pitch.cos() * 0.3,
];
self.spawn_item(stack, eye, v, 40);
}
}
/// Aim the swapped-in player at an entity; returns its centre and the eye.
fn look_at_entity(
&mut self,
host: &mut LanHost,
gi: usize,
id: i32,
) -> Option<([f64; 3], [f64; 3])> {
let m = self.mobs.iter().find(|m| m.id as i32 == id)?;
let centre = [
m.position.x,
m.position.y + m.kind.height * 0.5,
m.position.z,
];
let g = &mut host.hub.guests[gi];
let eye = [g.position[0], g.position[1] + g.eye_height(), g.position[2]];
let d = [centre[0] - eye[0], centre[1] - eye[1], centre[2] - eye[2]];
let horizontal = (d[0] * d[0] + d[2] * d[2]).sqrt();
g.yaw = (-d[0].atan2(d[2])).to_degrees() as f32;
g.pitch = (-d[1].atan2(horizontal)).to_degrees() as f32;
Some((centre, eye))
}
fn guest_attack(&mut self, host: &mut LanHost, conn: u32, id: i32) {
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
return;
};
if host.hub.guests[gi].spectator() {
return;
}
let (old_yaw, old_pitch) = (host.hub.guests[gi].yaw, host.hub.guests[gi].pitch);
if self.look_at_entity(host, gi, id).is_none() {
return;
}
self.as_guest(host, conn, |g| {
g.attack();
});
host.hub.guests[gi].yaw = old_yaw;
host.hub.guests[gi].pitch = old_pitch;
}
/// Commands.performCommand for a guest with command access.
fn guest_command(&mut self, host: &mut LanHost, conn: u32, command: &str) {
if !host.settings.guest_commands || !self.cheats {
host.hub.send_to(
conn,
&C::SystemChat(play::SystemChat {
content: horizon_protocol::text::translatable("command.unknown.command", &[]),
overlay: false,
}),
);
return;
}
let command = command.trim_start_matches('/').to_owned();
let lines = self.as_guest(host, conn, |g| {
g.chat_capture = Some(Vec::new());
g.run_command(&command);
g.chat_capture.take().unwrap_or_default()
});
for line in lines.unwrap_or_default() {
host.hub.send_to(
conn,
&C::SystemChat(play::SystemChat {
content: literal(&line),
overlay: false,
}),
);
}
}
fn guest_respawn(&mut self, host: &mut LanHost, conn: u32) {
let spawn = self.spawn.map_or([0.5, 80.0, 0.5], |s| [s.x, s.y, s.z]);
let Some(i) = host.hub.guests.iter().position(|g| g.conn == conn) else {
return;
};
if !host.hub.guests[i].dead {
return;
}
let g = &mut host.hub.guests[i];
g.dead = false;
g.health = 20.0;
g.food = 20;
g.saturation = 5.0;
g.sent_health = None;
g.motion = None;
host.hub.respawn(i, spawn);
}
/// Per tick, for every guest: dig, use items, pick up drops, die.
pub(super) fn tick_guests(&mut self, host: &mut LanHost) {
let conns: Vec<u32> = host
.hub
.guests
.iter()
.filter(|g| g.placed && g.loaded)
.map(|g| g.conn)
.collect();
for conn in conns {
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
continue;
};
if host.hub.guests[gi].dead {
continue;
}
let play = host.play.entry(conn).or_default();
let digging = play.digging;
let using = play.using.is_some();
let delayed = play.destroy_delay > 0 || play.use_delay > 0 || play.attack_ticks < 100;
if digging.is_some() || using || delayed {
self.as_guest(host, conn, |g| {
g.attack_ticks = g.attack_ticks.saturating_add(1);
if let Some((pos, face)) = digging {
g.forced_hit = Some(Hit {
pos,
face,
point: [
f64::from(pos[0]) + 0.5,
f64::from(pos[1]) + 0.5,
f64::from(pos[2]) + 0.5,
],
});
}
let _ = g.tick_mining();
g.forced_hit = None;
g.right = g.using.is_some();
g.tick_using();
if g.use_delay > 0 {
g.use_delay -= 1;
}
});
}
self.guest_dig_feedback(host, conn);
self.guest_pickups(host, gi);
let g = &mut host.hub.guests[gi];
if g.health <= 0.0 && !g.dead {
g.dead = true;
let message = literal(&format!("{} died", g.name));
host.hub.send_to(
conn,
&C::PlayerCombatKill(play::PlayerCombatKill {
id: host.hub.guests[gi].entity_id,
message,
}),
);
}
}
}
/// The crack animation other players see.
fn guest_dig_feedback(&mut self, host: &mut LanHost, conn: u32) {
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
return;
};
let play = host.play.entry(conn).or_default();
let Some((pos, _)) = play.digging else {
return;
};
let progress = play
.mining
.as_ref()
.map_or(-1, |m| (m.progress.clamp(0.0, 1.0) * 10.0) as i32 - 1);
let swinging = play.swing.is_some();
if progress != play.last_progress && progress >= 0 {
play.last_progress = progress;
host.hub.broadcast_near(
[f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])],
64.0,
&C::BlockDestruction(play::BlockDestruction {
id: host.hub.guests[gi].entity_id,
pos,
progress: progress as u8,
}),
Some(conn),
);
}
let _ = swinging;
}
/// Dropped items touching a guest go into their inventory.
fn guest_pickups(&mut self, host: &mut LanHost, gi: usize) {
let (conn, mode, position, id) = {
let g = &host.hub.guests[gi];
(g.conn, g.game_mode, g.position, g.entity_id)
};
if mode == SPECTATOR || self.dropped.is_empty() {
return;
}
let near: Vec<usize> = self
.dropped
.iter()
.enumerate()
.filter(|(_, d)| {
d.pickup_delay == 0
&& (d.position.x - position[0]).abs() < 1.5
&& (d.position.z - position[2]).abs() < 1.5
&& d.position.y > position[1] - 0.6
&& d.position.y < position[1] + 2.4
})
.map(|(i, _)| i)
.collect();
let mut taken = Vec::new();
for i in near.into_iter().rev() {
let (stack, item_id) = (self.dropped[i].stack.clone(), self.dropped[i].id);
let before = stack.count;
let rest = self.as_guest(host, conn, |g| g.give(stack)).flatten();
match rest {
None => {
self.dropped.remove(i);
taken.push((item_id, before));
}
Some(rest) if rest.count < before => {
self.dropped[i].stack = rest;
taken.push((item_id, before - self.dropped[i].stack.count));
}
Some(_) => {}
}
}
for (item, count) in taken {
host.hub.take_item(item as i32, id, count as i32, position);
host.hub
.sound("minecraft:entity.item.pickup", position, 0.2, 1.4, 7, None);
}
}
/// Positional sounds and level events of the tick, for the guests.
pub(super) fn lan_broadcast_effects(&mut self, host: &mut LanHost) {
let sounds = self.audio.capture.take().unwrap_or_default();
self.audio.capture = Some(Vec::new());
let blocks: Vec<[f64; 3]> = std::mem::take(&mut host.broken);
for (name, at, volume, pitch) in sounds {
// Block breaks are heard through the level event.
if blocks
.iter()
.any(|b| (0..3).all(|k| (b[k] + 0.5 - at[k]).abs() < 1e-6))
{
continue;
}
let source = horizon_client::settings::sound_source(&name) as i32;
host.hub.sound(&name, at, volume, pitch, source, None);
}
}
/// Guests' arm swings for everyone else.
pub(super) fn lan_swings(&mut self, host: &mut LanHost) {
let conns: Vec<u32> = host.play.keys().copied().collect();
for conn in conns {
let Some(g) = host.hub.guests.iter().find(|g| g.conn == conn) else {
continue;
};
let (id, at) = (g.entity_id, g.position);
let play = host.play.get_mut(&conn).expect("play");
let swinging = play.swing == Some(0);
if swinging && !play.swung {
host.hub.swing(id, 0, at, Some(conn));
}
play.swung = swinging;
}
}
}
@@ -0,0 +1,371 @@
//! WorldOptionsScreen: the in-world options with the multiplayer section
//! that opens the world to the local network (the 26.3 replacement of the
//! old "Open to LAN" screen): default and personal game mode, cheats,
//! difficulty, LAN on/off with its port, command access for guests and
//! forcing the game mode.
use super::{Game, Screen, lan::LanSettings};
use horizon_client::{
hud::{HudBatch, rgba},
text::Text,
ui::{self, EditBox},
};
use winit::{event::KeyEvent, keyboard::PhysicalKey};
pub(super) struct WorldOptions {
default_mode: i32,
personal_mode: i32,
cheats: bool,
difficulty: u8,
lan: bool,
port: EditBox,
/// The free port suggested while the box is empty.
hint: u16,
guest_commands: bool,
force: bool,
initial: Snapshot,
}
#[derive(Clone, PartialEq)]
struct Snapshot {
default_mode: i32,
personal_mode: i32,
cheats: bool,
difficulty: u8,
lan: bool,
port: u16,
guest_commands: bool,
force: bool,
}
const MODES: [&str; 4] = ["survival", "creative", "adventure", "spectator"];
const DIFFICULTIES: [&str; 4] = ["peaceful", "easy", "normal", "hard"];
#[derive(Clone, Copy, PartialEq)]
enum Button {
DefaultMode,
PersonalMode,
Cheats,
Difficulty,
Lan,
CommandAccess,
Force,
Apply,
Cancel,
}
fn on_off(on: bool) -> Text {
Text::translate(if on { "options.on" } else { "options.off" }, &[])
}
fn labelled(key: &str, value: Text) -> Text {
Text::translate("options.generic_value", &[Text::translate(key, &[]), value])
}
impl WorldOptions {
fn parsed_port(&self) -> Option<u16> {
if self.port.value.is_empty() {
return Some(self.hint);
}
self.port.value.parse::<u16>().ok().filter(|p| *p >= 1024)
}
fn snapshot(&self) -> Snapshot {
Snapshot {
default_mode: self.default_mode,
personal_mode: self.personal_mode,
cheats: self.cheats,
difficulty: self.difficulty,
lan: self.lan,
port: if self.lan {
self.parsed_port().unwrap_or(0)
} else {
0
},
guest_commands: self.guest_commands && self.lan && self.cheats,
force: self.force,
}
}
fn changed(&self) -> bool {
let valid = !self.lan || self.parsed_port().is_some();
valid && self.snapshot() != self.initial
}
fn buttons(w: f32) -> Vec<(Button, f32, f32, f32)> {
let x = (w / 2.0 - 154.0).floor();
let right = x + 158.0;
vec![
(Button::DefaultMode, x, 38.0, 308.0),
(Button::PersonalMode, x, 62.0, 308.0),
(Button::Cheats, x, 86.0, 150.0),
(Button::Difficulty, right, 86.0, 150.0),
(Button::Lan, x, 126.0, 150.0),
(Button::CommandAccess, x, 150.0, 150.0),
(Button::Force, right, 150.0, 150.0),
]
}
fn footer(w: f32, h: f32) -> [(Button, f32, f32, f32); 2] {
let x = (w / 2.0 - 154.0).floor();
[
(Button::Apply, x, h - 28.0, 150.0),
(Button::Cancel, x + 158.0, h - 28.0, 150.0),
]
}
fn label(&self, b: Button) -> Text {
let mode = |m: i32| {
Text::translate(
&format!("selectWorld.gameMode.{}", MODES[m as usize & 3]),
&[],
)
};
match b {
Button::DefaultMode => {
labelled("options.worldOptions.game_mode", mode(self.default_mode))
}
Button::PersonalMode => labelled(
"options.worldOptions.personal_game_mode",
mode(self.personal_mode),
),
Button::Cheats => labelled("selectWorld.allowCommands", on_off(self.cheats)),
Button::Difficulty => labelled(
"options.difficulty",
Text::translate(
&format!(
"options.difficulty.{}",
DIFFICULTIES[usize::from(self.difficulty) & 3]
),
&[],
),
),
Button::Lan => labelled("menu.multiplayerOptions.lan", on_off(self.lan)),
Button::CommandAccess => labelled(
"options.worldOptions.guest.command_access",
on_off(self.guest_commands && self.lan && self.cheats),
),
Button::Force => labelled(
"options.worldOptions.guest.force_game_mode",
on_off(self.force || !self.lan),
),
Button::Apply => Text::translate("menu.multiplayerOptions.applyChanges", &[]),
Button::Cancel => Text::translate("gui.cancel", &[]),
}
}
fn active(&self, b: Button) -> bool {
match b {
Button::CommandAccess => self.lan && self.cheats,
Button::Force => self.lan && !(self.guest_commands && self.cheats),
Button::Apply => self.changed(),
_ => true,
}
}
}
impl Game<'_> {
pub(super) fn open_world_options(&mut self) {
let hint = horizon_client::lan::available_port();
let lan = self.lan.is_some();
let mut port = EditBox::new(0.0, 0.0, 150.0, 20.0);
port.max_length = 5;
let (guest_commands, force) = self.lan.as_ref().map_or((false, true), |h| {
(h.settings.guest_commands, h.settings.force_game_mode)
});
if let Some(p) = self.lan_port() {
port.set_value(&p.to_string());
}
let mut options = WorldOptions {
default_mode: self.level.mode(),
personal_mode: self.mode_id(),
cheats: self.cheats,
difficulty: self.ui.difficulty,
lan,
port,
hint,
guest_commands,
force,
initial: Snapshot {
default_mode: 0,
personal_mode: 0,
cheats: false,
difficulty: 0,
lan: false,
port: 0,
guest_commands: false,
force: false,
},
};
options.initial = options.snapshot();
self.world_options = Some(options);
self.screen = Screen::WorldOptions;
}
pub(super) fn close_world_options(&mut self) {
self.world_options = None;
self.screen = Screen::Paused;
}
pub(super) fn draw_world_options(&mut self, batch: &mut HudBatch) {
let Some(mut o) = self.world_options.take() else {
return;
};
let atlas = &self.res.atlas;
let (w, h) = (batch.width, batch.height);
ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
let centered = |batch: &mut HudBatch, key: &str, y: f32| {
let t = Text::translate(key, &[]);
let tw = atlas.font.width_text(&t);
batch.text_styled(atlas, &t, ((w - tw) / 2.0).floor(), y, u32::MAX, true);
};
centered(batch, "options.worldOptions.title", 12.0);
centered(batch, "options.worldOptions.general.title", 26.0);
centered(batch, "options.worldOptions.multiplayer.title", 114.0);
for (b, x, y, bw) in WorldOptions::buttons(w)
.into_iter()
.chain(WorldOptions::footer(w, h))
{
let active = o.active(b);
let hover = active && ui::hovered(self.cursor, x, y, bw, 20.0);
ui::button(batch, atlas, x, y, bw, 20.0, &o.label(b), active, hover);
}
// The port box sits beside the LAN button.
let x = (w / 2.0 - 154.0).floor() + 158.0;
o.port.x = x;
o.port.y = 126.0;
o.port.focused = o.lan && o.port.focused;
if o.lan {
o.port.draw(batch, atlas, None);
if o.port.value.is_empty() {
let hint = Text::literal(o.hint.to_string());
batch.text_styled(
atlas,
&hint,
x + 4.0,
132.0,
rgba(160, 160, 160, 255),
false,
);
}
if o.parsed_port().is_none() {
let t = Text::translate(
"lanServer.port.invalid.new",
&[Text::literal("1024"), Text::literal("65535")],
);
let first = t.clone();
batch.text_styled(atlas, &first, x, 148.0, rgba(255, 85, 85, 255), true);
}
} else {
ui::button(
batch,
atlas,
x,
126.0,
150.0,
20.0,
&Text::translate("lanServer.port", &[]),
false,
false,
);
}
self.world_options = Some(o);
}
pub(super) fn world_options_click(&mut self) {
let Some(mut o) = self.world_options.take() else {
return;
};
let size = self
.renderer
.as_ref()
.map_or([1, 1], |r| [r.config.width, r.config.height]);
let b = HudBatch::new(size);
let (w, h) = (b.width, b.height);
let port_x = (w / 2.0 - 154.0).floor() + 158.0;
o.port.focused = o.lan && ui::hovered(self.cursor, port_x, 126.0, 150.0, 20.0);
let hit = WorldOptions::buttons(w)
.into_iter()
.chain(WorldOptions::footer(w, h))
.find(|(button, x, y, bw)| {
o.active(*button) && ui::hovered(self.cursor, *x, *y, *bw, 20.0)
})
.map(|b| b.0);
match hit {
Some(Button::DefaultMode) => o.default_mode = (o.default_mode + 1) % 4,
Some(Button::PersonalMode) => o.personal_mode = (o.personal_mode + 1) % 4,
Some(Button::Cheats) => o.cheats = !o.cheats,
Some(Button::Difficulty) => o.difficulty = (o.difficulty + 1) % 4,
Some(Button::Lan) => {
o.lan = !o.lan;
o.port.focused = false;
}
Some(Button::CommandAccess) => o.guest_commands = !o.guest_commands,
Some(Button::Force) => o.force = !o.force,
Some(Button::Cancel) => {
self.world_options = Some(o);
self.close_world_options();
return;
}
Some(Button::Apply) => {
let wanted = o.snapshot();
let before = o.initial.clone();
self.world_options = Some(o);
self.apply_world_options(&before, &wanted);
self.close_world_options();
self.screen = Screen::Playing;
self.capture(true);
return;
}
None => {}
}
self.world_options = Some(o);
}
pub(super) fn world_options_key(&mut self, event: &KeyEvent) {
if event.state != winit::event::ElementState::Pressed {
return;
}
let PhysicalKey::Code(key) = event.physical_key else {
return;
};
let ctrl = self.keys.contains(&winit::keyboard::KeyCode::ControlLeft);
let Some(o) = self.world_options.as_mut() else {
return;
};
if !o.port.focused {
return;
}
if !o.port.key(key, ctrl, false)
&& !ctrl
&& let Some(text) = &event.text
{
let digits: String = text.chars().filter(char::is_ascii_digit).collect();
if !digits.is_empty() {
o.port.insert_text(&digits);
}
}
}
fn apply_world_options(&mut self, before: &Snapshot, wanted: &Snapshot) {
if wanted.difficulty != before.difficulty {
let name = DIFFICULTIES[usize::from(wanted.difficulty) & 3];
self.run_command(&format!("difficulty {name}"));
}
if wanted.default_mode != before.default_mode {
self.set_default_game_mode(wanted.default_mode);
}
if wanted.personal_mode != before.personal_mode {
self.set_mode_id(wanted.personal_mode);
}
self.cheats = wanted.cheats;
let settings_changed =
wanted.guest_commands != before.guest_commands || wanted.force != before.force;
if wanted.lan != before.lan || (wanted.lan && wanted.port != before.port) {
self.lan_close(before.lan);
if wanted.lan {
let opened = self.lan_open(LanSettings {
port: wanted.port,
guest_commands: wanted.guest_commands,
force_game_mode: wanted.force,
});
if opened.is_err() {
self.system_message(Text::translate("commands.publish.failed", &[]));
}
}
} else if settings_changed {
self.lan_apply_settings(wanted.guest_commands, wanted.force);
}
}
}
+7 -1
View File
@@ -58,7 +58,13 @@ impl Game<'_> {
&& !below.ends_with("lightning_rod");
if trap {
let at = [f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])];
let _ = self.spawn_mob("minecraft:skeleton_horse", at, false);
// ServerLevel.tickChunk: a trap horse waits for a player.
if let Some(id) = self.spawn_mob("minecraft:skeleton_horse", at, false)
&& let Some(h) = self.mobs.iter_mut().find(|m| m.id == id)
{
h.extra.trap = true;
h.extra.age = 0;
}
}
let at = [
f64::from(pos[0]) + 0.5,
@@ -0,0 +1,295 @@
//! Blocks mobs carry: block items in a hand (`ItemInHandLayer`) and the
//! block an enderman holds (`CarriedBlockLayer`), drawn as shaded cubes like
//! dropped block items.
use super::{Game, Icon};
use horizon_client::{
mesher::Vertex,
mobs::{Mob, Species, render},
};
/// The six faces of the unit cube with their shade: top, bottom, the two
/// z faces, the two x faces.
const FACES: [([[f32; 3]; 4], f32, u8); 6] = [
(
[[0., 1., 1.], [1., 1., 1.], [1., 1., 0.], [0., 1., 0.]],
1.0,
0,
),
(
[[0., 0., 0.], [1., 0., 0.], [1., 0., 1.], [0., 0., 1.]],
0.5,
0,
),
(
[[1., 0., 0.], [0., 0., 0.], [0., 1., 0.], [1., 1., 0.]],
0.8,
1,
),
(
[[0., 0., 1.], [1., 0., 1.], [1., 1., 1.], [0., 1., 1.]],
0.8,
1,
),
(
[[0., 0., 0.], [0., 0., 1.], [0., 1., 1.], [0., 1., 0.]],
0.6,
2,
),
(
[[1., 0., 1.], [1., 0., 0.], [1., 1., 0.], [1., 1., 1.]],
0.6,
2,
),
];
/// The sprites of a cube's top, z sides and x sides, and the top's tint.
struct Cube<'a> {
sprites: [&'a str; 3],
tint: u32,
}
/// `CustomHeadLayer.translateToHead` and the banner's `head` display.
fn banner_matrix(head: glam::Mat4) -> glam::Mat4 {
head * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.25, 0.0))
* glam::Mat4::from_rotation_y(std::f32::consts::PI)
* glam::Mat4::from_scale(glam::Vec3::new(0.625, -0.625, -0.625))
* glam::Mat4::from_translation(glam::Vec3::new(0.0, 1.0, 7.0 / 16.0))
* glam::Mat4::from_rotation_y(std::f32::consts::PI)
* glam::Mat4::from_scale(glam::Vec3::splat(1.5))
* glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.5, 0.0))
* glam::Mat4::from_scale(glam::Vec3::new(2.0 / 3.0, -2.0 / 3.0, -2.0 / 3.0))
}
/// `ElderGuardianParticle.lifetime`.
pub(super) const APPARITION_TICKS: i32 = 30;
impl Game<'_> {
/// Count the elder guardian's apparition down.
pub(super) fn tick_apparition(&mut self) {
self.creatures.elder_apparition = (self.creatures.elder_apparition - 1).max(0);
}
/// `ElderGuardianParticleGroup`: the ghostly elder guardian that swings
/// up in front of the camera while the curse is laid, fading in and out.
pub(super) fn elder_apparition_geometry(&self, alpha: f64, out: &mut Vec<Vertex>) {
let left = self.creatures.elder_apparition;
if left <= 0 {
return;
}
let Some(kind) = self.res.mob_types.get("minecraft:elder_guardian") else {
return;
};
let Some(r) = self.res.atlas.sprites.get("entity/guardian_elder").copied() else {
return;
};
let age = (APPARITION_TICKS - left) as f32 + alpha as f32;
let t = (age / APPARITION_TICKS as f32).clamp(0.0, 1.0);
let fade = 0.05 + 0.5 * (t * std::f32::consts::PI).sin();
let color = (((fade * 255.0) as u32) << 24) | 0x00FF_FFFF;
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();
// The camera's rotation: local +x right, +y up, +z behind.
let camera = glam::Mat4::from_cols(
right.extend(0.0),
up.extend(0.0),
(-forward).extend(0.0),
glam::Vec4::W,
);
let k = 0.425_531_92;
let m = camera
* glam::Mat4::from_rotation_x((60.0 - 150.0 * t).to_radians())
* glam::Mat4::from_scale(glam::Vec3::new(k, -k, -k))
* glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.56, 3.5));
let poses = horizon_client::mobs::anim::Poses::new(&kind.model);
render::draw(
&kind.model,
m,
&poses,
[r.u0, r.v0, r.u1, r.v1],
color,
240 | 240 << 8,
0,
out,
);
}
/// The ominous banner a raid captain wears on its head: the banner model
/// with its eight pattern layers (`CustomHeadLayer`).
fn captain_banner_geometry(
&self,
mob: &Mob,
camera: glam::DVec3,
alpha: f64,
light: u32,
out: &mut Vec<Vertex>,
) {
use horizon_client::mobs::{Part, anim::Poses, load_model};
static MODELS: std::sync::OnceLock<Option<(Part, Part)>> = std::sync::OnceLock::new();
if !horizon_client::mobs::raider::is_captain(mob) {
return;
}
let Some((pole, flag)) = MODELS.get_or_init(|| {
let root = &self.options.resources;
Some((
load_model(root, "minecraft:standing_banner#main")?,
load_model(root, "minecraft:standing_banner#flag")?,
))
}) else {
return;
};
let Some(head) =
render::part_transform(mob, alpha as f32, camera, &self.res.mob_data, "head")
else {
return;
};
let m = banner_matrix(head);
let atlas = &self.res.atlas;
let uv = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]);
// BannerRenderer: the flag sways with a per-banner phase.
let phase =
(((u64::from(mob.id) * 7 + u64::from(mob.age)) % 100) as f32 + alpha as f32) / 100.0;
let mut flag_poses = Poses::new(flag);
flag_poses.xrot(
"flag",
(-0.0125 + 0.01 * (2.0 * std::f32::consts::PI * phase).cos()) * std::f32::consts::PI,
);
let still = Poses::new(pole);
let white = 0xFFFF_FFFF;
if let Some(r) = uv("entity/banner/banner_base") {
render::draw(pole, m, &still, r, white, light, 0, out);
render::draw(flag, m, &flag_poses, r, white, light, 0, out);
}
let layers =
std::iter::once(("base", "white")).chain(horizon_client::item_data::OMINOUS_LAYERS);
for (pattern, dye) in layers {
let Some(r) = uv(&format!("entity/banner/{pattern}")) else {
continue;
};
let index = render::DYE_NAMES
.iter()
.position(|n| *n == dye)
.unwrap_or(0);
let color = render::abgr(render::DYE[index]);
render::draw(flag, m, &flag_poses, r, color, light, 0, out);
}
}
/// Resolve the icons of the items mobs hold, so drawing can look them up.
pub(super) fn cache_mob_icons(&mut self) {
let items: Vec<String> = self
.mobs
.iter()
.filter(|m| m.extra.main_hand.is_some() || m.extra.off_hand.is_some())
.flat_map(|m| [m.extra.main_hand.clone(), m.extra.off_hand.clone()])
.flatten()
.map(|i| i.to_string())
.collect();
for item in items {
if !self.res.icons.contains_key(&item) {
let _ = self.icon(&item);
}
}
}
fn push_cube(
&self,
t: glam::Mat4,
cube: &Cube,
light: u32,
overlay: u32,
out: &mut Vec<Vertex>,
) {
for (corners, shade, side) in FACES {
let name = cube.sprites[usize::from(side)];
let Some(r) = self.res.atlas.sprites.get(name).copied() else {
continue;
};
let tint = if side == 0 { cube.tint } else { 0xFF_FFFF };
let c = |sft: u32| (((tint >> sft) & 255) as f32 * shade) as u32;
let color = 0xFF00_0000 | c(0) << 16 | c(8) << 8 | c(16);
let uvs = [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]];
for (corner, uv) in corners.iter().zip(uvs) {
let p = t.transform_point3(glam::Vec3::from(*corner));
out.push(Vertex {
pos: p.to_array(),
uv,
layer: overlay,
color,
light,
});
}
}
}
/// The blocks one mob holds or carries.
pub(super) fn mob_block_geometry(
&self,
mob: &Mob,
camera: glam::DVec3,
alpha: f64,
light: u32,
out: &mut Vec<Vertex>,
) {
let overlay = u32::from(mob.hurt_time > 0);
self.captain_banner_geometry(mob, camera, alpha, light, out);
for (item, left) in [(&mob.extra.main_hand, false), (&mob.extra.off_hand, true)] {
let Some(item) = item else { continue };
let Some(Icon::Cube {
top,
left: z,
right: x,
tint,
}) = self.res.icons.get(&**item).cloned().flatten()
else {
continue;
};
let Some(t) =
render::held_block_transform(mob, alpha as f32, camera, &self.res.mob_data, left)
else {
continue;
};
let slot = if left {
horizon_client::mobs::gear::OFF
} else {
horizon_client::mobs::gear::MAIN
};
let glint = horizon_client::mobs::gear::enchanted(mob, slot);
let overlay = if glint { 7 } else { overlay };
self.push_cube(
t,
&Cube {
sprites: [&top, &z, &x],
tint,
},
light,
overlay,
out,
);
}
if mob.species() == Species::Enderman
&& let Some(state) = mob.extra.carried
&& let Some((sprite, tint)) = self.particle_sprite(state)
{
// CarriedBlockLayer.
let base = render::base_transform(mob, alpha as f32, camera);
let t = base
* glam::Mat4::from_translation(glam::Vec3::new(0.0, 0.6875, -0.75))
* glam::Mat4::from_rotation_x(20.0f32.to_radians())
* glam::Mat4::from_rotation_y(45.0f32.to_radians())
* glam::Mat4::from_translation(glam::Vec3::new(0.25, 0.1875, 0.25))
* glam::Mat4::from_scale(glam::Vec3::new(-0.5, -0.5, 0.5))
* glam::Mat4::from_rotation_y(90.0f32.to_radians())
* glam::Mat4::from_translation(glam::Vec3::splat(-0.5));
self.push_cube(
t,
&Cube {
sprites: [&sprite, &sprite, &sprite],
tint,
},
light,
overlay,
out,
);
}
}
}
+159
View File
@@ -0,0 +1,159 @@
//! Enchanting what mobs spawn with (`Mob.populateDefaultEquipmentEnchantments`
//! through the `mob_spawn_equipment` provider) and the raid buffs
//! (`Raider.applyRaidBuffs`).
use super::Game;
use horizon_client::{
mobs::{
Species,
gear::{self, ARMOR, MAIN},
},
raid::{self, RaiderType},
};
use horizon_core::random::RandomSource;
/// `EnchantmentsByCostWithDifficulty` of `mob_spawn_equipment`.
const MIN_COST: i32 = 5;
const MAX_COST_SPAN: f32 = 17.0;
/// The mobs that call `populateDefaultEquipmentEnchantments` when they spawn.
fn enchants_spawn_gear(s: Species) -> bool {
matches!(
s,
Species::Zombie
| Species::Husk
| Species::Drowned
| Species::ZombieVillager
| Species::ZombifiedPiglin
| Species::Skeleton
| Species::Stray
| Species::Bogged
| Species::Parched
| Species::Pillager
| Species::Vindicator
| Species::Piglin
| Species::Vex
)
}
/// The item a mob holds or wears in an equipment slot.
fn slot_item(m: &horizon_client::mobs::Mob, slot: usize) -> Option<std::sync::Arc<str>> {
match slot {
gear::MAIN => m.extra.main_hand.clone(),
gear::OFF => m.extra.off_hand.clone(),
gear::HEAD => m.extra.head.clone(),
gear::CHEST => m.extra.chest.clone(),
gear::LEGS => m.extra.legs.clone(),
_ => m.extra.feet.clone(),
}
}
impl Game<'_> {
/// `Mob.populateDefaultEquipmentEnchantments`: the weapon one time in
/// four and each piece of armour one time in two, scaled by the local
/// difficulty, enchanted as if at an enchanting table of cost 5 to 22.
pub(super) fn enchant_spawn_equipment(&mut self, id: u32) {
let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
return;
};
let species = m.species();
if !enchants_spawn_gear(species) {
return;
}
let special = self
.local_difficulty([m.position.x, m.position.y, m.position.z])
.special();
self.enchant_slot(id, MAIN, 0.25, special);
for slot in ARMOR {
self.enchant_slot(id, slot, 0.5, special);
}
// Pillager.enchantSpawnedWeapon: one crossbow in 300 pierces.
if species == Species::Pillager && self.world.random.next_int_bound(300).unwrap_or(1) == 0 {
self.enchant_single(id, MAIN, "minecraft:piercing", 1, "minecraft:crossbow");
}
}
fn enchant_slot(&mut self, id: u32, slot: usize, chance: f32, special: f32) {
let Some(item) = self
.mobs
.iter()
.find(|m| m.id == id)
.and_then(|m| slot_item(m, slot))
else {
return;
};
if self.world.random.next_float() >= chance * special {
return;
}
self.enchant_item(id, slot, &item, special);
}
/// `EnchantmentsByCostWithDifficulty.enchant` on the item in a slot.
pub(super) fn enchant_item(&mut self, id: u32, slot: usize, item: &str, special: f32) {
let random = &mut self.world.random;
let top = MIN_COST + (special * MAX_COST_SPAN) as i32;
let cost = random
.next_int_between_inclusive(MIN_COST, top)
.unwrap_or(MIN_COST);
let e = &self.res.stations.enchantments;
let pool = e.tag("minecraft:on_mob_spawn_equipment");
let picked = e.select(&self.res.items, random, item, cost, pool);
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
for (enchantment, level) in picked {
gear::upgrade(m, slot, &enchantment, level);
}
}
}
/// A `SingleEnchantment` provider on the item in `slot`, when it is `item`.
fn enchant_single(&mut self, id: u32, slot: usize, enchantment: &str, level: u32, item: &str) {
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
&& slot_item(m, slot).as_deref() == Some(item)
{
gear::upgrade(m, slot, enchantment, level);
}
}
/// `Pillager` / `Vindicator.applyRaidBuffs`: Quick Charge on a fresh
/// crossbow after waves 3 and 5, Sharpness on a fresh axe.
pub(super) fn apply_raid_buffs(&mut self, id: u32, kind: RaiderType, wave: i32, odds: f32) {
let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) else {
return;
};
let enchant = m.random.next_float() <= odds;
match kind {
RaiderType::Pillager if enchant => {
let level = if wave > raid::num_groups(2) {
2
} else if wave > raid::num_groups(1) {
1
} else {
0
};
if level > 0 {
m.extra.main_hand = Some("minecraft:crossbow".into());
gear::set(m, MAIN, Vec::new());
gear::upgrade(m, MAIN, "minecraft:quick_charge", level);
}
}
RaiderType::Vindicator => {
m.extra.main_hand = Some("minecraft:iron_axe".into());
gear::set(m, MAIN, Vec::new());
if enchant {
let level = if wave > raid::num_groups(2) { 2 } else { 1 };
gear::upgrade(m, MAIN, "minecraft:sharpness", level);
}
}
_ => {}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_the_vanilla_mobs_enchant_their_spawn_gear() {
assert!(enchants_spawn_gear(Species::Skeleton));
assert!(enchants_spawn_gear(Species::Pillager));
assert!(!enchants_spawn_gear(Species::WitherSkeleton));
assert!(!enchants_spawn_gear(Species::PiglinBrute));
assert!(!enchants_spawn_gear(Species::Villager));
}
}
@@ -0,0 +1,272 @@
//! Mobs riding mobs: boarding and dismounting, keeping riders on their
//! vehicles, the jockeys that spawn mounted (chicken jockeys, spider
//! jockeys, strider jockeys, zombie horsemen) and the skeleton horse trap.
//! Saving riders under `Passengers` lives in `persist.rs`.
use super::Game;
use horizon_client::mobs::{Species, riders};
use horizon_core::{geometry::Vec3, random::RandomSource};
use std::collections::HashMap;
/// `Zombie.finalizeSpawn`: a baby zombie takes a chicken one time in twenty,
/// and another one time in twenty of the rest.
const CHICKEN_JOCKEY_ODDS: f32 = 0.05;
/// The seconds a skeleton horse trap waits for a player: 15 minutes.
const TRAP_LIFETIME: i32 = 18000;
/// `SkeletonTrapGoal`: a player this close springs the trap.
const TRAP_RANGE: f64 = 10.0;
/// Ticks of invulnerability the trap's riders and horses start with.
const TRAP_INVULNERABLE: i32 = 60;
fn zombie_kind(s: Species) -> bool {
matches!(
s,
Species::Zombie | Species::Husk | Species::Drowned | Species::ZombieVillager
)
}
impl Game<'_> {
/// `Entity.startRiding` for two mobs.
pub(super) fn mount_mob(&mut self, rider: u32, vehicle: u32) {
if rider == vehicle {
return;
}
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == rider) {
m.extra.mount = Some(vehicle);
m.extra.passenger = true;
}
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == vehicle) {
m.extra.rider = Some(rider);
}
}
/// Riders sit on their vehicles (`Entity.positionRider`), and let go when
/// the vehicle dies or is gone.
pub(super) fn sync_riders(&mut self) {
let index: HashMap<u32, usize> = self
.mobs
.iter()
.enumerate()
.map(|(i, m)| (m.id, i))
.collect();
let mut riding: HashMap<u32, u32> = HashMap::new();
for i in 0..self.mobs.len() {
let Some(v) = self.mobs[i].extra.mount else {
continue;
};
let valid = self.mobs[i].alive()
&& !self.mobs[i].removed
&& index
.get(&v)
.is_some_and(|&j| self.mobs[j].alive() && !self.mobs[j].removed);
if valid {
riding.insert(v, self.mobs[i].id);
} else {
let m = &mut self.mobs[i];
m.extra.mount = None;
m.extra.passenger = false;
}
}
for m in &mut self.mobs {
m.extra.rider = riding.get(&m.id).copied();
}
// Riders of riders settle over a few passes.
for _ in 0..3 {
for i in 0..self.mobs.len() {
let Some(v) = self.mobs[i].extra.mount else {
continue;
};
let Some(&j) = index.get(&v) else { continue };
let vehicle = &self.mobs[j];
let attach = riders::passenger_attachment(vehicle);
let (pos, prev) = (vehicle.position, vehicle.previous);
let (yaw, prev_yaw) = (vehicle.yaw, vehicle.previous_yaw);
let (body, prev_body) = (vehicle.body_yaw, vehicle.previous_body_yaw);
let m = &mut self.mobs[i];
let offset = riders::vehicle_attachment(m);
m.position = riders::seat(attach, offset, pos, yaw);
m.previous = riders::seat(attach, offset, prev, prev_yaw);
m.velocity = Vec3::ZERO;
m.fall_distance = 0.0;
m.on_ground = false;
m.body_yaw = body;
m.previous_body_yaw = prev_body;
m.extra.passenger = true;
// A rider never walks off on its own.
m.ai.nav.stop();
}
}
}
/// `finalizeSpawn` jockeys of a naturally spawned mob: baby zombies on
/// chickens, skeletons on spiders, piglins and baby striders on striders,
/// zombies on zombie horses.
pub(super) fn spawn_jockeys(&mut self, id: u32, natural: bool) {
let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
return;
};
let (species, baby) = (m.species(), m.is_baby());
let at = [m.position.x, m.position.y, m.position.z];
match species {
s if zombie_kind(s) && baby => {
if self.world.random.next_float() < CHICKEN_JOCKEY_ODDS {
if let Some(chicken) = self.free_chicken_near(at) {
self.make_chicken_jockey(chicken);
self.mount_mob(id, chicken);
}
} else if self.world.random.next_float() < CHICKEN_JOCKEY_ODDS
&& let Some(chicken) = self.spawn_mob("minecraft:chicken", at, false)
{
self.make_chicken_jockey(chicken);
self.mount_mob(id, chicken);
}
}
// Spider.finalizeSpawn: one in a hundred carries a skeleton.
Species::Spider if self.world.random.next_int_bound(100).unwrap_or(1) == 0 => {
if let Some(skeleton) = self.spawn_mob("minecraft:skeleton", at, false) {
self.mount_mob(skeleton, id);
}
}
Species::Strider if !baby => self.spawn_strider_jockey(id, at),
// ZombieHorse.finalizeSpawn: a zombie with an iron spear.
Species::ZombieHorse if natural => {
if let Some(zombie) = self.spawn_mob("minecraft:zombie", at, false) {
if let Some(z) = self.mobs.iter_mut().find(|m| m.id == zombie) {
z.extra.main_hand = Some("minecraft:iron_spear".into());
}
self.mount_mob(zombie, id);
}
}
_ => {}
}
}
fn free_chicken_near(&self, at: [f64; 3]) -> Option<u32> {
self.mobs
.iter()
.find(|c| {
c.species() == Species::Chicken
&& c.alive()
&& c.extra.rider.is_none()
&& c.extra.mount.is_none()
&& (c.position.x - at[0]).abs() <= 5.3
&& (c.position.y - at[1]).abs() <= 3.0 + 1.0
&& (c.position.z - at[2]).abs() <= 5.3
})
.map(|c| c.id)
}
fn make_chicken_jockey(&mut self, chicken: u32) {
if let Some(c) = self.mobs.iter_mut().find(|m| m.id == chicken) {
c.extra.jockey = true;
}
}
/// `Strider.finalizeSpawn`: one strider in thirty carries a zombified
/// piglin holding a warped fungus on a stick (and wears a saddle), one in
/// ten of the rest a baby strider.
fn spawn_strider_jockey(&mut self, id: u32, at: [f64; 3]) {
if self.world.random.next_int_bound(30).unwrap_or(1) == 0 {
if !self.ui.rules.bool("spawn_mobs") {
return;
}
if let Some(piglin) = self.spawn_mob("minecraft:zombified_piglin", at, false) {
let baby = self.world.random.next_float() < CHICKEN_JOCKEY_ODDS;
if let Some(p) = self.mobs.iter_mut().find(|m| m.id == piglin) {
p.extra.main_hand = Some("minecraft:warped_fungus_on_a_stick".into());
p.extra.age = if baby { i32::MIN / 2 } else { 0 };
}
if let Some(s) = self.mobs.iter_mut().find(|m| m.id == id) {
s.extra.saddled = true;
}
self.mount_mob(piglin, id);
}
} else if self.world.random.next_int_bound(10).unwrap_or(1) == 0
&& let Some(baby) = self.spawn_mob("minecraft:strider", at, false)
{
if let Some(b) = self.mobs.iter_mut().find(|m| m.id == baby) {
b.extra.age = -24000;
}
self.mount_mob(baby, id);
}
}
/// `SkeletonHorse.customServerAiStep` and `SkeletonTrapGoal`: a trap
/// horse is a trap for fifteen minutes; a player within ten blocks springs
/// it.
pub(super) fn tick_skeleton_traps(&mut self) {
let player = self
.player
.as_ref()
.filter(|p| !p.health.dead_or_dying())
.map(|p| p.position);
let mut sprung = Vec::new();
for m in &mut self.mobs {
if m.species() != Species::SkeletonHorse || !m.extra.trap || !m.alive() {
continue;
}
if !m.persistent {
m.extra.trap_time += 1;
if m.extra.trap_time > TRAP_LIFETIME {
m.removed = true;
continue;
}
}
if player.is_some_and(|p| m.distance_sqr(p) < TRAP_RANGE * TRAP_RANGE) {
sprung.push(m.id);
}
}
for id in sprung {
self.spring_skeleton_trap(id);
}
}
fn spring_skeleton_trap(&mut self, id: u32) {
let Some(horse) = self.mobs.iter_mut().find(|m| m.id == id) else {
return;
};
horse.extra.trap = false;
horse.extra.tame = true;
horse.extra.age = 0;
let at = [horse.position.x, horse.position.y, horse.position.z];
self.spawn_bolt(at, true);
let Some(skeleton) = self.trap_skeleton(at) else {
return;
};
self.mount_mob(skeleton, id);
for _ in 0..3 {
let Some(other) = self.spawn_mob("minecraft:skeleton_horse", at, true) else {
continue;
};
let (dx, dz) = (
self.world.random.triangle(0.0, 1.1485),
self.world.random.triangle(0.0, 1.1485),
);
if let Some(h) = self.mobs.iter_mut().find(|m| m.id == other) {
h.invulnerable = TRAP_INVULNERABLE;
h.extra.tame = true;
h.extra.age = 0;
h.velocity = Vec3::new(h.velocity.x + dx, h.velocity.y, h.velocity.z + dz);
}
if let Some(rider) = self.trap_skeleton(at) {
self.mount_mob(rider, other);
}
}
}
/// `SkeletonTrapGoal.createSkeleton`: an iron helmet unless it already
/// has a helm.
fn trap_skeleton(&mut self, at: [f64; 3]) -> Option<u32> {
let id = self.spawn_mob("minecraft:skeleton", at, true)?;
let m = self.mobs.iter_mut().find(|m| m.id == id)?;
m.invulnerable = TRAP_INVULNERABLE;
if m.extra.head.is_none() {
m.extra.head = Some("minecraft:iron_helmet".into());
}
let (weapon, helmet) = (m.extra.main_hand.clone(), m.extra.head.clone());
let special = self.local_difficulty(at).special();
// `SkeletonTrapGoal.enchant`: the weapon and the helmet, always.
for (slot, item) in [
(horizon_client::mobs::gear::MAIN, weapon),
(horizon_client::mobs::gear::HEAD, helmet),
] {
if let Some(item) = item {
self.enchant_item(id, slot, &item, special);
}
}
Some(id)
}
}
+192 -54
View File
@@ -25,6 +25,36 @@ pub struct EntityMemory {
/// Entities of types Horizon does not simulate, kept per chunk and
/// written back unchanged.
unknown: HashMap<(i32, i32), Vec<Tag>>,
/// Entities without a Horizon entity ID (orbs, arrows, falling blocks, crystals,
/// the dragon): the UUID and compound they were loaded with, found again by
/// type and position (an entity that has moved since loading is saved afresh).
anon: HashMap<(String, [u64; 3]), (Vec3, Option<[i32; 4]>, Tag)>,
}
fn anon_key(kind: &str, p: Vec3) -> (String, [u64; 3]) {
(
kind.to_owned(),
[p.x.to_bits(), p.y.to_bits(), p.z.to_bits()],
)
}
/// The loaded compound underneath the fields Horizon models: what the entity was
/// loaded with, with every key of `modelled` replacing its loaded value.
fn with_raw(modelled: Tag, raw: Option<&Tag>) -> Tag {
let (Some(Tag::Compound(raw)), Tag::Compound(modelled)) = (raw, &modelled) else {
return modelled;
};
let mut out = raw.clone();
for (k, v) in modelled {
// Defaults Horizon invents for fields it does not simulate give way to the save.
let invented = matches!(
k.to_string_lossy().as_str(),
"Fire" | "Air" | "Invulnerable" | "PortalCooldown" | "HasBeenShot"
);
if !(invented && out.contains_key(k)) {
out.insert(k.clone(), v.clone());
}
}
Tag::Compound(out)
}
fn painting_center(p: &horizon_client::entities::Painting) -> Vec3 {
@@ -111,6 +141,19 @@ impl Game<'_> {
for tag in tags {
let kind = entity_nbt::kind(&tag).unwrap_or_default();
let uuid = entity_nbt::uuid(&tag);
if matches!(
kind.as_str(),
"minecraft:experience_orb"
| "minecraft:arrow"
| "minecraft:falling_block"
| "minecraft:end_crystal"
| "minecraft:ender_dragon"
) && let Some(at) = entity_nbt::position(&tag)
{
self.persist
.anon
.insert(anon_key(&kind, at), (at, uuid, tag.clone()));
}
match kind.as_str() {
"minecraft:item" => {
self.next_entity += 1;
@@ -217,52 +260,117 @@ impl Game<'_> {
}
}
_ if self.res.mob_types.contains_key(&kind) => {
self.next_entity += 1;
// Structure entities placed with finalizeEntities.
let mut tag = tag;
let finalize = match &mut tag {
Tag::Compound(c) => c.remove(&"horizon:finalize".into()).is_some(),
_ => false,
};
if let Some(mut m) =
entity_nbt::mob_from_nbt(&tag, &self.res.mob_types, self.next_entity)
{
if finalize {
let facts = self.biome_facts(
m.position.x.floor() as i32,
m.position.y.floor() as i32,
m.position.z.floor() as i32,
);
let at = [m.position.x, m.position.y, m.position.z];
let difficulty = self.local_difficulty(at);
horizon_client::mobs::spawning::finalize(
&mut m,
&facts,
&difficulty,
);
// Cat.finalizeSpawn: black in #cats_spawn_as_black.
if m.species() == horizon_client::mobs::Species::Cat {
let p = [
m.position.x.floor() as i32,
m.position.y.floor() as i32,
m.position.z.floor() as i32,
];
let black = self.structure_tag("minecraft:cats_spawn_as_black");
if self.structures_at(p).iter().any(|s| black.contains(s)) {
m.extra.variant = 10;
m.persistent = true;
}
}
}
self.remember(m.id, uuid, tag);
self.mobs.push(m);
}
self.load_mob(tag, None);
}
_ => self.persist.unknown.entry(key).or_default().push(tag),
}
}
}
}
/// A saved mob and, under `Passengers`, the mobs riding it.
fn load_mob(&mut self, tag: Tag, mount: Option<u32>) -> Option<u32> {
self.next_entity += 1;
let uuid = entity_nbt::uuid(&tag);
// Structure entities placed with finalizeEntities.
let mut tag = tag;
let mut finalize = false;
let mut riders = Vec::new();
let mut unknown = Vec::new();
if let Tag::Compound(c) = &mut tag {
finalize = c.remove(&"horizon:finalize".into()).is_some();
if let Some(Tag::List(list)) = c.remove(&"Passengers".into()) {
for p in list {
let known =
entity_nbt::kind(&p).is_some_and(|k| self.res.mob_types.contains_key(&k));
if known {
riders.push(p);
} else {
unknown.push(p);
}
}
}
if !unknown.is_empty() {
c.insert("Passengers".into(), Tag::List(unknown));
}
}
let mut m = entity_nbt::mob_from_nbt(&tag, &self.res.mob_types, self.next_entity)?;
m.extra.mount = mount;
m.extra.passenger = mount.is_some();
if finalize {
let facts = self.biome_facts(
m.position.x.floor() as i32,
m.position.y.floor() as i32,
m.position.z.floor() as i32,
);
let at = [m.position.x, m.position.y, m.position.z];
let difficulty = self.local_difficulty(at);
horizon_client::mobs::spawning::finalize(&mut m, &facts, &difficulty);
// Cat.finalizeSpawn: black in #cats_spawn_as_black.
if m.species() == horizon_client::mobs::Species::Cat {
let p = [
m.position.x.floor() as i32,
m.position.y.floor() as i32,
m.position.z.floor() as i32,
];
let black = self.structure_tag("minecraft:cats_spawn_as_black");
if self.structures_at(p).iter().any(|s| black.contains(s)) {
m.extra.variant = 10;
m.persistent = true;
}
}
}
let id = m.id;
self.remember(id, uuid, tag);
self.mobs.push(m);
if finalize {
self.enchant_spawn_equipment(id);
}
for rider in riders {
if let Some(r) = self.load_mob(rider, Some(id))
&& let Some(v) = self.mobs.iter_mut().find(|m| m.id == id)
{
v.extra.rider = Some(r);
}
}
Some(id)
}
/// The root of a stack of riders (`Entity.getRootVehicle`).
fn mob_root(&self, mut i: usize) -> usize {
for _ in 0..8 {
let Some(v) = self.mobs[i].extra.mount else {
break;
};
let Some(j) = self.mobs.iter().position(|m| m.id == v) else {
break;
};
i = j;
}
i
}
/// A mob's entity tag with the mobs riding it under `Passengers`.
fn mob_tree_nbt(&mut self, i: usize) -> Tag {
let id = self.mobs[i].id;
let uuid = self.uuid_for(id);
let mut tag = entity_nbt::mob_to_nbt(&self.mobs[i], uuid, self.persist.raw.get(&id));
self.write_leash(&mut tag, i);
let riders: Vec<usize> = (0..self.mobs.len())
.filter(|&j| self.mobs[j].extra.mount == Some(id) && self.mobs[j].alive())
.collect();
let riders: Vec<Tag> = riders.into_iter().map(|j| self.mob_tree_nbt(j)).collect();
if let Tag::Compound(c) = &mut tag {
let mut list = match c.get(&"Passengers".into()) {
Some(Tag::List(l)) => l.clone(),
_ => Vec::new(),
};
list.extend(riders);
if list.is_empty() {
c.remove(&"Passengers".into());
} else {
c.insert("Passengers".into(), Tag::List(list));
}
}
tag
}
fn remember(&mut self, id: u32, uuid: Option<[i32; 4]>, tag: Tag) {
if let Some(u) = uuid {
self.persist.uuids.insert(id, u);
@@ -336,14 +444,16 @@ impl Game<'_> {
let mut out: HashMap<(i32, i32), Vec<Tag>> =
keys.iter().map(|k| (*k, Vec::new())).collect();
let player_uuid = self.level.player_uuid;
// A rider is saved inside its root vehicle, in the root's chunk.
let mobs: Vec<usize> = (0..self.mobs.len())
.filter(|&i| keys.contains(&chunk_of(self.mobs[i].position)) && self.mobs[i].alive())
.filter(|&i| {
self.mob_root(i) == i
&& keys.contains(&chunk_of(self.mobs[i].position))
&& self.mobs[i].alive()
})
.collect();
for i in mobs {
let id = self.mobs[i].id;
let uuid = self.uuid_for(id);
let mut tag = entity_nbt::mob_to_nbt(&self.mobs[i], uuid, self.persist.raw.get(&id));
self.write_leash(&mut tag, i);
let tag = self.mob_tree_nbt(i);
out.entry(chunk_of(self.mobs[i].position))
.or_default()
.push(tag);
@@ -360,31 +470,44 @@ impl Game<'_> {
.or_default()
.push(tag);
}
let anon = |persist: &EntityMemory, kind: &str, at: Vec3| {
persist
.anon
.get(&anon_key(kind, at))
.map(|(_, uuid, raw)| (uuid.unwrap_or_else(random_uuid), Some(raw.clone())))
.unwrap_or_else(|| (random_uuid(), None))
};
for o in &self.orbs {
if keys.contains(&chunk_of(o.position)) {
let (uuid, raw) = anon(&self.persist, "minecraft:experience_orb", o.position);
out.entry(chunk_of(o.position))
.or_default()
.push(entity_nbt::orb_to_nbt(o, random_uuid()));
.push(with_raw(entity_nbt::orb_to_nbt(o, uuid), raw.as_ref()));
}
}
for a in &self.arrows {
if keys.contains(&chunk_of(a.position)) {
let owner = if a.from_player { player_uuid } else { None };
out.entry(chunk_of(a.position))
.or_default()
.push(entity_nbt::arrow_to_nbt(a, random_uuid(), owner));
let (uuid, raw) = anon(&self.persist, "minecraft:arrow", a.position);
out.entry(chunk_of(a.position)).or_default().push(with_raw(
entity_nbt::arrow_to_nbt(a, uuid, owner),
raw.as_ref(),
));
}
}
for f in &self.falling {
if keys.contains(&chunk_of(f.position)) {
let (uuid, raw) = anon(&self.persist, "minecraft:falling_block", f.position);
let tag = entity_nbt::falling_block_to_nbt(
self.state_to_nbt(f.state),
f.position,
f.velocity,
f.age,
random_uuid(),
uuid,
);
out.entry(chunk_of(f.position)).or_default().push(tag);
out.entry(chunk_of(f.position))
.or_default()
.push(with_raw(tag, raw.as_ref()));
}
}
for b in &self.boats {
@@ -409,15 +532,17 @@ impl Game<'_> {
if let Some(d) = &self.dragon
&& keys.contains(&chunk_of(d.position))
{
let (uuid, raw) = anon(&self.persist, "minecraft:ender_dragon", d.position);
out.entry(chunk_of(d.position))
.or_default()
.push(d.to_nbt(random_uuid(), None));
.push(d.to_nbt(uuid, raw.as_ref()));
}
for c in &self.crystals {
if keys.contains(&chunk_of(c.position)) {
let (uuid, raw) = anon(&self.persist, "minecraft:end_crystal", c.position);
out.entry(chunk_of(c.position))
.or_default()
.push(c.to_nbt(random_uuid(), None));
.push(c.to_nbt(uuid, raw.as_ref()));
}
}
for c in &self.carts {
@@ -533,8 +658,13 @@ impl Game<'_> {
}
keep
});
// Riders leave with their root vehicle.
let leaving: HashSet<u32> = (0..self.mobs.len())
.filter(|&i| gone(self.mobs[self.mob_root(i)].position))
.map(|i| self.mobs[i].id)
.collect();
self.mobs.retain(|m| {
let keep = !gone(m.position);
let keep = !leaving.contains(&m.id);
if !keep {
removed.push(m.id);
}
@@ -550,6 +680,9 @@ impl Game<'_> {
self.orbs.retain(|o| !gone(o.position));
self.arrows.retain(|a| !gone(a.position));
self.falling.retain(|f| !gone(f.position));
self.persist
.anon
.retain(|_, (at, _, _)| !keys.contains(&chunk_of(*at)));
for id in removed {
self.persist.uuids.remove(&id);
self.persist.raw.remove(&id);
@@ -568,6 +701,11 @@ impl Game<'_> {
.iter()
.map(|m| m.id)
.chain(self.dropped.iter().map(|e| e.id))
.chain(self.boats.iter().map(|e| e.id))
.chain(self.carts.iter().map(|e| e.id))
.chain(self.armor_stands.iter().map(|e| e.id))
.chain(self.item_frames.iter().map(|e| e.id))
.chain(self.paintings.iter().map(|e| e.id))
.collect();
self.persist.uuids.retain(|id, _| alive.contains(id));
self.persist.raw.retain(|id, _| alive.contains(id));
+29 -2
View File
@@ -19,6 +19,23 @@ pub(super) struct ThrownPotion {
velocity: Vec3,
age: u32,
}
/// A mob's effect ids carry the `minecraft:` namespace.
fn mob_effect_id(id: &str) -> Option<&'static str> {
use std::{collections::HashMap, sync::OnceLock};
static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
let id = id.trim_start_matches("minecraft:");
IDS.get_or_init(|| {
brewing::EFFECTS
.iter()
.map(|e| {
let full: &'static str = Box::leak(format!("minecraft:{}", e.id).into_boxed_str());
(e.id, full)
})
.collect()
})
.get(id)
.copied()
}
impl Game<'_> {
/// A splash potion, lingering potion or experience bottle in flight (the
/// player's throws and dispensers both end up here).
@@ -490,11 +507,21 @@ impl Game<'_> {
}
}
for (i, intensity, inverted) in hits {
for (id, _, amp) in def.effects {
for (id, duration, amp) in def.effects {
let harm = match *id {
"instant_damage" => !inverted,
"instant_health" => inverted,
_ => continue,
_ => {
// `Potion.applySplash`: timed effects last in
// proportion to how close the mob was.
let d = (intensity * f64::from(*duration) * scale + 0.5) as i32;
if d > 20
&& let Some(name) = mob_effect_id(id)
{
self.mobs[i].add_effect(name, d, *amp);
}
continue;
}
};
let m = &mut self.mobs[i];
if harm {
+3 -88
View File
@@ -424,13 +424,7 @@ impl Game<'_> {
if let Some(kind) = sp.rider
&& let Some(rider) = self.spawn_raider(kind, pos, raid_id, wave, false, odds)
{
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == rider) {
raider::state_mut(m).vehicle = Some(id);
m.extra.passenger = true;
}
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
raider::state_mut(m).rider = true;
}
self.mount_mob(rider, id);
}
}
}
@@ -462,33 +456,7 @@ impl Game<'_> {
s.ticks_outside_raid = 0;
s.active_raid = true;
m.on_ground = true;
// applyRaidBuffs: Quick Charge crossbows and Sharpness axes.
let enchant = m.random.next_float() <= odds;
match kind {
RaiderType::Pillager if enchant => {
raider::state_mut(m).enchant = if wave > raid::num_groups(2) {
2
} else if wave > raid::num_groups(1) {
1
} else {
0
};
}
RaiderType::Vindicator => {
let level = if !enchant {
0
} else if wave > raid::num_groups(2) {
2
} else {
1
};
raider::state_mut(m).enchant = level;
if level > 0 {
m.attrs.attack_damage += 1.0 + 0.5 * f32::from(level - 1);
}
}
_ => {}
}
self.apply_raid_buffs(id, kind, wave, odds);
Some(id)
}
@@ -515,7 +483,7 @@ impl Game<'_> {
if let (Some(id), true) = (s.raid_id, s.patrol_leader) {
leaders.insert((id, s.wave));
}
if let Some(v) = s.vehicle {
if let Some(v) = m.extra.mount {
ridden.insert(v);
}
positions.push((m.id, m.position, s.active_raid));
@@ -732,59 +700,6 @@ impl Game<'_> {
.map(|(id, (_, v))| (*id, v.clone()))
.collect()
}
/// A raider riding a ravager sits on its back (`Entity.positionRider`
/// with the ravager's passenger attachment and a 0.6 riding offset).
pub(super) fn sync_riders(&mut self) {
let vehicles: HashMap<u32, (Vec3, Vec3, f32, f32, bool)> = self
.mobs
.iter()
.filter(|m| m.species() == Species::Ravager)
.map(|m| {
(
m.id,
(
m.position,
m.previous,
m.body_yaw,
m.previous_body_yaw,
m.alive(),
),
)
})
.collect();
for m in &mut self.mobs {
let Some(v) = raider::state(m).and_then(|s| s.vehicle) else {
continue;
};
match vehicles.get(&v) {
Some(&(pos, prev, yaw, prev_yaw, true)) => {
let place = |p: Vec3, yaw: f32| {
let a = f64::from(yaw).to_radians();
// The attachment's z offset of -0.0625, rotated.
Vec3::new(
p.x + a.sin() * -0.0625,
p.y + 2.2625 - 0.6,
p.z - a.cos() * -0.0625,
)
};
m.position = place(pos, yaw);
m.previous = place(prev, prev_yaw);
m.velocity = Vec3::ZERO;
m.fall_distance = 0.0;
m.on_ground = false;
m.body_yaw = yaw;
m.previous_body_yaw = prev_yaw;
m.extra.passenger = true;
// Raiders on a ravager never walk off on their own.
m.ai.nav.stop();
}
_ => {
raider::state_mut(m).vehicle = None;
m.extra.passenger = false;
}
}
}
}
/// `Raider.die`: the killing player becomes a hero of the village.
pub(super) fn raider_died(&mut self, m: &Mob, by_player: bool) {
let Some(id) = raider::state(m).and_then(|s| s.raid_id) else {
+2 -1
View File
@@ -24,7 +24,7 @@ fn pause_buttons(w: f32, h: f32) -> Vec<(f32, f32, f32, &'static str, u8, bool)>
98.0,
"options.worldOptions.button",
9,
false,
true,
),
(x0 + 4.0, y0 + 146.0, 204.0, "menu.returnToMenu", 2, true),
]
@@ -114,6 +114,7 @@ impl Game<'_> {
Some(1) => self.open_options(false),
Some(3) => self.open_stats(),
Some(4) => self.open_advancements(true),
Some(9) => self.open_world_options(),
Some(2) => self.close_world()?,
_ => {}
}
+27 -23
View File
@@ -99,29 +99,9 @@ impl Game<'_> {
};
self.res.stations.trades.offers_from_set(&ctx, set, random)
}
/// `Villager.mobInteract` / `WanderingTrader.mobInteract`: shake the
/// head without offers, else open the trading screen.
pub(super) fn interact_trader(
&mut self,
index: usize,
item: &str,
) -> horizon_client::Result<bool> {
let m = &self.mobs[index];
let species = m.species();
if !matches!(species, Species::Villager | Species::WanderingTrader)
|| !m.alive()
|| item == "minecraft:villager_spawn_egg"
|| self.station.is_some()
{
return Ok(false);
}
if m.is_baby() {
let mut events = Vec::new();
villager::set_unhappy(&mut self.mobs[index], &mut events);
self.handle_mob_events(events)?;
return Ok(true);
}
// AbstractVillager.getOffers: generated on first use.
/// `AbstractVillager.getOffers`: generated on first use.
pub(super) fn ensure_offers(&mut self, index: usize) {
let species = self.mobs[index].species();
if self.mobs[index].extra.trade.is_none() {
let m = &self.mobs[index];
let variant = VILLAGER_TYPES[m.extra.variant as usize % VILLAGER_TYPES.len()];
@@ -147,6 +127,30 @@ impl Game<'_> {
..Default::default()
}));
}
}
/// `Villager.mobInteract` / `WanderingTrader.mobInteract`: shake the
/// head without offers, else open the trading screen.
pub(super) fn interact_trader(
&mut self,
index: usize,
item: &str,
) -> horizon_client::Result<bool> {
let m = &self.mobs[index];
let species = m.species();
if !matches!(species, Species::Villager | Species::WanderingTrader)
|| !m.alive()
|| item == "minecraft:villager_spawn_egg"
|| self.station.is_some()
{
return Ok(false);
}
if m.is_baby() {
let mut events = Vec::new();
villager::set_unhappy(&mut self.mobs[index], &mut events);
self.handle_mob_events(events)?;
return Ok(true);
}
self.ensure_offers(index);
let m = &self.mobs[index];
let mut trade = m.extra.trade.as_deref().cloned().unwrap_or_default();
// Villager.updateSpecialPrices: reputation and Hero of the Village.
@@ -0,0 +1,254 @@
//! Zombie villagers in the world: zombies turning the villagers they kill
//! into zombie villagers (`Zombie.killedEntity`), the golden apple that starts
//! a cure (`ZombieVillager.mobInteract`), and the cured villager that
//! remembers who saved it (`ZombieVillager.finishConversion`).
use super::Game;
use horizon_client::{
advancements as adv,
gossip::GossipType,
mobs::{Mob, Species, villager, zombie_villager},
};
use horizon_core::random::RandomSource;
use horizon_world::food::Difficulty;
/// The `Zombie` subclasses that convert the villagers they kill.
fn is_zombie(s: Species) -> bool {
matches!(
s,
Species::Zombie
| Species::Husk
| Species::Drowned
| Species::ZombieVillager
| Species::ZombifiedPiglin
)
}
/// Whether a zombie turns the villager it killed: always on Hard, half the
/// time on Normal (`Zombie.killedEntity`).
fn infects(difficulty: Difficulty, coin: impl FnOnce() -> bool) -> bool {
match difficulty {
Difficulty::Hard => true,
Difficulty::Normal => !coin(),
_ => false,
}
}
impl Game<'_> {
/// `Zombie.killedEntity`: a villager killed by a zombie may rise as a
/// zombie villager keeping its profession, trades and gossip.
pub(super) fn zombie_killed(&mut self, killer: u32, victim: u32) {
let Some(k) = self.mobs.iter().position(|m| m.id == killer) else {
return;
};
let Some(v) = self.mobs.iter().position(|m| m.id == victim) else {
return;
};
if !is_zombie(self.mobs[k].species())
|| self.mobs[v].species() != Species::Villager
|| self.mobs[v].alive()
|| self.mobs[v].removed
{
return;
}
let difficulty = self.world.health_rules.difficulty;
let random = &mut self.mobs[k].random;
if !infects(difficulty, || random.next_boolean()) {
return;
}
// The villager is gone without dying: no drops, no death animation.
let old = self.mobs[v].clone();
self.mobs[v].removed = true;
self.mobs[v].health = 0.0;
let at = [old.position.x, old.position.y, old.position.z];
let Some(id) = self.spawn_mob("minecraft:zombie_villager", at, old.persistent) else {
return;
};
let ensure = self.mobs.iter().position(|m| m.id == victim);
if let Some(i) = ensure {
self.ensure_offers(i);
}
let old = ensure.map_or(old, |i| self.mobs[i].clone());
let Some(z) = self.mobs.iter_mut().find(|m| m.id == id) else {
return;
};
convert_to_zombie_villager(&old, z);
let killer_at = self.mobs[k].position;
let pitch = (self.world.random.next_float() - self.world.random.next_float()) * 0.2 + 1.0;
self.audio.play(
"minecraft:entity.zombie.infect",
Some([killer_at.x, killer_at.y, killer_at.z]),
2.0,
pitch,
);
}
/// `ZombieVillager.mobInteract`: a golden apple on a weakened zombie
/// villager starts the cure and is eaten; without weakness it does
/// nothing. Returns whether the click was used.
pub(super) fn interact_zombie_villager(&mut self, index: usize, item: &str) -> bool {
let m = &self.mobs[index];
if m.species() != Species::ZombieVillager || item != "minecraft:golden_apple" {
return false;
}
if !m.has_effect("minecraft:weakness") {
return true;
}
self.consume_held();
let starter = self.level.player_uuid;
let time = zombie_villager::WAIT_MIN
+ self
.world
.random
.next_int_bound(zombie_villager::WAIT_SPREAD)
.unwrap_or(0);
let mut events = Vec::new();
zombie_villager::start_converting(&mut self.mobs[index], starter, time, &mut events);
let _ = self.handle_mob_events(events);
self.swing_arm();
true
}
/// `ZombieVillager.finishConversion`: the villager returns with its
/// data, trades, experience and gossip, and the curing player earns the
/// village's trust.
pub(super) fn cure_zombie_villager(&mut self, id: u32) {
let Some(i) = self.mobs.iter().position(|m| m.id == id) else {
return;
};
if self.mobs[i].removed || zombie_villager::cure(&self.mobs[i]).is_none() {
return;
}
let old = self.mobs[i].clone();
self.mobs[i].removed = true;
let at = [old.position.x, old.position.y, old.position.z];
let Some(vid) = self.spawn_mob("minecraft:villager", at, old.persistent) else {
return;
};
let Some(v) = self.mobs.iter_mut().find(|m| m.id == vid) else {
return;
};
convert_to_villager(&old, v);
// `Villager.onReputationEventFrom(ZOMBIE_VILLAGER_CURED)`.
let starter = zombie_villager::cure(&old).and_then(|c| c.starter);
let player = self.level.player_uuid;
let cured_by_player = starter.is_some() && starter == player;
if cured_by_player && let Some(uuid) = starter {
let g = &mut villager::ext_mut(v).gossips;
g.add(uuid, GossipType::MajorPositive, 20);
g.add(uuid, GossipType::MinorPositive, 25);
}
let cured = v.clone();
let villager_view = self.mob_entity(&cured);
let zombie_view = self.mob_entity(&old);
if cured_by_player {
self.trigger_cured_zombie_villager(&zombie_view, &villager_view);
}
let pitch = (self.world.random.next_float() - self.world.random.next_float()) * 0.2 + 1.0;
self.audio.play(
"minecraft:entity.zombie_villager.converted",
Some(at),
2.0,
pitch,
);
}
/// `CuredZombieVillagerTrigger`.
fn trigger_cured_zombie_villager(
&mut self,
zombie: &adv::EntityView,
villager: &adv::EntityView,
) {
let me = self.player_entity();
let (zombie, villager) = (zombie.clone(), villager.clone());
self.trigger("minecraft:cured_zombie_villager", move |c, w| {
let origin = me.position;
let ctx = |e| adv::Entities {
this: Some(e),
origin,
tool: None,
block_pos: None,
};
adv::conditions(&c["player"], &ctx(&me), w)
&& adv::conditions(&c["zombie"], &ctx(&zombie), w)
&& adv::conditions(&c["villager"], &ctx(&villager), w)
});
}
}
/// `Mob.convertTo` (`ConversionType.SINGLE`, keeping equipment and the
/// pick-up-loot flag): what any converted mob carries over.
fn carry_over(from: &Mob, to: &mut Mob) {
to.position = from.position;
to.previous = from.position;
to.velocity = from.velocity;
to.yaw = from.yaw;
to.previous_yaw = from.yaw;
to.body_yaw = from.body_yaw;
to.previous_body_yaw = from.body_yaw;
to.head_yaw = from.head_yaw;
to.previous_head_yaw = from.head_yaw;
to.head_pitch = from.head_pitch;
to.previous_head_pitch = from.head_pitch;
to.fall_distance = from.fall_distance;
to.hurt_time = from.hurt_time;
to.on_ground = from.on_ground;
to.fire_ticks = from.fire_ticks;
to.persistent = from.persistent;
to.custom_name = from.custom_name.clone();
to.name_visible = from.name_visible;
to.extra.pick_up_loot = from.extra.pick_up_loot;
to.extra.main_hand = from.extra.main_hand.clone();
to.extra.off_hand = from.extra.off_hand.clone();
to.extra.head = from.extra.head.clone();
to.extra.chest = from.extra.chest.clone();
to.extra.legs = from.extra.legs.clone();
to.extra.feet = from.extra.feet.clone();
to.extra.effects = from.extra.effects.clone();
// VillagerData and the trades, experience and gossip.
to.extra.variant = from.extra.variant;
to.extra.variant2 = from.extra.variant2;
to.extra.variant3 = from.extra.variant3.max(1);
to.extra.trade = from.extra.trade.clone();
if let Some(g) = villager::ext(from).map(|e| e.gossips.clone()) {
villager::ext_mut(to).gossips = g;
}
}
/// A villager rises as a zombie villager (never as an adult-age baby: a baby
/// stays a baby for good).
pub(super) fn convert_to_zombie_villager(from: &Mob, to: &mut Mob) {
carry_over(from, to);
to.extra.age = if from.is_baby() { i32::MIN / 2 } else { 0 };
}
/// A cured zombie villager becomes a villager again, queasy for 10 seconds.
pub(super) fn convert_to_villager(from: &Mob, to: &mut Mob) {
carry_over(from, to);
to.extra.age = if from.is_baby() { -24000 } else { 0 };
to.add_effect("minecraft:nausea", 200, 0);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn zombies_convert_by_difficulty() {
assert!(infects(Difficulty::Hard, || unreachable!()));
assert!(!infects(Difficulty::Easy, || false));
assert!(!infects(Difficulty::Peaceful, || false));
// Normal: a coin toss that spares the villager when it is true.
assert!(infects(Difficulty::Normal, || false));
assert!(!infects(Difficulty::Normal, || true));
}
#[test]
fn every_zombie_kind_infects() {
for s in [
Species::Zombie,
Species::Husk,
Species::Drowned,
Species::ZombieVillager,
Species::ZombifiedPiglin,
] {
assert!(is_zombie(s));
}
assert!(!is_zombie(Species::Skeleton) && !is_zombie(Species::Villager));
}
}
+356
View File
@@ -0,0 +1,356 @@
//! Encoding resident chunks for the wire: ClientboundLevelChunkWithLightPacket
//! (sections with their paletted containers, block entities and the sky and
//! block DataLayers) and the section block-change batches.
use crate::{
chunk::{Blocks, Chunk, Light, MIN_Y, SECTIONS, Section},
containers::BlockEntity,
};
use horizon_protocol::{
buf::set_bit,
chunk::{BIOMES, BLOCKS, BlockEntityInfo, ChunkData, LightData, Paletted, Strategy},
packets::play::LevelChunkWithLight,
registry::{Builtin, ceil_log2},
};
use horizon_world::nbt::Tag;
use std::{collections::HashMap, sync::Arc};
const NON_AIR: u8 = 1;
const FLUID: u8 = 2;
const ENTITY: u8 = 4;
/// The vanilla block entity type of a block (BlockEntityType.validBlocks).
pub fn block_entity_type(name: &str) -> Option<&'static str> {
let n = name.strip_prefix("minecraft:")?;
Some(match n {
"chest" => "minecraft:chest",
"trapped_chest" => "minecraft:trapped_chest",
"ender_chest" => "minecraft:ender_chest",
"barrel" => "minecraft:barrel",
"furnace" => "minecraft:furnace",
"blast_furnace" => "minecraft:blast_furnace",
"smoker" => "minecraft:smoker",
"hopper" => "minecraft:hopper",
"dispenser" => "minecraft:dispenser",
"dropper" => "minecraft:dropper",
"brewing_stand" => "minecraft:brewing_stand",
"beacon" => "minecraft:beacon",
"bell" => "minecraft:bell",
"campfire" | "soul_campfire" => "minecraft:campfire",
"enchanting_table" => "minecraft:enchanting_table",
"jukebox" => "minecraft:jukebox",
"lectern" => "minecraft:lectern",
"spawner" => "minecraft:mob_spawner",
"comparator" => "minecraft:comparator",
"daylight_detector" => "minecraft:daylight_detector",
"conduit" => "minecraft:conduit",
"decorated_pot" => "minecraft:decorated_pot",
"moving_piston" => "minecraft:piston",
"structure_block" => "minecraft:structure_block",
"jigsaw" => "minecraft:jigsaw",
"command_block" | "chain_command_block" | "repeating_command_block" => {
"minecraft:command_block"
}
"end_portal" => "minecraft:end_portal",
"end_gateway" => "minecraft:end_gateway",
"sculk_sensor" => "minecraft:sculk_sensor",
"calibrated_sculk_sensor" => "minecraft:calibrated_sculk_sensor",
"sculk_catalyst" => "minecraft:sculk_catalyst",
"sculk_shrieker" => "minecraft:sculk_shrieker",
"crafter" => "minecraft:crafter",
"chiseled_bookshelf" => "minecraft:chiseled_bookshelf",
"trial_spawner" => "minecraft:trial_spawner",
"vault" => "minecraft:vault",
"beehive" | "bee_nest" => "minecraft:beehive",
"suspicious_sand" | "suspicious_gravel" => "minecraft:brushable_block",
"creaking_heart" => "minecraft:creaking_heart",
"test_block" => "minecraft:test_block",
"test_instance_block" => "minecraft:test_instance_block",
n if n.ends_with("shulker_box") => "minecraft:shulker_box",
n if n.ends_with("_wall_hanging_sign") || n.ends_with("_hanging_sign") => {
"minecraft:hanging_sign"
}
n if n.ends_with("_sign") => "minecraft:sign",
n if n.ends_with("_banner") => "minecraft:banner",
n if n.ends_with("_head") || n.ends_with("_skull") => "minecraft:skull",
n if n.ends_with("_shelf") => "minecraft:shelf",
n if n.ends_with("copper_golem_statue") => "minecraft:copper_golem_statue",
_ => return None,
})
}
/// Per-state facts and registry ids for encoding chunks.
pub struct ChunkEncoder {
flags: Vec<u8>,
/// Block entity type id per state (-1 for none).
entity_types: Vec<i16>,
/// Network biome id per internal biome index.
pub biome_ids: Vec<i32>,
biome_bits: u8,
/// The block registry id of each state's block, for BlockEvent.
pub block_ids: Vec<i32>,
}
impl ChunkEncoder {
/// `biome_names`: the internal biome list in order; `biome_registry`:
/// the synchronized biome entries in network order.
pub fn new(
states: impl IntoIterator<Item = (Arc<str>, bool)>,
builtin: &Builtin,
biome_names: &[String],
biome_registry: &[String],
) -> Self {
let types = builtin.get("minecraft:block_entity_type");
let blocks = builtin.get("minecraft:block");
let mut flags = Vec::new();
let mut entity_types = Vec::new();
let mut block_ids = Vec::new();
for (name, has_fluid) in states {
let air = matches!(
&*name,
"minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
);
let mut f = 0u8;
if !air {
f |= NON_AIR;
if has_fluid {
f |= FLUID;
}
}
let t = block_entity_type(&name)
.and_then(|t| types.and_then(|ids| ids.id(t)))
.map_or(-1, |v| v as i16);
if t >= 0 {
f |= ENTITY;
}
flags.push(f);
entity_types.push(t);
block_ids.push(blocks.and_then(|b| b.id(&name)).unwrap_or(0));
}
let biome_ids = biome_names
.iter()
.map(|n| {
biome_registry
.iter()
.position(|b| b == n)
.map_or(0, |i| i as i32)
})
.collect();
Self {
flags,
entity_types,
biome_ids,
biome_bits: ceil_log2(biome_registry.len()),
block_ids,
}
}
pub fn entity_type(&self, state: u16) -> Option<i32> {
self.entity_types
.get(usize::from(state))
.filter(|t| **t >= 0)
.map(|t| i32::from(*t))
}
pub fn is_air(&self, state: u16) -> bool {
self.flags
.get(usize::from(state))
.is_none_or(|f| f & NON_AIR == 0)
}
fn section(
&self,
section: &Section,
chunk: &Chunk,
index: usize,
) -> (horizon_protocol::chunk::Section, bool) {
let mut values = Vec::with_capacity(BLOCKS);
let (mut non_empty, mut fluids, mut entities) = (0i16, 0i16, false);
let mut count = |state: u16, n: i16| {
let f = self.flags.get(usize::from(state)).copied().unwrap_or(0);
if f & NON_AIR != 0 {
non_empty += n;
if f & FLUID != 0 {
fluids += n;
}
}
f & ENTITY != 0
};
match &section.blocks {
Blocks::Uniform(v) => {
entities |= count(*v, BLOCKS as i16);
values.resize(BLOCKS, i32::from(*v));
}
Blocks::Full(a) => {
for &v in a.iter() {
entities |= count(v, 1);
values.push(i32::from(v));
}
}
}
let biome_values: Vec<i32> = (0..BIOMES)
.map(|j| {
let internal = chunk.biomes.get(index * BIOMES + j).copied().unwrap_or(0);
self.biome_ids
.get(usize::from(internal))
.copied()
.unwrap_or(0)
})
.collect();
(
horizon_protocol::chunk::Section {
non_empty,
fluids,
states: Paletted::from_values(&values, Strategy::Blocks, 16),
biomes: Paletted::from_values(&biome_values, Strategy::Biomes, self.biome_bits),
},
entities,
)
}
/// The chunk column with its light and block entities.
pub fn encode(
&self,
chunk: &Chunk,
block_entities: &HashMap<(i32, i32, i32), BlockEntity>,
) -> LevelChunkWithLight {
let mut sections = Vec::with_capacity(SECTIONS);
let mut entity_infos = Vec::new();
for (i, s) in chunk.sections.iter().enumerate() {
let (encoded, has_entities) = self.section(s, chunk, i);
if has_entities {
for y in 0..16 {
for z in 0..16 {
for x in 0..16 {
let state = s.get(crate::chunk::index(x, y, z));
if let Some(kind) = self.entity_type(state) {
let wy = MIN_Y + (i as i32) * 16 + y;
let pos = (chunk.x * 16 + x, wy, chunk.z * 16 + z);
entity_infos.push(BlockEntityInfo {
packed_xz: ((x << 4) | z) as i8,
y: wy as i16,
kind,
tag: block_entities
.get(&pos)
.and_then(entity_tag)
.unwrap_or_else(
|| Tag::compound(Vec::<(&str, Tag)>::new()),
),
});
}
}
}
}
}
sections.push(encoded);
}
LevelChunkWithLight {
x: chunk.x,
z: chunk.z,
chunk: ChunkData {
heightmaps: Vec::new(),
buffer: ChunkData::from_sections(&sections),
block_entities: entity_infos,
},
light: light_data(chunk),
}
}
}
/// The update tag of a block entity (getUpdateTag) for what the client shows.
pub fn entity_tag(entity: &BlockEntity) -> Option<Tag> {
match entity {
BlockEntity::Sign(sign) => Some(Tag::compound(sign.encode())),
BlockEntity::Jukebox(_) | BlockEntity::Lectern(_) => None,
_ => None,
}
}
/// Light sections run from one below the world to one above it.
fn light_data(chunk: &Chunk) -> LightData {
let mut data = LightData {
sky_mask: Vec::new(),
block_mask: Vec::new(),
empty_sky_mask: Vec::new(),
empty_block_mask: Vec::new(),
sky: Vec::new(),
block: Vec::new(),
};
// The section below the world has no sky light; the one above is full.
set_bit(&mut data.empty_sky_mask, 0);
set_bit(&mut data.empty_block_mask, 0);
for (i, s) in chunk.sections.iter().enumerate() {
let bit = i + 1;
let (mut sky, mut block) = (vec![0u8; 2048], vec![0u8; 2048]);
let (mut sky_any, mut block_any) = (false, false);
match &s.light {
Light::Uniform(v) => {
let (sk, bl) = (v >> 4, v & 15);
sky_any = sk != 0;
block_any = bl != 0;
let (sb, bb) = (sk | sk << 4, bl | bl << 4);
sky.fill(sb);
block.fill(bb);
}
Light::Full(a) => {
for (j, &v) in a.iter().enumerate() {
let (sk, bl) = (v >> 4, v & 15);
sky_any |= sk != 0;
block_any |= bl != 0;
if j & 1 == 0 {
sky[j >> 1] |= sk;
block[j >> 1] |= bl;
} else {
sky[j >> 1] |= sk << 4;
block[j >> 1] |= bl << 4;
}
}
}
}
if sky_any {
set_bit(&mut data.sky_mask, bit);
data.sky.push(sky);
} else {
set_bit(&mut data.empty_sky_mask, bit);
}
if block_any {
set_bit(&mut data.block_mask, bit);
data.block.push(block);
} else {
set_bit(&mut data.empty_block_mask, bit);
}
}
set_bit(&mut data.sky_mask, SECTIONS + 1);
data.sky.push(vec![0xFF; 2048]);
set_bit(&mut data.empty_block_mask, SECTIONS + 1);
data
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn block_entity_blocks_are_recognised() {
assert_eq!(
block_entity_type("minecraft:oak_sign"),
Some("minecraft:sign")
);
assert_eq!(
block_entity_type("minecraft:oak_wall_hanging_sign"),
Some("minecraft:hanging_sign")
);
assert_eq!(
block_entity_type("minecraft:red_shulker_box"),
Some("minecraft:shulker_box")
);
assert_eq!(block_entity_type("minecraft:stone"), None);
}
#[test]
fn light_masks_cover_the_world_plus_borders() {
let chunk = Chunk::empty(0, 0);
let data = light_data(&chunk);
// Default sections are full sky light and no block light.
assert_eq!(data.sky.len(), SECTIONS + 1);
assert_eq!(data.block.len(), 0);
assert_eq!(data.sky[0][0], 0xFF);
assert!(horizon_protocol::buf::bit(&data.empty_block_mask, 5));
}
}
+395
View File
@@ -0,0 +1,395 @@
//! One accepted connection: handshake, status ping, offline-mode login and the
//! configuration phase (ServerStatusPacketListenerImpl,
//! ServerLoginPacketListenerImpl, ServerConfigurationPacketListenerImpl). A
//! player that completes configuration continues in the play state: the
//! reader forwards decoded packets to the game thread while a writer thread
//! frames, compresses and encrypts what the game queues, and answers the
//! keep-alive schedule on its own so a long frame never times a client out.
use super::{
Joined, NetEvent, Out, Shared,
data::{CORE_PACK, SyncData},
};
use horizon_protocol::{
PROTOCOL_VERSION,
connection::{ConnReader, ConnWriter, Connection},
crypto::offline_uuid,
packets::{
Empty,
configuration::{self as cfg, ClientInformation, KnownPack},
handshake, login, play, status,
},
text::translatable,
};
use std::{
net::TcpStream,
sync::{
Arc,
atomic::{AtomicI32, AtomicI64, AtomicUsize, Ordering},
mpsc::{Receiver, RecvTimeoutError, Sender, channel},
},
time::{Duration, Instant},
};
/// ServerCommonPacketListenerImpl.KEEPALIVE_TIME and the disconnect timeout.
const KEEP_ALIVE_EVERY: Duration = Duration::from_secs(15);
const KEEP_ALIVE_TIMEOUT: Duration = Duration::from_secs(30);
/// Packets queued for one client beyond this many bytes disconnect it.
const MAX_PENDING: usize = 96 << 20;
/// Connection.setupCompression threshold of the integrated server.
const COMPRESSION_THRESHOLD: i32 = 256;
/// Vanilla's server-side disconnect during login is a JSON component.
fn login_disconnect(c: &mut Connection, key: &str) {
let json = format!("{{\"translate\":\"{key}\"}}");
let _ =
c.send(&login::Clientbound::Disconnect(login::Disconnect { reason_json: json }).encode());
}
/// StringUtil.isValidPlayerName.
pub fn valid_name(name: &str) -> bool {
(1..=16).contains(&name.len()) && name.chars().all(|c| c as u32 > 32 && (c as u32) < 127)
}
/// The sending half given to the game thread.
#[derive(Clone)]
pub struct PlayerSender {
pub tx: Sender<Out>,
pub pending: Arc<AtomicUsize>,
}
impl PlayerSender {
pub fn send(&self, body: Vec<u8>) {
self.pending.fetch_add(body.len(), Ordering::Relaxed);
let _ = self.tx.send(Out::Packet(body));
}
}
pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
let e = |e: horizon_protocol::Error| e.to_string();
let mut c = Connection::from_stream(stream).map_err(e)?;
c.reader
.set_read_timeout(Some(Duration::from_secs(30)))
.map_err(e)?;
let (id, payload) = c.recv().map_err(e)?;
let intention = match handshake::Serverbound::decode(id, &payload).map_err(e)? {
handshake::Serverbound::Intention(i) => i,
_ => return Err("expected a handshake".into()),
};
match intention.intent {
handshake::STATUS => serve_status(&mut c, &shared),
handshake::LOGIN | handshake::TRANSFER => {
if intention.protocol != PROTOCOL_VERSION {
let key = if intention.protocol < PROTOCOL_VERSION {
"multiplayer.disconnect.outdated_client"
} else {
"multiplayer.disconnect.incompatible"
};
let json = format!(
"{{\"translate\":\"{key}\",\"with\":[\"{}\"]}}",
horizon_protocol::GAME_VERSION
);
let _ = c.send(
&login::Clientbound::Disconnect(login::Disconnect { reason_json: json })
.encode(),
);
return Ok(());
}
serve_login(c, &shared)
}
other => Err(format!("unknown intent {other}")),
}
}
fn serve_status(c: &mut Connection, shared: &Shared) -> Result<(), String> {
let e = |e: horizon_protocol::Error| e.to_string();
loop {
let (id, payload) = c.recv().map_err(e)?;
match status::Serverbound::decode(id, &payload).map_err(e)? {
status::Serverbound::StatusRequest(_) => {
let json = shared.status_json();
c.send(
&status::Clientbound::StatusResponse(status::StatusResponse { json }).encode(),
)
.map_err(e)?;
}
status::Serverbound::PingRequest(p) => {
c.send(&status::Clientbound::PongResponse(p).encode())
.map_err(e)?;
return Ok(());
}
status::Serverbound::Unknown(..) => return Ok(()),
}
}
}
fn serve_login(mut c: Connection, shared: &Arc<Shared>) -> Result<(), String> {
let e = |e: horizon_protocol::Error| e.to_string();
let (id, payload) = c.recv().map_err(e)?;
let hello = match login::Serverbound::decode(id, &payload).map_err(e)? {
login::Serverbound::Hello(h) => h,
_ => return Err("expected a login hello".into()),
};
if !valid_name(&hello.name) {
login_disconnect(&mut c, "multiplayer.disconnect.invalid_name");
return Ok(());
}
// Offline mode: the profile is derived from the name (PlayerList.canPlayerLogin
// then rejects duplicates and a full server).
let uuid = offline_uuid(&hello.name);
if let Some(reason) = shared.try_admit(uuid, &hello.name) {
login_disconnect(&mut c, reason);
return Ok(());
}
let result = login_and_configure(&mut c, shared, uuid, &hello.name);
match result {
Ok(Some(parts)) => {
play(c, shared, parts);
Ok(())
}
Ok(None) => {
shared.release(uuid);
Ok(())
}
Err(err) => {
shared.release(uuid);
Err(err)
}
}
}
struct Parts {
uuid: u128,
name: String,
info: ClientInformation,
brand: String,
}
fn login_and_configure(
c: &mut Connection,
shared: &Arc<Shared>,
uuid: u128,
name: &str,
) -> Result<Option<Parts>, String> {
let e = |e: horizon_protocol::Error| e.to_string();
c.send(
&login::Clientbound::Compression(login::Compression {
threshold: COMPRESSION_THRESHOLD,
})
.encode(),
)
.map_err(e)?;
c.set_compression(COMPRESSION_THRESHOLD);
c.send(
&login::Clientbound::LoginFinished(login::LoginFinished {
profile: login::GameProfile {
uuid,
name: name.to_owned(),
properties: Vec::new(),
},
session: uuid,
})
.encode(),
)
.map_err(e)?;
// The client may send its settings before acknowledging the login.
loop {
let (id, payload) = c.recv().map_err(e)?;
match login::Serverbound::decode(id, &payload).map_err(e)? {
login::Serverbound::LoginAcknowledged(_) => break,
login::Serverbound::CustomQueryAnswer(_) | login::Serverbound::CookieResponse(_) => {}
_ => return Err("unexpected packet during login".into()),
}
}
// Configuration.
let sync: &SyncData = &shared.sync;
let send = |c: &mut Connection, p: cfg::Clientbound| c.send(&p.encode()).map_err(e);
send(
c,
cfg::Clientbound::CustomPayload(cfg::CustomPayload {
channel: "minecraft:brand".into(),
data: {
let mut w = horizon_protocol::buf::Writer::new();
w.string("horizon");
w.data
},
}),
)?;
send(
c,
cfg::Clientbound::UpdateEnabledFeatures(cfg::UpdateEnabledFeatures {
features: sync.features.clone(),
}),
)?;
let core = KnownPack {
namespace: CORE_PACK.0.into(),
id: CORE_PACK.1.into(),
version: CORE_PACK.2.into(),
};
send(
c,
cfg::Clientbound::SelectKnownPacks(cfg::SelectKnownPacks {
packs: vec![core.clone()],
}),
)?;
let mut info = ClientInformation::new(10);
let mut brand = String::from("vanilla");
let known_pack = loop {
let (id, payload) = c.recv().map_err(e)?;
match cfg::Serverbound::decode(id, &payload).map_err(e)? {
cfg::Serverbound::ClientInformation(i) => info = i,
cfg::Serverbound::CustomPayload(p) if p.channel == "minecraft:brand" => {
brand = horizon_protocol::buf::Reader::new(&p.data)
.string(32767)
.unwrap_or(brand);
}
cfg::Serverbound::SelectKnownPacks(p) => break p.packs == vec![core.clone()],
_ => {}
}
};
for packet in sync.registry_packets(known_pack) {
send(c, cfg::Clientbound::RegistryData(packet))?;
}
send(c, cfg::Clientbound::UpdateTags(sync.tags.clone()))?;
send(c, cfg::Clientbound::FinishConfiguration(Empty))?;
loop {
let (id, payload) = c.recv().map_err(e)?;
match cfg::Serverbound::decode(id, &payload).map_err(e)? {
cfg::Serverbound::FinishConfiguration(_) => break,
cfg::Serverbound::ClientInformation(i) => info = i,
_ => {}
}
}
Ok(Some(Parts {
uuid,
name: name.to_owned(),
info,
brand,
}))
}
fn play(c: Connection, shared: &Arc<Shared>, parts: Parts) {
let conn_id = shared.next_id();
let events = shared.events.clone();
let _ = c.reader.set_read_timeout(Some(KEEP_ALIVE_TIMEOUT));
let (mut reader, writer) = c.split();
let (tx, rx) = channel();
let pending = Arc::new(AtomicUsize::new(0));
let latency = Arc::new(AtomicI32::new(0));
let alive = Arc::new(AtomicI64::new(-1));
let sender = PlayerSender {
tx: tx.clone(),
pending: pending.clone(),
};
let writer_thread = {
let (alive, latency, pending) = (alive.clone(), latency.clone(), pending.clone());
std::thread::Builder::new()
.name(format!("horizon-lan-out-{conn_id}"))
.spawn(move || write_loop(writer, rx, alive, latency, pending))
.ok()
};
let joined = Joined {
conn: conn_id,
uuid: parts.uuid,
name: parts.name,
info: parts.info,
brand: parts.brand,
sender,
latency,
};
let reason = if events.send(NetEvent::Joined(Box::new(joined))).is_ok() {
read_loop(&mut reader, conn_id, &events, &alive)
} else {
"server closed".to_owned()
};
let _ = tx.send(Out::Close);
let _ = events.send(NetEvent::Left(conn_id, reason));
if let Some(t) = writer_thread {
let _ = t.join();
}
shared.release(parts.uuid);
}
fn read_loop(
reader: &mut ConnReader,
conn: u32,
events: &Sender<NetEvent>,
alive: &AtomicI64,
) -> String {
loop {
let (id, payload) = match reader.recv() {
Ok(p) => p,
Err(e) => return e.to_string(),
};
match play::Serverbound::decode(id, &payload) {
Ok(play::Serverbound::KeepAlive(k)) => alive.store(k.id, Ordering::Relaxed),
Ok(p) => {
if events.send(NetEvent::Packet(conn, Box::new(p))).is_err() {
return "server closed".to_owned();
}
}
// A malformed packet disconnects like vanilla's decoder exception.
Err(e) => return format!("Invalid packet {id}: {e}"),
}
}
}
fn write_loop(
mut writer: ConnWriter,
rx: Receiver<Out>,
alive: Arc<AtomicI64>,
latency: Arc<AtomicI32>,
pending: Arc<AtomicUsize>,
) {
let start = Instant::now();
let mut sent_at: Option<(i64, Instant)> = None;
let mut next = Instant::now() + KEEP_ALIVE_EVERY;
loop {
match rx.recv_timeout(Duration::from_millis(200)) {
Ok(Out::Packet(body)) => {
pending.fetch_sub(body.len(), Ordering::Relaxed);
if writer.send(&body).is_err() {
break;
}
if pending.load(Ordering::Relaxed) > MAX_PENDING {
break;
}
}
Ok(Out::Disconnect(reason)) => {
let _ = writer
.send(&play::Clientbound::Disconnect(cfg::Disconnect { reason }).encode());
std::thread::sleep(Duration::from_millis(50));
break;
}
Ok(Out::Close) | Err(RecvTimeoutError::Disconnected) => break,
Err(RecvTimeoutError::Timeout) => {}
}
let now = Instant::now();
if let Some((id, at)) = sent_at {
if alive.load(Ordering::Relaxed) == id {
let ms = i32::try_from(at.elapsed().as_millis()).unwrap_or(i32::MAX);
let old = latency.load(Ordering::Relaxed);
latency.store((old * 3 + ms) / 4, Ordering::Relaxed);
sent_at = None;
} else if at.elapsed() > KEEP_ALIVE_TIMEOUT {
let _ = writer.send(
&play::Clientbound::Disconnect(cfg::Disconnect {
reason: translatable("disconnect.timeout", &[]),
})
.encode(),
);
break;
}
}
if sent_at.is_none() && now >= next {
let id = i64::try_from(start.elapsed().as_millis()).unwrap_or(0);
if writer
.send(&play::Clientbound::KeepAlive(cfg::KeepAlive { id }).encode())
.is_err()
{
break;
}
sent_at = Some((id, now));
next = now + KEEP_ALIVE_EVERY;
}
}
writer.shutdown();
}
+393
View File
@@ -0,0 +1,393 @@
//! Hub operations on what guests perceive and do beyond the basics: sounds,
//! level events, animations and block containers with their clicks.
use super::{
hub::Hub,
menu::{self, Menu, Rules, View},
};
use crate::{items::ItemStack, world::World};
use horizon_protocol::{
item::Hashed,
packets::play::{self, Clientbound as C},
};
use horizon_world::nbt::Tag;
use std::collections::HashMap;
impl Hub {
pub fn send_to(&self, conn: u32, packet: &C) {
if let Some(g) = self.guest(conn) {
g.send(packet);
}
}
/// Send to every placed guest within `range` blocks of `at`.
pub fn broadcast_near(&self, at: [f64; 3], range: f64, packet: &C, except: Option<u32>) {
let body = packet.encode();
for g in self
.guests
.iter()
.filter(|g| g.placed && Some(g.conn) != except)
{
let d: f64 = (0..3).map(|k| (g.position[k] - at[k]).powi(2)).sum();
if d <= range * range {
g.sender.send(body.clone());
}
}
}
/// ClientboundSoundPacket for a sound event name (an inline event when
/// the registry does not know it).
pub fn sound(
&self,
name: &str,
at: [f64; 3],
volume: f32,
pitch: f32,
source: i32,
except: Option<u32>,
) {
let sound = match self.sync.id("minecraft:sound_event", name) {
Some(id) => (id, None),
None => (-1, Some((name.to_owned(), None))),
};
let packet = C::Sound(play::Sound {
sound,
source,
x: (at[0] * 8.0) as i32,
y: (at[1] * 8.0) as i32,
z: (at[2] * 8.0) as i32,
volume,
pitch,
seed: self.ticks as i64,
});
self.broadcast_near(at, f64::from(volume.max(1.0)) * 16.0, &packet, except);
}
/// ClientboundLevelEventPacket (block break particles and sounds ...).
pub fn level_event(&self, kind: i32, pos: [i32; 3], data: i32, except: Option<u32>) {
let at = [f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])];
self.broadcast_near(
at,
64.0,
&C::LevelEvent(play::LevelEvent {
kind,
pos,
data,
global: false,
}),
except,
);
}
pub fn entity_event(&self, id: i32, event: i8, at: [f64; 3]) {
self.broadcast_near(
at,
128.0,
&C::EntityEvent(play::EntityEvent { id, event }),
None,
);
}
pub fn swing(&self, id: i32, hand: i32, at: [f64; 3], except: Option<u32>) {
self.broadcast_near(
at,
128.0,
&C::SwingAnimation(play::SwingAnimation {
id,
hand,
kind: 1,
duration: 6,
}),
except,
);
}
pub fn take_item(&self, item: i32, collector: i32, count: i32, at: [f64; 3]) {
self.broadcast_near(
at,
64.0,
&C::TakeItemEntity(play::TakeItemEntity {
item,
player: collector,
amount: count,
}),
None,
);
}
/// Open a block container for a guest (ServerPlayer.openMenu).
pub fn open_container(
&mut self,
conn: u32,
menu_kind: &str,
title: Tag,
pos: (i32, i32, i32),
items: Vec<Option<ItemStack>>,
) {
let Some(kind) = self
.sync
.builtin
.get("minecraft:menu")
.and_then(|m| m.id(menu_kind))
else {
return;
};
let Some(i) = self.guests.iter().position(|g| g.conn == conn) else {
return;
};
self.close_container_at(i);
let g = &mut self.guests[i];
g.next_window = g.next_window % 100 + 1;
let window = g.next_window;
g.send(&C::OpenScreen(play::OpenScreen {
container: window,
menu: kind,
title,
}));
g.menu = Some(Menu {
window,
kind,
pos: Some(pos),
size: items.len(),
state: 0,
sent: Vec::new(),
drag: None,
});
self.send_menu_content(i, items);
}
fn send_menu_content(&mut self, i: usize, mut items: Vec<Option<ItemStack>>) {
for j in 0..36 {
items.push(self.guests[i].inventory[player_slot(j)].clone());
}
let net: Vec<_> = items.iter().map(|s| self.stack(s)).collect();
let carried = self.guests[i].carried.clone();
let carried = self.stack(&carried);
let g = &mut self.guests[i];
let Some(menu) = g.menu.as_mut() else {
return;
};
menu.state = (menu.state + 1) & 0x7FFF;
let packet = C::ContainerSetContent(play::ContainerSetContent {
container: menu.window,
state: menu.state,
items: net,
carried,
});
menu.sent = items;
g.send(&packet);
}
fn close_container_at(&mut self, i: usize) {
let g = &mut self.guests[i];
if let Some(menu) = g.menu.take() {
g.send(&C::ContainerClose(play::ContainerClose {
container: menu.window,
}));
}
}
pub(super) fn close_container_for(&mut self, i: usize) {
self.close_container_at(i);
}
pub fn close_container(&mut self, conn: u32) {
if let Some(i) = self.guests.iter().position(|g| g.conn == conn) {
self.close_container_at(i);
}
}
/// The client closed its window.
pub fn container_closed(&mut self, conn: u32, window: i32) {
if let Some(g) = self.guest_mut(conn)
&& g.menu.as_ref().is_some_and(|m| m.window == window)
{
g.menu = None;
}
}
fn hashed_matches(&mut self, claimed: &Option<Hashed>, mine: &Option<ItemStack>) -> bool {
match (claimed, mine) {
(None, None) => true,
(Some(h), Some(s)) => h.item == self.item_id(&s.item) && h.count == s.count as i32,
_ => false,
}
}
fn view_slot(&self, i: usize, world: &World, slot: usize) -> Option<ItemStack> {
let g = &self.guests[i];
match &g.menu {
Some(m) if slot < m.size => {
let e = world.block_entities.get(&m.pos?)?;
e.slots().get(slot).cloned().flatten()
}
Some(m) => g
.inventory
.get(player_slot(slot - m.size))
.cloned()
.flatten(),
None => g.menu_slot(slot),
}
}
/// ServerGamePacketListenerImpl.handleContainerClick. Returns the stacks
/// thrown out of the menu.
pub fn container_click(
&mut self,
conn: u32,
p: play::ContainerClick,
world: &mut World,
rules: &dyn Rules,
) -> Vec<ItemStack> {
let Some(i) = self.guests.iter().position(|g| g.conn == conn) else {
return Vec::new();
};
let in_menu = p.container != 0;
let window_ok = !in_menu
|| self.guests[i]
.menu
.as_ref()
.is_some_and(|m| m.window == p.container);
if !window_ok || self.guests[i].spectator() {
return Vec::new();
}
let pos = self.guests[i].menu.as_ref().and_then(|m| m.pos);
let mut drag = if in_menu {
self.guests[i].menu.as_mut().and_then(|m| m.drag.take())
} else {
self.guests[i].drag.take()
};
let (drops, changed) = {
let guest = &mut self.guests[i];
let mut entity = pos.and_then(|k| world.block_entities.get_mut(&k));
let slots = entity.as_mut().map(|e| e.slots_mut());
if in_menu && slots.is_none() {
return Vec::new();
}
let mut view = View {
guest,
container: slots,
};
menu::click(
&mut view,
&mut drag,
i32::from(p.slot),
i32::from(p.button),
p.input,
rules,
)
};
if in_menu {
if let Some(m) = self.guests[i].menu.as_mut() {
m.drag = drag;
}
} else {
self.guests[i].drag = drag;
}
// Tell the client about every slot it got wrong, or that it did not claim.
let claimed: HashMap<usize, Option<Hashed>> = p
.changed
.iter()
.map(|(s, h)| (*s as usize, h.clone()))
.collect();
let total = if in_menu {
self.guests[i].menu.as_ref().map_or(0, |m| m.size) + 36
} else {
46
};
let mut resend: Vec<usize> = Vec::new();
for slot in 0..total {
let mine = self.view_slot(i, world, slot);
let agreed = match claimed.get(&slot) {
Some(c) => self.hashed_matches(c, &mine),
None => !changed.contains(&slot),
};
if !agreed {
resend.push(slot);
}
}
for slot in resend {
let mine = self.view_slot(i, world, slot);
let net = self.stack(&mine);
let g = &mut self.guests[i];
let state = if in_menu {
g.menu.as_mut().map_or(0, |m| {
m.state = (m.state + 1) & 0x7FFF;
m.state
})
} else {
g.menu_state = (g.menu_state + 1) & 0x7FFF;
g.menu_state
};
g.send(&C::ContainerSetSlot(play::ContainerSetSlot {
container: p.container,
state,
slot: slot as i16,
item: net,
}));
}
let carried = self.guests[i].carried.clone();
if !self.hashed_matches(&p.carried, &carried) {
let net = self.stack(&carried);
self.guests[i].send(&C::SetCursorItem(play::SetCursorItem { item: net }));
}
// What the client now believes equals the server's state.
let items: Vec<_> = (0..total).map(|s| self.view_slot(i, world, s)).collect();
if in_menu {
if let Some(m) = self.guests[i].menu.as_mut() {
m.sent = items;
}
} else {
self.guests[i].menu_sent = items;
}
drops
}
/// Slot changes of open containers (AbstractContainerMenu.broadcastChanges).
pub fn sync_containers(&mut self, world: &World) {
for i in 0..self.guests.len() {
let Some(menu) = self.guests[i]
.menu
.as_ref()
.filter(|_| self.guests[i].placed)
else {
continue;
};
let (size, window, pos) = (menu.size, menu.window, menu.pos);
if !pos.is_some_and(|k| world.block_entities.contains_key(&k)) {
self.close_container_at(i);
continue;
}
for slot in 0..size + 36 {
let now = self.view_slot(i, world, slot);
let sent = self.guests[i]
.menu
.as_ref()
.and_then(|m| m.sent.get(slot).cloned());
if sent.as_ref() == Some(&now) {
continue;
}
let net = self.stack(&now);
let g = &mut self.guests[i];
if let Some(m) = g.menu.as_mut() {
m.state = (m.state + 1) & 0x7FFF;
let state = m.state;
if m.sent.len() <= slot {
m.sent.resize(slot + 1, None);
}
m.sent[slot] = now;
g.send(&C::ContainerSetSlot(play::ContainerSetSlot {
container: window,
state,
slot: slot as i16,
item: net,
}));
}
}
}
}
}
/// Inventory index of the n-th player slot of a container menu (27 main, then the hotbar).
fn player_slot(n: usize) -> usize {
if n < 27 { 9 + n } else { n - 27 }
}
+282
View File
@@ -0,0 +1,282 @@
//! What the configuration phase sends: the synchronized registries (names in
//! network order, with their data for clients that do not know the vanilla
//! pack) and the tags of every registry, loaded from the prepared resources
//! (`data/minecraft/...`) and the registries report.
use horizon_protocol::{
packets::configuration::{RegistryData, RegistryEntry, RegistryTags, TagEntry, UpdateTags},
registry::{Builtin, Dynamic},
};
use horizon_world::nbt::{JavaString, Tag};
use serde_json::Value;
use std::{
collections::{BTreeMap, HashMap, HashSet},
path::{Path, PathBuf},
};
/// RegistryDataLoader.SYNCHRONIZED_REGISTRIES, in vanilla's order.
pub const SYNCHRONIZED: &[&str] = &[
"minecraft:worldgen/biome",
"minecraft:chat_type",
"minecraft:trim_pattern",
"minecraft:trim_material",
"minecraft:wolf_variant",
"minecraft:wolf_sound_variant",
"minecraft:pig_variant",
"minecraft:pig_sound_variant",
"minecraft:frog_variant",
"minecraft:cat_variant",
"minecraft:cat_sound_variant",
"minecraft:cow_sound_variant",
"minecraft:cow_variant",
"minecraft:chicken_sound_variant",
"minecraft:chicken_variant",
"minecraft:zombie_nautilus_variant",
"minecraft:painting_variant",
"minecraft:sulfur_cube_archetype",
"minecraft:dimension_type",
"minecraft:damage_type",
"minecraft:banner_pattern",
"minecraft:enchantment",
"minecraft:jukebox_song",
"minecraft:instrument",
"minecraft:test_environment",
"minecraft:test_instance",
"minecraft:dialog",
"minecraft:world_clock",
"minecraft:timeline",
"minecraft:decorated_pot_pattern",
"minecraft:block_transformer",
"minecraft:worldgen/block_state_provider",
];
/// KnownPack.vanilla("core") for this version.
pub const CORE_PACK: (&str, &str, &str) = ("minecraft", "core", horizon_protocol::GAME_VERSION);
/// A data-driven registry: entry names in network order and their JSON.
struct Entries {
names: Vec<String>,
json: Vec<Value>,
}
pub struct SyncData {
pub builtin: Builtin,
/// Entry names per synchronized registry (for id lookups).
pub dynamic: Dynamic,
registries: Vec<(String, Entries)>,
pub tags: UpdateTags,
pub features: Vec<String>,
}
/// Every `*.json` under `dir`, as (path without extension relative to dir, value), sorted.
fn walk(dir: &Path, prefix: &str, out: &mut BTreeMap<String, Value>) {
let Ok(read) = std::fs::read_dir(dir) else {
return;
};
for entry in read.flatten() {
let path = entry.path();
let name = entry.file_name().to_string_lossy().into_owned();
if path.is_dir() {
walk(&path, &format!("{prefix}{name}/"), out);
} else if let Some(stem) = name.strip_suffix(".json")
&& let Ok(text) = std::fs::read_to_string(&path)
&& let Ok(value) = serde_json::from_str::<Value>(&text)
{
out.insert(format!("{prefix}{stem}"), value);
}
}
}
/// A JSON value as the NBT that vanilla's NbtOps would produce from the codec
/// (integers are ints, other numbers doubles, booleans bytes).
pub fn json_to_nbt(v: &Value) -> Tag {
match v {
Value::Null => Tag::compound(Vec::<(&str, Tag)>::new()),
Value::Bool(b) => Tag::Byte(i8::from(*b)),
Value::Number(n) => match n.as_i64() {
Some(i) => match i32::try_from(i) {
Ok(i) => Tag::Int(i),
Err(_) => Tag::Long(i),
},
None => Tag::Double(n.as_f64().unwrap_or(0.0).to_bits()),
},
Value::String(s) => Tag::String(JavaString::from(s.as_str())),
Value::Array(a) => Tag::List(a.iter().map(json_to_nbt).collect()),
Value::Object(o) => Tag::compound(o.iter().map(|(k, v)| (k.as_str(), json_to_nbt(v)))),
}
}
impl SyncData {
pub fn load(resources: &Path) -> Result<Self, String> {
let builtin = Builtin::find(resources)
.and_then(|p| Builtin::load(&p).ok())
.ok_or("registries.json not found next to the resources")?;
let root: PathBuf = resources.join("data/minecraft");
let mut registries = Vec::new();
let mut dynamic = Dynamic::default();
for key in SYNCHRONIZED {
let path = key.trim_start_matches("minecraft:");
let mut found = BTreeMap::new();
walk(&root.join(path), "", &mut found);
let (names, json): (Vec<_>, Vec<_>) = found
.into_iter()
.map(|(n, v)| (format!("minecraft:{n}"), v))
.unzip();
dynamic.registries.insert(
(*key).to_owned(),
names.iter().map(|n| (n.clone(), None)).collect(),
);
registries.push(((*key).to_owned(), Entries { names, json }));
}
let tags = Self::load_tags(&root, &builtin, &dynamic);
Ok(Self {
builtin,
dynamic,
registries,
tags,
features: vec!["minecraft:vanilla".to_owned()],
})
}
/// The id of a name in a built-in or synchronized registry.
pub fn id(&self, registry: &str, name: &str) -> Option<i32> {
if let Some(ids) = self.builtin.get(registry) {
return ids.id(name);
}
self.dynamic
.registries
.get(registry)?
.iter()
.position(|(n, _)| n == name)
.map(|i| i as i32)
}
/// ClientboundRegistryDataPacket per registry. With `known_pack` the
/// client rebuilds the entries from its own data, so none is sent.
pub fn registry_packets(&self, known_pack: bool) -> Vec<RegistryData> {
self.registries
.iter()
.map(|(key, e)| RegistryData {
registry: key.clone(),
entries: e
.names
.iter()
.zip(&e.json)
.map(|(name, json)| RegistryEntry {
id: name.clone(),
data: if known_pack {
None
} else {
Some(json_to_nbt(json))
},
})
.collect(),
})
.collect()
}
fn registry_names<'a>(
builtin: &'a Builtin,
dynamic: &'a Dynamic,
key: &str,
) -> Option<HashMap<&'a str, i32>> {
if let Some(ids) = builtin.get(key) {
return Some(
ids.names
.iter()
.enumerate()
.map(|(i, n)| (n.as_str(), i as i32))
.collect(),
);
}
dynamic.registries.get(key).map(|v| {
v.iter()
.enumerate()
.map(|(i, (n, _))| (n.as_str(), i as i32))
.collect()
})
}
/// TagNetworkSerialization.serializeTagsToNetwork from the tag files.
fn load_tags(root: &Path, builtin: &Builtin, dynamic: &Dynamic) -> UpdateTags {
let tag_root = root.join("tags");
let mut registries = Vec::new();
let mut keys: Vec<String> = builtin
.registries
.keys()
.chain(dynamic.registries.keys())
.cloned()
.collect();
keys.sort();
for key in keys {
let dir = tag_root.join(key.trim_start_matches("minecraft:"));
if !dir.is_dir() {
continue;
}
let mut files = BTreeMap::new();
walk(&dir, "", &mut files);
if files.is_empty() {
continue;
}
let Some(names) = Self::registry_names(builtin, dynamic, &key) else {
continue;
};
let mut tags = Vec::new();
for name in files.keys() {
let mut ids = Vec::new();
let mut seen = HashSet::new();
Self::expand(&files, name, &names, &mut ids, &mut seen);
tags.push(TagEntry {
name: format!("minecraft:{name}"),
ids,
});
}
registries.push(RegistryTags {
registry: key,
tags,
});
}
UpdateTags { registries }
}
fn expand(
files: &BTreeMap<String, Value>,
tag: &str,
names: &HashMap<&str, i32>,
out: &mut Vec<i32>,
seen: &mut HashSet<String>,
) {
if !seen.insert(tag.to_owned()) {
return;
}
let Some(values) = files.get(tag).and_then(|v| v["values"].as_array()) else {
return;
};
for value in values {
let id = value
.as_str()
.or_else(|| value["id"].as_str())
.unwrap_or_default();
if let Some(reference) = id.strip_prefix('#') {
let reference = reference.trim_start_matches("minecraft:");
Self::expand(files, reference, names, out, seen);
} else if let Some(&n) = names.get(id)
&& !out.contains(&n)
{
out.push(n);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn json_becomes_nbt() {
let v: Value = serde_json::from_str(r#"{"a":1,"b":[true,2.5],"c":"x"}"#).unwrap();
let t = json_to_nbt(&v);
assert!(matches!(t.get("a"), Some(Tag::Int(1))));
assert!(matches!(t.get("c"), Some(Tag::String(_))));
assert!(matches!(t.get("b"), Some(Tag::List(l)) if l.len() == 2));
}
}
+314
View File
@@ -0,0 +1,314 @@
//! Entity tracking (ServerEntity / TrackedEntity): the game describes every
//! entity it simulates as an `EntityState` each tick; a `Tracker` remembers
//! what one client has been told and produces the spawn, movement, metadata,
//! equipment and removal packets that bring it up to date.
use horizon_protocol::{
buf::pack_degrees,
entity_data::Value,
item::Stack,
packets::play::{
self, AddEntity, MoveEntity, MoveEntityPos, MoveEntityPosRot, MoveEntityRot, RotateHead,
SetEntityData, SetEntityMotion, SetEquipment, TeleportEntity, VecDelta,
},
};
/// What the game says about one entity this tick.
#[derive(Clone, Debug)]
pub struct EntityState {
pub id: i32,
pub uuid: u128,
/// Registry id of the entity type (`minecraft:zombie`).
pub kind: String,
pub position: [f64; 3],
pub yaw: f32,
pub pitch: f32,
pub head_yaw: f32,
pub on_ground: bool,
pub velocity: [f64; 3],
/// ClientboundAddEntityPacket.data (item frame direction, block state ...).
pub data: i32,
/// SynchedEntityData entries that differ from the defaults.
pub meta: Vec<(u8, i32, Value)>,
/// EquipmentSlot ordinals (0 main hand, 1 off hand, 2 feet, 3 legs,
/// 4 chest, 5 head) and their stacks.
pub equipment: Vec<(u8, Option<Stack>)>,
/// Whether movement packets should include a velocity (items, projectiles).
pub send_velocity: bool,
}
/// What a client was last told about one entity.
struct Sent {
/// The position in 1/4096 blocks (VecDeltaCodec base).
base: [i64; 3],
position: [f64; 3],
rotation: (i8, i8),
head: i8,
velocity: [f64; 3],
meta: Vec<(u8, i32, Value)>,
equipment: Vec<(u8, Option<Stack>)>,
on_ground: bool,
ticks: u32,
}
#[derive(Default)]
pub struct Tracker {
sent: std::collections::HashMap<i32, Sent>,
}
fn quantize(p: [f64; 3]) -> [i64; 3] {
[
(p[0] * 4096.0).round() as i64,
(p[1] * 4096.0).round() as i64,
(p[2] * 4096.0).round() as i64,
]
}
fn dequantize(q: [i64; 3]) -> [f64; 3] {
[
q[0] as f64 / 4096.0,
q[1] as f64 / 4096.0,
q[2] as f64 / 4096.0,
]
}
impl Tracker {
pub fn is_tracking(&self, id: i32) -> bool {
self.sent.contains_key(&id)
}
pub fn ids(&self) -> Vec<i32> {
self.sent.keys().copied().collect()
}
pub fn forget(&mut self, id: i32) {
self.sent.remove(&id);
}
pub fn clear(&mut self) {
self.sent.clear();
}
pub fn len(&self) -> usize {
self.sent.len()
}
pub fn is_empty(&self) -> bool {
self.sent.is_empty()
}
/// The packets that introduce an entity (ServerEntity.sendPairingData).
pub fn spawn(&mut self, e: &EntityState, entity_type: i32) -> Vec<play::Clientbound> {
let rotation = (pack_degrees(e.pitch), pack_degrees(e.yaw));
let head = pack_degrees(e.head_yaw);
let mut out = vec![play::Clientbound::AddEntity(AddEntity {
id: e.id,
uuid: e.uuid,
kind: entity_type,
position: e.position,
velocity: e.velocity,
pitch: rotation.0,
yaw: rotation.1,
head_yaw: head,
data: e.data,
})];
if !e.meta.is_empty() {
out.push(play::Clientbound::SetEntityData(SetEntityData {
id: e.id,
values: e.meta.clone(),
}));
}
if !e.equipment.is_empty() {
out.push(play::Clientbound::SetEquipment(SetEquipment {
id: e.id,
slots: e.equipment.clone(),
}));
}
self.sent.insert(
e.id,
Sent {
base: quantize(e.position),
position: e.position,
rotation,
head,
velocity: e.velocity,
meta: e.meta.clone(),
equipment: e.equipment.clone(),
on_ground: e.on_ground,
ticks: 0,
},
);
out
}
/// Changes since the last update (ServerEntity.sendChanges).
pub fn update(&mut self, e: &EntityState) -> Vec<play::Clientbound> {
let Some(s) = self.sent.get_mut(&e.id) else {
return Vec::new();
};
let mut out = Vec::new();
s.ticks += 1;
let rotation = (pack_degrees(e.pitch), pack_degrees(e.yaw));
let rotated = rotation != s.rotation;
let now = quantize(e.position);
let delta = [now[0] - s.base[0], now[1] - s.base[1], now[2] - s.base[2]];
let moved = delta != [0; 3];
let fits = delta.iter().all(|d| i16::try_from(*d).is_ok());
if moved && !fits {
out.push(play::Clientbound::TeleportEntity(TeleportEntity {
id: e.id,
position: e.position,
delta: e.velocity,
yaw: e.yaw,
pitch: e.pitch,
relatives: 0,
on_ground: e.on_ground,
}));
s.base = now;
} else if moved || rotated || e.on_ground != s.on_ground {
let d = VecDelta::Linear([delta[0] as i16, delta[1] as i16, delta[2] as i16]);
let rot = Some((rotation.1, rotation.0));
let packet = if moved && rotated {
play::Clientbound::MoveEntityPosRot(MoveEntityPosRot(MoveEntity {
id: e.id,
delta: Some(d),
rotation: rot,
on_ground: e.on_ground,
}))
} else if moved {
play::Clientbound::MoveEntityPos(MoveEntityPos(MoveEntity {
id: e.id,
delta: Some(d),
rotation: None,
on_ground: e.on_ground,
}))
} else {
play::Clientbound::MoveEntityRot(MoveEntityRot(MoveEntity {
id: e.id,
delta: None,
rotation: rot,
on_ground: e.on_ground,
}))
};
out.push(packet);
if moved {
s.base = now;
}
}
if moved || rotated || e.on_ground != s.on_ground {
s.rotation = rotation;
s.on_ground = e.on_ground;
}
s.position = dequantize(s.base);
let head = pack_degrees(e.head_yaw);
if head != s.head {
out.push(play::Clientbound::RotateHead(RotateHead {
id: e.id,
head_yaw: head,
}));
s.head = head;
}
if e.send_velocity {
let dv: f64 = (0..3)
.map(|i| (e.velocity[i] - s.velocity[i]).powi(2))
.sum();
if dv > 1.0e-7 || (e.velocity == [0.0; 3] && s.velocity != [0.0; 3]) {
out.push(play::Clientbound::SetEntityMotion(SetEntityMotion {
id: e.id,
velocity: e.velocity,
}));
s.velocity = e.velocity;
}
}
if e.meta != s.meta {
let changed: Vec<_> = e
.meta
.iter()
.filter(|m| !s.meta.contains(m))
.cloned()
.collect();
if !changed.is_empty() {
out.push(play::Clientbound::SetEntityData(SetEntityData {
id: e.id,
values: changed,
}));
}
s.meta = e.meta.clone();
}
if e.equipment != s.equipment {
// Cleared slots are sent as empty stacks.
let mut slots: Vec<(u8, Option<Stack>)> = e
.equipment
.iter()
.filter(|m| !s.equipment.contains(m))
.cloned()
.collect();
for (slot, _) in &s.equipment {
if !e.equipment.iter().any(|(k, _)| k == slot) {
slots.push((*slot, None));
}
}
if !slots.is_empty() {
out.push(play::Clientbound::SetEquipment(SetEquipment {
id: e.id,
slots,
}));
}
s.equipment = e.equipment.clone();
}
out
}
}
#[cfg(test)]
mod tests {
use super::*;
fn state(x: f64) -> EntityState {
EntityState {
id: 7,
uuid: 1,
kind: "minecraft:zombie".into(),
position: [x, 64.0, 0.0],
yaw: 0.0,
pitch: 0.0,
head_yaw: 0.0,
on_ground: true,
velocity: [0.0; 3],
data: 0,
meta: Vec::new(),
equipment: Vec::new(),
send_velocity: false,
}
}
#[test]
fn small_moves_are_relative_and_large_ones_teleport() {
let mut t = Tracker::default();
let spawn = t.spawn(&state(0.0), 100);
assert!(matches!(spawn[0], play::Clientbound::AddEntity(_)));
assert!(t.update(&state(0.0)).is_empty());
let step = t.update(&state(0.5));
assert!(matches!(step[0], play::Clientbound::MoveEntityPos(_)));
let jump = t.update(&state(40.0));
assert!(matches!(jump[0], play::Clientbound::TeleportEntity(_)));
}
#[test]
fn metadata_and_equipment_send_only_the_changes() {
let mut t = Tracker::default();
let mut e = state(0.0);
t.spawn(&e, 100);
e.meta.push((0, 0, Value::Byte(1)));
e.equipment.push((0, Some(Stack::new(5, 1))));
let out = t.update(&e);
assert!(
out.iter()
.any(|p| matches!(p, play::Clientbound::SetEntityData(_)))
);
assert!(
out.iter()
.any(|p| matches!(p, play::Clientbound::SetEquipment(_)))
);
assert!(t.update(&e).is_empty());
e.equipment.clear();
let out = t.update(&e);
let Some(play::Clientbound::SetEquipment(eq)) = out.first() else {
panic!("expected equipment");
};
assert_eq!(eq.slots, vec![(0, None)]);
}
}
+252
View File
@@ -0,0 +1,252 @@
//! A remote player: connection, position, chunk and entity views, and the
//! player state (inventory, health, game mode) that the host's gameplay code
//! operates on when it acts for them.
use super::{Joined, PlayerSender, entity::Tracker};
use crate::{items::ItemStack, motion::PlayerMotion};
use horizon_protocol::{
item::Stack,
packets::{configuration::ClientInformation, play},
};
use std::{
collections::{HashSet, VecDeque},
sync::{Arc, atomic::AtomicI32},
};
/// GameType ids.
pub const SURVIVAL: i32 = 0;
pub const CREATIVE: i32 = 1;
pub const ADVENTURE: i32 = 2;
pub const SPECTATOR: i32 = 3;
pub struct Guest {
pub conn: u32,
pub uuid: u128,
pub name: String,
pub entity_id: i32,
pub sender: PlayerSender,
pub latency: Arc<AtomicI32>,
pub info: ClientInformation,
pub brand: String,
/// The chunk radius this client is sent.
pub view_distance: i32,
pub position: [f64; 3],
pub previous_position: [f64; 3],
pub yaw: f32,
pub pitch: f32,
pub head_yaw: f32,
pub on_ground: bool,
pub game_mode: i32,
pub sneaking: bool,
pub sprinting: bool,
pub fall_flying: bool,
pub flying: bool,
pub sleeping: bool,
/// Pending ClientboundPlayerPositionPacket id; movement is ignored until
/// the client accepts it (ServerGamePacketListenerImpl.awaitingPositionFromClient).
pub awaiting_teleport: Option<(i32, [f64; 3])>,
pub teleport_counter: i32,
/// The client finished loading terrain (ServerboundPlayerLoadedPacket).
pub loaded: bool,
// Chunks.
pub center: Option<(i32, i32)>,
pub sent_chunks: HashSet<(i32, i32)>,
pub chunk_queue: Vec<(i32, i32)>,
pub unacknowledged: u32,
pub chunks_per_tick: f32,
pub chunk_credit: f32,
// Entities.
pub tracker: Tracker,
// Player state the gameplay code reads and writes.
pub motion: Option<Box<PlayerMotion>>,
/// The 36 inventory slots (hotbar first), armor (head..feet) and off hand.
pub inventory: Vec<Option<ItemStack>>,
pub armor: [Option<ItemStack>; 4],
pub offhand: Option<ItemStack>,
pub selected: usize,
pub carried: Option<ItemStack>,
pub health: f32,
pub food: i32,
pub saturation: f32,
pub xp_level: i32,
pub xp_progress: f32,
pub xp_total: i32,
/// What the client believes the inventory menu holds (for change detection).
pub menu_sent: Vec<Option<ItemStack>>,
pub menu_state: i32,
pub sent_health: Option<(f32, i32, f32)>,
pub sent_xp: Option<(f32, i32, i32)>,
pub sent_selected: usize,
pub inbox: VecDeque<play::Serverbound>,
pub joined_tick: u64,
pub ticks: u64,
pub dead: bool,
/// The join packets were sent (PlayerList.placeNewPlayer ran).
pub placed: bool,
/// The open block container, if any.
pub menu: Option<super::menu::Menu>,
pub next_window: i32,
/// An unfinished drag in the inventory menu.
pub drag: Option<(u8, Vec<usize>)>,
/// The compound this player was loaded from, for fields Horizon does not model.
pub saved: Option<horizon_world::nbt::Tag>,
}
impl Guest {
pub fn new(j: Joined, entity_id: i32, position: [f64; 3], view_distance: i32) -> Self {
Self {
conn: j.conn,
uuid: j.uuid,
name: j.name,
entity_id,
sender: j.sender,
latency: j.latency,
view_distance: (i32::from(j.info.view_distance)).clamp(2, view_distance),
info: j.info,
brand: j.brand,
position,
previous_position: position,
yaw: 0.0,
pitch: 0.0,
head_yaw: 0.0,
on_ground: false,
game_mode: SURVIVAL,
sneaking: false,
sprinting: false,
fall_flying: false,
flying: false,
sleeping: false,
awaiting_teleport: None,
teleport_counter: 0,
loaded: false,
center: None,
sent_chunks: HashSet::new(),
chunk_queue: Vec::new(),
unacknowledged: 0,
chunks_per_tick: 9.0,
chunk_credit: 0.0,
tracker: Tracker::default(),
motion: None,
inventory: vec![None; 36],
armor: [None, None, None, None],
offhand: None,
selected: 0,
carried: None,
health: 20.0,
food: 20,
saturation: 5.0,
xp_level: 0,
xp_progress: 0.0,
xp_total: 0,
menu_sent: vec![None; 46],
menu_state: 0,
sent_health: None,
sent_xp: None,
sent_selected: 0,
inbox: VecDeque::new(),
joined_tick: 0,
ticks: 0,
dead: false,
placed: false,
menu: None,
next_window: 0,
drag: None,
saved: None,
}
}
pub fn send(&self, packet: &play::Clientbound) {
self.sender.send(packet.encode());
}
pub fn send_all(&self, packets: &[play::Clientbound]) {
for p in packets {
self.send(p);
}
}
pub fn chunk(&self) -> (i32, i32) {
(
(self.position[0].floor() as i32) >> 4,
(self.position[2].floor() as i32) >> 4,
)
}
pub fn creative(&self) -> bool {
self.game_mode == CREATIVE
}
pub fn spectator(&self) -> bool {
self.game_mode == SPECTATOR
}
/// PlayerAbilities flags (invulnerable, flying, may fly, instabuild).
pub fn ability_flags(&self) -> i8 {
let mut f = 0;
if self.creative() || self.spectator() {
f |= 1;
}
if self.flying || self.spectator() {
f |= 2;
}
if self.creative() || self.spectator() {
f |= 4;
}
if self.creative() {
f |= 8;
}
f
}
pub fn eye_height(&self) -> f64 {
if self.sneaking { 1.27 } else { 1.62 }
}
/// The inventory menu's 46 slots (ServerPlayer.inventoryMenu): 0 crafting
/// result, 1..=4 crafting grid, 5..=8 armor, 9..=35 main, 36..=44 hotbar,
/// 45 off hand.
pub fn menu_slot(&self, slot: usize) -> Option<ItemStack> {
match slot {
0..=4 => None,
5..=8 => self.armor[slot - 5].clone(),
9..=35 => self.inventory.get(slot).cloned().flatten(),
36..=44 => self.inventory.get(slot - 36).cloned().flatten(),
45 => self.offhand.clone(),
_ => None,
}
}
pub fn set_menu_slot(&mut self, slot: usize, item: Option<ItemStack>) {
match slot {
5..=8 => self.armor[slot - 5] = item,
9..=35 => self.inventory[slot] = item,
36..=44 => self.inventory[slot - 36] = item,
45 => self.offhand = item,
_ => {}
}
}
}
/// The off hand slot is conventionally 40 in saves and 45 in the menu.
pub fn stack_to_network(
item_id: impl Fn(&str) -> i32,
enchantment_id: impl Fn(&str) -> Option<i32>,
s: &Option<ItemStack>,
) -> Option<Stack> {
let s = s.as_ref()?;
let mut stack = Stack::new(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),
));
}
let enchantments: Vec<(i32, i32)> = s
.enchantments()
.iter()
.filter_map(|(e, level)| Some((enchantment_id(e)?, *level as i32)))
.collect();
if !enchantments.is_empty() {
stack.added.push((
horizon_protocol::item::component::ENCHANTMENTS,
horizon_protocol::item::Component::Enchantments(enchantments),
));
}
if let Some(name) = s.custom_name() {
stack.added.push((
horizon_protocol::item::component::CUSTOM_NAME,
horizon_protocol::item::Component::Text(horizon_protocol::text::literal(name)),
));
}
Some(stack)
}
File diff suppressed because it is too large Load Diff
+467
View File
@@ -0,0 +1,467 @@
//! Container menus for guests (AbstractContainerMenu.doClick): the player's
//! inventory menu (window 0) and block containers (chests, barrels, hoppers,
//! dispensers, shulker boxes). The click modes are pickup, quick move, swap,
//! clone, throw, quick craft (drag) and pickup all; items thrown out of a
//! menu are returned for the game to drop.
use super::guest::Guest;
use crate::items::ItemStack;
/// What the menus need to know about items.
pub trait Rules {
fn max_stack(&self, item: &str) -> u32;
/// The armor slot (0 head .. 3 feet) an item can be worn in.
fn armor_index(&self, item: &str) -> Option<usize>;
}
/// An open block container.
pub struct Menu {
pub window: i32,
/// The `minecraft:menu` registry id.
pub kind: i32,
pub pos: Option<(i32, i32, i32)>,
/// Slots of the container itself (without the 36 inventory slots).
pub size: usize,
pub state: i32,
/// What the client was last told, for change detection.
pub sent: Vec<Option<ItemStack>>,
/// An unfinished drag: (mode, slots).
pub drag: Option<(u8, Vec<usize>)>,
}
/// Slots of a menu seen as one list.
pub struct View<'a> {
pub guest: &'a mut Guest,
/// The container's slots, or None for the inventory menu.
pub container: Option<&'a mut [Option<ItemStack>]>,
}
impl View<'_> {
pub fn len(&self) -> usize {
match &self.container {
Some(c) => c.len() + 36,
None => 46,
}
}
pub fn is_empty(&self) -> bool {
false
}
pub fn get(&self, i: usize) -> Option<ItemStack> {
match &self.container {
Some(c) if i < c.len() => c[i].clone(),
Some(c) => self
.guest
.inventory
.get(player_slot(i - c.len()))
.cloned()
.flatten(),
None => self.guest.menu_slot(i),
}
}
pub fn set(&mut self, i: usize, item: Option<ItemStack>) {
match &mut self.container {
Some(c) if i < c.len() => c[i] = item,
Some(c) => {
let n = c.len();
self.guest.inventory[player_slot(i - n)] = item;
}
None => self.guest.set_menu_slot(i, item),
}
}
/// Whether the slot takes part in clicks at all.
fn enabled(&self, i: usize) -> bool {
self.container.is_some() || i >= 5
}
fn may_place(&self, i: usize, stack: &ItemStack, rules: &dyn Rules) -> bool {
if self.container.is_none() && (5..=8).contains(&i) {
return rules.armor_index(&stack.item) == Some(i - 5);
}
self.enabled(i)
}
fn slot_max(&self, i: usize, stack: &ItemStack, rules: &dyn Rules) -> u32 {
if self.container.is_none() && (5..=8).contains(&i) {
return 1;
}
rules.max_stack(&stack.item).max(1)
}
/// The ranges quick move uses: (container start..end, main, hotbar).
fn player_ranges(&self) -> (std::ops::Range<usize>, std::ops::Range<usize>) {
match &self.container {
Some(c) => (c.len()..c.len() + 27, c.len() + 27..c.len() + 36),
None => (9..36, 36..45),
}
}
}
/// Inventory index of the n-th player slot of a container menu (27 main, then hotbar).
fn player_slot(n: usize) -> usize {
if n < 27 { 9 + n } else { n - 27 }
}
/// Inventory.add-like merge of `stack` into slots `range` (moveItemStackTo).
fn move_to(
view: &mut View,
mut stack: ItemStack,
range: std::ops::Range<usize>,
reverse: bool,
rules: &dyn Rules,
) -> Option<ItemStack> {
let order: Vec<usize> = if reverse {
range.rev().collect()
} else {
range.collect()
};
for &i in &order {
if stack.count == 0 {
break;
}
if !view.enabled(i) {
continue;
}
if let Some(mut existing) = view.get(i)
&& existing.same_item_same_components(&stack)
{
let max = view.slot_max(i, &existing, rules);
if existing.count < max {
let moved = (max - existing.count).min(stack.count);
existing.count += moved;
stack.count -= moved;
view.set(i, Some(existing));
}
}
}
for &i in &order {
if stack.count == 0 {
break;
}
if view.enabled(i) && view.get(i).is_none() && view.may_place(i, &stack, rules) {
let moved = stack.count.min(view.slot_max(i, &stack, rules));
view.set(
i,
Some(ItemStack {
count: moved,
..stack.clone()
}),
);
stack.count -= moved;
}
}
(stack.count > 0).then_some(stack)
}
fn quick_move(view: &mut View, i: usize, rules: &dyn Rules) {
let Some(stack) = view.get(i) else {
return;
};
if !view.enabled(i) {
return;
}
let (main, hotbar) = view.player_ranges();
let rest = if let Some(c) = &view.container {
let n = c.len();
if i < n {
// Container to inventory, filling from the hotbar's end.
move_to(view, stack, n..n + 36, true, rules)
} else {
move_to(view, stack, 0..n, false, rules)
}
} else if (5..=8).contains(&i) || i == 45 || i < 5 {
move_to(view, stack, 9..45, false, rules)
} else {
// Wear it, otherwise swap between the main inventory and the hotbar.
let armor = rules
.armor_index(&stack.item)
.filter(|a| view.get(5 + a).is_none());
if let Some(a) = armor {
view.set(
5 + a,
Some(ItemStack {
count: 1,
..stack.clone()
}),
);
let mut rest = stack.clone();
rest.count -= 1;
(rest.count > 0).then_some(rest)
} else if hotbar.contains(&i) {
move_to(view, stack, main, false, rules)
} else {
move_to(view, stack, hotbar, false, rules)
}
};
view.set(i, rest);
}
/// The click modes of ServerboundContainerClickPacket.
pub mod input {
pub const PICKUP: i32 = 0;
pub const QUICK_MOVE: i32 = 1;
pub const SWAP: i32 = 2;
pub const CLONE: i32 = 3;
pub const THROW: i32 = 4;
pub const QUICK_CRAFT: i32 = 5;
pub const PICKUP_ALL: i32 = 6;
}
/// Apply one click; returns the stacks thrown out and the slots changed.
pub fn click(
view: &mut View,
drag: &mut Option<(u8, Vec<usize>)>,
slot: i32,
button: i32,
mode: i32,
rules: &dyn Rules,
) -> (Vec<ItemStack>, Vec<usize>) {
let mut drops = Vec::new();
let before: Vec<Option<ItemStack>> = (0..view.len()).map(|i| view.get(i)).collect();
if mode == input::QUICK_CRAFT {
quick_craft(view, drag, slot, button, rules);
} else {
*drag = None;
match mode {
input::PICKUP | input::QUICK_MOVE if slot == -999 => {
if mode == input::PICKUP
&& let Some(mut carried) = view.guest.carried.take()
{
if button == 1 && carried.count > 1 {
let mut one = carried.clone();
one.count = 1;
carried.count -= 1;
view.guest.carried = Some(carried);
drops.push(one);
} else {
drops.push(carried);
}
}
}
input::PICKUP => pickup(view, slot, button, rules),
input::QUICK_MOVE => {
if let Ok(i) = usize::try_from(slot)
&& i < view.len()
{
quick_move(view, i, rules);
}
}
input::SWAP => swap(view, slot, button, rules),
input::CLONE => {
if view.guest.carried.is_none()
&& view.guest.creative()
&& let Ok(i) = usize::try_from(slot)
&& let Some(stack) = view.get(i)
{
let max = rules.max_stack(&stack.item).max(1);
view.guest.carried = Some(ItemStack {
count: max,
..stack
});
}
}
input::THROW => {
if view.guest.carried.is_none()
&& let Ok(i) = usize::try_from(slot)
&& view.enabled(i)
&& let Some(mut stack) = view.get(i)
{
if button == 1 || stack.count <= 1 {
drops.push(stack);
view.set(i, None);
} else {
let mut one = stack.clone();
one.count = 1;
stack.count -= 1;
view.set(i, Some(stack));
drops.push(one);
}
}
}
input::PICKUP_ALL => pickup_all(view, slot, rules),
_ => {}
}
}
let changed = (0..view.len())
.filter(|&i| view.get(i) != before[i])
.collect();
(drops, changed)
}
fn pickup(view: &mut View, slot: i32, button: i32, rules: &dyn Rules) {
let Ok(i) = usize::try_from(slot) else {
return;
};
if i >= view.len() || !view.enabled(i) {
return;
}
let right = button == 1;
let (slot_item, carried) = (view.get(i), view.guest.carried.clone());
match (slot_item, carried) {
(None, None) => {}
(None, Some(mut c)) => {
if view.may_place(i, &c, rules) {
let amount = if right { 1 } else { c.count }.min(view.slot_max(i, &c, rules));
view.set(
i,
Some(ItemStack {
count: amount,
..c.clone()
}),
);
c.count -= amount;
view.guest.carried = (c.count > 0).then_some(c);
}
}
(Some(mut s), None) => {
let take = if right { s.count.div_ceil(2) } else { s.count };
let taken = ItemStack {
count: take,
..s.clone()
};
s.count -= take;
view.set(i, (s.count > 0).then_some(s));
view.guest.carried = Some(taken);
}
(Some(mut s), Some(mut c)) => {
if !view.may_place(i, &c, rules) {
return;
}
if s.same_item_same_components(&c) {
let max = view.slot_max(i, &s, rules);
let moved = if right { 1 } else { c.count }.min(max.saturating_sub(s.count));
s.count += moved;
c.count -= moved;
view.set(i, Some(s));
view.guest.carried = (c.count > 0).then_some(c);
} else if c.count <= view.slot_max(i, &c, rules) {
view.set(i, Some(c));
view.guest.carried = Some(s);
}
}
}
}
fn swap(view: &mut View, slot: i32, button: i32, rules: &dyn Rules) {
let Ok(i) = usize::try_from(slot) else {
return;
};
if i >= view.len() || !view.enabled(i) {
return;
}
// Hotbar slot `button` (0..9) or the off hand (40).
let other = match button {
0..=8 => match &view.container {
Some(c) => c.len() + 27 + button as usize,
None => 36 + button as usize,
},
40 if view.container.is_none() => 45,
_ => return,
};
if other == i {
return;
}
let (a, b) = (view.get(i), view.get(other));
if a.as_ref().is_some_and(|a| !view.may_place(other, a, rules))
|| b.as_ref().is_some_and(|b| !view.may_place(i, b, rules))
{
return;
}
view.set(i, b);
view.set(other, a);
}
fn pickup_all(view: &mut View, slot: i32, rules: &dyn Rules) {
let _ = slot;
let Some(mut carried) = view.guest.carried.clone() else {
return;
};
let max = rules.max_stack(&carried.item).max(1);
// Partial stacks first, then full ones.
for full in [false, true] {
for i in 0..view.len() {
if carried.count >= max {
break;
}
if !view.enabled(i) || (view.container.is_none() && i == 0) {
continue;
}
let Some(mut s) = view.get(i) else {
continue;
};
if !s.same_item_same_components(&carried) || (s.count == max) != full {
continue;
}
let moved = (max - carried.count).min(s.count);
carried.count += moved;
s.count -= moved;
view.set(i, (s.count > 0).then_some(s));
}
}
view.guest.carried = Some(carried);
}
/// Dragging a stack over slots (QUICK_CRAFT): start, add slots, end.
fn quick_craft(
view: &mut View,
drag: &mut Option<(u8, Vec<usize>)>,
slot: i32,
button: i32,
rules: &dyn Rules,
) {
let (stage, kind) = (button & 3, ((button >> 2) & 3) as u8);
match stage {
0 => *drag = view.guest.carried.is_some().then_some((kind, Vec::new())),
1 => {
if let (Some((_, slots)), Ok(i)) = (drag.as_mut(), usize::try_from(slot))
&& i < view.len()
&& !slots.contains(&i)
&& let Some(c) = &view.guest.carried
&& view.enabled(i)
&& view.may_place(i, c, rules)
&& view.get(i).is_none_or(|s| s.same_item_same_components(c))
{
slots.push(i);
}
}
_ => {
let Some((kind, slots)) = drag.take() else {
return;
};
let Some(mut carried) = view.guest.carried.clone() else {
return;
};
if slots.is_empty() {
return;
}
if slots.len() == 1 {
// A single slot behaves like a plain click.
let button = if kind == 1 { 1 } else { 0 };
pickup(view, slots[0] as i32, button, rules);
return;
}
let each = match kind {
0 => carried.count / slots.len() as u32,
1 => 1,
_ => rules.max_stack(&carried.item).max(1),
};
for i in slots {
if carried.count == 0 {
break;
}
let existing = view.get(i).map_or(0, |s| s.count);
let max = view.slot_max(i, &carried, rules);
let put = each.min(max.saturating_sub(existing)).min(carried.count);
if put == 0 {
continue;
}
view.set(
i,
Some(ItemStack {
count: existing + put,
..carried.clone()
}),
);
if kind != 2 || !view.guest.creative() {
carried.count -= put;
}
}
view.guest.carried = (carried.count > 0).then_some(carried);
}
}
}
+201
View File
@@ -0,0 +1,201 @@
//! Hosting a world on the local network. The network side lives here: the
//! listener, the per-connection handshake/login/configuration threads and the
//! writer threads (`conn`), plus the data the configuration phase sends
//! (`data`). The play state is driven by the game thread (`hub`), which only
//! ever exchanges decoded packets with these threads through channels, so a
//! world that is not open to the network pays nothing.
pub mod chunks;
pub mod conn;
pub mod containers;
pub mod data;
pub mod entity;
pub mod guest;
pub mod hub;
pub mod menu;
pub mod playerdata;
pub use conn::PlayerSender;
use horizon_protocol::packets::play;
use horizon_protocol::{GAME_VERSION, PROTOCOL_VERSION, packets::configuration::ClientInformation};
use std::{
collections::HashSet,
io,
net::{SocketAddr, TcpListener, TcpStream},
sync::{
Arc, Mutex,
atomic::{AtomicBool, AtomicI32, AtomicU32, Ordering},
mpsc::{Receiver, Sender, channel},
},
thread::JoinHandle,
time::Duration,
};
/// IntegratedServer.MAX_PLAYERS.
pub const MAX_PLAYERS: usize = 8;
/// Messages from the connection threads to the game thread.
pub enum NetEvent {
/// A client finished configuration and enters the play state.
Joined(Box<Joined>),
Packet(u32, Box<play::Serverbound>),
/// The connection ended (reason for the log).
Left(u32, String),
}
pub struct Joined {
pub conn: u32,
pub uuid: u128,
pub name: String,
pub info: ClientInformation,
pub brand: String,
pub sender: PlayerSender,
/// Smoothed keep-alive round trip in milliseconds.
pub latency: Arc<AtomicI32>,
}
/// Queued for a connection's writer thread.
pub enum Out {
/// A packet body: VarInt id and payload.
Packet(Vec<u8>),
/// Send a play disconnect with this component, then close.
Disconnect(horizon_world::nbt::Tag),
Close,
}
/// State shared with the connection threads.
pub struct Shared {
pub sync: Arc<data::SyncData>,
pub events: Sender<NetEvent>,
motd: Mutex<String>,
online: Mutex<HashSet<u128>>,
max_players: usize,
next: AtomicU32,
stop: AtomicBool,
}
impl Shared {
pub fn next_id(&self) -> u32 {
self.next.fetch_add(1, Ordering::Relaxed)
}
/// PlayerList.canPlayerLogin: duplicates and a full server are refused.
pub fn try_admit(&self, uuid: u128, _name: &str) -> Option<&'static str> {
let mut online = self.online.lock().unwrap();
if online.contains(&uuid) {
return Some("multiplayer.disconnect.duplicate_login");
}
if online.len() >= self.max_players {
return Some("multiplayer.disconnect.server_full");
}
online.insert(uuid);
None
}
pub fn release(&self, uuid: u128) {
self.online.lock().unwrap().remove(&uuid);
}
pub fn online(&self) -> usize {
self.online.lock().unwrap().len()
}
/// The status response (ServerStatus): version, players and the MOTD.
pub fn status_json(&self) -> String {
let motd = self.motd.lock().unwrap().clone();
serde_json::json!({
"version": { "name": GAME_VERSION, "protocol": PROTOCOL_VERSION },
"players": { "max": self.max_players, "online": self.online() },
"description": { "text": motd },
"enforcesSecureChat": false,
})
.to_string()
}
}
/// A running LAN server.
pub struct Lan {
pub shared: Arc<Shared>,
events: Receiver<NetEvent>,
pub port: u16,
listener: Option<JoinHandle<()>>,
}
impl Lan {
/// Listen on `port` (0 picks a free one).
pub fn start(
sync: Arc<data::SyncData>,
port: u16,
motd: String,
max_players: usize,
) -> io::Result<Self> {
let listener = TcpListener::bind(("0.0.0.0", port))?;
listener.set_nonblocking(true)?;
let port = listener.local_addr()?.port();
let (tx, events) = channel();
let shared = Arc::new(Shared {
sync,
events: tx,
motd: Mutex::new(motd),
online: Mutex::new(HashSet::new()),
max_players,
next: AtomicU32::new(1),
stop: AtomicBool::new(false),
});
let accept_shared = shared.clone();
let listener = std::thread::Builder::new()
.name("horizon-lan-accept".into())
.spawn(move || accept_loop(listener, accept_shared))?;
Ok(Self {
shared,
events,
port,
listener: Some(listener),
})
}
/// Everything the connection threads reported since the last call.
pub fn poll(&self) -> Vec<NetEvent> {
self.events.try_iter().collect()
}
/// Reserve a uuid for the host so a guest cannot take the name.
pub fn reserve(&self, uuid: u128) {
self.shared.online.lock().unwrap().insert(uuid);
}
pub fn set_motd(&self, motd: &str) {
*self.shared.motd.lock().unwrap() = motd.to_owned();
}
pub fn stop(&mut self) {
self.shared.stop.store(true, Ordering::Relaxed);
if let Some(t) = self.listener.take() {
let _ = t.join();
}
}
}
impl Drop for Lan {
fn drop(&mut self) {
self.stop();
}
}
fn accept_loop(listener: TcpListener, shared: Arc<Shared>) {
while !shared.stop.load(Ordering::Relaxed) {
match listener.accept() {
Ok((stream, addr)) => {
let shared = shared.clone();
let _ = std::thread::Builder::new()
.name("horizon-lan-conn".into())
.spawn(move || handle(stream, addr, shared));
}
Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
std::thread::sleep(Duration::from_millis(25));
}
Err(_) => std::thread::sleep(Duration::from_millis(100)),
}
}
}
fn handle(stream: TcpStream, addr: SocketAddr, shared: Arc<Shared>) {
let _ = stream.set_nonblocking(false);
if let Err(e) = conn::serve(stream, shared)
&& std::env::var_os("HORIZON_NET_DEBUG").is_some()
{
eprintln!("[lan] {addr}: {e}");
}
}
/// HttpUtil.getAvailablePort: a free local port.
pub fn available_port() -> u16 {
TcpListener::bind(("0.0.0.0", 0))
.and_then(|l| l.local_addr())
.map_or(25565, |a| a.port())
}
+130
View File
@@ -0,0 +1,130 @@
//! Guests' saved state: `players/data/<uuid>.dat` in the vanilla player
//! compound, through the same code that saves the host.
use super::guest::Guest;
use crate::{
items::ItemStack,
save::{Level, read_dat, write_dat},
};
use horizon_protocol::crypto::uuid_string;
use std::{
path::{Path, PathBuf},
sync::Arc,
};
pub fn path(world: &Path, uuid: u128) -> PathBuf {
world
.join("players")
.join("data")
.join(format!("{}.dat", uuid_string(uuid)))
}
fn uuid_ints(uuid: u128) -> [i32; 4] {
[
(uuid >> 96) as i32,
(uuid >> 64) as i32,
(uuid >> 32) as i32,
uuid as i32,
]
}
/// Whether a saved file exists for this player.
pub fn exists(world: &Path, uuid: u128) -> bool {
path(world, uuid).is_file()
}
/// Load a guest's saved state, if they have been here before.
pub fn load(guest: &mut Guest, world: &Path) -> bool {
let Some(tag) = read_dat(&path(world, guest.uuid)) else {
return false;
};
let mut level = Level {
health: 20.0,
food: 20,
saturation: 5.0,
..Level::default()
};
level.read_player(&tag);
if let Some(p) = level.position {
guest.position = p;
guest.previous_position = p;
}
guest.yaw = level.rotation[0];
guest.pitch = level.rotation[1];
guest.head_yaw = guest.yaw;
guest.on_ground = level.on_ground;
guest.health = level.health;
guest.food = level.food;
guest.saturation = level.saturation;
guest.xp_level = level.xp_level;
guest.xp_progress = level.xp_progress;
guest.xp_total = level.xp_total;
guest.game_mode = level.mode();
guest.selected = (level.selected_slot.max(0) as usize).min(8);
guest.saved = Some(tag);
for (slot, item, count, damage) in &level.inventory {
let mut stack = ItemStack {
item: Arc::from(item.as_str()),
count: *count,
damage: *damage,
extra: level.inventory_components.get(slot).cloned(),
};
if stack.count == 0 {
stack.count = 1;
}
match *slot {
0..=35 => guest.inventory[usize::from(*slot)] = Some(stack),
100 => guest.armor[3] = Some(stack),
101 => guest.armor[2] = Some(stack),
102 => guest.armor[1] = Some(stack),
103 => guest.armor[0] = Some(stack),
150 => guest.offhand = Some(stack),
_ => {}
}
}
true
}
/// Save a guest (PlayerDataStorage.save).
pub fn save(guest: &Guest, world: &Path) {
let mut level = Level {
player_uuid: Some(uuid_ints(guest.uuid)),
position: Some(guest.position),
rotation: [guest.yaw, guest.pitch],
health: guest.health,
food: guest.food,
saturation: guest.saturation,
xp_level: guest.xp_level,
xp_progress: guest.xp_progress,
xp_total: guest.xp_total,
game_mode: guest.game_mode,
creative: guest.game_mode == 1,
selected_slot: guest.selected as i32,
on_ground: guest.on_ground,
dimension: "minecraft:overworld".into(),
player_extra: guest.saved.clone(),
..Level::default()
};
let mut put = |slot: u8, stack: &Option<ItemStack>| {
if let Some(s) = stack {
level
.inventory
.push((slot, s.item.to_string(), s.count, s.damage));
if let Some(extra) = &s.extra {
level.inventory_components.insert(slot, extra.clone());
}
}
};
for (i, s) in guest.inventory.iter().enumerate() {
put(i as u8, s);
}
put(103, &guest.armor[0]);
put(102, &guest.armor[1]);
put(101, &guest.armor[2]);
put(100, &guest.armor[3]);
put(150, &guest.offhand);
let file = path(world, guest.uuid);
if let Some(dir) = file.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = write_dat(&file, level.player_tag());
}
+2
View File
@@ -9,6 +9,7 @@ pub mod attribute_updates;
pub mod audio;
pub mod banner;
pub mod biome;
pub mod block_entity_nbt;
pub mod block_entity_render;
pub mod blocks;
pub mod bossbar;
@@ -43,6 +44,7 @@ pub mod input;
pub mod item_data;
pub mod items;
pub mod keybinds;
pub mod lan;
pub mod landing;
pub mod lang;
pub mod light;
+22
View File
@@ -20,6 +20,7 @@ pub mod data;
pub mod enderman;
pub mod equine;
pub mod farm;
pub mod gear;
pub mod goals;
pub mod golem;
pub mod guardian;
@@ -38,6 +39,7 @@ pub mod piglin;
pub mod raider;
pub mod ravager;
pub mod render;
pub mod riders;
pub mod shulker;
pub mod sniffer;
pub mod spawning;
@@ -51,6 +53,7 @@ pub mod warden;
pub mod witch;
pub mod wither;
mod world;
pub mod zombie_villager;
use crate::{blocks::BlockFacts, mesher::Vertex, world::World};
pub use data::MobData;
@@ -505,6 +508,16 @@ pub struct Extra {
pub raider: Option<Box<raider::State>>,
/// A villager's raid activity and gossip.
pub villager: Option<Box<villager::Ext>>,
/// The mob this one rides, and the mob riding it (`getVehicle`, `getFirstPassenger`).
pub mount: Option<u32>,
pub rider: Option<u32>,
/// A chicken carrying a zombie (`IsChickenJockey`).
pub jockey: bool,
/// A skeleton horse waiting to spring its trap, and how long it has waited.
pub trap: bool,
pub trap_time: i32,
/// Enchantments on the equipment above.
pub gear: Option<Box<gear::Gear>>,
}
#[derive(Clone, Debug)]
pub struct Mob {
@@ -744,6 +757,10 @@ pub enum MobEvent {
drop: bool,
sound: bool,
},
/// A zombie villager's cure is complete: the game turns it back into a villager.
CureZombieVillager {
mob: u32,
},
/// A vibration travelling to a listener (`VibrationParticleOption`).
Vibration {
from: [f64; 3],
@@ -1007,6 +1024,11 @@ impl Mob {
let effective = (armor - amount / toughness).clamp(armor * 0.2, 20.0);
amount *= 1.0 - effective / 25.0;
}
// CombatRules.getDamageAfterMagicAbsorb: enchantment protection.
let epf = gear::protection(self, source.kind);
if epf > 0.0 {
amount *= 1.0 - epf / 25.0;
}
let mut knock = true;
if self.invulnerable as f32 > 10.0 {
if amount <= self.last_hurt {
+41 -3
View File
@@ -562,6 +562,7 @@ fn server_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
super::equine::ridden_step(m);
return;
}
super::riders::drive(m, w);
let tick_count = m.age as i64;
let id_based = tick_count + i64::from(m.id);
let mut targets = std::mem::take(&mut m.ai.targets);
@@ -661,15 +662,21 @@ fn species_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
/// Mob.checkDespawn (players are the only despawn reference).
fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool {
let creature = m.kind.category == "creature";
// Warden.removeWhenFarAway is false.
if m.persistent || m.species() == Species::Warden || creature && m.kind.flags.animal {
// Warden.removeWhenFarAway is false; a jockey's chicken despawns like a monster.
if m.persistent
|| m.species() == Species::Warden
|| creature && m.kind.flags.animal && !m.extra.jockey
{
m.ai.no_action_time = 0;
return true;
}
let Some(p) = &w.player else { return true };
let d = m.distance_sqr(p.position);
// Patrols and raiders (`removeWhenFarAway`, `requiresCustomPersistence`).
if super::raider::keeps_alive(m, d) {
if super::raider::keeps_alive(m, d)
|| super::zombie_villager::keeps_alive(m)
|| super::riders::keeps_alive(m)
{
return true;
}
let despawn = if m.kind.category == "water_ambient" {
@@ -829,6 +836,37 @@ pub fn do_hurt_target(m: &mut Mob, who: Who, cx: &mut Cx) {
if amount <= 0.0 {
amount = 1.0;
}
// The held weapon's enchantments: Sharpness, Smite, Bane of Arthropods,
// Fire Aspect and Knockback.
let target_species = match who {
Who::Mob(id) => cx.w.seen(id).map(|s| s.species),
Who::Player => None,
};
amount += super::gear::melee_bonus(m, target_species);
let burn = super::gear::fire_aspect(m);
if burn > 0 {
cx.events.push(MobEvent::Ignite {
target: who,
seconds: burn,
});
}
let knock = super::gear::knockback(m);
if knock > 0 {
let (dx, dz) = match who {
Who::Player => cx.w.player.as_ref().map_or((0.0, 0.0), |p| {
(p.position.x - m.position.x, p.position.z - m.position.z)
}),
Who::Mob(id) => cx.w.seen(id).map_or((0.0, 0.0), |s| {
(s.position.x - m.position.x, s.position.z - m.position.z)
}),
};
let len = (dx * dx + dz * dz).sqrt().max(1e-5);
let k = f64::from(knock) * 0.5;
cx.events.push(MobEvent::Push {
target: who,
velocity: [dx / len * k, 0.1, dz / len * k],
});
}
// Zombies set their target on fire while burning (Zombie.doHurtTarget).
if m.fire_ticks > 0 && matches!(m.species(), Species::Zombie) && m.random.next_float() < 0.3 {
cx.events.push(MobEvent::Ignite {
+1 -1
View File
@@ -81,7 +81,7 @@ pub fn chicken_ai_step(m: &mut Mob, _w: &MobWorld, events: &mut Vec<MobEvent>) {
m.velocity.y *= 0.6;
}
a.flap += a.flapping * 2.0;
if m.alive() && !m.is_baby() {
if m.alive() && !m.is_baby() && !m.extra.jockey {
m.extra.egg_time -= 1;
if m.extra.egg_time <= 0 {
let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0;
+228
View File
@@ -0,0 +1,228 @@
//! Enchantments on the gear mobs wear and hold (`Mob.populateDefaultEquipmentEnchantments`,
//! raid buffs): the side table kept beside the plain item ids in `Extra`,
//! its saved form, and the combat numbers the enchantments give (Sharpness,
//! Smite, Bane of Arthropods, Fire Aspect, Knockback, Power, Punch, Flame,
//! Quick Charge and the protections).
use super::{DamageKind, Mob, Species};
use std::sync::Arc;
/// Equipment slots in the order `Extra` keeps them.
pub const MAIN: usize = 0;
pub const OFF: usize = 1;
pub const HEAD: usize = 2;
pub const CHEST: usize = 3;
pub const LEGS: usize = 4;
pub const FEET: usize = 5;
pub const ARMOR: [usize; 4] = [HEAD, CHEST, LEGS, FEET];
/// The `equipment` keys of each slot.
pub const KEYS: [&str; 6] = ["mainhand", "offhand", "head", "chest", "legs", "feet"];
pub type Levels = Vec<(Arc<str>, u32)>;
/// The enchantments of each equipment slot.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Gear {
pub slots: [Levels; 6],
}
impl Gear {
pub fn is_empty(&self) -> bool {
self.slots.iter().all(Vec::is_empty)
}
pub fn level(&self, slot: usize, id: &str) -> u32 {
self.slots[slot]
.iter()
.find(|(e, _)| &**e == id)
.map_or(0, |(_, l)| *l)
}
/// `ItemEnchantments.Mutable.upgrade`: keep the higher level.
pub fn upgrade(&mut self, slot: usize, id: &str, level: u32) {
match self.slots[slot].iter_mut().find(|(e, _)| &**e == id) {
Some((_, l)) => *l = (*l).max(level),
None => self.slots[slot].push((Arc::from(id), level)),
}
}
}
pub fn gear(m: &Mob) -> Option<&Gear> {
m.extra.gear.as_deref()
}
/// The level of an enchantment on what `m` wears or holds in `slot`.
pub fn level(m: &Mob, slot: usize, id: &str) -> u32 {
gear(m).map_or(0, |g| g.level(slot, id))
}
/// Whether the item in `slot` is enchanted (the glint).
pub fn enchanted(m: &Mob, slot: usize) -> bool {
gear(m).is_some_and(|g| !g.slots[slot].is_empty())
}
/// Replace the enchantments of a slot; an empty list removes them.
pub fn set(m: &mut Mob, slot: usize, levels: Levels) {
let g = m.extra.gear.get_or_insert_with(Box::default);
g.slots[slot] = levels;
if g.is_empty() {
m.extra.gear = None;
}
}
pub fn upgrade(m: &mut Mob, slot: usize, id: &str, level: u32) {
m.extra
.gear
.get_or_insert_with(Box::default)
.upgrade(slot, id, level);
}
/// `#sensitive_to_smite` and `#sensitive_to_bane_of_arthropods`.
fn undead(s: Species) -> bool {
matches!(
s,
Species::Zombie
| Species::Husk
| Species::Drowned
| Species::ZombieVillager
| Species::ZombifiedPiglin
| Species::Skeleton
| Species::Stray
| Species::Bogged
| Species::Parched
| Species::WitherSkeleton
| Species::Wither
| Species::Phantom
| Species::Zoglin
| Species::SkeletonHorse
| Species::ZombieHorse
)
}
fn arthropod(s: Species) -> bool {
matches!(
s,
Species::Spider
| Species::CaveSpider
| Species::Silverfish
| Species::Endermite
| Species::Bee
)
}
/// The `minecraft:damage` bonus of a weapon's levels against `target`.
pub fn damage_bonus(levels: &[(Arc<str>, u32)], target: Option<Species>) -> f32 {
let mut bonus = 0.0;
for (id, l) in levels {
let l = *l as f32;
match &**id {
"minecraft:sharpness" => bonus += 1.0 + 0.5 * (l - 1.0),
"minecraft:smite" if target.is_some_and(undead) => bonus += 2.5 * l,
"minecraft:bane_of_arthropods" if target.is_some_and(arthropod) => bonus += 2.5 * l,
_ => {}
}
}
bonus
}
/// The extra damage of the mob's held weapon against a target species.
pub fn melee_bonus(m: &Mob, target: Option<Species>) -> f32 {
gear(m).map_or(0.0, |g| damage_bonus(&g.slots[MAIN], target))
}
/// Seconds of fire a melee hit sets (`Fire Aspect`: 4 per level).
pub fn fire_aspect(m: &Mob) -> i32 {
4 * level(m, MAIN, "minecraft:fire_aspect") as i32
}
/// `minecraft:knockback` of the held weapon.
pub fn knockback(m: &Mob) -> u32 {
level(m, MAIN, "minecraft:knockback")
}
/// What a bow adds to its arrows.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct ArrowBonus {
/// Power: 1 + 0.5 per level above the first.
pub damage: f32,
/// Punch: knockback levels.
pub punch: u32,
/// Flame: sets the target on fire.
pub flame: bool,
/// Piercing: entities an arrow passes through.
pub pierce: u32,
}
pub fn arrow_bonus(m: &Mob) -> ArrowBonus {
let power = level(m, MAIN, "minecraft:power");
ArrowBonus {
damage: if power > 0 {
1.0 + 0.5 * (power as f32 - 1.0)
} else {
0.0
},
punch: level(m, MAIN, "minecraft:punch"),
flame: level(m, MAIN, "minecraft:flame") > 0,
pierce: level(m, MAIN, "minecraft:piercing"),
}
}
/// Enchantment protection points of the worn armour against a damage kind
/// (`damage_protection`: 1 per level of Protection, 2 for the specialist
/// ones, 3 for Feather Falling), capped at 20.
pub fn protection(m: &Mob, kind: DamageKind) -> f32 {
let Some(g) = gear(m) else { return 0.0 };
protection_points(g, kind).min(20.0)
}
pub fn protection_points(g: &Gear, kind: DamageKind) -> f32 {
if kind == DamageKind::Generic {
return 0.0;
}
let fire = matches!(
kind,
DamageKind::OnFire | DamageKind::InFire | DamageKind::Lava | DamageKind::Fireball
);
let projectile = matches!(
kind,
DamageKind::Arrow | DamageKind::Thrown | DamageKind::Fireball
);
let mut total = 0.0;
for slot in ARMOR {
for (id, l) in &g.slots[slot] {
let l = *l as f32;
total += match &**id {
"minecraft:protection" => l,
"minecraft:fire_protection" if fire => 2.0 * l,
"minecraft:blast_protection" if kind == DamageKind::Explosion => 2.0 * l,
"minecraft:projectile_protection" if projectile => 2.0 * l,
"minecraft:feather_falling" if kind == DamageKind::Fall => 3.0 * l,
_ => 0.0,
};
}
}
total
}
#[cfg(test)]
mod tests {
use super::*;
fn levels(list: &[(&str, u32)]) -> Levels {
list.iter().map(|(e, l)| (Arc::from(*e), *l)).collect()
}
#[test]
fn sharpness_adds_half_a_heart_per_level_above_one() {
let s = levels(&[("minecraft:sharpness", 3)]);
assert_eq!(damage_bonus(&s, Some(Species::Cow)), 2.0);
}
#[test]
fn smite_and_bane_need_the_right_target() {
let l = levels(&[("minecraft:smite", 2), ("minecraft:bane_of_arthropods", 1)]);
assert_eq!(damage_bonus(&l, Some(Species::Zombie)), 5.0);
assert_eq!(damage_bonus(&l, Some(Species::Spider)), 2.5);
assert_eq!(damage_bonus(&l, None), 0.0);
}
#[test]
fn protections_count_by_damage_kind() {
let mut g = Gear::default();
g.upgrade(HEAD, "minecraft:protection", 4);
g.upgrade(FEET, "minecraft:feather_falling", 4);
g.upgrade(CHEST, "minecraft:fire_protection", 2);
assert_eq!(protection_points(&g, DamageKind::MobAttack), 4.0);
assert_eq!(protection_points(&g, DamageKind::Fall), 16.0);
assert_eq!(protection_points(&g, DamageKind::OnFire), 8.0);
assert_eq!(protection_points(&g, DamageKind::Generic), 0.0);
}
#[test]
fn upgrading_keeps_the_higher_level() {
let mut g = Gear::default();
g.upgrade(MAIN, "minecraft:power", 2);
g.upgrade(MAIN, "minecraft:power", 1);
assert_eq!(g.level(MAIN, "minecraft:power"), 2);
assert!(!g.is_empty());
}
}
+2 -1
View File
@@ -386,7 +386,7 @@ pub fn crossbow_goal(speed: f64, radius: f64) -> impl Goal {
}
/// `CrossbowItem.getChargeDuration` (25 ticks, 5 fewer per level of Quick Charge).
pub fn charge_ticks(m: &Mob) -> i32 {
25 - 5 * i32::from(super::raider::state(m).map_or(0, |s| s.enchant))
25 - 5 * super::gear::level(m, super::gear::MAIN, "minecraft:quick_charge") as i32
}
fn holding_crossbow(m: &Mob) -> bool {
m.extra.main_hand.as_deref() == Some("minecraft:crossbow")
@@ -521,6 +521,7 @@ fn shoot_crossbow(m: &mut Mob, who: Who, cx: &mut Cx) {
start,
Some(Who::Mob(m.id)),
);
p.bonus = super::gear::arrow_bonus(m);
// rangedAttackUncertainty at normal difficulty: 14 - 2 * 4.
p.shoot(&mut m.random, [dx, dy, dz], 1.6, 6.0);
cx.events.push(MobEvent::Projectile(p));
+1 -5
View File
@@ -40,12 +40,8 @@ pub struct State {
pub banner_at: Option<[f64; 3]>,
/// Beds around the raid's centre.
pub homes: Option<std::sync::Arc<Vec<[i32; 3]>>>,
/// The ravager this raider rides, and (for a ravager) that it carries one.
pub vehicle: Option<u32>,
/// A ravager carrying a raider, set every tick from `Extra::rider`.
pub rider: bool,
/// Quick Charge (pillager crossbows) or Sharpness (vindicator axes) from
/// the raid's enchanting.
pub enchant: u8,
}
impl State {
/// A ravager carrying a raider (`hasControllingPassenger`).
+156 -37
View File
@@ -566,11 +566,7 @@ pub fn layers(m: &Mob) -> Vec<Layer> {
} else {
"entity/zombie_villager"
};
let baby = if m.is_baby() && m.species() == S::Villager {
"baby/"
} else {
""
};
let baby = if m.is_baby() { "baby/" } else { "" };
push(
&mut v,
&model,
@@ -587,9 +583,10 @@ pub fn layers(m: &Mob) -> Vec<Layer> {
white,
false,
);
if m.species() == S::Villager && prof != "nitwit" {
if prof != "nitwit" {
// `LEVEL_LOCATIONS` clamps the level to 1..=5.
let level = ["stone", "iron", "gold", "emerald", "diamond"]
[(m.extra.variant3 as usize).min(4)];
[(m.extra.variant3.max(1) as usize - 1).min(4)];
push(
&mut v,
&model,
@@ -674,7 +671,12 @@ pub fn base_transform(m: &Mob, alpha: f32, camera: glam::DVec3) -> glam::Mat4 {
m.previous.y + (m.position.y - m.previous.y) * a,
m.previous.z + (m.position.z - m.previous.z) * a,
) - camera;
let body = m.previous_body_yaw + wrap(m.body_yaw - m.previous_body_yaw) * alpha;
let mut body = m.previous_body_yaw + wrap(m.body_yaw - m.previous_body_yaw) * alpha;
if shaking(m) {
// LivingEntityRenderer.setupRotations: a rapid wobble.
let ticks = (m.age as f32 + alpha).floor();
body += (f64::from(ticks * 3.25).cos() * std::f64::consts::PI * 0.4) as f32;
}
let sleep = (m.species() == Species::Villager)
.then(|| super::villager::sleep_pose(m))
.flatten();
@@ -706,6 +708,18 @@ pub fn base_transform(m: &Mob, alpha: f32, camera: glam::DVec3) -> glam::Mat4 {
base *= species_scale(m, alpha);
base * glam::Mat4::from_translation(glam::Vec3::new(0.0, -1.501, 0.0))
}
/// `LivingEntityRenderer.isShaking`: converting zombies, piglins and
/// hoglins, and a zombie villager being cured.
fn shaking(m: &Mob) -> bool {
match m.species() {
Species::ZombieVillager => super::zombie_villager::is_converting(m),
Species::Zombie | Species::Husk => m.extra.counter2 > 0,
Species::Piglin | Species::PiglinBrute | Species::Hoglin => {
!m.extra.flag2 && m.extra.counter2 > 0
}
_ => false,
}
}
fn flip_degrees(m: &Mob) -> f32 {
match m.species() {
Species::Spider | Species::CaveSpider | Species::Silverfish | Species::Endermite => 180.0,
@@ -868,9 +882,28 @@ pub fn render_with(
} else {
light
};
let overlay = if armor_slot(&layer.model).is_some_and(|s| super::gear::enchanted(m, s)) {
glint_overlay(overlay)
} else {
overlay
};
draw(&part, base, &poses, uv, layer.color, light, overlay, out);
}
}
/// The equipment slot of a `HumanoidArmorLayer` model (`zombie#helmet`).
fn armor_slot(model: &str) -> Option<usize> {
Some(match model.rsplit('#').next()? {
"helmet" => super::gear::HEAD,
"chestplate" => super::gear::CHEST,
"leggings" => super::gear::LEGS,
"boots" => super::gear::FEET,
_ => return None,
})
}
/// The entity shader's glint overlay (7), keeping the hurt tint (8).
fn glint_overlay(overlay: u32) -> u32 {
if overlay == 1 { 8 } else { 7 }
}
/// Render with a fixed texture rect (the earlier API).
pub fn render_single(
m: &Mob,
@@ -969,6 +1002,100 @@ fn item_sprite(m: &Mob, item: &str) -> String {
}
format!("item/{name}")
}
/// The hand of a mob in model space, up to the item's own transform
/// (`ItemInHandLayer.submitArmWithItem`).
fn hand_base(
m: &Mob,
model: &Part,
base: glam::Mat4,
poses: &Poses,
left: bool,
) -> Option<glam::Mat4> {
let skeleton = matches!(
m.species(),
Species::Skeleton
| Species::Stray
| Species::Bogged
| Species::Parched
| Species::WitherSkeleton
);
let arm = if left { "left_arm" } else { "right_arm" };
let offset = if skeleton {
if left { -1.0 } else { 1.0 }
} else {
0.0
};
let mut t = part_matrix(model, base, poses, arm, offset)?;
let (ox, oy, oz) = if m.is_baby() {
(0.0, 1.0, -4.5)
} else {
(1.0, 2.0, -10.0)
};
t *= glam::Mat4::from_rotation_x((-90.0f32).to_radians()) * glam::Mat4::from_rotation_y(PI);
t *= glam::Mat4::from_translation(glam::Vec3::new(
if left { -ox } else { ox } / 16.0,
oy / 16.0,
oz / 16.0,
));
Some(t)
}
/// The transform of one of a mob's model parts, in camera space
/// (`ModelPart.translateAndRotate` down the tree).
pub fn part_transform(
m: &Mob,
alpha: f32,
camera: glam::DVec3,
data: &MobData,
part: &str,
) -> Option<glam::Mat4> {
let base = base_transform(m, alpha, camera);
let s = anim::state(m, alpha);
let (model_key, _) = body(m);
let model = m
.kind
.layer(&model_key)
.cloned()
.unwrap_or_else(|| m.kind.model.clone());
let mut poses = Poses::new(&model);
anim::setup(m, &s, &mut poses, &data.animations);
part_matrix(&model, base, &poses, part, 0.0)
}
/// Where a mob holds a block item (`block/block` thirdperson display: turned
/// 75 and 45 degrees, at 0.375 scale), as the hand transform for `left`, or
/// `None` when the mob shows no held items.
pub fn held_block_transform(
m: &Mob,
alpha: f32,
camera: glam::DVec3,
data: &MobData,
left: bool,
) -> Option<glam::Mat4> {
if !super::illager::shows_item(m) {
return None;
}
let base = base_transform(m, alpha, camera);
let s = anim::state(m, alpha);
let (model_key, _) = body(m);
let model = m
.kind
.layer(&model_key)
.cloned()
.unwrap_or_else(|| m.kind.model.clone());
let mut poses = Poses::new(&model);
anim::setup(m, &s, &mut poses, &data.animations);
let mut t = hand_base(m, &model, base, &poses, left)?;
let ry = if left { -45.0f32 } else { 45.0 };
t *= glam::Mat4::from_translation(glam::Vec3::new(0.0, 2.5, 0.0) / 16.0);
t *= glam::Mat4::from_quat(glam::Quat::from_euler(
glam::EulerRot::XYZ,
75.0f32.to_radians(),
ry.to_radians(),
0.0,
));
t *= glam::Mat4::from_scale(glam::Vec3::splat(0.375));
t *= glam::Mat4::from_translation(glam::Vec3::splat(-0.5));
Some(t)
}
/// ItemInHandLayer: items in the mob's hands.
fn held_items(
m: &Mob,
@@ -979,43 +1106,17 @@ fn held_items(
light: u32,
out: &mut Vec<Vertex>,
) {
let skeleton = matches!(
m.species(),
Species::Skeleton
| Species::Stray
| Species::Bogged
| Species::Parched
| Species::WitherSkeleton
);
if !super::illager::shows_item(m) {
return;
}
for (item, left) in [(&m.extra.main_hand, false), (&m.extra.off_hand, true)] {
let Some(item) = item else { continue };
let arm = if left { "left_arm" } else { "right_arm" };
let offset = if skeleton {
if left { -1.0 } else { 1.0 }
} else {
0.0
};
let Some(mut t) = part_matrix(model, base, poses, arm, offset) else {
let Some(mut t) = hand_base(m, model, base, poses, left) else {
continue;
};
let Some(uv) = atlas(&item_sprite(m, item)) else {
continue;
};
let baby = m.is_baby();
let (ox, oy, oz) = if baby {
(0.0, 1.0, -4.5)
} else {
(1.0, 2.0, -10.0)
};
t *= glam::Mat4::from_rotation_x((-90.0f32).to_radians()) * glam::Mat4::from_rotation_y(PI);
t *= glam::Mat4::from_translation(glam::Vec3::new(
if left { -ox } else { ox } / 16.0,
oy / 16.0,
oz / 16.0,
));
// ItemTransform.apply (mirrored for the left hand).
let (rot, tr, sc) = item_display(item);
let (ry, rz, tx) = if left {
@@ -1032,11 +1133,29 @@ fn held_items(
));
t *= glam::Mat4::from_scale(glam::Vec3::from(sc));
t *= glam::Mat4::from_translation(glam::Vec3::splat(-0.5));
draw_item_plane(t, uv, light, out);
let glint = super::gear::enchanted(
m,
if left {
super::gear::OFF
} else {
super::gear::MAIN
},
);
draw_item_plane_with(t, uv, light, if glint { 7 } else { 0 }, out);
}
}
/// A generated item model: the sprite on two faces 1/16 apart.
pub fn draw_item_plane(t: glam::Mat4, uv: [f32; 4], light: u32, out: &mut Vec<Vertex>) {
draw_item_plane_with(t, uv, light, 0, out);
}
/// `draw_item_plane` with an entity shader overlay (7: enchantment glint).
pub fn draw_item_plane_with(
t: glam::Mat4,
uv: [f32; 4],
light: u32,
overlay: u32,
out: &mut Vec<Vertex>,
) {
let (u0, v0, u1, v1) = (uv[0], uv[1], uv[2], uv[3]);
let south = 8.5 / 16.0;
let north = 7.5 / 16.0;
@@ -1060,7 +1179,7 @@ pub fn draw_item_plane(t: glam::Mat4, uv: [f32; 4], light: u32, out: &mut Vec<Ve
out.push(Vertex {
pos: pos.to_array(),
uv,
layer: 0,
layer: overlay,
color: 0xFFFF_FFFF,
light,
});
+166
View File
@@ -0,0 +1,166 @@
//! Mobs riding mobs (`Entity.getPassengers`): where a rider sits on its
//! vehicle (`EntityAttachments`), the rider steering the vehicle toward its
//! target (`Mob.getControllingPassenger`, whose navigation and move control
//! the rider's goals use), and the saved jockey fields. The game links the
//! two (`game/passengers.rs`) and spawns the jockeys.
use super::{
Mob, MobWorld, Species,
goals::{JUMP, LOOK, MOVE},
};
use horizon_core::geometry::Vec3;
use horizon_world::nbt::{Compound, Tag};
/// The goal flags a controlling passenger takes from its vehicle.
const CONTROLLED: u8 = MOVE | JUMP | LOOK;
/// `EntityType` passenger attachment of a vehicle (before rotation): where a
/// rider's attachment point sits relative to the vehicle's feet.
pub fn passenger_attachment(v: &Mob) -> [f64; 3] {
match v.species() {
Species::Chicken => [0.0, 0.7, -0.1],
Species::Spider => [0.0, 0.765, 0.0],
Species::Ravager => [0.0, 2.2625, -0.0625],
Species::Horse => [0.0, 1.44375, 0.0],
Species::Donkey => [0.0, 1.1125, 0.0],
Species::Mule => [0.0, 1.2125, 0.0],
Species::SkeletonHorse | Species::ZombieHorse => [0.0, 1.31875, 0.0],
Species::Pig => [0.0, 0.86875, 0.0],
// The default attachments: the top of the bounding box.
_ => [0.0, f64::from(v.height()), 0.0],
}
}
/// The rider's own `VEHICLE` attachment height (`ridingOffset`): how far
/// below the vehicle's attachment point its feet hang.
pub fn vehicle_attachment(r: &Mob) -> f64 {
use Species as S;
match r.species() {
S::Zombie | S::Husk | S::Drowned if r.is_baby() => 0.1875,
S::ZombieVillager if r.is_baby() => 0.125,
S::Zombie
| S::Husk
| S::Drowned
| S::ZombieVillager
| S::ZombifiedPiglin
| S::Piglin
| S::PiglinBrute
| S::Skeleton
| S::Stray
| S::Bogged
| S::Parched
| S::WitherSkeleton => 0.7,
S::Pillager | S::Vindicator | S::Evoker => 0.6,
_ => 0.0,
}
}
/// `Vec3.yRot(-yaw)` of an attachment point.
fn rotated([x, y, z]: [f64; 3], yaw: f32) -> [f64; 3] {
let a = -f64::from(yaw).to_radians();
let (sin, cos) = (a.sin(), a.cos());
[x * cos + z * sin, y, z * cos - x * sin]
}
/// `Entity.positionRider`: the vehicle's position plus its rotated passenger
/// attachment, less the rider's own vehicle attachment.
pub fn seat(attachment: [f64; 3], rider_offset: f64, at: Vec3, yaw: f32) -> Vec3 {
let [x, y, z] = rotated(attachment, yaw);
Vec3::new(at.x + x, at.y + y - rider_offset, at.z + z)
}
/// Ranged riders keep this far from their target instead of closing in.
const RANGED_DISTANCE: f64 = 8.0;
fn ranged(s: Species) -> bool {
matches!(
s,
Species::Skeleton
| Species::Stray
| Species::Bogged
| Species::Parched
| Species::Pillager
| Species::Witch
| Species::Piglin
)
}
/// A mob rider steers: while it has a target, its vehicle gives up its own
/// movement goals and carries it toward the target (melee riders to contact,
/// archers to a shooting distance). Without a target the vehicle wanders.
pub fn drive(m: &mut Mob, w: &MobWorld) {
let Some(rider) = m.extra.rider else {
m.ai.goals.disabled &= !CONTROLLED;
return;
};
let seen = w.seen(rider).filter(|s| s.alive);
let info = seen
.and_then(|s| s.target)
.and_then(|t| w.target_info(t))
.filter(|t| t.alive && !(t.is_player && t.creative));
let (Some(seen), Some(t)) = (seen, info) else {
m.ai.goals.disabled &= !CONTROLLED;
return;
};
m.ai.goals.disabled |= CONTROLLED;
m.look_at_speed([t.position.x, t.eye_y, t.position.z], 30.0, 30.0);
let close =
ranged(seen.species) && m.distance_sqr(t.position) < RANGED_DISTANCE * RANGED_DISTANCE;
if close {
m.nav_stop();
} else if m.ai.nav.is_done() || (m.age + m.id).is_multiple_of(10) {
m.nav_move_to_entity(w, [t.position.x, t.position.y, t.position.z], 0, 1.0);
}
}
/// `Mob.requiresCustomPersistence`: a passenger never despawns.
pub fn keeps_alive(m: &Mob) -> bool {
m.extra.mount.is_some()
}
/// `IsChickenJockey`, `SkeletonTrap` and `SkeletonTrapTime`.
pub fn write_nbt(m: &Mob, map: &mut Compound) {
match m.species() {
Species::Chicken => {
map.insert(
"IsChickenJockey".into(),
Tag::Byte(i8::from(m.extra.jockey)),
);
}
Species::SkeletonHorse => {
map.insert("SkeletonTrap".into(), Tag::Byte(i8::from(m.extra.trap)));
map.insert("SkeletonTrapTime".into(), Tag::Int(m.extra.trap_time));
}
_ => {}
}
}
pub fn read_nbt(m: &mut Mob, tag: &Tag) {
let int = |key: &str| match tag.get(key) {
Some(Tag::Int(v)) => *v,
Some(Tag::Byte(v)) => i32::from(*v),
Some(Tag::Short(v)) => i32::from(*v),
_ => 0,
};
match m.species() {
Species::Chicken => m.extra.jockey = int("IsChickenJockey") != 0,
Species::SkeletonHorse => {
m.extra.trap = int("SkeletonTrap") != 0;
m.extra.trap_time = int("SkeletonTrapTime");
}
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn attachments_turn_with_the_vehicle() {
// A ravager's seat sits a sixteenth behind its centre.
let behind = [0.0, 2.2625, -0.0625];
let [x, y, z] = rotated(behind, 0.0);
assert!(x.abs() < 1e-9 && (z + 0.0625).abs() < 1e-9 && y == 2.2625);
// Facing west (yaw 90), behind is to the east.
let [x, _, z] = rotated(behind, 90.0);
assert!((x - 0.0625).abs() < 1e-9 && z.abs() < 1e-9);
}
#[test]
fn archers_keep_their_distance_and_brawlers_close_in() {
assert!(ranged(Species::Skeleton) && ranged(Species::Pillager));
assert!(!ranged(Species::Zombie) && !ranged(Species::Vindicator));
}
}
+4
View File
@@ -199,6 +199,9 @@ fn zombified_piglin_step(m: &mut Mob, cx: &mut Cx) {
}
}
pub fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
if m.species() == Species::ZombieVillager {
super::zombie_villager::step(m, cx);
}
if m.species() == Species::ZombifiedPiglin {
return zombified_piglin_step(m, cx);
}
@@ -414,6 +417,7 @@ pub fn perform_ranged_attack(m: &mut Mob, who: Who, cx: &mut Cx, power: f32) {
start,
Some(Who::Mob(m.id)),
);
p.bonus = super::gear::arrow_bonus(m);
p.shoot(
&mut m.random,
[xd, yd + dist * 0.2, zd],
@@ -647,6 +647,8 @@ pub struct Ext {
pub golem_until: i64,
/// The `last_hurt_by_time` of the player's hit already counted.
pub hurt_seen: i32,
/// A zombie villager's cure under way.
pub cure: Option<super::zombie_villager::Cure>,
}
pub fn ext(m: &Mob) -> Option<&Ext> {
m.extra.villager.as_deref()
@@ -0,0 +1,164 @@
//! Zombie villagers (`ZombieVillager`): the cure started by a golden apple on
//! a weakened one, the conversion clock that iron bars and beds speed up, and
//! the saved fields. Turning villagers into zombie villagers and back is done
//! by the game (`game/zombie_villagers.rs`), which owns entity creation.
use super::{Mob, MobEvent, MobWorld, Species, goals::Cx, villager};
use horizon_core::random::RandomSource;
use horizon_world::nbt::{Compound, Tag};
/// `VILLAGER_CONVERSION_WAIT_MIN` and the width of the random range.
pub const WAIT_MIN: i32 = 3600;
pub const WAIT_SPREAD: i32 = 2401;
/// `MAX_SPECIAL_BLOCKS_COUNT` and `SPECIAL_BLOCK_RADIUS`.
const MAX_SPECIAL_BLOCKS: i32 = 14;
const RADIUS: i32 = 4;
const SPEEDS_UP_CURING: &str = "minecraft:speeds_up_zombie_villager_curing";
/// A cure under way: ticks left and the player who started it.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Cure {
pub time: i32,
pub starter: Option<[i32; 4]>,
}
pub fn cure(m: &Mob) -> Option<&Cure> {
villager::ext(m).and_then(|e| e.cure.as_ref())
}
pub fn is_converting(m: &Mob) -> bool {
m.species() == Species::ZombieVillager && cure(m).is_some()
}
/// `removeWhenFarAway`: curing ones and those with experience stay.
pub fn keeps_alive(m: &Mob) -> bool {
m.species() == Species::ZombieVillager
&& (is_converting(m) || m.extra.trade.as_ref().is_some_and(|t| t.xp != 0))
}
/// `ZombieVillager.startConverting`: weakness gives way to strength for the
/// length of the cure and the cure sound plays (entity event 16).
pub fn start_converting(
m: &mut Mob,
starter: Option<[i32; 4]>,
time: i32,
events: &mut Vec<MobEvent>,
) {
villager::ext_mut(m).cure = Some(Cure { time, starter });
m.extra.effects.retain(|e| e.0 != "minecraft:weakness");
// Strength amplifier: min(difficulty id - 1, 0), always 0 with monsters.
m.add_effect("minecraft:strength", time, 0);
let pitch = m.random.next_float() * 0.7 + 0.3;
let volume = 1.0 + m.random.next_float();
events.push(MobEvent::Sound(
"entity.zombie_villager.cure",
[m.position.x, m.eye_y(), m.position.z],
volume,
pitch,
));
}
/// `getConversionProgress`: 1 per tick, plus a chance per nearby iron bars or
/// bed (up to 14 of them) found on one tick in a hundred.
fn progress(m: &mut Mob, w: &MobWorld) -> i32 {
let mut amount = 1;
if m.random.next_float() < 0.01 {
let mut special = 0;
// `(int) getX()` truncates toward zero.
let (bx, by, bz) = (
m.position.x as i32,
m.position.y as i32,
m.position.z as i32,
);
'scan: for x in bx - RADIUS..bx + RADIUS {
for y in by - RADIUS..by + RADIUS {
for z in bz - RADIUS..bz + RADIUS {
if special >= MAX_SPECIAL_BLOCKS {
break 'scan;
}
if w.has_tag(SPEEDS_UP_CURING, w.block_name(x, y, z)) {
if m.random.next_float() < 0.3 {
amount += 1;
}
special += 1;
}
}
}
}
}
amount
}
/// `ZombieVillager.tick`: count the cure down, finishing it at zero.
pub fn step(m: &mut Mob, cx: &mut Cx) {
if !m.alive() || !is_converting(m) {
return;
}
let amount = progress(m, cx.w);
let Some(c) = villager::ext_mut(m).cure.as_mut() else {
return;
};
c.time -= amount;
if c.time <= 0 {
cx.events.push(MobEvent::CureZombieVillager { mob: m.id });
}
}
/// `ConversionTime` (-1: not converting) and `ConversionPlayer`.
fn put_cure(map: &mut Compound, cure: Option<Cure>) {
map.insert(
"ConversionTime".into(),
Tag::Int(cure.map_or(-1, |c| c.time)),
);
if let Some(starter) = cure.and_then(|c| c.starter) {
map.insert("ConversionPlayer".into(), Tag::IntArray(starter.to_vec()));
}
}
fn parse_cure(tag: &Tag) -> Option<Cure> {
let time = match tag.get("ConversionTime") {
Some(Tag::Int(v)) => *v,
_ => -1,
};
(time != -1).then(|| Cure {
time,
starter: crate::save::uuid_from_tag(tag.get("ConversionPlayer")),
})
}
/// The saved fields: the cure and the gossip.
pub fn write_nbt(m: &Mob, map: &mut Compound) {
put_cure(map, cure(m).copied());
if let Some(e) = villager::ext(m)
&& !e.gossips.is_empty()
{
map.insert("Gossips".into(), e.gossips.to_nbt());
}
}
pub fn read_nbt(m: &mut Mob, tag: &Tag) {
let cure = parse_cure(tag);
let e = villager::ext_mut(m);
e.cure = cure;
e.gossips = tag
.get("Gossips")
.map(crate::gossip::Gossips::from_nbt)
.unwrap_or_default();
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_cure_round_trips_through_nbt() {
let cure = Cure {
time: 4200,
starter: Some([1, 2, 3, 4]),
};
let mut map = Compound::new();
put_cure(&mut map, Some(cure));
assert_eq!(parse_cure(&Tag::Compound(map)), Some(cure));
}
#[test]
fn no_cure_saves_minus_one() {
let mut map = Compound::new();
put_cure(&mut map, None);
assert_eq!(map.get(&"ConversionTime".into()), Some(&Tag::Int(-1)));
assert_eq!(parse_cure(&Tag::Compound(map)), None);
}
}
+3
View File
@@ -63,6 +63,8 @@ pub struct Projectile {
pub stuck: bool,
/// Whether the projectile has left its owner's box (Projectile.leftOwner).
pub left_owner: bool,
/// The shooter's bow enchantments (Power, Punch, Flame, Piercing).
pub bonus: crate::mobs::gear::ArrowBonus,
}
/// What a projectile struck this tick.
#[derive(Clone, Copy, Debug, PartialEq)]
@@ -122,6 +124,7 @@ impl Projectile {
age: 0,
stuck: false,
left_owner: false,
bonus: Default::default(),
}
}
pub fn is_arrow(&self) -> bool {
+81 -8
View File
@@ -113,6 +113,26 @@ pub fn dimension_dir(world: &Path, dimension: &str) -> PathBuf {
.unwrap_or(("minecraft", dimension));
world.join("dimensions").join(namespace).join(path)
}
/// `DirectoryLock`: `session.lock` holds "\u{2603}" (UTF-16BE) under an exclusive
/// file lock for as long as the world is open, so two instances cannot share it.
pub struct SessionLock(#[allow(dead_code)] fs::File);
impl SessionLock {
pub fn acquire(world: &Path) -> Result<Self> {
use std::io::Write;
fs::create_dir_all(world)?;
let mut file = fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(false)
.open(world.join("session.lock"))?;
file.try_lock()
.map_err(|_| format!("{} is already open in another instance", world.display()))?;
file.set_len(0)?;
file.write_all(&[0x26, 0x03])?;
file.flush()?;
Ok(Self(file))
}
}
/// Move a world saved by an older Horizon build (pre-26.3 layout with a
/// DataVersion that keeps vanilla from upgrading it) into the 26.3 layout.
pub fn migrate_legacy(world: &Path) -> Result<()> {
@@ -199,6 +219,9 @@ pub struct ChunkExtras {
pub root: Compound,
/// Block entities Horizon does not model.
pub block_entities: Vec<Tag>,
/// The NBT of the modelled block entities as loaded, to restore the fields and
/// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
/// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
/// save time. Registered with the level's tick scheduler on arrival and
/// replaced with the scheduler's pending ticks when saving.
@@ -435,6 +458,17 @@ pub fn encode_block_entity(
}
Tag::compound(entries)
}
/// `block_entity_nbt::overlay`, then a container that now holds items loses its
/// loot table (vanilla clears it when the loot is generated into the container).
fn merge_block_entity(original: &Tag, loaded: &Tag, current: &Tag) -> Tag {
let mut merged = crate::block_entity_nbt::overlay(original, loaded, current);
let has_items = matches!(current.get("Items"), Some(Tag::List(items)) if !items.is_empty());
if has_items && let Tag::Compound(map) = &mut merged {
map.remove(&"LootTable".into());
map.remove(&"LootTableSeed".into());
}
merged
}
pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers::BlockEntity)> {
use crate::containers::BlockEntity;
let int = |k: &str| number(tag.get(k)).map(|v| v as i32);
@@ -495,7 +529,7 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain
f.lit_remaining = int("lit_time_remaining").unwrap_or(0);
f.lit_total = int("lit_total_time").unwrap_or(0);
f.cooking_timer = int("cooking_time_spent").unwrap_or(0);
f.cooking_total = int("cooking_total_time").unwrap_or(200);
f.cooking_total = int("cooking_total_time").unwrap_or(0);
if let Some(speed) = float(tag.get("speed_multiplier")) {
f.speed = speed as f32;
}
@@ -736,7 +770,27 @@ pub fn encode_with(
let mut block_entities: Vec<Tag> = chunk
.block_entities
.iter()
.map(|(p, e)| encode_block_entity(*p, e, &block_name(p)))
.map(|(p, e)| {
let block = block_name(p);
let current = encode_block_entity(*p, e, &block);
let source = extras
.and_then(|x| x.block_entity_sources.iter().find(|(q, _)| q == p))
.map(|(_, tag)| tag)
.filter(|tag| {
crate::block_entity_nbt::id(tag) == crate::block_entity_nbt::id(&current)
});
let merged = match source {
Some(original) => {
let loaded = decode_block_entity(original).map_or_else(
|| current.clone(),
|(q, e)| encode_block_entity(q, &e, &block),
);
merge_block_entity(original, &loaded, &current)
}
None => current,
};
crate::block_entity_nbt::canonical(&merged).unwrap_or(merged)
})
.collect();
if let Some(extras) = extras {
for raw in &extras.block_entities {
@@ -749,7 +803,8 @@ pub fn encode_with(
let still_there =
tables.is_none_or(|t| t.block_entity.get(state).copied().unwrap_or(true));
if still_there && !chunk.block_entities.iter().any(|(p, _)| *p == pos) {
block_entities.push(raw.clone());
block_entities
.push(crate::block_entity_nbt::canonical(raw).unwrap_or_else(|| raw.clone()));
}
}
}
@@ -946,7 +1001,10 @@ pub fn decode_with(
if let Some(Tag::List(entities)) = tag.get("block_entities") {
for e in entities {
match decode_block_entity(e) {
Some(be) => chunk.block_entities.push(be),
Some(be) => {
extras.block_entity_sources.push((be.0, e.clone()));
chunk.block_entities.push(be);
}
None => extras.block_entities.push(e.clone()),
}
}
@@ -1299,7 +1357,7 @@ pub fn random_uuid() -> [i32; 4] {
let b = (b & !(0xC000_0000_0000_0000)) | 0x8000_0000_0000_0000;
[(a >> 32) as i32, a as i32, (b >> 32) as i32, b as i32]
}
fn uuid_tag(u: [i32; 4]) -> Tag {
pub(crate) fn uuid_tag(u: [i32; 4]) -> Tag {
Tag::IntArray(u.to_vec())
}
pub(crate) fn uuid_from_tag(tag: Option<&Tag>) -> Option<[i32; 4]> {
@@ -1580,7 +1638,7 @@ impl Level {
level.player_extra = player;
Some(level)
}
fn read_player(&mut self, p: &Tag) {
pub fn read_player(&mut self, p: &Tag) {
let n = |k: &str| number(p.get(k));
let f = |k: &str| float(p.get(k));
self.position = read_doubles::<3>(p.get("Pos"));
@@ -1786,8 +1844,10 @@ impl Level {
}),
),
];
if !equipment.is_empty() {
entries.push(("equipment", Tag::compound(equipment)));
// Vanilla writes `equipment` even when empty and omits an empty effect list.
entries.push(("equipment", Tag::compound(equipment)));
if self.active_effects.is_empty() {
entries.retain(|(key, _)| *key != "active_effects");
}
if let Some(pos) = self.position {
entries.push(("Pos", doubles(&pos)));
@@ -2127,6 +2187,19 @@ impl<G: ChunkGenerator> ChunkGenerator for Persistent<G> {
#[cfg(test)]
mod tests {
#[test]
fn session_lock_is_exclusive() {
let dir = std::env::temp_dir().join(format!("horizon-lock-{}", std::process::id()));
let first = super::SessionLock::acquire(&dir).expect("first lock");
assert!(super::SessionLock::acquire(&dir).is_err());
assert_eq!(
std::fs::read(dir.join("session.lock")).unwrap(),
[0x26, 0x03]
);
drop(first);
assert!(super::SessionLock::acquire(&dir).is_ok());
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn crafter_block_entity_round_trips() {
let mut crafter = crate::containers::Crafter::default();
+47 -19
View File
@@ -123,6 +123,9 @@ pub struct Streaming {
/// Chunks come from a server (`insert_remote`/`forget`): nothing is
/// generated and columns are only unloaded when the server says so.
pub remote: bool,
/// More areas to keep loaded (centre chunk, radius), e.g. around guests
/// of a world open to the network. They are generated and kept but not meshed.
pub extra: Vec<((i32, i32), i32)>,
}
pub struct WorkerContext {
pub assets: Arc<crate::assets::Assets>,
@@ -231,6 +234,7 @@ impl Streaming {
generated_total: 0,
meshed_total: 0,
remote: false,
extra: Vec::new(),
}
}
/// A column received from a server: store it and relight it and its neighbours.
@@ -265,8 +269,14 @@ impl Streaming {
self.shared.ready.notify_one();
}
fn distance(&self, x: i32, z: i32) -> i64 {
let (dx, dz) = (i64::from(x - self.center.0), i64::from(z - self.center.1));
dx * dx + dz * dz
let d = |c: (i32, i32)| {
let (dx, dz) = (i64::from(x - c.0), i64::from(z - c.1));
dx * dx + dz * dz
};
self.extra
.iter()
.map(|(c, _)| d(*c))
.fold(d(self.center), i64::min)
}
fn region(world: &World, x: i32, z: i32) -> Option<Box<Region>> {
let mut region: Region = Default::default();
@@ -408,12 +418,16 @@ impl Streaming {
self.meshed.remove(key);
}
// Drop far proto chunks that are not checked out.
let (cx, cz, r4) = (self.center.0, self.center.1, i64::from(self.radius + 4));
let areas: Vec<((i32, i32), i64)> =
std::iter::once((self.center, i64::from(self.radius + 4)))
.chain(self.extra.iter().map(|&(c, r)| (c, i64::from(r + 4))))
.collect();
let forced = &self.forced;
self.protos.retain(|&(x, z), p| {
let d = i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2);
p.is_none()
|| d <= r4 * r4
|| areas.iter().any(|&((cx, cz), r4)| {
i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2) <= r4 * r4
})
|| forced
.iter()
.any(|f| (x - f.0).abs() <= 3 && (z - f.1).abs() <= 3)
@@ -496,20 +510,25 @@ impl Streaming {
// Generation (load or proto), closest first, bounded in flight.
let margin = if self.decorates { 3 } else { 1 };
if !self.remote && self.generating.len() < workers * 3 {
let r = self.radius + margin;
let mut wanted = Vec::new();
for dz in -r..=r {
for dx in -r..=r {
let (x, z) = (self.center.0 + dx, self.center.1 + dz);
if !self.in_range(x, z, margin)
|| world.chunks.contains_key(&(x, z))
|| self.generating.contains(&(x, z))
|| self.protos.contains_key(&(x, z))
|| self.finishing.contains(&(x, z))
{
continue;
let areas: Vec<((i32, i32), i32)> = std::iter::once((self.center, self.radius))
.chain(self.extra.iter().copied())
.collect();
for (center, radius) in areas {
let r = radius + margin;
for dz in -r..=r {
for dx in -r..=r {
let (x, z) = (center.0 + dx, center.1 + dz);
if !self.in_range(x, z, margin)
|| world.chunks.contains_key(&(x, z))
|| self.generating.contains(&(x, z))
|| self.protos.contains_key(&(x, z))
|| self.finishing.contains(&(x, z))
{
continue;
}
wanted.push((self.distance(x, z), x, z));
}
wanted.push((self.distance(x, z), x, z));
}
}
// Forced chunks and their generation neighbourhood.
@@ -560,7 +579,7 @@ impl Streaming {
let dirty: Vec<_> = world.dirty_sections.iter().copied().collect();
let mut columns: HashMap<(i32, i32), Option<Box<Region>>> = HashMap::new();
for (x, sy, z) in dirty {
if !world.chunks.contains_key(&(x, z)) || !self.in_range(x, z, 0) {
if !world.chunks.contains_key(&(x, z)) || !self.in_main_range(x, z, 0) {
world.dirty_sections.remove(&(x, sy, z));
continue;
}
@@ -666,8 +685,17 @@ impl Streaming {
}
}
fn in_range(&self, x: i32, z: i32, margin: i32) -> bool {
self.in_main_range(x, z, margin)
|| self.extra.iter().any(|&(c, radius)| {
let r = i64::from(radius + margin);
let (dx, dz) = (i64::from(x - c.0), i64::from(z - c.1));
dx * dx + dz * dz <= r * r
})
}
fn in_main_range(&self, x: i32, z: i32, margin: i32) -> bool {
let r = i64::from(self.radius + margin);
if self.distance(x, z) <= r * r {
let (dx, dz) = (i64::from(x - self.center.0), i64::from(z - self.center.1));
if dx * dx + dz * dz <= r * r {
return true;
}
let reach = (margin - 1).max(0);
+7
View File
@@ -37,6 +37,9 @@ pub struct World {
pub game_time: i64,
pub day_time: i64,
pub weather: Weather,
/// Every block position written since the log was last drained, kept
/// only while the world is open to the network (see `lan`).
pub block_log: Option<Vec<(i32, i32, i32)>>,
}
/// ServerLevel weather state (advanceWeatherCycle).
#[derive(Clone, Copy, Debug, Default)]
@@ -117,6 +120,7 @@ impl World {
game_time: 0,
day_time: 1000,
weather: Weather::default(),
block_log: None,
}
}
/// A controlled blockstate scene for the native scene probes: material
@@ -190,6 +194,9 @@ impl World {
.push(((x, y, z), previous, state.0 as u16));
}
self.revision = self.revision.wrapping_add(1);
if let Some(log) = &mut self.block_log {
log.push((x, y, z));
}
self.modified.insert((x >> 4, z >> 4));
let sy = (y - MIN_Y) >> 4;
for dz in -1..=1 {
+495
View File
@@ -0,0 +1,495 @@
//! A protocol bot joins a hosted world the way a vanilla client does:
//! handshake, status, offline login, configuration (registries and tags),
//! then the play state (login, chunks with light, player list, entities,
//! block changes). Needs the prepared resources; skipped without them.
use horizon_client::{
chunk::{Chunk, MIN_Y},
lan::{
Lan,
chunks::ChunkEncoder,
data::SyncData,
entity::EntityState,
hub::{HostEvent, HostState, Hub, HubConfig, TickCtx},
},
world::World,
};
use horizon_protocol::{
PROTOCOL_VERSION,
connection::Connection,
crypto::offline_uuid,
packets::{
Empty,
configuration::{self as cfg, ClientInformation},
handshake, login,
play::{self, Clientbound as C, Serverbound as S},
status,
},
};
use horizon_world::registry::BlockStateId;
use std::{
path::Path,
sync::Arc,
thread,
time::{Duration, Instant},
};
fn resources() -> Option<std::path::PathBuf> {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
root.join("items.json").exists().then_some(root)
}
const STONE: u16 = 1;
fn flat_world() -> World {
let mut world = World::new(BlockStateId(0), 0);
for cz in -4..=4 {
for cx in -4..=4 {
let mut chunk = Chunk::empty(cx, cz);
for z in 0..16 {
for x in 0..16 {
chunk.set(x, MIN_Y + 4, z, STONE);
}
}
chunk.lit = true;
world.chunks.insert((cx, cz), Arc::new(chunk));
}
}
world
}
struct Bot {
c: Connection,
name: String,
}
impl Bot {
fn recv_play(&mut self) -> Result<C, String> {
let (id, payload) = self.c.recv().map_err(|e| e.to_string())?;
match C::decode(id, &payload) {
Ok(p) => Ok(p),
// The command tree has argument nodes the client side does not decode.
Err(e) if id == horizon_protocol::ids::play::clientbound::COMMANDS => {
let _ = e;
Ok(C::Unknown(id, payload))
}
Err(e) => Err(format!("packet {id}: {e}")),
}
}
fn send(&mut self, p: S) {
self.c.send(&p.encode()).unwrap();
}
}
fn connect(port: u16, name: &str, known_pack: bool) -> Result<Bot, String> {
let e = |e: horizon_protocol::Error| e.to_string();
let mut c = Connection::connect("127.0.0.1", port, Duration::from_secs(5)).map_err(e)?;
c.reader
.set_read_timeout(Some(Duration::from_secs(20)))
.map_err(e)?;
c.send(
&handshake::Serverbound::Intention(handshake::Intention {
protocol: PROTOCOL_VERSION,
host: "127.0.0.1".into(),
port,
intent: handshake::LOGIN,
})
.encode(),
)
.map_err(e)?;
c.send(
&login::Serverbound::Hello(login::ServerHello {
name: name.into(),
uuid: offline_uuid(name),
})
.encode(),
)
.map_err(e)?;
loop {
let (id, payload) = c.recv().map_err(e)?;
match login::Clientbound::decode(id, &payload).map_err(e)? {
login::Clientbound::Compression(p) => c.set_compression(p.threshold),
login::Clientbound::LoginFinished(p) => {
assert_eq!(p.profile.name, name);
assert_eq!(p.profile.uuid, offline_uuid(name));
c.send(&login::Serverbound::LoginAcknowledged(Empty).encode())
.map_err(e)?;
break;
}
login::Clientbound::Disconnect(d) => return Err(d.reason_json),
other => return Err(format!("unexpected login packet {other:?}")),
}
}
c.send(&cfg::Serverbound::ClientInformation(ClientInformation::new(4)).encode())
.map_err(e)?;
let (mut registries, mut tags, mut features) = (0, 0, 0);
loop {
let (id, payload) = c.recv().map_err(e)?;
match cfg::Clientbound::decode(id, &payload).map_err(e)? {
cfg::Clientbound::SelectKnownPacks(p) => {
assert_eq!(p.packs.len(), 1);
assert_eq!(p.packs[0].id, "core");
let reply = if known_pack { p.packs } else { Vec::new() };
c.send(
&cfg::Serverbound::SelectKnownPacks(cfg::SelectKnownPacks { packs: reply })
.encode(),
)
.map_err(e)?;
}
cfg::Clientbound::RegistryData(r) => {
registries += 1;
let has_data = r.entries.iter().any(|e| e.data.is_some());
assert_eq!(has_data, !known_pack, "{}", r.registry);
}
cfg::Clientbound::UpdateTags(t) => tags += t.registries.len(),
cfg::Clientbound::UpdateEnabledFeatures(_) => features += 1,
cfg::Clientbound::FinishConfiguration(_) => {
c.send(&cfg::Serverbound::FinishConfiguration(Empty).encode())
.map_err(e)?;
break;
}
_ => {}
}
}
assert!(registries >= 28, "registries: {registries}");
assert!(tags >= 5, "tag registries: {tags}");
assert_eq!(features, 1);
Ok(Bot {
c,
name: name.into(),
})
}
/// Drive the hub like the game loop does until `done` is true.
struct Server {
hub: Hub,
world: World,
next_entity: u32,
placed: Vec<(u32, [i32; 3], u16, i32)>,
}
impl Server {
fn tick(&mut self, entities: &[EntityState]) {
let host = HostState {
uuid: 42,
name: "Host".into(),
entity_id: 1,
position: [0.5, -59.0, 0.5],
yaw: 0.0,
pitch: 0.0,
head_yaw: 0.0,
on_ground: true,
game_mode: 1,
sneaking: false,
sprinting: false,
equipment: Default::default(),
health: 20.0,
};
let mut ctx = TickCtx {
world: &mut self.world,
host: &host,
entities,
next_entity: &mut self.next_entity,
spawn: [8.5, f64::from(MIN_Y + 5), 8.5],
difficulty: 2,
difficulty_locked: false,
clock_rate: 1.0,
};
let events = self.hub.tick(&mut ctx);
for event in events {
match event {
HostEvent::Joined(conn) => self.hub.place_new_player(conn, &mut ctx),
HostEvent::Packet(conn, packet) => {
if let S::UseItemOn(p) = *packet {
let at = [p.pos[0], p.pos[1] + 1, p.pos[2]];
ctx.world
.set(at[0], at[1], at[2], BlockStateId(u32::from(STONE)))
.unwrap();
self.placed.push((conn, at, STONE, p.sequence));
self.hub.ack(conn, p.sequence);
}
}
_ => {}
}
}
}
}
fn server(resources: &Path) -> Server {
let sync = Arc::new(SyncData::load(resources).expect("sync data"));
let lan = Lan::start(sync.clone(), 0, "Test - World".into(), 8).unwrap();
let biomes: Vec<String> = sync
.dynamic
.registries
.get("minecraft:worldgen/biome")
.map(|v| v.iter().map(|(n, _)| n.clone()).collect())
.unwrap_or_default();
let states = vec![
(Arc::<str>::from("minecraft:air"), false),
(Arc::<str>::from("minecraft:stone"), false),
(Arc::<str>::from("minecraft:chest"), false),
];
let encoder = ChunkEncoder::new(states, &sync.builtin, &biomes, &biomes);
let hub = Hub::new(
lan,
sync,
encoder,
HubConfig {
default_game_mode: 1,
guest_commands: true,
force_game_mode: false,
hardcore: false,
view_distance: 3,
simulation_distance: 3,
dimension: "minecraft:overworld".into(),
seed: 1234,
max_players: 8,
},
);
Server {
hub,
world: flat_world(),
next_entity: 100,
placed: Vec::new(),
}
}
/// Tick the server while a bot thread runs.
fn run<T: Send + 'static>(
s: &mut Server,
bot: impl FnOnce() -> Result<T, String> + Send + 'static,
) -> T {
let handle = thread::spawn(bot);
let start = Instant::now();
while !handle.is_finished() {
s.tick(&[]);
thread::sleep(Duration::from_millis(10));
assert!(start.elapsed() < Duration::from_secs(40), "timed out");
}
handle.join().unwrap().unwrap()
}
#[test]
fn status_and_join() {
let Some(resources) = resources() else {
return;
};
let mut s = server(&resources);
let port = s.hub.lan.port;
// Server list ping.
let json = run(&mut s, move || {
let mut c = Connection::connect("127.0.0.1", port, Duration::from_secs(5))
.map_err(|e| e.to_string())?;
c.send(
&handshake::Serverbound::Intention(handshake::Intention {
protocol: PROTOCOL_VERSION,
host: "127.0.0.1".into(),
port,
intent: handshake::STATUS,
})
.encode(),
)
.unwrap();
c.send(&status::Serverbound::StatusRequest(Empty).encode())
.unwrap();
let (id, payload) = c.recv().map_err(|e| e.to_string())?;
let status::Clientbound::StatusResponse(r) =
status::Clientbound::decode(id, &payload).map_err(|e| e.to_string())?
else {
return Err("no status".into());
};
Ok(r.json)
});
let v: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(v["version"]["protocol"], 777);
assert_eq!(v["description"]["text"], "Test - World");
// Join, receive the world, place a block, see another player arrive.
let report = run(&mut s, move || {
let mut bot = connect(port, "Steve", true)?;
let mut chunks = 0;
let (mut login_seen, mut teleported, mut time, mut info) = (false, false, false, false);
let mut commands = false;
let deadline = Instant::now() + Duration::from_secs(15);
let mut sent_loaded = false;
let mut block_update = None;
while Instant::now() < deadline {
match bot.recv_play()? {
C::Login(l) => {
assert_eq!(l.chunk_radius, 3);
assert_eq!(l.spawn.dimension, "minecraft:overworld");
assert_eq!(l.spawn.game_type, 1);
login_seen = true;
}
C::PlayerPosition(p) => {
assert_eq!(p.position[0], 8.5);
bot.send(S::AcceptTeleportation(play::AcceptTeleportation {
id: p.teleport,
x: p.position[0],
y: p.position[1],
z: p.position[2],
yaw: 0.0,
pitch: 0.0,
}));
teleported = true;
}
C::SetTime(t) => {
assert!(!t.clocks.is_empty());
time = true;
}
C::PlayerInfoUpdate(u) => {
info |= u.entries.iter().any(|e| e.name.as_deref() == Some("Host"));
}
C::Unknown(id, _) if id == horizon_protocol::ids::play::clientbound::COMMANDS => {
commands = true
}
C::LevelChunkWithLight(l) => {
chunks += 1;
let sections = l.chunk.sections(24, 16, 7).map_err(|e| e.to_string())?;
// The floor is in the lowest section.
assert_eq!(sections[0].states.get(4 * 256), i32::from(STONE));
assert_eq!(sections[0].non_empty, 256);
assert_eq!(sections[1].non_empty, 0);
assert!(!l.light.sky.is_empty());
}
C::ChunkBatchFinished(b) => {
assert!(b.size > 0);
bot.send(S::ChunkBatchReceived(play::ChunkBatchReceived {
chunks_per_tick: 20.0,
}));
if !sent_loaded && chunks >= 9 {
bot.send(S::PlayerLoaded(Empty));
sent_loaded = true;
bot.send(S::MovePlayerPosRot(play::MovePlayerPosRot {
x: 9.5,
y: f64::from(MIN_Y + 5),
z: 9.5,
yaw: 90.0,
pitch: 10.0,
flags: 1,
}));
bot.send(S::UseItemOn(play::UseItemOn {
hand: 0,
pos: [9, MIN_Y + 4, 9],
face: 1,
cursor: [0.5, 1.0, 0.5],
inside: false,
world_border: false,
sequence: 77,
}));
}
}
C::BlockUpdate(u) => {
block_update = Some((u.pos, u.state));
}
C::BlockChangedAck(a) if a.sequence == 77 && block_update.is_some() => break,
_ => {}
}
}
assert!(
login_seen && teleported && time && info && commands,
"missing login data"
);
assert!(chunks >= 9, "only {chunks} chunks");
assert_eq!(
block_update,
Some(([9, MIN_Y + 5, 9], i32::from(STONE))),
"placed block was not broadcast"
);
Ok(bot.name)
});
assert_eq!(report, "Steve");
assert_eq!(s.placed.len(), 1);
}
#[test]
fn guests_see_each_other_and_the_world_entities() {
let Some(resources) = resources() else {
return;
};
let mut s = server(&resources);
let port = s.hub.lan.port;
let zombie = EntityState {
id: 500,
uuid: 9,
kind: "minecraft:zombie".into(),
position: [12.0, f64::from(MIN_Y + 5), 12.0],
yaw: 0.0,
pitch: 0.0,
head_yaw: 0.0,
on_ground: true,
velocity: [0.0; 3],
data: 0,
meta: Vec::new(),
equipment: Vec::new(),
send_velocity: false,
};
let first = thread::spawn(move || {
let mut bot = connect(port, "Alex", false)?;
let mut zombies = 0;
let mut players = 0;
let mut moves = 0;
let deadline = Instant::now() + Duration::from_secs(20);
while Instant::now() < deadline && !(zombies > 0 && players > 0 && moves > 0) {
match bot.recv_play()? {
C::PlayerPosition(p) => {
bot.send(S::AcceptTeleportation(play::AcceptTeleportation {
id: p.teleport,
x: p.position[0],
y: p.position[1],
z: p.position[2],
yaw: 0.0,
pitch: 0.0,
}))
}
C::AddEntity(a) if a.id == 500 => zombies += 1,
C::AddEntity(a) if a.uuid == offline_uuid("Bob") => players += 1,
C::MoveEntityPos(_) | C::MoveEntityPosRot(_) => moves += 1,
_ => {}
}
}
if zombies > 0 && players > 0 && moves > 0 {
Ok(())
} else {
Err(format!("zombies {zombies} players {players} moves {moves}"))
}
});
let second = thread::spawn(move || {
thread::sleep(Duration::from_millis(600));
let mut bot = connect(port, "Bob", true)?;
let deadline = Instant::now() + Duration::from_secs(20);
let mut x = 8.5;
while Instant::now() < deadline {
// Keep reading and walking so the other player sees movement.
bot.c
.reader
.set_read_timeout(Some(Duration::from_millis(200)))
.unwrap();
if let Ok((id, payload)) = bot.c.recv()
&& let Ok(C::PlayerPosition(p)) = C::decode(id, &payload)
{
bot.send(S::AcceptTeleportation(play::AcceptTeleportation {
id: p.teleport,
x: p.position[0],
y: p.position[1],
z: p.position[2],
yaw: 0.0,
pitch: 0.0,
}));
}
x += 0.2;
bot.send(S::MovePlayerPos(play::MovePlayerPos {
x,
y: f64::from(MIN_Y + 5),
z: 8.5,
flags: 1,
}));
}
Ok::<(), String>(())
});
let start = Instant::now();
while !first.is_finished() {
s.tick(std::slice::from_ref(&zombie));
thread::sleep(Duration::from_millis(10));
assert!(start.elapsed() < Duration::from_secs(40), "timed out");
}
first.join().unwrap().unwrap();
drop(second);
}
+142
View File
@@ -567,6 +567,139 @@ packet!(TeleportEntity {
on_ground: bool => Bool,
});
packet!(BlockEvent { pos: [i32; 3] => Pos, b0: u8 => UByte, b1: u8 => UByte, block: i32 => VarInt });
packet!(
/// ClientboundInitializeBorderPacket.
InitializeBorder {
center_x: f64 => Double,
center_z: f64 => Double,
old_size: f64 => Double,
new_size: f64 => Double,
lerp_time: i64 => VarLong,
absolute_max_size: i32 => VarInt,
warning_blocks: i32 => VarInt,
warning_time: i32 => VarInt,
}
);
packet!(TabList { header: Tag => Nbt, footer: Tag => Nbt });
packet!(ServerData { motd: Tag => Nbt, icon: Option<Vec<u8>> => Opt<crate::buf::Bytes> });
packet!(
/// ClientboundUpdateMobEffectPacket; flags: 1 ambient, 2 visible, 4 icon, 8 blend.
UpdateMobEffect { id: i32 => VarInt, effect: i32 => VarInt, amplifier: i32 => VarInt, duration: i32 => VarInt, flags: i8 => Byte }
);
packet!(RemoveMobEffect { id: i32 => VarInt, effect: i32 => VarInt });
packet!(
/// ClientboundSwingAnimationPacket: hand (0 main, 1 off) and the swing
/// type (0 none, 1 whack, 2 stab) with its duration in ticks.
SwingAnimation { id: i32 => VarInt, hand: i32 => VarInt, kind: i32 => VarInt, duration: i32 => VarInt }
);
packet!(SoundEntity {
sound: (i32, Option<(String, Option<f32>)>) => SoundHolder,
source: i32 => VarInt,
id: i32 => VarInt,
volume: f32 => Float,
pitch: f32 => Float,
seed: i64 => Long,
});
/// One entry of ClientboundCommandsPacket: a literal or an argument node.
#[derive(Clone, Debug, PartialEq)]
pub struct CommandNode {
/// 0 root, 1 literal, 2 argument.
pub kind: u8,
pub executable: bool,
pub restricted: bool,
pub children: Vec<i32>,
pub redirect: Option<i32>,
pub name: String,
/// Argument parser registry id and its raw property bytes.
pub parser: Option<(i32, Vec<u8>)>,
/// Custom suggestion provider (`minecraft:ask_server`).
pub suggestions: Option<String>,
}
/// The command tree: nodes and the index of the root.
#[derive(Clone, Debug, PartialEq)]
pub struct Commands {
pub nodes: Vec<CommandNode>,
pub root: i32,
}
impl Codec<Commands> for Commands {
fn read(r: &mut Reader) -> Result<Self> {
let n = r.count(r.remaining())?;
let mut nodes = Vec::with_capacity(n.min(4096));
for _ in 0..n {
let flags = r.u8()?;
let count = r.count(r.remaining())?;
let children = (0..count).map(|_| r.varint()).collect::<Result<_>>()?;
let redirect = if flags & 8 != 0 {
Some(r.varint()?)
} else {
None
};
let kind = flags & 3;
let (mut name, mut parser, mut suggestions) = (String::new(), None, None);
if kind >= 1 {
name = r.string(32767)?;
}
if kind == 2 {
// Properties are parser specific; only the property-less parsers
// can be skipped without a table, so keep the rest of the packet.
return Err(crate::Error::new("argument nodes are not decoded"));
}
let _ = (&mut parser, &mut suggestions);
nodes.push(CommandNode {
kind,
executable: flags & 4 != 0,
restricted: flags & 32 != 0,
children,
redirect,
name,
parser,
suggestions,
});
}
Ok(Self {
nodes,
root: r.varint()?,
})
}
fn write(v: &Self, w: &mut Writer) {
w.varint(v.nodes.len() as i32);
for n in &v.nodes {
let mut flags = n.kind & 3;
if n.executable {
flags |= 4;
}
if n.redirect.is_some() {
flags |= 8;
}
if n.suggestions.is_some() {
flags |= 16;
}
if n.restricted {
flags |= 32;
}
w.u8(flags);
w.varint(n.children.len() as i32);
n.children.iter().for_each(|c| w.varint(*c));
if let Some(r) = n.redirect {
w.varint(r);
}
if n.kind >= 1 {
w.string(&n.name);
}
if n.kind == 2 {
let (id, props) = n.parser.clone().unwrap_or((5, Vec::new()));
w.varint(id);
w.bytes(&props);
if let Some(s) = &n.suggestions {
w.string(s);
}
}
}
w.varint(v.root);
}
}
packet_enum!(Clientbound, crate::ids::play::clientbound {
BundleDelimiter(Empty) = BUNDLE_DELIMITER,
AddEntity(AddEntity) = ADD_ENTITY,
@@ -574,11 +707,13 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
BlockChangedAck(BlockChangedAck) = BLOCK_CHANGED_ACK,
BlockDestruction(BlockDestruction) = BLOCK_DESTRUCTION,
BlockEntityData(BlockEntityData) = BLOCK_ENTITY_DATA,
BlockEvent(BlockEvent) = BLOCK_EVENT,
BlockUpdate(BlockUpdate) = BLOCK_UPDATE,
ChangeDifficulty(ChangeDifficulty) = CHANGE_DIFFICULTY,
ChunkBatchFinished(ChunkBatchFinished) = CHUNK_BATCH_FINISHED,
ChunkBatchStart(Empty) = CHUNK_BATCH_START,
ClearTitles(Bool1) = CLEAR_TITLES,
Commands(Commands) = COMMANDS,
ContainerClose(ContainerClose) = CONTAINER_CLOSE,
ContainerSetContent(ContainerSetContent) = CONTAINER_SET_CONTENT,
ContainerSetData(ContainerSetData) = CONTAINER_SET_DATA,
@@ -592,6 +727,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
GameEvent(GameEvent) = GAME_EVENT,
HurtAnimation(HurtAnimation) = HURT_ANIMATION,
KeepAlive(KeepAlive) = KEEP_ALIVE,
InitializeBorder(InitializeBorder) = INITIALIZE_BORDER,
LevelChunkWithLight(LevelChunkWithLight) = LEVEL_CHUNK_WITH_LIGHT,
LevelEvent(LevelEvent) = LEVEL_EVENT,
LightUpdate(LightUpdate) = LIGHT_UPDATE,
@@ -609,10 +745,12 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
PlayerPosition(PlayerPosition) = PLAYER_POSITION,
PlayerRotation(PlayerRotation) = PLAYER_ROTATION,
RemoveEntities(RemoveEntities) = REMOVE_ENTITIES,
RemoveMobEffect(RemoveMobEffect) = REMOVE_MOB_EFFECT,
ResourcePackPush(ResourcePackPush) = RESOURCE_PACK_PUSH,
Respawn(Respawn) = RESPAWN,
RotateHead(RotateHead) = ROTATE_HEAD,
SectionBlocksUpdate(SectionBlocksUpdate) = SECTION_BLOCKS_UPDATE,
ServerData(ServerData) = SERVER_DATA,
SetActionBarText(Text) = SET_ACTION_BAR_TEXT,
SetChunkCacheCenter(SetChunkCacheCenter) = SET_CHUNK_CACHE_CENTER,
SetChunkCacheRadius(Distance) = SET_CHUNK_CACHE_RADIUS,
@@ -631,10 +769,14 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
SetTitleText(Text) = SET_TITLE_TEXT,
SetTitlesAnimation(TitlesAnimation) = SET_TITLES_ANIMATION,
Sound(Sound) = SOUND,
SoundEntity(SoundEntity) = SOUND_ENTITY,
StartConfiguration(Empty) = START_CONFIGURATION,
SwingAnimation(SwingAnimation) = SWING_ANIMATION,
SystemChat(SystemChat) = SYSTEM_CHAT,
TabList(TabList) = TAB_LIST,
TakeItemEntity(TakeItemEntity) = TAKE_ITEM_ENTITY,
TeleportEntity(TeleportEntity) = TELEPORT_ENTITY,
UpdateMobEffect(UpdateMobEffect) = UPDATE_MOB_EFFECT,
UpdateTags(UpdateTags) = UPDATE_TAGS,
});
packet!(
+130
View File
@@ -0,0 +1,130 @@
"""The test arrangement of tools/test_save_roundtrip_parity.py: one of every vanilla 26.3
block entity type and many entity types, placed by console commands in a flat world.
BLOCK_ENTITIES entries are (block id and states, block entity NBT in SNBT or '').
ENTITIES entries are (entity id, extra SNBT fields). Entities get deterministic UUIDs
and NoAI/Silent/NoGravity so that the two saves can be matched one to one.
"""
SWORD = ('{Slot:0b,id:"minecraft:iron_sword",count:1,components:{"minecraft:damage":7,'
'"minecraft:custom_name":{text:"Blade",italic:0b},"minecraft:enchantments":{"minecraft:sharpness":3}}}')
STONE = '{Slot:5b,id:"minecraft:stone",count:64}'
APPLE = '{Slot:1b,id:"minecraft:apple",count:3}'
NAME = 'CustomName:{text:"Named",color:"red"}'
LOCKED = 'lock:{components:{"minecraft:custom_name":{text:"Key"}}}'
LOOT = 'LootTable:"minecraft:chests/simple_dungeon",LootTableSeed:12345L'
SIGN_SIDE = ('{messages:[{text:"one",color:"red"},"two",{text:"three",bold:1b},""],color:"blue",'
'has_glowing_text:1b}')
BOOK = ('{id:"minecraft:written_book",count:1,components:{"minecraft:written_book_content":'
'{title:{raw:"Title"},author:"Author",pages:[{raw:"page one"},{raw:"page two"}]}}}')
FULL = [
('chest', f'{{Items:[{SWORD},{STONE}],{NAME},{LOCKED}}}'),
('chest[facing=east]', f'{{{LOOT}}}'),
('trapped_chest', f'{{Items:[{SWORD},{APPLE}]}}'),
('ender_chest', ''),
('barrel[facing=up]', f'{{Items:[{STONE}],{NAME}}}'),
('barrel[facing=up]', f'{{{LOOT}}}'),
('dispenser[facing=up]', f'{{Items:[{APPLE}],{NAME}}}'),
('dropper[facing=up]', f'{{Items:[{STONE}]}}'),
('hopper', f'{{Items:[{STONE}],TransferCooldown:3,{NAME}}}'),
('red_shulker_box', f'{{Items:[{SWORD},{STONE}],{NAME}}}'),
('furnace', f'{{Items:[{{Slot:0b,id:"minecraft:iron_ore",count:5}},{{Slot:1b,id:"minecraft:coal",count:2}}],'
'lit_time_remaining:100,lit_total_time:200,cooking_time_spent:50,cooking_total_time:200,'
'speed_multiplier:1.5f,RecipesUsed:{"minecraft:iron_ingot":2}}'),
('blast_furnace', '{Items:[{Slot:2b,id:"minecraft:iron_ingot",count:9}],RecipesUsed:{"minecraft:copper_ingot":4}}'),
('smoker', f'{{{NAME},cooking_total_time:100}}'),
('brewing_stand', f'{{Items:[{{Slot:0b,id:"minecraft:potion",count:1}},{{Slot:3b,id:"minecraft:nether_wart",count:2}},'
'{Slot:4b,id:"minecraft:blaze_powder",count:1}],BrewTime:200,Fuel:10}'),
('campfire', '{Items:[{Slot:0b,id:"minecraft:beef",count:1}],CookingTimes:[I;10,0,0,0],'
'CookingTotalTimes:[I;600,0,0,0]}'),
('soul_campfire', ''),
('chiseled_bookshelf', '{Items:[{Slot:0b,id:"minecraft:book",count:1},{Slot:3b,id:"minecraft:book",count:1}],'
'last_interacted_slot:3}'),
('oak_shelf', f'{{Items:[{APPLE}],align_items_to_bottom:1b}}'),
('crafter', f'{{crafting_ticks_remaining:3,disabled_slots:[I;2,4],triggered:1,Items:[{APPLE}]}}'),
('decorated_pot', '{sherds:{back:"minecraft:brick",left:"minecraft:brick",right:"minecraft:angler_pottery_sherd",'
'front:{id:"minecraft:brick"}},item:{id:"minecraft:diamond",count:2}}'),
('suspicious_sand', '{item:{id:"minecraft:diamond",count:1}}'),
('suspicious_gravel', f'{{{LOOT}}}'),
('jukebox', '{RecordItem:{id:"minecraft:music_disc_13",count:1},ticks_since_song_started:5L}'),
('lectern', f'{{Book:{BOOK},Page:1}}'),
('beacon', f'{{Levels:0,primary_effect:"minecraft:speed",secondary_effect:"minecraft:regeneration",{NAME}}}'),
('bell', ''),
('white_banner', '{patterns:[{pattern:"minecraft:stripe_top",color:"red"},'
'{pattern:"minecraft:creeper",color:"black"}],CustomName:{text:"Flag"}}'),
('skeleton_skull', '{note_block_sound:"minecraft:block.note_block.imitate.skeleton",custom_name:{text:"Skully"}}'),
('creeper_head', ''),
('oak_sign', f'{{front_text:{SIGN_SIDE},back_text:{{messages:["a","b","c","d"],color:"black",has_glowing_text:0b}},is_waxed:1b}}'),
('oak_hanging_sign', f'{{front_text:{SIGN_SIDE}}}'),
('spawner', '{SpawnData:{entity:{id:"minecraft:pig"}},Delay:20s,MinSpawnDelay:200s,MaxSpawnDelay:800s,'
'SpawnCount:4s,MaxNearbyEntities:6s,RequiredPlayerRange:16s,SpawnRange:4s}'),
('trial_spawner', '{required_player_range:10,target_cooldown_length:1200}'),
('vault', '{config:{loot_table:"minecraft:chests/trial_chambers/reward",key_item:{id:"minecraft:trial_key",count:1}},'
'server_data:{rewarded_players:[[I;1,2,3,4]],total_ejections_needed:2}}'),
('command_block', f'{{Command:"say hi",auto:1b,TrackOutput:0b,{NAME}}}'),
('chain_command_block', '{Command:"say chain",conditionMet:1b}'),
('comparator', '{OutputSignal:5}'),
('conduit', ''),
('daylight_detector', ''),
('enchanting_table', f'{{{NAME}}}'),
('end_gateway', '{Age:20L,exit_portal:[I;0,70,0],ExactTeleport:1b}'),
('end_portal', ''),
('jigsaw', '{name:"minecraft:a",target:"minecraft:b",pool:"minecraft:empty",final_state:"minecraft:stone",'
'joint:"aligned",placement_priority:1,selection_priority:2}'),
('structure_block', '{name:"test:s",author:"me",metadata:"meta",mode:"SAVE",posX:1,posY:2,posZ:3,sizeX:4,sizeY:5,'
'sizeZ:6,rotation:"CLOCKWISE_90",mirror:"LEFT_RIGHT",ignoreEntities:0b,integrity:0.5f,seed:9L}'),
('sculk_sensor', '{last_vibration_frequency:3}'),
('calibrated_sculk_sensor', ''),
('sculk_catalyst', ''),
('sculk_shrieker[can_summon=true]', '{warning_level:2}'),
('creaking_heart', ''),
('beehive', '{bees:[{entity_data:{id:"minecraft:bee"},ticks_in_hive:100,min_ticks_in_hive:2400}],flower_pos:[I;1,2,3]}'),
('bee_nest', ''),
('test_block', '{mode:"accept",message:"hello",powered:1b}'),
('test_instance_block', ''),
('copper_golem_statue', ''),
('potent_sulfur', '{countdown:7}'),
]
# The same blocks with no NBT: vanilla fills every field with its default, which
# Horizon must reproduce when it loads and saves them.
BLOCK_ENTITIES = FULL + [(block, '') for block, nbt in FULL if nbt]
# (entity id, extra SNBT). Each also gets UUID, Pos, NoAI, Silent, a name and a tag.
ENTITIES = [
('pig', ''), ('cow', 'Age:-100'), ('sheep', 'Color:5b,Sheared:1b'), ('chicken', 'EggLayTime:1000'),
('horse', 'Tame:1b,Variant:258,Temper:30'), ('wolf', 'Health:12f,CollarColor:3b'), ('cat', ''),
('villager', 'VillagerData:{profession:"minecraft:farmer",level:2,type:"minecraft:plains"},Xp:15,'
'Offers:{Recipes:[{buy:{id:"minecraft:wheat",count:20},sell:{id:"minecraft:emerald",count:1},'
'maxUses:16,uses:2,xp:2,priceMultiplier:0.05f,demand:0}]}'),
('zombie', 'IsBaby:1b,ArmorItems:[{},{},{},{id:"minecraft:iron_helmet",count:1}],HandItems:[{id:"minecraft:iron_sword",count:1},{}]'),
('skeleton', ''), ('creeper', 'powered:1b,Fuse:20s'), ('spider', ''), ('enderman', ''),
('bee', 'HasNectar:1b,Anger:0'), ('axolotl', 'Variant:2'), ('frog', ''), ('fox', 'Type:"snow"'),
('parrot', 'Variant:3'), ('llama', 'Strength:3,Variant:1'), ('rabbit', 'RabbitType:2'),
('allay', ''), ('iron_golem', 'PlayerCreated:1b'), ('snow_golem', 'Pumpkin:0b'),
('armor_stand', 'ShowArms:1b,Small:1b,Pose:{Head:[10f,20f,30f]},ArmorItems:[{},{},{},{id:"minecraft:diamond_helmet",count:1}]'),
('item', 'Item:{id:"minecraft:diamond",count:5},Age:100,PickupDelay:20s'),
('experience_orb', 'Value:7s,Age:30s'),
('item_frame', 'Facing:3b,Item:{id:"minecraft:apple",count:1},ItemRotation:2b,ItemDropChance:0.5f'),
('glow_item_frame', 'Facing:2b'),
('painting', 'Facing:3b,variant:"minecraft:kebab"'),
('arrow', 'inGround:1b,life:5s,damage:2.0d'),
('falling_block', 'BlockState:{id:"minecraft:anvil",properties:{facing:"east"}},Time:3,HurtEntities:1b,FallHurtAmount:2f'),
('tnt', 'fuse:50s,block_state:{id:"minecraft:tnt",properties:{unstable:"true"}}'),
('oak_boat', ''), ('chest_boat', ''),
('minecart', ''), ('chest_minecart', 'Items:[{Slot:0b,id:"minecraft:apple",count:2}]'),
('hopper_minecart', ''), ('furnace_minecart', 'Fuel:100s'), ('tnt_minecart', 'TNTFuse:-1'),
('text_display', 'text:{text:"Hello"},billboard:"center",line_width:100,background:1234,alignment:"left"'),
('block_display', 'block_state:{id:"minecraft:oak_stairs",properties:{facing:"east"}},transformation:{translation:[1f,0f,0f],left_rotation:[0f,0f,0f,1f],right_rotation:[0f,0f,0f,1f],scale:[2f,2f,2f]}'),
('item_display', 'item:{id:"minecraft:stone",count:1},item_display:"head"'),
('interaction', 'width:2f,height:3f,response:1b'),
('marker', 'data:{a:1,b:"two"}'),
('area_effect_cloud', 'Radius:3f,Duration:200,Particle:{type:"minecraft:entity_effect",color:16711680},Potion:"minecraft:poison"'),
('end_crystal', 'ShowBottom:0b'),
('snowball', ''), ('ender_pearl', ''), ('small_fireball', ''), ('wither_skull', 'dangerous:1b'),
('glow_squid', ''), ('turtle', 'HomePosX:1,HomePosY:-60,HomePosZ:1,HasEgg:1b'),
('ghast', ''), ('piglin', ''), ('hoglin', ''), ('strider', 'Saddle:1b'), ('warden', ''),
('trader_llama', ''), ('mooshroom', 'Type:"brown"'), ('panda', 'MainGene:"lazy"'),
('copper_golem', ''), ('creaking', ''),
]
+555
View File
@@ -0,0 +1,555 @@
#!/usr/bin/env python3
"""Save-format differential test: vanilla 26.3 world -> Horizon -> vanilla.
1. A headless vanilla server (flat world, offline) is filled with one of every block
entity type and many entity types (tools/save_roundtrip_scene.py), a bot player
joins so a player file exists, and the world is saved (world V0).
2. Horizon opens a copy of V0 under a virtual screen, rewrites every resident chunk and
entity section (`save-all`) and quits; this is world H.
3. The NBT of V0 and H is compared: chunks (block states and biomes decoded, so palette
order does not matter), block entities, entities, heightmaps, light, ticks, structure
data, level.dat, data/*.dat, players/data/*.dat. Differences must be explained by
IGNORED below (vanilla-irrelevant: elapsed time, ordering, derived data) or the test
fails.
4. The vanilla server loads H: its log must show no errors, upgrades or DataFixer
activity, and `data get` of every block entity and entity must print the same
data as the server that loaded V0 (so vanilla reads Horizon's files as it reads its own).
test_save_roundtrip_parity.py [--keep] [--skip-horizon] [--bin-dir DIR] [--stage gen|resave|compare|all]
[--world DIR] (compare an existing V0/H pair: --vanilla DIR --horizon DIR)
Run files stay under .local/save-roundtrip/run. The Horizon client runs on the virtual
screen (`vscreen`), never on a real monitor, with a null ALSA device.
"""
import argparse
import collections
import json
import os
import queue
import re
import shutil
import subprocess
import sys
import tempfile
import threading
import time
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
import anvil_dump # noqa: E402
import save_roundtrip_scene as scene # noqa: E402
ROOT = Path(__file__).resolve().parent.parent
LOCAL = ROOT / '.local'
RESOURCES = LOCAL / 'horizon-client' / '26.3'
SERVER = LOCAL / 'minecraft' / '26.3' / 'jars' / 'server.jar'
RUN = LOCAL / 'save-roundtrip' / 'run'
PORT = 25000 + (os.getpid() % 5000) + 1000
# Differences that do not change what vanilla reads: path pattern (list indices as [])
# -> reason. Anything else is a failure.
IGNORED = {
r'^chunk\.LastUpdate$': 'game time of the save (Horizon saves at its own time)',
r'^chunk\.InhabitedTime$': 'ticks the chunk was loaded; differs by the time Horizon ran',
r'^chunk\.isLightOn$': 'light is recomputed by vanilla when absent',
# Horizon keeps simulating between loading and saving (it needs a few seconds of
# chunk generation first), so counters and positions of live things move on.
r'^chunk\.block_entities\.\(2, -60, 5\)\.(cooking_time_spent|lit_time_remaining|Items\[\]\.count)$':
'the lit furnace keeps smelting',
r'^chunk\.block_entities\..*\.(ticks_since_song_started|Age|BrewTime|warning_level|ticks_in_hive)$':
'block entity timers advance',
r'^entity\.(Age|Motion\[\]|Rotation\[\]|Pos\[\]|OnGround|HurtTime|Health|TimeInOverworld|fall_distance|'
r'wasOnGround|Fire|Air|DeathTime|Fuse|life|inGround|ticks_in_ground)$': 'entity simulation advances',
r'^level\.dat\.Data\.(Time|LastPlayed)$': 'clock and wall time of the save',
r'^level\.dat\.Data\.(ServerBrands.*|singleplayer_uuid)$': 'a client world names its brand and its player',
r'^players/data/.*\.dat\.(Health|Pos\[\]|foodSaturationLevel|foodLevel|foodExhaustionLevel|Motion\[\]|OnGround)$':
'the player keeps simulating',
}
# Real differences that are known and not fixed yet: (pattern -> what is wrong). They are
# reported, and do not fail the run, so that new differences still do.
KNOWN_GAPS = {
r'^chunk\.sections\.blocks|^chunk\.Heightmaps': 'a falling block entity with NoGravity lands anyway',
r'^entity \(28672, 0, 0, 11\)': 'the spider is gone from the Horizon save (not yet explained)',
r'^entity \(28672, 0, 0, 30\) minecraft:falling_block': 'the NoGravity falling block landed (above)',
r'^entity\.attributes': 'Horizon derives the attribute list of a horse from its own model',
r'^entity\.Brain\.memories': 'Horizon gives villagers memories (meeting point) that vanilla had not formed yet',
}
SUSPICIOUS = re.compile(
r"(/ERROR\]|/WARN\]|login failed|Exception|Couldn't load|Failed to|Skipping|Invalid|Unknown|corrupt|"
r'Recreating|upgrad|DataFix|out of bounds|missing|Mismatch|Discarding)', re.IGNORECASE)
BENIGN = re.compile(r'(Unpacking |OFFLINE/INSECURE|online-mode|authenticate usernames|hackers|'
r'Failed to load properties|Failed to load eula|Unknown or incomplete command|'
r'Can.t keep up|Ignoring unknown|^WARNING: |No key layers|has the following)')
# ---------------------------------------------------------------- vanilla server
class Vanilla:
def __init__(self, directory, port=PORT, world='world', extra=None):
directory.mkdir(parents=True, exist_ok=True)
(directory / 'eula.txt').write_text('eula=true\n')
props = {
'server-port': port, 'online-mode': 'false', 'white-list': 'false', 'enforce-whitelist': 'false',
'level-name': world, 'level-seed': '4242', 'spawn-protection': '0', 'view-distance': '4',
'simulation-distance': '4', 'sync-chunk-writes': 'true', 'enable-query': 'false',
'enable-rcon': 'false', 'management-server-enabled': 'false', 'pause-when-empty-seconds': '-1',
'level-type': 'minecraft:flat', 'generate-structures': 'false', 'spawn-monsters': 'false',
'spawn-npcs': 'false', 'spawn-animals': 'false', 'max-tick-time': '-1',
}
props.update(extra or {})
(directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()))
self.port = port
self.process = subprocess.Popen(
['java', '-Xmx2G', '-jar', str(SERVER), '--nogui'], cwd=directory, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
self.lines = []
self.queue = queue.Queue()
self.counter = 0
threading.Thread(target=self._pump, daemon=True).start()
self.wait('Done (', 240)
def _pump(self):
for line in self.process.stdout:
line = line.rstrip('\n')
self.lines.append(line)
self.queue.put(line)
def wait(self, pattern, timeout=60):
end = time.time() + timeout
seen = []
while time.time() < end:
try:
line = self.queue.get(timeout=1)
except queue.Empty:
if self.process.poll() is not None:
break
continue
seen.append(line)
if pattern in line:
return seen
raise TimeoutError(f'vanilla: no "{pattern}" in {timeout}s; last lines: {seen[-5:]}')
def run(self, command, timeout=60):
"""Run a console command; return the log lines it produced."""
self.counter += 1
marker = f'@@{self.counter}@@'
self.process.stdin.write(command + '\n' + 'say ' + marker + '\n')
self.process.stdin.flush()
out = self.wait(marker, timeout)
return [re.sub(r'^\[[0-9:]+\] \[[^\]]*\]: (System chat: )?', '', l) for l in out[:-1]]
def stop(self):
try:
self.process.stdin.write('stop\n')
self.process.stdin.flush()
self.process.wait(90)
except Exception:
self.process.kill()
def problems(self):
return [l for l in self.lines if SUSPICIOUS.search(l) and not BENIGN.search(l)]
def command_failed(lines):
return any(re.search(r'(Unknown|Expected|Incorrect|Invalid|Could not|Unable|Failed|That block|error)', l, re.I)
for l in lines)
UUID_BASE = 0x7000
def entity_uuid(i):
return f'[I;{UUID_BASE},0,0,{i}]'
def entity_command(i, kind, extra):
x = 3 + 3 * (i % 10)
z = 36 + 3 * (i // 10)
nbt = (f'UUID:{entity_uuid(i)},NoAI:1b,Silent:1b,NoGravity:1b,Invulnerable:1b,Tags:["rt"],'
f'CustomName:{{text:"E{i}"}}' + (',' + extra if extra else ''))
if kind in ('item_frame', 'glow_item_frame', 'painting'):
nbt += f',block_pos:[I;{x},-60,{z}],Pos:[{x}.5d,-60.0d,{z}.5d]'
return f'summon minecraft:{kind} {x} -60 {z} {{{nbt}}}'
def block_position(i):
return 2 + 3 * (i % 10), -60, 2 + 3 * (i // 10)
def build_world(directory):
"""Fill a fresh vanilla world; returns the failed scene commands."""
server = Vanilla(directory)
failed = []
# A bot joins first so the player file exists and the chunks around spawn are loaded.
server.run('forceload add 0 0 63 63')
for rule in ('spawn_mobs', 'spawn_monsters', 'spawn_wandering_traders', 'spawn_patrols', 'spawn_phantoms',
'spawn_wardens', 'raids'):
server.run(f'gamerule {rule} false')
server.run('gamerule random_tick_speed 0')
time.sleep(3)
server.run('fill 0 -61 0 47 -61 47 minecraft:stone')
for i, (block, nbt) in enumerate(scene.BLOCK_ENTITIES):
x, y, z = block_position(i)
command = f'setblock {x} {y} {z} minecraft:{block}{nbt}'
out = server.run(command)
if command_failed(out):
failed.append((command, out))
for i, (kind, extra) in enumerate(scene.ENTITIES):
command = entity_command(i, kind, extra)
out = server.run(command)
if command_failed(out):
failed.append((command, out))
server.run('time set 6000')
server.run('gamerule advance_time false')
server.run('gamerule advance_weather false')
sys.path.insert(0, str(Path(__file__).resolve().parent))
import vanilla_login
threading.Thread(target=lambda: vanilla_login.join('127.0.0.1', server.port, 'RoundTrip', 25), daemon=True).start()
time.sleep(6)
server.run('item replace entity RoundTrip container.0 with minecraft:iron_sword[damage=3]')
server.run('give RoundTrip minecraft:apple 7')
server.run('xp set RoundTrip 5 levels')
time.sleep(20)
server.run('save-all flush')
time.sleep(2)
server.stop()
return failed, server.problems()
def view_of_world(directory):
"""Run vanilla on a world; return ({label: data text}, problem log lines)."""
server = Vanilla(directory)
views = {}
try:
server.run('forceload add 0 0 63 63')
time.sleep(3)
for i, (block, _) in enumerate(scene.BLOCK_ENTITIES):
x, y, z = block_position(i)
out = server.run(f'data get block {x} {y} {z}')
views[f'block {i} {block}'] = ' '.join(out)
for i, (kind, _) in enumerate(scene.ENTITIES):
out = server.run(f'data get entity {entity_uuid_text(i)}')
views[f'entity {i} {kind}'] = ' '.join(out)
finally:
server.stop()
return views, server.problems()
def entity_uuid_text(i):
def u(v):
return f'{v & 0xffffffff:08x}'
return f'{u(UUID_BASE)}-{u(0)[:4]}-{u(0)[4:]}-{u(0)[:4]}-{u(0)[4:]}{u(i)}'
# ---------------------------------------------------------------- Horizon
def vscreen_env():
text = subprocess.run(['vscreen', 'env'], capture_output=True, text=True, check=True).stdout
env = dict(os.environ)
env.pop('DISPLAY', None)
for match in re.finditer(r'(\w+)=(\S+)', text.split('unset')[0]):
env[match.group(1)] = match.group(2)
return env
def horizon_resave(source, destination, bin_dir):
shutil.rmtree(destination, ignore_errors=True)
saves = destination / 'saves'
saves.mkdir(parents=True)
shutil.copytree(source, saves / 'world')
alsa = destination / 'null-asound.conf'
alsa.write_text('pcm.!default { type null }\nctl.!default { type null }\n')
env = vscreen_env()
env['ALSA_CONFIG_PATH'] = str(alsa)
socket = Path(tempfile.mkdtemp(prefix='hzrt')) / 'control.sock' # sockets need short paths
ctl = [str(bin_dir / 'horizon-ctl'), '--socket', str(socket)]
subprocess.run(['vscreen', 'up'], check=False, capture_output=True)
launch = subprocess.run(
ctl + ['launch', '--resources', str(RESOURCES), '--world', 'world', '--render-distance', '6'],
cwd=destination, env=env, capture_output=True, text=True)
print(launch.stdout.strip())
if launch.returncode:
sys.exit('horizon failed to launch: ' + launch.stdout + launch.stderr)
steps = [['wait-ready', '240'], ['save-all'], ['quit']]
for step in steps:
result = subprocess.run(ctl + step, cwd=destination, env=env, capture_output=True, text=True)
print(' '.join(step), '->', result.stdout.strip() or result.stderr.strip())
if step[0] != 'quit' and result.returncode:
sys.exit('horizon-ctl failed: ' + result.stdout)
time.sleep(3)
return saves / 'world'
# ---------------------------------------------------------------- NBT comparison
def unwrap(v):
"""26.3 mixed-list wrappers ({"": value}) and plain python values."""
if isinstance(v, dict):
return {k: unwrap(x) for k, x in v.items()}
if isinstance(v, list):
return [unwrap(x[''] if isinstance(x, dict) and list(x) == [''] else x) for x in v]
return v
def short(v):
s = json.dumps(v, default=str)
return s if len(s) < 160 else s[:157] + '...'
def diff(a, b, path, out):
if type(a) is not type(b):
out.append((path, a, b))
elif isinstance(a, dict):
for k in sorted(set(a) | set(b)):
if k not in a:
out.append((f'{path}.{k}', None, b[k]))
elif k not in b:
out.append((f'{path}.{k}', a[k], None))
else:
diff(a[k], b[k], f'{path}.{k}', out)
elif isinstance(a, list):
if len(a) != len(b):
out.append((f'{path}[len]', len(a), len(b)))
if all(not isinstance(x, (dict, list)) for x in a + b):
out.append((path, a, b))
return
for i, (x, y) in enumerate(zip(a, b)):
diff(x, y, f'{path}[{i}]', out)
elif a != b:
out.append((path, a, b))
def pattern_of(path):
return re.sub(r'\[\d+\]', '[]', path)
def ignored(path):
for pattern, why in IGNORED.items():
if re.search(pattern, pattern_of(path.split(' @')[0])):
return why
return None
def state_text(entry):
if isinstance(entry, str):
return entry
props = entry.get('properties', entry.get('Properties', {}))
return entry.get('id', entry.get('Name')) + ('[' + ','.join(f'{k}={v}' for k, v in sorted(props.items())) + ']' if props else '')
def unpack(longs, bits, count):
per = 64 // bits
out = []
for word in longs:
word &= (1 << 64) - 1
for i in range(per):
if len(out) == count:
return out
out.append((word >> (i * bits)) & ((1 << bits) - 1))
return out
def decode_container(container, count, minimum, default):
palette = [state_text(e) for e in container.get('palette', [default])] if count == 4096 else \
list(container.get('palette', [default]))
if len(palette) == 1:
return [palette[0]] * count
bits = max(minimum, (len(palette) - 1).bit_length())
return [palette[i] if i < len(palette) else None for i in unpack(container['data'][1], bits, count)]
def normalize_chunk(root):
root = unwrap(root)
sections = {}
for s in root.get('sections', []):
y = s['Y'][1] if isinstance(s['Y'], tuple) else s['Y']
blocks = decode_container(s['block_states'], 4096, 4, 'minecraft:air')
biomes = decode_container(s['biomes'], 64, 1, 'minecraft:plains') if 'biomes' in s else None
sections[y] = {'blocks': blocks, 'biomes': biomes, 'BlockLight': s.get('BlockLight'),
'SkyLight': s.get('SkyLight')}
out = {k: v for k, v in root.items() if k != 'sections'}
out['block_entities'] = {(e['x'], e['y'], e['z']): e for e in root.get('block_entities', [])}
for key in ('block_ticks', 'fluid_ticks'):
out[key] = sorted(root.get(key, []), key=lambda t: json.dumps(t, sort_keys=True, default=str))
return out, sections
def compare_chunks(vanilla, horizon, report):
for key in sorted(set(vanilla) | set(horizon)):
if key not in horizon:
report.append((f'chunk {key}', 'present', 'missing from Horizon'))
continue
if key not in vanilla:
report.append((f'chunk {key}', 'missing from vanilla', 'present'))
continue
va, vs = normalize_chunk(vanilla[key])
ha, hs = normalize_chunk(horizon[key])
out = []
diff(va, ha, 'chunk', out)
for y in sorted(set(vs) | set(hs)):
empty = {'blocks': ['minecraft:air'] * 4096, 'biomes': None, 'BlockLight': None, 'SkyLight': None}
a, b = vs.get(y, empty), hs.get(y, empty)
blocks = [(i, p, q) for i, (p, q) in enumerate(zip(a['blocks'], b['blocks'])) if p != q]
if blocks:
i, p, q = blocks[0]
out.append((f'chunk.sections.blocks[{y}]', f'{len(blocks)} differ, first #{i} {p}', q))
if a['biomes'] is not None and b['biomes'] is not None and a['biomes'] != b['biomes']:
out.append((f'chunk.sections.biomes[{y}]', 'differ', ''))
for light in ('BlockLight', 'SkyLight'):
if a[light] != b[light]:
out.append((f'chunk.sections.{light}[{y}]', None if a[light] is None else 'present',
None if b[light] is None else 'present'))
for path, p, q in out:
report.append((f'{path} @{key}', p, q))
def compare_entities(vanilla, horizon, report):
def collect(regions):
out = {}
for key, root in regions.items():
for e in unwrap(root).get('Entities', []):
uuid = tuple(e['UUID'][1]) if 'UUID' in e else None
out[uuid] = e
return out
a, b = collect(vanilla), collect(horizon)
# Entities Horizon adds (chunk-generation spawns in the chunks vanilla never
# generated) are not part of the scene.
extra = [u for u in b if u not in a and not (u and u[0] == UUID_BASE)]
if extra:
print(f' note: Horizon saved {len(extra)} entities that are not in the scene (generated chunks)')
for uuid in extra:
del b[uuid]
for uuid in sorted(set(a) | set(b), key=str):
if uuid not in b:
report.append((f'entity {uuid} {a[uuid].get("id")}', 'present', 'missing from Horizon'))
elif uuid not in a:
report.append((f'entity {uuid} {b[uuid].get("id")}', 'missing from vanilla', 'present'))
else:
out = []
diff(a[uuid], b[uuid], 'entity', out)
for path, p, q in out:
report.append((f'{path} @{a[uuid].get("id")}#{uuid[-1]}', p, q))
def load_regions(folder):
out = {}
if folder.is_dir():
for f in sorted(folder.glob('r.*.*.mca')):
out.update({(f.name, *k): v for k, v in anvil_dump.region_chunks(str(f)).items()})
return out
def compare_dat(name, a, b, report):
out = []
diff(unwrap(a), unwrap(b), name, out)
report.extend(out)
def dimension(world):
d = world / 'dimensions' / 'minecraft' / 'overworld'
return d if d.is_dir() else world
def compare_worlds(vanilla, horizon):
report = []
va, ha = dimension(vanilla), dimension(horizon)
compare_chunks(load_regions(va / 'region'), load_regions(ha / 'region'), report)
compare_entities(load_regions(va / 'entities'), load_regions(ha / 'entities'), report)
for rel in ['level.dat'] + sorted(
str(p.relative_to(vanilla)) for pattern in ('data/**/*.dat', 'players/**/*.dat')
for p in vanilla.glob(pattern)):
a, b = vanilla / rel, horizon / rel
if not b.exists():
report.append((rel, 'present', 'missing from Horizon'))
elif a.exists():
compare_dat(rel, anvil_dump.read_dat(str(a)), anvil_dump.read_dat(str(b)), report)
return report
def summarize(report):
groups = collections.OrderedDict()
for path, a, b in report:
why = ignored(path)
groups.setdefault((pattern_of(path.split(' @')[0]), why), []).append((path, a, b))
failures = 0
for (pattern, why), items in groups.items():
if why:
print(f' ignored {pattern} x{len(items)} ({why})')
continue
gap = next((g for p, g in KNOWN_GAPS.items() if re.search(p, pattern)), None)
if gap:
print(f' KNOWN GAP {pattern} x{len(items)} ({gap})')
continue
failures += len(items)
path, a, b = items[0]
print(f' DIFF {pattern} x{len(items)}\n e.g. {path}\n vanilla {short(a)}\n horizon {short(b)}')
return failures
# ---------------------------------------------------------------- main
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--keep', action='store_true')
parser.add_argument('--bin-dir', default=str(ROOT / 'target' / 'fast'))
parser.add_argument('--vanilla', help='an existing vanilla world folder (skips generation)')
parser.add_argument('--horizon', help='an existing Horizon-saved world folder (skips the Horizon run)')
parser.add_argument('--skip-vanilla-load', action='store_true')
parser.add_argument('--gen-only', action='store_true', help='stop after building the vanilla world')
args = parser.parse_args()
RUN.mkdir(parents=True, exist_ok=True)
failures = 0
if args.vanilla:
v0 = Path(args.vanilla)
else:
shutil.rmtree(RUN / 'v0', ignore_errors=True)
failed, problems = build_world(RUN / 'v0')
v0 = RUN / 'v0' / 'world'
for command, out in failed:
print('scene command failed:', command[:100], out[:2])
for line in problems:
print('vanilla log:', line)
if args.gen_only:
return
if args.horizon:
h = Path(args.horizon)
else:
h = horizon_resave(v0, RUN / 'h', Path(args.bin_dir))
print('comparing', v0, 'with', h)
report = compare_worlds(v0, h)
failures += summarize(report)
if not args.skip_vanilla_load:
shutil.rmtree(RUN / 'v1', ignore_errors=True)
shutil.copytree(h, RUN / 'v1' / 'world')
views1, problems1 = view_of_world(RUN / 'v1')
shutil.rmtree(RUN / 'v0view', ignore_errors=True)
shutil.copytree(v0, RUN / 'v0view' / 'world')
views0, problems0 = view_of_world(RUN / 'v0view')
for line in problems1:
if line not in problems0:
print('vanilla log (Horizon save):', line)
failures += 1
volatile = re.compile(r'(cooking_time_spent|lit_time_remaining|ticks_since_song_started|Age|BrewTime|'
r'ticks_in_hive|state_updating_resumes_at|LastExecution|last_vibration_frequency|warning_level): -?[0-9]+[a-zA-Z]?')
for label in views0:
if label.startswith('entity'):
# Entity data moves with the simulation: only require vanilla to load it.
if 'falling_block' in label:
continue # lands in Horizon (known gap above)
if 'No entity was found' in views1.get(label, '') and 'No entity was found' not in views0[label]:
print(f'VANILLA cannot find {label} in the Horizon save')
failures += 1
continue
if volatile.sub('', views0[label]) != volatile.sub('', views1.get(label, '')):
print(f'VANILLA VIEW differs: {label}\n V0 {views0[label][:300]}\n H {str(views1.get(label))[:300]}')
failures += 1
print('save round-trip parity', 'FAILED' if failures else 'ok', f'({failures} unexplained differences)')
if not args.keep and not failures:
shutil.rmtree(RUN, ignore_errors=True)
sys.exit(1 if failures else 0)
if __name__ == '__main__':
main()