Merge branch 'parity-base' into parity/old-saves

This commit is contained in:
Ludovic Marie
2026-10-13 03:27:26 +02:00
41 changed files with 7919 additions and 530 deletions
+6 -11
View File
@@ -111,7 +111,7 @@ The client starts on the title screen. Command-line options (`--world`, `--seed`
## Project status
Parity is **not** complete. The table below is the project's own audit of each subsystem. Still missing: the warden's brain and the sculk shrieker summoning it, villager breeding and gossip, spawned mob gear enchantments, the resource pack screen, a dedicated server mode, and worlds older than 1.17.
Parity is **not** complete. The table below is the project's own audit of each subsystem. Still missing: the warden's brain and the sculk shrieker summoning it, villager breeding and gossip, the resource pack screen, a dedicated server mode, and worlds older than 1.17.
### Java parity: 88%
@@ -134,7 +134,7 @@ from vanilla in places: `mob_ai` (71 of 72 scenarios; a tempted ghastling) and
| Lighting | 1 | None: saved and relit light matches vanilla, slabs and stairs included |
| World generation | 1 | None: 2,352 whole chunks over 225 structure sites, in all three dimensions, identical to vanilla |
| Region files and saves | 0.75 | Saves round-trip with vanilla, and worlds from 1.17 to 26.2 upgrade as vanilla's DataFixers do; worlds older than 1.17 are not upgraded |
| Entities and physics | 0.75 | Attributes, dimensions, death loot, spawn rules, natural spawning (15,500 cases), raids and patrols (1,900 cases) and mob AI (71 of 72 scenarios, villager brains included) match; the warden's brain, villager breeding and gossip, and spawned mob gear are missing |
| Entities and physics | 0.75 | Attributes, dimensions, death loot, spawn rules, natural spawning (15,500 cases), raids and patrols (1,900 cases), spawned mobs' gear, enchantments and state (`finalizeSpawn`, 24,000 cases) and mob AI (71 of 72 scenarios, villager brains included) match; the warden's brain and villager breeding and gossip are missing |
| Interaction and inventory | 1 | None: menu clicks match over 8,000 click sequences, the loom and the crafter included; recipe book placement (6,000 cases), its buttons (1,200), the saved book (1,500) and the loom and crafter screens (1,600) match vanilla |
| Menus, HUD and chat | 0.75 | Every command runs as vanilla (758 commands over 39,685 parsed inputs), scoreboards and teams match (81,000 operations), and the player list matches over 844,758 draw calls; the focused chat is not compared and player list heads use default skins |
| Audio | 1 | None: the sound engine, sound events, music, situational music, ambience and subtitles match vanilla |
@@ -151,17 +151,12 @@ from vanilla in places: `mob_ai` (71 of 72 scenarios; a tempted ghastling) and
- **Worlds from 1.17 onwards** open and are upgraded as vanilla does; server.properties, eula.txt and the server user lists are read and written as vanilla does.
- **Builds for Linux, macOS (Apple Silicon) and Windows.**
### Known issues
- **Render distance 2 never finishes loading:** a world opened with the render distance at 2 chunks stays on "Loading terrain…". Use a render distance of 3 or more (in Options > Video, or `--render-distance 12` on the command line).
### Roadmap
1. Fix loading at render distance 2; finish the warden's brain and the sculk shrieker summoning it, and the tempted ghastling.
2. Villager breeding and gossip, and spawned mob gear enchantments (both started on their branches).
3. A dedicated server mode, and LAN hosting tested with a vanilla client.
4. Save upgrades from before 1.17, and the resource pack screen.
5. Platform-independent float math, so every harness also gives vanilla's results on macOS.
1. Finish the warden's brain and the sculk shrieker summoning it, and the tempted ghastling.
2. A dedicated server mode, and LAN hosting tested with a vanilla client.
3. Save upgrades from before 1.17, and the resource pack screen.
4. Platform-independent float math, so every harness also gives vanilla's results on macOS.
The rewrite is complete when it reaches one-to-one parity and packaged native builds pass the launch checks in [Rust rewrite status](docs/rust-parity.md#completion-criteria-and-playable-builds).
@@ -0,0 +1,531 @@
//! `Mob.finalizeSpawn` for differential tests against vanilla
//! (tools/test_finalize_spawn_parity.py): reads the cases of
//! `VanillaFinalizeSpawnOracle`, runs `mobs::finalize` with the same level
//! random and entity randoms, and prints every entity of the case in the
//! oracle's format.
//!
//! usage: finalize_spawn_fixture RESOURCES INPUT OUTPUT HALLOWEEN
use horizon_client::{
assets::Assets,
blocks::BlockFacts,
enchant::Enchantments,
items::Items,
mobs::{
Mob, MobTypes, Species,
data::MobData,
finalize::{self, Attr, Ctx, FinalizeLevel, Reason, SpawnData, SpawnRegistries},
gear,
render::{DYE_NAMES, PROFESSIONS, VILLAGER_TYPES},
spawning::LocalDifficulty,
},
};
use horizon_core::{
geometry::{Aabb, Vec3},
random::{LegacyRandom, RandomSource},
};
use std::{collections::HashMap, fmt::Write as _, fs, path::Path, sync::Arc};
struct Level<'a> {
types: &'a MobTypes,
data: &'a MobData,
biome: String,
structure: Option<(String, [i32; 6])>,
phase: usize,
monsters: bool,
peaceful: bool,
time: i64,
halloween: bool,
roof: Option<i32>,
eseed: i64,
/// Every entity of the case in creation order (case chickens first).
created: usize,
/// The level's entities that can carry a zombie: (id, bounds, ridden).
chickens: Vec<(u32, Aabb, bool)>,
rides: Vec<(u32, u32)>,
}
impl FinalizeLevel for Level<'_> {
fn biome(&self, _pos: [i32; 3]) -> String {
self.biome.clone()
}
fn biome_tag(&self, tag: &str, _pos: [i32; 3]) -> bool {
self.data.biome_has(tag, &self.biome)
}
fn structures_with_piece_at(&self, pos: [i32; 3]) -> Vec<String> {
match &self.structure {
Some((id, b))
if pos[0] >= b[0]
&& pos[0] <= b[3]
&& pos[1] >= b[1]
&& pos[1] <= b[4]
&& pos[2] >= b[2]
&& pos[2] <= b[5] =>
{
vec![id.clone()]
}
_ => Vec::new(),
}
}
fn moon_phase(&self, _pos: [i32; 3]) -> usize {
self.phase
}
fn spawning_monsters(&self) -> bool {
self.monsters
}
fn no_collision(&self, bounds: Aabb) -> bool {
// A floor under the spawn point and an optional roof layer.
self.roof.is_none_or(|y| {
let (lo, hi) = (
bounds.min(horizon_core::geometry::Axis::Y),
bounds.max(horizon_core::geometry::Axis::Y),
);
!(lo < f64::from(y) + 1.0 && hi > f64::from(y))
})
}
fn free_chicken(&self, bounds: Aabb) -> Option<u32> {
self.chickens
.iter()
.find(|(_, b, ridden)| !ridden && b.intersects(bounds))
.map(|c| c.0)
}
fn ride_chicken(&mut self, chicken: u32, rider: u32) {
if let Some(c) = self.chickens.iter_mut().find(|c| c.0 == chicken) {
c.2 = true;
}
self.rides.push((chicken, rider));
}
fn game_time(&self) -> i64 {
self.time
}
fn halloween(&self) -> bool {
self.halloween
}
fn create(&mut self, kind: &str, _reason: Reason) -> Option<Mob> {
if self.peaceful && !finalize::allowed_in_peaceful(kind) {
return None;
}
let t = Arc::new(self.types.types.get(kind)?.clone());
let index = self.created;
self.created += 1;
let mut m = Mob::new(index as u32 + 1, t, Vec3::ZERO, 0.0);
m.random = LegacyRandom::new(self.eseed.wrapping_add(index as i64));
Some(m)
}
}
fn hex64(v: f64) -> String {
format!("{:x}", v.to_bits())
}
fn hex32(v: f32) -> String {
format!("{:x}", v.to_bits())
}
const HORSE: [&str; 7] = [
"white",
"creamy",
"chestnut",
"brown",
"black",
"gray",
"dark_brown",
];
const MARKINGS: [&str; 5] = ["none", "white", "white_field", "white_dots", "black_dots"];
const RABBITS: [&str; 6] = ["brown", "white", "black", "white_splotched", "gold", "salt"];
const PARROTS: [&str; 5] = ["red_blue", "blue", "green", "yellow_blue", "gray"];
const AXOLOTLS: [&str; 5] = ["lucy", "wild", "gold", "cyan", "blue"];
const SALMON: [&str; 3] = ["small", "medium", "large"];
const GENES: [&str; 7] = [
"normal",
"lazy",
"worried",
"playful",
"brown",
"weak",
"aggressive",
];
const MEMORIES: [&str; 7] = [
"long_jump_cooldown",
"ram_cooldown",
"attack_target_cooldown",
"hunted_recently",
"dig_cooldown",
"is_emerging",
"home",
];
fn variant(m: &Mob, regs: &SpawnRegistries, v: &mut Vec<String>) {
use Species as S;
let s = m.species();
let named = |reg: &finalize::VariantRegistry, i: u8| {
format!(
"minecraft:{}",
reg.names.get(i as usize).map_or("?", |n| n.as_str())
)
};
let var = format!("minecraft:{}", finalize::variant_name(s, m.extra.variant));
match s {
S::Pig => {
v.push(var);
v.push(named(&regs.pig_sound, m.extra.sound_variant));
}
S::Cow => {
v.push(var);
v.push(named(&regs.cow_sound, m.extra.sound_variant));
}
S::Mooshroom => v.push(if m.extra.variant == 0 { "red" } else { "brown" }.into()),
S::Chicken => {
v.push(var);
v.push(named(&regs.chicken_sound, m.extra.sound_variant));
v.push(format!("jockey={}", m.extra.jockey));
}
S::Cat => {
v.push(var);
v.push(named(&regs.cat_sound, m.extra.sound_variant));
}
S::Wolf => {
v.push(var);
v.push(named(&regs.wolf_sound, m.extra.sound_variant));
}
S::Frog | S::ZombieNautilus => v.push(var),
S::Sheep => v.push(DYE_NAMES[m.extra.color as usize & 15].into()),
S::Horse => v.push(format!(
"{}/{}",
HORSE[m.extra.variant as usize % 7],
MARKINGS[m.extra.variant2 as usize % 5]
)),
S::Llama | S::TraderLlama => v.push(format!(
"{}/{}",
horizon_client::mobs::llama::VARIANTS[m.extra.variant as usize % 4],
m.extra.variant2
)),
S::SkeletonHorse => v.push(format!("trap={}", m.extra.trap)),
S::Fox => v.push(if m.extra.variant == 1 { "snow" } else { "red" }.into()),
S::Rabbit => v.push(RABBITS[m.extra.variant as usize % 6].into()),
S::Parrot => v.push(PARROTS[m.extra.variant as usize % 5].into()),
S::Axolotl => v.push(AXOLOTLS[m.extra.variant as usize % 5].into()),
S::TropicalFish => {
let p = u32::from(m.extra.variant);
let pattern = if p < 6 { p << 8 } else { 1 | (p - 6) << 8 };
let packed = (pattern & 0xFFFF)
| (u32::from(m.extra.variant2) & 0xFF) << 16
| (u32::from(m.extra.variant3) & 0xFF) << 24;
v.push((packed as i32).to_string());
}
S::Salmon => v.push(SALMON[m.extra.variant as usize % 3].into()),
S::Panda => v.push(format!(
"{}/{}",
GENES[m.extra.variant as usize % 7],
GENES[m.extra.variant2 as usize % 7]
)),
S::Goat => v.push(format!(
"scream={} horns={},{}",
m.extra.screaming, !m.extra.lost_horns[0], !m.extra.lost_horns[1]
)),
S::Slime | S::MagmaCube | S::SulfurCube => v.push(format!("size={}", m.extra.size.max(1))),
S::Villager => v.push(format!(
"minecraft:{}/minecraft:{}/{}",
VILLAGER_TYPES[m.extra.variant as usize % 7],
PROFESSIONS[m.extra.variant2 as usize % PROFESSIONS.len()],
m.extra.variant3.max(1)
)),
S::ZombieVillager => v.push(format!(
"minecraft:{}/{}",
VILLAGER_TYPES[m.extra.variant as usize % 7],
m.extra.variant3.max(1)
)),
S::Phantom => v.push(format!("size={}", m.extra.size)),
S::Turtle => v.push(format!(
"home={}",
m.extra
.home
.map_or("-".into(), |h| format!("{},{},{}", h[0], h[1], h[2]))
)),
S::Dolphin => v.push(format!("air={}", m.air)),
_ => {}
}
if matches!(
s,
S::Zombie | S::Husk | S::Drowned | S::ZombieVillager | S::ZombifiedPiglin
) {
v.push(format!("doors={}", m.extra.can_break_doors));
}
if horizon_client::mobs::raider::is_raider(s) {
let st = horizon_client::mobs::raider::state(m);
v.push(format!(
"leader={} patrolling={}",
st.is_some_and(|s| s.patrol_leader),
st.is_some_and(|s| s.patrolling)
));
v.push(format!("raid={}", st.is_some_and(|s| s.can_join_raid)));
}
if s == S::Strider {
v.push(format!("saddled={}", m.extra.saddled));
}
}
fn describe(m: &Mob, all: &[Mob], regs: &SpawnRegistries) -> String {
let mut t = vec![m.kind.id.clone()];
let vehicle = m
.extra
.mount
.and_then(|v| all.iter().position(|o| o.id == v))
.map_or("-".to_owned(), |i| i.to_string());
t.push(format!("veh={vehicle}"));
if finalize::ageable(m.species()) {
t.push(format!("age={}", m.extra.age));
} else {
t.push(format!("baby={}", m.is_baby()));
}
t.push(format!("hp={}", hex32(m.health)));
t.push(format!("lh={}", m.extra.left_handed));
t.push(format!("loot={}", m.can_pick_up_loot()));
t.push(format!("persist={}", m.persistent));
let mut eq = Vec::new();
for (slot, name) in finalize::SLOT_NAMES.iter().enumerate() {
let Some(id) = finalize::item(m, slot) else {
continue;
};
let mut text = id.to_string();
let g = match slot {
0 => Some(gear::MAIN),
1 => Some(gear::OFF),
2 => Some(gear::FEET),
3 => Some(gear::LEGS),
4 => Some(gear::CHEST),
5 => Some(gear::HEAD),
_ => None,
};
if let (Some(g), Some(levels)) = (g, gear::gear(m)) {
let mut list: Vec<String> = levels.slots[g]
.iter()
.map(|(e, l)| format!("{e}={l}"))
.collect();
list.sort();
if !list.is_empty() {
let _ = write!(text, "[{}]", list.join(","));
}
}
if slot == 5 && horizon_client::mobs::raider::is_captain(m) {
text.push_str("*4");
}
eq.push(format!("{name}:{text}"));
}
t.push(format!(
"eq={}",
if eq.is_empty() {
"-".into()
} else {
eq.join(";")
}
));
let drops: Vec<String> = finalize::SLOT_NAMES
.iter()
.enumerate()
.filter_map(|(i, name)| {
let d = finalize::stored_drop_chance(m, i);
(d != 0.085).then(|| format!("{name}:{}", hex32(d)))
})
.collect();
t.push(format!(
"drop={}",
if drops.is_empty() {
"-".into()
} else {
drops.join(";")
}
));
let attrs: Vec<String> = [
Attr::MaxHealth,
Attr::MovementSpeed,
Attr::FollowRange,
Attr::AttackDamage,
Attr::KnockbackResistance,
Attr::SpawnReinforcements,
Attr::JumpStrength,
]
.into_iter()
.filter(|a| finalize::default_value(m, *a).is_some())
.map(|a| format!("{}:{}", a.name(), hex64(finalize::value(m, a))))
.collect();
t.push(format!("a={}", attrs.join(",")));
let mut fx: Vec<String> = m
.extra
.effects
.iter()
.map(|(e, d, a)| format!("{e}:{a}:{d}"))
.collect();
fx.sort();
t.push(format!(
"fx={}",
if fx.is_empty() {
"-".into()
} else {
fx.join(",")
}
));
let mem: Vec<String> = MEMORIES
.iter()
.filter_map(|name| {
let (_, value, ttl) = m.extra.memories.iter().find(|x| x.0 == *name)?;
let text = match *name {
"hunted_recently" => "true".to_owned(),
"dig_cooldown" | "is_emerging" => "INSTANCE".to_owned(),
"home" => m
.extra
.home
.map_or("-".into(), |h| format!("{},{},{}", h[0], h[1], h[2])),
_ => value.to_string(),
};
Some(format!("{name}:{text}:{ttl}"))
})
.collect();
if !mem.is_empty() {
t.push(format!("mem={}", mem.join(",")));
}
let mut v = Vec::new();
variant(m, regs, &mut v);
if !v.is_empty() {
t.push(format!("v={}", v.join(" ").replace(' ', "_")));
}
t.join(" ")
}
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().collect();
let root = Path::new(
args.get(1)
.ok_or("usage: finalize_spawn_fixture RESOURCES INPUT OUTPUT HALLOWEEN")?,
);
let input = fs::read_to_string(args.get(2).ok_or("missing INPUT")?)?;
let halloween = args.get(4).is_some_and(|h| h == "true");
let assets = Assets::load(root)?;
let facts = BlockFacts::load(root, assets.registry)?;
let mob_data = MobData::load(root, &facts);
let items = Items::tags_only(root)?;
let enchantments = Enchantments::load(root);
let types = MobTypes::load(root)?;
let registries = SpawnRegistries::load(root);
let camel = &types.types["minecraft:camel_husk"];
let data = SpawnData {
registries: &registries,
enchantments: &enchantments,
items: &items,
camel_husk_size: (camel.width as f32, camel.height as f32),
};
let mut out = format!("halloween {halloween}\n");
for line in input.lines().filter(|l| !l.trim().is_empty()) {
let mut c: HashMap<&str, &str> = HashMap::new();
let mut name = "";
for token in line.split_whitespace() {
match token.split_once('=') {
Some((k, v)) => {
c.insert(k, v);
}
None => name = token,
}
}
let get =
|k: &str, d: &'static str| -> String { c.get(k).copied().unwrap_or(d).to_owned() };
let p: Vec<f64> = get("pos", "0,0,0")
.split(',')
.map(|x| x.parse().unwrap_or(0.0))
.collect();
let pos = Vec3::new(p[0], p[1], p[2]);
let block = [
p[0].floor() as i32,
p[1].floor() as i32,
p[2].floor() as i32,
];
let base = match get("difficulty", "normal").as_str() {
"peaceful" => 0,
"easy" => 1,
"hard" => 3,
_ => 2,
};
let phase: usize = get("phase", "0").parse().unwrap_or(0);
let time: i64 = get("time", "0").parse().unwrap_or(0);
let inhabited: i64 = get("inhabited", "0").parse().unwrap_or(0);
let difficulty = LocalDifficulty::new(
base,
time,
inhabited,
horizon_client::mobs::spawning::MOON_BRIGHTNESS[phase & 7],
);
let mut level = Level {
types: &types,
data: &mob_data,
biome: get("biome", "minecraft:plains"),
structure: c.get("structure").map(|s| {
(
(*s).to_owned(),
[
block[0] - 8,
block[1] - 8,
block[2] - 8,
block[0] + 8,
block[1] + 8,
block[2] + 8,
],
)
}),
phase,
monsters: get("monsters", "1") != "0",
peaceful: base == 0,
time,
halloween,
roof: c
.get("roof")
.and_then(|r| r.parse::<i32>().ok())
.map(|r| block[1] + r),
eseed: get("eseed", "0").parse().unwrap_or(0),
created: 0,
chickens: Vec::new(),
rides: Vec::new(),
};
let mut all: Vec<Mob> = Vec::new();
let chickens: usize = get("chickens", "0").parse().unwrap_or(0);
for i in 0..chickens {
if let Some(mut chicken) = level.create("minecraft:chicken", Reason::Load) {
chicken.position = Vec3::new(pos.x + i as f64, pos.y, pos.z);
level.chickens.push((chicken.id, chicken.bounds(), false));
all.push(chicken);
}
}
let kind = get("type", "minecraft:pig");
let reason = Reason::parse(&get("reason", "NATURAL")).unwrap_or(Reason::Natural);
let pack: usize = get("pack", "1").parse().unwrap_or(1);
let mut random = LegacyRandom::new(get("seed", "0").parse().unwrap_or(0));
let mut group = None;
for _ in 0..pack {
let Some(mut mob) = level.create(&kind, reason) else {
break;
};
mob.position = pos;
mob.previous = pos;
let mut cx = Ctx {
level: &mut level,
random: &mut random,
difficulty,
data: &data,
created: Vec::new(),
};
group = finalize::finalize(&mut cx, &mut mob, reason, group);
let created = std::mem::take(&mut cx.created);
all.push(mob);
all.extend(created);
}
for (chicken, rider) in std::mem::take(&mut level.rides) {
if let Some(c) = all.iter_mut().find(|m| m.id == chicken) {
c.extra.jockey = true;
c.extra.rider = Some(rider);
}
}
all.sort_by_key(|m| m.id);
let mut parts: Vec<String> = all.iter().map(|m| describe(m, &all, &registries)).collect();
for m in &mut all {
parts.push(format!("rng {}", m.random.next_long()));
}
parts.push(format!("next {}", random.next_long()));
let _ = writeln!(out, "{name} {}", parts.join(" | "));
}
fs::write(args.get(3).ok_or("missing OUTPUT")?, out)?;
Ok(())
}
@@ -0,0 +1,46 @@
//! Horizon's LAN world discovery for tools/test_lan_parity.py: the cases of
//! VanillaLanOracle (announcements sent, datagrams heard, list resets) run
//! through `lan::discovery`, printing the same lines.
use horizon_client::lan::discovery::{
LanGame, add_server, parse_address, parse_motd, ping_string_text,
};
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
fn unhex(s: &str) -> Vec<u8> {
(0..s.len() / 2)
.map(|i| u8::from_str_radix(&s[2 * i..2 * i + 2], 16).unwrap())
.collect()
}
fn main() {
let args: Vec<String> = std::env::args().collect();
let cases = std::fs::read_to_string(&args[1]).unwrap();
let mut out = String::new();
let mut games: Vec<LanGame> = Vec::new();
for line in cases.lines() {
let f: Vec<&str> = line.split('\t').collect();
match f[0] {
"ping" => out += &format!("ping {}\n", hex(ping_string_text(f[1], f[2]).as_bytes())),
"heard" => {
let received = String::from_utf8_lossy(&unhex(f[2])).into_owned();
out += &format!(
"heard motd={} address={}\n",
parse_motd(&received),
parse_address(&received).unwrap_or_else(|| "null".into())
);
if add_server(&mut games, &received, f[1]) {
out += "list";
for g in &games {
out += &format!(" [{} @ {}]", g.motd, g.address);
}
out += "\n";
}
}
"reset" => games.clear(),
other => panic!("{other}"),
}
}
std::fs::write(&args[2], out).unwrap();
}
+224 -49
View File
@@ -223,56 +223,133 @@ fn goals(m: &Mob, names: Vec<&'static str>) -> String {
.join("|")
}
fn seen(m: &Mob) -> Seen {
Seen {
id: m.id,
species: m.species(),
position: m.position,
bounds: m.bounds(),
eye_y: m.eye_y(),
alive: m.alive(),
baby: m.is_baby(),
in_love: if m.species() == Species::Villager {
horizon_client::mobs::villager::can_breed(m)
} else {
m.extra.in_love > 0
},
tame: m.extra.tame,
hostile: m.hostile(),
target: m.ai.target,
health: m.health,
variant: m.extra.variant,
color: m.extra.color,
job: (m.species() == Species::Villager)
.then_some(m.extra.home)
.flatten(),
bed: (m.species() == Species::Villager)
.then_some(m.extra.bed)
.flatten(),
yaw: m.yaw,
velocity: m.velocity,
leash: m.extra.leash,
caravan: horizon_client::mobs::caravan::head_of(m),
delay: m.extra.ints[5],
hurt_by: m.ai.last_hurt_by.map(|w| (w, m.ai.last_hurt_by_time)),
active_raid: horizon_client::mobs::raider::has_active_raid(m),
player_rep: 0,
pushable: m.pushable(),
category: m.category(),
potential_job: horizon_client::mobs::villager_brain::potential_job_site(m),
meeting: (m.species() == Species::Villager)
.then_some(m.extra.meeting)
.flatten(),
profession: m.extra.variant2,
xp: horizon_client::mobs::villager::xp(m),
stats: [
f64::from(m.attrs.max_health),
m.extra.vector[0],
m.attrs.speed,
],
/// The oracle's villager flags: profession, level, xp, food, inventory,
/// gossip about the player and the last sleep.
fn villager_flag(m: &mut Mob, flag: &str) {
use horizon_client::mobs::villager;
let (k, v) = flag
.split_once('=')
.unwrap_or_else(|| panic!("unknown mob flag {flag}"));
match k {
"profession" => {
let p = horizon_client::mobs::render::PROFESSIONS
.iter()
.position(|p| *p == v)
.expect("profession");
villager::set_profession(m, p as u8);
}
"level" => m.extra.variant3 = v.parse().unwrap(),
"xp" => {
m.extra.trade.get_or_insert_with(Default::default).xp = v.parse().unwrap();
}
"food" => villager::ext_mut(m).food_level = v.parse().unwrap(),
"inv" => {
for item in v.split(',') {
let (name, count) = item.split_once('*').unwrap_or((item, "1"));
villager::ext_mut(m)
.inventory
.push(horizon_client::items::ItemStack::new(
&if name.contains(':') {
name.to_owned()
} else {
format!("minecraft:{name}")
},
count.parse().unwrap(),
));
}
}
"gossip" => {
let g: Vec<&str> = v.split(':').collect();
assert_eq!(g[0], "player", "gossip about the player only");
let kind = horizon_client::gossip::GossipType::from_id(g[1]).expect("gossip type");
villager::ext_mut(m)
.gossips
.add(PLAYER_UUID, kind, g[2].parse().unwrap());
}
"slept" => villager::ext_mut(m).last_slept = Some(v.parse().unwrap()),
_ => panic!("unknown mob flag {flag}"),
}
}
/// The random seed of the entity a scenario spawns at this index (the
/// oracle's `spawnSeed`).
fn spawn_seed(index: usize) -> i64 {
1000 + 7919 * index as i64
}
/// Villager events that act at once in vanilla (`TradeWithVillager` and
/// `VillagerMakeLove` write the other villager directly).
fn villager_events(
mobs: &mut [Mob],
events: &mut Vec<MobEvent>,
from: usize,
w: &MobWorld,
types: &MobTypes,
items: &Items,
born: &mut Vec<Mob>,
day_time: i64,
) {
use horizon_client::mobs::villager;
let index = |mobs: &[Mob], id: u32| {
mobs.iter()
.position(|m| m.id == id && m.species() == Species::Villager)
};
let mut i = from;
while i < events.len() {
match events[i] {
MobEvent::VillagerMeet { mob, other } => {
if let (Some(a), Some(b)) = (index(mobs, mob), index(mobs, other)) {
let meeting = villager::meet(mobs, a, b, w.game_time, |item| {
items.get(item).map_or(64, |i| i.max_stack)
});
assert!(
meeting.thrown.is_empty(),
"villagers toss items: not modelled here"
);
}
events.remove(i);
}
MobEvent::VillagerBirth {
parent,
partner,
child,
} => {
events.remove(i);
let (Some(a), Some(b)) = (index(mobs, parent), index(mobs, partner)) else {
continue;
};
villager::ext_mut(&mut mobs[b]).eat_and_digest();
let Some((bed, variant)) = child else {
continue;
};
mobs[b].extra.age = 6000;
let index = mobs.len() + born.len();
let kind = types.types.get("minecraft:villager").expect("villager");
let p = mobs[a].position;
let mut child = Mob::new(100_000 + index as u32, Arc::new(kind.clone()), p, 0.0);
child.persistent = true;
// The flat world is all plains (type 0).
child.extra.variant = variant.unwrap_or(0);
child.extra.variant2 = villager::NONE;
child.extra.age = -24000;
child.extra.bed = Some(bed);
let seed = spawn_seed(index);
child.random = LegacyRandom::new(seed);
horizon_client::mobs::villager_brain::init(&mut child, w.game_time, day_time, seed);
born.push(child);
}
_ => i += 1,
}
}
}
/// The player's UUID (the oracle's `PLAYER_UUID`).
const PLAYER_UUID: [i32; 4] = [0, 0x1234, 0, 0x5678];
fn seen(m: &Mob) -> Seen {
m.seen(Some(PLAYER_UUID))
}
/// The probe's mobs as a creaking heart sees them: creakings it creates take
/// the n-th seed from 1000, as the oracle's do.
struct Host<'a> {
@@ -479,9 +556,95 @@ fn print(out: &mut String, t: i32, i: usize, m: &Mob) {
if let Some((acts, mem)) = brain {
let _ = write!(out, "\tact {acts}\tmem {mem}");
}
if m.species() == Species::Villager {
let _ = write!(out, "\tvx {}", villager(m));
}
out.push('\n');
}
fn stack(s: &horizon_client::items::ItemStack) -> String {
if s.count == 0 {
return "-".into();
}
format!("{}*{}", s.item.trim_start_matches("minecraft:"), s.count)
}
/// The oracle's `villager`: data, food, inventory, gossip, sleep and offers.
fn villager(m: &Mob) -> String {
use horizon_client::mobs::villager;
let e = villager::ext(m);
let mut slots: Vec<String> = (0..8)
.map(|k| {
e.and_then(|e| e.inventory.get(k))
.map_or_else(|| "-".to_owned(), stack)
})
.collect();
while slots.last().is_some_and(|s| s == "-") {
slots.pop();
}
// Villagers gossip about players only.
let label = |t: [i32; 4]| {
if t == PLAYER_UUID {
"player".to_owned()
} else {
format!("{t:?}")
}
};
let mut gossips: Vec<String> = e
.map(|e| {
e.gossips
.entries()
.map(|(t, k, v)| format!("{}:{}={v}", label(t), k.id()))
.collect()
})
.unwrap_or_default();
gossips.sort();
let join = |v: &[String]| {
if v.is_empty() {
"-".to_owned()
} else {
v.join(",")
}
};
let mut s = format!(
"prof {} lvl {} xp {} food {} age {} inv {} gossip {} rep {} sleep {}",
horizon_client::mobs::render::PROFESSIONS[m.extra.variant2 as usize % 15],
m.extra.variant3.max(1),
villager::xp(m),
e.map_or(0, |e| e.food_level),
m.extra.age,
join(&slots),
join(&gossips),
e.map_or(0, |e| e.gossips.reputation(PLAYER_UUID)),
match (villager::sleeping(m), m.extra.bed) {
(true, Some(b)) => format!("{},{},{}", b[0], b[1], b[2]),
_ => "-".into(),
}
);
if let Some(t) = m.extra.trade.as_ref().filter(|t| !t.offers.is_empty()) {
let offers: Vec<String> = t
.offers
.iter()
.map(|o| {
format!(
"{}+{}>{}/{}/{}/{}/{}",
stack(&o.base_cost_a.stack),
o.cost_b
.as_ref()
.map_or_else(|| "-".to_owned(), |c| stack(&c.stack)),
stack(&o.result),
o.uses,
o.max_uses,
o.demand,
o.special_price_diff
)
})
.collect();
s.push_str(&format!(" offers {}", join(&offers)));
}
s
}
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().skip(1).collect();
if args.len() != 3 {
@@ -608,7 +771,7 @@ fn main() -> horizon_client::Result<()> {
let n: u32 = x[8..].parse().unwrap();
m.extra.leash = Some(horizon_client::mobs::leash::Holder::Mob(100_000 + n));
}
other => panic!("unknown mob flag {other}"),
other => villager_flag(&mut m, other),
}
}
m.random = LegacyRandom::new(spec.seed);
@@ -657,7 +820,7 @@ fn main() -> horizon_client::Result<()> {
velocity: Vec3::ZERO,
yaw: 0.0,
hero: false,
uuid: [0, 0x1234, 0, 0x5678],
uuid: PLAYER_UUID,
allies: Default::default(),
}
});
@@ -767,6 +930,7 @@ fn main() -> horizon_client::Result<()> {
#[allow(unused_mut)] // filled only with the rng-trace feature
let mut traces: Vec<String> = Vec::new();
let mut pushes = Vec::new();
let mut born = Vec::new();
for i in 0..mobs.len() {
if mobs[i].removed {
continue;
@@ -790,6 +954,16 @@ fn main() -> horizon_client::Result<()> {
m.removed = true;
}
horizon_client::mobs::apply_brain_events(&mut mobs, &mut events, from);
villager_events(
&mut mobs,
&mut events,
from,
&w,
&types,
&items,
&mut born,
s.time,
);
// ServerLevel ticks entities one after another: the ones
// after this mob see it as it is now.
if let Some(e) = snapshot.iter_mut().find(|e| e.id == mobs[i].id) {
@@ -822,6 +996,7 @@ fn main() -> horizon_client::Result<()> {
added.append(&mut host.added);
}
drop(w);
mobs.append(&mut born);
mobs.append(&mut added);
for e in &heart_events {
match e {
+16 -2
View File
@@ -329,12 +329,26 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
}
impl Audio {
pub fn new(root: &Path) -> Self {
Self::with_output(root, true)
}
/// No output device: the dedicated server.
pub fn silent(root: &Path) -> Self {
Self::with_output(root, false)
}
fn with_output(root: &Path, output: bool) -> Self {
let registry = SoundRegistry::load(root);
let mixer = Arc::new(Mutex::new(Mixer::default()));
let (stream, live) = match Self::open(mixer.clone()) {
let opened = if output {
Self::open(mixer.clone())
} else {
Err("no output on a dedicated server".into())
};
let (stream, live) = match opened {
Ok(v) => (Some(v), true),
Err(e) => {
eprintln!("Horizon: audio unavailable: {e}");
if output {
eprintln!("Horizon: audio unavailable: {e}");
}
(None, false)
}
};
+1 -1
View File
@@ -140,7 +140,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
for (key, value) in [
("AbsorptionAmount", Tag::Float(0)),
("FallFlying", Tag::Byte(0)),
("CanPickUpLoot", Tag::Byte(i8::from(m.extra.pick_up_loot))),
("CanPickUpLoot", Tag::Byte(i8::from(m.can_pick_up_loot()))),
("LeftHanded", Tag::Byte(0)),
(
"Brain",
+33 -1
View File
@@ -22,6 +22,7 @@ mod copper_golems;
mod creaking;
mod creatures;
mod crossbow;
mod dedicated;
mod dispense_fixture;
mod dispenser;
mod dragon;
@@ -58,6 +59,7 @@ mod music;
mod names;
mod natural_spawning;
mod nautili;
mod net_harness;
mod options;
mod packs;
mod paintings;
@@ -184,6 +186,9 @@ struct Options {
/// Multiplayer: `--server HOST[:PORT]` joins at start; `--name` is the offline player name.
server: Option<String>,
player_name: String,
/// `--dedicated`: run as a dedicated server; vanilla's server arguments
/// (`--nogui`, `--port`, `--world`, `--universe`, `--initSettings`) follow.
dedicated: Option<Vec<String>>,
}
impl Options {
fn read() -> Result<Option<Self>> {
@@ -215,6 +220,7 @@ impl Options {
control: None,
server: None,
player_name: std::env::var("HORIZON_PLAYER_NAME").unwrap_or_else(|_| "Player".into()),
dedicated: None,
};
let mut args = std::env::args().skip(1);
while let Some(arg) = args.next() {
@@ -225,6 +231,10 @@ impl Options {
);
return Ok(None);
}
"--dedicated" => {
o.dedicated = Some(args.by_ref().collect());
break;
}
"--creative" => o.creative = true,
"--test-terrain" => o.test_terrain = true,
"--no-pause" => o.no_pause = true,
@@ -2573,6 +2583,10 @@ impl Game<'_> {
}
let riding = self.riding.is_some();
let Some(player) = self.player.as_mut() else {
// A dedicated server has no local player: the world still runs.
if self.options.dedicated.is_some() {
return self.tick_world(running);
}
return Ok(());
};
// Hold position until the surrounding terrain exists.
@@ -2760,6 +2774,11 @@ impl Game<'_> {
self.screen = Screen::Dead;
self.capture(false);
}
self.tick_world(running)
}
/// What the tick runs after the local player's own update: effects, the
/// world's entities and blocks, and the network hub.
fn tick_world(&mut self, running: bool) -> Result<()> {
self.tick_effects();
self.tick_burning();
self.tick_using();
@@ -8053,6 +8072,9 @@ pub fn run() -> Result<()> {
let Some(mut options) = Options::read()? else {
return Ok(());
};
if options.dedicated.is_some() && !dedicated::preflight(&mut options)? {
return Ok(());
}
let started = Instant::now();
let vanilla_root = options.resources.clone();
let early_settings = Settings::load(&std::env::current_dir()?.join("options.txt"));
@@ -8127,7 +8149,11 @@ pub fn run() -> Result<()> {
.join("saves")
.join(".horizon-title"),
));
let audio = Audio::new(&root);
let audio = if options.dedicated.is_some() {
Audio::silent(&root)
} else {
Audio::new(&root)
};
let world = World::new(facts.air, 0);
let creative = options.creative;
let stations = horizon_client::stations::StationData::load(&root, &items);
@@ -8417,6 +8443,9 @@ pub fn run() -> Result<()> {
if let Ok(spec) = std::env::var("HORIZON_SCULK_FIXTURE") {
return game.sculk_fixture(&spec);
}
if game.options.dedicated.is_some() {
return game.run_dedicated();
}
match game.options.world.clone() {
_ if game.options.server.is_some() => {
let (address, name) = (
@@ -8424,6 +8453,9 @@ pub fn run() -> Result<()> {
game.options.player_name.clone(),
);
game.connect_server(&address, &name)?;
if let Some(report) = std::env::var_os("HORIZON_NET_REPORT") {
return game.run_net_harness(report.as_ref());
}
}
Some(folder) => {
let (seed, creative) = (game.options.seed, game.options.creative);
+6 -55
View File
@@ -87,60 +87,7 @@ impl ProjectileWorld for ProjWorld<'_, '_> {
}
}
pub(super) fn seen(m: &Mob, player: Option<[i32; 4]>) -> Seen {
let villager = m.species() == Species::Villager;
Seen {
id: m.id,
species: m.species(),
position: m.position,
bounds: m.bounds(),
eye_y: m.eye_y(),
alive: m.alive(),
baby: m.is_baby(),
// A villager is "in love" when it is willing to breed (`canBreed`).
in_love: if villager {
horizon_client::mobs::villager::can_breed(m)
} else {
m.extra.in_love > 0
},
tame: m.extra.tame,
hostile: m.hostile(),
target: m.ai.target,
health: m.health,
variant: m.extra.variant,
color: m.extra.color,
job: (m.species() == Species::Villager)
.then_some(m.extra.home)
.flatten(),
bed: (m.species() == Species::Villager)
.then_some(m.extra.bed)
.flatten(),
yaw: m.yaw,
velocity: m.velocity,
leash: m.extra.leash,
caravan: horizon_client::mobs::caravan::head_of(m),
delay: m.extra.ints[5],
hurt_by: m.ai.last_hurt_by.map(|w| (w, m.ai.last_hurt_by_time)),
active_raid: horizon_client::mobs::raider::has_active_raid(m),
player_rep: match (villager, player) {
(true, Some(uuid)) => {
horizon_client::mobs::villager::ext(m).map_or(0, |e| e.gossips.reputation(uuid))
}
_ => 0,
},
pushable: m.pushable(),
category: m.category(),
potential_job: horizon_client::mobs::villager_brain::potential_job_site(m),
meeting: (m.species() == Species::Villager)
.then_some(m.extra.meeting)
.flatten(),
profession: m.extra.variant2,
xp: horizon_client::mobs::villager::xp(m),
stats: [
f64::from(m.attrs.max_health),
m.extra.vector[0],
m.attrs.speed,
],
}
m.seen(player)
}
impl Game<'_> {
pub(super) fn player_view(&self) -> Option<PlayerView> {
@@ -967,7 +914,11 @@ impl Game<'_> {
}
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::VillagerBirth {
parent,
partner,
child,
} => self.villager_birth(parent, partner, child),
MobEvent::GolemCheck { mob, needed } => self.villager_golem_check(mob, needed),
MobEvent::Firework { at, color, flight } => {
self.villager_firework(at, color, flight)
File diff suppressed because it is too large Load Diff
+96 -37
View File
@@ -7,7 +7,7 @@ use horizon_client::{
Result,
items::ItemStack,
lan::{
self, Lan, MAX_PLAYERS,
self, Lan, MAX_PLAYERS, NetConfig,
chunks::ChunkEncoder,
data::SyncData,
entity::EntityState,
@@ -345,6 +345,40 @@ impl Game<'_> {
if self.lan.is_some() || self.remote.is_some() || self.title.is_some() {
return Err("already open".into());
}
let motd = format!("{PLAYER_NAME} - {}", self.level.name);
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)
},
);
let config = 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,
dedicated: false,
};
let net = NetConfig::lan(settings.port, motd, MAX_PLAYERS);
self.lan_host(settings, net, config, Some(host_uuid))
}
/// Start the network side and the play-state hub: for the LAN (with the
/// host's own profile reserved) or for a dedicated server (no host).
pub(super) fn lan_host(
&mut self,
settings: LanSettings,
net: NetConfig,
config: HubConfig,
host: Option<u128>,
) -> Result<()> {
let root = self.options.resources.clone();
let sync = SYNC
.get_or_init(|| SyncData::load(&root).map(Arc::new))
@@ -362,7 +396,7 @@ impl Game<'_> {
.get("minecraft:worldgen/biome")
.map(|v| v.iter().map(|(n, _)| n.clone()).collect())
.unwrap_or_default();
let encoder = ChunkEncoder::new(
let mut encoder = ChunkEncoder::new(
self.res
.facts
.states
@@ -372,37 +406,20 @@ impl Game<'_> {
&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)
},
encoder.tables = Some(
self.save
.tables
.get_or_init(|| Arc::new(horizon_client::save::SaveTables::new(&self.res.assets)))
.clone(),
);
lan.reserve(host_uuid);
let lan = Lan::start_with(sync.clone(), net)?;
if let Some(uuid) = host {
lan.reserve(uuid);
}
let host_uuid = host.unwrap_or(0);
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,
dedicated: false,
},
);
let hub = Hub::new(lan, sync, encoder, config);
let port = hub.lan.port;
self.world.block_log = Some(Vec::new());
self.lan = Some(LanHost {
@@ -543,7 +560,9 @@ impl Game<'_> {
let Some(mut host) = self.lan.take() else {
return;
};
if let Some(state) = self.lan_host_state(&host) {
let state = self.lan_host_state(&host);
// A dedicated server runs the hub without a host player.
if state.is_some() || host.hub.config.dedicated {
let has_guests = !host.hub.guests.is_empty();
let entities = if has_guests {
self.lan_entities(&mut host.hub)
@@ -554,7 +573,7 @@ impl Game<'_> {
let events = {
let mut ctx = TickCtx {
world: &mut self.world,
host: Some(&state),
host: state.as_ref(),
entities: &entities,
next_entity: &mut self.next_entity,
spawn,
@@ -570,18 +589,56 @@ impl Game<'_> {
};
host.hub.tick(&mut ctx)
};
if host.host_mode != state.game_mode {
if let Some(state) = &state
&& 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)
self.lan_guest_joined(&mut host, conn, state.as_ref(), &entities, spawn);
if self.options.dedicated.is_some()
&& let Some(g) = host.hub.guest(conn)
{
// PlayerList.placeNewPlayer, then the broadcast join message.
let [x, y, z] = g.position;
super::dedicated::log(
"INFO",
&format!(
"{}[/{}] logged in with entity id {} at ({}, {}, {})",
g.name,
g.address,
g.entity_id,
super::dedicated::java_double(x),
super::dedicated::java_double(y),
super::dedicated::java_double(z)
),
);
super::dedicated::log(
"INFO",
&format!("System chat: {} joined the game", g.name),
);
}
}
HostEvent::Left(guest) => {
playerdata::save(&guest, &self.world_root);
host.models.remove(&guest.conn);
if self.options.dedicated.is_some() && guest.placed {
super::dedicated::log(
"INFO",
&format!("{} lost connection: {}", guest.name, guest.left_reason),
);
super::dedicated::log(
"INFO",
&format!("System chat: {} left the game", guest.name),
);
}
}
// MinecraftServer.logChatMessage of an unsigned message.
HostEvent::Chat(line) if self.options.dedicated.is_some() => {
super::dedicated::log("INFO", &format!("[Not Secure] {line}"));
}
HostEvent::Chat(line) => self.system_message(Text::literal(line)),
HostEvent::Packet(conn, packet) => {
@@ -602,7 +659,7 @@ impl Game<'_> {
&mut self,
host: &mut LanHost,
conn: u32,
state: &HostState,
state: Option<&HostState>,
entities: &[EntityState],
spawn: [f64; 3],
) {
@@ -624,7 +681,7 @@ impl Game<'_> {
}
let mut ctx = TickCtx {
world: &mut self.world,
host: Some(state),
host: state,
entities,
next_entity: &mut self.next_entity,
spawn,
@@ -688,7 +745,9 @@ impl Game<'_> {
.guests
.iter()
.filter(|g| g.placed)
.map(|g| (g.chunk(), g.view_distance + 1))
// The tracked square's corners and their lit neighbours lie
// within (view distance + 2) * √2 of the player's chunk.
.map(|g| (g.chunk(), (g.view_distance + 2) * 3 / 2 + 1))
.collect();
}
@@ -511,6 +511,21 @@ impl Game<'_> {
/// Commands.performCommand for a guest with command access.
fn guest_command(&mut self, host: &mut LanHost, conn: u32, command: &str) {
// ListPlayersCommand needs no permission and lists every player.
let words: Vec<&str> = command.trim_start_matches('/').split(' ').collect();
if words[0] == "list" && (words.len() == 1 || words[1..] == ["uuids"]) {
let me = (self.options.dedicated.is_none() && self.player.is_some())
.then_some((host.host_uuid, super::chat::PLAYER_NAME));
let content = host.hub.list_reply(me, words.len() == 2);
host.hub.send_to(
conn,
&C::SystemChat(play::SystemChat {
content,
overlay: false,
}),
);
return;
}
if !host.settings.guest_commands || !self.cheats {
host.hub.send_to(
conn,
@@ -0,0 +1,93 @@
//! Headless multiplayer client for `tools/test_dedicated_server_parity.py`:
//! with `--server` and `HORIZON_NET_REPORT` set, the client joins without a
//! window, waits until it stands in the world with the chunks around it,
//! sends a chat message and `/list`, collects the chat it is shown, leaves
//! and writes a JSON report (position, chunks, chat lines, whether the
//! server kept it connected throughout).
use super::Game;
use horizon_client::Result;
use serde_json::json;
use std::{
path::Path,
time::{Duration, Instant},
};
impl Game<'_> {
pub(super) fn run_net_harness(&mut self, report: &Path) -> Result<()> {
let deadline = Instant::now() + Duration::from_secs(120);
let mut next = Instant::now();
let mut spawned_at: Option<Instant> = None;
let mut last_chunks = 0;
let mut quiet_since = Instant::now();
let mut step = 0;
let mut step_at = Instant::now();
let mut position = None;
let mut chunks = 0;
let mut error = None;
while Instant::now() < deadline {
self.update_world();
if self.remote.is_none() {
error = Some("disconnected".to_owned());
break;
}
if Instant::now() >= next {
next += Duration::from_millis(50);
self.tick()?;
}
let now = Instant::now();
if let Some(p) = &self.player {
spawned_at.get_or_insert(now);
position.get_or_insert([p.position.x, p.position.y, p.position.z]);
}
let count = self.world.chunks.len();
if count != last_chunks {
last_chunks = count;
quiet_since = now;
}
match step {
0 if spawned_at.is_some()
&& count > 0
&& now - quiet_since > Duration::from_secs(3) =>
{
chunks = count;
self.send_chat("hello from the horizon client");
step = 1;
step_at = now;
}
1 if now - step_at > Duration::from_millis(1500) => {
self.send_chat("/list");
step = 2;
step_at = now;
}
2 if now - step_at > Duration::from_millis(1500) => {
step = 3;
break;
}
_ => {}
}
std::thread::sleep(Duration::from_millis(5));
}
if step < 3 && error.is_none() {
error = Some(format!("timed out at step {step}"));
}
let chat: Vec<String> = self
.remote
.as_ref()
.map(|r| r.chat.iter().map(|(t, _)| t.clone()).collect())
.unwrap_or_default();
if self.remote.is_some() {
self.leave_server(None)?;
}
std::fs::write(
report,
json!({
"position": position,
"chunks": chunks,
"chat": chat,
"error": error,
})
.to_string(),
)?;
Ok(())
}
}
@@ -144,6 +144,7 @@ pub(super) fn player_type(root: &Path) -> Option<Arc<MobType>> {
armor_toughness: 0.0,
knockback_resistance: 0.0,
jump_strength: 0.42,
attributes: Default::default(),
gravity: 0.08,
safe_fall_distance: 3.0,
fall_damage_multiplier: 1.0,
+23 -124
View File
@@ -8,7 +8,6 @@ use horizon_client::{
mobs::{Mob, Species, spawning, villager},
};
use horizon_core::{geometry::Vec3, random::RandomSource};
use std::collections::HashMap;
fn block_of(p: Vec3) -> [i32; 3] {
[p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]
@@ -59,68 +58,13 @@ impl Game<'_> {
};
let now = self.world.game_time;
let items = &self.res.items;
let max = |item: &str| items.get(item).map_or(64, |i| i.max_stack);
// Villager.gossip: both must be past their cool-down.
let ready = {
let ea = villager::ext(&self.mobs[ia]);
let eb = villager::ext(&self.mobs[ib]);
ea.is_none_or(|e| e.can_gossip(now)) && eb.is_none_or(|e| e.can_gossip(now))
};
let mut golem = false;
if ready {
let source = villager::ext(&self.mobs[ib]).cloned().unwrap_or_default();
let me = &mut self.mobs[ia];
let mut random = me.random.clone();
let e = villager::ext_mut(me);
e.gossips.transfer_from(&source.gossips, &mut random, 10);
e.last_gossip_time = now;
me.random = random;
villager::ext_mut(&mut self.mobs[ib]).last_gossip_time = now;
golem = true;
let meeting = villager::meet(&mut self.mobs, ia, ib, now, |item| {
items.get(item).map_or(64, |i| i.max_stack)
});
for stack in meeting.thrown {
self.villager_throw(meeting.from, meeting.eye, meeting.to, stack);
}
// Surplus food goes to a hungry neighbour (farmers hand it to anyone).
let farmer = villager::is_farmer(&self.mobs[ia]);
let (from, eye, to) = (
self.mobs[ia].position,
self.mobs[ia].eye_y(),
self.mobs[ib].position,
);
let wants_more = villager::ext(&self.mobs[ib]).is_none_or(|e| e.wants_more_food());
let excess = villager::ext(&self.mobs[ia]).is_some_and(|e| e.has_excess_food());
let mut thrown = Vec::new();
if excess
&& (farmer || wants_more)
&& let Some(s) = villager::ext_mut(&mut self.mobs[ia])
.take_half_stack(|s| villager::food_points(&s.item) > 0, max)
{
thrown.push(s);
}
// A farmer's wheat.
if farmer
&& villager::ext(&self.mobs[ia]).is_some_and(|e| e.count_item("minecraft:wheat") > 32)
&& let Some(s) = villager::ext_mut(&mut self.mobs[ia])
.take_half_stack(|s| &*s.item == "minecraft:wheat", max)
{
thrown.push(s);
}
// Wares the neighbour's profession asks for and ours does not.
let theirs = villager::requested_items(&self.mobs[ib]);
let mine = villager::requested_items(&self.mobs[ia]);
let wanted: Vec<&str> = theirs
.iter()
.copied()
.filter(|i| !mine.contains(i))
.collect();
if !wanted.is_empty()
&& let Some(s) = villager::ext_mut(&mut self.mobs[ia])
.take_half_stack(|s| wanted.contains(&&*s.item), max)
{
thrown.push(s);
}
for stack in thrown {
self.villager_throw(from, eye, to, stack);
}
if golem {
if meeting.gossiped {
self.villager_golem_check(a, 5);
}
}
@@ -219,46 +163,39 @@ impl Game<'_> {
/// `VillagerMakeLove.tryToGiveBirth`: both eat, a free bed within 48
/// blocks is taken for the child, who is a baby villager of one of
/// three villager types.
pub(super) fn villager_birth(&mut self, parent: u32, partner: u32) {
pub(super) fn villager_birth(
&mut self,
parent: u32,
partner: u32,
child: Option<([i32; 3], Option<u8>)>,
) {
let (Some(ia), Some(ib)) = (self.villager_index(parent), self.villager_index(partner))
else {
return;
};
villager::ext_mut(&mut self.mobs[ia]).eat_and_digest();
villager::ext_mut(&mut self.mobs[ib]).eat_and_digest();
let from = self.mobs[ia].position;
let angry = |g: &mut Self| {
let Some((bed, variant)) = child else {
for i in [ia, ib] {
let p = g.mobs[i].position;
g.particles_at("angry_villager", [p.x, p.y + 1.8, p.z]);
let p = self.mobs[i].position;
self.particles_at("angry_villager", [p.x, p.y + 1.8, p.z]);
}
};
let Some(bed) = self.take_vacant_bed(block_of(from)) else {
angry(self);
return;
};
// Villager.getBreedOffspring: half the biome's type, a quarter each parent's.
let roll = self.mobs[ia].random.next_double();
let kind_of = |m: &Mob| m.extra.variant;
let facts = self.biome_facts(
from.x.floor() as i32,
from.y.floor() as i32,
from.z.floor() as i32,
);
let variant = if roll < 0.5 {
let variant = variant.unwrap_or_else(|| {
let facts = self.biome_facts(
from.x.floor() as i32,
from.y.floor() as i32,
from.z.floor() as i32,
);
spawning::villager_type(&facts)
} else if roll < 0.75 {
kind_of(&self.mobs[ia])
} else {
kind_of(&self.mobs[ib])
};
});
self.mobs[ib].extra.age = 6000;
let Some(id) =
self.spawn_mob_for("minecraft:villager", [from.x, from.y, from.z], true, true)
else {
return;
};
self.mobs[ia].extra.age = 6000;
self.mobs[ib].extra.age = 6000;
if let Some(child) = self.mobs.iter_mut().find(|m| m.id == id) {
child.extra.variant = variant;
child.extra.variant2 = villager::NONE;
@@ -267,44 +204,6 @@ impl Game<'_> {
}
self.particles_at("heart", [from.x, from.y + 1.8, from.z]);
}
/// `PoiManager.take(HOME, ..., 48)`: the nearest unclaimed bed head.
fn take_vacant_bed(&self, from: [i32; 3]) -> Option<[i32; 3]> {
let claimed: Vec<[i32; 3]> = self
.mobs
.iter()
.filter(|m| m.species() == Species::Villager)
.filter_map(|m| m.extra.bed)
.collect();
let mut known: HashMap<u32, bool> = HashMap::new();
let mut best: Option<(i32, [i32; 3])> = None;
for y in from[1] - 8..=from[1] + 8 {
for z in from[2] - 48..=from[2] + 48 {
for x in from[0] - 48..=from[0] + 48 {
let state = self.world.block(x, y, z);
if self.res.facts.is_air(state) {
continue;
}
let free_head = *known.entry(state.0).or_insert_with(|| {
self.res.facts.get(state).name.ends_with("_bed")
&& self.res.assets.registry.state(state).is_some_and(|s| {
s.properties.get("part").map(String::as_str) == Some("head")
&& s.properties.get("occupied").map(String::as_str)
!= Some("true")
})
});
let d = (x - from[0]).pow(2) + (y - from[1]).pow(2) + (z - from[2]).pow(2);
if free_head
&& d <= 48 * 48
&& !claimed.contains(&[x, y, z])
&& best.is_none_or(|(b, _)| d < b)
{
best = Some((d, [x, y, z]));
}
}
}
}
best.map(|(_, p)| p)
}
fn particles_at(&mut self, kind: &'static str, at: [f64; 3]) {
if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) {
let options = horizon_client::particles::ParticleOptions::simple(ty);
+9
View File
@@ -110,6 +110,15 @@ impl Gossips {
pub fn clear(&mut self) {
self.map.clear();
}
/// Every (target, type, value) held.
pub fn entries(&self) -> impl Iterator<Item = (Target, GossipType, i32)> + '_ {
self.map.iter().flat_map(|(t, e)| {
GossipType::ALL
.into_iter()
.filter(move |k| e[k.index()] != 0)
.map(move |k| (*t, k, e[k.index()]))
})
}
pub fn get(&self, target: Target, kind: GossipType) -> i32 {
self.map.get(&target).map_or(0, |e| e[kind.index()])
}
+168 -21
View File
@@ -88,6 +88,8 @@ pub struct ChunkEncoder {
biome_bits: u8,
/// The block registry id of each state's block, for BlockEvent.
pub block_ids: Vec<i32>,
/// The save's tables, for the heightmaps.
pub tables: Option<Arc<crate::save::SaveTables>>,
}
impl ChunkEncoder {
/// `biome_names`: the internal biome list in order; `biome_registry`:
@@ -140,6 +142,7 @@ impl ChunkEncoder {
biome_ids,
biome_bits: ceil_log2(biome_registry.len()),
block_ids,
tables: None,
}
}
pub fn entity_type(&self, state: u16) -> Option<i32> {
@@ -194,6 +197,38 @@ impl ChunkEncoder {
}
/// The chunk column with its light and block entities.
/// The non-air sections of a column as bits (LevelChunkSection.hasOnlyAir).
fn occupied(&self, chunk: &Chunk) -> u64 {
let mut bits = 0u64;
for (i, s) in chunk.sections.iter().enumerate() {
let mut unpacked = [0u16; BLOCKS];
s.unpack(&mut unpacked);
let any = unpacked
.iter()
.any(|&v| self.flags.get(usize::from(v)).copied().unwrap_or(0) & NON_AIR != 0);
if any {
bits |= 1 << i;
}
}
bits
}
/// The chunk column with its light and block entities. `world` gives the
/// neighbouring columns, whose sections decide which light layers exist.
pub fn encode_in(&self, chunk: &Chunk, world: &crate::world::World) -> LevelChunkWithLight {
let mut around = 0u64;
for dz in -1..=1 {
for dx in -1..=1 {
if let Some(c) = world.chunks.get(&(chunk.x + dx, chunk.z + dz)) {
around |= self.occupied(c);
}
}
}
let mut packet = self.encode(chunk, &world.block_entities);
packet.light = light_data(chunk, around);
packet
}
pub fn encode(
&self,
chunk: &Chunk,
@@ -215,12 +250,12 @@ impl ChunkEncoder {
packed_xz: ((x << 4) | z) as i8,
y: wy as i16,
kind,
// BlockEntityInfo.create: an empty update tag is not sent.
tag: block_entities
.get(&pos)
.and_then(entity_tag)
.unwrap_or_else(
|| Tag::compound(Vec::<(&str, Tag)>::new()),
),
.or_else(|| saved_update_tag(chunk, pos))
.unwrap_or(Tag::End),
});
}
}
@@ -229,19 +264,118 @@ impl ChunkEncoder {
}
sections.push(encoded);
}
java_hash_order(&mut entity_infos, |e| {
(
chunk.x * 16 + i32::from(e.packed_xz as u8 >> 4),
i32::from(e.y),
chunk.z * 16 + i32::from(e.packed_xz as u8 & 15),
)
});
LevelChunkWithLight {
x: chunk.x,
z: chunk.z,
chunk: ChunkData {
heightmaps: Vec::new(),
heightmaps: self
.tables
.as_ref()
.map(|t| crate::save::client_heightmaps(chunk, t))
.unwrap_or_default(),
buffer: ChunkData::from_sections(&sections),
block_entities: entity_infos,
},
light: light_data(chunk),
light: light_data(chunk, u64::MAX),
}
}
}
/// The order LevelChunk.getBlockEntities() iterates in: a fastutil
/// Object2ObjectOpenHashMap keyed by BlockPos (linear probing from
/// HashCommon.mix(hashCode), grown at 3/4 by reinserting from the top of
/// the table, iterated from the top down), filled in the order of the
/// java.util.HashMap of pending block entities that the loaded chunk's list
/// (`items` in section order) went through.
fn java_hash_order<T>(items: &mut Vec<T>, pos: impl Fn(&T) -> (i32, i32, i32)) {
// Vec3i.hashCode.
let hash = |&(x, y, z): &(i32, i32, i32)| {
y.wrapping_add(z.wrapping_mul(31))
.wrapping_mul(31)
.wrapping_add(x)
};
let keys: Vec<i32> = items.iter().map(|i| hash(&pos(i))).collect();
// java.util.HashMap: buckets in index order, insertion order within one.
let mut capacity = 16usize;
while keys.len() * 4 > capacity * 3 {
capacity *= 2;
}
let mut order: Vec<usize> = (0..keys.len()).collect();
order.sort_by_key(|&i| {
((keys[i] ^ ((keys[i] as u32) >> 16) as i32) as u32 as usize) & (capacity - 1)
});
// Object2ObjectOpenHashMap.
let mix = |h: i32| {
let h = h.wrapping_mul(0x9E37_79B9_u32 as i32) as u32;
(h ^ (h >> 16)) as usize
};
let put = |table: &mut Vec<Option<usize>>, i: usize| {
let mask = table.len() - 1;
let mut at = mix(keys[i]) & mask;
while table[at].is_some() {
at = (at + 1) & mask;
}
table[at] = Some(i);
};
// Default expected size 16: HashCommon.arraySize(16, 0.75) = 32 slots.
let mut table: Vec<Option<usize>> = vec![None; 32];
for (size, &i) in order.iter().enumerate() {
put(&mut table, i);
// insert: `if (size++ >= maxFill) rehash(arraySize(size + 1, f))`.
let max_fill = (table.len() * 3).div_ceil(4).min(table.len() - 1);
if size >= max_fill {
let grown = ((size + 2) * 4).div_ceil(3).next_power_of_two().max(2);
let old = std::mem::replace(&mut table, vec![None; grown]);
for &j in old.iter().rev().flatten() {
put(&mut table, j);
}
}
}
let iteration: Vec<usize> = table.iter().rev().flatten().copied().collect();
let mut slots: Vec<Option<T>> = items.drain(..).map(Some).collect();
items.extend(iteration.into_iter().filter_map(|i| slots[i].take()));
}
/// The update tag of a block entity Horizon keeps only as loaded NBT:
/// SpawnerBlockEntity.getUpdateTag is its saved fields without
/// SpawnPotentials (saveCustomOnly, so no id or position).
fn saved_update_tag(chunk: &Chunk, pos: (i32, i32, i32)) -> Option<Tag> {
let saved = chunk.saved.as_ref()?;
let tag = saved.block_entities.iter().find(|t| {
let Tag::Compound(c) = t else { return false };
let at = |k: &str| match c.get(&k.into()) {
Some(Tag::Int(v)) => Some(*v),
_ => None,
};
(at("x"), at("y"), at("z")) == (Some(pos.0), Some(pos.1), Some(pos.2))
})?;
if crate::block_entity_nbt::id(tag).as_deref() != Some("minecraft:mob_spawner") {
return None;
}
let Tag::Compound(mut c) = crate::block_entity_nbt::canonical(tag)? else {
return None;
};
for key in [
"id",
"x",
"y",
"z",
"keepPacked",
"SpawnPotentials",
"components",
] {
c.remove(&key.into());
}
Some(Tag::Compound(c))
}
/// The update tag of a block entity (getUpdateTag) for what the client shows.
pub fn entity_tag(entity: &BlockEntity) -> Option<Tag> {
match entity {
@@ -251,8 +385,12 @@ pub fn entity_tag(entity: &BlockEntity) -> Option<Tag> {
}
}
/// Light sections run from one below the world to one above it.
fn light_data(chunk: &Chunk) -> LightData {
/// Light sections run from one below the world to one above it. A layer
/// exists where vanilla's light storage keeps one: within one section of a
/// non-air section of this column or a neighbouring one (`around`, bit i for
/// section i; LayerLightSectionStorage.updateSectionStatus). An existing
/// layer is sent, or marked empty when all dark; the others are left out.
fn light_data(chunk: &Chunk, around: u64) -> LightData {
let mut data = LightData {
sky_mask: Vec::new(),
block_mask: Vec::new(),
@@ -261,14 +399,24 @@ fn light_data(chunk: &Chunk) -> LightData {
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;
// Light section b holds chunk section b - 1.
let exists = |b: usize| {
(b.saturating_sub(2)..=b.min(SECTIONS - 1)).any(|s| s + 2 >= b && around >> s & 1 != 0)
};
let full_sky = Light::Uniform(0xF0);
for b in 0..SECTIONS + 2 {
if !exists(b) {
continue;
}
let light = match b {
// Below the world nothing is lit; above it the sky is full.
0 => &Light::Uniform(0),
_ if b == SECTIONS + 1 => &full_sky,
_ => &chunk.sections[b - 1].light,
};
let (mut sky, mut block) = (vec![0u8; 2048], vec![0u8; 2048]);
let (mut sky_any, mut block_any) = (false, false);
match &s.light {
match light {
Light::Uniform(v) => {
let (sk, bl) = (v >> 4, v & 15);
sky_any = sk != 0;
@@ -293,21 +441,18 @@ fn light_data(chunk: &Chunk) -> LightData {
}
}
if sky_any {
set_bit(&mut data.sky_mask, bit);
set_bit(&mut data.sky_mask, b);
data.sky.push(sky);
} else {
set_bit(&mut data.empty_sky_mask, bit);
set_bit(&mut data.empty_sky_mask, b);
}
if block_any {
set_bit(&mut data.block_mask, bit);
set_bit(&mut data.block_mask, b);
data.block.push(block);
} else {
set_bit(&mut data.empty_block_mask, bit);
set_bit(&mut data.empty_block_mask, b);
}
}
set_bit(&mut data.sky_mask, SECTIONS + 1);
data.sky.push(vec![0xFF; 2048]);
set_bit(&mut data.empty_block_mask, SECTIONS + 1);
data
}
@@ -335,7 +480,9 @@ mod tests {
#[test]
fn light_masks_cover_the_world_plus_borders() {
let chunk = Chunk::empty(0, 0);
let data = light_data(&chunk);
// A column with nothing around it has no light layers at all.
assert!(light_data(&chunk, 0).sky.is_empty());
let data = light_data(&chunk, u64::MAX);
// Default sections are full sky light and no block light.
assert_eq!(data.sky.len(), SECTIONS + 1);
assert_eq!(data.block.len(), 0);
+205 -23
View File
@@ -35,16 +35,88 @@ 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}\"}}");
fn login_disconnect(c: &mut Connection, reason: &horizon_world::nbt::Tag) {
let json = component_json(reason);
let _ =
c.send(&login::Clientbound::Disconnect(login::Disconnect { reason_json: json }).encode());
}
/// A component as ComponentSerialization.CODEC writes it with JsonOps (and
/// Gson without HTML escaping): plain text collapses to a string, the
/// content fields come first, then `extra`, then the style.
pub fn component_json(tag: &horizon_world::nbt::Tag) -> String {
component_value(tag).compact()
}
fn component_value(tag: &horizon_world::nbt::Tag) -> crate::server::json::Json {
use crate::server::json::Json;
use horizon_world::nbt::Tag;
const ORDER: &[&str] = &[
"type",
"text",
"translate",
"fallback",
"with",
"score",
"selector",
"separator",
"keybind",
"nbt",
"interpret",
"block",
"entity",
"storage",
"source",
"object",
"sprite",
"atlas",
"player",
"hat",
"extra",
"color",
"shadow_color",
"bold",
"italic",
"underlined",
"strikethrough",
"obfuscated",
"click_event",
"hover_event",
"insertion",
"font",
];
match tag {
Tag::String(s) => Json::String(s.to_string_lossy()),
Tag::List(items) => Json::Array(items.iter().map(component_value).collect()),
Tag::Compound(map) => {
if map.len() == 1
&& let Some(Tag::String(t)) = map.get(&horizon_world::nbt::JavaString::from("text"))
{
return Json::String(t.to_string_lossy());
}
let mut keys: Vec<String> = map.keys().map(|k| k.to_string_lossy()).collect();
keys.sort_by_key(|k| ORDER.iter().position(|o| o == k).unwrap_or(ORDER.len()));
Json::Object(
keys.into_iter()
.map(|k| {
let v = &map[&horizon_world::nbt::JavaString::from(k.as_str())];
let value = match v {
Tag::Byte(b) => Json::Bool(*b != 0),
Tag::Int(i) => Json::Number(i.to_string()),
other => component_value(other),
};
(k, value)
})
.collect(),
)
}
Tag::Byte(b) => Json::Bool(*b != 0),
Tag::Int(i) => Json::Number(i.to_string()),
Tag::Long(i) => Json::Number(i.to_string()),
_ => Json::Null,
}
}
/// 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)
@@ -63,8 +135,88 @@ impl PlayerSender {
}
}
pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
/// LegacyQueryHandler: the pre-1.7 server list ping. What the first read
/// holds decides the reply (1.3 and older: no more bytes; 1.4 and 1.5: 0x01;
/// 1.6: 0x01 then the MC|PingHost payload); anything else gets no reply.
fn serve_legacy(mut stream: TcpStream, shared: &Shared) -> Result<(), String> {
use std::io::{Read, Write};
let _ = stream.set_read_timeout(Some(Duration::from_millis(100)));
let mut data = Vec::new();
let mut chunk = [0u8; 1024];
// The bytes of the first read: what arrived together.
if let Ok(n) = stream.read(&mut chunk) {
data.extend_from_slice(&chunk[..n]);
}
let in_string = |d: &[u8], at: &mut usize| -> Option<String> {
let len = usize::from(u16::from_be_bytes([*d.get(*at)?, *d.get(*at + 1)?]));
let bytes = d.get(*at + 2..*at + 2 + len * 2)?;
*at += 2 + len * 2;
Some(String::from_utf16_lossy(
&bytes
.chunks(2)
.map(|c| u16::from_be_bytes([c[0], c[1]]))
.collect::<Vec<_>>(),
))
};
let motd = shared.motd();
let (online, max) = (shared.online(), shared.max_players());
let body = if data.len() == 1 {
format!("{motd}\u{a7}{online}\u{a7}{max}")
} else {
if data[1] != 1 {
return Ok(());
}
if data.len() > 2 {
// readCustomPayloadPacket.
let mut at = 3;
let valid = data[2] == 0xFA
&& in_string(&data, &mut at).as_deref() == Some("MC|PingHost")
&& data
.get(at..at + 2)
.map(|b| usize::from(u16::from_be_bytes([b[0], b[1]])))
== Some(data.len().saturating_sub(at + 2))
&& {
at += 2;
data.get(at).is_some_and(|v| *v >= 73)
}
&& {
at += 1;
in_string(&data, &mut at).is_some()
}
&& data
.get(at..at + 4)
.is_some_and(|b| i32::from_be_bytes([b[0], b[1], b[2], b[3]]) <= 65535);
if !valid {
return Ok(());
}
}
format!("\u{a7}1\0127\026.3\0{motd}\0{online}\0{max}")
};
let units: Vec<u16> = body.encode_utf16().collect();
let mut out = vec![0xFF];
out.extend_from_slice(&(units.len() as u16).to_be_bytes());
for u in units {
out.extend_from_slice(&u.to_be_bytes());
}
stream.write_all(&out).map_err(|e| e.to_string())?;
let _ = stream.shutdown(std::net::Shutdown::Both);
Ok(())
}
pub fn serve(
stream: TcpStream,
address: std::net::SocketAddr,
shared: Arc<Shared>,
) -> Result<(), String> {
let e = |e: horizon_protocol::Error| e.to_string();
// LegacyQueryHandler, ahead of the frame decoder while status is on.
let mut first = [0u8; 1];
if shared.config.enable_status
&& stream.peek(&mut first).is_ok_and(|n| n == 1)
&& first[0] == 0xFE
{
return serve_legacy(stream, &shared);
}
let mut c = Connection::from_stream(stream).map_err(e)?;
c.reader
.set_read_timeout(Some(Duration::from_secs(30)))
@@ -75,10 +227,20 @@ pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
_ => return Err("expected a handshake".into()),
};
match intention.intent {
// ServerHandshakePacketListenerImpl: a server that does not reply
// to status requests closes the connection.
handshake::STATUS if !shared.config.enable_status => Ok(()),
handshake::STATUS => serve_status(&mut c, &shared),
handshake::TRANSFER if !shared.config.accepts_transfers => {
login_disconnect(
&mut c,
&translatable("multiplayer.disconnect.transfers_disabled", &[]),
);
Ok(())
}
handshake::LOGIN | handshake::TRANSFER => {
if intention.protocol != PROTOCOL_VERSION {
let key = if intention.protocol < PROTOCOL_VERSION {
let key = if intention.protocol < 754 {
"multiplayer.disconnect.outdated_client"
} else {
"multiplayer.disconnect.incompatible"
@@ -93,7 +255,7 @@ pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
);
return Ok(());
}
serve_login(c, &shared)
serve_login(c, address, &shared)
}
other => Err(format!("unknown intent {other}")),
}
@@ -101,10 +263,14 @@ pub fn serve(stream: TcpStream, shared: Arc<Shared>) -> Result<(), String> {
fn serve_status(c: &mut Connection, shared: &Shared) -> Result<(), String> {
let e = |e: horizon_protocol::Error| e.to_string();
let mut requested = false;
loop {
let (id, payload) = c.recv().map_err(e)?;
match status::Serverbound::decode(id, &payload).map_err(e)? {
// ServerStatusPacketListenerImpl: a second request disconnects.
status::Serverbound::StatusRequest(_) if requested => return Ok(()),
status::Serverbound::StatusRequest(_) => {
requested = true;
let json = shared.status_json();
c.send(
&status::Clientbound::StatusResponse(status::StatusResponse { json }).encode(),
@@ -121,7 +287,11 @@ fn serve_status(c: &mut Connection, shared: &Shared) -> Result<(), String> {
}
}
fn serve_login(mut c: Connection, shared: &Arc<Shared>) -> Result<(), String> {
fn serve_login(
mut c: Connection,
address: std::net::SocketAddr,
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)? {
@@ -129,20 +299,23 @@ fn serve_login(mut c: Connection, shared: &Arc<Shared>) -> Result<(), String> {
_ => return Err("expected a login hello".into()),
};
if !valid_name(&hello.name) {
login_disconnect(&mut c, "multiplayer.disconnect.invalid_name");
login_disconnect(
&mut c,
&translatable("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);
if let Some(reason) = shared.try_admit(address, 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);
play(c, shared, parts, address);
Ok(())
}
Ok(None) => {
@@ -170,14 +343,12 @@ fn login_and_configure(
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);
let threshold = shared.config.compression_threshold;
if threshold >= 0 {
c.send(&login::Clientbound::Compression(login::Compression { threshold }).encode())
.map_err(e)?;
c.set_compression(threshold);
}
c.send(
&login::Clientbound::LoginFinished(login::LoginFinished {
profile: login::GameProfile {
@@ -208,7 +379,8 @@ fn login_and_configure(
channel: "minecraft:brand".into(),
data: {
let mut w = horizon_protocol::buf::Writer::new();
w.string("horizon");
// MinecraftServer.getServerModName.
w.string("vanilla");
w.data
},
}),
@@ -266,7 +438,7 @@ fn login_and_configure(
}))
}
fn play(c: Connection, shared: &Arc<Shared>, parts: Parts) {
fn play(c: Connection, shared: &Arc<Shared>, parts: Parts, address: std::net::SocketAddr) {
let conn_id = shared.next_id();
let events = shared.events.clone();
let _ = c.reader.set_read_timeout(Some(KEEP_ALIVE_TIMEOUT));
@@ -294,6 +466,7 @@ fn play(c: Connection, shared: &Arc<Shared>, parts: Parts) {
brand: parts.brand,
sender,
latency,
address,
};
let reason = if events.send(NetEvent::Joined(Box::new(joined))).is_ok() {
read_loop(&mut reader, conn_id, &events, &alive)
@@ -317,6 +490,15 @@ fn read_loop(
loop {
let (id, payload) = match reader.recv() {
Ok(p) => p,
// The client closed the connection: Connection.channelInactive
// without details, multiplayer.disconnect.generic.
Err(e)
if e.0 == "Connection closed by the server"
|| e.0.contains("reset by peer")
|| e.0.contains("aborted") =>
{
return "Disconnected".to_owned();
}
Err(e) => return e.to_string(),
};
match play::Serverbound::decode(id, &payload) {
+58 -35
View File
@@ -10,34 +10,61 @@ use std::{
atomic::{AtomicBool, Ordering},
},
thread::JoinHandle,
time::{Duration, Instant},
time::Duration,
};
pub const GROUP: Ipv4Addr = Ipv4Addr::new(224, 0, 2, 60);
pub const PORT: u16 = 4445;
/// LanServerPinger sleeps 1500 ms between announcements.
const INTERVAL: Duration = Duration::from_millis(1500);
/// LanServerDetection.LanServerList drops entries not refreshed for 5 s.
const EXPIRY: Duration = Duration::from_secs(5);
/// LanServerPinger.createPingString.
pub fn ping_string(motd: &str, port: u16) -> String {
format!("[MOTD]{motd}[/MOTD][AD]{port}[/AD]")
ping_string_text(motd, &port.to_string())
}
fn between<'a>(s: &'a str, open: &str, close: &str) -> Option<&'a str> {
let start = s.find(open)? + open.len();
let end = s[start..].find(close)? + start;
Some(&s[start..end])
/// LanServerPinger.createPingString with the address as text.
pub fn ping_string_text(motd: &str, address: &str) -> String {
format!("[MOTD]{motd}[/MOTD][AD]{address}[/AD]")
}
/// LanServerPinger.parseMotd; vanilla shows "missing no" when absent.
/// String.indexOf(needle, from) on a Rust string (byte offsets).
fn index_of(s: &str, needle: &str, from: usize) -> Option<usize> {
s.get(from..)?.find(needle).map(|i| i + from)
}
/// LanServerPinger.parseMotd; "missing no" when there is none.
pub fn parse_motd(s: &str) -> String {
between(s, "[MOTD]", "[/MOTD]")
.unwrap_or("missing no")
.to_owned()
let Some(start) = s.find("[MOTD]") else {
return "missing no".to_owned();
};
match index_of(s, "[/MOTD]", start + "[MOTD]".len()) {
Some(end) => s[start + "[MOTD]".len()..end].to_owned(),
None => "missing no".to_owned(),
}
}
/// LanServerPinger.parseAddress: the announced port, if present and valid.
pub fn parse_port(s: &str) -> Option<u16> {
between(s, "[AD]", "[/AD]")?.parse().ok().filter(|p| *p > 0)
/// LanServerPinger.parseAddress: the text between [AD] and [/AD] after the
/// only [/MOTD], as announced (vanilla does not check it is a port).
pub fn parse_address(s: &str) -> Option<String> {
let end_motd = s.find("[/MOTD]")?;
if index_of(s, "[/MOTD]", end_motd + "[/MOTD]".len()).is_some() {
return None;
}
let start = index_of(s, "[AD]", end_motd + "[/MOTD]".len())?;
let end = index_of(s, "[/AD]", start + "[AD]".len())?;
Some(s[start + "[AD]".len()..end].to_owned())
}
/// LanServerDetection.LanServerList.addServer: an announcement from `ip`.
/// A new address joins the list; a known one keeps its first MOTD. True
/// when the list changed.
pub fn add_server(games: &mut Vec<LanGame>, ping: &str, ip: &str) -> bool {
let motd = parse_motd(ping);
let Some(address) = parse_address(ping) else {
return false;
};
let address = format!("{ip}:{address}");
if games.iter().any(|g| g.address == address) {
return false;
}
games.push(LanGame { motd, address });
true
}
/// Announces one hosted world until dropped.
@@ -48,7 +75,6 @@ pub struct Pinger {
impl Pinger {
pub fn start(motd: String, port: u16) -> io::Result<Self> {
let socket = UdpSocket::bind(("0.0.0.0", 0))?;
let _ = socket.set_multicast_ttl_v4(4);
let stop = Arc::new(AtomicBool::new(false));
let flag = stop.clone();
let message = ping_string(&motd, port);
@@ -86,7 +112,7 @@ pub struct LanGame {
pub motd: String,
pub address: String,
}
type Games = Arc<Mutex<Vec<(LanGame, Instant)>>>;
type Games = Arc<Mutex<Vec<LanGame>>>;
/// Listens for announcements until the last clone is dropped.
#[derive(Clone, Debug)]
@@ -118,11 +144,10 @@ impl Scanner {
inner: Arc::new(ScanInner { games, stop }),
}
}
/// The live announcements, oldest first.
/// The worlds announced since the scan started, in order (vanilla's
/// list keeps them while the multiplayer screen is open).
pub fn games(&self) -> Vec<LanGame> {
let mut games = self.inner.games.lock().unwrap();
games.retain(|(_, seen)| seen.elapsed() < EXPIRY);
games.iter().map(|(g, _)| g.clone()).collect()
self.inner.games.lock().unwrap().clone()
}
}
fn bind_listener() -> io::Result<UdpSocket> {
@@ -138,18 +163,7 @@ fn listen(socket: UdpSocket, games: Games, stop: Arc<AtomicBool>) {
continue;
};
let text = String::from_utf8_lossy(&buf[..n]);
let Some(port) = parse_port(&text) else {
continue;
};
let game = LanGame {
motd: parse_motd(&text),
address: format!("{}:{port}", from.ip()),
};
let mut games = games.lock().unwrap();
match games.iter_mut().find(|(g, _)| g.address == game.address) {
Some(entry) => *entry = (game, Instant::now()),
None => games.push((game, Instant::now())),
}
add_server(&mut games.lock().unwrap(), &text, &from.ip().to_string());
}
}
@@ -162,8 +176,17 @@ mod tests {
let s = ping_string("Steve - World", 25565);
assert_eq!(s, "[MOTD]Steve - World[/MOTD][AD]25565[/AD]");
assert_eq!(parse_motd(&s), "Steve - World");
assert_eq!(parse_port(&s), Some(25565));
assert_eq!(parse_port("[AD]0[/AD]"), None);
assert_eq!(parse_address(&s).as_deref(), Some("25565"));
assert_eq!(parse_address("[AD]1[/AD]"), None);
assert_eq!(parse_address("[/MOTD][AD]x[/AD][/MOTD]"), None);
assert_eq!(parse_motd("junk"), "missing no");
let mut games = Vec::new();
assert!(add_server(&mut games, &s, "10.0.0.2"));
assert!(!add_server(
&mut games,
&ping_string("Other", 25565),
"10.0.0.2"
));
assert_eq!(games[0].motd, "Steve - World");
}
}
+20
View File
@@ -20,6 +20,20 @@ pub const SPECTATOR: i32 = 3;
pub struct Guest {
pub conn: u32,
/// The client's address (IP bans, `list`).
pub address: std::net::SocketAddr,
/// The hub tick of the player's last action (ServerPlayer.lastActionTime),
/// for player-idle-timeout.
pub last_action_tick: u64,
/// The next ClientboundPlayerChatPacket.globalIndex for this connection.
pub chat_index: i32,
/// The hub tick the player was placed on: chunks go out from the tick
/// after next, behind the first doTick's packets, as vanilla's do.
pub placed_at: u64,
/// The chunk cache centre placeNewPlayer already sent.
pub center_sent: Option<(i32, i32)>,
/// Why the connection closed (the console's "lost connection").
pub left_reason: String,
pub uuid: u128,
pub name: String,
pub entity_id: i32,
@@ -97,6 +111,12 @@ impl Guest {
pub fn new(j: Joined, entity_id: i32, position: [f64; 3], view_distance: i32) -> Self {
Self {
conn: j.conn,
address: j.address,
last_action_tick: 0,
chat_index: 0,
placed_at: 0,
center_sent: None,
left_reason: String::new(),
uuid: j.uuid,
name: j.name,
entity_id,
+248 -27
View File
@@ -126,6 +126,54 @@ pub fn yellow_translation(key: &str, args: &[&str]) -> Tag {
t
}
/// Player.getDisplayName for a player in no team: the name, suggesting
/// `/tell NAME `, showing the player on hover and inserting the name.
pub fn display_name(uuid: u128, name: &str) -> Tag {
let words = [
(uuid >> 96) as i32,
(uuid >> 64) as i32,
(uuid >> 32) as i32,
uuid as i32,
];
Tag::compound([
("text", string(name)),
(
"click_event",
Tag::compound([
("action", string("suggest_command")),
("command", string(&format!("/tell {name} "))),
]),
),
(
"hover_event",
Tag::compound([
("action", string("show_entity")),
("id", string("minecraft:player")),
("uuid", Tag::IntArray(words.to_vec())),
("name", string(name)),
]),
),
("insertion", string(name)),
])
}
/// A yellow translation of player names (`multiplayer.player.joined`).
fn yellow_names(key: &str, names: Vec<Tag>) -> Tag {
Tag::compound([
("translate", string(key)),
("with", Tag::List(names)),
("color", string("yellow")),
])
}
/// ChunkTrackingView.contains: the chunks a player at (cx, cz) with view
/// distance `r` is sent (isWithinDistance with the neighbours' buffer).
fn tracked(cx: i32, cz: i32, r: i32, x: i32, z: i32) -> bool {
let dx = i64::from(((x - cx).abs() - 2).max(0));
let dz = i64::from(((z - cz).abs() - 2).max(0));
dx * dx + dz * dz < i64::from(r) * i64::from(r)
}
impl Hub {
pub fn new(lan: Lan, sync: Arc<SyncData>, encoder: ChunkEncoder, config: HubConfig) -> Self {
let chat_type = sync
@@ -214,19 +262,123 @@ impl Hub {
overlay: false,
}));
}
/// A chat message from `sender` (PlayerChatMessage as a disguised chat).
/// A chat message from the host (a disguised chat: the host has no
/// connection to sign with).
pub fn chat(&self, sender: &str, text: &str) {
self.broadcast(&self.chat_packet(sender, text));
}
fn chat_packet(&self, sender: &str, text: &str) -> C {
C::DisguisedChat(play::DisguisedChat {
self.broadcast(&C::DisguisedChat(play::DisguisedChat {
message: literal(text),
chat_type: play::ChatTypeBound {
chat_type: self.chat_type,
name: literal(sender),
target: None,
},
})
}));
}
/// ListPlayersCommand's reply: the players in join order (the host of a
/// LAN world first), as display names or names with ids, joined by
/// gray commas (ComponentUtils.formatList).
pub fn list_reply(&self, host: Option<(u128, &str)>, uuids: bool) -> Tag {
let players: Vec<(u128, &str)> = host
.into_iter()
.chain(
self.guests
.iter()
.filter(|g| g.placed)
.map(|g| (g.uuid, g.name.as_str())),
)
.collect();
let format = |(uuid, name): (u128, &str)| {
if uuids {
Tag::compound([
("translate", string("commands.list.nameAndId")),
(
"with",
Tag::List(vec![
string(name),
string(&horizon_protocol::crypto::uuid_string(uuid)),
]),
),
])
} else {
display_name(uuid, name)
}
};
let names = match players.len() {
0 => string(""),
1 => format(players[0]),
_ => {
let mut extra = Vec::new();
for (k, p) in players.iter().enumerate() {
if k > 0 {
extra.push(Tag::compound([
("text", string(", ")),
("color", string("gray")),
]));
}
extra.push(format(*p));
}
Tag::compound([("text", string("")), ("extra", Tag::List(extra))])
}
};
Tag::compound([
("translate", string("commands.list.players")),
(
"with",
Tag::List(vec![
Tag::Int(players.len() as i32),
Tag::Int(self.lan.shared.max_players() as i32),
names,
]),
),
])
}
/// SayCommand from a source without a player: a disguised chat of type
/// say_command named after the source.
pub fn say(&self, source: &str, text: &str) {
let chat_type = self
.sync
.id("minecraft:chat_type", "minecraft:say_command")
.unwrap_or(self.chat_type);
self.broadcast(&C::DisguisedChat(play::DisguisedChat {
message: literal(text),
chat_type: play::ChatTypeBound {
chat_type,
name: literal(source),
target: None,
},
}));
}
/// PlayerList.broadcastChatMessage of a guest's unsigned message
/// (PlayerChatMessage.unsigned): a ClientboundPlayerChatPacket to every
/// player, each connection numbering its messages.
pub fn player_chat(&mut self, from: usize, text: &str) {
let (uuid, name) = (self.guests[from].uuid, self.guests[from].name.clone());
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_millis() as i64);
let bound = play::ChatTypeBound {
chat_type: self.chat_type,
name: display_name(uuid, &name),
target: None,
};
for g in self.guests.iter_mut().filter(|g| g.placed) {
let packet = C::PlayerChat(play::PlayerChat {
global_index: g.chat_index,
sender: uuid,
index: 0,
signature: None,
content: text.to_owned(),
timestamp,
salt: 0,
last_seen: Vec::new(),
unsigned_content: None,
filter: (0, Vec::new()),
chat_type: bound.clone(),
});
g.chat_index += 1;
g.send(&packet);
}
}
/// Disconnect a guest with a reason (ServerGamePacketListenerImpl.disconnect).
@@ -275,6 +427,7 @@ impl Hub {
*ctx.next_entity += 1;
let conn = j.conn;
let mut guest = Guest::new(j, entity_id, ctx.spawn, self.config.view_distance);
guest.last_action_tick = self.ticks;
guest.game_mode = self.config.default_game_mode;
guest.permission = self.default_permission(guest.uuid);
guest.joined_tick = self.ticks;
@@ -356,7 +509,10 @@ impl Hub {
self.broadcast_except(
conn,
&C::SystemChat(play::SystemChat {
content: yellow_translation("multiplayer.player.joined", &[&name]),
content: yellow_names(
"multiplayer.player.joined",
vec![display_name(self.guests[i].uuid, &name)],
),
overlay: false,
}),
);
@@ -365,7 +521,7 @@ impl Hub {
let g = &self.guests[i];
g.send(&C::ServerData(play::ServerData {
motd: literal(&self.lan.shared.motd()),
icon: None,
icon: self.lan.shared.config.favicon.clone(),
}));
// The player list: everyone already here, then the newcomer to all.
let mut entries = Vec::new();
@@ -390,6 +546,15 @@ impl Hub {
};
self.broadcast(&C::PlayerInfoUpdate(newcomer));
self.send_level_info(i, ctx);
// ServerLevel.addNewPlayer: the chunk tracking starts at the player.
let g = &mut self.guests[i];
let (cx, cz) = g.chunk();
g.send(&C::SetChunkCacheCenter(play::SetChunkCacheCenter {
x: cx,
z: cz,
}));
g.center_sent = Some((cx, cz));
g.placed_at = self.ticks;
// ServerPlayer.sendPostEffects and initInventoryMenu.
self.guests[i].send(&raw(ids::POST_EFFECTS, vec![0]));
self.send_inventory(i);
@@ -409,9 +574,7 @@ impl Hub {
/// The permissions changed: tell everyone their level and commands again.
pub fn resend_commands(&mut self) {
for i in 0..self.guests.len() {
if !self.config.dedicated {
self.guests[i].permission = self.default_permission(self.guests[i].uuid);
}
self.guests[i].permission = self.default_permission(self.guests[i].uuid);
if self.guests[i].placed {
self.send_permission_level(i);
}
@@ -586,6 +749,20 @@ impl Hub {
g.inbox.push_back(*packet);
}
}
NetEvent::Duplicate(uuid) => {
let conns: Vec<u32> = self
.guests
.iter()
.filter(|g| g.uuid == uuid)
.map(|g| g.conn)
.collect();
for conn in conns {
self.kick(
conn,
translatable("multiplayer.disconnect.duplicate_login", &[]),
);
}
}
}
}
for i in 0..self.guests.len() {
@@ -639,7 +816,8 @@ impl Hub {
}
fn remove_guest(&mut self, i: usize, reason: &str) -> Guest {
let g = self.guests.remove(i);
let mut g = self.guests.remove(i);
g.left_reason = reason.to_owned();
if std::env::var_os("HORIZON_NET_DEBUG").is_some() {
eprintln!("[lan] {} left: {reason}", g.name);
}
@@ -652,7 +830,10 @@ impl Hub {
self.broadcast(&C::RemoveEntities(play::RemoveEntities {
ids: vec![g.entity_id],
}));
self.system_message(yellow_translation("multiplayer.player.left", &[&g.name]));
self.system_message(yellow_names(
"multiplayer.player.left",
vec![display_name(g.uuid, &g.name)],
));
g
}
@@ -729,27 +910,31 @@ impl Hub {
let g = &mut self.guests[i];
if g.center != Some((cx, cz)) {
g.center = Some((cx, cz));
g.send(&C::SetChunkCacheCenter(play::SetChunkCacheCenter {
x: cx,
z: cz,
}));
if g.center_sent.take() != Some((cx, cz)) {
g.send(&C::SetChunkCacheCenter(play::SetChunkCacheCenter {
x: cx,
z: cz,
}));
}
// Chunks that left the view.
let forget: Vec<_> = g
.sent_chunks
.iter()
.copied()
.filter(|&(x, z)| (x - cx).abs().max((z - cz).abs()) > r)
.filter(|&(x, z)| !tracked(cx, cz, r, x, z))
.collect();
for (x, z) in forget {
g.sent_chunks.remove(&(x, z));
g.send(&C::ForgetLevelChunk(play::ForgetLevelChunk { pos: [x, z] }));
}
g.chunk_queue
.retain(|&(x, z)| (x - cx).abs().max((z - cz).abs()) <= r);
for dz in -r..=r {
for dx in -r..=r {
g.chunk_queue.retain(|&(x, z)| tracked(cx, cz, r, x, z));
for dz in -r - 2..=r + 2 {
for dx in -r - 2..=r + 2 {
let key = (cx + dx, cz + dz);
if !g.sent_chunks.contains(&key) && !g.chunk_queue.contains(&key) {
if tracked(cx, cz, r, key.0, key.1)
&& !g.sent_chunks.contains(&key)
&& !g.chunk_queue.contains(&key)
{
g.chunk_queue.push(key);
}
}
@@ -758,7 +943,7 @@ impl Hub {
.sort_by_key(|&(x, z)| i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2));
}
// Send ready chunks, closest first, in batches.
if g.chunk_queue.is_empty() || g.unacknowledged >= 10 {
if g.chunk_queue.is_empty() || g.unacknowledged >= 10 || self.ticks <= g.placed_at + 1 {
return;
}
g.chunk_credit = (g.chunk_credit + g.chunks_per_tick).min(g.chunks_per_tick.max(1.0) * 2.0);
@@ -779,7 +964,7 @@ impl Hub {
continue;
}
packets.push(C::LevelChunkWithLight(
self.encoder.encode(chunk, &ctx.world.block_entities),
self.encoder.encode_in(chunk, ctx.world),
));
taken.push(idx);
}
@@ -806,7 +991,7 @@ impl Hub {
let Some(chunk) = world.chunks.get(&(x, z)) else {
return;
};
let packet = C::LevelChunkWithLight(self.encoder.encode(chunk, &world.block_entities));
let packet = C::LevelChunkWithLight(self.encoder.encode_in(chunk, world));
let body = packet.encode();
for g in self
.guests
@@ -1092,6 +1277,15 @@ impl Hub {
/// ServerPlayer.doTick: health, food, experience and the inventory menu.
fn sync_player_state(&mut self, i: usize) {
// ServerEntity.sendDirtyEntityData on the player's first tick: the
// health its creation set is still dirty, and goes to the player too.
if self.guests[i].sent_health.is_none() {
let g = &self.guests[i];
g.send(&C::SetEntityData(play::SetEntityData {
id: g.entity_id,
values: vec![(9, serializer::FLOAT, Value::Float(g.health))],
}));
}
let health = {
let g = &self.guests[i];
(g.health, g.food, g.saturation)
@@ -1142,6 +1336,13 @@ impl Hub {
// ---- incoming ------------------------------------------------------
/// The squared movement past 1.0E-5F (handlePlayerKnownMovement).
fn moved_far(&self, i: usize, to: [f64; 3]) -> bool {
let from = self.guests[i].position;
let d: f64 = (0..3).map(|k| (to[k] - from[k]).powi(2)).sum();
d > f64::from(1.0E-5_f32)
}
fn process_inbox(&mut self, i: usize, ctx: &mut TickCtx, events: &mut Vec<HostEvent>) {
let mut budget = 400;
while budget > 0 {
@@ -1150,6 +1351,26 @@ impl Hub {
};
budget -= 1;
let conn = self.guests[i].conn;
// ServerPlayer.resetLastActionTime: every handler of a player's
// own action resets it, movement only when it moved
// (handlePlayerKnownMovement), PlayerInput once loaded.
let acted = match &packet {
S::AcceptTeleportation(_)
| S::MovePlayerStatus(_)
| S::MovePlayerRot(_)
| S::PlayerLoaded(_)
| S::ChunkBatchReceived(_)
| S::ClientInformation(_)
| S::ClientTickEnd(_)
| S::KeepAlive(_) => false,
S::MovePlayerPos(p) => self.moved_far(i, [p.x, p.y, p.z]),
S::MovePlayerPosRot(p) => self.moved_far(i, [p.x, p.y, p.z]),
S::PlayerInput(_) => self.guests[i].loaded,
_ => true,
};
if acted {
self.guests[i].last_action_tick = self.ticks;
}
match packet {
S::AcceptTeleportation(p) => {
let g = &mut self.guests[i];
@@ -1202,7 +1423,7 @@ impl Hub {
let text: String = c.message.chars().filter(|c| !c.is_control()).collect();
if !text.is_empty() {
let name = self.guests[i].name.clone();
self.chat(&name, &text);
self.player_chat(i, &text);
events.push(HostEvent::Chat(format!("<{name}> {text}")));
}
}
+228 -29
View File
@@ -20,14 +20,17 @@ pub mod tracking;
pub use conn::PlayerSender;
use horizon_protocol::packets::play;
use horizon_protocol::{GAME_VERSION, PROTOCOL_VERSION, packets::configuration::ClientInformation};
use horizon_protocol::{
GAME_VERSION, PROTOCOL_VERSION, crypto::uuid_string, packets::configuration::ClientInformation,
text::translatable,
};
use std::{
collections::HashSet,
io,
net::{SocketAddr, TcpListener, TcpStream},
sync::{
Arc, Mutex,
atomic::{AtomicBool, AtomicI32, AtomicU32, Ordering},
atomic::{AtomicBool, AtomicI32, AtomicU32, AtomicUsize, Ordering},
mpsc::{Receiver, Sender, channel},
},
thread::JoinHandle,
@@ -44,6 +47,9 @@ pub enum NetEvent {
Packet(u32, Box<play::Serverbound>),
/// The connection ended (reason for the log).
Left(u32, String),
/// PlayerList.disconnectAllPlayersWithProfile: a new login of this
/// profile replaces the player already in the world.
Duplicate(u128),
}
pub struct Joined {
pub conn: u32,
@@ -54,6 +60,7 @@ pub struct Joined {
pub sender: PlayerSender,
/// Smoothed keep-alive round trip in milliseconds.
pub latency: Arc<AtomicI32>,
pub address: SocketAddr,
}
/// Queued for a connection's writer thread.
pub enum Out {
@@ -64,54 +71,232 @@ pub enum Out {
Close,
}
/// PlayerList.canPlayerLogin for a dedicated server: the disconnect reason
/// (bans, whitelist) for a profile connecting from an address, if refused.
pub type LoginGate =
Arc<dyn Fn(SocketAddr, u128, &str) -> Option<horizon_world::nbt::Tag> + Send + Sync>;
/// How the server side of the network behaves: an integrated server's LAN
/// uses the defaults, a dedicated server takes them from server.properties.
#[derive(Clone)]
pub struct NetConfig {
/// server-ip (all interfaces when absent).
pub bind: Option<std::net::IpAddr>,
/// 0 picks a free port.
pub port: u16,
pub motd: String,
pub max_players: usize,
/// network-compression-threshold; negative disables compression.
pub compression_threshold: i32,
/// enable-status: answer status pings.
pub enable_status: bool,
pub hide_online_players: bool,
/// server-icon.png (64x64 PNG bytes).
pub favicon: Option<Vec<u8>>,
/// MinecraftServer.enforceSecureProfile.
pub enforces_secure_chat: bool,
pub accepts_transfers: bool,
/// LanServerPinger: announce the world on the local network.
pub announce: bool,
/// Ops bypass a full server (ServerOpList.canBypassPlayerLimit).
pub bypasses_limit: Option<Arc<dyn Fn(u128) -> bool + Send + Sync>>,
pub gate: Option<LoginGate>,
}
impl NetConfig {
/// IntegratedServer.publishServer.
pub fn lan(port: u16, motd: String, max_players: usize) -> Self {
Self {
bind: None,
port,
motd,
max_players,
compression_threshold: 256,
enable_status: true,
hide_online_players: false,
favicon: None,
enforces_secure_chat: false,
accepts_transfers: false,
announce: true,
bypasses_limit: None,
gate: None,
}
}
}
/// State shared with the connection threads.
pub struct Shared {
pub sync: Arc<data::SyncData>,
pub events: Sender<NetEvent>,
pub config: NetConfig,
motd: Mutex<String>,
online: Mutex<HashSet<u128>>,
max_players: usize,
max_players: AtomicUsize,
/// PlayerList.players in join order: profile id and name.
online: Mutex<Vec<(u128, String)>>,
/// Profiles held by the host (the LAN host's own name).
reserved: Mutex<HashSet<u128>>,
next: AtomicU32,
stop: AtomicBool,
random: Mutex<u64>,
}
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");
/// PlayerList.canPlayerLogin then disconnectAllPlayersWithProfile: the
/// refusal reason, or None once the profile holds a place. A profile
/// already playing is kicked and its place awaited.
pub fn try_admit(
&self,
address: SocketAddr,
uuid: u128,
name: &str,
) -> Option<horizon_world::nbt::Tag> {
if let Some(gate) = &self.config.gate
&& let Some(reason) = gate(address, uuid, name)
{
return Some(reason);
}
if online.len() >= self.max_players {
return Some("multiplayer.disconnect.server_full");
if self.reserved.lock().unwrap().contains(&uuid) {
return Some(translatable("multiplayer.disconnect.duplicate_login", &[]));
}
online.insert(uuid);
{
let online = self.online.lock().unwrap();
let bypass = self.config.bypasses_limit.as_ref().is_some_and(|b| b(uuid));
let taken = online.len() + self.reserved.lock().unwrap().len();
if taken >= self.max_players() && !bypass {
return Some(translatable("multiplayer.disconnect.server_full", &[]));
}
}
if self.is_online(uuid) {
let _ = self.events.send(NetEvent::Duplicate(uuid));
let deadline = std::time::Instant::now() + Duration::from_secs(30);
while self.is_online(uuid) {
if std::time::Instant::now() > deadline {
return Some(translatable("multiplayer.disconnect.slow_login", &[]));
}
std::thread::sleep(Duration::from_millis(10));
}
}
self.online.lock().unwrap().push((uuid, name.to_owned()));
None
}
fn is_online(&self, uuid: u128) -> bool {
self.online.lock().unwrap().iter().any(|(u, _)| *u == uuid)
}
pub fn motd(&self) -> String {
self.motd.lock().unwrap().clone()
}
pub fn max_players(&self) -> usize {
self.max_players.load(Ordering::Relaxed)
}
pub fn set_max_players(&self, n: usize) {
self.max_players.store(n, Ordering::Relaxed);
}
pub fn release(&self, uuid: u128) {
self.online.lock().unwrap().remove(&uuid);
self.online.lock().unwrap().retain(|(u, _)| *u != uuid);
}
pub fn online(&self) -> usize {
self.online.lock().unwrap().len()
self.online.lock().unwrap().len() + self.reserved.lock().unwrap().len()
}
/// The status response (ServerStatus): version, players and the MOTD.
fn next_random(&self, bound: usize) -> usize {
let mut r = self.random.lock().unwrap();
*r = r
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1_442_695_040_888_963_407);
((*r >> 33) as usize) % bound.max(1)
}
/// The status response (MinecraftServer.buildServerStatus encoded with
/// ServerStatus.CODEC): description, players with up to 12 shuffled
/// names, version, favicon and enforcesSecureChat when true.
pub fn status_json(&self) -> String {
use crate::server::json::Json;
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()
let online: Vec<(u128, String)> = self.online.lock().unwrap().clone();
let count = self.online();
let mut players = vec![
(
"max".to_owned(),
Json::Number(self.max_players().to_string()),
),
("online".to_owned(), Json::Number(count.to_string())),
];
if !self.config.hide_online_players && !online.is_empty() {
let size = online.len().min(12);
let offset = self.next_random(online.len() - size + 1);
let mut sample: Vec<(u128, String)> = online[offset..offset + size].to_vec();
for i in (1..sample.len()).rev() {
let j = self.next_random(i + 1);
sample.swap(i, j);
}
players.push((
"sample".to_owned(),
Json::Array(
sample
.into_iter()
.map(|(u, n)| {
Json::Object(vec![
("id".to_owned(), Json::String(uuid_string(u))),
("name".to_owned(), Json::String(n)),
])
})
.collect(),
),
));
}
let mut status = vec![
("description".to_owned(), Json::String(motd)),
("players".to_owned(), Json::Object(players)),
(
"version".to_owned(),
Json::Object(vec![
("name".to_owned(), Json::String(GAME_VERSION.to_owned())),
(
"protocol".to_owned(),
Json::Number(PROTOCOL_VERSION.to_string()),
),
]),
),
];
if let Some(icon) = &self.config.favicon {
status.push((
"favicon".to_owned(),
Json::String(format!("data:image/png;base64,{}", base64(icon))),
));
}
if self.config.enforces_secure_chat {
status.push(("enforcesSecureChat".to_owned(), Json::Bool(true)));
}
Json::Object(status).compact()
}
}
/// java.util.Base64.getEncoder (padded, no line breaks).
pub fn base64(data: &[u8]) -> String {
const A: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
for chunk in data.chunks(3) {
let b = [
chunk[0],
*chunk.get(1).unwrap_or(&0),
*chunk.get(2).unwrap_or(&0),
];
let n = u32::from(b[0]) << 16 | u32::from(b[1]) << 8 | u32::from(b[2]);
out.push(char::from(A[(n >> 18) as usize & 63]));
out.push(char::from(A[(n >> 12) as usize & 63]));
out.push(if chunk.len() > 1 {
char::from(A[(n >> 6) as usize & 63])
} else {
'='
});
out.push(if chunk.len() > 2 {
char::from(A[n as usize & 63])
} else {
'='
});
}
out
}
/// A running LAN server.
pub struct Lan {
pub shared: Arc<Shared>,
@@ -129,19 +314,33 @@ impl Lan {
motd: String,
max_players: usize,
) -> io::Result<Self> {
let listener = TcpListener::bind(("0.0.0.0", port))?;
Self::start_with(sync, NetConfig::lan(port, motd, max_players))
}
/// ServerConnectionListener.startTcpServerListener with a configuration.
pub fn start_with(sync: Arc<data::SyncData>, config: NetConfig) -> io::Result<Self> {
let bind = config
.bind
.unwrap_or(std::net::IpAddr::V4(std::net::Ipv4Addr::UNSPECIFIED));
let listener = TcpListener::bind((bind, config.port))?;
listener.set_nonblocking(true)?;
let port = listener.local_addr()?.port();
let _pinger = discovery::Pinger::start(motd.clone(), port).ok();
let _pinger = if config.announce {
discovery::Pinger::start(config.motd.clone(), port).ok()
} else {
None
};
let (tx, events) = channel();
let shared = Arc::new(Shared {
sync,
events: tx,
motd: Mutex::new(motd),
online: Mutex::new(HashSet::new()),
max_players,
motd: Mutex::new(config.motd.clone()),
max_players: AtomicUsize::new(config.max_players),
online: Mutex::new(Vec::new()),
reserved: Mutex::new(HashSet::new()),
next: AtomicU32::new(1),
stop: AtomicBool::new(false),
random: Mutex::new(crate::server::java_properties::now_millis() as u64 | 1),
config,
});
let accept_shared = shared.clone();
let listener = std::thread::Builder::new()
@@ -161,7 +360,7 @@ impl Lan {
}
/// 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);
self.shared.reserved.lock().unwrap().insert(uuid);
}
pub fn set_motd(&self, motd: &str) {
*self.shared.motd.lock().unwrap() = motd.to_owned();
@@ -198,7 +397,7 @@ fn accept_loop(listener: TcpListener, shared: Arc<Shared>) {
}
fn handle(stream: TcpStream, addr: SocketAddr, shared: Arc<Shared>) {
let _ = stream.set_nonblocking(false);
if let Err(e) = conn::serve(stream, shared)
if let Err(e) = conn::serve(stream, addr, shared)
&& std::env::var_os("HORIZON_NET_DEBUG").is_some()
{
eprintln!("[lan] {addr}: {e}");
+130 -6
View File
@@ -25,6 +25,7 @@ pub mod drops;
pub mod enderman;
pub mod equine;
pub mod farm;
pub mod finalize;
pub mod gear;
pub mod goals;
pub mod golem;
@@ -205,6 +206,8 @@ pub struct MobType {
pub armor_toughness: f32,
pub knockback_resistance: f64,
pub jump_strength: f64,
/// Every default attribute value of the type (`entity-types.json`).
pub attributes: Arc<HashMap<String, f64>>,
pub gravity: f64,
pub safe_fall_distance: f64,
pub fall_damage_multiplier: f64,
@@ -238,12 +241,35 @@ impl MobType {
self.layers.get(key)
}
}
/// Each type's default attribute values, parsed exactly (serde_json's
/// default float parsing can miss the nearest double by one ulp).
fn exact_attributes(bytes: &[u8]) -> HashMap<String, HashMap<String, f64>> {
use serde_json::value::RawValue;
type Raw = HashMap<String, Box<RawValue>>;
let Ok(types) = serde_json::from_slice::<Raw>(bytes) else {
return HashMap::new();
};
types
.into_iter()
.filter_map(|(id, t)| {
let t: Raw = serde_json::from_str(t.get()).ok()?;
let attrs: Raw = serde_json::from_str(t.get("attributes")?.get()).ok()?;
let values = attrs
.into_iter()
.filter_map(|(k, v)| v.get().trim().parse::<f64>().ok().map(|v| (k, v)))
.collect();
Some((id, values))
})
.collect()
}
pub struct MobTypes {
pub types: HashMap<String, MobType>,
}
impl MobTypes {
pub fn load(root: &Path) -> crate::Result<Self> {
let types: Value = serde_json::from_slice(&fs::read(root.join("entity-types.json"))?)?;
let bytes = fs::read(root.join("entity-types.json"))?;
let types: Value = serde_json::from_slice(&bytes)?;
let exact = exact_attributes(&bytes);
let models: Value = serde_json::from_slice(&fs::read(root.join("entity-models.json"))?)?;
let item_tags = crate::items::load_tags(root, "item").unwrap_or_default();
sulfur_cube::load_archetype_items(&item_tags);
@@ -268,7 +294,8 @@ impl MobTypes {
let Some(model) = models.get(&model_key) else {
continue;
};
let attr = |k: &str| t["attributes"][format!("minecraft:{k}")].as_f64();
let defaults = exact.get(&id).cloned().unwrap_or_default();
let attr = |k: &str| defaults.get(&format!("minecraft:{k}")).copied();
let mut layers = HashMap::new();
if let Some(all) = models.as_object() {
for prefix in def.layer_prefixes() {
@@ -302,6 +329,7 @@ impl MobTypes {
armor_toughness: attr("armor_toughness").unwrap_or(0.0) as f32,
knockback_resistance: attr("knockback_resistance").unwrap_or(0.0),
jump_strength: attr("jump_strength").unwrap_or(0.42),
attributes: Arc::new(defaults.clone()),
gravity: attr("gravity").unwrap_or(0.08),
safe_fall_distance: attr("safe_fall_distance").unwrap_or(3.0),
fall_damage_multiplier: attr("fall_damage_multiplier").unwrap_or(1.0),
@@ -461,6 +489,9 @@ pub struct Attrs {
pub attack_damage: f32,
pub max_health: f32,
pub follow_range: f64,
pub knockback_resistance: f64,
pub spawn_reinforcements: f64,
pub jump_strength: f64,
}
/// Species-specific persistent state (variants, colours, taming, ageing...).
#[derive(Clone, Debug, Default)]
@@ -561,6 +592,24 @@ pub struct Extra {
/// `Mob.dropChances` by `EquipmentSlot` (`drops::SLOTS` order) when set
/// explicitly; None uses the defaults of `drops::drop_chance`.
pub drop_chances: Option<Box<[f32; 8]>>,
/// `Mob.leftHanded`.
pub left_handed: bool,
/// The sound variant: index in the species' `*_sound_variant` registry.
pub sound_variant: u8,
/// `Zombie.canBreakDoors`.
pub can_break_doors: bool,
/// A goat's `IsScreamingGoat` and the horns it lost (left, right).
pub screaming: bool,
pub lost_horns: [bool; 2],
/// Attribute bases and permanent modifiers set by `finalizeSpawn`.
pub attributes: Option<Box<finalize::Attributes>>,
/// Brain memories `finalizeSpawn` sets: (memory, value, ticks to expiry).
pub memories: Vec<(&'static str, i64, i64)>,
/// A camel's `LAST_POSE_CHANGE_TICK`.
pub pose_change_tick: i64,
/// The school leader a fish follows, and a tropical fish that swims alone.
pub leader: Option<u32>,
pub lone: bool,
/// A breeze's or creaking's brain (`monster_brain`).
pub brain: Option<Box<monster_brain::Brain>>,
}
@@ -798,10 +847,14 @@ pub enum MobEvent {
mob: u32,
other: u32,
},
/// Two villagers make a baby.
/// Two villagers make a baby (`VillagerMakeLove.tryToGiveBirth`): the
/// parent has eaten and, with a bed for the child, rests; the partner
/// eats, and rests too if `child` holds the child's bed and type
/// (`None`: the biome's).
VillagerBirth {
parent: u32,
partner: u32,
child: Option<([i32; 3], Option<u8>)>,
},
/// A villager asks whether enough neighbours want an iron golem.
GolemCheck {
@@ -936,11 +989,65 @@ pub struct Seen {
/// `render::PROFESSIONS`), a llama's strength. And a villager's experience.
pub profession: u8,
pub xp: i32,
/// What other villagers read of a villager's state and brain.
pub villager: Option<Arc<villager::Seen>>,
/// `MAX_HEALTH`, `JUMP_STRENGTH` and `MOVEMENT_SPEED` base values (a
/// horse's breeding stock).
pub stats: [f64; 3],
}
impl Mob {
/// What other mobs see of this one this tick (`player`: the player's
/// UUID, which villagers' reputation is keyed by).
pub fn seen(&self, player: Option<[i32; 4]>) -> Seen {
let m = self;
let villager = m.species() == Species::Villager;
Seen {
id: m.id,
species: m.species(),
position: m.position,
bounds: m.bounds(),
eye_y: m.eye_y(),
alive: m.alive(),
baby: m.is_baby(),
// A villager is "in love" when it is willing to breed (`canBreed`).
in_love: if villager {
villager::can_breed(m)
} else {
m.extra.in_love > 0
},
tame: m.extra.tame,
hostile: m.hostile(),
target: m.ai.target,
health: m.health,
variant: m.extra.variant,
color: m.extra.color,
job: villager.then_some(m.extra.home).flatten(),
bed: villager.then_some(m.extra.bed).flatten(),
yaw: m.yaw,
velocity: m.velocity,
leash: m.extra.leash,
caravan: caravan::head_of(m),
delay: m.extra.ints[5],
hurt_by: m.ai.last_hurt_by.map(|w| (w, m.ai.last_hurt_by_time)),
active_raid: raider::has_active_raid(m),
player_rep: match (villager, player) {
(true, Some(uuid)) => villager::ext(m).map_or(0, |e| e.gossips.reputation(uuid)),
_ => 0,
},
pushable: m.pushable(),
category: m.category(),
potential_job: villager_brain::potential_job_site(m),
meeting: villager.then_some(m.extra.meeting).flatten(),
profession: m.extra.variant2,
xp: villager::xp(m),
villager: villager.then(|| Arc::new(villager::seen(m))),
stats: [
f64::from(m.attrs.max_health),
m.extra.vector[0],
m.attrs.speed,
],
}
}
/// `EntityType.getCategory`'s name.
pub fn category(&self) -> &'static str {
match self.kind.category.as_str() {
@@ -1000,6 +1107,7 @@ pub fn apply_brain_events(mobs: &mut [Mob], events: &mut Vec<MobEvent>, from: us
MobEvent::LockGaze { mob, partner } => {
if let Some(m) = mobs.iter_mut().find(|m| m.id == mob) {
animal_brain::lock_gaze(m, partner);
villager_brain::lock_gaze_half(m, Who::Mob(partner));
}
events.remove(i);
}
@@ -1156,17 +1264,24 @@ impl Mob {
attack_damage: kind.attack_damage,
max_health: kind.max_health,
follow_range: kind.follow_range,
knockback_resistance: kind.knockback_resistance,
spawn_reinforcements: kind
.attributes
.get("minecraft:spawn_reinforcements")
.copied()
.unwrap_or(0.0),
jump_strength: kind.jump_strength,
},
kind,
};
// setCanPickUpLoot(true) in the Villager, AbstractPiglin, Allay,
// Dolphin, Fox and Panda constructors.
// setCanPickUpLoot(true) in the Villager, AbstractPiglin, Dolphin,
// Fox and Panda constructors (an allay's is false until it holds
// something: it overrides canPickUpLoot).
mob.extra.pick_up_loot = matches!(
mob.species(),
Species::Villager
| Species::Piglin
| Species::PiglinBrute
| Species::Allay
| Species::Dolphin
| Species::Fox
| Species::Panda
@@ -1174,6 +1289,15 @@ impl Mob {
ai::register(&mut mob);
mob
}
/// `Mob.canPickUpLoot`, with the overrides: an allay that holds
/// something off its pickup cooldown, a sulfur cube with no block.
pub fn can_pick_up_loot(&self) -> bool {
match self.species() {
Species::Allay => self.extra.main_hand.is_some() && self.extra.ints[3] <= 0,
Species::SulfurCube => !sulfur_cube::has_body(self),
_ => self.extra.pick_up_loot,
}
}
pub fn bounds(&self) -> Aabb {
let w = f64::from(self.width()) / 2.0;
Aabb::new(
+7 -4
View File
@@ -895,11 +895,14 @@ fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool {
|| super::nautilus::is_nautilus(m.species()) && m.extra.tame
|| m.species() == Species::SulfurCube
&& (super::sulfur_cube::has_body(m) || m.extra.scratch[3] != 0);
// removeWhenFarAway: animals, wardens, patrols and raiders, zombie
// villagers being cured and ridden mobs stay.
// removeWhenFarAway: animals, wardens, allays, patrols and raiders,
// zombie villagers being cured and ridden mobs stay; the wither's
// checkDespawn never removes it for distance.
let creature = m.kind.category == "creature";
let removable = !(m.species() == Species::Warden
|| creature && m.kind.flags.animal && !m.extra.jockey
let removable = !(matches!(
m.species(),
Species::Warden | Species::Allay | Species::Wither
) || creature && m.kind.flags.animal && !m.extra.jockey
|| super::raider::keeps_alive(m, d)
|| super::zombie_villager::keeps_alive(m)
|| super::riders::keeps_alive(m));
-1
View File
@@ -27,7 +27,6 @@ pub fn register(m: &mut Mob) {
m.ai.nav.kind = NavKind::Flying;
// FlyingPathNavigation.setRequiredPathLength(48).
m.ai.nav.required_path_length = 48.0;
m.persistent = true;
let g = &mut m.ai.goals;
g.add(0, Panic::new(2.5));
g.add(1, Fetch);
+29 -26
View File
@@ -445,35 +445,38 @@ impl Goal for PufferfishPuff {
}
}
/// finalizeSpawn variants (tropical fish patterns and colours).
/// TropicalFish.COMMON_VARIANTS: (pattern index, base colour, pattern colour).
pub const COMMON_TROPICAL: [(u8, u8, u8); 22] = [
(7, 1, 7),
(6, 7, 7),
(6, 7, 11),
(11, 0, 7),
(1, 11, 7),
(0, 1, 0),
(5, 6, 3),
(9, 10, 4),
(11, 0, 14),
(5, 0, 4),
(8, 0, 7),
(11, 0, 1),
(3, 9, 6),
(4, 5, 3),
(10, 14, 0),
(2, 7, 14),
(9, 14, 0),
(6, 0, 4),
(0, 14, 0),
(1, 7, 0),
(3, 9, 4),
(6, 4, 4),
];
pub fn finalize(m: &mut Mob) {
if m.species() == Species::TropicalFish {
// TropicalFish.COMMON_VARIANTS: (pattern index, base colour, pattern colour).
const COMMON: [(u8, u8, u8); 22] = [
(7, 1, 7),
(6, 7, 7),
(6, 7, 11),
(11, 0, 7),
(1, 11, 7),
(0, 1, 0),
(5, 6, 3),
(9, 10, 4),
(11, 0, 14),
(5, 0, 4),
(8, 0, 7),
(11, 0, 1),
(3, 9, 6),
(4, 5, 3),
(10, 14, 0),
(2, 7, 14),
(9, 14, 0),
(6, 0, 4),
(0, 14, 0),
(1, 7, 0),
(3, 9, 4),
(6, 4, 4),
];
let (p, b, c) = if m.random.next_float() < 0.9 {
COMMON[m.random.next_int_bound(COMMON.len() as i32).unwrap_or(0) as usize]
COMMON_TROPICAL[m
.random
.next_int_bound(COMMON_TROPICAL.len() as i32)
.unwrap_or(0) as usize]
} else {
(
m.random.next_int_bound(12).unwrap_or(0) as u8,
File diff suppressed because it is too large Load Diff
+97 -2
View File
@@ -132,6 +132,38 @@ impl MobWorld<'_> {
.map(|shape| shape.boxes().iter().map(|b| b.move_by(offset)).collect())
.unwrap_or_default()
}
/// `Level.findSupportingBlock`: of the blocks whose collision shape
/// meets `area`, the one whose centre is nearest `from` (ties: the
/// greatest by `Vec3i.compareTo`, y then z then x).
pub fn supporting_block(&self, area: Aabb, from: Vec3) -> Option<[i32; 3]> {
use horizon_core::geometry::Axis;
let range = |axis| {
(area.min(axis) - 1.0e-7).floor() as i32 - 1
..=(area.max(axis) + 1.0e-7).floor() as i32 + 1
};
let mut best: Option<(f64, [i32; 3])> = None;
for y in range(Axis::Y) {
for z in range(Axis::Z) {
for x in range(Axis::X) {
if !self
.block_collision_boxes(x, y, z)
.iter()
.any(|b| b.intersects(area))
{
continue;
}
let d = (f64::from(x) + 0.5 - from.x).powi(2)
+ (f64::from(y) + 0.5 - from.y).powi(2)
+ (f64::from(z) + 0.5 - from.z).powi(2);
let greater = |b: [i32; 3]| (y, z, x) > (b[1], b[2], b[0]);
if best.is_none_or(|(bd, b)| d < bd || d == bd && greater(b)) {
best = Some((d, [x, y, z]));
}
}
}
}
best.map(|(_, p)| p)
}
pub fn no_collision(&self, b: Aabb) -> bool {
let mut scene = SceneCollisions {
world: self.world,
@@ -346,7 +378,8 @@ impl Mob {
let full = (moved.length() * f64::from(0.6_f32)) as f32;
let horizontal =
((moved.x * moved.x + moved.z * moved.z).sqrt() * f64::from(0.6_f32)) as f32;
let on = self.on_pos(1.0e-5);
let supporting = self.supporting_block(w, moved);
let on = self.supported_on_pos(w, supporting, 1.0e-5);
let state = w.world.block(on[0], on[1], on[2]);
let climbable = w.facts.get(state).name.as_ref() == "minecraft:powder_snow"
|| w.has_tag("minecraft:climbable", &w.facts.get(state).name);
@@ -354,7 +387,7 @@ impl Mob {
steps.move_dist += if climbable { full } else { horizontal };
steps.fly_dist += full;
if steps.move_dist > steps.next_step && !w.facts.is_air(state) {
let legacy = self.on_pos(0.2);
let legacy = self.supported_on_pos(w, supporting, 0.2);
let legacy_state = w.world.block(legacy[0], legacy[1], legacy[2]);
let produced = !w.facts.is_air(legacy_state)
&& (self.on_ground || climbable)
@@ -397,6 +430,68 @@ impl Mob {
fn fluids_swimming(&self) -> bool {
false
}
/// `Entity.checkSupportingBlock` after a move: on the ground, the block
/// under the feet (`mainSupportingBlockPos`), looked for again where
/// the mob came from if none is under it now.
fn supporting_block(&self, w: &MobWorld, moved: Vec3) -> Option<[i32; 3]> {
if !self.on_ground {
return None;
}
let b = self.bounds();
use horizon_core::geometry::Axis;
let area = Aabb::new(
Vec3::new(b.min(Axis::X), b.min(Axis::Y) - 1.0e-6, b.min(Axis::Z)),
Vec3::new(b.max(Axis::X), b.min(Axis::Y), b.max(Axis::Z)),
);
w.supporting_block(area, self.position).or_else(|| {
let back = Vec3::new(-moved.x, 0.0, -moved.z);
let shifted = Aabb::new(
Vec3::new(
area.min(Axis::X) + back.x,
area.min(Axis::Y),
area.min(Axis::Z) + back.z,
),
Vec3::new(
area.max(Axis::X) + back.x,
area.max(Axis::Y),
area.max(Axis::Z) + back.z,
),
);
w.supporting_block(shifted, self.position)
})
}
/// `Entity.getOnPos(offset)` with a supporting block: its column (its
/// own position for fences, walls and gates up to half a block down).
fn supported_on_pos(
&self,
w: &MobWorld,
supporting: Option<[i32; 3]>,
offset: f32,
) -> [i32; 3] {
let Some(p) = supporting else {
return self.on_pos(offset);
};
if offset <= 1.0e-5 {
return p;
}
let name = &w.facts.get(w.world.block(p[0], p[1], p[2])).name;
let tall = [
"minecraft:fences",
"minecraft:walls",
"minecraft:fence_gates",
]
.iter()
.any(|t| w.has_tag(t, name));
if offset <= 0.5 && tall {
p
} else {
[
p[0],
(self.position.y - f64::from(offset)).floor() as i32,
p[2],
]
}
}
/// Entity.getOnPos(offset) without a supporting block record.
pub fn on_pos(&self, offset: f32) -> [i32; 3] {
[
+138
View File
@@ -496,6 +496,144 @@ impl Ext {
now < self.last_gossip_time || now >= self.last_gossip_time + 1200
}
}
/// What a villager ticking later reads of another one this tick (vanilla
/// reads the other villager itself).
#[derive(Clone, Debug, Default)]
pub struct Seen {
pub gossips: crate::gossip::Gossips,
pub last_gossip_time: i64,
/// `countFoodPointsInInventory`.
pub food_points: i32,
/// The `INTERACTION_TARGET` memory (play tag's chases).
pub interaction_target: Option<super::Who>,
/// The `PATH` memory, when not done: its previous and next nodes.
pub path_nodes: Option<(Option<[i32; 3]>, [i32; 3])>,
/// `LAST_SLEPT` and whether `GOLEM_DETECTED_RECENTLY` is remembered.
pub last_slept: Option<i64>,
pub golem_detected: bool,
}
impl Seen {
/// `Villager.wantsToSpawnGolem`.
pub fn wants_golem(&self, now: i64) -> bool {
self.last_slept.is_some_and(|t| now - t < 24000) && !self.golem_detected
}
/// `Villager.wantsMoreFood`.
pub fn wants_more_food(&self) -> bool {
self.food_points < 12
}
}
pub fn seen(m: &Mob) -> Seen {
let e = ext(m);
let (interaction_target, path_nodes, golem_detected, last_slept) =
super::villager_brain::seen_memories(m);
Seen {
gossips: e.map(|e| e.gossips.clone()).unwrap_or_default(),
last_gossip_time: e.map_or(0, |e| e.last_gossip_time),
food_points: e.map_or(0, Ext::food_in_inventory),
interaction_target,
path_nodes,
last_slept: last_slept.or(e.and_then(|e| e.last_slept)),
golem_detected,
}
}
/// What `TradeWithVillager.tick` hands over: stacks tossed from the first
/// villager's hand (`from`, its eye height) toward the second (`to`), and
/// whether the gossip happened (`spawnGolemIfNeeded` follows).
pub struct Meeting {
pub thrown: Vec<ItemStack>,
pub from: horizon_core::geometry::Vec3,
pub eye: f64,
pub to: horizon_core::geometry::Vec3,
pub gossiped: bool,
}
/// `TradeWithVillager.tick` for villagers `a` and `b` (indices into `mobs`):
/// `Villager.gossip` (at most once in 1200 ticks for both), then surplus
/// food and wanted wares taken out of `a`'s inventory.
pub fn meet(
mobs: &mut [Mob],
a: usize,
b: usize,
now: i64,
max_stack: impl Fn(&str) -> u32,
) -> Meeting {
let ready = ext(&mobs[a]).is_none_or(|e| e.can_gossip(now))
&& ext(&mobs[b]).is_none_or(|e| e.can_gossip(now));
if ready {
let source = ext(&mobs[b]).map(|e| e.gossips.clone()).unwrap_or_default();
let me = &mut mobs[a];
let mut random = me.random.clone();
let e = ext_mut(me);
e.gossips.transfer_from(&source, &mut random, 10);
e.last_gossip_time = now;
me.random = random;
ext_mut(&mut mobs[b]).last_gossip_time = now;
}
// Surplus food goes to a hungry neighbour (farmers hand it to anyone).
let farmer = is_farmer(&mobs[a]);
let wants_more = ext(&mobs[b]).is_none_or(Ext::wants_more_food);
let excess = ext(&mobs[a]).is_some_and(Ext::has_excess_food);
let mut thrown = Vec::new();
if excess
&& (farmer || wants_more)
&& let Some(s) =
ext_mut(&mut mobs[a]).take_half_stack(|s| food_points(&s.item) > 0, &max_stack)
{
thrown.push(s);
}
// A farmer's wheat.
if farmer
&& ext(&mobs[a]).is_some_and(|e| e.count_item("minecraft:wheat") > 32)
&& let Some(s) =
ext_mut(&mut mobs[a]).take_half_stack(|s| &*s.item == "minecraft:wheat", &max_stack)
{
thrown.push(s);
}
// Wares the neighbour's profession asks for and ours does not.
let theirs = requested_items(&mobs[b]);
let mine = requested_items(&mobs[a]);
let wanted: Vec<&str> = theirs
.iter()
.copied()
.filter(|i| !mine.contains(i))
.collect();
if !wanted.is_empty()
&& let Some(s) =
ext_mut(&mut mobs[a]).take_half_stack(|s| wanted.contains(&&*s.item), &max_stack)
{
thrown.push(s);
}
Meeting {
thrown,
from: mobs[a].position,
eye: mobs[a].eye_y(),
to: mobs[b].position,
gossiped: ready,
}
}
/// `PoiManager.take(HOME, ..., 48)`: the nearest bed head not `claimed`
/// (`free_head`: a bed head that is not occupied).
pub fn take_vacant_bed(
claimed: &[[i32; 3]],
from: [i32; 3],
mut free_head: impl FnMut(i32, i32, i32) -> bool,
) -> Option<[i32; 3]> {
let mut best: Option<(i32, [i32; 3])> = None;
for y in from[1] - 8..=from[1] + 8 {
for z in from[2] - 48..=from[2] + 48 {
for x in from[0] - 48..=from[0] + 48 {
let d = (x - from[0]).pow(2) + (y - from[1]).pow(2) + (z - from[2]).pow(2);
if d <= 48 * 48
&& best.is_none_or(|(b, _)| d < b)
&& free_head(x, y, z)
&& !claimed.contains(&[x, y, z])
{
best = Some((d, [x, y, z]));
}
}
}
}
best.map(|(_, p)| p)
}
/// `Villager.canBreed`: enough food, awake and an adult.
pub fn can_breed(m: &Mob) -> bool {
m.species() == Species::Villager
@@ -663,7 +663,7 @@ fn sense_bed(m: &mut Mob, w: &MobWorld, lr: &mut LegacyRandom) {
let mut cache = std::mem::take(&mut brain_mut(m).bed_cache);
let mut tried = 0;
let mut targets = Vec::new();
for p in homes {
for &p in &homes {
if cache.iter().any(|(q, _)| *q == p) {
continue;
}
@@ -679,8 +679,12 @@ fn sense_bed(m: &mut Mob, w: &MobWorld, lr: &mut LegacyRandom) {
} else {
m.create_path_to_any(w, &targets, 1)
};
// createPath hands back the current path when it still heads for a
// target position it was asked: only a bed (a POI) counts.
if let Some(path) = path.filter(|p| p.reached) {
mem(m).nearest_bed.set(path.target);
if homes.contains(&path.target) {
mem(m).nearest_bed.set(path.target);
}
} else if tried < 5 {
cache.retain(|(_, until)| *until >= last_update);
}
@@ -1609,13 +1613,7 @@ impl B {
}
t.begin(cx);
let target = mem(m).interaction_target.value().unwrap();
let mm = mem(m);
mm.look_target.set(Tracker::Entity(target, true));
mm.walk_target.set(WalkTarget {
target: Tracker::Entity(target, true),
speed: 0.5,
close: 2,
});
lock_gaze(m, target, cx);
true
}
B::MakeLove { t, birth } => {
@@ -1628,7 +1626,7 @@ impl B {
}
t.begin(cx);
let target = mem(m).breed_target.value().unwrap();
lock_gaze(m, target);
lock_gaze(m, target, cx);
*birth = now + 275 + i64::from(m.random.next_int_bound(50).unwrap_or(0));
true
}
@@ -2853,6 +2851,7 @@ impl B {
&& i.position.distance_squared(m.position) <= 5.0
{
let Who::Mob(other) = target else { return };
lock_gaze(m, target, cx);
cx.events.push(MobEvent::VillagerMeet { mob: m.id, other });
}
}
@@ -2870,11 +2869,29 @@ impl B {
.target_info(target)
.is_some_and(|t| t.position.distance_squared(m.position) <= 5.0)
{
lock_gaze(m, target);
lock_gaze(m, target, cx);
if now >= *birth {
// The parent's half happens in its own tick: it eats,
// takes a bed for the child, picks its type and rests.
super::villager::ext_mut(m).eat_and_digest();
let child = take_bed_for_child(m, cx.w).map(|bed| {
// Villager.getBreedOffspring: half the biome's type,
// a quarter each parent's.
let roll = m.random.next_double();
let variant = if roll < 0.5 {
None
} else if roll < 0.75 {
Some(m.extra.variant)
} else {
Some(cx.w.seen(partner).map_or(m.extra.variant, |s| s.variant))
};
m.extra.age = 6000;
(bed, variant)
});
cx.events.push(MobEvent::VillagerBirth {
parent: m.id,
partner,
child,
});
} else if m.random.next_int_bound(35).unwrap_or(1) == 0 {
let mut p = vec![m.position];
@@ -3366,8 +3383,38 @@ fn breeding_possible(m: &mut Mob, w: &MobWorld) -> bool {
&& super::villager::can_breed(m)
&& w.seen(id).is_some_and(|s| s.in_love)
}
/// `BehaviorUtils.lockGazeAndWalkToEachOther`, this villager's half.
fn lock_gaze(m: &mut Mob, target: Who) {
/// `VillagerMakeLove.takeVacantBed`: a bed head no villager has claimed.
fn take_bed_for_child(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
let claimed: Vec<[i32; 3]> = w
.others
.iter()
.filter(|s| s.species == Species::Villager && s.id != m.id)
.filter_map(|s| s.bed)
.chain(m.extra.bed)
.collect();
let p = m.position;
let from = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
super::villager::take_vacant_bed(&claimed, from, |x, y, z| {
w.prop(x, y, z, "part") == Some("head") && w.prop(x, y, z, "occupied") != Some("true")
})
}
/// `BehaviorUtils.lockGazeAndWalkToEachOther`: this villager's half, and
/// the other villager's through a `LockGaze` event.
fn lock_gaze(m: &mut Mob, target: Who, cx: &mut Bx) {
lock_gaze_half(m, target);
if let Who::Mob(other) = target {
cx.events.push(MobEvent::LockGaze {
mob: other,
partner: m.id,
});
}
}
/// One villager's half of `lockGazeAndWalkToEachOther`: look at the other
/// and walk to it.
pub fn lock_gaze_half(m: &mut Mob, target: Who) {
if super::villager::ext(m).is_none_or(|e| e.brain.is_none()) {
return;
}
let mm = mem(m);
mm.look_target.set(Tracker::Entity(target, true));
mm.walk_target.set(WalkTarget {
@@ -4080,3 +4127,34 @@ pub fn potential_job_site(m: &Mob) -> Option<[i32; 3]> {
pub fn seen_can_breed(s: &Seen) -> bool {
s.species == Species::Villager && s.in_love
}
/// The memories other villagers read: the interaction target, the path's
/// nodes (while it is not done), whether a golem was seen lately and the
/// last sleep.
#[allow(clippy::type_complexity)]
pub fn seen_memories(
m: &Mob,
) -> (
Option<Who>,
Option<(Option<[i32; 3]>, [i32; 3])>,
bool,
Option<i64>,
) {
let Some(mm) = mem_ref(m) else {
return (None, None, false, None);
};
let path = mm
.path
.present()
.then_some(m.ai.nav.path.as_ref())
.flatten();
let nodes = path.filter(|p| !p.is_done()).map(|p| {
let n = |i: usize| [p.nodes[i].x, p.nodes[i].y, p.nodes[i].z];
((p.next > 0).then(|| n(p.next - 1)), n(p.next))
});
(
mm.interaction_target.value(),
nodes,
mm.golem_detected_recently.present(),
mm.last_slept.value(),
)
}
-1
View File
@@ -28,7 +28,6 @@ pub fn register(m: &mut Mob) {
hovers: false,
};
m.ai.nav.kind = NavKind::Flying;
m.persistent = true;
let g = &mut m.ai.goals;
g.add(0, DoNothing);
g.add(
+26
View File
@@ -639,6 +639,32 @@ fn heightmaps(chunk: &Chunk, tables: &SaveTables) -> Tag {
)
}))
}
/// The heightmaps a ClientboundLevelChunkPacketData carries (the types with
/// sendToClient: WORLD_SURFACE, MOTION_BLOCKING, MOTION_BLOCKING_NO_LEAVES),
/// as (network id, packed longs) in Heightmap.Types order.
pub fn client_heightmaps(chunk: &Chunk, tables: &SaveTables) -> Vec<(i32, Vec<i64>)> {
let kinds = [
(1, HeightmapType::WorldSurface),
(4, HeightmapType::MotionBlocking),
(5, HeightmapType::MotionBlockingNoLeaves),
];
let mut maps: Vec<(i32, Heightmap)> = kinds
.iter()
.filter_map(|(id, k)| {
Heightmap::new(*k, MIN_Y, SECTIONS as i32 * 16)
.ok()
.map(|m| (*id, m))
})
.collect();
let view = HeightmapView { chunk, tables };
let mut refs: Vec<&mut Heightmap> = maps.iter_mut().map(|(_, m)| m).collect();
if Heightmap::prime(&view, &mut refs).is_err() {
return Vec::new();
}
maps.iter()
.map(|(id, m)| (*id, m.raw_data().iter().map(|&w| w as i64).collect()))
.collect()
}
/// Vanilla light layer (nibbles, index y<<8|z<<4|x, low nibble first).
fn nibbles(light: &Light, sky: bool) -> Vec<u8> {
let mut out = vec![0u8; 2048];
+112 -6
View File
@@ -341,7 +341,7 @@ impl Streaming {
match done {
Done::Proto(x, z, proto) => {
self.generating.remove(&(x, z));
if self.in_range(x, z, 4) {
if self.in_range(x, z, 4) || self.near_finished(x, z, 2) {
self.protos.insert((x, z), Some(proto));
if !self.decorates {
self.decorated.insert((x, z));
@@ -371,7 +371,7 @@ impl Streaming {
self.generating.remove(&key);
self.finishing.remove(&key);
self.decorated.insert(key);
if self.in_range(key.0, key.1, 2) {
if self.in_range(key.0, key.1, 2) || self.near_finished(key.0, key.1, 1) {
self.generated_total += 1;
// A chunk saved with its light needs no light job; its
// unlit neighbours still light themselves from it.
@@ -435,7 +435,9 @@ impl Streaming {
.chunks
.keys()
.copied()
.filter(|&(x, z)| !self.remote && !self.in_range(x, z, 3))
.filter(|&(x, z)| {
!self.remote && !self.in_range(x, z, 3) && !self.near_finished(x, z, 1)
})
.collect();
for key in &far {
self.decorated.remove(key);
@@ -499,7 +501,9 @@ impl Streaming {
.protos
.iter()
.filter(|(k, p)| {
p.is_some() && !self.decorated.contains(k) && self.in_range(k.0, k.1, 2)
p.is_some()
&& !self.decorated.contains(k)
&& (self.in_range(k.0, k.1, 2) || self.near_finished(k.0, k.1, 1))
})
.map(|(k, _)| (self.distance(k.0, k.1), k.0, k.1))
.collect();
@@ -540,17 +544,19 @@ impl Streaming {
}
// Generation (load or proto), closest first, bounded in flight.
let margin = if self.decorates { 3 } else { 1 };
// Neighbours a finished chunk needs generated: decorated ones need theirs.
let reach = if self.decorates { 2 } else { 1 };
if !self.remote && self.generating.len() < workers * 3 {
let mut wanted = Vec::new();
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;
let r = radius + margin.max(reach + 1);
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)
if !(self.in_range(x, z, margin) || self.near_finished(x, z, reach))
|| world.chunks.contains_key(&(x, z))
|| self.generating.contains(&(x, z))
|| self.protos.contains_key(&(x, z))
@@ -728,6 +734,46 @@ impl Streaming {
}
}
}
fn ranges(&self) -> Ranges<'_> {
Ranges {
center: self.center,
radius: self.radius,
extra: &self.extra,
forced: &self.forced,
}
}
fn near_finished(&self, x: i32, z: i32, reach: i32) -> bool {
self.ranges().near_finished(x, z, reach)
}
fn in_range(&self, x: i32, z: i32, margin: i32) -> bool {
self.ranges().in_range(x, z, margin)
}
fn in_main_range(&self, x: i32, z: i32, margin: i32) -> bool {
self.ranges().in_main_range(x, z, margin)
}
}
/// The areas kept loaded: circles around the player and `extra`, and forced chunks.
struct Ranges<'a> {
center: (i32, i32),
radius: i32,
extra: &'a [((i32, i32), i32)],
forced: &'a HashSet<(i32, i32)>,
}
impl Ranges<'_> {
/// Whether a chunk finished here (`in_range(_, _, 1)`) lies within `reach`
/// chunks of (x, z) on both axes: its decoration needs its 3x3 neighbours
/// decorated, which need their own 3x3 neighbours generated. The ranges are
/// circles, so a fixed margin alone misses the corners of those squares
/// (render distance 2 never finished the chunks next to the player).
fn near_finished(&self, x: i32, z: i32, reach: i32) -> bool {
let near = |c: (i32, i32), radius: i32| {
let gap = |d: i32| i64::from((d.abs() - reach).max(0));
let (dx, dz) = (gap(x - c.0), gap(z - c.1));
let r = i64::from(radius + 1);
dx * dx + dz * dz <= r * r
};
near(self.center, self.radius) || self.extra.iter().any(|&(c, r)| near(c, r))
}
fn in_range(&self, x: i32, z: i32, margin: i32) -> bool {
self.in_main_range(x, z, margin)
|| self.extra.iter().any(|&(c, radius)| {
@@ -757,3 +803,63 @@ impl Drop for Streaming {
}
}
}
#[cfg(test)]
mod tests {
use super::*;
/// The ranges `Streaming::update` checks at each step, from generation to
/// light, must let every chunk the player spawns on finish and light: the
/// 3x3 columns around the player need their own 3x3 neighbours finished,
/// each of those its 3x3 neighbours decorated, and each of those its 3x3
/// neighbours generated and kept. Render distance 2 once stopped short.
#[test]
fn spawn_neighbourhood_completes_at_every_distance() {
let forced = HashSet::new();
for decorates in [true, false] {
let (margin, reach) = if decorates { (3, 2) } else { (1, 1) };
for radius in 2..=32 {
let r = Ranges {
center: (5, -7),
radius,
extra: &[],
forced: &forced,
};
let square = |x: i32, z: i32, n: i32| {
(-n..=n).flat_map(move |dz| (-n..=n).map(move |dx| (x + dx, z + dz)))
};
let generated = |x, z| {
(r.in_range(x, z, margin) || r.near_finished(x, z, reach))
&& (x - r.center.0).abs() <= radius + margin.max(reach + 1)
&& (z - r.center.1).abs() <= radius + margin.max(reach + 1)
};
let proto_kept = |x, z| r.in_range(x, z, 4) || r.near_finished(x, z, 2);
let decorated =
|x, z| !decorates || r.in_range(x, z, 2) || r.near_finished(x, z, 1);
let chunk_kept = |x, z| r.in_range(x, z, 2) || r.near_finished(x, z, 1);
let unloaded = |x, z| !r.in_range(x, z, 3) && !r.near_finished(x, z, 1);
let finishes = |x: i32, z: i32| {
r.in_range(x, z, 1)
&& chunk_kept(x, z)
&& !unloaded(x, z)
&& square(x, z, 1).all(|(nx, nz)| {
decorated(nx, nz)
&& (!decorates
|| square(nx, nz, 1)
.all(|(gx, gz)| generated(gx, gz) && proto_kept(gx, gz)))
&& generated(nx, nz)
&& proto_kept(nx, nz)
})
};
let (cx, cz) = r.center;
for (x, z) in square(cx, cz, 1) {
for (nx, nz) in square(x, z, 1) {
assert!(
finishes(nx, nz),
"radius {radius} (decorates: {decorates}): ({nx}, {nz}) never finishes"
);
}
}
}
}
}
}
+2 -1
View File
@@ -302,7 +302,8 @@ fn status_and_join() {
});
let v: serde_json::Value = serde_json::from_str(&json).unwrap();
assert_eq!(v["version"]["protocol"], 777);
assert_eq!(v["description"]["text"], "Test - World");
// ServerStatus.CODEC writes a plain literal MOTD as a bare string.
assert_eq!(v["description"], "Test - World");
// Join, receive the world, place a block, see another player arrive.
let report = run(&mut s, move || {
@@ -0,0 +1,527 @@
package dev.horizonlab.parity;
import java.io.PrintWriter;
import java.lang.reflect.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import java.util.function.Predicate;
import net.minecraft.SharedConstants;
import net.minecraft.core.*;
import net.minecraft.core.component.DataComponents;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.Identifier;
import net.minecraft.resources.RegistryDataLoader;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.Bootstrap;
import net.minecraft.server.RegistryLayer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.packs.PackType;
import net.minecraft.server.packs.repository.ServerPacksSource;
import net.minecraft.server.packs.resources.MultiPackResourceManager;
import net.minecraft.sounds.SoundEvent;
import net.minecraft.sounds.SoundSource;
import net.minecraft.tags.TagLoader;
import net.minecraft.util.RandomSource;
import net.minecraft.world.Difficulty;
import net.minecraft.world.DifficultyInstance;
import net.minecraft.world.effect.MobEffectInstance;
import net.minecraft.world.entity.*;
import net.minecraft.world.entity.ai.Brain;
import net.minecraft.world.entity.ai.attributes.Attribute;
import net.minecraft.world.entity.ai.attributes.AttributeInstance;
import net.minecraft.world.entity.ai.attributes.Attributes;
import net.minecraft.world.entity.ai.memory.MemoryModuleType;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.enchantment.ItemEnchantments;
import net.minecraft.world.level.*;
import net.minecraft.world.level.biome.Biome;
import net.minecraft.world.level.biome.BiomeManager;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.border.WorldBorder;
import net.minecraft.world.level.dimension.DimensionType;
import net.minecraft.world.level.entity.EntityTypeTest;
import net.minecraft.world.level.gamerules.GameRules;
import net.minecraft.world.level.levelgen.structure.BoundingBox;
import net.minecraft.world.level.levelgen.structure.Structure;
import net.minecraft.world.level.levelgen.structure.StructurePiece;
import net.minecraft.world.level.levelgen.structure.StructureStart;
import net.minecraft.world.level.levelgen.structure.pieces.PiecesContainer;
import net.minecraft.world.level.material.FluidState;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.Vec3;
/**
* Original oracle: Mob.finalizeSpawn as vanilla runs it, for every mob type,
* spawn reason, difficulty and local difficulty, on a stand-in ServerLevel
* (one biome, an optional structure piece, a floor and an optional roof,
* chickens standing by, the moon phase).
*
* Each case seeds the level random (what finalizeSpawn reads through
* level.getRandom()) and the entities' own randoms: every entity created
* in the case, the case's mobs and the jockeys finalizeSpawn makes, gets
* a LegacyRandomSource seeded eseed + its creation index, swapped in
* through each EntityType's factory. A pack of mobs is finalized in turn
* with the group data passed along, as NaturalSpawner does, each added to
* the level with its passengers.
*
* The log lists every entity of the case in creation order (equipment and
* enchantments, drop chances, CanPickUpLoot, LeftHanded, persistence, age,
* health, attribute values, effects, the species' variant state and spawn
* memories, its vehicle) and the next draws of the level random and of each
* entity's random, which pin every draw in between.
*/
public final class VanillaFinalizeSpawnOracle {
static Object unsafe;
static Method allocate, putObject, objectFieldOffset;
static Object alloc(Class<?> c) throws Exception { return allocate.invoke(unsafe, c); }
static void put(Object target, Class<?> owner, String field, Object value) throws Exception {
Field f = owner.getDeclaredField(field);
putObject.invoke(unsafe, target, (long) objectFieldOffset.invoke(unsafe, f), value);
}
static Object get(Object target, Class<?> owner, String field) {
try {
Field f = owner.getDeclaredField(field);
f.setAccessible(true);
return f.get(target);
} catch (Exception e) { throw new RuntimeException(e); }
}
static final class Lvl extends ServerLevel {
Lvl() { super(null, null, null, null, null, null, false, 0L, List.of(), false); }
RegistryAccess registries;
net.minecraft.server.MinecraftServer fake;
BlockState floor;
int floorY, roofY;
Holder<Biome> biome;
Difficulty difficulty;
DimensionType dimensionType;
ResourceKey<Level> dimensionKey;
List<Entity> entities = new ArrayList<>();
net.minecraft.world.attribute.EnvironmentAttributeSystem attributes;
BiomeManager biomeManager;
WorldBorder border = new WorldBorder();
GameRules rules;
Structures structures;
RandomSource levelRandom;
long time;
int next = 1;
@Override public net.minecraft.server.MinecraftServer getServer() { return fake; }
@Override public RegistryAccess registryAccess() { return registries; }
@Override public Difficulty getDifficulty() { return difficulty; }
@Override public long getGameTime() { return time; }
@Override public int getNextEntityId() { return next++; }
@Override public net.minecraft.world.flag.FeatureFlagSet enabledFeatures() { return net.minecraft.world.flag.FeatureFlags.REGISTRY.allFlags(); }
@Override public BlockState getBlockState(BlockPos pos) {
if (pos.getY() == floorY) return floor;
if (pos.getY() == roofY) return Blocks.STONE.defaultBlockState();
return Blocks.AIR.defaultBlockState();
}
@Override public FluidState getFluidState(BlockPos pos) { return getBlockState(pos).getFluidState(); }
@Override public DimensionType dimensionType() { return dimensionType; }
@Override public ResourceKey<Level> dimension() { return dimensionKey; }
@Override public Holder<Biome> getBiome(BlockPos pos) { return biome; }
@Override public BiomeManager getBiomeManager() { return biomeManager; }
@Override public net.minecraft.world.attribute.EnvironmentAttributeSystem environmentAttributes() { return attributes; }
@Override public WorldBorder getWorldBorder() { return border; }
@Override public GameRules getGameRules() { return rules; }
@Override public RandomSource getRandom() { return levelRandom; }
@Override public int getSeaLevel() { return 63; }
net.minecraft.server.ServerScoreboard scoreboard;
@Override public net.minecraft.server.ServerScoreboard getScoreboard() { return scoreboard; }
@Override public net.minecraft.world.level.StructureManager structureManager() { return structures; }
@Override public BlockGetter getChunkForCollisions(int chunkX, int chunkZ) { return this; }
@Override public boolean isSpawningMonsters() { return rules.get(GameRules.SPAWN_MOBS) && rules.get(GameRules.SPAWN_MONSTERS); }
@Override public void playSeededSound(net.minecraft.world.entity.Entity except, double x, double y, double z, Holder<SoundEvent> sound, SoundSource source, float volume, float pitch, long seed) {}
@Override public void playSeededSound(net.minecraft.world.entity.Entity except, net.minecraft.world.entity.Entity sourceEntity, Holder<SoundEvent> sound, SoundSource source, float volume, float pitch, long seed) {}
@Override public void gameEvent(Holder<net.minecraft.world.level.gameevent.GameEvent> gameEvent, Vec3 position, net.minecraft.world.level.gameevent.GameEvent.Context context) {}
@Override public void broadcastEntityEvent(Entity entity, byte event) {}
@SuppressWarnings({"unchecked", "rawtypes"})
@Override public List players() { return List.of(); }
@Override public Iterable<Entity> getAllEntities() { return entities; }
@Override public List<Entity> getEntities(Entity except, AABB bb, Predicate<? super Entity> selector) {
List<Entity> out = new ArrayList<>();
for (Entity e : entities) if (e != except && e.getBoundingBox().intersects(bb) && selector.test(e)) out.add(e);
return out;
}
@Override public <T extends Entity> List<T> getEntities(EntityTypeTest<Entity, T> type, AABB bb, Predicate<? super T> selector) {
List<T> out = new ArrayList<>();
for (Entity e : entities) {
T t = type.tryCast(e);
if (t != null && e.getBoundingBox().intersects(bb) && selector.test(t)) out.add(t);
}
return out;
}
@Override public boolean addFreshEntity(Entity entity) { if (!entities.contains(entity)) entities.add(entity); return true; }
@Override public void addFreshEntityWithPassengers(Entity entity) { entity.getSelfAndPassengers().forEach(this::addFreshEntity); }
@Override public Player getNearestPlayer(double x, double y, double z, double maxDist, boolean filter) { return null; }
}
/** One structure start whose single piece covers a box around the spawn point. */
static final class Structures extends net.minecraft.world.level.StructureManager {
Structures() { super(null, null, null); }
Lvl level;
Structure structure;
StructureStart start;
@Override public List<StructureStart> startsForStructure(int sectionX, int sectionZ, Predicate<Structure> matcher) {
return start != null && matcher.test(structure) ? List.of(start) : List.of();
}
@Override public List<StructureStart> startsForStructure(int sectionX, int sectionZ, Structure s) {
return start != null && s == structure ? List.of(start) : List.of();
}
@Override public RegistryAccess registryAccess() { return level.registries; }
}
static final class Piece extends StructurePiece {
Piece(BoundingBox box) { super(null, 0, box); }
@Override protected void addAdditionalSaveData(net.minecraft.world.level.levelgen.structure.pieces.StructurePieceSerializationContext context, net.minecraft.nbt.CompoundTag tag) {}
@Override public void postProcess(WorldGenLevel level, net.minecraft.world.level.StructureManager structureManager, net.minecraft.world.level.chunk.ChunkGenerator generator, RandomSource random,
BoundingBox chunkBB, ChunkPos chunkPos, BlockPos referencePos) {}
}
/** Entities created in the current case, and the seed base of their randoms. */
static List<Entity> created = new ArrayList<>();
static long entitySeed;
static boolean seeding;
static int otherIds;
@SuppressWarnings({"unchecked", "rawtypes"})
static void wrapFactories() throws Exception {
Field factory = EntityType.class.getDeclaredField("factory");
long offset = (long) objectFieldOffset.invoke(unsafe, factory);
factory.setAccessible(true);
for (EntityType<?> type : BuiltInRegistries.ENTITY_TYPE) {
EntityType.EntityFactory original = (EntityType.EntityFactory) factory.get(type);
EntityType.EntityFactory wrapped = (t, level) -> {
Entity e = original.create(t, level);
if (e != null && !seeding) e.setId(1000000 + otherIds++);
if (e != null && seeding) {
try {
put(e, Entity.class, "random", RandomSource.create(entitySeed + created.size()));
} catch (Exception ex) { throw new RuntimeException(ex); }
created.add(e);
e.setId(created.size());
}
return e;
};
putObject.invoke(unsafe, type, offset, wrapped);
}
}
static String hex(double v) { return Long.toHexString(Double.doubleToRawLongBits(v)); }
static String hex(float v) { return Integer.toHexString(Float.floatToRawIntBits(v)); }
static String id(Holder<?> h) { return h.unwrapKey().map(k -> k.identifier().toString()).orElse("?"); }
static final EquipmentSlot[] SLOTS = {EquipmentSlot.MAINHAND, EquipmentSlot.OFFHAND, EquipmentSlot.FEET, EquipmentSlot.LEGS,
EquipmentSlot.CHEST, EquipmentSlot.HEAD, EquipmentSlot.BODY, EquipmentSlot.SADDLE};
static String stack(ItemStack s) {
StringBuilder b = new StringBuilder(BuiltInRegistries.ITEM.getKey(s.getItem()).toString());
if (s.getCount() != 1) b.append('x').append(s.getCount());
ItemEnchantments e = s.getOrDefault(DataComponents.ENCHANTMENTS, ItemEnchantments.EMPTY);
if (!e.isEmpty()) {
List<String> list = new ArrayList<>();
for (var entry : e.entrySet()) list.add(id(entry.getKey()) + "=" + entry.getIntValue());
list.sort(null);
b.append('[').append(String.join(",", list)).append(']');
}
// Components besides enchantments (the ominous banner's).
int other = s.getComponentsPatch().forget(t -> t == DataComponents.ENCHANTMENTS).size();
if (other > 0) b.append('*').append(other);
return b.toString();
}
/** Loaded after the bootstrap. */
static final class Lists {
static final List<Map.Entry<String, Holder<Attribute>>> ATTRIBUTES = List.of(
Map.entry("max_health", Attributes.MAX_HEALTH), Map.entry("movement_speed", Attributes.MOVEMENT_SPEED),
Map.entry("follow_range", Attributes.FOLLOW_RANGE), Map.entry("attack_damage", Attributes.ATTACK_DAMAGE),
Map.entry("knockback_resistance", Attributes.KNOCKBACK_RESISTANCE), Map.entry("spawn_reinforcements", Attributes.SPAWN_REINFORCEMENTS_CHANCE),
Map.entry("jump_strength", Attributes.JUMP_STRENGTH));
static final List<Map.Entry<String, MemoryModuleType<?>>> MEMORIES = List.of(
Map.entry("long_jump_cooldown", MemoryModuleType.LONG_JUMP_COOLDOWN_TICKS), Map.entry("ram_cooldown", MemoryModuleType.RAM_COOLDOWN_TICKS),
Map.entry("attack_target_cooldown", MemoryModuleType.ATTACK_TARGET_COOLDOWN), Map.entry("hunted_recently", MemoryModuleType.HUNTED_RECENTLY),
Map.entry("dig_cooldown", MemoryModuleType.DIG_COOLDOWN), Map.entry("is_emerging", MemoryModuleType.IS_EMERGING),
Map.entry("home", MemoryModuleType.HOME));
}
/** The species state finalizeSpawn sets. */
static void variant(Entity e, List<String> v) {
if (e instanceof net.minecraft.world.entity.animal.pig.Pig p) {
v.add(id(p.getVariant()));
v.add(id((Holder<?>) data(p, p.getClass(), "DATA_SOUND_VARIANT_ID")));
} else if (e instanceof net.minecraft.world.entity.animal.cow.Cow c) {
v.add(id(c.getVariant()));
v.add(id((Holder<?>) data(c, net.minecraft.world.entity.animal.cow.Cow.class, "DATA_SOUND_VARIANT_ID")));
} else if (e instanceof net.minecraft.world.entity.animal.cow.MushroomCow m) {
v.add(m.getVariant().getSerializedName());
} else if (e instanceof net.minecraft.world.entity.animal.chicken.Chicken c) {
v.add(id(c.getVariant()));
v.add(id((Holder<?>) data(c, c.getClass(), "DATA_SOUND_VARIANT_ID")));
v.add("jockey=" + c.isChickenJockey());
} else if (e instanceof net.minecraft.world.entity.animal.feline.Cat c) {
v.add(id(c.getVariant()));
v.add(id((Holder<?>) data(c, c.getClass(), "DATA_SOUND_VARIANT_ID")));
} else if (e instanceof net.minecraft.world.entity.animal.wolf.Wolf w) {
v.add(id((Holder<?>) call(w, net.minecraft.world.entity.animal.wolf.Wolf.class, "getVariant")));
v.add(id((Holder<?>) data(w, w.getClass(), "DATA_SOUND_VARIANT_ID")));
} else if (e instanceof net.minecraft.world.entity.animal.frog.Frog f) {
v.add(id(f.getVariant()));
} else if (e instanceof net.minecraft.world.entity.animal.nautilus.ZombieNautilus n) {
v.add(id(n.getVariant()));
} else if (e instanceof net.minecraft.world.entity.animal.sheep.Sheep s) {
v.add(s.getColor().getSerializedName());
} else if (e instanceof net.minecraft.world.entity.animal.equine.Horse h) {
v.add(h.getVariant().getSerializedName() + "/" + h.getMarkings().name().toLowerCase(Locale.ROOT));
} else if (e instanceof net.minecraft.world.entity.animal.equine.Llama l) {
v.add(l.getVariant().getSerializedName() + "/" + l.getStrength());
} else if (e instanceof net.minecraft.world.entity.animal.equine.SkeletonHorse h) {
v.add("trap=" + h.isTrap());
} else if (e instanceof net.minecraft.world.entity.animal.fox.Fox f) {
v.add(f.getVariant().getSerializedName());
} else if (e instanceof net.minecraft.world.entity.animal.rabbit.Rabbit r) {
v.add(r.getVariant().getSerializedName());
} else if (e instanceof net.minecraft.world.entity.animal.parrot.Parrot p) {
v.add(p.getVariant().getSerializedName());
} else if (e instanceof net.minecraft.world.entity.animal.axolotl.Axolotl a) {
v.add(a.getVariant().getSerializedName());
} else if (e instanceof net.minecraft.world.entity.animal.fish.TropicalFish f) {
v.add(String.valueOf(call(f, net.minecraft.world.entity.animal.fish.TropicalFish.class, "getPackedVariant")));
} else if (e instanceof net.minecraft.world.entity.animal.fish.Salmon s) {
v.add(s.getVariant().getSerializedName());
} else if (e instanceof net.minecraft.world.entity.animal.panda.Panda p) {
v.add(p.getMainGene().getSerializedName() + "/" + p.getHiddenGene().getSerializedName());
} else if (e instanceof net.minecraft.world.entity.animal.goat.Goat g) {
v.add("scream=" + g.isScreamingGoat() + " horns=" + g.hasLeftHorn() + "," + g.hasRightHorn());
} else if (e instanceof net.minecraft.world.entity.monster.cubemob.AbstractCubeMob s) {
v.add("size=" + s.getSize());
} else if (e instanceof net.minecraft.world.entity.npc.villager.Villager vi) {
v.add(id(vi.getVillagerData().type()) + "/" + id(vi.getVillagerData().profession()) + "/" + vi.getVillagerData().level());
} else if (e instanceof net.minecraft.world.entity.monster.zombie.ZombieVillager z) {
// The profession comes from the constructor's unseeded random.
v.add(id(z.getVillagerData().type()) + "/" + z.getVillagerData().level());
} else if (e instanceof net.minecraft.world.entity.monster.Phantom p) {
v.add("size=" + p.getPhantomSize());
} else if (e instanceof net.minecraft.world.entity.animal.turtle.Turtle t) {
BlockPos h = (BlockPos) get(t, net.minecraft.world.entity.animal.turtle.Turtle.class, "homePos");
v.add("home=" + (h == null ? "-" : h.getX() + "," + h.getY() + "," + h.getZ()));
} else if (e instanceof net.minecraft.world.entity.animal.dolphin.Dolphin d) {
v.add("air=" + d.getAirSupply());
}
if (e instanceof net.minecraft.world.entity.monster.zombie.Zombie z) v.add("doors=" + z.canBreakDoors());
if (e instanceof net.minecraft.world.entity.monster.PatrollingMonster p) v.add("leader=" + p.isPatrolLeader() + " patrolling=" + call(p, net.minecraft.world.entity.monster.PatrollingMonster.class, "isPatrolling"));
if (e instanceof net.minecraft.world.entity.raid.Raider r) v.add("raid=" + r.canJoinRaid());
if (e instanceof net.minecraft.world.entity.monster.Strider s) v.add("saddled=" + s.isSaddled());
}
@SuppressWarnings({"unchecked", "rawtypes"})
static Object data(Entity e, Class<?> owner, String name) {
return e.getEntityData().get((net.minecraft.network.syncher.EntityDataAccessor) fieldValue(owner, name));
}
static Object call(Object target, Class<?> owner, String name) {
try {
Method m = owner.getDeclaredMethod(name);
m.setAccessible(true);
return m.invoke(target);
} catch (Exception ex) { throw new RuntimeException(ex); }
}
static Object fieldValue(Class<?> owner, String name) {
try {
Field f = owner.getDeclaredField(name);
f.setAccessible(true);
return f.get(null);
} catch (Exception ex) { throw new RuntimeException(ex); }
}
static String describe(Entity e, List<Entity> all) {
List<String> t = new ArrayList<>();
t.add(BuiltInRegistries.ENTITY_TYPE.getKey(e.getType()).toString());
Entity vehicle = e.getVehicle();
t.add("veh=" + (vehicle == null ? "-" : Integer.toString(all.indexOf(vehicle))));
if (e instanceof AgeableMob a) t.add("age=" + a.getAge());
else if (e instanceof LivingEntity l) t.add("baby=" + l.isBaby());
if (e instanceof LivingEntity l) t.add("hp=" + hex(l.getHealth()));
if (e instanceof Mob m) {
t.add("lh=" + m.isLeftHanded());
t.add("loot=" + m.canPickUpLoot());
t.add("persist=" + m.isPersistenceRequired());
List<String> eq = new ArrayList<>();
for (EquipmentSlot s : SLOTS) {
ItemStack st = m.getItemBySlot(s);
if (!st.isEmpty()) eq.add(s.getSerializedName() + ":" + stack(st));
}
t.add("eq=" + (eq.isEmpty() ? "-" : String.join(";", eq)));
List<String> drops = new ArrayList<>();
for (EquipmentSlot s : SLOTS) {
float d = m.getDropChances().byEquipment(s);
if (d != 0.085F) drops.add(s.getSerializedName() + ":" + hex(d));
}
t.add("drop=" + (drops.isEmpty() ? "-" : String.join(";", drops)));
}
if (e instanceof LivingEntity l) {
List<String> attrs = new ArrayList<>();
for (var a : Lists.ATTRIBUTES) {
AttributeInstance inst = l.getAttribute(a.getValue());
if (inst != null) attrs.add(a.getKey() + ":" + hex(inst.getValue()));
}
t.add("a=" + String.join(",", attrs));
List<String> fx = new ArrayList<>();
for (MobEffectInstance i : l.getActiveEffects()) fx.add(id(i.getEffect()) + ":" + i.getAmplifier() + ":" + i.getDuration());
fx.sort(null);
t.add("fx=" + (fx.isEmpty() ? "-" : String.join(",", fx)));
Brain<?> brain = l.getBrain();
List<String> mem = new ArrayList<>();
for (var m : Lists.MEMORIES) {
if (!brain.hasMemoryValue(m.getValue())) continue;
Object value = brain.getMemory(m.getValue()).orElse(null);
String text = value instanceof GlobalPos g ? g.pos().getX() + "," + g.pos().getY() + "," + g.pos().getZ() : String.valueOf(value);
mem.add(m.getKey() + ":" + text + ":" + brain.getTimeUntilExpiry(m.getValue()));
}
if (!mem.isEmpty()) t.add("mem=" + String.join(",", mem));
}
List<String> v = new ArrayList<>();
variant(e, v);
if (!v.isEmpty()) t.add("v=" + String.join(" ", v).replace(' ', '_'));
return String.join(" ", t);
}
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();
Bootstrap.bootStrap();
var unsafeField = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
unsafe = unsafeField.get(null);
allocate = unsafe.getClass().getMethod("allocateInstance", Class.class);
putObject = unsafe.getClass().getMethod("putObject", Object.class, long.class, Object.class);
objectFieldOffset = unsafe.getClass().getMethod("objectFieldOffset", Field.class);
var repo = ServerPacksSource.createVanillaTrustedRepository();
repo.reload();
repo.setSelected(List.of("vanilla"));
var resources = new MultiPackResourceManager(PackType.SERVER_DATA, repo.openAllSelected());
var layers = RegistryLayer.createRegistryAccess();
var staticTags = TagLoader.loadTagsForExistingRegistries(resources, layers.getLayer(RegistryLayer.STATIC));
var context = TagLoader.buildUpdatedLookups(layers.getAccessForLoading(RegistryLayer.WORLD), staticTags);
RegistryAccess.Frozen world = RegistryDataLoader.load(resources, context, RegistryDataLoader.WORLD_REGISTRIES, Runnable::run).join();
var worldLayers = layers.replaceFrom(RegistryLayer.WORLD, world);
var loaded = net.minecraft.server.ReloadableServerRegistries.reload(worldLayers, staticTags, resources, Runnable::run).join();
HolderLookup.Provider lookup = loaded.lookupWithUpdatedTags();
var components = BuiltInRegistries.DATA_COMPONENT_INITIALIZERS.build(lookup);
staticTags.forEach(Registry.PendingTags::apply);
components.forEach(net.minecraft.core.component.DataComponentInitializers.PendingComponents::apply);
RegistryAccess access = loaded.layers().compositeAccess();
var biomes = access.lookupOrThrow(Registries.BIOME);
var dimensions = access.lookupOrThrow(Registries.DIMENSION_TYPE);
var blockLookup = access.lookupOrThrow(Registries.BLOCK);
var structureLookup = access.lookupOrThrow(Registries.STRUCTURE);
var server = (net.minecraft.server.MinecraftServer) alloc(net.minecraft.server.dedicated.DedicatedServer.class);
put(server, net.minecraft.server.MinecraftServer.class, "debugSubscribers", alloc(net.minecraft.util.debug.ServerDebugSubscribers.class));
Lvl level = (Lvl) alloc(Lvl.class);
level.fake = server;
put(level, ServerLevel.class, "server", server);
level.registries = access;
// Level.playSound draws a sound seed before the (ignored) seeded sound.
put(level, net.minecraft.world.level.Level.class, "soundSeedGenerator", RandomSource.create(0L));
level.entities = new ArrayList<>();
level.scoreboard = new net.minecraft.server.ServerScoreboard(server);
level.border = new WorldBorder();
level.rules = new GameRules(net.minecraft.world.flag.FeatureFlags.REGISTRY.allFlags());
level.biomeManager = new BiomeManager((x, y, z) -> level.biome, 0L) {
@Override public Holder<Biome> getBiome(BlockPos pos) { return level.biome; }
@Override public Holder<Biome> getBiome(int x, int y, int z) { return level.biome; }
};
Structures structures = (Structures) alloc(Structures.class);
structures.level = level;
level.structures = structures;
wrapFactories();
List<String> lines = Files.readAllLines(Path.of(args[0]));
try (var w = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8))) {
w.println("halloween " + net.minecraft.util.SpecialDates.isHalloween());
for (String raw : lines) {
if (raw.isBlank()) continue;
Map<String, String> c = new LinkedHashMap<>();
for (String token : raw.trim().split("\\s+")) {
int eq = token.indexOf('=');
if (eq < 0) c.put("name", token); else c.put(token.substring(0, eq), token.substring(eq + 1));
}
try {
level.dimensionKey = ResourceKey.create(Registries.DIMENSION, Identifier.parse(c.getOrDefault("dim", "minecraft:overworld")));
level.dimensionType = dimensions.getOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, level.dimensionKey.identifier())).value();
level.biome = biomes.getOrThrow(ResourceKey.create(Registries.BIOME, Identifier.parse(c.getOrDefault("biome", "minecraft:plains"))));
level.difficulty = Difficulty.byName(c.getOrDefault("difficulty", "normal"));
level.time = Long.parseLong(c.getOrDefault("time", "0"));
level.rules.set(GameRules.SPAWN_MONSTERS, !c.getOrDefault("monsters", "1").equals("0"), null);
int phase = Integer.parseInt(c.getOrDefault("phase", "0"));
level.attributes = net.minecraft.world.attribute.EnvironmentAttributeSystem.builder().addStaticLayers(level)
.addConstantLayer(net.minecraft.world.attribute.EnvironmentAttributeMap.builder()
.set(net.minecraft.world.attribute.EnvironmentAttributes.MOON_PHASE, MoonPhase.values()[phase]).build())
.build();
String[] p = c.get("pos").split(",");
double x = Double.parseDouble(p[0]), y = Double.parseDouble(p[1]), z = Double.parseDouble(p[2]);
BlockPos block = BlockPos.containing(x, y, z);
level.floorY = block.getY() - 1;
level.floor = net.minecraft.commands.arguments.blocks.BlockStateParser.parseForBlock(blockLookup, c.getOrDefault("floor", "minecraft:grass_block"), false).blockState();
level.roofY = c.containsKey("roof") ? block.getY() + Integer.parseInt(c.get("roof")) : Integer.MIN_VALUE;
structures.start = null;
if (c.containsKey("structure")) {
structures.structure = structureLookup.getValue(Identifier.parse(c.get("structure")));
BoundingBox box = new BoundingBox(block.getX() - 8, block.getY() - 8, block.getZ() - 8, block.getX() + 8, block.getY() + 8, block.getZ() + 8);
structures.start = new StructureStart(structures.structure, new ChunkPos(block.getX() >> 4, block.getZ() >> 4), 0,
new PiecesContainer(List.of(new Piece(box))));
}
level.entities.clear();
level.levelRandom = RandomSource.create(Long.parseLong(c.getOrDefault("seed", "0")));
put(level, Level.class, "random", level.levelRandom);
created = new ArrayList<>();
entitySeed = Long.parseLong(c.getOrDefault("eseed", "0"));
seeding = true;
// Chickens already standing by (zombie jockeys look for one).
int chickens = Integer.parseInt(c.getOrDefault("chickens", "0"));
for (int i = 0; i < chickens; i++) {
Entity chicken = EntityTypes.CHICKEN.create(level, EntitySpawnReason.LOAD);
chicken.setPos(x + i, y, z);
level.entities.add(chicken);
}
EntityType<?> type = BuiltInRegistries.ENTITY_TYPE.getValue(Identifier.parse(c.get("type")));
EntitySpawnReason reason = EntitySpawnReason.valueOf(c.getOrDefault("reason", "NATURAL"));
float moon = DimensionType.MOON_BRIGHTNESS_PER_PHASE[phase];
DifficultyInstance difficulty = new DifficultyInstance(level.difficulty, level.time, Long.parseLong(c.getOrDefault("inhabited", "0")), moon);
int pack = Integer.parseInt(c.getOrDefault("pack", "1"));
SpawnGroupData group = null;
for (int i = 0; i < pack; i++) {
Entity e = type.create(level, reason);
if (e == null) break; // monsters do not exist in peaceful
if (!(e instanceof Mob mob)) throw new IllegalStateException("not a mob");
mob.snapTo(x, y, z, 0.0F, 0.0F);
group = mob.finalizeSpawn(level, difficulty, reason, group);
level.addFreshEntityWithPassengers(mob);
}
seeding = false;
List<String> out = new ArrayList<>();
for (Entity e : created) out.add(describe(e, created));
for (Entity e : created) out.add("rng " + e.getRandom().nextLong());
out.add("next " + level.levelRandom.nextLong());
w.println(c.get("name") + " " + String.join(" | ", out));
} catch (Throwable t) {
seeding = false;
Throwable cause = t;
while ((cause instanceof InvocationTargetException || cause instanceof RuntimeException && cause.getCause() != null) && cause.getCause() != null) cause = cause.getCause();
StringBuilder line = new StringBuilder(c.get("name") + " error " + cause);
if (System.getenv("ORACLE_TRACE") != null) for (var frame : cause.getStackTrace()) line.append("\n at ").append(frame);
w.println(line);
}
}
}
System.exit(0);
}
}
@@ -0,0 +1,52 @@
package dev.horizonlab.parity;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HexFormat;
import java.util.List;
import net.minecraft.client.server.LanServer;
import net.minecraft.client.server.LanServerDetection;
import net.minecraft.client.server.LanServerPinger;
/**
* Vanilla's LAN world discovery for tools/test_lan_parity.py. Each input
* line is a case: `ping MOTD PORT` prints the announcement
* LanServerPinger sends (its UTF-8 bytes); `heard IP HEX` decodes a received
* datagram as LanServerDetection does and adds it to the list
* (LanServerList.addServer), printing what it parsed and the list when it
* changed; `reset` starts a new list (a new multiplayer screen).
*/
public final class VanillaLanOracle {
public static void main(String[] args) throws Exception {
List<String> cases = Files.readAllLines(Path.of(args[0]), StandardCharsets.UTF_8);
try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8))) {
LanServerDetection.LanServerList list = new LanServerDetection.LanServerList();
for (String line : cases) {
String[] f = line.split("\t", -1);
switch (f[0]) {
case "ping" -> {
String ping = LanServerPinger.createPingString(f[1], f[2]);
out.println("ping " + HexFormat.of().formatHex(ping.getBytes(StandardCharsets.UTF_8)));
}
case "heard" -> {
byte[] bytes = HexFormat.of().parseHex(f[2]);
String received = new String(bytes, 0, bytes.length, StandardCharsets.UTF_8);
out.println("heard motd=" + LanServerPinger.parseMotd(received) + " address=" + LanServerPinger.parseAddress(received));
list.addServer(received, InetAddress.getByName(f[1]));
List<LanServer> dirty = list.takeDirtyServers();
if (dirty != null) {
StringBuilder b = new StringBuilder("list");
for (LanServer s : dirty) b.append(" [").append(s.getMotd()).append(" @ ").append(s.getAddress()).append(']');
out.println(b);
}
}
case "reset" -> list = new LanServerDetection.LanServerList();
default -> throw new IllegalArgumentException(line);
}
}
}
}
}
@@ -67,6 +67,8 @@ import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.AgeableMob;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.entity.npc.villager.Villager;
import net.minecraft.world.entity.ai.Brain;
import net.minecraft.world.entity.ai.behavior.BehaviorControl;
import net.minecraft.world.entity.ai.behavior.BlockPosTracker;
@@ -140,6 +142,10 @@ public final class VanillaMobAiOracle {
}
}
static final List<String> TRACE = new ArrayList<>();
/** The entities a scenario ticks, in order: its mobs, then what they spawned. */
static final List<Entity> ENTS = new ArrayList<>();
static final Map<Entity, Integer> LABELS = new java.util.IdentityHashMap<>();
static final UUID PLAYER_UUID = new UUID(0x1234L, 0x5678L);
static final class MobSpec {
String type;
@@ -166,6 +172,12 @@ public final class VanillaMobAiOracle {
String hand;
List<MobSpec> mobs = new ArrayList<>();
long levelSeed = 0;
/** The day time advances with the game time (sleeping, waking). */
boolean daycycle;
/** Blocks changed before a given tick: (tick, block or fill line). */
List<Object[]> timed = new ArrayList<>();
/** Boxes whose block changes are printed every tick. */
List<int[]> watches = new ArrayList<>();
/** Blocks placed when the scenario starts, so their block entities start afresh and tick. */
List<String[]> hearts = new ArrayList<>();
/** ServerLevel.isSpawningMonsters during the scenario (a heart spawns creakings). */
@@ -192,6 +204,7 @@ public final class VanillaMobAiOracle {
case "rain" -> s.rain = true;
case "thunder" -> s.thunder = true;
case "levelseed" -> s.levelSeed = Long.parseLong(kv[1]);
case "daycycle" -> s.daycycle = true;
case "spawning" -> s.spawning = true;
default -> throw new IllegalArgumentException(line);
}
@@ -199,6 +212,12 @@ public final class VanillaMobAiOracle {
}
case "origin" -> { s.originX = Integer.parseInt(f[1]); s.originZ = Integer.parseInt(f[2]); }
case "fill", "block" -> s.blocks.add(f);
case "at" -> s.timed.add(new Object[] {Integer.parseInt(f[1]), java.util.Arrays.copyOfRange(f, 2, f.length)});
case "watch" -> {
int[] box = new int[6];
for (int i = 0; i < 6; i++) box[i] = Integer.parseInt(f[i + 1]);
s.watches.add(box);
}
case "heart" -> s.hearts.add(f);
case "hurt" -> s.hurts.add(new int[] {Integer.parseInt(f[1]), Integer.parseInt(f[2])});
case "player" -> {
@@ -425,8 +444,12 @@ public final class VanillaMobAiOracle {
}
void build(Scenario s, ServerLevel level) throws Exception {
for (String[] b : s.blocks) place(b, level);
}
static void place(String[] b, ServerLevel level) throws Exception {
var blocks = level.holderLookup(Registries.BLOCK);
for (String[] b : s.blocks) {
{
if (b[0].equals("block")) {
BlockState state = BlockStateParser.parseForBlock(blocks, b[4], false).blockState();
level.setBlock(new BlockPos(Integer.parseInt(b[1]), Integer.parseInt(b[2]), Integer.parseInt(b[3])), state, 2 | 16);
@@ -453,7 +476,7 @@ public final class VanillaMobAiOracle {
level.setThunderLevel(s.thunder ? 1.0F : 0.0F);
if (s.player != null) {
if (player == null) {
CommonListenerCookie cookie = CommonListenerCookie.createInitial(new GameProfile(new UUID(0x1234L, 0x5678L), "horizon-ai"), false);
CommonListenerCookie cookie = CommonListenerCookie.createInitial(new GameProfile(PLAYER_UUID, "horizon-ai"), false);
player = new ServerPlayer(this, level, cookie.gameProfile(), cookie.clientInformation());
Connection connection = new Connection(PacketFlow.SERVERBOUND);
new EmbeddedChannel(connection);
@@ -479,14 +502,15 @@ public final class VanillaMobAiOracle {
} else if (player != null) {
player.snapTo(s.originX + 5000, -60, s.originZ, 0.0F, 0.0F);
}
List<Mob> mobs = new ArrayList<>();
ENTS.clear();
LABELS.clear();
List<Brain<?>> brains = new ArrayList<>();
List<Long> seeds = new ArrayList<>();
int id = 100000;
for (MobSpec spec : s.mobs) {
EntityType<?> type = BuiltInRegistries.ENTITY_TYPE.getValue(net.minecraft.resources.Identifier.parse(spec.type));
Mob mob = (Mob) type.create(level, EntitySpawnReason.COMMAND);
if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, mobs.size()));
if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, ENTS.size()));
mob.setId(id++);
mob.snapTo(spec.x, spec.y, spec.z, spec.yaw, 0.0F);
mob.setYHeadRot(spec.yaw);
@@ -495,36 +519,74 @@ public final class VanillaMobAiOracle {
if (mob instanceof AgeableMob a) a.setBaby(true);
else mob.setBaby(true);
}
List<Runnable> afterAdd = new ArrayList<>();
for (String flag : spec.flags) {
if (flag.equals("persistent")) mob.setPersistenceRequired();
else if (flag.equals("noai")) mob.setNoAi(true);
else if (flag.equals("inlove")) ((net.minecraft.world.entity.animal.Animal) mob).setInLoveTime(600);
else if (flag.equals("tame") && mob instanceof net.minecraft.world.entity.animal.equine.AbstractHorse horse) horse.setTamed(true);
else if (flag.startsWith("age=")) ((AgeableMob) mob).setAge(Integer.parseInt(flag.substring(4)));
else if (flag.startsWith("strength=")) method(net.minecraft.world.entity.animal.equine.Llama.class, "setStrength", int.class)
.invoke(mob, Integer.parseInt(flag.substring(9)));
else if (flag.equals("leashed") || flag.startsWith("leashto=")) {
// Leashed once every mob exists (below).
String[] kv = flag.split("=", 2);
String v = kv.length > 1 ? kv[1] : "";
switch (kv[0]) {
case "persistent" -> mob.setPersistenceRequired();
case "noai" -> mob.setNoAi(true);
case "profession" -> {
Villager villager = (Villager) mob;
villager.setVillagerData(villager.getVillagerData().withProfession(level.registryAccess(),
ResourceKey.create(Registries.VILLAGER_PROFESSION, net.minecraft.resources.Identifier.withDefaultNamespace(v))));
villager.refreshBrain(level);
}
case "level" -> {
Villager villager = (Villager) mob;
villager.setVillagerData(villager.getVillagerData().withLevel(Integer.parseInt(v)));
}
case "xp" -> ((Villager) mob).setVillagerXp(Integer.parseInt(v));
case "food" -> field(Villager.class, "foodLevel").setInt(mob, Integer.parseInt(v));
case "age" -> ((AgeableMob) mob).setAge(Integer.parseInt(v));
case "inv" -> {
for (String item : v.split(",")) {
String[] ic = item.split("\\*");
((Villager) mob).getInventory().addItem(new net.minecraft.world.item.ItemStack(
BuiltInRegistries.ITEM.getValue(net.minecraft.resources.Identifier.parse(ic[0])),
ic.length > 1 ? Integer.parseInt(ic[1]) : 1));
}
}
case "gossip" -> {
// gossip=player:minor_negative:100
String[] g = v.split(":");
UUID target = g[0].equals("player") ? PLAYER_UUID : UUID.fromString(g[0]);
((Villager) mob).getGossips().add(target,
net.minecraft.world.entity.ai.gossip.GossipType.valueOf(g[1].toUpperCase(java.util.Locale.ROOT)), Integer.parseInt(g[2]));
}
case "slept" -> {
long at = Long.parseLong(v);
afterAdd.add(() -> mob.getBrain().setMemory(MemoryModuleType.LAST_SLEPT, at));
}
case "inlove" -> ((net.minecraft.world.entity.animal.Animal) mob).setInLoveTime(600);
case "tame" -> { if (mob instanceof net.minecraft.world.entity.animal.equine.AbstractHorse horse) horse.setTamed(true); }
case "strength" -> method(net.minecraft.world.entity.animal.equine.Llama.class, "setStrength", int.class)
.invoke(mob, Integer.parseInt(v));
case "leashed", "leashto" -> {
// Leashed once every mob exists (below).
}
default -> throw new IllegalArgumentException(flag);
}
else throw new IllegalArgumentException(flag);
}
level.addFreshEntity(mob);
for (Runnable r : afterAdd) r.run();
mob.getRandom().setSeed(spec.seed);
Brain<?> brain = mob.getBrain();
@SuppressWarnings("unchecked")
Map<Object, Sensor<?>> sensors = (Map<Object, Sensor<?>>) get(brain, "sensors");
for (Sensor<?> sensor : sensors.values()) sensor.randomlyDelayStart(mob.getRandom());
seedGates(brain, spec.seed);
mobs.add(mob);
LABELS.put(mob, ENTS.size());
ENTS.add(mob);
brains.add(brain);
seeds.add(spec.seed);
}
// Leads: to the player ("leashed") or to the n-th mob ("leashto=n").
for (int i = 0; i < s.mobs.size(); i++) {
for (String flag : s.mobs.get(i).flags) {
if (flag.equals("leashed")) ((net.minecraft.world.entity.Leashable) mobs.get(i)).setLeashedTo(player, true);
else if (flag.startsWith("leashto=")) ((net.minecraft.world.entity.Leashable) mobs.get(i))
.setLeashedTo(mobs.get(Integer.parseInt(flag.substring(8))), true);
if (flag.equals("leashed")) ((net.minecraft.world.entity.Leashable) ENTS.get(i)).setLeashedTo(player, true);
else if (flag.startsWith("leashto=")) ((net.minecraft.world.entity.Leashable) ENTS.get(i))
.setLeashedTo(ENTS.get(Integer.parseInt(flag.substring(8))), true);
}
}
// Hearts start with the scenario: their tickers have not run during the warm-up.
@@ -541,12 +603,11 @@ public final class VanillaMobAiOracle {
List<Mob> created = new ArrayList<>();
Field factoryField = field(EntityType.class, "factory");
Object creakingFactory = factoryField.get(EntityTypes.CREAKING);
final List<Mob> mobsView = mobs;
factoryField.set(EntityTypes.CREAKING, (EntityType.EntityFactory<Creaking>) (type, lvl) -> {
Creaking c = new Creaking(type, lvl);
try {
long seed = 1000 + created.size();
if (tracing(s)) field(Entity.class, "random").set(c, new TracingRandom(0L, TRACE, mobsView.size() + created.size()));
if (tracing(s)) field(Entity.class, "random").set(c, new TracingRandom(0L, TRACE, ENTS.size() + created.size()));
c.getRandom().setSeed(seed);
@SuppressWarnings("unchecked")
Map<Object, Sensor<?>> cs = (Map<Object, Sensor<?>>) get(c.getBrain(), "sensors");
@@ -562,14 +623,25 @@ public final class VanillaMobAiOracle {
boolean spawnMonsters = this.getGameRules().get(GameRules.SPAWN_MONSTERS);
this.getGameRules().set(GameRules.SPAWN_MOBS, s.spawning, this);
this.getGameRules().set(GameRules.SPAWN_MONSTERS, s.spawning, this);
int adopted = 0;
level.getRandom().setSeed(s.levelSeed);
// Loot drawn from random sequences starts afresh in every scenario.
this.getRandomSequences().clear();
SOUNDS.clear();
Method tickTime = method(ServerLevel.class, "tickTime");
Object manager = get(level, "entityManager");
Method managerTick = method(manager.getClass(), "tick");
for (int i = 0; i < mobs.size(); i++) print(0, i, mobs.get(i));
Map<BlockPos, BlockState> watched = new java.util.LinkedHashMap<>();
for (int[] box : s.watches)
for (int y = box[1]; y <= box[4]; y++)
for (int z = box[2]; z <= box[5]; z++)
for (int x = box[0]; x <= box[3]; x++) {
BlockPos pos = new BlockPos(x + s.originX, y, z + s.originZ);
watched.put(pos, level.getBlockState(pos));
}
for (int i = 0; i < ENTS.size(); i++) print(0, i, ENTS.get(i));
for (int t = 1; t <= s.ticks; t++) {
if (s.daycycle) this.clockManager().setTotalTicks(clock, s.time + t);
for (Object[] e : s.timed) if ((Integer) e[0] == t) place((String[]) e[1], level);
level.environmentAttributes().invalidateTickCache();
level.updateSkyBrightness();
tickTime.invoke(level);
@@ -591,41 +663,78 @@ public final class VanillaMobAiOracle {
TracingRandom.tick = t;
TracingRandom.on = tracing(s) && t >= traceFrom() && t <= traceTo();
SOUNDS.clear();
for (int i = 0; i < mobs.size(); i++) {
for (int i = 0; i < ENTS.size(); i++) {
// Villager.refreshBrain builds a new brain with new gates: seed those too.
if (mobs.get(i).getBrain() != brains.get(i)) {
brains.set(i, mobs.get(i).getBrain());
if (ENTS.get(i) instanceof Mob m && m.getBrain() != brains.get(i)) {
brains.set(i, m.getBrain());
seedGates(brains.get(i), seeds.get(i));
}
}
for (int[] hurt : s.hurts) {
if (hurt[0] == t && hurt[1] < mobs.size() && !mobs.get(hurt[1]).isRemoved())
mobs.get(hurt[1]).hurtServer(level, level.damageSources().playerAttack(player), 1.0F);
if (hurt[0] == t && hurt[1] < ENTS.size() && ENTS.get(hurt[1]) instanceof LivingEntity hurtMob && !hurtMob.isRemoved())
hurtMob.hurtServer(level, level.damageSources().playerAttack(player), 1.0F);
}
for (Mob mob : mobs) {
if (mob.isRemoved()) continue;
mob.checkDespawn();
if (mob.isRemoved()) continue;
level.tickNonPassenger(mob);
for (Entity e : List.copyOf(ENTS)) {
if (e.isRemoved()) continue;
e.checkDespawn();
if (e.isRemoved()) continue;
level.tickNonPassenger(e);
}
if (!heartPositions.isEmpty()) level.tickBlockEntities();
managerTick.invoke(manager);
// Created mobs that made it into the level, in creation order.
for (; adopted < created.size(); adopted++) {
Mob c = created.get(adopted);
if (!c.isRemoved()) {
mobs.add(c);
brains.add(c.getBrain());
seeds.add(1000L + adopted);
// Villagers the tick spawned (babies) and a heart's creakings tick from the next
// one, in the order they were added, with a seeded random of their own. Other
// newcomers (animal babies, dropped items) are left out, as the probe leaves them.
List<Entity> fresh = new ArrayList<>();
for (Entity e : level.getAllEntities())
if (!LABELS.containsKey(e) && (e instanceof Villager || created.contains(e))) fresh.add(e);
fresh.sort(java.util.Comparator.comparingInt(Entity::getId));
for (Entity e : fresh) {
int index = ENTS.size();
int made = created.indexOf(e);
if (made >= 0) {
// A heart's creaking: seeded when it was created.
LABELS.put(e, index);
ENTS.add(e);
seeds.add(1000L + made);
brains.add(((Mob) e).getBrain());
continue;
}
long seed = spawnSeed(index);
LABELS.put(e, index);
ENTS.add(e);
seeds.add(seed);
if (e instanceof Mob mob) {
// LivingEntity's constructor turns the head at random (Math.random):
// face it the way the body does, as the probe's newborns.
mob.setYHeadRot(mob.getYRot());
mob.yHeadRotO = mob.getYRot();
if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, index));
mob.getRandom().setSeed(seed);
@SuppressWarnings("unchecked")
Map<Object, Sensor<?>> sensors = (Map<Object, Sensor<?>>) get(mob.getBrain(), "sensors");
for (Sensor<?> sensor : sensors.values()) sensor.randomlyDelayStart(mob.getRandom());
seedGates(mob.getBrain(), seed);
brains.add(mob.getBrain());
} else {
brains.add(null);
}
}
for (int i = 0; i < mobs.size(); i++) print(t, i, mobs.get(i));
for (int i = 0; i < ENTS.size(); i++) print(t, i, ENTS.get(i));
for (BlockPos h : heartPositions) printHeart(t, level, h);
for (String sound : SOUNDS) out.println(t + " sound " + sound);
for (var w : watched.entrySet()) {
BlockState now = level.getBlockState(w.getKey());
if (now != w.getValue()) {
w.setValue(now);
BlockPos p = w.getKey();
out.println(t + " block " + (p.getX() - s.originX) + "," + p.getY() + "," + (p.getZ() - s.originZ) + " " + stateName(now));
}
}
for (String line : TRACE) out.println(line);
TRACE.clear();
}
for (Mob mob : mobs) mob.discard();
for (Entity e : ENTS) e.discard();
for (BlockPos h : heartPositions) level.setBlock(h, net.minecraft.world.level.block.Blocks.AIR.defaultBlockState(), 2 | 16);
factoryField.set(EntityTypes.CREAKING, creakingFactory);
this.getGameRules().set(GameRules.SPAWN_MOBS, spawnMobs, this);
@@ -634,6 +743,18 @@ public final class VanillaMobAiOracle {
out.flush();
}
/** The random seed of the entity a scenario spawned at this index. */
static long spawnSeed(int index) { return 1000L + 7919L * index; }
static String stateName(BlockState state) {
StringBuilder sb = new StringBuilder(BuiltInRegistries.BLOCK.getKey(state.getBlock()).toString());
List<String> props = new ArrayList<>();
state.getValues().forEach(v -> props.add(v.toString()));
props.sort(null);
if (!props.isEmpty()) sb.append('[').append(String.join(",", props)).append(']');
return sb.toString();
}
/** A heart's block state and block entity, and the level random. */
static void printHeart(int t, ServerLevel level, BlockPos at) throws Exception {
StringBuilder sb = new StringBuilder();
@@ -663,16 +784,44 @@ public final class VanillaMobAiOracle {
}
static void seedGate(Object behavior, long seed) throws Exception {
if (!(behavior instanceof GateBehavior<?>)) return;
ShufflingList<?> list = (ShufflingList<?>) field(GateBehavior.class, "behaviors").get(behavior);
field(ShufflingList.class, "random").set(list, new net.minecraft.world.level.levelgen.LegacyRandomSource(seed));
for (Object child : list) seedGate(child, seed);
seedLists(behavior, seed, java.util.Collections.newSetFromMap(new java.util.IdentityHashMap<>()), 0);
}
/**
* Seeds every ShufflingList a behaviour holds: a GateBehavior's, and the ones TriggerGate
* captures in its lambdas (BehaviorBuilder's one-shots), found through their fields.
*/
static void seedLists(Object o, long seed, Set<Object> seen, int depth) throws Exception {
if (o == null || depth > 8 || !seen.add(o)) return;
if (o instanceof ShufflingList<?> list) {
field(ShufflingList.class, "random").set(list, new net.minecraft.world.level.levelgen.LegacyRandomSource(seed));
for (Object child : list) seedLists(child, seed, seen, depth + 1);
return;
}
String name = o.getClass().getName();
if (!name.startsWith("net.minecraft.world.entity.ai.behavior") || o instanceof Enum<?>) return;
for (Class<?> c = o.getClass(); c != null && c.getName().startsWith("net.minecraft"); c = c.getSuperclass()) {
for (Field f : c.getDeclaredFields()) {
if (java.lang.reflect.Modifier.isStatic(f.getModifiers()) || f.getType().isPrimitive()) continue;
f.setAccessible(true);
Object v = f.get(o);
if (v instanceof Iterable<?> it && !(v instanceof ShufflingList<?>)) {
for (Object x : it) seedLists(x, seed, seen, depth + 1);
} else if (v instanceof com.mojang.datafixers.util.Pair<?, ?> pair) {
seedLists(pair.getFirst(), seed, seen, depth + 1);
seedLists(pair.getSecond(), seed, seen, depth + 1);
} else {
seedLists(v, seed, seen, depth + 1);
}
}
}
}
static String who(Entity e) {
if (e == null) return "none";
if (e instanceof ServerPlayer) return "player";
return "e" + e.getId();
Integer label = LABELS.get(e);
return "e" + (label != null ? 100000 + label : e.getId());
}
static String goals(GoalSelector selector) {
@@ -705,13 +854,24 @@ public final class VanillaMobAiOracle {
return v.getClass().getSimpleName();
}
void print(int t, int i, Mob m) throws Exception {
void print(int t, int i, Entity e) throws Exception {
StringBuilder sb = new StringBuilder();
sb.append(t).append(' ').append(i);
if (m.isRemoved()) {
out.println(sb.append(" removed ").append(m.getRemovalReason()));
if (e.isRemoved()) {
out.println(sb.append(" removed ").append(e.getRemovalReason()));
return;
}
if (e instanceof ItemEntity item) {
sb.append("\tp ").append(d(item.getX())).append(',').append(d(item.getY())).append(',').append(d(item.getZ()));
Vec3 v = item.getDeltaMovement();
sb.append("\tv ").append(d(v.x)).append(',').append(d(v.y)).append(',').append(d(v.z));
sb.append("\tg ").append(item.onGround() ? 1 : 0).append(item.horizontalCollision ? 1 : 0);
sb.append("\titem ").append(stack(item.getItem())).append(' ').append(item.getAge()).append(' ')
.append(field(ItemEntity.class, "pickupDelay").getInt(item));
out.println(sb);
return;
}
Mob m = (Mob) e;
sb.append("\tp ").append(d(m.getX())).append(',').append(d(m.getY())).append(',').append(d(m.getZ()));
Vec3 v = m.getDeltaMovement();
sb.append("\tv ").append(d(v.x)).append(',').append(d(v.y)).append(',').append(d(v.z));
@@ -752,9 +912,52 @@ public final class VanillaMobAiOracle {
mem.sort(null);
sb.append("\tmem ").append(String.join(" ", mem));
}
if (m instanceof Villager villager) sb.append("\tvx ").append(villager(villager));
out.println(sb);
}
static String stack(net.minecraft.world.item.ItemStack stack) {
if (stack.isEmpty()) return "-";
return BuiltInRegistries.ITEM.getKey(stack.getItem()).getPath() + "*" + stack.getCount();
}
static String uuidLabel(UUID uuid) {
if (uuid.equals(PLAYER_UUID)) return "player";
for (Entity e : ENTS) if (e.getUUID().equals(uuid)) return who(e);
return uuid.toString();
}
/** A villager's data, food, inventory slots, gossip and offers. */
static String villager(Villager v) throws Exception {
StringBuilder sb = new StringBuilder();
var data = v.getVillagerData();
sb.append("prof ").append(data.profession().unwrapKey().get().identifier().getPath()).append(" lvl ").append(data.level())
.append(" xp ").append(v.getVillagerXp()).append(" food ").append(field(Villager.class, "foodLevel").getInt(v))
.append(" age ").append(v.getAge());
List<String> slots = new ArrayList<>();
var inv = v.getInventory();
for (int k = 0; k < inv.getContainerSize(); k++) slots.add(stack(inv.getItem(k)));
while (!slots.isEmpty() && slots.getLast().equals("-")) slots.removeLast();
sb.append(" inv ").append(slots.isEmpty() ? "-" : String.join(",", slots));
List<String> gossips = new ArrayList<>();
v.getGossips().getGossipEntries().forEach((uuid, types) -> types.forEach((type, value) ->
gossips.add(uuidLabel(uuid) + ":" + type.getSerializedName() + "=" + value)));
gossips.sort(null);
sb.append(" gossip ").append(gossips.isEmpty() ? "-" : String.join(",", gossips));
sb.append(" rep ").append(v.getGossips().getReputation(PLAYER_UUID, x -> true));
sb.append(" sleep ").append(v.getSleepingPos().map(Server::pos).orElse("-"));
Object offers = get(v, "offers");
if (offers != null) {
List<String> list = new ArrayList<>();
for (var o : (net.minecraft.world.item.trading.MerchantOffers) offers) {
list.add(stack(o.getBaseCostA()) + "+" + stack(o.getCostB()) + ">" + stack(o.getResult()) + "/" + o.getUses() + "/"
+ o.getMaxUses() + "/" + o.getDemand() + "/" + o.getSpecialPriceDiff());
}
sb.append(" offers ").append(list.isEmpty() ? "-" : String.join(",", list));
}
return sb.toString();
}
static String name(MemoryModuleType<?> type) {
return BuiltInRegistries.MEMORY_MODULE_TYPE.getKey(type).getPath();
}
@@ -0,0 +1,661 @@
package dev.horizonlab.parity;
import com.google.gson.JsonElement;
import com.mojang.serialization.JsonOps;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.time.Instant;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HexFormat;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.UUID;
import java.util.zip.DataFormatException;
import java.util.zip.Deflater;
import java.util.zip.Inflater;
import net.minecraft.SharedConstants;
import net.minecraft.core.UUIDUtil;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.network.RegistryFriendlyByteBuf;
import net.minecraft.world.level.chunk.LevelChunkSection;
import net.minecraft.world.level.chunk.PalettedContainerFactory;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.ComponentSerialization;
import net.minecraft.network.chat.LastSeenMessages;
import net.minecraft.network.protocol.Packet;
import net.minecraft.network.ProtocolInfo;
import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
import net.minecraft.network.protocol.common.ClientboundDisconnectPacket;
import net.minecraft.network.protocol.common.ClientboundKeepAlivePacket;
import net.minecraft.network.protocol.common.ClientboundPingPacket;
import net.minecraft.network.protocol.common.ServerboundClientInformationPacket;
import net.minecraft.network.protocol.common.ServerboundCustomPayloadPacket;
import net.minecraft.network.protocol.common.ServerboundKeepAlivePacket;
import net.minecraft.network.protocol.common.ServerboundPongPacket;
import net.minecraft.network.protocol.common.custom.BrandPayload;
import net.minecraft.network.protocol.configuration.ClientboundFinishConfigurationPacket;
import net.minecraft.network.protocol.configuration.ClientboundSelectKnownPacks;
import net.minecraft.network.protocol.configuration.ConfigurationProtocols;
import net.minecraft.network.protocol.configuration.ServerboundFinishConfigurationPacket;
import net.minecraft.network.protocol.configuration.ServerboundSelectKnownPacks;
import net.minecraft.network.protocol.game.ClientboundChunkBatchFinishedPacket;
import net.minecraft.network.protocol.game.ClientboundDisguisedChatPacket;
import net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData;
import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket;
import net.minecraft.network.protocol.game.ClientboundPlayerChatPacket;
import net.minecraft.network.protocol.game.ClientboundPlayerPositionPacket;
import net.minecraft.network.protocol.game.ClientboundSystemChatPacket;
import net.minecraft.network.protocol.game.GameProtocols;
import net.minecraft.network.protocol.game.ServerboundAcceptTeleportationPacket;
import net.minecraft.network.protocol.game.ServerboundChatCommandPacket;
import net.minecraft.network.protocol.game.ServerboundChatPacket;
import net.minecraft.network.protocol.game.ServerboundChunkBatchReceivedPacket;
import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
import net.minecraft.network.protocol.game.ServerboundPlayerLoadedPacket;
import net.minecraft.network.protocol.handshake.ClientIntent;
import net.minecraft.network.protocol.handshake.ClientIntentionPacket;
import net.minecraft.network.protocol.handshake.HandshakeProtocols;
import net.minecraft.network.protocol.login.ClientboundLoginCompressionPacket;
import net.minecraft.network.protocol.login.ClientboundLoginDisconnectPacket;
import net.minecraft.network.protocol.login.ClientboundLoginFinishedPacket;
import net.minecraft.network.protocol.login.LoginProtocols;
import net.minecraft.network.protocol.login.ServerboundHelloPacket;
import net.minecraft.network.protocol.login.ServerboundLoginAcknowledgedPacket;
import net.minecraft.network.protocol.ping.ClientboundPongResponsePacket;
import net.minecraft.network.protocol.ping.ServerboundPingRequestPacket;
import net.minecraft.network.protocol.status.ClientboundStatusResponsePacket;
import net.minecraft.network.protocol.status.ServerStatus;
import net.minecraft.network.protocol.status.ServerboundStatusRequestPacket;
import net.minecraft.network.protocol.status.StatusProtocols;
import net.minecraft.server.level.ClientInformation;
import net.minecraft.world.entity.PositionMoveRotation;
import net.minecraft.world.phys.Vec3;
/**
* A headless client made of vanilla's own protocol: it frames, compresses and
* decodes every packet with the codecs of the pinned server JAR (the client
* shares them), so any byte a server sends that vanilla would not read is
* recorded as an error. tools/test_dedicated_server_parity.py points it at a
* vanilla dedicated server and at Horizon's, with the same settings and
* world, and compares the transcripts.
*
* <p>{@code VanillaProtocolClient HOST PORT NAME OUT} pings the server (status
* and ping), joins as NAME in offline mode, goes through login and
* configuration, accepts the spawn teleport, waits for the chunks around the
* spawn, sends a chat message and the {@code /list} command, and leaves.
* Each transcript line is a section and a summary: the login and
* configuration packets in order; in play, the packets up to the first chunk
* batch in order, then the chunks by position with the hash of their bytes
* and the replies to the chat and command. Values that change between runs
* (entity ids, keep-alive ids, times, salts) are not part of the summaries.
*/
public final class VanillaProtocolClient {
private Socket socket;
private DataInputStream in;
private OutputStream out;
private int threshold = -1;
private final List<String> lines = new ArrayList<>();
private ProtocolInfo<?> inbound;
private ProtocolInfo<?> outbound;
private String state;
public static void main(String[] args) throws Exception {
ParityData.init();
String host = args[0];
int port = Integer.parseInt(args[1]);
String name = args[2];
Path output = Path.of(args[3]);
VanillaProtocolClient client = new VanillaProtocolClient();
try {
client.status(host, port);
client.join(host, port, name);
} catch (Exception e) {
client.lines.add("error " + client.state + " " + e);
} finally {
if (client.socket != null) client.socket.close();
}
try (PrintWriter w = new PrintWriter(Files.newBufferedWriter(output, StandardCharsets.UTF_8))) {
for (String line : client.lines) w.println(line);
}
System.exit(0);
}
// ---- connection ---------------------------------------------------
private void open(String host, int port) throws Exception {
socket = new Socket();
socket.connect(new InetSocketAddress(host, port), 10_000);
socket.setSoTimeout(30_000);
socket.setTcpNoDelay(true);
in = new DataInputStream(socket.getInputStream());
out = socket.getOutputStream();
threshold = -1;
}
private static int readVarInt(InputStream in) throws Exception {
int value = 0;
for (int i = 0; i < 5; i++) {
int b = in.read();
if (b < 0) throw new EOFException();
value |= (b & 0x7F) << (7 * i);
if ((b & 0x80) == 0) return value;
}
throw new IllegalStateException("VarInt too big");
}
private static void writeVarInt(ByteBuf buf, int value) {
while ((value & ~0x7F) != 0) {
buf.writeByte((value & 0x7F) | 0x80);
value >>>= 7;
}
buf.writeByte(value);
}
@SuppressWarnings({"unchecked", "rawtypes"})
private void send(Packet<?> packet) throws Exception {
ByteBuf body = Unpooled.buffer();
((ProtocolInfo) outbound).codec().encode(body, packet);
byte[] raw = new byte[body.readableBytes()];
body.readBytes(raw);
ByteBuf frame = Unpooled.buffer();
if (threshold >= 0) {
ByteBuf inner = Unpooled.buffer();
if (raw.length >= threshold) {
writeVarInt(inner, raw.length);
Deflater d = new Deflater();
d.setInput(raw);
d.finish();
byte[] tmp = new byte[raw.length + 64];
while (!d.finished()) {
int n = d.deflate(tmp);
inner.writeBytes(tmp, 0, n);
}
d.end();
} else {
writeVarInt(inner, 0);
inner.writeBytes(raw);
}
writeVarInt(frame, inner.readableBytes());
frame.writeBytes(inner);
} else {
writeVarInt(frame, raw.length);
frame.writeBytes(raw);
}
byte[] bytes = new byte[frame.readableBytes()];
frame.readBytes(bytes);
out.write(bytes);
out.flush();
}
/** The next packet's raw payload, decompressed as CompressionDecoder does (validating). */
private byte[] readFrame() throws Exception {
int length = readVarInt(in);
byte[] frame = new byte[length];
in.readFully(frame);
if (threshold < 0) return frame;
ByteBuf buf = Unpooled.wrappedBuffer(frame);
int dataLength = readVarInt(new java.io.ByteArrayInputStream(frame));
int header = varIntSize(dataLength);
buf.skipBytes(header);
if (dataLength == 0) {
byte[] raw = new byte[buf.readableBytes()];
buf.readBytes(raw);
return raw;
}
if (dataLength < threshold) {
throw new IllegalStateException("Badly compressed packet - size of " + dataLength + " is below server threshold of " + threshold);
}
if (dataLength > 8388608) {
throw new IllegalStateException("Badly compressed packet - size of " + dataLength + " is larger than protocol maximum of 8388608");
}
Inflater inflater = new Inflater();
inflater.setInput(frame, header, frame.length - header);
byte[] raw = new byte[dataLength];
int n;
try {
n = inflater.inflate(raw);
} catch (DataFormatException e) {
throw new IllegalStateException("bad zlib data", e);
}
boolean finished = inflater.finished();
inflater.end();
if (n != dataLength || !finished) throw new IllegalStateException("decompressed " + n + " of " + dataLength + " bytes");
return raw;
}
private static int varIntSize(int v) {
int n = 1;
while ((v & ~0x7F) != 0) {
v >>>= 7;
n++;
}
return n;
}
private record Received(Packet<?> packet, byte[] payload, String type) {}
/** The next packet, decoded with the inbound protocol; leftover bytes are an error (PacketDecoder). */
private Received read() throws Exception {
byte[] payload = readFrame();
ByteBuf buf = Unpooled.wrappedBuffer(payload);
Packet<?> packet = inbound.codec().decode(buf);
if (buf.readableBytes() > 0) {
throw new IllegalStateException("Packet " + inbound.id().id() + "/" + packet.type().id() + " was larger than I expected, found "
+ buf.readableBytes() + " bytes extra whilst reading");
}
return new Received(packet, payload, packet.type().id().toString());
}
// ---- summaries ----------------------------------------------------
private static String sha(byte[] bytes) {
try {
return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(bytes)).substring(0, 16);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static String json(Component c) {
JsonElement e = ComponentSerialization.CODEC.encodeStart(ParityData.access.createSerializationContext(JsonOps.INSTANCE), c).getOrThrow();
return e.toString();
}
/** A record's text without object identities; other objects by their fields. */
private static String text(Object o) {
String s = String.valueOf(o);
if (o != null && s.matches("[\\w.$]+@[0-9a-f]+")) {
StringBuilder b = new StringBuilder(o.getClass().getSimpleName()).append('{');
for (Class<?> c = o.getClass(); c != null && c != Object.class; c = c.getSuperclass()) {
for (java.lang.reflect.Field f : c.getDeclaredFields()) {
if (java.lang.reflect.Modifier.isStatic(f.getModifiers())) continue;
try {
f.setAccessible(true);
b.append(f.getName()).append('=').append(text(f.get(o))).append(", ");
} catch (Exception e) {
b.append(f.getName()).append("=?, ");
}
}
}
return b.append('}').toString();
}
return s.replaceAll("\\$\\$Lambda/0x[0-9a-f]+@", "\\$\\$Lambda@").replaceAll("@[0-9a-f]{4,}", "@");
}
private void record(String section, String line) {
lines.add(section + " " + line);
}
// ---- status -------------------------------------------------------
private void status(String host, int port) throws Exception {
state = "status";
open(host, port);
outbound = HandshakeProtocols.SERVERBOUND;
send(new ClientIntentionPacket(SharedConstants.getProtocolVersion(), host, port, ClientIntent.STATUS));
outbound = StatusProtocols.SERVERBOUND;
inbound = StatusProtocols.CLIENTBOUND;
send(ServerboundStatusRequestPacket.INSTANCE);
Received r = read();
if (r.packet instanceof ClientboundStatusResponsePacket p) {
JsonElement e = ServerStatus.CODEC.encodeStart(JsonOps.INSTANCE, p.status()).getOrThrow();
// The favicon is compared by its bytes' hash.
String s = e.toString().replaceAll("\"favicon\":\"[^\"]*\"", "\"favicon\":\"" + p.status().favicon().map(f -> sha(f.iconBytes())).orElse("") + "\"");
record("status", r.type + " " + s);
} else {
record("status", r.type + " " + text(r.packet));
}
send(new ServerboundPingRequestPacket(1234567890123L));
Received pong = read();
record("status", pong.type + " " + (pong.packet instanceof ClientboundPongResponsePacket p ? p.time() : text(pong.packet)));
int after = in.read();
record("status", "closed-after-pong " + (after < 0));
socket.close();
}
// ---- join ---------------------------------------------------------
private void join(String host, int port, String name) throws Exception {
open(host, port);
state = "login";
outbound = HandshakeProtocols.SERVERBOUND;
send(new ClientIntentionPacket(SharedConstants.getProtocolVersion(), host, port, ClientIntent.LOGIN));
outbound = LoginProtocols.SERVERBOUND;
inbound = LoginProtocols.CLIENTBOUND;
UUID uuid = UUIDUtil.createOfflinePlayerUUID(name);
send(new ServerboundHelloPacket(name, uuid));
while (true) {
Received r = read();
if (r.packet instanceof ClientboundLoginCompressionPacket p) {
threshold = p.getCompressionThreshold();
record("login", r.type + " " + threshold);
} else if (r.packet instanceof ClientboundLoginFinishedPacket p) {
record("login", r.type + " " + p.gameProfile().id() + " " + p.gameProfile().name() + " " + p.gameProfile().properties().size());
send(ServerboundLoginAcknowledgedPacket.INSTANCE);
break;
} else if (r.packet instanceof ClientboundLoginDisconnectPacket p) {
record("login", r.type + " " + json(p.reason()));
return;
} else {
record("login", r.type + " " + text(r.packet));
}
}
state = "configuration";
outbound = ConfigurationProtocols.SERVERBOUND;
inbound = ConfigurationProtocols.CLIENTBOUND;
// ClientHandshakePacketListenerImpl.handleLoginFinished: brand, then the options.
send(new ServerboundCustomPayloadPacket(new BrandPayload("vanilla")));
send(new ServerboundClientInformationPacket(ClientInformation.createDefault()));
while (true) {
Received r = read();
if (r.packet instanceof ClientboundSelectKnownPacks p) {
record("config", r.type + " " + text(p.knownPacks()));
send(new ServerboundSelectKnownPacks(p.knownPacks()));
} else if (r.packet instanceof ClientboundKeepAlivePacket p) {
record("config", r.type);
send(new ServerboundKeepAlivePacket(p.getId()));
} else if (r.packet instanceof ClientboundPingPacket p) {
record("config", r.type);
send(new ServerboundPongPacket(p.getId()));
} else if (r.packet instanceof ClientboundCustomPayloadPacket p) {
record("config", r.type + " " + text(p.payload()));
} else if (r.packet instanceof net.minecraft.network.protocol.common.ClientboundUpdateTagsPacket p) {
// Each registry's tags and what they hold. Vanilla sends the
// registries and tags in the order of maps keyed by interned
// ResourceKeys (identity hashes), which changes between runs.
var registries = new TreeMap<String, String>();
for (var e : p.tags().entrySet()) {
var tags = new TreeMap<String, String>();
for (var t : e.getValue().tags().entrySet()) {
tags.put(t.getKey().toString(), t.getValue().toString());
}
registries.put(e.getKey().identifier().toString(), tags.size() + " " + sha(tags.toString().getBytes()));
}
record("config", r.type + " " + registries.size() + " registries");
registries.forEach((k, v) -> record("config-tags", k + " " + v));
} else if (r.packet instanceof ClientboundFinishConfigurationPacket) {
record("config", r.type);
send(ServerboundFinishConfigurationPacket.INSTANCE);
break;
} else if (r.packet instanceof ClientboundDisconnectPacket p) {
record("config", r.type + " " + json(p.reason()));
return;
} else {
record("config", r.type + " " + (r.payload.length > 200 ? "sha=" + sha(r.payload) : text(r.packet)));
}
}
play();
}
private void play() throws Exception {
state = "play";
GameProtocols.Context context = new GameProtocols.Context() {
@Override
public boolean hasInfiniteMaterials() {
return false;
}
@Override
public boolean canUseCommandBlocks() {
return false;
}
};
outbound = GameProtocols.SERVERBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(ParityData.access), context);
inbound = GameProtocols.CLIENTBOUND_TEMPLATE.bind(RegistryFriendlyByteBuf.decorator(ParityData.access));
socket.setSoTimeout(250);
Map<String, String> chunks = new TreeMap<>();
Map<String, String> layers = new TreeMap<>();
Map<String, Integer> counts = new TreeMap<>();
boolean ordered = true;
boolean loaded = false;
PositionMoveRotation position = new PositionMoveRotation(Vec3.ZERO, Vec3.ZERO, 0, 0);
long lastChunk = 0;
long deadline = System.currentTimeMillis() + 90_000;
int step = 0;
long stepAt = 0;
while (System.currentTimeMillis() < deadline) {
Received r;
try {
r = read();
} catch (SocketTimeoutException e) {
r = null;
}
long now = System.currentTimeMillis();
if (r != null) {
Packet<?> packet = r.packet;
counts.merge(r.type, 1, Integer::sum);
if (r.type.equals("minecraft:chunk_batch_start")) ordered = false;
if (packet instanceof ClientboundKeepAlivePacket p) {
send(new ServerboundKeepAlivePacket(p.getId()));
} else if (packet instanceof ClientboundPingPacket p) {
send(new ServerboundPongPacket(p.getId()));
} else if (packet instanceof ClientboundPlayerPositionPacket p) {
position = PositionMoveRotation.calculateAbsolute(position, p.change(), p.relatives());
record("play-move", text(position.position()) + " " + position.yRot() + " " + position.xRot());
send(new ServerboundAcceptTeleportationPacket(p.id(), position.position().x, position.position().y, position.position().z,
position.yRot(), position.xRot()));
send(new ServerboundMovePlayerPacket.PosRot(position.position(), position.yRot(), position.xRot(), false, false));
if (!loaded) {
send(new ServerboundPlayerLoadedPacket());
loaded = true;
}
} else if (packet instanceof ClientboundChunkBatchFinishedPacket) {
send(new ServerboundChunkBatchReceivedPacket(64.0F));
} else if (packet instanceof ClientboundLevelChunkWithLightPacket p) {
chunks.put(p.x() + "," + p.z(), chunkHash(p));
layers.put(p.x() + "," + p.z(), lightLayers(p));
lastChunk = now;
int px = (int) Math.floor(position.position().x) >> 4;
int pz = (int) Math.floor(position.position().z) >> 4;
if (p.x() == px && p.z() == pz) chunkParts(p);
} else if (packet instanceof ClientboundSystemChatPacket p && step > 0) {
record("play-chat", "system " + p.overlay() + " " + json(p.content()));
} else if (packet instanceof ClientboundPlayerChatPacket p && step > 0) {
record("play-chat", "player " + p.sender() + " " + p.index() + " " + p.body().content() + " " + p.signature().isPresent()
+ " " + p.unsignedContent().map(VanillaProtocolClient::json) + " " + text(p.filterMask()) + " "
+ p.chatType().chatType().getRegisteredName() + " " + json(p.chatType().name()) + " "
+ p.chatType().targetName().map(VanillaProtocolClient::json));
} else if (packet instanceof ClientboundDisguisedChatPacket p && step > 0) {
record("play-chat", "disguised " + json(p.message()) + " " + p.chatType().chatType().getRegisteredName());
} else if (packet instanceof ClientboundDisconnectPacket p) {
record("play", r.type + " " + json(p.reason()));
break;
}
if (ordered) {
record("play-start", r.type + " " + summary(r));
}
if (packet instanceof net.minecraft.network.protocol.game.ClientboundCommandsPacket p && counts.get(r.type) == 1) {
commandTree(p);
}
}
// Once the chunks stop coming: chat, then /list, then leave.
if (loaded && lastChunk > 0 && now - lastChunk > 3000 && step == 0) {
record("play-chunks", chunks.size() + " " + chunks);
BLOCK_ENTITIES.forEach((k, v) -> record("play-block-entities", k + " " + v));
// Which light layers exist depends on the neighbouring
// columns: compared where all eight were sent.
Map<String, String> inner = new TreeMap<>();
layers.forEach((k, v) -> {
String[] xz = k.split(",");
int x = Integer.parseInt(xz[0]), z = Integer.parseInt(xz[1]);
boolean all = true;
for (int dz = -1; dz <= 1; dz++) for (int dx = -1; dx <= 1; dx++) all &= chunks.containsKey((x + dx) + "," + (z + dz));
if (all) inner.put(k, v);
});
record("play-light-layers", inner.size() + " " + inner);
step = 1;
stepAt = now;
send(new ServerboundChatPacket("hello from the parity client", Instant.now(), 0L, Optional.empty(),
new LastSeenMessages.Update(0, new BitSet(), (byte) 0)));
} else if (step == 1 && now - stepAt > 1500) {
step = 2;
stepAt = now;
send(new ServerboundChatCommandPacket("list"));
} else if (step == 2 && now - stepAt > 1500) {
record("play-counts", "chunks " + counts.getOrDefault("minecraft:level_chunk_with_light", 0));
return;
}
}
record("error", "timed out in play, step " + step + ", chunks " + chunks.size());
}
/**
* A chunk's blocks, biomes, heightmaps and block entities (its
* ClientboundLevelChunkPacketData bytes). The light is left out: both servers relight around chunks
* loaded with their saved light, which test_light_parity covers.
*/
private static final Map<String, String> BLOCK_ENTITIES = new TreeMap<>();
private static String chunkHash(ClientboundLevelChunkWithLightPacket p) {
var data = p.chunkData();
var heightmaps = new TreeMap<String, String>();
data.getHeightmaps().forEach((k, v) -> heightmaps.put(k.getSerializedName(), java.util.Arrays.toString(v)));
FriendlyByteBuf buf = data.getReadBuffer();
byte[] sections = new byte[buf.readableBytes()];
buf.getBytes(buf.readerIndex(), sections);
// What the sections hold, apart from how their palettes encode it.
FriendlyByteBuf copy = new FriendlyByteBuf(Unpooled.wrappedBuffer(sections));
var factory = PalettedContainerFactory.create(ParityData.access);
StringBuilder content = new StringBuilder();
while (copy.isReadable()) {
LevelChunkSection section = new LevelChunkSection(factory);
section.read(copy);
for (int y = 0; y < 16; y++) for (int z = 0; z < 16; z++) for (int x = 0; x < 16; x++) {
content.append(net.minecraft.world.level.block.Block.getId(section.getBlockState(x, y, z))).append(',');
}
for (int y = 0; y < 4; y++) for (int z = 0; z < 4; z++) for (int x = 0; x < 4; x++) {
content.append(section.getNoiseBiome(x, y, z).getRegisteredName()).append(',');
}
}
StringBuilder entities = new StringBuilder();
data.forEachBlockEntityTag(p.x(), p.z(), (pos, type, tag) -> entities.append(pos.toShortString()).append(' ')
.append(net.minecraft.core.registries.BuiltInRegistries.BLOCK_ENTITY_TYPE.getKey(type)).append(' ').append(tag).append(';'));
if (entities.length() > 0) BLOCK_ENTITIES.put(p.x() + "," + p.z(), entities.toString());
return "c" + sha(content.toString().getBytes()).substring(0, 8) + "s" + sha(sections).substring(0, 8) + "h" + sha(heightmaps.toString().getBytes()).substring(0, 8) + "e"
+ sha(entities.toString().getBytes()).substring(0, 8);
}
/** The light layers a chunk has, sky then block (with data or empty). */
private static String lightLayers(ClientboundLevelChunkWithLightPacket p) {
var light = p.lightData();
BitSet sky = (BitSet) light.skyYMask().clone();
sky.or(light.emptySkyYMask());
BitSet block = (BitSet) light.blockYMask().clone();
block.or(light.emptyBlockYMask());
return sky + "/" + block;
}
/** The player's chunk part by part, so a difference in its bytes can be told apart. */
private void chunkParts(ClientboundLevelChunkWithLightPacket p) {
var data = p.chunkData();
for (var e : new TreeMap<>(data.getHeightmaps().entrySet().stream()
.collect(java.util.stream.Collectors.toMap(x -> x.getKey().getSerializedName(), x -> x.getValue()))).entrySet()) {
record("chunk-heightmap", e.getKey() + " " + java.util.Arrays.toString(e.getValue()).hashCode());
}
FriendlyByteBuf buf = data.getReadBuffer();
byte[] all = new byte[buf.readableBytes()];
buf.getBytes(buf.readerIndex(), all);
var factory = PalettedContainerFactory.create(ParityData.access);
int index = 0;
while (buf.isReadable()) {
int start = buf.readerIndex();
LevelChunkSection section = new LevelChunkSection(factory);
section.read(buf);
StringBuilder states = new StringBuilder();
for (int y = 0; y < 16; y++) for (int z = 0; z < 16; z++) for (int x = 0; x < 16; x++) {
states.append(net.minecraft.world.level.block.Block.getId(section.getBlockState(x, y, z))).append(',');
}
StringBuilder biomes = new StringBuilder();
for (int y = 0; y < 4; y++) for (int z = 0; z < 4; z++) for (int x = 0; x < 4; x++) {
biomes.append(section.getNoiseBiome(x, y, z).getRegisteredName()).append(',');
}
byte[] bytes = new byte[buf.readerIndex() - start];
buf.getBytes(start, bytes);
record("chunk-section", index++ + " states=" + sha(states.toString().getBytes()) + " biomes=" + sha(biomes.toString().getBytes())
+ " count=" + (((bytes[0] & 0xFF) << 8) | (bytes[1] & 0xFF)) + " bytes=" + sha(bytes));
}
StringBuilder entities = new StringBuilder();
data.forEachBlockEntityTag(p.x(), p.z(), (pos, type, tag) -> entities.append(pos.toShortString()).append(' ')
.append(net.minecraft.core.registries.BuiltInRegistries.BLOCK_ENTITY_TYPE.getKey(type)).append(' ').append(tag).append(';'));
record("chunk-block-entities", entities.toString());
}
/** The command tree, one line per top-level command with its subtree. */
private void commandTree(net.minecraft.network.protocol.game.ClientboundCommandsPacket p) {
var context = net.minecraft.commands.CommandBuildContext.simple(ParityData.access, net.minecraft.world.flag.FeatureFlags.VANILLA_SET);
var root = p.getRoot(context, new net.minecraft.network.protocol.game.ClientboundCommandsPacket.NodeBuilder<Object>() {
@Override
public com.mojang.brigadier.builder.ArgumentBuilder<Object, ?> createLiteral(String id) {
return com.mojang.brigadier.builder.LiteralArgumentBuilder.literal(id);
}
@Override
public com.mojang.brigadier.builder.ArgumentBuilder<Object, ?> createArgument(String id, com.mojang.brigadier.arguments.ArgumentType<?> type,
net.minecraft.resources.Identifier suggestionId) {
return com.mojang.brigadier.builder.RequiredArgumentBuilder.argument(id + ":" + type.getClass().getSimpleName() + ":" + suggestionId, type);
}
@Override
public com.mojang.brigadier.builder.ArgumentBuilder<Object, ?> configure(com.mojang.brigadier.builder.ArgumentBuilder<Object, ?> input,
boolean executable, boolean restricted) {
if (executable) input.executes(c -> 0);
return input;
}
});
// Vanilla sends each node's children in registration order, which
// its commands report (sorted) does not keep: compared as sets.
var lines = new TreeMap<String, String>();
for (var child : root.getChildren()) {
var paths = new java.util.TreeSet<String>();
describe(child, "", paths, new java.util.IdentityHashMap<>());
lines.put(child.getName(), paths.size() + " " + sha(String.join("\n", paths).getBytes()));
}
lines.forEach((k, v) -> record("play-command", k + " " + v));
}
private static void describe(com.mojang.brigadier.tree.CommandNode<Object> node, String path, java.util.Set<String> out,
java.util.IdentityHashMap<Object, Boolean> seen) {
String here = path + " " + node.getName() + (node.getCommand() != null ? "*" : "");
out.add(here + (node.getRedirect() != null ? " -> " + node.getRedirect().getName() : ""));
if (seen.put(node, true) != null) return;
for (var child : node.getChildren()) describe(child, here, out, seen);
}
/** The first play packets: entity ids, seeds and times aside. */
private String summary(Received r) {
String t = r.type;
if (t.equals("minecraft:login")) {
// levels: the server's level keys, in an identity-hashed order after the overworld.
var login = (net.minecraft.network.protocol.game.ClientboundLoginPacket) r.packet;
var levels = new java.util.TreeSet<String>();
login.levels().forEach(l -> levels.add(l.identifier().toString()));
return text(r.packet).replaceAll("playerId=-?\\d+", "playerId=_").replaceAll("levels=\\[(ResourceKey\\[[^\\]]*\\](, )?)*\\]", "levels=" + levels);
}
if (t.equals("minecraft:set_time") || t.equals("minecraft:keep_alive") || t.equals("minecraft:ping")) return "";
// The tree is compared below, as sets: the children's order is vanilla's registration order.
if (t.equals("minecraft:commands")) return "";
if (t.equals("minecraft:set_entity_data")) {
return text(((net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket) r.packet).packedItems());
}
if (t.contains("entity") || t.equals("minecraft:add_entity") || t.equals("minecraft:update_attributes")
|| t.equals("minecraft:player_info_update") || t.equals("minecraft:player_position")) {
return "";
}
return r.payload.length > 200 ? "sha=" + sha(r.payload) : text(r.packet);
}
}
+392
View File
@@ -0,0 +1,392 @@
#!/usr/bin/env python3
"""The dedicated server against vanilla's, seen from a vanilla client.
The pinned server JAR first generates a world (offline mode, a fixed seed,
respawn_radius 0) and stops; a vanilla dedicated server and Horizon's
(`horizon-client --dedicated --nogui`) then serve copies of it with the same
server.properties, server-icon.png and lists. VanillaProtocolClient, a
headless client made of vanilla's own codecs (any byte vanilla would not
read is an error), pings each server, joins it in offline mode through
login, configuration and play, accepts the spawn teleport, receives the
chunks around the spawn (their bytes are compared: the world is loaded from
the same files), chats, runs /list and leaves. The console then runs `list`
and `say` and `stop`. Compared, all of them exactly:
- the status response (MOTD, players, version, favicon) and the ping;
- the legacy (pre-1.7, 0xFE) ping reply;
- the login and configuration packets in order (compression, profile,
brand, features, known packs, every registry, tags);
- the play packets up to the first chunk batch, in order, with entity ids,
keep-alive ids and times left out; the chunks sent and their bytes; the
replies to the chat message and to /list;
- the console lines about the player, the chat, `list`, `say` and `stop`;
- the files the servers leave: server.properties (but the date line),
eula.txt, ops.json, whitelist.json, banned-players.json, banned-ips.json.
Online mode needs Mojang's session servers and is not tested.
"""
import json
import os
from pathlib import Path
import platform
import re
import shutil
import socket
import struct
import subprocess
import sys
import threading
import time
import zlib
try:
from . import lab, oracle_harness as oh, test_rust_parity as base
except ImportError:
import lab
import oracle_harness as oh
import test_rust_parity as base
NAME = 'dedicated-server-parity'
SEED = 12345
PLAYER = 'Tester'
# Packets Horizon's server does not send yet, listed rather than compared:
# the recipe property sets and stonecutter recipes (ClientboundUpdateRecipes)
# and a player's advancements (ClientboundUpdateAdvancements, and the recipe
# unlocks their first tick grants). Each is reported on every run.
KNOWN_GAPS = {
'minecraft:update_recipes': 'ClientboundUpdateRecipesPacket (recipe property sets, stonecutter recipes)',
'minecraft:update_advancements': 'ClientboundUpdateAdvancementsPacket (player advancements)',
'minecraft:recipe_book_add+': 'recipes unlocked by advancements on the first tick',
}
def gap(line):
"""The known gap a vanilla play-start line belongs to, if any."""
parts = line.split(' ')
if len(parts) < 2 or parts[0] != 'play-start':
return None
if parts[1] in KNOWN_GAPS:
return parts[1]
if parts[1] == 'minecraft:recipe_book_add' and 'entries=[]' not in line:
return 'minecraft:recipe_book_add+'
return None
PROPERTIES = {
'online-mode': 'false',
'white-list': 'false',
'level-seed': str(SEED),
'view-distance': '4',
'simulation-distance': '4',
'spawn-protection': '0',
'max-players': '5',
'motd': '\\u00a7aHorizon \\u00a7rparity \\u00e9t\\u00e9',
'pause-when-empty-seconds': '-1',
}
def free_port():
with socket.socket() as s:
s.bind(('127.0.0.1', 0))
return s.getsockname()[1]
def icon_png():
"""A 64x64 RGBA PNG (server-icon.png)."""
rows = b''.join(b'\0' + b''.join(bytes((x * 4, y * 4, (x ^ y) * 4, 255)) for x in range(64)) for y in range(64))
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', 64, 64, 8, 6, 0, 0, 0))
+ chunk(b'IDAT', zlib.compress(rows)) + chunk(b'IEND', b''))
def write_server_dir(directory, port, world=None):
if directory.exists():
shutil.rmtree(directory)
directory.mkdir(parents=True)
props = dict(PROPERTIES, **{'server-port': str(port)})
(directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()), encoding='iso-8859-1')
(directory / 'eula.txt').write_text('eula=true\n')
(directory / 'server-icon.png').write_bytes(icon_png())
if world is not None:
shutil.copytree(world, directory / 'world')
for lock in (directory / 'world').glob('session.lock'):
lock.unlink()
class Server:
"""A server process with its console on stdin and its log collected."""
def __init__(self, command, directory, log_name):
self.log_path = directory.parent / f'{log_name}.log'
self.log = self.log_path.open('w', encoding='utf-8')
self.lines = []
self.process = subprocess.Popen(list(map(str, command)), cwd=directory, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
encoding='utf-8', errors='replace')
self.reader = threading.Thread(target=self._read, daemon=True)
self.reader.start()
def _read(self):
for line in self.process.stdout:
self.lines.append(line.rstrip('\n'))
self.log.write(line)
self.log.flush()
def wait_for(self, pattern, timeout=300):
deadline = time.time() + timeout
regex = re.compile(pattern)
while time.time() < deadline:
if any(regex.search(l) for l in self.lines):
return
if self.process.poll() is not None:
time.sleep(0.5)
raise AssertionError(f'{self.log_path.name}: server exited ({self.process.returncode}):\n'
+ '\n'.join(self.lines[-30:]))
time.sleep(0.2)
raise AssertionError(f'{self.log_path.name}: no line matching {pattern!r} in {timeout} s:\n' + '\n'.join(self.lines[-30:]))
def console(self, command):
self.process.stdin.write(command + '\n')
self.process.stdin.flush()
def stop(self, timeout=120):
if self.process.poll() is None:
try:
self.console('stop')
self.process.wait(timeout=timeout)
except (BrokenPipeError, subprocess.TimeoutExpired):
self.process.kill()
self.process.wait()
self.reader.join(timeout=10)
self.log.close()
def legacy_ping(port):
"""The reply to a 1.6 client's 0xFE 0x01 0xFA MC|PingHost query (LegacyQueryHandler)."""
host = 'localhost'
data = (b'\xfe\x01\xfa' + struct.pack('>H', 11) + 'MC|PingHost'.encode('utf-16-be')
+ struct.pack('>H', 7 + 2 * len(host)) + bytes([78]) + struct.pack('>H', len(host))
+ host.encode('utf-16-be') + struct.pack('>I', port))
with socket.create_connection(('127.0.0.1', port), timeout=10) as s:
s.sendall(data)
reply = b''
while True:
try:
chunk = s.recv(4096)
except TimeoutError:
return reply.hex() + ' <no close>'
if not chunk:
break
reply += chunk
return reply.hex()
CONSOLE_LINE = re.compile(r'^\[\d\d:\d\d:\d\d\] \[([^\]]+)\]: (.*)$')
KEPT = re.compile(r'Tester|\[Server\]|\[Not Secure\]|There are|Stopping|Saving|ThreadedAnvilChunkStorage|All dimensions|Unknown or incomplete')
def console_lines(lines):
"""The console lines the comparison covers, timestamps and ports aside."""
out = []
for line in lines:
m = CONSOLE_LINE.match(line)
if not m or not KEPT.search(m.group(2)):
continue
text = re.sub(r'/127\.0\.0\.1:\d+', '/127.0.0.1:_', m.group(2))
text = re.sub(r'entity id \d+', 'entity id _', text)
out.append(f'[{m.group(1)}] {text}')
# Vanilla saves its levels in the order of an identity-hashed map, which
# changes between runs: each block of saves is compared sorted.
i = 0
while i < len(out):
j = i
while j < len(out) and 'Saving chunks for level' in out[j]:
j += 1
out[i:j] = sorted(out[i:j])
i = j + 1 if j == i else j
return out
def server_files(directory):
out = []
for name in ['server.properties', 'eula.txt', 'ops.json', 'whitelist.json', 'banned-players.json', 'banned-ips.json']:
path = directory / name
if not path.exists():
out.append(f'{name}: missing')
continue
text = path.read_bytes().decode('iso-8859-1')
if name in ('server.properties', 'eula.txt'):
# The second comment line is the date Properties.store wrote.
text = re.sub(r'^(#[^\n]*\n)#[^\n]*\n', r'\1#<date>\n', text)
# Random per server, and each side has its own port.
text = re.sub(r'\n(management-server-secret|server-port)=[^\n]*', r'\n\1=<varies>', text)
out.append(f'{name}: {text!r}')
return out
def run_side(label, command, directory, client):
server = Server(command, directory, label)
try:
server.wait_for(r'Done \(')
port = int(PROPERTIES_PORTS[label])
legacy = legacy_ping(port)
client(port, directory.parent / f'{label}-client.txt')
time.sleep(1)
server.console('list')
server.console('say console says hi')
server.wait_for(r'\[Server\] console says hi', timeout=30)
finally:
server.stop()
transcript = (directory.parent / f'{label}-client.txt').read_text(encoding='utf-8').splitlines()
return (['legacy-ping ' + legacy] + transcript + ['console ' + l for l in console_lines(server.lines)]
+ ['file ' + l for l in server_files(directory)])
PROPERTIES_PORTS = {}
def horizon_client_joins(vanilla_server, binary, world, build, reference):
"""Horizon's client joins a vanilla dedicated server headless: it must
land where the vanilla client did, receive as many chunks, see its chat
and /list reply, and leave as a vanilla client does (the server's log)."""
label = 'vanilla-for-horizon-client'
PROPERTIES_PORTS[label] = port = free_port()
directory = build / label
write_server_dir(directory, port, world)
client_dir = build / 'horizon-client'
shutil.rmtree(client_dir, ignore_errors=True)
client_dir.mkdir()
report = build / 'horizon-client-report.json'
report.unlink(missing_ok=True)
server = Server(vanilla_server, directory, label)
try:
server.wait_for(r'Done \(')
env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_NET_REPORT=str(report))
with (build / 'horizon-client-run.log').open('w') as log:
subprocess.run([str(c) for c in [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--render-distance', 2,
'--server', f'127.0.0.1:{port}', '--name', PLAYER]],
cwd=client_dir, env=env, stdout=log, stderr=subprocess.STDOUT, timeout=300, check=True)
server.wait_for(r'left the game', timeout=30)
finally:
server.stop()
got = json.loads(report.read_text())
move = next(l for l in reference if l.startswith('play-move'))
want_position = [float(v) for v in re.match(r'play-move \(([^,]+), ([^,]+), ([^)]+)\)', move).groups()]
want_chunks = int(next(l for l in reference if l.startswith('play-counts')).split()[-1])
expected = {
'connected throughout': None,
'spawn position': want_position,
'chunks received': want_chunks,
'own chat shown': True,
'/list reply shown': True,
'server log': ['logged in', 'Tester joined the game', '[Not Secure] <Tester> hello from the horizon client',
'Tester lost connection: Disconnected', 'Tester left the game'],
}
log = '\n'.join(server.lines)
actual = {
'connected throughout': got['error'],
'spawn position': got['position'],
'chunks received': got['chunks'],
'own chat shown': any('<Tester> hello from the horizon client' in c for c in got['chat']),
'/list reply shown': any('There are 1 of a max of 5 players online: Tester' in c for c in got['chat']),
'server log': [k for k in expected['server log'] if k in log],
}
return [f'horizon-client {k}: {"ok" if actual[k] == v else f"expected {v!r}, got {actual[k]!r}"}'
for k, v in expected.items()]
def main():
lock, jars, libraries = base.verify_artifacts()
build = lab.LOCAL / NAME
build.mkdir(parents=True, exist_ok=True)
report = build / 'report.json'
report.unlink(missing_ok=True)
oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaProtocolClient.java'
classes = build / 'classes'
shutil.rmtree(classes, ignore_errors=True)
classes.mkdir()
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
oh.run_logged(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-sourcepath',
lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle],
build, 'compile-java')
oh.run_logged(['cargo', 'build', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], build,
'compile-rust')
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'],
cwd=lab.ROOT, text=True))
binary = Path(metadata['target_directory']) / 'release' / ('horizon-client.exe' if os.name == 'nt' else 'horizon-client')
vanilla_server = ['java', '-Xmx2g', '-Duser.timezone=UTC', '-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
horizon_server = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--dedicated', '--nogui']
# The world, generated once by vanilla.
generate = build / 'generate'
write_server_dir(generate, free_port())
server = Server(vanilla_server, generate, 'generate')
try:
server.wait_for(r'Done \(')
server.console('gamerule respawn_radius 0')
server.wait_for(r'respawn_radius', timeout=30)
# Vanilla keeps no spawn chunks: force-load the area the client is
# sent and its neighbours (the console stands at the world spawn) so
# both servers load full chunks instead of finishing proto-chunks.
server.console('forceload add ~-80 ~-80 ~80 ~80')
server.wait_for(r'chunks in the Overworld are now force loaded|forceloaded|force loaded', timeout=60)
time.sleep(20)
server.console('forceload remove all')
server.console('save-all flush')
server.wait_for(r'Saved the game', timeout=120)
finally:
server.stop()
world = generate / 'world'
(world / 'playerdata').mkdir(exist_ok=True)
def client(port, out):
oh.run_logged(['java', '-Xmx1g', '-Duser.timezone=UTC', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaProtocolClient', '127.0.0.1', port, PLAYER, out], build,
out.stem, timeout=300)
results = {}
for label, command in [('vanilla', vanilla_server), ('horizon', horizon_server)]:
PROPERTIES_PORTS[label] = free_port()
directory = build / label
write_server_dir(directory, PROPERTIES_PORTS[label], world)
results[label] = run_side(label, command, directory, client)
(build / f'{label}.txt').write_text('\n'.join(results[label]) + '\n', encoding='utf-8')
client_checks = horizon_client_joins(vanilla_server, binary, world, build, results['vanilla'])
vanilla, horizon = results['vanilla'], results['horizon']
gaps = sorted({gap(l) for l in vanilla if gap(l)})
vanilla = [l for l in vanilla if not gap(l)]
for g in gaps:
print(f'known gap: {KNOWN_GAPS[g]}')
errors = [l for l in vanilla + horizon if l.startswith('error')] + [l for l in client_checks if not l.endswith(': ok')]
for line in client_checks:
print(line)
differences = []
import difflib
for line in difflib.unified_diff(vanilla, horizon, 'vanilla', 'horizon', n=0, lineterm=''):
differences.append(line[:400])
# Name the chunks that differ instead of the whole line.
chunk_lines = [dict(re.findall(r'(-?\d+,-?\d+)=(\w+)', next((l for l in side if l.startswith('play-chunks')), '')))
for side in (vanilla, horizon)]
for key in sorted(set(chunk_lines[0]) | set(chunk_lines[1])):
a, b = chunk_lines[0].get(key), chunk_lines[1].get(key)
if a != b:
differences.append(f'chunk {key}: vanilla {a} horizon {b}')
if differences or errors:
raise AssertionError(f'{len([d for d in differences if d[:1] in "+-" and d[:3] not in ("+++", "---")])} differing lines '
f'(see {build}/vanilla.txt and horizon.txt):\n' + '\n'.join(differences[:80]))
lab.write_json(report, dict(
schema=1, minecraft=lock['minecraft']['version'], platform=platform.platform(),
java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0],
lines=len(vanilla), known_gaps=[KNOWN_GAPS[g] for g in gaps], output_sha256=lab.digest(build / 'horizon.txt', 'sha256'),
scope='Dedicated server seen by a vanilla-codec client: status, legacy ping, login, configuration, play '
'start, chunks, chat, /list, console list/say/stop, files written. Offline mode.'))
print(f'dedicated server: {len(vanilla)} transcript lines identical')
if __name__ == '__main__':
try:
main()
except AssertionError as error:
sys.exit(f'{NAME}: {error}')
+177
View File
@@ -0,0 +1,177 @@
#!/usr/bin/env python3
"""Compare Mob.finalizeSpawn (spawned mob gear, enchantments and state) with vanilla.
Java (VanillaFinalizeSpawnOracle) creates each case's mobs on a stand-in
ServerLevel and runs vanilla's finalizeSpawn with a seeded level random (what
finalizeSpawn reads through level.getRandom()) and seeded entity randoms; Rust
(finalize_spawn_fixture) runs horizon_client::mobs::finalize on the same case.
Cases cover every mob type, every spawn reason, peaceful to hard, game times,
inhabited times and moon phases (the local difficulty and its special
multiplier), packs sharing group data, biomes (variants, villager types,
sheep colours, rabbit and fox types), structures (black cats), roofs (camel
husk room) and chickens standing by (zombie jockeys).
Each entity created in a case, the mobs and the jockeys finalizeSpawn makes,
is compared: equipment with its enchantments, drop chances, CanPickUpLoot,
LeftHanded, persistence, age, health, attribute values, effects, variants,
the memories finalizeSpawn sets and the vehicle it rides; then the next draw
of every entity random and of the level random, which pins every draw in
between.
"""
import argparse
import json
import os
from pathlib import Path
import platform
import random
import subprocess
try:
from . import lab, test_rust_parity as base
except ImportError:
import lab
import test_rust_parity as base
REASONS = ['NATURAL', 'CHUNK_GENERATION', 'SPAWNER', 'STRUCTURE', 'BREEDING', 'MOB_SUMMONED', 'JOCKEY', 'EVENT',
'CONVERSION', 'REINFORCEMENT', 'TRIGGERED', 'BUCKET', 'SPAWN_ITEM_USE', 'COMMAND', 'DISPENSER', 'PATROL',
'TRIAL_SPAWNER', 'LOAD', 'DIMENSION_TRAVEL']
# Mobs whose finalizeSpawn draws, by how often the corpus picks them.
GEARED = ['zombie', 'husk', 'drowned', 'zombie_villager', 'zombified_piglin', 'skeleton', 'stray', 'bogged', 'parched',
'wither_skeleton', 'pillager', 'vindicator', 'piglin', 'piglin_brute', 'vex', 'fox', 'spider', 'illusioner',
'evoker', 'ravager', 'witch']
OTHERS = ['pig', 'cow', 'mooshroom', 'sheep', 'chicken', 'rabbit', 'horse', 'donkey', 'mule', 'llama', 'trader_llama',
'goat', 'panda', 'polar_bear', 'wolf', 'cat', 'ocelot', 'parrot', 'bee', 'turtle', 'armadillo', 'frog',
'axolotl', 'squid', 'glow_squid', 'cod', 'salmon', 'tropical_fish', 'pufferfish', 'dolphin', 'bat', 'villager',
'wandering_trader', 'iron_golem', 'snow_golem', 'creeper', 'cave_spider', 'enderman', 'endermite',
'silverfish', 'slime', 'magma_cube', 'phantom', 'hoglin', 'zoglin', 'ghast', 'blaze', 'strider', 'guardian',
'elder_guardian', 'shulker', 'camel', 'allay', 'breeze', 'sniffer', 'happy_ghast', 'warden', 'creaking',
'camel_husk', 'nautilus', 'zombie_nautilus', 'sulfur_cube', 'zombie_horse', 'skeleton_horse', 'tadpole',
'giant', 'wither']
BIOMES = ['minecraft:plains', 'minecraft:desert', 'minecraft:snowy_plains', 'minecraft:snowy_taiga', 'minecraft:taiga',
'minecraft:jungle', 'minecraft:bamboo_jungle', 'minecraft:swamp', 'minecraft:mangrove_swamp',
'minecraft:savanna', 'minecraft:badlands', 'minecraft:forest', 'minecraft:grove', 'minecraft:old_growth_pine_taiga',
'minecraft:old_growth_spruce_taiga', 'minecraft:sparse_jungle', 'minecraft:windswept_savanna',
'minecraft:mushroom_fields', 'minecraft:river', 'minecraft:frozen_river', 'minecraft:ocean',
'minecraft:warm_ocean', 'minecraft:lukewarm_ocean', 'minecraft:cold_ocean', 'minecraft:frozen_ocean',
'minecraft:ice_spikes', 'minecraft:cherry_grove', 'minecraft:pale_garden', 'minecraft:dripstone_caves',
'minecraft:lush_caves', 'minecraft:deep_dark', 'minecraft:nether_wastes', 'minecraft:crimson_forest',
'minecraft:soul_sand_valley', 'minecraft:the_end', 'minecraft:snowy_slopes', 'minecraft:frozen_peaks',
'minecraft:wooded_badlands', 'minecraft:beach', 'minecraft:snowy_beach', 'minecraft:meadow',
'minecraft:sulfur_caves']
STRUCTURES = ['minecraft:swamp_hut', 'minecraft:village_plains', 'minecraft:pillager_outpost', 'minecraft:fortress',
'minecraft:trial_chambers']
FLOORS = ['minecraft:grass_block', 'minecraft:sand', 'minecraft:stone', 'minecraft:snow_block', 'minecraft:netherrack']
def dimension(biome):
if biome in ('minecraft:nether_wastes', 'minecraft:crimson_forest', 'minecraft:soul_sand_valley'):
return 'minecraft:the_nether'
if biome == 'minecraft:the_end':
return 'minecraft:the_end'
return 'minecraft:overworld'
def corpus():
rng = random.Random(0x46494E414C)
cases = []
for k in range(int(os.environ.get('FINALIZE_SPAWN_CASES', '24000'))):
kind = rng.choice(GEARED) if rng.random() < 0.55 else rng.choice(OTHERS)
reason = rng.choice(['NATURAL'] * 10 + ['CHUNK_GENERATION', 'SPAWNER', 'STRUCTURE', 'COMMAND', 'SPAWN_ITEM_USE',
'TRIAL_SPAWNER', 'PATROL', 'EVENT', 'JOCKEY'] * 2 + REASONS)
biome = rng.choice(BIOMES)
kv = {
'type': f'minecraft:{kind}',
'reason': reason,
'difficulty': rng.choice(['hard', 'hard', 'normal', 'normal', 'easy', 'peaceful']),
'time': rng.choice([0, 0, 50000, 72000, 400000, 800000, 1512000, 3000000, rng.randrange(0, 4000000)]),
'inhabited': rng.choice([0, 0, 0, 100000, 1000000, 3600000, 5000000, rng.randrange(0, 4000000)]),
'phase': rng.randrange(8),
'seed': rng.randrange(-2**63, 2**63),
'eseed': rng.randrange(-2**47, 2**47),
'pack': rng.choice([1, 1, 1, 2, 3, 4, 6]),
'pos': f'{rng.randrange(-200, 200) + rng.choice([0.5, 0.25, 0.0]):.2f},{rng.randrange(-30, 120)},'
f'{rng.randrange(-200, 200) + rng.choice([0.5, 0.75, 0.0]):.2f}',
'biome': biome,
'dim': dimension(biome),
'floor': rng.choice(FLOORS),
}
if rng.random() < 0.15:
kv['structure'] = rng.choice(STRUCTURES)
if rng.random() < 0.2:
kv['roof'] = rng.choice([1, 2, 3])
if rng.random() < 0.15:
kv['chickens'] = rng.choice([1, 2])
if rng.random() < 0.05:
kv['monsters'] = 0
cases.append(f'case/{k} ' + ' '.join(f'{a}={b}' for a, b in kv.items()))
return cases
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--prepare', action='store_true')
parser.add_argument('--java-only', action='store_true', help='run the oracle and stop')
args = parser.parse_args()
build = lab.LOCAL / 'rust-finalize-spawn-parity'
build.mkdir(parents=True, exist_ok=True)
if args.prepare:
lab.prepare()
lock, jars, libraries = base.verify_artifacts()
resources = lab.LOCAL / 'horizon-client/26.3'
oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaFinalizeSpawnOracle.java'
sources = [oracle, Path(__file__), lab.ROOT / 'crates/horizon-client/examples/finalize_spawn_fixture.rs',
lab.ROOT / 'crates/horizon-client/src/mobs/finalize.rs']
tested = base.source_hashes([s for s in sources if s.exists()])
inputs = build / 'inputs.txt'
cases = corpus()
inputs.write_text(''.join(line + '\n' for line in cases), encoding='utf-8')
classes = build / 'classes'
classes.mkdir(exist_ok=True)
deps = os.pathsep.join(map(str, libraries))
def run(command, name):
path = build / (name + '.log')
with path.open('w', encoding='utf-8') as log:
try:
base.run(list(map(str, command)), stdout=log, stderr=subprocess.STDOUT)
except subprocess.CalledProcessError:
log.flush()
raise SystemExit(f'{name} failed:\n' + path.read_text(errors='replace')[-4000:])
run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-sourcepath', str(lab.ROOT / 'mods/horizon/src/test/java'),
'-cp', str(jars['server']) + os.pathsep + deps, '-d', classes, oracle], 'compile-java')
run(['java', '-Xmx3G', '-cp', os.pathsep.join([str(classes), str(jars['server']), deps]),
'dev.horizonlab.parity.VanillaFinalizeSpawnOracle', inputs, build / 'server.txt'], 'server')
vanilla = (build / 'server.txt').read_text().splitlines()
errors = [l for l in vanilla if ' error ' in l]
if errors:
raise SystemExit(f'oracle errors ({len(errors)}): {errors[:5]}')
if args.java_only:
print(f'{len(vanilla)} oracle lines')
return
halloween = vanilla[0].split()[1]
run(['cargo', 'build', '--release', '-p', 'horizon-client', '--example', 'finalize_spawn_fixture'], 'compile-rust')
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
binary = Path(metadata['target_directory']) / 'release/examples/finalize_spawn_fixture'
run([binary, resources, inputs, build / 'rust.txt', halloween], 'rust')
rust = (build / 'rust.txt').read_text().splitlines()
bad = [(a, b) for a, b in zip(vanilla, rust) if a != b]
if bad or len(vanilla) != len(rust):
report = '\n'.join(f' vanilla {a[:2000]}\n rust {b[:2000]}' for a, b in bad[:12])
raise SystemExit(f'{len(bad)} of {len(vanilla)} lines differ (rust {len(rust)} lines):\n{report}')
base.ensure_sources_unchanged([s for s in sources if s.exists()], tested)
entities = sum(line.count(' | ') for line in vanilla) // 2
enchanted = sum(line.count('[minecraft:') for line in vanilla)
lab.write_json(build / 'report.json', {
'schema': 1, 'minecraft': lock['minecraft']['version'], 'platform': platform.platform(), 'cases': len(cases),
'entities': entities, 'enchanted_items': enchanted, 'sources_sha256': tested,
'scope': 'Mob.finalizeSpawn for every mob type and spawn reason: populateDefaultEquipmentSlots, '
'populateDefaultEquipmentEnchantments through the mob_spawn_equipment and pillager_spawn_crossbow '
'providers, drop chances, CanPickUpLoot, LeftHanded, the follow range spawn bonus, babies and '
'group data, jockeys (chicken, spider, strider, zombie horse, camel husk, zombie nautilus), '
'variants and sound variants, zombie attributes, spider effects, patrol leaders, villager types, '
'cube sizes, horse and llama attributes and the memories finalizeSpawn sets, with every draw of the '
'level random and of the entities\' own randoms.'})
print(f'{len(cases):,} finalizeSpawn cases match vanilla ({entities:,} entities, {enchanted:,} enchanted items)')
if __name__ == '__main__':
main()
+48
View File
@@ -0,0 +1,48 @@
#!/usr/bin/env python3
"""LAN world discovery against the pinned client's LanServerPinger and
LanServerDetection: the announcement an opened world multicasts
(`[MOTD]...[/MOTD][AD]port[/AD]` in UTF-8), and how the multiplayer screen
parses what it hears (parseMotd, parseAddress, UTF-8 decoding of malformed
bytes) and keeps its list (LanServerList.addServer: one entry per
address, the first MOTD kept, never expired while the screen is open).
VanillaLanOracle and the `lan_probe` example must print the same lines."""
import random
try:
from . import oracle_harness as oh
except ImportError:
import oracle_harness as oh
NAME = 'lan-parity'
def make_input(build):
rng = random.Random(4445)
lines = []
motds = ['Player - New World', 'Steve - §aGreen §lWorld', 'été 日本語 ✓', '', '[MOTD]', 'a[/MOTD]b', 'x' * 300,
'tab\\there', '[AD]25565[/AD]']
for motd in motds:
for port in ['25565', '1024', '65535', '0', 'abc', '']:
lines.append(f'ping\t{motd}\t{port}')
fragments = [b'[MOTD]', b'[/MOTD]', b'[AD]', b'[/AD]', b'25565', b'1234', b'Steve - World', b'\xc3\xa9', b'\xe6\x97',
b'\xff', b'\xc0\x80', b'\xed\xa0\x80', b'\xf0\x9f\x98\x80', b'\xf0\x9f', b'abc', b' ', b'\x00', b'-1']
ips = ['192.168.1.10', '10.0.0.2', '127.0.0.1']
good = lambda motd, port: f'[MOTD]{motd}[/MOTD][AD]{port}[/AD]'.encode()
for i in range(400):
if i % 50 == 0:
lines.append('reset')
if rng.random() < 0.4:
data = good(rng.choice(['A - W', 'B - W', 'é', '']), rng.choice(['25565', '25566', 'x', '']))
else:
data = b''.join(rng.choice(fragments) for _ in range(rng.randint(0, 9)))
lines.append(f'heard\t{rng.choice(ips)}\t{data.hex()}')
path = build / 'cases.txt'
path.write_text('\n'.join(lines) + '\n', encoding='utf-8')
return path, len(lines)
if __name__ == '__main__':
oh.differential(NAME, 'VanillaLanOracle', 'lan_probe', make_input,
'LanServerPinger.createPingString/parseMotd/parseAddress, LanServerDetection decoding and '
'LanServerList.addServer/takeDirtyServers',
sources=[oh.lab.ROOT / 'crates/horizon-client/src/lan/discovery.rs'])
+44 -6
View File
@@ -77,6 +77,36 @@ def scenarios():
'player 12.5 -60 0.5',
'mob minecraft:villager 0.5 -60 0.5 0 51 persistent',
])
# Two villagers gossip (TradeWithVillager): what one heard of the player
# passes to the other, weakened, once in 1200 ticks; idle and at the bell.
gossips = ('gossip=player:minor_negative:100 gossip=player:major_positive:15 '
'gossip=player:trading:20 gossip=player:minor_positive:3')
for name, opts, extra in [('villager_gossip_idle', 'time=100', []),
('villager_gossip_bell', 'time=9500', ['block 0 -60 -6 minecraft:bell'])]:
add(name, 400, extra + [
'player 14.5 -60 0.5',
f'mob minecraft:villager 0.5 -60 0.5 0 61 persistent {gossips}',
'mob minecraft:villager 2.5 -60 0.5 180 62 persistent gossip=player:minor_positive:50',
], opts)
# Two villagers with bread breed (VillagerMakeLove): they eat, a baby is
# born and takes a free bed, the parents rest for 6000 ticks.
# PoiManager.take hands out the free beds of a section in hash order:
# the parents claim the two near them, the child gets the only one left.
beds = []
for x in (-6, 3, 6):
beds += [f'block {x} -60 6 minecraft:red_bed[facing=north,part=foot]',
f'block {x} -60 5 minecraft:red_bed[facing=north,part=head]']
for name, seeds in [('villager_breed', (71, 72)), ('villager_breed_2', (73, 74))]:
add(name, 900, beds + [
'player 14.5 -60 0.5',
f'mob minecraft:villager 0.5 -60 0.5 0 {seeds[0]} persistent inv=bread*3',
f'mob minecraft:villager 2.5 -60 0.5 180 {seeds[1]} persistent inv=bread*3 food=4',
], 'time=100')
# Too little food: no breeding.
add('villager_breed_hungry', 400, beds[:2] + [
'mob minecraft:villager 0.5 -60 0.5 0 75 persistent inv=bread*2',
'mob minecraft:villager 2.5 -60 0.5 180 76 persistent inv=bread*3',
], 'time=100')
# Breezes: idle, and fighting a player near, in, and beyond the inner jump circle.
add('breeze_alone', 200, ['mob minecraft:breeze 0.5 -60 0.5 90 61 persistent'])
add('breeze_player', 200, ['player 8.5 -60 0.5', 'mob minecraft:breeze 0.5 -60 0.5 0 62 persistent'])
@@ -155,6 +185,8 @@ def write_scenarios(path, chosen):
lines.append(f'origin {ox} {oz}')
for line in body:
f = line.split()
# `at TICK block ...` changes blocks before that tick; `watch` boxes stay relative.
head, f = (f[:2], f[2:]) if f[0] == 'at' else ([], f)
if f[0] == 'player':
f[1] = repr(float(f[1]) + ox)
f[3] = repr(float(f[3]) + oz)
@@ -169,7 +201,7 @@ def write_scenarios(path, chosen):
f[k] = str(int(f[k]) + ox)
for k in (3, 6):
f[k] = str(int(f[k]) + oz)
lines.append(' '.join(f))
lines.append(' '.join(head + f))
lines.append('end')
path.write_text('\n'.join(lines) + '\n')
@@ -187,6 +219,9 @@ def parse(path):
if parts[1] == 'sound':
cur['sounds'].setdefault(t, []).append(parts[2])
continue
if parts[1] == 'block':
cur.setdefault('blocks', {}).setdefault(t, []).append(parts[2])
continue
if parts[1] == 'trace':
cur.setdefault('trace', {}).setdefault(t, []).append(parts[2])
continue
@@ -286,11 +321,14 @@ def compare(vanilla, rust, fields=None):
report.append(f'{name}: hearts differ at tick {t}: vanilla {v.get("hearts", {}).get(t)} | horizon {r.get("hearts", {}).get(t)}')
clean = False
break
for t in sorted(set(v['sounds']) | set(r['sounds'])):
if v['sounds'].get(t, []) != r['sounds'].get(t, []):
report.append(f'{name}: sounds differ at tick {t}: vanilla {v["sounds"].get(t, [])} | horizon {r["sounds"].get(t, [])}')
clean = False
break
# Sounds and watched block changes: first differing tick.
for kind in ('sounds', 'blocks'):
va, ra = v.get(kind, {}), r.get(kind, {})
for t in sorted(set(va) | set(ra)):
if va.get(t, []) != ra.get(t, []):
report.append(f'{name}: {kind} differ at tick {t}: vanilla {va.get(t, [])} | horizon {ra.get(t, [])}')
clean = False
break
totals['clean'] += clean
if clean:
report.append(f'{name}: all {len(v["ticks"])} ticks match')