Merge branch 'parity/dedicated-server' into parity-base
This commit is contained in:
@@ -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();
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
};
|
||||
|
||||
@@ -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);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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,
|
||||
®istry,
|
||||
);
|
||||
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(())
|
||||
}
|
||||
}
|
||||
@@ -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(§ions),
|
||||
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);
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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,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,
|
||||
|
||||
@@ -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}")));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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}");
|
||||
|
||||
@@ -640,6 +640,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];
|
||||
|
||||
@@ -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,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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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}')
|
||||
@@ -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'])
|
||||
Reference in New Issue
Block a user