Merge current main and preserve axolotl damage behavior

This commit is contained in:
Cosmic
2026-10-14 16:18:08 -04:00
59 changed files with 6796 additions and 328 deletions
+3
View File
@@ -33,6 +33,9 @@ jobs:
runs-on: ${{ matrix.os }}
env:
RUSTFLAGS: ${{ matrix.rustflags }}
# Horizon's Azure app for Microsoft sign-in (docs/microsoft-account.md): a repository
# variable, not a secret. Unset, the launcher says sign-in is not configured.
HORIZON_MSA_CLIENT_ID: ${{ vars.HORIZON_MSA_CLIENT_ID }}
defaults:
run:
working-directory: launcher
Generated
+382
View File
@@ -174,6 +174,12 @@ version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
[[package]]
name = "base64"
version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
[[package]]
name = "bit-set"
version = "0.10.0"
@@ -693,6 +699,15 @@ version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
[[package]]
name = "form_urlencoded"
version = "1.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
dependencies = [
"percent-encoding",
]
[[package]]
name = "futures-core"
version = "0.3.34"
@@ -737,6 +752,17 @@ dependencies = [
"windows-link",
]
[[package]]
name = "getrandom"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
dependencies = [
"cfg-if",
"libc",
"wasi",
]
[[package]]
name = "getrandom"
version = "0.3.4"
@@ -894,6 +920,7 @@ dependencies = [
"pollster",
"serde_json",
"symphonia",
"ureq",
"wgpu",
"winit",
]
@@ -920,8 +947,10 @@ name = "horizon-protocol"
version = "0.1.0"
dependencies = [
"flate2",
"getrandom 0.3.4",
"horizon-world",
"serde_json",
"sha1",
]
[[package]]
@@ -964,6 +993,110 @@ dependencies = [
"cc",
]
[[package]]
name = "icu_collections"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
dependencies = [
"displaydoc",
"potential_utf",
"utf8_iter",
"yoke",
"zerofrom",
"zerovec",
]
[[package]]
name = "icu_locale_core"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
dependencies = [
"displaydoc",
"litemap",
"tinystr",
"writeable",
"zerovec",
]
[[package]]
name = "icu_normalizer"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
dependencies = [
"icu_collections",
"icu_normalizer_data",
"icu_properties",
"icu_provider",
"smallvec",
"zerovec",
]
[[package]]
name = "icu_normalizer_data"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
[[package]]
name = "icu_properties"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
dependencies = [
"displaydoc",
"icu_collections",
"icu_locale_core",
"icu_properties_data",
"icu_provider",
"zerotrie",
"zerovec",
]
[[package]]
name = "icu_properties_data"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
[[package]]
name = "icu_provider"
version = "2.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
dependencies = [
"displaydoc",
"icu_locale_core",
"writeable",
"yoke",
"zerofrom",
"zerotrie",
"zerovec",
]
[[package]]
name = "idna"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
dependencies = [
"idna_adapter",
"smallvec",
"utf8_iter",
]
[[package]]
name = "idna_adapter"
version = "1.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
dependencies = [
"icu_normalizer",
"icu_properties",
]
[[package]]
name = "indexmap"
version = "2.14.2"
@@ -1157,6 +1290,12 @@ version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
[[package]]
name = "litemap"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
[[package]]
name = "litrs"
version = "1.0.0"
@@ -1880,6 +2019,15 @@ dependencies = [
"portable-atomic",
]
[[package]]
name = "potential_utf"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
dependencies = [
"zerovec",
]
[[package]]
name = "presser"
version = "0.3.1"
@@ -2020,6 +2168,20 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"
[[package]]
name = "ring"
version = "0.17.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
dependencies = [
"cc",
"cfg-if",
"getrandom 0.2.17",
"libc",
"untrusted",
"windows-sys 0.52.0",
]
[[package]]
name = "rustc-hash"
version = "1.1.0"
@@ -2061,6 +2223,41 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "rustls"
version = "0.23.46"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf"
dependencies = [
"log",
"once_cell",
"ring",
"rustls-pki-types",
"rustls-webpki",
"subtle",
"zeroize",
]
[[package]]
name = "rustls-pki-types"
version = "1.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
dependencies = [
"zeroize",
]
[[package]]
name = "rustls-webpki"
version = "0.103.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
dependencies = [
"ring",
"rustls-pki-types",
"untrusted",
]
[[package]]
name = "rustversion"
version = "1.0.23"
@@ -2254,6 +2451,12 @@ dependencies = [
"bitflags 2.13.2",
]
[[package]]
name = "stable_deref_trait"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
[[package]]
name = "static_assertions"
version = "1.1.0"
@@ -2266,6 +2469,12 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
[[package]]
name = "subtle"
version = "2.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
[[package]]
name = "symphonia"
version = "0.5.5"
@@ -2359,6 +2568,17 @@ dependencies = [
"unicode-ident",
]
[[package]]
name = "synstructure"
version = "0.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.6",
]
[[package]]
name = "thiserror"
version = "1.0.69"
@@ -2424,6 +2644,16 @@ dependencies = [
"strict-num",
]
[[package]]
name = "tinystr"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
dependencies = [
"displaydoc",
"zerovec",
]
[[package]]
name = "tokio"
version = "1.53.2"
@@ -2520,6 +2750,45 @@ version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
[[package]]
name = "untrusted"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
[[package]]
name = "ureq"
version = "2.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
dependencies = [
"base64",
"log",
"once_cell",
"rustls",
"rustls-pki-types",
"url",
"webpki-roots 0.26.11",
]
[[package]]
name = "url"
version = "2.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
dependencies = [
"form_urlencoded",
"idna",
"percent-encoding",
"serde",
]
[[package]]
name = "utf8_iter"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
[[package]]
name = "uuid"
version = "1.28.0"
@@ -2556,6 +2825,12 @@ dependencies = [
"winapi-util",
]
[[package]]
name = "wasi"
version = "0.11.1+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
[[package]]
name = "wasip2"
version = "1.0.4+wasi-0.2.12"
@@ -2750,6 +3025,24 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "webpki-roots"
version = "0.26.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
dependencies = [
"webpki-roots 1.0.9",
]
[[package]]
name = "webpki-roots"
version = "1.0.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
dependencies = [
"rustls-pki-types",
]
[[package]]
name = "wgpu"
version = "30.0.1"
@@ -3289,6 +3582,12 @@ dependencies = [
"wayland-protocols-wlr",
]
[[package]]
name = "writeable"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
[[package]]
name = "x11-dl"
version = "2.21.0"
@@ -3356,6 +3655,29 @@ version = "0.8.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "550a2b930b62486a393c52d5c3b84bff264b28aa437ed64694d31e93b1757af7"
[[package]]
name = "yoke"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
dependencies = [
"stable_deref_trait",
"yoke-derive",
"zerofrom",
]
[[package]]
name = "yoke-derive"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec8ebde2db3681e8c9980cc27822030e68752690ddfa9473e739aeb4dbde6d71"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.6",
"synstructure",
]
[[package]]
name = "zerocopy"
version = "0.8.60"
@@ -3376,6 +3698,66 @@ dependencies = [
"syn 2.0.119",
]
[[package]]
name = "zerofrom"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
dependencies = [
"zerofrom-derive",
]
[[package]]
name = "zerofrom-derive"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.6",
"synstructure",
]
[[package]]
name = "zeroize"
version = "1.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879"
[[package]]
name = "zerotrie"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
dependencies = [
"displaydoc",
"yoke",
"zerofrom",
]
[[package]]
name = "zerovec"
version = "0.11.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
dependencies = [
"yoke",
"zerofrom",
"zerovec-derive",
]
[[package]]
name = "zerovec-derive"
version = "0.11.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.6",
]
[[package]]
name = "zip"
version = "2.4.2"
+2
View File
@@ -30,6 +30,8 @@ horizon-theme = { path = "../horizon-theme" }
arboard = { version = "3.6.1", default-features = false, features = ["wayland-data-control"] }
# Controllers (evdev + libudev on Linux, IOKit on macOS, Windows.Gaming.Input).
gilrs = "0.11"
# HTTPS to the Minecraft services (online-mode session join).
ureq = { version = "2", default-features = false, features = ["tls"] }
[features]
# Records the call sites of mob random draws (`mob_ai_probe` traces).
+343
View File
@@ -0,0 +1,343 @@
//! The Microsoft account the launcher signed in, handed over in a session
//! file (docs/microsoft-account.md), and the Minecraft services call
//! online-mode servers need: authlib's MinecraftServicesSessionService.joinServer
//! through the services discovery document. The access token stays in this
//! process's memory: it is never logged, printed or written anywhere.
use std::{
path::Path,
sync::{Arc, Mutex, OnceLock},
time::{Duration, SystemTime},
};
/// MinecraftServicesEnvironment.PROD.
pub const DEFAULT_DISCOVERY: &str = "https://discovery.minecraftservices.com/minecraft/client";
/// A session file older than this is refused: it can't be replayed later.
const MAX_SESSION_FILE_AGE: Duration = Duration::from_secs(120);
/// A signed-in account (vanilla's User with type msa).
pub struct AuthSession {
pub name: String,
pub uuid: u128,
pub xuid: Option<String>,
access_token: String,
}
impl std::fmt::Debug for AuthSession {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AuthSession")
.field("name", &self.name)
.field("uuid", &horizon_protocol::crypto::uuid_string(self.uuid))
.field("access_token", &"<hidden>")
.finish()
}
}
/// A UUID with or without dashes.
pub fn parse_uuid(text: &str) -> Option<u128> {
let hex: String = text.chars().filter(|c| *c != '-').collect();
(hex.len() == 32)
.then(|| u128::from_str_radix(&hex, 16).ok())
.flatten()
}
impl AuthSession {
/// For tests and harnesses.
pub fn new(name: &str, uuid: u128, access_token: &str) -> Self {
Self {
name: name.to_owned(),
uuid,
xuid: None,
access_token: access_token.to_owned(),
}
}
/// The session file's JSON: {"name", "uuid", "access_token", "user_type": "msa", "xuid"}.
pub fn parse(text: &str) -> Result<Self, String> {
let v: serde_json::Value =
serde_json::from_str(text).map_err(|_| "the session file is not valid JSON")?;
let field = |k: &str| v.get(k).and_then(|s| s.as_str());
let name = field("name").ok_or("the session file has no name")?;
if name.is_empty() || name.chars().count() > 16 {
return Err("the session file's name is not a valid player name".into());
}
let uuid = field("uuid")
.and_then(parse_uuid)
.ok_or("the session file has no valid uuid")?;
let access_token = field("access_token")
.filter(|t| !t.is_empty())
.ok_or("the session file has no access token")?;
if field("user_type").is_some_and(|t| t != "msa") {
return Err("the session file is not a Microsoft account session".into());
}
Ok(Self {
name: name.to_owned(),
uuid,
xuid: field("xuid").map(str::to_owned),
access_token: access_token.to_owned(),
})
}
/// Read the session file the launcher wrote and delete it at once. It
/// must be fresh and, on Unix, readable by its owner only.
pub fn load(path: &Path) -> Result<Self, String> {
let meta = std::fs::metadata(path).map_err(|e| format!("{}: {e}", path.display()))?;
let refuse = |why: &str| {
let _ = std::fs::remove_file(path);
Err(format!("{}: {why}", path.display()))
};
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
if meta.permissions().mode() & 0o077 != 0 {
return refuse("other users can read it");
}
}
let age = meta
.modified()
.ok()
.and_then(|m| SystemTime::now().duration_since(m).ok())
.unwrap_or_default();
if age > MAX_SESSION_FILE_AGE {
return refuse("it is too old (start the game from the launcher)");
}
let text = std::fs::read_to_string(path);
let _ = std::fs::remove_file(path);
Self::parse(&text.map_err(|e| format!("{}: {e}", path.display()))?)
}
}
static CURRENT: OnceLock<Arc<AuthSession>> = OnceLock::new();
/// The account this game was started with (set once at start).
pub fn set_current(session: AuthSession) {
let _ = CURRENT.set(Arc::new(session));
}
pub fn current() -> Option<Arc<AuthSession>> {
CURRENT.get().cloned()
}
/// Why joining a server through the session service failed, like the
/// AuthenticationException subclasses authlib throws.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum JoinError {
/// No answer, or a 5xx (AuthenticationUnavailableException).
Unavailable,
/// 401 or ForbiddenOperationException (InvalidCredentialsException).
InvalidSession,
/// InsufficientPrivilegesException: multiplayer is off for the account.
InsufficientPrivileges,
/// multiplayer.access.banned or FORCED_USERNAME_CHANGE.
Banned,
/// Anything else, with the service's message.
Other(String),
}
impl JoinError {
/// MinecraftClientHttpException.toAuthenticationException.
pub fn from_response(status: u16, body: &str) -> Self {
let v: serde_json::Value = serde_json::from_str(body).unwrap_or_default();
let error = v.get("error").and_then(|e| e.as_str()).unwrap_or("");
match error {
"ForbiddenOperationException" => return Self::InvalidSession,
"multiplayer.access.banned" | "FORCED_USERNAME_CHANGE" => return Self::Banned,
"InsufficientPrivilegesException" => return Self::InsufficientPrivileges,
_ => {}
}
match status {
401 => Self::InvalidSession,
500.. => Self::Unavailable,
_ => Self::Other(
v.get("errorMessage")
.and_then(|m| m.as_str())
.map_or_else(|| format!("Status: {status}"), str::to_owned),
),
}
}
/// ClientHandshakePacketListenerImpl.authenticateServer's message: the
/// key of the reason inside "disconnect.loginFailedInfo", or its text.
pub fn reason(&self) -> Result<&'static str, &str> {
match self {
Self::Unavailable => Ok("disconnect.loginFailedInfo.serversUnavailable"),
Self::InvalidSession => Ok("disconnect.loginFailedInfo.invalidSession"),
Self::InsufficientPrivileges => Ok("disconnect.loginFailedInfo.insufficientPrivileges"),
Self::Banned => Ok("disconnect.loginFailedInfo.userBanned"),
Self::Other(message) => Err(message),
}
}
}
/// The services discovery document URL: `HORIZON_API_DISCOVERY` overrides
/// it like authlib's `-Dminecraft.api.discovery.host`.
pub fn discovery_url() -> String {
std::env::var("HORIZON_API_DISCOVERY")
.ok()
.filter(|u| !u.is_empty())
.unwrap_or_else(|| DEFAULT_DISCOVERY.to_owned())
}
fn agent() -> ureq::Agent {
ureq::AgentBuilder::new()
.timeout(Duration::from_secs(15))
.user_agent(concat!("Horizon/", env!("CARGO_PKG_VERSION")))
.build()
}
/// The discovery document, fetched once per game (a failure is retried next time).
fn discovery() -> Result<Arc<serde_json::Value>, JoinError> {
static CACHE: Mutex<Option<Arc<serde_json::Value>>> = Mutex::new(None);
if let Some(d) = CACHE.lock().unwrap().clone() {
return Ok(d);
}
let doc: serde_json::Value = agent()
.get(&discovery_url())
.call()
.ok()
.and_then(|r| r.into_string().ok())
.and_then(|t| serde_json::from_str(&t).ok())
.ok_or(JoinError::Unavailable)?;
let doc = Arc::new(doc);
*CACHE.lock().unwrap() = Some(doc.clone());
Ok(doc)
}
/// MinecraftServicesDiscoveryService.getUrl(service, endpoint).
pub fn endpoint(doc: &serde_json::Value, service: &str, name: &str) -> Option<String> {
doc.pointer(&format!("/discovery/{service}/endpoints/{name}/uri"))
.and_then(|u| u.as_str())
.map(str::to_owned)
}
/// The JoinMinecraftServerRequest body; `selectedProfile` is the undashed UUID.
pub fn join_request(session: &AuthSession, server_hash: &str) -> String {
serde_json::json!({
"accessToken": session.access_token,
"selectedProfile": format!("{:032x}", session.uuid),
"serverId": server_hash,
})
.to_string()
}
/// MinecraftServicesSessionService.joinServer: tell the session service this
/// account is joining the server whose hash is `server_hash`.
pub fn join_server(session: &AuthSession, server_hash: &str) -> Result<(), JoinError> {
let doc = discovery()?;
let url = endpoint(&doc, "session", "join").ok_or(JoinError::Unavailable)?;
match agent()
.post(&url)
.set("Content-Type", "application/json; charset=utf-8")
.send_string(&join_request(session, server_hash))
{
Ok(_) => Ok(()),
Err(ureq::Error::Status(status, response)) => Err(JoinError::from_response(
status,
&response.into_string().unwrap_or_default(),
)),
Err(ureq::Error::Transport(_)) => Err(JoinError::Unavailable),
}
}
#[cfg(test)]
mod tests {
use super::*;
const UUID: u128 = 0x069a79f444e94726a5befca90e38aaf5;
fn write(dir: &Path, text: &str, mode: u32) -> std::path::PathBuf {
let path = dir.join("session.json");
std::fs::write(&path, text).unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(mode)).unwrap();
}
let _ = mode;
path
}
#[test]
fn session_files_are_read_once_and_must_be_private() {
let dir = std::env::temp_dir().join(format!("horizon-auth-test-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let text = r#"{"name":"Notch","uuid":"069a79f4-44e9-4726-a5be-fca90e38aaf5","access_token":"mock-token","user_type":"msa"}"#;
let path = write(&dir, text, 0o600);
let s = AuthSession::load(&path).unwrap();
assert_eq!((s.name.as_str(), s.uuid), ("Notch", UUID));
assert!(!path.exists(), "deleted after reading");
assert!(!format!("{s:?}").contains("mock-token"));
#[cfg(unix)]
{
let path = write(&dir, text, 0o644);
assert!(
AuthSession::load(&path)
.unwrap_err()
.contains("other users")
);
assert!(!path.exists());
}
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn session_file_fields() {
assert!(
AuthSession::parse(r#"{"name":"Notch","uuid":"069a79f444e94726a5befca90e38aaf5"}"#)
.is_err()
);
assert!(
AuthSession::parse(
r#"{"name":"","uuid":"069a79f444e94726a5befca90e38aaf5","access_token":"t"}"#
)
.is_err()
);
assert!(AuthSession::parse(r#"{"name":"A","uuid":"nope","access_token":"t"}"#).is_err());
assert!(AuthSession::parse(r#"{"name":"A","uuid":"069a79f444e94726a5befca90e38aaf5","access_token":"t","user_type":"legacy"}"#).is_err());
let s = AuthSession::parse(r#"{"name":"A","uuid":"069a79f444e94726a5befca90e38aaf5","access_token":"t","xuid":"25"}"#).unwrap();
assert_eq!(s.xuid.as_deref(), Some("25"));
}
#[test]
fn join_request_like_authlib() {
let s = AuthSession::new("Notch", UUID, "tok");
let v: serde_json::Value = serde_json::from_str(&join_request(&s, "-7c9d")).unwrap();
assert_eq!(
v,
serde_json::json!({"accessToken": "tok", "selectedProfile": "069a79f444e94726a5befca90e38aaf5", "serverId": "-7c9d"})
);
}
#[test]
fn errors_map_like_authlib() {
let e = |status, body| JoinError::from_response(status, body);
assert_eq!(
e(
403,
r#"{"error":"ForbiddenOperationException","errorMessage":"Invalid token"}"#
),
JoinError::InvalidSession
);
assert_eq!(e(401, ""), JoinError::InvalidSession);
assert_eq!(
e(403, r#"{"error":"InsufficientPrivilegesException"}"#),
JoinError::InsufficientPrivileges
);
assert_eq!(
e(403, r#"{"error":"multiplayer.access.banned"}"#),
JoinError::Banned
);
assert_eq!(e(503, "down"), JoinError::Unavailable);
assert_eq!(
e(429, r#"{"errorMessage":"Too many"}"#),
JoinError::Other("Too many".into())
);
assert_eq!(
JoinError::InvalidSession.reason(),
Ok("disconnect.loginFailedInfo.invalidSession")
);
}
#[test]
fn discovery_endpoints() {
let doc = serde_json::json!({"discovery": {"session": {"endpoints": {"join": {"uri": "https://s/join"}}}}});
assert_eq!(
endpoint(&doc, "session", "join").as_deref(),
Some("https://s/join")
);
assert_eq!(endpoint(&doc, "session", "verify"), None);
}
}
+34 -1
View File
@@ -628,7 +628,8 @@ impl Enchantments {
} else {
spec
};
spec.is_null() && entity.is_some() || self.entity_matches(spec, entity)
(spec.is_null() && entity.is_some() || self.entity_matches(spec, entity))
&& movement_matches(&c["predicate"], role_state(c, ctx))
}
"minecraft:random_chance" => {
let chance = match &c["chance"] {
@@ -661,6 +662,38 @@ pub struct EffectContext<'a> {
pub this: Option<&'a str>,
pub attacker: Option<&'a str>,
pub direct_attacker: Option<&'a str>,
/// The direct attacker's fall distance and whether it flies (elytra or
/// abilities), for `movement` and `flags` predicates.
pub direct_motion: Option<(f64, bool)>,
}
/// The fall distance and flying flag known for an `entity_properties` role.
fn role_state(c: &Value, ctx: &EffectContext<'_>) -> Option<(f64, bool)> {
match c["entity"].as_str().unwrap_or("this") {
"direct_attacker" => ctx.direct_motion,
_ => None,
}
}
/// `EntityPredicate`'s `minecraft:movement` fall distance and
/// `minecraft:flags` is_flying (the parts enchantment requirements use); an
/// entity whose state is unknown matches neither.
fn movement_matches(predicate: &Value, state: Option<(f64, bool)>) -> bool {
let fall = &predicate["minecraft:movement"]["fall_distance"];
let flying = predicate["minecraft:flags"]["is_flying"].as_bool();
if fall.is_null() && flying.is_none() {
return true;
}
let Some((distance, is_flying)) = state else {
return false;
};
// MinMaxBounds.Doubles: a number is an exact bound.
let bound = |key: &str| {
fall.as_f64()
.or_else(|| fall.get(key).and_then(Value::as_f64))
};
// MinMaxBounds.Doubles.matches
bound("min").is_none_or(|min| min <= distance)
&& bound("max").is_none_or(|max| distance <= max)
&& flying.is_none_or(|f| f == is_flying)
}
fn next_int<R: RandomSource>(random: &mut R, bound: i32) -> i32 {
random.next_int_bound(bound.max(1)).unwrap_or(0)
+128 -52
View File
@@ -58,6 +58,7 @@ mod level_particles;
mod lightning;
mod llamas;
mod loom;
mod mace;
mod machines;
mod maps;
mod minecarts;
@@ -88,6 +89,7 @@ mod recipe_book;
mod remote;
mod render_control;
mod render_tick;
mod respawn_anchor;
mod scoreboard;
mod screens;
mod sculk;
@@ -246,12 +248,13 @@ impl Options {
player_name: std::env::var("HORIZON_PLAYER_NAME").unwrap_or_else(|_| "Player".into()),
dedicated: None,
};
let mut session_file = std::env::var("HORIZON_SESSION_FILE").ok();
let mut args = std::env::args().skip(1);
while let Some(arg) = args.next() {
match arg.as_str() {
"--help" | "-h" => {
println!(
"Horizon — Minecraft Java Edition 26.3 in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --smoke-report PATH Write a JSON report on exit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default Player)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause."
"Horizon — Minecraft Java Edition 26.3 in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --smoke-report PATH Write a JSON report on exit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default Player)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause."
);
return Ok(None);
}
@@ -295,6 +298,7 @@ impl Options {
"--world" => o.world = Some(value),
"--server" => o.server = Some(value),
"--name" => o.player_name = value,
"--session-file" => session_file = Some(value),
"--control-socket" => o.control = Some(value.into()),
"--time" => o.time = Some(value.parse()?),
"--weather" => o.weather = Some(value),
@@ -314,6 +318,17 @@ impl Options {
}
}
}
// The launcher's account: online-mode servers need it. A bad file
// only leaves the game offline.
if let Some(path) = session_file.filter(|p| !p.is_empty()) {
match horizon_client::auth::AuthSession::load(path.as_ref()) {
Ok(session) => {
o.player_name = session.name.clone();
horizon_client::auth::set_current(session);
}
Err(e) => eprintln!("Horizon: not signed in: {e}"),
}
}
Ok(Some(o))
}
}
@@ -791,6 +806,11 @@ struct Game<'a> {
portals: nether_portal::Portals,
/// The pending travel goes through an End portal (EndPortalBlock destinations).
end_travel: bool,
/// The respawn point when it is not the world spawn or a bed: a respawn
/// anchor (`game/respawn_anchor.rs`).
respawn_config: Option<respawn_anchor::RespawnConfig>,
/// A respawn travelling to its anchor's dimension and chunks.
respawn_travel: Option<respawn_anchor::RespawnConfig>,
/// The next enter_dimension call comes from an End portal.
end_portal_travel: bool,
end: end::EndState,
@@ -1654,6 +1674,11 @@ impl Game<'_> {
LevelEvent::LevelEvent { id: 2004, pos, .. } => {
self.spawner_burst([pos.x, pos.y, pos.z])
}
LevelEvent::LevelEvent {
id: 2013,
pos,
data,
} => self.smash_dust(pos, data),
LevelEvent::LevelEvent {
id: id @ 3002..=3005,
pos,
@@ -1731,6 +1756,9 @@ impl Game<'_> {
}
LevelEvent::Player { pos, effect, .. } => match effect {
PlayerEffect::OpenMenu => self.open_menu([pos.x, pos.y, pos.z]),
PlayerEffect::Sleep if self.beds_destroy_on_use() => {
self.destroy_bed_on_use([pos.x, pos.y, pos.z])?
}
PlayerEffect::Sleep => self.try_sleep([pos.x, pos.y, pos.z]),
PlayerEffect::GiveItem(item) => {
if let Some(rest) = self.give(ItemStack {
@@ -1751,7 +1779,10 @@ impl Game<'_> {
food.saturation = (food.saturation + 0.4).min(food.food as f32);
}
}
PlayerEffect::InteractLoot(_) | PlayerEffect::RespawnAnchor => {}
PlayerEffect::RespawnAnchor => {
self.respawn_anchor_used([pos.x, pos.y, pos.z])?
}
PlayerEffect::InteractLoot(_) => {}
},
LevelEvent::PrimeTnt { pos, rot } => self.add_primed_tnt(pos, rot, 80),
LevelEvent::BlockEvent {
@@ -2145,6 +2176,7 @@ impl Game<'_> {
return Ok(());
}
let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
let mut anchor_passed = None;
// MultiPlayerGameMode.useItemOn: blocks react first unless sneaking with an item.
if !(sneaking && self.held().is_some())
&& let Some(hit) = self.pick()
@@ -2162,6 +2194,15 @@ impl Game<'_> {
self.swing_arm();
return Ok(());
}
match self.use_respawn_anchor(hit.pos, held.as_ref())? {
respawn_anchor::AnchorUse::Charged => {
self.swing_arm();
return Ok(());
}
// The main hand passes; its item is used, then the off hand's glowstone.
respawn_anchor::AnchorUse::Pass => anchor_passed = Some(hit.pos),
respawn_anchor::AnchorUse::Other => {}
}
let face = match hit.face {
[0, 1, 0] => Direction::Up,
[0, -1, 0] => Direction::Down,
@@ -2183,17 +2224,21 @@ impl Game<'_> {
};
let at = Vec3::new(hit.point[0], hit.point[1], hit.point[2]);
let item = held.as_ref().map(|s| s.item.to_string());
let result = self.with_level(|b, level, ticks| {
b.use_item_on(
level,
ticks,
BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
face,
at,
player,
item.as_deref(),
)
});
let result = if anchor_passed.is_some() {
horizon_world::level::InteractionResult::Pass
} else {
self.with_level(|b, level, ticks| {
b.use_item_on(
level,
ticks,
BlockPos::new(hit.pos[0], hit.pos[1], hit.pos[2]),
face,
at,
player,
item.as_deref(),
)
})
};
self.process_level_events()?;
if result.consumes_action() {
self.swing_arm();
@@ -2201,6 +2246,12 @@ impl Game<'_> {
}
}
let Some(stack) = self.held().cloned() else {
// Minecraft.startUseItem goes on to the off hand.
if let Some(pos) = anchor_passed
&& self.charge_anchor_from_offhand(pos)?
{
return Ok(());
}
self.use_offhand();
return Ok(());
};
@@ -2272,6 +2323,11 @@ impl Game<'_> {
return Ok(());
};
if info.block.is_none() {
if let Some(pos) = anchor_passed
&& self.charge_anchor_from_offhand(pos)?
{
return Ok(());
}
self.use_offhand();
return Ok(());
}
@@ -2619,7 +2675,10 @@ impl Game<'_> {
self.streaming.center = (cx, cz);
if (-2..=2).all(|dz| (-2..=2).all(|dx| self.streaming.is_lit(cx + dx, cz + dz))) {
let (player, target) = self.travelling.take().ok_or("travel")?;
if self.end_travel {
if let Some(config) = self.respawn_travel.take() {
drop(player);
self.place_respawned(config)?;
} else if self.end_travel {
self.place_after_end_travel(player, target)?;
} else {
self.place_after_travel(player, target)?;
@@ -2922,6 +2981,11 @@ impl Game<'_> {
MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
MotionEvent::InsidePortal { pos } => self.player_inside_nether_portal(pos),
MotionEvent::SmashLanding {
state,
position,
fall_distance,
} => self.smash_landing_particles(state, position, fall_distance),
_ => {}
}
}
@@ -3156,6 +3220,7 @@ impl Game<'_> {
/// `Minecraft.pause`: a single-player game with a pausing screen open.
fn pauses_game(&self) -> bool {
self.remote.is_none()
&& self.lan.is_none()
&& self.title.is_none()
&& (matches!(
self.screen,
@@ -5274,19 +5339,20 @@ impl Game<'_> {
let delay = 20.0 / speed;
let scale = ((self.attack_ticks as f32 + 0.5) / delay).clamp(0.0, 1.0);
let mut amount = damage * (0.2 + scale * scale * 0.8);
let target_kind = self.mobs[index].kind.id.clone();
let target_kind = format!("minecraft:{}", target_kind.trim_start_matches("minecraft:"));
// Item.getAttackDamageBonus (a mace's smash), before the critical hit.
amount += self.smash_damage_bonus(&target_kind);
let player = self.player.as_ref();
// Player.canCriticalAttack: falling, off the ground, not sprinting.
let falling =
player.is_some_and(|p| !p.ground.on_ground && p.velocity.y < 0.0 && !p.sprinting);
player.is_some_and(|p| !p.ground.on_ground && p.fall_distance > 0.0 && !p.sprinting);
let crit = scale > 0.9 && falling;
if crit {
amount *= 1.5;
}
// Enchantment damage (sharpness, smite, bane) scaled by the attack strength.
let target_kind = self.mobs[index].kind.id.clone();
amount += self.enchant_damage_bonus(&format!(
"minecraft:{}",
target_kind.trim_start_matches("minecraft:")
)) * scale;
amount += self.enchant_damage_bonus(&target_kind) * scale;
self.attack_ticks = 0;
if let Some(p) = self.player.as_mut()
&& !self.creative
@@ -5298,21 +5364,23 @@ impl Game<'_> {
self.swing_arm();
// LivingEntity.setLastHurtMob (tamed wolves join in).
self.combat.last_hurt_mob = Some((self.mobs[index].id, self.world.game_time));
let mob = &mut self.mobs[index];
let center = [
mob.position.x,
mob.position.y + mob.kind.height / 2.0,
mob.position.z,
];
let dealt = (amount.min(mob.health.max(0.0)) * 10.0).round() as i32;
if mob.hurt(amount, from, &mut self.world.random) {
self.stats.custom("damage_dealt", dealt);
let old_health = self.mobs[index].health;
let source = match from {
Some(f) => self.attack_source(f),
None => horizon_client::mobs::Damage::of(horizon_client::mobs::DamageKind::Generic),
};
if self.hurt_by_player(index, amount, source) {
let mob = &self.mobs[index];
// Player.damageStatsAndHearts: the damage the hit actually did.
let actual = old_health - mob.health;
// Player.attack: crit emitter and damage indicator hearts.
let (feet, width, height) = (
[mob.position.x, mob.position.y, mob.position.z],
mob.kind.width,
mob.kind.height,
);
self.stats
.custom("damage_dealt", (actual * 10.0).round() as i32);
if crit {
self.particles.tracking_emitter(
horizon_client::particles::ParticleOptions::simple(
@@ -5323,7 +5391,7 @@ impl Game<'_> {
height,
);
}
if amount > 2.0 {
if actual > 2.0 {
let indicator = horizon_client::particles::ParticleOptions::simple(
horizon_client::particles::ParticleType::DamageIndicator,
);
@@ -5332,10 +5400,10 @@ impl Game<'_> {
[feet[0], feet[1] + height * 0.5, feet[2]],
[0.1, 0.0, 0.1],
0.2,
(amount * 0.5) as u32,
(actual * 0.5) as u32,
);
}
self.last_hurt_by_player.insert(mob.id);
self.last_hurt_by_player.insert(self.mobs[index].id);
let sound = if crit {
"minecraft:entity.player.attack.crit"
} else if scale > 0.9 {
@@ -5343,33 +5411,21 @@ impl Game<'_> {
} else {
"minecraft:entity.player.attack.weak"
};
self.audio.play(sound, Some(center), 1.0, 1.0);
// Player.playServerSideSound: at the player.
self.audio.play(sound, from, 1.0, 1.0);
// The hurt or death sound the mob raised (getHurtSound / getDeathSound,
// its voice pitch from its own random).
let queued = std::mem::take(&mut self.mobs[index].outbox);
for event in queued {
if let horizon_client::mobs::MobEvent::Sound(s, _, volume, pitch) = event {
if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event {
self.audio
.play(&format!("minecraft:{s}"), Some(center), volume, pitch);
}
}
self.post_attack(index);
if let Some(stack) = self.inventory[self.selected].clone()
&& let Some(max) = self
.res
.items
.get(&stack.item)
.filter(|i| i.max_damage > 0)
.map(|i| i.max_damage)
{
let loss = self.durability_loss(&stack, 1);
if let Some(stack) = self.inventory[self.selected].as_mut() {
stack.damage += loss;
if stack.damage >= max {
self.inventory[self.selected] = None;
}
.play(&format!("minecraft:{s}"), Some(at), volume, pitch);
}
}
self.weapon_hit(index);
} else {
self.audio
.play("minecraft:entity.player.attack.nodamage", from, 1.0, 1.0);
}
true
}
@@ -5784,6 +5840,17 @@ impl Game<'_> {
self.travelling = None;
self.player = None;
self.spawn = None;
self.respawn_travel = None;
self.respawn_config =
self.level
.respawn_elsewhere
.as_ref()
.map(|(dim, pos, yaw, forced)| respawn_anchor::RespawnConfig {
dim: Dim::from_id(dim),
pos: *pos,
yaw: *yaw,
forced: *forced,
});
self.spawn_search = 0;
self.spawn_origin = None;
self.spawn_spiral = Default::default();
@@ -6073,6 +6140,7 @@ impl Game<'_> {
if self.remote.is_none() {
self.stats.custom("leave_game", 1);
}
self.lan_close(false);
self.save_game()
}
fn close_world(&mut self) -> Result<()> {
@@ -6086,6 +6154,7 @@ impl Game<'_> {
}
self.stats.custom("leave_game", 1);
self.save_game()?;
self.lan_close(false);
horizon_client::crash::clear_detail("World");
self.streaming.paused = true;
self.world = World::new(self.res.facts.air, 0);
@@ -7300,6 +7369,8 @@ impl Game<'_> {
f64::from(head[1]) + 0.6,
f64::from(head[2]) + 0.5,
));
// The bed replaces a respawn anchor.
self.respawn_config = None;
self.level.spawn = Some([
f64::from(head[0]),
f64::from(head[1]) + 1.0,
@@ -7677,6 +7748,9 @@ impl Game<'_> {
level.weather = self.world.weather;
level.day_time = self.world.day_time;
level.spawn = self.spawn.map(|s| [s.x, s.y, s.z]);
level.respawn_elsewhere = self
.respawn_config
.map(|c| (c.dim.id().to_owned(), c.pos, c.yaw, c.forced));
level.rotation = [self.yaw, self.pitch];
level.xp_level = self.experience.level;
level.xp_progress = self.experience.progress;
@@ -9267,6 +9341,8 @@ pub fn run() -> Result<()> {
travelling: None,
portals: Default::default(),
end_travel: false,
respawn_config: None,
respawn_travel: None,
end_portal_travel: false,
end: Default::default(),
block_ticks: Ticks::new(0),
@@ -2010,6 +2010,7 @@ impl Game<'_> {
f64::from(pos[1]),
f64::from(pos[2]) + 0.5,
));
self.respawn_config = None;
let dim = Text::literal(self.dim.id());
let p = pos.map(|v| Text::literal(v.to_string()));
let mut args = vec![
@@ -89,6 +89,7 @@ impl Game<'_> {
fn damage_kind(ty: &str) -> DamageKind {
match ty.trim_start_matches("minecraft:") {
"player_attack" => DamageKind::PlayerAttack,
"mace_smash" => DamageKind::MaceSmash,
"mob_attack" | "mob_attack_no_aggro" => DamageKind::MobAttack,
"arrow" => DamageKind::Arrow,
"thrown" | "trident" | "mob_projectile" => DamageKind::Thrown,
@@ -2596,6 +2596,7 @@ fn damage_type(kind: horizon_client::mobs::DamageKind, player: bool) -> &'static
use horizon_client::mobs::DamageKind as K;
match kind {
K::PlayerAttack => "minecraft:player_attack",
K::MaceSmash => "minecraft:mace_smash",
K::MobAttack => "minecraft:mob_attack",
K::Arrow => "minecraft:arrow",
K::Thrown => "minecraft:thrown",
@@ -59,8 +59,18 @@ pub(super) fn record_events(events: &[horizon_world::level::LevelEvent]) {
}
}
/// Java's `String.format("%.6f")`: the exact value rounded half up (away
/// from zero) where Rust rounds a tie to even.
fn num(v: f64) -> String {
format!("{v:.6}")
let exact = format!("{:.40}", v.abs());
let tie = exact
.split_once('.')
.is_some_and(|(_, f)| f[6..].starts_with('5') && f[7..].bytes().all(|b| b == b'0'));
if tie {
format!("{:.6}", v + 0.5e-6_f64.copysign(v))
} else {
format!("{v:.6}")
}
}
fn floor_pos(p: [f64; 3]) -> String {
format!(
@@ -137,6 +147,8 @@ impl Game<'_> {
// Hopper cooldowns of an earlier case.
self.hoppers.clear();
self.ui.rules = Default::default();
self.dim = super::Dim::Overworld;
self.respawn_config = None;
// The oracle level plays on normal difficulty.
self.ui.difficulty = 2;
// The oracle level has world seed 0 and fresh random sequences.
@@ -162,6 +174,11 @@ impl Game<'_> {
}
}
self.world.game_time = case["time"].as_i64().unwrap_or(0);
match case["dim"].as_str() {
Some("nether") => self.dim = super::Dim::Nether,
Some("end") => self.dim = super::Dim::End,
_ => {}
}
// The oracle level's clock stands at day time 6000.
self.world.day_time = 6000;
if let Some(rules) = case["rules"].as_object() {
@@ -272,6 +289,28 @@ impl Game<'_> {
used = self.fixture_use(origin, op)?;
} else if let Some(op) = case.get("use_item") {
used = self.fixture_use_item(origin, op)?;
} else if let Some(op) = case.get("respawn_at") {
// ServerPlayer.findRespawnAndUseSpawnBlock for a respawn point at the origin.
let config = super::respawn_anchor::RespawnConfig {
dim: self.dim,
pos: [origin.x, origin.y, origin.z],
yaw: 0.0,
forced: op["forced"].as_bool().unwrap_or(false),
};
let found =
self.find_respawn_and_use(config, op["consume"].as_bool().unwrap_or(true))?;
used.push(match found {
Some((p, yaw)) => format!(
"respawn {} {} {} {}",
num(p.x),
num(p.y),
num(p.z),
yaw.to_bits() as i32
),
None => "respawn none".to_owned(),
});
} else if let Some(op) = case.get("attack") {
used = self.fixture_attack(op, &targets)?;
} else if case.get("hopper").is_some() {
// HopperBlockEntity.pushItemsTick, once.
self.hopper_try_move_items((origin.x, origin.y, origin.z));
@@ -447,14 +486,24 @@ impl Game<'_> {
GameMode::Survival
};
self.creative = self.mode == GameMode::Creative;
let distance = op["distance"].as_f64().unwrap_or(3.0);
let mut player = PlayerMotion::new(
self.motion,
horizon_core::geometry::Vec3::new(
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 1.0,
f64::from(pos.z) + 3.5,
f64::from(pos.z) + 0.5 + distance,
),
)?;
if let Some(r) = op["respawn"].as_array() {
let p = |i: usize| r.get(i).and_then(Value::as_i64).unwrap_or(0) as i32;
self.respawn_config = Some(super::respawn_anchor::RespawnConfig {
dim: self.dim,
pos: [p(0), p(1), p(2)],
yaw: 0.0,
forced: false,
});
}
player.health.food.food = op["food"].as_i64().unwrap_or(20) as i32;
self.player = Some(player);
self.yaw = 0.0;
@@ -488,7 +537,10 @@ impl Game<'_> {
let key = m.component()["translate"]
.as_str()
.map_or_else(|| m.plain(), str::to_owned);
out.push(format!("msg {key}"));
// The oracle player's advancements are not tracked.
if !key.starts_with("chat.type.advancement") {
out.push(format!("msg {key}"));
}
}
if let Some(s) = &stack {
let used = self.stats.get("used", &s.item) - used_before;
@@ -504,11 +556,134 @@ impl Game<'_> {
"held {} using {using}",
canon_stack(self.inventory[self.selected].as_ref())
));
out.push(match self.respawn_config {
Some(c) => format!(
"respawn {} {},{},{}",
c.dim.id(),
c.pos[0],
c.pos[1],
c.pos[2]
),
None => "respawn -".to_owned(),
});
self.player = None;
self.using = None;
Ok(out)
}
/// The player's hit on the first target with the case's item, from the
/// attack strength's scaled `base` damage on: the item's damage bonus and
/// source, the hurt with the weapon's armor effects, then `weapon_hit`
/// (the mace's smash, post-attack enchantments, the wear), as
/// `VanillaDispenserOracle.attack` prints them.
fn fixture_attack(&mut self, op: &Value, targets: &[Target]) -> Result<Vec<String>> {
let stack = parse_stack(op["item"].as_str().unwrap_or("-"))?;
self.mode = if op["creative"].as_bool().unwrap_or(false) {
GameMode::Creative
} else {
GameMode::Survival
};
self.creative = self.mode == GameMode::Creative;
let v3 = |v: &Value| {
horizon_core::geometry::Vec3::new(
v[0].as_f64().unwrap_or(0.0),
v[1].as_f64().unwrap_or(0.0),
v[2].as_f64().unwrap_or(0.0),
)
};
let mut player = PlayerMotion::new(self.motion, v3(&op["player"]))?;
player.velocity = v3(&op["motion"]);
player.fall_distance = op["fall"].as_f64().unwrap_or(0.0);
player.fall_flying = op["fall_flying"].as_bool().unwrap_or(false);
player.flying = op["flying"].as_bool().unwrap_or(false);
player.may_fly = self.creative;
if !op["impact"].is_null() {
player.impulse.impact_position = Some(v3(&op["impact"]));
}
let feet = [player.position.x, player.position.y, player.position.z];
self.player = Some(player);
self.inventory[self.selected] = stack.clone();
let used_before = stack
.as_ref()
.map_or(0, |s| self.stats.get("used", &s.item));
let Some(&Target::Mob(id)) = targets.first() else {
return Err("an attack case hits a mob".into());
};
let index = self
.mobs
.iter()
.position(|m| m.id == id)
.ok_or("the target is gone")?;
let kind = self.mobs[index].kind.id.clone();
let base = op["base"].as_f64().unwrap_or(0.0) as f32;
let bonus = self.smash_damage_bonus(&kind);
let source = self.attack_source(feet);
let hurt = self.hurt_by_player(index, base + bonus, source);
// The hurt sound the mob raised, where it stands.
for event in std::mem::take(&mut self.mobs[index].outbox) {
if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event {
self.audio
.play(&format!("minecraft:{s}"), Some(at), volume, pitch);
}
}
if hurt {
self.weapon_hit(index);
}
self.process_level_events()?;
let mut out = Vec::new();
if let Some(s) = &stack {
let used = self.stats.get("used", &s.item) - used_before;
if used != 0 {
out.push(format!("stat {} minecraft:used {used}", s.item));
}
}
let source = match source.kind {
horizon_client::mobs::DamageKind::MaceSmash => "minecraft:mace_smash",
_ => "minecraft:player_attack",
};
out.push(format!(
"attack bonus={} source={source} hurt={hurt}",
num(f64::from(bonus))
));
for (i, t) in targets.iter().enumerate() {
let (health, v) = match *t {
Target::Mob(id) => match self.mobs.iter().find(|m| m.id == id) {
Some(m) => (num(f64::from(m.health)), m.velocity),
None => continue,
},
Target::Stand(id) => match self.armor_stands.iter().find(|s| s.id == id) {
Some(s) => ("-".to_owned(), s.velocity),
None => continue,
},
};
out.push(format!(
"V {i} {health} {} {} {}",
num(v.x),
num(v.y),
num(v.z)
));
}
if let Some(p) = self.player.take() {
let impact = p.impulse.impact_position.map_or("-".to_owned(), |i| {
format!("{},{},{}", num(i.x), num(i.y), num(i.z))
});
out.push(format!(
"P {} {} {} fall={} impact={impact} grace={} extra={}",
num(p.velocity.x),
num(p.velocity.y),
num(p.velocity.z),
num(p.fall_distance),
p.impulse.reset_grace_time,
p.spawn_extra_particles_on_fall
));
}
out.push(format!(
"held {}",
canon_stack(self.inventory[self.selected].as_ref())
));
Ok(out)
}
/// A stack in a block entity's slot: a container's, a jukebox's record, a
/// lectern's book, or the items of a block entity Horizon keeps as saved.
fn fixture_fill(&mut self, p: (i32, i32, i32), slot: usize, stack: Option<ItemStack>) {
@@ -628,8 +803,10 @@ impl Game<'_> {
self.next_entity += 1;
let id = self.next_entity;
if kind == "minecraft:armor_stand" {
self.armor_stands
.push(horizon_client::entities::ArmorStand::new(id, at, yaw));
let mut stand = horizon_client::entities::ArmorStand::new(id, at, yaw);
stand.marker = e["marker"].as_bool().unwrap_or(false);
stand.on_ground = e["ground"].as_bool().unwrap_or(false);
self.armor_stands.push(stand);
return Ok(Target::Stand(id));
}
let t = self
@@ -678,6 +855,14 @@ impl Game<'_> {
if flag("loot") {
mob.extra.pick_up_loot = true;
}
mob.on_ground = flag("ground");
if let Some(health) = e["health"].as_f64() {
mob.attrs.max_health = health as f32;
mob.health = health as f32;
}
if let Some(resistance) = e["knockback_resistance"].as_f64() {
mob.attrs.knockback_resistance = resistance;
}
if flag("brown") && s == Species::Mooshroom {
mob.extra.variant = 1;
}
@@ -165,6 +165,69 @@ impl Game<'_> {
{
m.ignite_for_ticks((ignite * 20.0) as i32);
}
self.post_attack_bursts(&held, &kind);
}
/// `minecraft:post_attack` explode effects on the attacker (wind burst):
/// a burst at the player's feet that only knocks back and triggers
/// blocks (`ExplodeEffect` with `block_interaction: trigger`).
fn post_attack_bursts(&mut self, held: &ItemStack, victim: &str) {
let Some(p) = self.player.as_ref() else {
return;
};
// EntityFlagsPredicate.isFlying: gliding or flying.
let motion = (p.fall_distance, p.fall_flying || p.flying);
let feet = [p.position.x, p.position.y, p.position.z];
let ctx = EffectContext {
this: Some(victim),
attacker: Some("minecraft:player"),
direct_attacker: Some("minecraft:player"),
is_direct: true,
items: Some(&self.res.items),
direct_motion: Some(motion),
..Default::default()
};
let mut bursts = Vec::new();
for (id, level) in held.enchantments() {
let Some(def) = self.res.stations.enchantments.get(id) else {
continue;
};
for effect in def.effects["minecraft:post_attack"]
.as_array()
.into_iter()
.flatten()
{
let e = &effect["effect"];
if effect["enchanted"] != "attacker"
|| effect["affected"] != "attacker"
|| e["type"] != "minecraft:explode"
|| e["block_interaction"] != "trigger"
{
continue;
}
let ok = effect.get("requirements").is_none_or(|r| {
self.res.stations.enchantments.condition(
r,
*level,
&ctx,
&mut self.world.random,
)
});
if !ok {
continue;
}
let radius = horizon_client::enchant::level_value(&e["radius"], *level).max(0.0);
// ExplosionDamageCalculator.getKnockbackMultiplier: 1 unless given.
let knockback = if e["knockback_multiplier"].is_null() {
1.0
} else {
horizon_client::enchant::level_value(&e["knockback_multiplier"], *level)
};
bursts.push((radius, knockback));
}
}
for (radius, knockback) in bursts {
let _ = self.wind_burst(feet, radius, knockback, false, false);
}
}
/// Thorns on worn armor when a mob at `from` hits the player.
pub(super) fn thorns(&mut self, from: [f64; 3]) {
+4 -2
View File
@@ -494,14 +494,16 @@ impl Game<'_> {
Ok(())
}
/// Dying in the End respawns in the Overworld.
/// Dying away from the Overworld respawns at the world spawn there.
pub(super) fn respawn_out_of_end(&mut self) -> Result<()> {
if self.dim != Dim::End || self.player.is_none() {
if self.dim == Dim::Overworld || self.player.is_none() {
return Ok(());
}
self.end_portal_travel = true;
let result = self.enter_dimension(Dim::Overworld);
self.end_portal_travel = false;
// The arrival places a fresh player at the spawn.
self.end_travel = true;
result
}
+143 -53
View File
@@ -3,14 +3,64 @@
//! draws), entity damage with exposure and knockback, block interaction with
//! merged drops and TNT chain priming, and optional fire.
use super::Game;
use horizon_client::{Result, blocks::Fluid, items::ItemStack};
use horizon_client::{Result, blocks::Fluid, collisions::SceneCollisions, items::ItemStack};
use horizon_core::{
geometry::Vec3,
geometry::{Vec3, VoxelShape},
position::BlockPos,
random::{LegacyRandom, RandomSource},
};
use horizon_world::java_hash_map::{JavaHashMap, JavaKey};
use std::cmp::Ordering;
use horizon_world::{
collision_context::{CollisionContext, CollisionEntity, CollisionItem},
entity_obstruction::EntityIdentity,
java_hash_map::{JavaHashMap, JavaKey},
registry::BlockStateId,
world_ray::{RayBlockMode, RayFluidMode, RayWorld, clip_world},
};
use std::{cmp::Ordering, io};
/// `Level.clip` with `ClipContext.Block.COLLIDER`, no fluids and the
/// collision context of the entity whose exposure is measured.
struct ColliderRays<'a, 'r> {
scene: SceneCollisions<'a, 'r>,
context: CollisionContext<'static>,
}
impl RayWorld for ColliderRays<'_, '_> {
type Error = io::Error;
type Block = BlockStateId;
type Fluid = ();
fn block_state(&mut self, p: BlockPos) -> io::Result<BlockStateId> {
Ok(self.scene.world.block(p.x, p.y, p.z))
}
fn fluid_state(&mut self, _: BlockPos) -> io::Result<()> {
Ok(())
}
fn block_shape(
&mut self,
state: BlockStateId,
p: BlockPos,
_: RayBlockMode,
) -> io::Result<VoxelShape> {
let binding = self.scene.binding;
binding
.collision_shape_with_context(&mut self.scene, state, p, &self.context)
.map_err(|e| io::Error::other(format!("{e:?}")))
}
fn interaction_shape(&mut self, _: BlockStateId, _: BlockPos) -> io::Result<VoxelShape> {
Ok(VoxelShape::empty())
}
fn fluid_is_source(&mut self, _: ()) -> io::Result<bool> {
Ok(false)
}
fn fluid_is_empty(&mut self, _: ()) -> io::Result<bool> {
Ok(true)
}
fn fluid_is_water(&mut self, _: ()) -> io::Result<bool> {
Ok(false)
}
fn fluid_shape(&mut self, _: (), _: BlockPos) -> io::Result<VoxelShape> {
Ok(VoxelShape::empty())
}
}
/// `BlockPos` with Java `Vec3i.hashCode` / `compareTo`.
#[derive(Clone, Copy, PartialEq, Eq)]
@@ -48,35 +98,6 @@ pub(super) fn client_float() -> f32 {
}
impl Game<'_> {
/// `Level.clip(from, to, COLLIDER, NONE)` missing every block, with full
/// collision cubes as obstacles.
fn clear_line(&self, from: [f64; 3], to: [f64; 3]) -> bool {
let d = [to[0] - from[0], to[1] - from[1], to[2] - from[2]];
let length = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt();
let steps = (length / 0.1).ceil().max(1.0) as i32;
let mut last = [i32::MIN; 3];
for i in 0..=steps {
let t = f64::from(i) / f64::from(steps);
let b = [
(from[0] + d[0] * t).floor() as i32,
(from[1] + d[1] * t).floor() as i32,
(from[2] + d[2] * t).floor() as i32,
];
if b == last {
continue;
}
last = b;
if self
.res
.facts
.get(self.world.block(b[0], b[1], b[2]))
.full_collision
{
return false;
}
}
true
}
/// `ServerExplosion.getSeenPercent` for an entity box.
pub(super) fn seen_percent(&self, center: [f64; 3], min: [f64; 3], max: [f64; 3]) -> f32 {
let xs = 1.0 / ((max[0] - min[0]) * 2.0 + 1.0);
@@ -87,6 +108,23 @@ impl Game<'_> {
if xs < 0.0 || ys < 0.0 || zs < 0.0 {
return 0.0;
}
// ClipContext(..., entity): the entity standing at the box's bottom.
let mut rays = ColliderRays {
scene: SceneCollisions {
world: &self.world,
binding: self.collision,
subject: None,
},
context: CollisionContext::for_entity(
CollisionEntity {
identity: EntityIdentity(0),
y: min[1],
descending: false,
main_hand: Some(CollisionItem::EMPTY),
},
false,
),
};
let (mut hits, mut count) = (0, 0);
let mut xx = 0.0;
while xx <= 1.0 {
@@ -97,7 +135,18 @@ impl Game<'_> {
let x = min[0] + (max[0] - min[0]) * xx;
let y = min[1] + (max[1] - min[1]) * yy;
let z = min[2] + (max[2] - min[2]) * zz;
if self.clear_line([x + x_offset, y, z + z_offset], center) {
let from = Vec3::new(x + x_offset, y, z + z_offset);
let to = Vec3::new(center[0], center[1], center[2]);
let missed = clip_world(
&mut rays,
from,
to,
RayBlockMode::Collider,
RayFluidMode::None,
4096,
)
.is_ok_and(|r| r.miss);
if missed {
hits += 1;
}
count += 1;
@@ -109,8 +158,14 @@ impl Game<'_> {
}
hits as f32 / count as f32
}
/// `ServerExplosion.calculateExplodedPositions`.
fn exploded_positions(&mut self, center: [f64; 3], radius: f32) -> Vec<[i32; 3]> {
/// `ServerExplosion.calculateExplodedPositions`; `resists` overrides one
/// block's resistance (`ExplosionDamageCalculator.getBlockExplosionResistance`).
fn exploded_positions(
&mut self,
center: [f64; 3],
radius: f32,
resists: Option<([i32; 3], f32)>,
) -> Vec<[i32; 3]> {
let (min_y, max_y) = self.with_level(|_, level, _| {
use horizon_world::level::LevelAccess;
(level.min_y(), level.max_y())
@@ -147,8 +202,14 @@ impl Game<'_> {
} else {
0.0
};
if !self.res.facts.is_air(state) || f.fluid != Fluid::None {
power -= (f.explosion_resistance.max(fluid) + 0.3) * 0.3;
match resists {
Some((at, resistance)) if at == pos => {
power -= (resistance + 0.3) * 0.3;
}
_ if !self.res.facts.is_air(state) || f.fluid != Fluid::None => {
power -= (f.explosion_resistance.max(fluid) + 0.3) * 0.3;
}
_ => {}
}
if power > 0.0 {
set.put(Key(pos), ());
@@ -163,8 +224,9 @@ impl Game<'_> {
}
set.entries().map(|(k, _)| k.0).collect()
}
/// `ServerExplosion.hurtEntities` (player, mobs, items, primed TNT).
fn explosion_hurt_entities(&mut self, center: [f64; 3], radius: f32) {
/// `ServerExplosion.hurtEntities` (player, mobs, items, primed TNT);
/// the player takes `damage_type`.
fn explosion_hurt_entities(&mut self, center: [f64; 3], radius: f32, damage_type: &str) {
if radius < 1.0e-5 {
return;
}
@@ -223,7 +285,7 @@ impl Game<'_> {
let mut hurt = false;
let creative = self.creative;
if let Some(p) = self.player.as_mut()
&& let Some(id) = self.motion.health.damage.id("minecraft:explosion")
&& let Some(id) = self.motion.health.damage.id(damage_type)
{
// Creative players are invulnerable to explosions.
if !creative && player_hurtable {
@@ -334,6 +396,26 @@ impl Game<'_> {
radius: f32,
interaction: BlockInteraction,
fire: bool,
) -> Result<()> {
self.server_explode_as(
center,
radius,
interaction,
fire,
"minecraft:explosion",
None,
)
}
/// `server_explode` with the damage type the player takes and a block
/// whose explosion resistance the damage calculator overrides.
pub(super) fn server_explode_as(
&mut self,
center: [f64; 3],
radius: f32,
interaction: BlockInteraction,
fire: bool,
damage_type: &str,
resists: Option<([i32; 3], f32)>,
) -> Result<()> {
if let Some(p) = &self.player {
let d = [
@@ -344,11 +426,11 @@ impl Game<'_> {
let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt();
self.pad_rumble(horizon_client::gamepad::Rumble::Explosion { distance, radius });
}
let mut targets = self.exploded_positions(center, radius);
// Explosion.explode: the blast is heard.
let ctx = horizon_client::sculk::Context::default();
self.post_game_event("minecraft:explode", center, ctx);
self.explosion_hurt_entities(center, radius);
let mut targets = self.exploded_positions(center, radius, resists);
self.explosion_hurt_entities(center, radius, damage_type);
if interaction != BlockInteraction::Keep {
// Util.shuffle(list, level.random)
for i in (2..=targets.len()).rev() {
@@ -375,8 +457,12 @@ impl Game<'_> {
.facts
.get(self.world.block(pos[0], pos[1] - 1, pos[2]))
.solid_render
&& let Some(fire) = self.res.assets.registry.default_state("minecraft:fire")
{
// BaseFireBlock.getState: soul fire on its base blocks,
// fire shaped by its neighbours elsewhere.
let at = BlockPos::new(pos[0], pos[1], pos[2]);
let fire =
self.with_level(|b, level, ticks| b.fire_state_for(level, ticks, at));
self.level_set(pos, fire)?;
}
}
@@ -420,32 +506,36 @@ impl Game<'_> {
}
if !is_tnt {
let dynamic = self.pending.dynamic(pos);
let drops = self.res.items.block_drops_full(
// LootContextParams.EXPLOSION_RADIUS under DESTROY_WITH_DECAY: the
// tables' survives_explosion and explosion_decay draw from their
// random sequence.
let decay = (interaction == BlockInteraction::DestroyWithDecay).then_some(radius);
let drops = self.res.items.block_drops_exploded(
self.res.assets.registry,
state,
None,
&dynamic,
&mut self.world.random,
Some((&mut self.rand_sequences, self.level.seed)),
decay,
);
for mut stack in drops {
if &*stack.item == "minecraft:air" || stack.count == 0 {
continue;
}
self.pending.attach(pos, &mut stack);
// survives_explosion / explosion_decay: 1 / radius per stack.
if interaction == BlockInteraction::DestroyWithDecay
&& self.world.random.next_float() > 1.0 / radius
{
continue;
}
add_or_append_stack(stacks, stack, pos);
}
}
self.pending.clear(pos);
self.level_set(pos, self.world.air)?;
if is_tnt {
self.spawn_primed_tnt(BlockPos::new(pos[0], pos[1], pos[2]), true);
// TntBlock.wasExploded: new PrimedTnt (its push drawn first), then
// getRandomShortFuse(80); no game event.
if is_tnt && self.ui.rules.bool("tnt_explodes") {
let r = &mut self.world.random;
let rot = r.next_double() * f64::from(std::f32::consts::TAU);
let fuse = r.next_int_bound(20).unwrap_or(0) + 10;
self.add_primed_tnt(BlockPos::new(pos[0], pos[1], pos[2]), rot, fuse);
}
Ok(())
}
+330
View File
@@ -0,0 +1,330 @@
//! Maces (`MaceItem`): a hit after falling more than one and a half blocks is
//! a smash attack. It adds damage for the height fallen (more with Density),
//! stops the fall, cancels its damage and knocks the creatures around the
//! target away. The rest of a weapon hit (`Player.itemAttackInteraction`)
//! is here too: `hurtEnemy`, the post-attack enchantments and `postHurtEnemy`.
use super::Game;
use horizon_client::{
enchant::EffectContext,
mobs::{Damage, Mob, Species},
particles::{ParticleOptions, ParticleType},
};
use horizon_core::{geometry::Vec3, position::BlockPos, random::RandomSource};
use horizon_world::registry::BlockStateId;
/// `MaceItem.SMASH_ATTACK_FALL_THRESHOLD`.
const FALL_THRESHOLD: f64 = 1.5;
/// `MaceItem.SMASH_ATTACK_HEAVY_THRESHOLD`.
const HEAVY_THRESHOLD: f64 = 5.0;
/// `MaceItem.SMASH_ATTACK_KNOCKBACK_RADIUS`.
const KNOCKBACK_RADIUS: f64 = 3.5;
/// `MaceItem.SMASH_ATTACK_KNOCKBACK_POWER`.
const KNOCKBACK_POWER: f32 = 0.7;
/// `Entity.isAlliedTo` between the player (`player` its UUID) and a mob
/// without teams: `TamableAnimal.considersEntityAsAlly` (a pet it tamed) and
/// `Allay.considersEntityAsAlly` (an allay that likes it).
fn ally_of_player(m: &Mob, player: Option<[i32; 4]>) -> bool {
let tamable = matches!(
m.species(),
Species::Wolf
| Species::Cat
| Species::Parrot
| Species::Nautilus
| Species::ZombieNautilus
);
tamable && m.extra.tame && m.extra.owner.is_some() && m.extra.owner == player
|| m.species() == Species::Allay && m.extra.tame
}
impl Game<'_> {
fn holds_mace(&self) -> bool {
self.inventory[self.selected]
.as_ref()
.is_some_and(|s| &*s.item == "minecraft:mace")
}
/// `MaceItem.canSmashAttack` for the player: falling and not gliding.
fn can_smash_attack(&self) -> bool {
self.player
.as_ref()
.is_some_and(|p| p.fall_distance > FALL_THRESHOLD && !p.fall_flying)
}
/// A held mace about to smash (`MaceItem.getItemDamageSource`: the attack
/// is `mace_smash` damage).
pub(super) fn smash_attack(&self) -> bool {
self.holds_mace() && self.can_smash_attack()
}
/// The damage source of the player's hit from `from` with the held item.
pub(super) fn attack_source(&self, from: [f64; 3]) -> Damage {
if self.smash_attack() {
Damage::mace(from)
} else {
Damage::player(from)
}
}
/// `MaceItem.getAttackDamageBonus` against `victim`: 4 per block for the
/// first three blocks fallen, 2 for the next five, 1 after that, plus
/// `smash_damage_per_fallen_block` (Density) for every block.
pub(super) fn smash_damage_bonus(&mut self, victim: &str) -> f32 {
if !self.smash_attack() {
return 0.0;
}
let fall = self.player.as_ref().map_or(0.0, |p| p.fall_distance);
let damage = if fall <= 3.0 {
4.0 * fall
} else if fall <= 8.0 {
12.0 + 2.0 * (fall - 3.0)
} else {
22.0 + fall - 8.0
};
let held = self.inventory[self.selected].clone();
let ctx = EffectContext {
this: Some(victim),
attacker: Some("minecraft:player"),
direct_attacker: Some("minecraft:player"),
is_direct: true,
damage_type: Some("minecraft:mace_smash"),
items: Some(&self.res.items),
..Default::default()
};
// EnchantmentHelper.modifyFallBasedDamage(..., 0)
let per_block = self.res.stations.enchantments.modify_value(
held.as_ref(),
"minecraft:smash_damage_per_fallen_block",
&ctx,
&mut self.world.random,
0.0,
);
(damage + f64::from(per_block) * fall) as f32
}
/// `LivingEntity.hurtServer` of the mob at `index` by the player's hit:
/// the weapon's `armor_effectiveness` enchantments (Breach) thin its armor.
pub(super) fn hurt_by_player(&mut self, index: usize, amount: f32, source: Damage) -> bool {
let held = self.inventory[self.selected].clone();
let kind = self.mobs[index].kind.id.clone();
let ctx = EffectContext {
this: Some(&kind),
attacker: Some("minecraft:player"),
direct_attacker: Some("minecraft:player"),
is_direct: true,
damage_type: Some(match source.kind {
horizon_client::mobs::DamageKind::MaceSmash => "minecraft:mace_smash",
_ => "minecraft:player_attack",
}),
items: Some(&self.res.items),
..Default::default()
};
let enchantments = &self.res.stations.enchantments;
let random = &mut self.world.random;
// CombatRules.getDamageAfterAbsorb: EnchantmentHelper.modifyArmorEffectiveness.
let mut breach = |fraction: f32| {
enchantments.modify_value(
held.as_ref(),
"minecraft:armor_effectiveness",
&ctx,
random,
fraction,
)
};
let old_health = self.mobs[index].health;
let hurt = self.mobs[index].damage_with(amount, source, Some(&mut breach));
if hurt && self.mobs[index].health != old_health {
self.mob_damage_event(self.mobs[index].id);
}
hurt
}
/// `Player.itemAttackInteraction` after the player's hit landed on the mob
/// at `index`: the item's `hurtEnemy` (the "used" statistic of a weapon),
/// the post-attack enchantments, then `postHurtEnemy` with the weapon's
/// wear.
pub(super) fn weapon_hit(&mut self, index: usize) {
let Some(stack) = self.inventory[self.selected].clone() else {
return;
};
let weapon = self
.res
.items
.get(&stack.item)
.and_then(|i| i.weapon_damage.map(|d| (d, i.max_damage)));
let smash = self.smash_attack();
if smash {
self.mace_hurt_enemy(index);
}
if weapon.is_some() {
self.stats.add("used", &stack.item, 1);
}
self.post_attack(index);
// MaceItem.postHurtEnemy
if smash && let Some(p) = self.player.as_mut() {
p.fall_distance = 0.0;
}
// ItemStack.postHurtEnemy: hurtAndBreak(weapon.itemDamagePerAttack).
if let Some((per_attack, max)) = weapon
&& max > 0
&& !self.creative
{
let loss = self.durability_loss(&stack, per_attack);
if let Some(held) = self.inventory[self.selected].as_mut() {
held.damage += loss;
if held.damage >= max {
self.inventory[self.selected] = None;
}
}
}
}
/// `MaceItem.hurtEnemy` for a smash: the fall stops and its damage is
/// waived from where the hit landed, the ground or air smash sounds, and
/// the knockback around the target.
fn mace_hurt_enemy(&mut self, index: usize) {
let target_on_ground = self.mobs[index].on_ground;
let Some(p) = self.player.as_mut() else {
return;
};
p.velocity = Vec3::new(p.velocity.x, f64::from(0.01f32), p.velocity.z);
// calculateImpactPosition: an earlier impact below the player stays.
let impact = match p.impulse.impact_position {
Some(at) if at.y <= p.position.y => at,
_ => p.position,
};
p.impulse.set_ignore_fall_damage(true, Some(impact));
let fall = p.fall_distance;
let feet = [p.position.x, p.position.y, p.position.z];
let sound = if target_on_ground {
p.spawn_extra_particles_on_fall = true;
if fall > HEAVY_THRESHOLD {
"minecraft:item.mace.smash_ground_heavy"
} else {
"minecraft:item.mace.smash_ground"
}
} else {
"minecraft:item.mace.smash_air"
};
self.audio.play(sound, Some(feet), 1.0, 1.0);
self.smash_knockback(index, fall);
}
/// `MaceItem.knockback`: the dust pillar (level event 2013) under the
/// target, then every living entity within 3.5 blocks of it but the
/// player and the target pushed away and up, harder after a fall of more
/// than five blocks. Spectators, the player's allies (`isAlliedTo`: its
/// pets and the allays that like it), marker armor stands and creative
/// flyers are spared; the predicate's own tamed-animal test asks whether
/// the target owns the animal, which a mob never does.
fn smash_knockback(&mut self, index: usize, fall: f64) {
let target = &self.mobs[index];
let (id, center) = (target.id, target.position);
// Entity.getOnPos without a supporting block.
let on_pos = [
center.x.floor() as i32,
(center.y - f64::from(1.0e-5f32)).floor() as i32,
center.z.floor() as i32,
];
self.level_event_at(2013, on_pos, 750);
let heavy = if fall > HEAVY_THRESHOLD { 2.0 } else { 1.0 };
// getKnockbackPower and the push of one entity at `at`.
let push = |at: Vec3, velocity: &mut Vec3, resistance: f64| {
let d = [at.x - center.x, at.y - center.y, at.z - center.z];
let distance_sqr = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
if distance_sqr > KNOCKBACK_RADIUS.powi(2) {
return;
}
let length = distance_sqr.sqrt();
let power = (KNOCKBACK_RADIUS - length)
* f64::from(KNOCKBACK_POWER)
* heavy
* (1.0 - resistance);
if power <= 0.0 {
return;
}
// Vec3.normalize: a vector shorter than 1e-5 has no direction.
let (x, z) = if length < f64::from(1.0e-5f32) {
(0.0, 0.0)
} else {
(d[0] / length * power, d[2] / length * power)
};
*velocity = Vec3::new(
velocity.x + x,
velocity.y + f64::from(KNOCKBACK_POWER),
velocity.z + z,
);
};
let player = self.level.player_uuid.or(Some([0, 0, 0, 1]));
for m in self
.mobs
.iter_mut()
.filter(|m| m.id != id && m.alive() && !m.removed && !ally_of_player(m, player))
{
push(m.position, &mut m.velocity, m.attrs.knockback_resistance);
}
for s in self.armor_stands.iter_mut().filter(|s| !s.marker) {
push(s.position, &mut s.velocity, 0.0);
}
}
/// `ServerPlayer.checkFallDamage` after a smash on a grounded target:
/// the landing block's particles, 50 for every block fallen (200 at most).
pub(super) fn smash_landing_particles(
&mut self,
state: BlockStateId,
pos: BlockPos,
fall_distance: f64,
) {
let Some((sprite, tint)) = self.particle_sprite(state) else {
return;
};
let count = (50.0 * fall_distance).clamp(0.0, 200.0) as u32;
let spread = f64::from(0.3f32);
self.particles.send_particles(
&ParticleOptions::block(ParticleType::Block, sprite, tint),
[
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 1.0,
f64::from(pos.z) + 0.5,
],
[spread; 3],
f64::from(0.15f32),
count,
);
}
/// Level event 2013 (`ParticleUtils.spawnSmashAttackParticles`): dust
/// pillars of the block at `pos`, a cluster over it and a ring 3.5 out.
pub(super) fn smash_dust(&mut self, pos: BlockPos, count: i32) {
let state = self.world.block(pos.x, pos.y, pos.z);
let Some((sprite, tint)) = self.particle_sprite(state) else {
return;
};
let options = ParticleOptions::block(ParticleType::DustPillar, sprite, tint);
let center = [
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 1.0,
f64::from(pos.z) + 0.5,
];
let near = f64::from(0.2f32);
let mut i = 0;
while (i as f32) < count as f32 / 3.0 {
let r = self.particles.random();
let x = center[0] + r.next_gaussian() / 2.0;
let z = center[2] + r.next_gaussian() / 2.0;
let v = [
r.next_gaussian() * near,
r.next_gaussian() * near,
r.next_gaussian() * near,
];
self.particles.add(&options, [x, center[1], z], v);
i += 1;
}
let far = f64::from(0.05f32);
let mut i = 0;
while (i as f32) < count as f32 / 1.5 {
let r = self.particles.random();
let angle = f64::from(i);
let x = center[0] + KNOCKBACK_RADIUS * angle.cos() + r.next_gaussian() / 2.0;
let z = center[2] + KNOCKBACK_RADIUS * angle.sin() + r.next_gaussian() / 2.0;
let v = [
r.next_gaussian() * far,
r.next_gaussian() * far,
r.next_gaussian() * far,
];
self.particles.add(&options, [x, center[1], z], v);
i += 1;
}
}
}
@@ -28,7 +28,12 @@ impl Game<'_> {
while Instant::now() < deadline {
self.update_world();
if self.remote.is_none() {
error = Some("disconnected".to_owned());
error = Some(match self.title.as_ref().map(|t| &t.mode) {
Some(horizon_client::title::Mode::Multiplayer(
horizon_client::multiplayer::Screen::Disconnected { reason },
)) => format!("disconnected: {reason}"),
_ => "disconnected".to_owned(),
});
break;
}
if Instant::now() >= next {
+4 -1
View File
@@ -158,7 +158,10 @@ impl Game<'_> {
let lang = Arc::new(horizon_client::net::load_language(&root));
let view = self.settings.render_distance.clamp(2, 32) as i8;
horizon_client::crash::set_detail("Server", address.to_owned());
let session = Session::connect(address, name, view, lang.clone());
// A signed-in account always plays under its own name.
let auth = horizon_client::auth::current();
let name = auth.as_ref().map_or(name, |a| a.name.as_str());
let session = Session::connect(address, name, auth.clone(), view, lang.clone());
let player_type = super::perspective::player_type(&root);
let mut streaming = Streaming::new(
Arc::new(NoTerrain),
@@ -0,0 +1,595 @@
//! `RespawnAnchorBlock` in the game: glowstone charges it (`useItemOn`), a
//! right click on a charged anchor sets the respawn point in the Nether and
//! blows it up anywhere else (`useWithoutItem`), and respawning goes to it
//! (`ServerPlayer.findRespawnAndUseSpawnBlock`, `PlayerList.respawn`),
//! using a charge.
use super::{Dim, Game};
use horizon_client::{
Result,
blocks::Fluid,
collisions::{SceneCollisions, no_collision_empty},
items::ItemStack,
mobs::Who,
motion::PlayerMotion,
text::Text,
};
use horizon_core::{
geometry::{Aabb, Axis, Vec3, VoxelShape},
position::BlockPos,
random::RandomSource,
};
use horizon_world::{collision_context::CollisionContext, registry::BlockStateId};
/// `ServerPlayer.RespawnConfig`: a respawn point other than the world spawn
/// that the game resolves through its block (a respawn anchor).
#[derive(Clone, Copy, Debug, PartialEq)]
pub(super) struct RespawnConfig {
pub dim: Dim,
pub pos: [i32; 3],
pub yaw: f32,
pub forced: bool,
}
/// `RespawnAnchorBlock.RESPAWN_HORIZONTAL_OFFSETS`, then the same a block
/// below, a block above, and straight above.
const HORIZONTAL: [[i32; 3]; 8] = [
[0, 0, -1],
[-1, 0, 0],
[0, 0, 1],
[1, 0, 0],
[-1, 0, -1],
[1, 0, -1],
[-1, 0, 1],
[1, 0, 1],
];
fn respawn_offsets() -> impl Iterator<Item = [i32; 3]> {
HORIZONTAL
.into_iter()
.chain(HORIZONTAL.into_iter().map(|[x, y, z]| [x, y - 1, z]))
.chain(HORIZONTAL.into_iter().map(|[x, y, z]| [x, y + 1, z]))
.chain(std::iter::once([0, 1, 0]))
}
/// What a right click with an item does to an anchor before `useWithoutItem`.
pub(super) enum AnchorUse {
/// Glowstone charged it.
Charged,
/// `PASS`: the off hand's glowstone charges it instead.
Pass,
/// `TRY_WITH_EMPTY_HAND`, or not an anchor.
Other,
}
impl Game<'_> {
fn is_anchor(&self, state: BlockStateId) -> bool {
&*self.res.facts.get(state).name == "minecraft:respawn_anchor"
}
fn anchor_charges(&self, state: BlockStateId) -> i32 {
self.res
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("charges"))
.and_then(|c| c.parse().ok())
.unwrap_or(0)
}
fn anchor_with_charges(&self, state: BlockStateId, charges: i32) -> Option<BlockStateId> {
let mut s = self.res.assets.registry.state(state)?.clone();
s.properties.insert("charges".into(), charges.to_string());
self.res.assets.registry.resolve(&s).ok()
}
/// `RespawnAnchorBlock.canSetSpawn`: the `respawn_anchor_works` attribute
/// (only the Nether's dimension type sets it).
pub(super) fn anchor_works(&self) -> bool {
self.dim == Dim::Nether
}
/// `RespawnAnchorBlock.charge`: one more charge, the block change and the sound.
fn charge_anchor(
&mut self,
pos: [i32; 3],
state: BlockStateId,
who: Option<Who>,
) -> Result<()> {
let Some(next) = self.anchor_with_charges(state, self.anchor_charges(state) + 1) else {
return Ok(());
};
self.level_set(pos, next)?;
self.post_block_game_event("minecraft:block_change", pos, who, Some(next));
let at = [
f64::from(pos[0]) + 0.5,
f64::from(pos[1]) + 0.5,
f64::from(pos[2]) + 0.5,
];
self.audio
.play("minecraft:block.respawn_anchor.charge", Some(at), 1.0, 1.0);
Ok(())
}
/// `RespawnAnchorBlock.useItemOn` with `held` in the main hand.
pub(super) fn use_respawn_anchor(
&mut self,
pos: [i32; 3],
held: Option<&ItemStack>,
) -> Result<AnchorUse> {
let state = self.world.block(pos[0], pos[1], pos[2]);
if !self.is_anchor(state) {
return Ok(AnchorUse::Other);
}
let fuel = |s: Option<&ItemStack>| s.is_some_and(|s| &*s.item == "minecraft:glowstone");
let chargeable = self.anchor_charges(state) < 4;
if fuel(held) && chargeable {
let used = held.cloned();
self.charge_anchor(pos, state, Some(Who::Player))?;
// itemStack.consume(1, player); the criterion sees the stack as used.
self.consume_held();
if let Some(stack) = used {
self.trigger_block("minecraft:item_used_on_block", pos, &stack);
}
return Ok(AnchorUse::Charged);
}
if fuel(self.offhand.as_ref()) && chargeable {
return Ok(AnchorUse::Pass);
}
Ok(AnchorUse::Other)
}
/// The off hand's glowstone on an anchor the main hand passed on.
pub(super) fn charge_anchor_from_offhand(&mut self, pos: [i32; 3]) -> Result<bool> {
let state = self.world.block(pos[0], pos[1], pos[2]);
let fuel = self
.offhand
.as_ref()
.is_some_and(|s| &*s.item == "minecraft:glowstone");
if !self.is_anchor(state) || !fuel || self.anchor_charges(state) >= 4 {
return Ok(false);
}
let used = self.offhand.clone();
self.charge_anchor(pos, state, Some(Who::Player))?;
if !self.creative
&& let Some(s) = self.offhand.as_mut()
{
s.count -= 1;
if s.count == 0 {
self.offhand = None;
}
}
if let Some(stack) = used {
self.trigger_block("minecraft:item_used_on_block", pos, &stack);
}
self.swing_arm();
Ok(true)
}
/// `RespawnAnchorBlock.useWithoutItem` on a charged anchor: outside the
/// Nether it explodes; inside, it becomes the respawn point.
pub(super) fn respawn_anchor_used(&mut self, pos: [i32; 3]) -> Result<()> {
let state = self.world.block(pos[0], pos[1], pos[2]);
if !self.anchor_works() {
return self.explode_anchor(pos, state);
}
let config = RespawnConfig {
dim: self.dim,
pos,
yaw: 0.0,
forced: false,
};
// RespawnConfig.isSamePosition: dimension and block.
let same = self
.respawn_config
.is_some_and(|c| c.dim == config.dim && c.pos == config.pos);
if !same {
// setRespawnPosition(config, true): the message, the point; the
// anchor replaces a bed.
self.system_message(Text::translate("block.minecraft.set_spawn", &[]));
self.respawn_config = Some(config);
if let Some([x, y, z]) = self.level.world_spawn {
self.spawn = Some(Vec3::new(
f64::from(x) + 0.5,
f64::from(y),
f64::from(z) + 0.5,
));
}
let at = [
f64::from(pos[0]) + 0.5,
f64::from(pos[1]) + 0.5,
f64::from(pos[2]) + 0.5,
];
self.audio.play(
"minecraft:block.respawn_anchor.set_spawn",
Some(at),
1.0,
1.0,
);
}
Ok(())
}
/// `RespawnAnchorBlock.isWaterThatWouldFlow`.
fn water_would_flow(&self, p: [i32; 3]) -> bool {
let f = self.res.facts.get(self.world.block(p[0], p[1], p[2]));
if f.fluid != Fluid::Water {
return false;
}
if f.fluid_level == 8 && !f.fluid_falling {
return true;
}
if f.fluid_level < 2 {
return false;
}
self.res
.facts
.get(self.world.block(p[0], p[1] - 1, p[2]))
.fluid
!= Fluid::Water
}
/// `RespawnAnchorBlock.explode`: the anchor goes, then a power 5 fiery
/// explosion (`badRespawnPointExplosion`, `ExplosionInteraction.BLOCK`)
/// whose centre resists like water when water would flow into it.
fn explode_anchor(&mut self, pos: [i32; 3], _state: BlockStateId) -> Result<()> {
self.level_set(pos, self.world.air)?;
let horizontal = [[0, 0, -1], [0, 0, 1], [-1, 0, 0], [1, 0, 0]]
.into_iter()
.any(|d| self.water_would_flow([pos[0] + d[0], pos[1], pos[2] + d[2]]));
let above = self
.res
.facts
.get(self.world.block(pos[0], pos[1] + 1, pos[2]))
.fluid
== Fluid::Water;
let in_water = horizontal || above;
let center = [
f64::from(pos[0]) + 0.5,
f64::from(pos[1]) + 0.5,
f64::from(pos[2]) + 0.5,
];
self.block_explosion(center, in_water.then_some(pos))
}
/// `BedRule.destroyOnUse` of the dimension's `bed_rule` and
/// `straw_bed_rule`: true in the Nether and the End.
pub(super) fn beds_destroy_on_use(&self) -> bool {
self.dim != Dim::Overworld
}
/// `AbstractBedBlock.useWithoutItem` where the bed rule destroys on use
/// (the bed's head at `head`): `BedBlock.destroyOnUse` removes both
/// halves and explodes; `StrawBedBlock` just falls apart.
pub(super) fn destroy_bed_on_use(&mut self, head: [i32; 3]) -> Result<()> {
let state = self.world.block(head[0], head[1], head[2]);
let name = self.res.facts.get(state).name.clone();
let center = [
f64::from(head[0]) + 0.5,
f64::from(head[1]) + 0.5,
f64::from(head[2]) + 0.5,
];
if &*name == "minecraft:straw_bed" {
// StrawBedBlock.destroyBed.
self.audio.play(
"minecraft:block.straw_bed.break_leave",
Some(center),
1.0,
1.0,
);
return self.level_set(head, self.world.air);
}
// removeBlock(head), then the foot behind it if it is still this bed.
let facing = self
.res
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("facing").cloned())
.unwrap_or_default();
let back = match facing.as_str() {
"north" => [0, 0, 1],
"south" => [0, 0, -1],
"west" => [1, 0, 0],
_ => [-1, 0, 0],
};
self.level_set(head, self.world.air)?;
let foot = [head[0] + back[0], head[1], head[2] + back[2]];
if self
.res
.facts
.get(self.world.block(foot[0], foot[1], foot[2]))
.name
== name
{
self.level_set(foot, self.world.air)?;
}
self.block_explosion(center, None)
}
/// `Level.explode(null, badRespawnPointExplosion(center), calculator,
/// center, 5, true, ExplosionInteraction.BLOCK)` (beds and anchors):
/// `water_at` is the block that resists like water.
pub(super) fn block_explosion(
&mut self,
center: [f64; 3],
water_at: Option<[i32; 3]>,
) -> Result<()> {
let interaction = if self.ui.rules.bool("block_explosion_drop_decay") {
super::explosion::BlockInteraction::DestroyWithDecay
} else {
super::explosion::BlockInteraction::Destroy
};
self.server_explode_as(
center,
5.0,
interaction,
true,
"minecraft:bad_respawn_point",
water_at.map(|p| (p, 100.0)),
)
}
// ---- respawning -------------------------------------------------------
/// `DismountHelper.nonClimbableShape`: the collision shape, empty for
/// climbable blocks and open trapdoors.
fn non_climbable_shape(&self, p: [i32; 3]) -> VoxelShape {
let state = self.world.block(p[0], p[1], p[2]);
let name = &self.res.facts.get(state).name;
let open_trapdoor = name.ends_with("_trapdoor")
&& self
.res
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("open"))
.is_some_and(|v| v == "true");
if self.block_in_tag("minecraft:climbable", name) || open_trapdoor {
return VoxelShape::empty();
}
let binding = self.collision;
let mut scene = SceneCollisions {
world: &self.world,
binding,
subject: None,
};
binding
.collision_shape_with_context(
&mut scene,
state,
BlockPos::new(p[0], p[1], p[2]),
&CollisionContext::empty(false),
)
.unwrap_or_else(|_| VoxelShape::empty())
}
fn block_in_tag(&self, tag: &str, block: &str) -> bool {
self.res
.items
.block_tags
.get(tag)
.is_some_and(|s| s.contains(block))
}
/// `EntityType.isBlockDangerous` for the player.
fn dangerous_for_player(&self, p: [i32; 3]) -> bool {
let state = self.world.block(p[0], p[1], p[2]);
let name = &*self.res.facts.get(state).name;
let lit_campfire = (name == "minecraft:campfire" || name == "minecraft:soul_campfire")
&& self
.res
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("lit"))
.is_some_and(|v| v == "true");
// NodeEvaluator.isBurningBlock, then the hurting plants and snow.
self.block_in_tag("minecraft:fire", name)
|| matches!(
name,
"minecraft:lava"
| "minecraft:magma_block"
| "minecraft:lava_cauldron"
| "minecraft:wither_rose"
| "minecraft:sweet_berry_bush"
| "minecraft:cactus"
| "minecraft:powder_snow"
)
|| lit_campfire
}
/// `DismountHelper.findSafeDismountLocation` for a standing player.
fn safe_dismount_location(&self, p: [i32; 3], check_dangerous: bool) -> Option<Vec3> {
if check_dangerous && self.dangerous_for_player(p) {
return None;
}
let shape = self.non_climbable_shape(p);
let below = self.non_climbable_shape([p[0], p[1] - 1, p[2]]);
let floor = horizon_core::geometry::block_floor_height(&shape, || &below);
// DismountHelper.isBlockFloorValid.
if floor.is_infinite() || floor >= 1.0 {
return None;
}
if check_dangerous && floor <= 0.0 && self.dangerous_for_player([p[0], p[1] - 1, p[2]]) {
return None;
}
let position = Vec3::new(
f64::from(p[0]) + 0.5,
f64::from(p[1]) + floor,
f64::from(p[2]) + 0.5,
);
// EntityDimensions.makeBoundingBox for 0.6 by 1.8 (the half width is a float).
let half = f64::from(0.6f32 / 2.0);
let bounds = Aabb::new(
Vec3::new(position.x - half, position.y, position.z - half),
Vec3::new(
position.x + half,
position.y + f64::from(1.8f32),
position.z + half,
),
);
let mut scene = SceneCollisions {
world: &self.world,
binding: self.collision,
subject: None,
};
if !no_collision_empty(&mut scene, bounds) {
return None;
}
let name = |q: [i32; 3]| {
self.res
.facts
.get(self.world.block(q[0], q[1], q[2]))
.name
.clone()
};
if self.block_in_tag("minecraft:invalid_spawn_inside", &name(p))
|| self.block_in_tag(
"minecraft:invalid_spawn_inside",
&name([p[0], p[1] + 1, p[2]]),
)
{
return None;
}
// WorldBorder.isWithinBounds(box).
let (lo, hi) = (bounds.min(Axis::X), bounds.max(Axis::X) - 1.0e-5);
let (lz, hz) = (bounds.min(Axis::Z), bounds.max(Axis::Z) - 1.0e-5);
(self.border.contains(lo, lz) && self.border.contains(hi, hz)).then_some(position)
}
/// `RespawnAnchorBlock.findStandUpPosition`: a safe spot around the
/// anchor, else any spot.
pub(super) fn anchor_stand_up(&self, pos: [i32; 3]) -> Option<Vec3> {
for check in [true, false] {
for d in respawn_offsets() {
let p = [pos[0] + d[0], pos[1] + d[1], pos[2] + d[2]];
if let Some(at) = self.safe_dismount_location(p, check) {
return Some(at);
}
}
}
None
}
/// `ServerPlayer.findRespawnAndUseSpawnBlock` for an anchor config in the
/// loaded dimension: the position and yaw, using a charge.
pub(super) fn find_respawn_and_use(
&mut self,
c: RespawnConfig,
consume: bool,
) -> Result<Option<(Vec3, f32)>> {
let state = self.world.block(c.pos[0], c.pos[1], c.pos[2]);
if !(self.is_anchor(state)
&& (c.forced || self.anchor_charges(state) > 0)
&& self.anchor_works())
{
return Ok(None);
}
let stand = self.anchor_stand_up(c.pos);
if !c.forced
&& consume
&& stand.is_some()
&& let Some(next) = self.anchor_with_charges(state, self.anchor_charges(state) - 1)
{
self.level_set(c.pos, next)?;
}
Ok(stand.map(|p| (p, look_at_yaw(p, c.pos))))
}
/// The death screen's respawn with an anchor as the respawn point: travel
/// to its dimension and wait for its chunks (`travelling`), then resolve
/// it in [`Game::place_respawned`].
pub(super) fn begin_anchor_respawn(&mut self) -> Result<bool> {
let Some(config) = self.respawn_config else {
return Ok(false);
};
if self.player.is_none() {
return Ok(false);
}
if self.dim != config.dim {
self.end_portal_travel = false;
self.enter_dimension(config.dim)?;
} else {
let player = self.player.take().ok_or("player")?;
self.travelling = Some((player, Vec3::ZERO));
}
let target = Vec3::new(
f64::from(config.pos[0]) + 0.5,
f64::from(config.pos[1]),
f64::from(config.pos[2]) + 0.5,
);
if let Some((_, t)) = self.travelling.as_mut() {
*t = target;
}
self.end_travel = false;
self.respawn_travel = Some(config);
Ok(true)
}
/// `PlayerList.respawn` at an anchor once its dimension is loaded around
/// it: a fresh player at the stand-up position facing the anchor and the
/// deplete sound, or, with no anchor left, the world spawn and
/// `block.minecraft.spawn.not_valid`.
pub(super) fn place_respawned(&mut self, config: RespawnConfig) -> Result<()> {
match self.find_respawn_and_use(config, true)? {
Some((position, yaw)) => {
let mut player = PlayerMotion::new(self.motion, position)?;
player.yaw = yaw;
player.head_yaw = yaw;
self.yaw = yaw;
self.pitch = 0.0;
player.pitch = 0.0;
self.eye = 1.62;
self.previous_eye = 1.62;
self.clock.reset();
self.previous_position = position;
self.player = Some(player);
self.sway = Default::default();
self.apply_equipment();
// ClientboundSoundPacket at the block's corner, seeded from the level random.
let state = self
.world
.block(config.pos[0], config.pos[1], config.pos[2]);
if self.is_anchor(state) {
let _seed = self.world.random.next_long();
let at = [
f64::from(config.pos[0]),
f64::from(config.pos[1]),
f64::from(config.pos[2]),
];
self.audio
.play("minecraft:block.respawn_anchor.deplete", Some(at), 1.0, 1.0);
}
Ok(())
}
None => {
// TeleportTransition.missingRespawnBlock: the world spawn, and
// the point is forgotten.
self.respawn_config = None;
self.system_message(Text::translate("block.minecraft.spawn.not_valid", &[]));
let dead = PlayerMotion::new(self.motion, Vec3::ZERO)?;
if self.dim != Dim::Overworld {
// A dead stand-in travels; the arrival makes a fresh player.
let mut dead = dead;
dead.set_health(0.0, false)?;
self.player = Some(dead);
self.end_portal_travel = true;
let result = self.enter_dimension(Dim::Overworld);
self.end_portal_travel = false;
self.end_travel = true;
return result;
}
self.player = None;
self.spawn_player()
}
}
}
}
/// `RespawnPosAngle.calculateLookAtYaw`: the yaw from the position to the
/// bottom centre of the block.
fn look_at_yaw(position: Vec3, block: [i32; 3]) -> f32 {
let d = Vec3::new(
f64::from(block[0]) + 0.5 - position.x,
f64::from(block[1]) - position.y,
f64::from(block[2]) + 0.5 - position.z,
)
.normalize();
// Mth.atan2(z, x) * 180.0F / (float) Math.PI - 90.0: the compiled code
// multiplies by the folded float constant widened to double.
let degrees = horizon_core::geometry::trig::atan2(d.z, d.x)
* f64::from(horizon_core::geometry::trig::RAD_TO_DEG)
- 90.0;
wrap_degrees(degrees) as f32
}
/// `Mth.wrapDegrees(double)`.
fn wrap_degrees(degrees: f64) -> f64 {
let mut d = degrees % 360.0;
if d >= 180.0 {
d -= 360.0;
}
if d < -180.0 {
d += 360.0;
}
d
}
+110 -4
View File
@@ -10,9 +10,11 @@ use horizon_client::{
},
hud::HudBatch,
hud_layout, hud_overlays,
lan::guest::Guest,
save::{self, uuid_from_text, uuid_text},
scoreboard::{self as sb, Comp, Scoreboard, literal},
scoreboard_cmd::{self, Env, Holder},
tab_list::TabPlayer,
text::Text,
};
use horizon_world::nbt::Tag;
@@ -581,10 +583,10 @@ impl Game<'_> {
impl Game<'_> {
/// `Hud.extractTabList`: the player list while the player-list key is
/// held. A single-player world lists only its player, so it shows only
/// with a `list` objective.
/// held. A local world shows it with a joined LAN guest or a `list`
/// objective.
pub(super) fn draw_tab_list(&mut self, batch: &mut HudBatch) {
use horizon_client::tab_list::{self, TabInputs, TabPlayer};
use horizon_client::tab_list::{self, TabInputs};
let chatting = self.remote.is_some() && self.remote_chat_open();
let key = self.screen == super::Screen::Playing
&& !chatting
@@ -600,7 +602,14 @@ impl Game<'_> {
let mut me = TabPlayer::new(uuid, PLAYER_NAME);
me.game_mode = self.mode_id();
me.skin = "entity/player/wide/steve".into();
(vec![me], true, Vec::new())
let guests = self.lan.as_ref().map_or(&[][..], |h| &h.hub.guests);
let players = local_tab_players(me, guests);
let upside_down = players
.iter()
.filter(|p| p.name == "Dinnerbone" || p.name == "Grumm")
.map(|p| p.uuid)
.collect();
(players, true, upside_down)
}
};
let board = &self.score.board;
@@ -635,6 +644,18 @@ impl Game<'_> {
}
}
/// The host and guests that have entered the world, rebuilt from live state.
fn local_tab_players(me: TabPlayer, guests: &[Guest]) -> Vec<TabPlayer> {
let mut players = vec![me];
players.extend(guests.iter().filter(|g| g.placed).map(|g| {
let mut player = TabPlayer::new(g.uuid, &g.name);
player.game_mode = g.game_mode;
player.latency = g.latency.load(std::sync::atomic::Ordering::Relaxed);
player
}));
players
}
/// The commands' view of the game.
struct GameEnv<'a, 'b> {
g: &'a mut Game<'b>,
@@ -692,3 +713,88 @@ impl Env for GameEnv<'_, '_> {
self.g.feedback(message);
}
}
#[cfg(test)]
mod tab_list_tests {
use super::*;
use horizon_client::{
lan::{Joined, PlayerSender},
tab_list,
};
use horizon_protocol::packets::configuration::ClientInformation;
use std::sync::{
Arc,
atomic::{AtomicI32, Ordering},
mpsc,
};
fn guest(uuid: u128, name: &str) -> Guest {
let (tx, _rx) = mpsc::channel();
Guest::new(
Joined {
conn: uuid as u32,
uuid,
name: name.into(),
info: ClientInformation::new(8),
brand: "test".into(),
sender: PlayerSender {
tx,
pending: Arc::default(),
},
latency: Arc::new(AtomicI32::new(42)),
address: "127.0.0.1:25565".parse().unwrap(),
},
uuid as i32,
[0.0, 64.0, 0.0],
8,
)
}
#[test]
fn lan_tab_list_tracks_join_and_disconnect() {
let me = TabPlayer::new(1, PLAYER_NAME);
let mut guests = vec![guest(2, "Alex")];
let players = local_tab_players(me.clone(), &guests);
assert_eq!(players.as_slice(), std::slice::from_ref(&me));
assert!(!tab_list::visible(true, true, players.len(), false));
guests[0].placed = true;
let players = local_tab_players(me.clone(), &guests);
assert_eq!(players.len(), 2);
assert_eq!(players[0], me);
assert_eq!(players[1].uuid, 2);
assert_eq!(players[1].name, "Alex");
assert!(tab_list::visible(true, true, players.len(), false));
assert!(!tab_list::visible(false, true, players.len(), false));
guests.clear();
let players = local_tab_players(me, &guests);
assert_eq!(players.len(), 1);
assert!(!tab_list::visible(true, true, players.len(), false));
assert!(tab_list::visible(true, true, players.len(), true));
}
#[test]
fn lan_tab_list_reads_current_guest_state() {
let me = TabPlayer::new(1, PLAYER_NAME);
let mut guests = vec![guest(2, "Alex"), guest(3, "Grumm")];
for guest in &mut guests {
guest.placed = true;
}
guests[0].game_mode = tab_list::SPECTATOR;
let players = local_tab_players(me.clone(), &guests);
assert_eq!(players.len(), 3);
assert_eq!(players[1].game_mode, tab_list::SPECTATOR);
assert_eq!(players[1].latency, 42);
assert_eq!(players[1].skin, tab_list::default_skin(2));
assert_eq!(players[2].name, "Grumm");
guests[0].game_mode = 1;
guests[0].latency.store(123, Ordering::Relaxed);
guests.remove(1);
let players = local_tab_players(me, &guests);
assert_eq!(players.len(), 2);
assert_eq!(players[1].game_mode, 1);
assert_eq!(players[1].latency, 123);
}
}
+10
View File
@@ -261,6 +261,16 @@ impl Game<'_> {
self.toggles.respawn();
self.remote_respawn();
}
Some(0) if self.respawn_config.is_some() => {
// LocalPlayer.respawn: KeyMapping.resetToggleKeys.
self.toggles.respawn();
// PlayerList.respawn at the respawn anchor, once it is loaded.
self.begin_anchor_respawn()?;
self.screen = Screen::Playing;
self.ui.death_text = None;
self.spawn_player()?;
self.capture(true);
}
Some(0) => {
// LocalPlayer.respawn: KeyMapping.resetToggleKeys.
self.toggles.respawn();
+13
View File
@@ -507,6 +507,19 @@ impl Game<'_> {
let ctx = self.who_context(who, state);
self.post_game_event(event, center((pos[0], pos[1], pos[2])), ctx);
}
/// `LivingEntity.actuallyHurt`'s damage vibration, heard as the hit lands;
/// the end-of-tick scan then knows this damage.
pub(super) fn mob_damage_event(&mut self, id: u32) {
if let Some(t) = self
.mobs
.iter()
.find(|m| m.id == id)
.and_then(|m| m.last_damage.map(|(_, t)| t))
{
self.sculk.damaged.insert(id, t);
}
self.post_entity_event("minecraft:entity_damage", Who::Mob(id));
}
/// A game event of an entity at its position.
pub(super) fn post_entity_event(&mut self, event: &'static str, who: Who) {
let at = match who {
+48 -16
View File
@@ -101,13 +101,7 @@ impl Game<'_> {
],
Hit::None => return Ok(()),
};
self.wind_burst(
center,
radius,
knockback,
breeze,
p.owner == Some(Who::Player),
)
self.wind_burst(center, radius, knockback, breeze, !breeze)
}
/// `AbstractWindCharge.onHitEntity`: one point of damage.
fn wind_charge_damage(&mut self, p: &Projectile, who: Who) {
@@ -208,7 +202,8 @@ impl Game<'_> {
center: [f64; 3],
radius: f32,
multiplier: f32,
player_charge: bool,
wind_charge: bool,
blocklike: bool,
) {
let diameter = f64::from(radius * 2.0);
let distance = |p: [f64; 3]| {
@@ -257,11 +252,10 @@ impl Game<'_> {
p.velocity.y + dir[1] * power,
p.velocity.z + dir[2] * power,
);
// ServerPlayer.onExplosionHit: a player's own charge cancels the fall.
if player_charge {
let at = p.position;
p.impulse.set_ignore_fall_damage(true, Some(at));
}
// ServerPlayer.onExplosionHit: a wind charge's burst cancels the
// fall; any other burst ends the grace of the last impulse.
let at = p.position;
p.impulse.set_ignore_fall_damage(wind_charge, Some(at));
}
}
}
@@ -288,6 +282,39 @@ impl Game<'_> {
);
}
self.mobs = mobs;
// ArmorStand.ignoreExplosion: a visible stand feels only a burst that
// affects block-like entities (never a wind charge's).
if blocklike {
let mut stands = std::mem::take(&mut self.armor_stands);
for s in stands.iter_mut().filter(|s| !s.invisible) {
let feet = [s.position.x, s.position.y, s.position.z];
let dist = distance(feet) / diameter;
if dist > 1.0 {
continue;
}
// EntityType.ARMOR_STAND's size, halved when small; a marker has none.
let (w, h, eye) = if s.marker {
(0.0, 0.0, 0.0)
} else if s.small {
(0.125, f64::from(0.9875f32), f64::from(0.9875f32))
} else {
(0.25, f64::from(1.975f32), f64::from(1.7775f32))
};
let exposure = self.seen_percent(
center,
[feet[0] - w, feet[1], feet[2] - w],
[feet[0] + w, feet[1] + h, feet[2] + w],
);
let power = (1.0 - dist) * f64::from(exposure) * multiplier;
let dir = direction([feet[0], feet[1] + eye, feet[2]]);
s.velocity = Vec3::new(
s.velocity.x + dir[0] * power,
s.velocity.y + dir[1] * power,
s.velocity.z + dir[2] * power,
);
}
self.armor_stands = stands;
}
// Arrows and other projectiles (the charges themselves ignore it).
let push = |position: Vec3, velocity: &mut Vec3, game: &Game<'_>| {
let feet = [position.x, position.y, position.z];
@@ -331,16 +358,21 @@ impl Game<'_> {
self.tnts = tnts;
}
/// The burst: knockback, the blocks that react, the gust and the sound.
fn wind_burst(
pub(super) fn wind_burst(
&mut self,
center: [f64; 3],
radius: f32,
multiplier: f32,
breeze: bool,
player_charge: bool,
wind_charge: bool,
) -> Result<()> {
// ServerExplosion.explode: the blast is heard first.
let ctx = horizon_client::sculk::Context::default();
self.post_game_event("minecraft:explode", center, ctx);
let mut targets = self.wind_positions(center, radius);
self.wind_knockback(center, radius, multiplier, player_charge);
// ServerExplosion.shouldAffectBlocklikeEntities
let blocklike = !breeze && !wind_charge && self.ui.rules.bool("mob_griefing");
self.wind_knockback(center, radius, multiplier, wind_charge, blocklike);
// Explosion.canTriggerBlocks: a breeze's charge needs mob griefing.
if !breeze || self.ui.rules.bool("mob_griefing") {
// Util.shuffle(list, level.random)
+116 -28
View File
@@ -10,6 +10,8 @@ use crate::hud::{HudBatch, Rect};
use glam::{EulerRot, Mat4, Vec2, Vec3};
use std::{collections::HashMap, f32::consts::PI};
mod depth;
/// `Lighting.DIFFUSE_LIGHT_0` and `DIFFUSE_LIGHT_1`.
fn diffuse_lights() -> (Vec3, Vec3) {
(
@@ -177,35 +179,19 @@ fn draw_quads(
rect: [f32; 4],
time: f32,
) {
// Back-face culling: front faces wind counter-clockwise on screen with y up.
let mut visible: Vec<(f32, usize)> = quads
.iter()
.enumerate()
.filter(|(_, q)| {
let p = q.pos.map(|v| Vec2::new(v.x, -v.y));
let area: f32 = (0..4)
.map(|i| {
let (a, b) = (p[i], p[(i + 1) % 4]);
a.x * b.y - b.x * a.y
})
.sum();
area > 0.0
})
.map(|(i, q)| (q.pos.iter().map(|v| v.z).sum::<f32>() / 4.0, i))
.collect();
// Far to near; the depth buffer of the item atlas, approximated per quad.
visible.sort_by(|a, b| a.0.total_cmp(&b.0));
for (_, i) in visible {
let q = &quads[i];
let points: [Point; 4] = std::array::from_fn(|k| Point {
p: Vec2::new(q.pos[k].x, q.pos[k].y),
uv: q.uv[k],
});
for face in depth::sort(quads) {
let q = &quads[face.quad];
let points: Vec<_> = face
.corners
.iter()
.map(|v| Point {
p: v.pos.truncate(),
uv: v.uv,
})
.collect();
let color = lit_color(q, lights);
for tri in [
[points[0], points[1], points[2]],
[points[0], points[2], points[3]],
] {
for i in 1..points.len().saturating_sub(1) {
let tri = [points[0], points[i], points[i + 1]];
let fan = clip_triangle(tri, rect);
if fan.len() < 3 {
continue;
@@ -275,6 +261,108 @@ pub fn draw_banner_result(
mod tests {
use super::*;
fn face(y0: f32, y1: f32, z: impl Fn(f32) -> f32, color: u32) -> ItemQuad {
ItemQuad {
pos: [(0.0, y0), (0.0, y1), (8.0, y1), (8.0, y0)].map(|(x, y)| Vec3::new(x, y, z(y))),
uv: [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]],
normal: Vec3::Z,
color,
foil: Foil::None,
light_emission: 0,
}
}
// Sample the emitted triangles in draw order, using opaque test faces.
fn color_at(batch: &HudBatch, p: Vec2) -> Option<u32> {
batch
.vertices
.as_chunks::<3>()
.0
.iter()
.rev()
.find_map(|tri| {
let [a, b, c] = std::array::from_fn(|i| Vec2::from(tri[i].pos));
let area = (b - a).perp_dot(c - a);
if area.abs() < 1e-6 {
return None;
}
let u = (b - p).perp_dot(c - p) / area;
let v = (c - p).perp_dot(a - p) / area;
let w = 1.0 - u - v;
(u >= 0.0 && v >= 0.0 && w >= 0.0).then_some(tri[0].color)
})
}
#[test]
fn banner_cloth_occludes_the_support_at_the_top_edge() {
// The cloth is nearer where it overlaps the bar, although its
// average depth is farther away because it slopes along its height.
let bar = face(0.0, 1.0, |_| 0.0, 0xFF80_4000);
let cloth = face(0.0, 8.0, |y| 2.0 - y, 0xFFFF_FFFF);
let mut batch = HudBatch::new([320, 240]);
draw_quads(
&[bar, cloth],
(Vec3::Z, Vec3::Z),
&mut batch,
[0.0, 0.0, 16.0, 16.0],
0.0,
);
assert_eq!(color_at(&batch, Vec2::new(4.0, 0.5)), Some(u32::MAX));
}
#[test]
fn intersecting_faces_change_draw_order_at_their_intersection() {
let flat = face(0.0, 8.0, |_| 0.0, 0xFFFF_0000);
let tilted = face(0.0, 8.0, |y| y - 4.0, 0xFF00_00FF);
for quads in [[flat, tilted], [tilted, flat]] {
let mut batch = HudBatch::new([320, 240]);
draw_quads(
&quads,
(Vec3::Z, Vec3::Z),
&mut batch,
[0.0, 0.0, 16.0, 16.0],
0.0,
);
assert_eq!(
color_at(&batch, Vec2::new(4.0, 2.0)),
Some(lit_color(&flat, (Vec3::Z, Vec3::Z)))
);
assert_eq!(
color_at(&batch, Vec2::new(4.0, 6.0)),
Some(lit_color(&tilted, (Vec3::Z, Vec3::Z)))
);
// The cut must interpolate the texture along with the position.
for v in &batch.vertices {
assert!((v.uv[0] - v.pos[0] / 8.0).abs() < 1e-6);
assert!((v.uv[1] - v.pos[1] / 8.0).abs() < 1e-6);
}
}
}
#[test]
fn coplanar_pattern_layers_keep_submission_order() {
let base = face(0.0, 8.0, |y| 2.0 - y, 0xFFFF_FFFF);
let pattern = ItemQuad {
color: 0xFF00_00FF,
..base
};
let quads = [face(0.0, 1.0, |_| 0.0, 0xFF80_4000), base, pattern];
let mut batch = HudBatch::new([320, 240]);
draw_quads(
&quads,
(Vec3::Z, Vec3::Z),
&mut batch,
[0.0, 0.0, 16.0, 16.0],
0.0,
);
for y in [0.5, 6.0] {
assert_eq!(
color_at(&batch, Vec2::new(4.0, y)),
Some(lit_color(&quads[2], (Vec3::Z, Vec3::Z)))
);
}
}
#[test]
fn flat_lights_match_joml() {
// new Matrix4f().rotationY(-PI/8).rotateX(3PI/4).transformDirection(L0).
@@ -0,0 +1,119 @@
//! Back-to-front ordering for the orthographic GUI item view (near is +Z).
//! Whole-face average depths fail when a long, tilted face overlaps a short
//! one, such as a banner's cloth and support. Partition faces by their planes
//! instead, splitting intersecting faces with their UVs. Coplanar faces keep
//! submission order so banner/shield pattern layers still paint bottom first.
use super::super::ItemQuad;
use glam::{Vec3, Vec4};
#[derive(Clone, Copy)]
pub(super) struct Corner {
pub pos: Vec3,
pub uv: [f32; 2],
}
pub(super) struct Face {
pub quad: usize,
pub corners: Vec<Corner>,
}
const EPSILON: f32 = 1e-4;
fn split(face: Face, distances: &[f32]) -> (Face, Face) {
let mut back = Vec::new();
let mut front = Vec::new();
for i in 0..face.corners.len() {
let a = face.corners[i];
let b = face.corners[(i + 1) % face.corners.len()];
let da = distances[i];
let db = distances[(i + 1) % face.corners.len()];
if da <= EPSILON {
back.push(a);
}
if da >= -EPSILON {
front.push(a);
}
if (da < -EPSILON && db > EPSILON) || (da > EPSILON && db < -EPSILON) {
let t = da / (da - db);
let corner = Corner {
pos: a.pos.lerp(b.pos, t),
uv: std::array::from_fn(|k| a.uv[k] + (b.uv[k] - a.uv[k]) * t),
};
back.push(corner);
front.push(corner);
}
}
(
Face {
quad: face.quad,
corners: back,
},
Face {
quad: face.quad,
corners: front,
},
)
}
pub(super) fn sort(quads: &[ItemQuad]) -> Vec<Face> {
let mut planes = vec![Vec4::ZERO; quads.len()];
let faces: Vec<_> = quads
.iter()
.enumerate()
.filter_map(|(i, q)| {
let normal = (q.pos[2] - q.pos[0]).cross(q.pos[3] - q.pos[1]);
// Front faces wind counter-clockwise on screen with Y up.
if normal.z >= 0.0 {
return None;
}
let normal = -normal.normalize();
planes[i] = normal.extend(-normal.dot(q.pos[0]));
Some(Face {
quad: i,
corners: std::array::from_fn::<_, 4, _>(|k| Corner {
pos: q.pos[k],
uv: q.uv[k],
})
.to_vec(),
})
})
.collect();
let mut out = Vec::new();
// An explicit stack avoids recursion for models with many parallel faces.
let mut pending = vec![(faces, false)];
while let Some((faces, emit)) = pending.pop() {
if emit {
out.extend(faces);
continue;
}
let mut faces = faces.into_iter();
let Some(first) = faces.next() else { continue };
let plane = planes[first.quad];
let mut coplanar = vec![first];
let mut back = Vec::new();
let mut front = Vec::new();
for face in faces {
let distances: Vec<_> = face
.corners
.iter()
.map(|c| plane.dot(c.pos.extend(1.0)))
.collect();
let behind = distances.iter().any(|d| *d < -EPSILON);
let ahead = distances.iter().any(|d| *d > EPSILON);
match (behind, ahead) {
(false, false) => coplanar.push(face),
(true, false) => back.push(face),
(false, true) => front.push(face),
(true, true) => {
let (b, f) = split(face, &distances);
back.push(b);
front.push(f);
}
}
}
pending.push((front, false));
pending.push((coplanar, true));
pending.push((back, false));
}
out
}
+47 -2
View File
@@ -72,6 +72,8 @@ pub struct ItemInfo {
pub blocks_attacks: Option<BlocksAttacks>,
/// `weapon.disable_blocking_for_seconds` (axes).
pub disable_blocking_seconds: f32,
/// `weapon.item_damage_per_attack`, when the item is a weapon.
pub weapon_damage: Option<u32>,
/// `use_effects.speed_multiplier` (UseEffects.DEFAULT: 0.2).
pub use_speed: f32,
/// `glider` (elytra).
@@ -464,6 +466,11 @@ impl Items {
disable_blocking_seconds: c["minecraft:weapon"]["disable_blocking_for_seconds"]
.as_f64()
.unwrap_or(0.0) as f32,
weapon_damage: c["minecraft:weapon"].is_object().then(|| {
c["minecraft:weapon"]["item_damage_per_attack"]
.as_u64()
.unwrap_or(1) as u32
}),
equip_asset: c["minecraft:equippable"]["asset_id"]
.as_str()
.map(str::to_owned),
@@ -626,6 +633,7 @@ impl Items {
properties: &empty,
held: None,
killed_by_player: false,
explosion_radius: None,
};
ctx.evaluate(table, random)
}
@@ -687,7 +695,22 @@ impl Items {
random: &mut impl RandomSource,
sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
) -> Vec<ItemStack> {
let drops = self.block_drops_raw(registry, state, held, random, sequences);
self.block_drops_exploded(registry, state, held, dynamic, random, sequences, None)
}
/// `block_drops_full` for a block an explosion destroys: `explosion`
/// is its radius when the explosion decays drops (`DESTROY_WITH_DECAY`).
#[allow(clippy::too_many_arguments)]
pub fn block_drops_exploded(
&self,
registry: &BlockRegistry,
state: BlockStateId,
held: Option<&ItemStack>,
dynamic: &[ItemStack],
random: &mut impl RandomSource,
sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
explosion: Option<f32>,
) -> Vec<ItemStack> {
let drops = self.block_drops_raw(registry, state, held, random, sequences, explosion);
if !drops.iter().any(|d| d.item.starts_with(DYNAMIC)) {
return drops;
}
@@ -709,6 +732,7 @@ impl Items {
held: Option<&ItemStack>,
random: &mut impl RandomSource,
sequences: Option<(&mut crate::random_sequences::RandomSequences, i64)>,
explosion_radius: Option<f32>,
) -> Vec<ItemStack> {
let Some(block) = registry.state(state) else {
return vec![];
@@ -738,6 +762,7 @@ impl Items {
properties: &block.properties,
held,
killed_by_player: false,
explosion_radius,
};
return ctx.evaluate(table, random);
}
@@ -747,6 +772,7 @@ impl Items {
properties: &block.properties,
held,
killed_by_player: false,
explosion_radius,
};
ctx.evaluate(table, random)
}
@@ -769,6 +795,7 @@ impl Items {
properties: &empty,
held,
killed_by_player,
explosion_radius: None,
};
ctx.evaluate(table, random)
}
@@ -800,6 +827,7 @@ impl Items {
properties: &block.properties,
held: None,
killed_by_player: false,
explosion_radius: None,
};
match table.get("random_sequence").and_then(Value::as_str) {
Some(sequence) => ctx.evaluate(table, sequences.get(sequence, seed)),
@@ -824,6 +852,7 @@ impl Items {
properties: &empty,
held,
killed_by_player,
explosion_radius: None,
};
ctx.evaluate(table, random)
}
@@ -845,6 +874,7 @@ impl Items {
properties: &empty,
held,
killed_by_player,
explosion_radius: None,
};
ctx.evaluate(table, random)
}
@@ -884,6 +914,8 @@ struct LootContext<'a> {
properties: &'a BTreeMap<String, String>,
held: Option<&'a ItemStack>,
killed_by_player: bool,
/// `LootContextParams.EXPLOSION_RADIUS`: an explosion that decays drops.
explosion_radius: Option<f32>,
}
impl LootContext<'_> {
/// Level of an enchantment on the tool / killer's weapon.
@@ -945,7 +977,10 @@ impl LootContext<'_> {
_ => return true,
};
match kind {
"minecraft:survives_explosion" => true,
// ExplosionCondition: 1 / radius under a decaying explosion.
"minecraft:survives_explosion" => self
.explosion_radius
.is_none_or(|r| random.next_float() <= 1.0 / r),
"minecraft:tool/can_silk_touch" => self.enchantment_level("minecraft:silk_touch") > 0,
"minecraft:tool/can_shear" => self.held.is_some_and(|h| &*h.item == "minecraft:shears"),
"minecraft:inverted" => !self.condition(&c["term"], random),
@@ -1230,6 +1265,15 @@ impl LootContext<'_> {
}
}
}
// ApplyExplosionDecay: each item survives with 1 / radius.
"minecraft:explosion_decay" => {
if let Some(radius) = self.explosion_radius {
let probability = 1.0 / radius;
stack.count = (0..stack.count)
.filter(|_| random.next_float() <= probability)
.count() as u32;
}
}
"minecraft:limit_count" => {
let limit = &f["limit"];
if let Some(min) = limit["min"].as_i64() {
@@ -1351,6 +1395,7 @@ mod tests {
properties: props,
held,
killed_by_player: block.is_empty(),
explosion_radius: None,
}
}
+1
View File
@@ -9,6 +9,7 @@ pub mod atlas_sources;
pub mod attack_strength;
pub mod attribute_updates;
pub mod audio;
pub mod auth;
pub mod auto_jump;
pub mod banner;
pub mod biome;
+27 -3
View File
@@ -493,6 +493,8 @@ pub enum Who {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DamageKind {
PlayerAttack,
/// `mace_smash`: a mace hit after a fall (the player attack tags too).
MaceSmash,
MobAttack,
Arrow,
Thrown,
@@ -542,6 +544,14 @@ impl Damage {
from: Some(from),
}
}
/// `DamageSources.mace`: a player's smash attack.
pub fn mace(from: [f64; 3]) -> Self {
Self {
kind: DamageKind::MaceSmash,
attacker: Some(Who::Player),
from: Some(from),
}
}
pub fn mob(id: u32, from: [f64; 3]) -> Self {
Self {
kind: DamageKind::MobAttack,
@@ -1551,6 +1561,16 @@ impl Mob {
.fold((0.0, 0.0), |(a, t), (x, y)| (a + x, t + y))
}
pub fn damage(&mut self, amount: f32, source: Damage) -> bool {
self.damage_with(amount, source, None)
}
/// `damage` by a source with a weapon: `armor_effectiveness` runs the
/// weapon's armor-effectiveness enchantments (breach) over the armor fraction.
pub fn damage_with(
&mut self,
amount: f32,
source: Damage,
armor_effectiveness: Option<&mut dyn FnMut(f32) -> f32>,
) -> bool {
axolotl::before_damage(self, amount, &source);
raider::note_hurt(self);
if !self.alive() || self.removed || self.invulnerable_flag {
@@ -1569,7 +1589,11 @@ impl Mob {
let armor = self.kind.armor + worn;
let toughness = 2.0 + (self.kind.armor_toughness + worn_toughness) / 4.0;
let effective = (armor - amount / toughness).clamp(armor * 0.2, 20.0);
amount *= 1.0 - effective / 25.0;
let mut fraction = effective / 25.0;
if let Some(modify) = armor_effectiveness {
fraction = modify(fraction).clamp(0.0, 1.0);
}
amount *= 1.0 - fraction;
}
// CombatRules.getDamageAfterMagicAbsorb: enchantment protection.
let epf = gear::protection(self, source.kind);
@@ -1604,7 +1628,7 @@ impl Mob {
let (dx, dz) = source.from.map_or((0.0, 0.0), |f| {
(f[0] - self.position.x, f[2] - self.position.z)
});
self.knockback(0.4, dx, dz);
self.knockback(f64::from(0.4f32), dx, dz);
}
ai::after_hurt(self, &source);
if self.health <= 0.0 {
@@ -1631,7 +1655,7 @@ impl Mob {
}
/// LivingEntity.knockback(power, xd, zd) towards the negative direction.
pub fn knockback(&mut self, power: f64, mut xd: f64, mut zd: f64) {
let power = power * (1.0 - self.kind.knockback_resistance);
let power = power * (1.0 - self.attrs.knockback_resistance);
if power <= 0.0 {
return;
}
@@ -117,6 +117,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage) -> bool {
let direct = matches!(
source.kind,
DamageKind::PlayerAttack
| DamageKind::MaceSmash
| DamageKind::MobAttack
| DamageKind::Arrow
| DamageKind::Thrown
+4 -1
View File
@@ -291,7 +291,10 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
if m.hurt_time == 10
&& !moving
&& let Some((d, _)) = m.last_damage
&& matches!(d.kind, DamageKind::PlayerAttack | DamageKind::MobAttack)
&& matches!(
d.kind,
DamageKind::PlayerAttack | DamageKind::MaceSmash | DamageKind::MobAttack
)
{
let from = [m.position.x, m.position.y, m.position.z];
match d.attacker {
@@ -289,6 +289,7 @@ pub fn accepts_damage(m: &mut Mob, source: &Damage, amount: f32) -> bool {
let immune = matches!(
source.kind,
DamageKind::PlayerAttack
| DamageKind::MaceSmash
| DamageKind::MobAttack
| DamageKind::Arrow
| DamageKind::Thrown
+20
View File
@@ -148,6 +148,13 @@ pub enum MotionEvent {
InsidePortal {
pos: BlockPos,
},
/// `ServerPlayer.checkFallDamage` after a mace smash: block particles
/// from the landing block, more the further the fall.
SmashLanding {
state: BlockStateId,
position: BlockPos,
fall_distance: f64,
},
}
pub struct PlayerMotion {
pub fluids: horizon_world::entity_fluid::EntityFluidInteraction,
@@ -214,6 +221,9 @@ pub struct PlayerMotion {
pub events: Vec<MotionEvent>,
pub attributes: LiveAttributes<Box<dyn FnMut() -> i32>>,
pub impulse: ImpulseContext,
/// `ServerPlayer.spawnExtraParticlesOnFall`: a mace smash on a grounded
/// target makes the next landing throw up the block below.
pub spawn_extra_particles_on_fall: bool,
pub health: crate::health::PlayerHealth,
/// Status effects and armor protection seen by movement and damage.
pub status: crate::effects::StatusFlags,
@@ -301,6 +311,7 @@ impl PlayerMotion {
health: crate::health::PlayerHealth::new(&resources.health, &mut attributes)?,
status: crate::effects::StatusFlags::default(),
impulse: ImpulseContext::default(),
spawn_extra_particles_on_fall: false,
position,
velocity: Vec3::ZERO,
ground: GroundState::default(),
@@ -1495,6 +1506,15 @@ impl EntityMoveWorld for MotionWorld<'_, '_, '_> {
state: BlockStateId,
position: BlockPos,
) -> Result<()> {
if self.player.spawn_extra_particles_on_fall && grounded && self.player.fall_distance > 0.0
{
self.player.events.push(MotionEvent::SmashLanding {
state,
position,
fall_distance: self.player.fall_distance,
});
self.player.spawn_extra_particles_on_fall = false;
}
self.player.events.push(MotionEvent::Landing {
dy,
grounded,
+60 -14
View File
@@ -1,17 +1,20 @@
//! Multiplayer session: a network thread that connects to a server, logs in
//! (offline mode only), runs the configuration phase and then forwards decoded
//! play packets to the game thread. Keep-alives and pings are answered on the
//! network thread like vanilla's connection handlers so a busy frame never
//! times the client out. Online-mode (authenticated) servers are refused:
//! Horizon never handles Microsoft credentials.
//! Multiplayer session: a network thread that connects to a server, logs in,
//! runs the configuration phase and then forwards decoded play packets to the
//! game thread. Keep-alives and pings are answered on the network thread like
//! vanilla's connection handlers so a busy frame never times the client out.
//! Online-mode servers need the Microsoft account the launcher signed in
//! (crate::auth): the login joins the server through the session service and
//! encrypts the connection (ClientHandshakePacketListenerImpl.handleHello).
use crate::auth::AuthSession;
use horizon_protocol::{
PROTOCOL_VERSION,
connection::{ConnReader, ConnWriter, Connection, Counters},
crypto::offline_uuid,
crypto::{generate_secret, offline_uuid, server_hash},
packets::{Empty, configuration as cfg, handshake, login, play},
registry::Dynamic,
rsa::RsaPublicKey,
servers::parse_address,
text::{Language, plain},
text::{Language, plain, translatable},
};
use std::{
sync::{
@@ -51,8 +54,14 @@ pub struct Session {
debug: bool,
}
impl Session {
/// Start connecting in the background.
pub fn connect(address: &str, name: &str, view_distance: i8, lang: Arc<Language>) -> Self {
/// Start connecting in the background, as `auth`'s account when there is one.
pub fn connect(
address: &str,
name: &str,
auth: Option<Arc<AuthSession>>,
view_distance: i8,
lang: Arc<Language>,
) -> Self {
let (send, events) = channel();
let writer = Arc::new(Mutex::new(None));
let counters = Arc::new(Mutex::new(None));
@@ -64,6 +73,7 @@ impl Session {
let reason = match run(
&address_owned,
&name_owned,
auth.as_deref(),
view_distance,
&lang,
&send,
@@ -131,10 +141,19 @@ fn status(send: &Sender<Event>, text: &str) {
let _ = send.send(Event::Status(text.to_owned()));
}
/// Shown when an online-mode server asks a client without an account to authenticate.
pub const NOT_SIGNED_IN: &str = "This server is in online mode. Sign in with your Microsoft account in the Horizon launcher to join it.";
/// A translation, or the key itself (Language.getOrDefault).
fn tr(lang: &Language, key: &str) -> String {
lang.get(key).cloned().unwrap_or_else(|| key.to_owned())
}
/// The whole connection; returns the disconnect reason.
fn run(
address: &str,
name: &str,
auth: Option<&AuthSession>,
view_distance: i8,
lang: &Language,
send: &Sender<Event>,
@@ -158,8 +177,8 @@ fn run(
.encode(),
)
.map_err(e)?;
status(send, "Logging in...");
let uuid = offline_uuid(name);
// Vanilla's login sends the account's profile id, or the offline one.
let uuid = auth.map_or_else(|| offline_uuid(name), |a| a.uuid);
c.send(
&login::Serverbound::Hello(login::ServerHello {
name: name.to_owned(),
@@ -183,8 +202,35 @@ fn run(
.unwrap_or(p.reason_json);
return Err(reason);
}
login::Clientbound::Hello(_) => {
return Err("This server is in online mode. Horizon only joins offline-mode servers (online-mode=false).".into());
login::Clientbound::Hello(hello) => {
status(send, &tr(lang, "connect.authorizing"));
let key = RsaPublicKey::from_der(&hello.public_key)
.map_err(|err| format!("Protocol error: {err}"))?;
let secret = generate_secret().map_err(e)?;
if hello.should_authenticate {
let account = auth.ok_or_else(|| NOT_SIGNED_IN.to_owned())?;
let hash = server_hash(&hello.server_id, &secret, &hello.public_key);
if let Err(err) = crate::auth::join_server(account, &hash) {
let reason = match err.reason() {
Ok(key) => tr(lang, key),
Err(message) => message.to_owned(),
};
return Err(plain(
&translatable("disconnect.loginFailedInfo", &[&reason]),
lang,
));
}
}
status(send, &tr(lang, "connect.encrypting"));
c.send(
&login::Serverbound::Key(login::Key {
key: key.encrypt(&secret).map_err(e)?,
challenge: key.encrypt(&hello.challenge).map_err(e)?,
})
.encode(),
)
.map_err(e)?;
c.enable_encryption(&secret);
}
login::Clientbound::CustomQuery(q) => {
c.send(
+28 -3
View File
@@ -1732,6 +1732,9 @@ pub struct Level {
pub day_time: i64,
/// The player's respawn point (bed, or the world spawn).
pub spawn: Option<[f64; 3]>,
/// A respawn point in another dimension than the Overworld (a respawn
/// anchor): dimension, block, yaw and `forced`.
pub respawn_elsewhere: Option<(String, [i32; 3], f32, bool)>,
pub position: Option<[f64; 3]>,
pub rotation: [f32; 2],
pub health: f32,
@@ -1924,7 +1927,18 @@ impl Level {
&& let Some(Tag::IntArray(pos)) = respawn.get("pos")
&& pos.len() == 3
{
self.spawn = Some([f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])]);
let dimension =
text(respawn.get("dimension")).unwrap_or_else(|| "minecraft:overworld".into());
if dimension == "minecraft:overworld" {
self.spawn = Some([f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])]);
} else {
let yaw = match respawn.get("yaw") {
Some(Tag::Float(b)) => f32::from_bits(*b),
_ => 0.0,
};
let forced = number(respawn.get("forced")).is_some_and(|v| v != 0);
self.respawn_elsewhere = Some((dimension, [pos[0], pos[1], pos[2]], yaw, forced));
}
}
let mut inventory = Vec::new();
let mut inventory_components = HashMap::new();
@@ -2116,8 +2130,19 @@ impl Level {
if let Some(pos) = self.position {
entries.push(("Pos", doubles(&pos)));
}
// A respawn point other than the world spawn (a bed).
if let Some(s) = self.spawn {
// A respawn point other than the world spawn: an anchor elsewhere, or a bed.
if let Some((dimension, block, yaw, forced)) = &self.respawn_elsewhere {
let mut respawn = vec![
("dimension", string(dimension)),
("pos", Tag::IntArray(block.to_vec())),
("yaw", Tag::Float(yaw.to_bits())),
("pitch", Tag::Float(0f32.to_bits())),
];
if *forced {
respawn.push(("forced", Tag::Byte(1)));
}
entries.push(("respawn", Tag::compound(respawn)));
} else if let Some(s) = self.spawn {
let block = [
s[0].floor() as i32,
s[1].floor() as i32,
+47 -49
View File
@@ -246,9 +246,8 @@ pub fn process_legacy_skin(width: u32, height: u32, rgba: &[u8]) -> Option<Vec<u
/// `SkinTextureDownloader`: fetches textures on background threads, from
/// the local cache (`<root>/<2 hex>/<sha1>`) or over HTTP, keeping each one
/// by kind and hash as vanilla's `TextureCache`s do. Plain HTTP only: an
/// `https` texture that isn't cached fails, and the player keeps their
/// default skin.
/// by kind and hash as vanilla's `TextureCache`s do. A texture that can't
/// be fetched fails, and the player keeps their default skin.
pub struct Downloader {
root: std::path::PathBuf,
states: std::collections::HashMap<(Kind, String), Download>,
@@ -318,53 +317,23 @@ impl Downloader {
}
}
/// A plain HTTP/1.1 GET; the body of a 2xx answer.
/// A GET over HTTP or HTTPS (textures.minecraft.net serves both; vanilla
/// uses https): the body of a 2xx answer, 16 MiB at most, after redirects.
fn http_get(url: &str) -> Option<Vec<u8>> {
use std::io::{Read, Write};
let rest = url.strip_prefix("http://")?;
let (authority, path) = rest.split_at(rest.find('/').unwrap_or(rest.len()));
let path = if path.is_empty() { "/" } else { path };
let path = &path[..path.find('#').unwrap_or(path.len())];
let host = authority.split(':').next()?;
let address = if authority.contains(':') {
authority.to_owned()
} else {
format!("{authority}:80")
};
let timeout = std::time::Duration::from_secs(15);
let addr = std::net::ToSocketAddrs::to_socket_addrs(&address)
.ok()?
.next()?;
let mut stream = std::net::TcpStream::connect_timeout(&addr, timeout).ok()?;
stream.set_read_timeout(Some(timeout)).ok()?;
write!(
stream,
"GET {path} HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\nUser-Agent: Java\r\n\r\n"
)
.ok()?;
let mut response = Vec::new();
stream.take(16 << 20).read_to_end(&mut response).ok()?;
let split = response.windows(4).position(|w| w == b"\r\n\r\n")?;
let head = String::from_utf8_lossy(&response[..split]).to_ascii_lowercase();
let mut body = response[split + 4..].to_vec();
let status: u32 = head.split_whitespace().nth(1)?.parse().ok()?;
if status / 100 != 2 {
return None;
}
if head.contains("transfer-encoding: chunked") {
let (mut out, mut at) = (Vec::new(), 0);
loop {
let end = at + body[at..].windows(2).position(|w| w == b"\r\n")?;
let line = String::from_utf8_lossy(&body[at..end]);
let size = usize::from_str_radix(line.split(';').next()?.trim(), 16).ok()?;
if size == 0 {
break;
}
out.extend_from_slice(body.get(end + 2..end + 2 + size)?);
at = end + 4 + size;
}
body = out;
}
use std::io::Read;
let response = ureq::AgentBuilder::new()
.timeout(std::time::Duration::from_secs(15))
.user_agent("Java")
.build()
.get(url)
.call()
.ok()?;
let mut body = Vec::new();
response
.into_reader()
.take(16 << 20)
.read_to_end(&mut body)
.ok()?;
Some(body)
}
@@ -424,6 +393,35 @@ pub fn sha1(data: &[u8]) -> [u8; 20] {
#[cfg(test)]
mod tests {
/// Textures come over plain HTTP too (a local server here; https is the
/// same request through rustls), and only 2xx answers count.
#[test]
fn http_get_reads_2xx_bodies() {
use std::io::{BufRead, BufReader, Write};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
std::thread::spawn(move || {
for stream in listener.incoming().take(2) {
let mut stream = stream.unwrap();
let mut line = String::new();
let mut reader = BufReader::new(stream.try_clone().unwrap());
reader.read_line(&mut line).unwrap();
while reader.read_line(&mut String::new()).unwrap() > 2 {}
let reply: &[u8] = if line.contains("/texture/abc") {
b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\nConnection: close\r\n\r\nPNG!"
} else {
b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
};
stream.write_all(reply).unwrap();
}
});
assert_eq!(
http_get(&format!("{base}/texture/abc")),
Some(b"PNG!".to_vec())
);
assert_eq!(http_get(&format!("{base}/texture/missing")), None);
}
use super::*;
#[test]
+356 -13
View File
@@ -513,7 +513,27 @@ pub fn import(
&hint(LAUNCHER_HINT, version),
)?);
}
for (side, jar) in [("client", &client), ("server", &server)] {
write_import_metadata(
root,
lock,
&client,
&server,
&client_libraries,
&server_libraries,
log,
)
}
fn write_import_metadata(
root: &Path,
lock: &Lock,
client: &Path,
server: &Path,
client_libraries: &[PathBuf],
server_libraries: &[PathBuf],
log: Log,
) -> Result<(), String> {
for (side, jar) in [("client", client), ("server", server)] {
let data = crate::inventory::inventory(jar)?;
let count = |key| data.get(key).cloned().unwrap_or(Value::Null);
write_json(
@@ -538,25 +558,19 @@ pub fn import(
write_json(
&lock.directory.join("prepared.json"),
&Value::Object(vec![
("version".into(), Value::str(id)),
("version".into(), Value::str(&lock.version)),
(
"jars".into(),
Value::Object(vec![
(
"client".into(),
Value::Str(relative_display(&client, root)?),
),
(
"server".into(),
Value::Str(relative_display(&server, root)?),
),
("client".into(), Value::Str(relative_display(client, root)?)),
("server".into(), Value::Str(relative_display(server, root)?)),
]),
),
(
"libraries".into(),
Value::Object(vec![
("client".into(), paths(&client_libraries)?),
("server".into(), paths(&server_libraries)?),
("client".into(), paths(client_libraries)?),
("server".into(), paths(server_libraries)?),
]),
),
]),
@@ -573,6 +587,100 @@ pub struct Artifacts {
pub libraries: Vec<PathBuf>,
}
/// Reuses checked imports from this root or another installed version beside it.
pub fn reuse_imported(root: &Path, log: Log) -> Result<bool, String> {
let root = fs::canonicalize(root).map_err(|e| format!("{}: {e}", root.display()))?;
let lock = Lock::read(&root)?;
let checked = |directory: PathBuf| -> Result<Vec<PathBuf>, String> {
let candidate = Lock {
json: lock.json.clone(),
version: lock.version.clone(),
java_major: lock.java_major,
directory,
};
let found = verify(&candidate)?;
let client = client_libraries(&candidate, &found.manifest)?;
let mut files = vec![
candidate.directory.join("manifest.json"),
candidate.directory.join("jars/client.jar"),
candidate.directory.join("jars/server.jar"),
found.jars["server"].clone(),
];
files.extend(found.libraries);
files.extend(client);
Ok(files)
};
if checked(lock.directory.clone()).is_ok() {
if [
"prepared.json",
"reports/client-inventory.json",
"reports/server-inventory.json",
]
.iter()
.any(|path| !lock.directory.join(path).is_file())
{
let found = verify(&lock)?;
let client_libraries = client_libraries(&lock, &found.manifest)?;
write_import_metadata(
&root,
&lock,
&found.jars["client"],
&found.jars["server"],
&client_libraries,
&found.libraries,
log,
)?;
}
log(&format!("Using imported Minecraft {}", lock.version));
return Ok(true);
}
let Some(versions) = root.parent() else {
return Ok(false);
};
// Sibling discovery is intended for the launcher's versions/ folder.
let mut siblings: Vec<_> = fs::read_dir(versions)
.map_err(|e| format!("{}: {e}", versions.display()))?
.filter_map(Result::ok)
.map(|entry| entry.path())
.filter(|path| path != &root && path.is_dir())
.collect();
siblings.sort();
for sibling in siblings {
let source = sibling.join(".local/minecraft").join(&lock.version);
let Ok(files) = checked(source.clone()) else {
continue;
};
for file in files {
let relative = file.strip_prefix(&source).map_err(|e| e.to_string())?;
import_copy(
&file,
&lock.directory.join(relative),
&digest(&file, "sha256")?,
"sha256",
"",
)?;
}
let found = verify(&lock)?;
let client_libraries = client_libraries(&lock, &found.manifest)?;
write_import_metadata(
&root,
&lock,
&found.jars["client"],
&found.jars["server"],
&client_libraries,
&found.libraries,
log,
)?;
log(&format!(
"Reused imported Minecraft {} from {}",
lock.version,
sibling.display()
));
return Ok(true);
}
Ok(false)
}
pub fn verify(lock: &Lock) -> Result<Artifacts, String> {
let manifest_path = lock.directory.join("manifest.json");
if !manifest_path.exists() {
@@ -597,7 +705,10 @@ pub fn verify(lock: &Lock) -> Result<Artifacts, String> {
.and_then(|d| d.get(side))
.and_then(|d| d.get("sha1"))
.and_then(Value::as_str);
if !jar.exists() || Some(digest(&jar, "sha1")?.as_str()) != pinned {
if pinned != Some(lock.pin(&format!("{side}_sha1"))?)
|| !jar.exists()
|| Some(digest(&jar, "sha1")?.as_str()) != pinned
{
return Err(format!(
"{side} artifact checksum changed; prepare again with --prepare"
));
@@ -648,6 +759,238 @@ pub fn client_libraries(lock: &Lock, manifest: &Value) -> Result<Vec<PathBuf>, S
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
fn jar(marker: &[u8]) -> Vec<u8> {
let mut archive = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
archive
.start_file("marker", zip::write::SimpleFileOptions::default())
.unwrap();
archive.write_all(marker).unwrap();
archive.finish().unwrap().into_inner()
}
struct Imports {
directory: PathBuf,
source: PathBuf,
target: PathBuf,
}
impl Imports {
fn new() -> Self {
static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
let n = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let directory = std::env::temp_dir()
.join(format!("horizon-import-reuse-{}-{n}", std::process::id()));
let source = directory.join("old");
let target = directory.join("new");
fs::create_dir_all(&target).unwrap();
let imported = source.join(".local/minecraft/9.9");
let write = |path: &str, data: &[u8]| {
let path = imported.join(path);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, data).unwrap();
};
let client = jar(b"client");
let game = jar(b"server game");
write("jars/client.jar", &client);
write("jars/server-game.jar", &game);
write("libraries/server/server.jar", b"server library");
write("libraries/client/client.jar", b"client library");
write("reports/private.txt", b"not an imported artifact");
let mut bundle =
zip::ZipWriter::new(fs::File::create(imported.join("jars/server.jar")).unwrap());
let entries = [
(
"META-INF/versions.list",
format!("{}\t9.9\tgame.jar\n", crate::sha256_hex(&game)),
),
(
"META-INF/libraries.list",
format!(
"{}\tserver:library:1\tserver.jar\n",
crate::sha256_hex(b"server library")
),
),
];
for (name, text) in entries {
bundle
.start_file(name, zip::write::SimpleFileOptions::default())
.unwrap();
bundle.write_all(text.as_bytes()).unwrap();
}
for (name, bytes) in [
("META-INF/versions/game.jar", game.as_slice()),
(
"META-INF/libraries/server.jar",
b"server library".as_slice(),
),
] {
bundle
.start_file(name, zip::write::SimpleFileOptions::default())
.unwrap();
bundle.write_all(bytes).unwrap();
}
bundle.finish().unwrap();
let client_sha1 = digest(&imported.join("jars/client.jar"), "sha1").unwrap();
let server_sha1 = digest(&imported.join("jars/server.jar"), "sha1").unwrap();
let library_sha1 =
digest(&imported.join("libraries/client/client.jar"), "sha1").unwrap();
let manifest = format!(
"{{\"id\":\"9.9\",\"downloads\":{{\"client\":{{\"sha1\":\"{client_sha1}\"}},\"server\":{{\"sha1\":\"{server_sha1}\"}}}},\"libraries\":[{{\"name\":\"client:library:1\",\"downloads\":{{\"artifact\":{{\"path\":\"client.jar\",\"sha1\":\"{library_sha1}\"}}}}}}]}}"
);
write("manifest.json", manifest.as_bytes());
let manifest_sha1 = digest(&imported.join("manifest.json"), "sha1").unwrap();
let lock = format!(
"{{\"minecraft\":{{\"version\":\"9.9\",\"java_major\":25,\"manifest_sha1\":\"{manifest_sha1}\",\"client_sha1\":\"{client_sha1}\",\"server_sha1\":\"{server_sha1}\"}}}}"
);
fs::write(target.join("research-lock.json"), lock).unwrap();
Self {
directory,
source,
target,
}
}
fn imported(&self, root: &Path) -> PathBuf {
root.join(".local/minecraft/9.9")
}
}
impl Drop for Imports {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.directory);
}
}
#[test]
fn imported_files_are_reused_without_the_official_install() {
let fixture = Imports::new();
fs::write(
fixture.imported(&fixture.source).join("prepared.json"),
b"stale source metadata",
)
.unwrap();
assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
let lock = Lock::read(&fixture.target).unwrap();
let artifacts = verify(&lock).unwrap();
assert_eq!(
client_libraries(&lock, &artifacts.manifest).unwrap().len(),
1
);
assert_eq!(artifacts.libraries.len(), 1);
let prepared = read_json(&lock.directory.join("prepared.json")).unwrap();
assert_eq!(prepared.get("version").and_then(Value::as_str), Some("9.9"));
for side in ["client", "server"] {
assert_eq!(
prepared
.get("jars")
.unwrap()
.get(side)
.and_then(Value::as_str),
Some(
relative_display(&artifacts.jars[side], &fixture.target)
.unwrap()
.as_str()
)
);
let inventory = read_json(
&lock
.directory
.join(format!("reports/{side}-inventory.json")),
)
.unwrap();
assert_eq!(
inventory.get("jar_sha256").and_then(Value::as_str),
Some(digest(&artifacts.jars[side], "sha256").unwrap().as_str())
);
}
assert!(!lock.directory.join("reports/private.txt").exists());
for side in ["client", "server"] {
let libraries = prepared
.get("libraries")
.unwrap()
.get(side)
.unwrap()
.as_array()
.unwrap();
assert_eq!(libraries.len(), 1);
assert_eq!(
libraries[0].as_str(),
Some(
relative_display(
&lock.directory.join(format!("libraries/{side}/{side}.jar")),
&fixture.target
)
.unwrap()
.as_str()
)
);
}
// The current root's valid imports suffice even after the older copy is corrupted.
fs::write(
fixture.imported(&fixture.source).join("jars/client.jar"),
b"bad",
)
.unwrap();
// Repair metadata omitted by earlier reuse implementations, without a sibling.
fs::remove_file(lock.directory.join("prepared.json")).unwrap();
fs::remove_file(lock.directory.join("reports/client-inventory.json")).unwrap();
assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
assert!(read_json(&lock.directory.join("prepared.json")).is_ok());
assert!(read_json(&lock.directory.join("reports/client-inventory.json")).is_ok());
}
#[test]
fn reuse_rejects_corrupt_imports() {
for file in [
"manifest.json",
"jars/client.jar",
"jars/server.jar",
"jars/server-game.jar",
"libraries/client/client.jar",
"libraries/server/server.jar",
] {
let fixture = Imports::new();
fs::write(fixture.imported(&fixture.source).join(file), b"bad").unwrap();
assert!(!reuse_imported(&fixture.target, &|_| {}).unwrap(), "{file}");
assert!(!fixture.imported(&fixture.target).exists());
}
}
#[test]
fn reuse_checks_the_target_pins() {
let fixture = Imports::new();
let mut lock = Lock::read(&fixture.target).unwrap();
let client = lock.pin("client_sha1").unwrap().to_string();
let text = fs::read_to_string(fixture.target.join("research-lock.json")).unwrap();
fs::write(
fixture.target.join("research-lock.json"),
text.replace(&client, "wrong-client-pin"),
)
.unwrap();
assert!(!reuse_imported(&fixture.target, &|_| {}).unwrap());
lock.directory = fixture.imported(&fixture.source);
assert!(verify(&lock).is_ok());
}
#[test]
fn reuse_skips_a_bad_sibling_and_repairs_bad_current_imports() {
let fixture = Imports::new();
let bad = fixture.directory.join("a-bad");
fs::rename(&fixture.source, &bad).unwrap();
let valid = Imports::new();
fs::rename(&valid.source, &fixture.source).unwrap();
fs::write(fixture.imported(&bad).join("jars/client.jar"), b"bad").unwrap();
let target = fixture.imported(&fixture.target);
fs::create_dir_all(target.join("jars")).unwrap();
fs::write(target.join("jars/client.jar"), b"bad").unwrap();
assert!(reuse_imported(&fixture.target, &|_| {}).unwrap());
assert_eq!(
fs::read(target.join("jars/client.jar")).unwrap(),
fs::read(fixture.imported(&fixture.source).join("jars/client.jar")).unwrap()
);
}
#[test]
fn natives_follow_the_architecture() {
+14 -4
View File
@@ -17,7 +17,7 @@ pub mod pyjson;
mod sounds;
mod survival;
pub use sounds::sounds;
pub use sounds::{panorama, sounds};
use pyjson::Value;
use sha2::Digest;
@@ -402,7 +402,7 @@ pub fn prepare(options: &Options, log: Log) -> Result<PathBuf, String> {
let lock = artifacts::Lock::read(root)?;
// Java first: nothing below can finish without it, and the player should hear it at once.
let jdk = java::find(lock.java_major)?;
if options.import {
if options.import && !artifacts::reuse_imported(root, log)? {
artifacts::import(
root,
&lock,
@@ -452,7 +452,7 @@ pub fn prepare(options: &Options, log: Log) -> Result<PathBuf, String> {
origin,
log,
};
steps(&run, &lock, &oracle)?;
steps(&run, &lock, &oracle, options.minecraft_dir.as_deref())?;
log(&format!(
"Prepared Horizon native-client resources: {}",
resources.display()
@@ -464,7 +464,12 @@ fn arg(path: &Path) -> String {
path.display().to_string()
}
fn steps(run: &Run, lock: &artifacts::Lock, oracle: &Path) -> Result<(), String> {
fn steps(
run: &Run,
lock: &artifacts::Lock,
oracle: &Path,
minecraft: Option<&Path>,
) -> Result<(), String> {
let root = &run.resources;
let repo = &run.root;
let server_cp = run.server_classpath.as_str();
@@ -678,6 +683,11 @@ fn steps(run: &Run, lock: &artifacts::Lock, oracle: &Path) -> Result<(), String>
count += 1;
}
// The JAR holds only gray 1x1 panorama placeholders. Import the indexed
// textures afterwards, including on reruns that just extracted the JAR again.
// Cosmetic assets are optional when preparing from already-imported JARs.
sounds::optional_panorama(repo, minecraft, run.log);
// One file each, exported again when the exporter or the jar it reads changed.
let single = |what: &str,
file: &str,
+15 -7
View File
@@ -10,6 +10,7 @@ horizon-prepare: prepare Horizon's resources from your own Minecraft Java Editio
Usage: horizon-prepare [--prepare] [--server-jar PATH] [--minecraft-dir PATH] [--root PATH]
horizon-prepare sounds [--minecraft-dir PATH] [--root PATH]
horizon-prepare panorama [--minecraft-dir PATH] [--root PATH]
--prepare Import the pinned game files from your own copy first
--server-jar PATH The pinned server jar you downloaded yourself
@@ -23,6 +24,9 @@ Needs Minecraft played once from the official launcher, and Java (a JDK) of the
research-lock.json pins: JAVA_HOME, else javac and java on the PATH.
The resources go to <root>/.local/horizon-client/<version>; pass that to horizon-client --resources.
horizon-prepare panorama repairs the classic menu background in existing resources without Java.
Full preparation also imports these textures after extracting the client JAR's placeholders.
horizon-prepare sounds copies the pinned version's sounds (about 380 MB) from the official
launcher's asset store into the same folder, checking every file. It is optional: without it the
game is silent. Nothing is downloaded; it needs the version played once from the official launcher.
@@ -52,7 +56,7 @@ fn main() -> ExitCode {
};
let mut root = None;
let mut args = std::env::args_os().skip(1).peekable();
let sounds = args.next_if(|a| a == "sounds").is_some();
let assets = args.next_if(|a| a == "sounds" || a == "panorama");
while let Some(arg) = args.next() {
let text = arg.to_string_lossy().into_owned();
let (flag, inline) = match text.split_once('=') {
@@ -71,8 +75,8 @@ fn main() -> ExitCode {
}
};
let parsed = match flag.as_str() {
"--prepare" | "--server-jar" if sounds => {
Err(format!("{flag} is for preparing, not for sounds"))
"--prepare" | "--server-jar" if assets.is_some() => {
Err(format!("{flag} is for preparing, not for asset copying"))
}
"--prepare" if inline.is_none() => {
options.import = true;
@@ -108,10 +112,14 @@ fn main() -> ExitCode {
let _ = writeln!(out, "{line}");
let _ = out.flush();
};
let result = if sounds {
horizon_prepare::sounds(&options.root, options.minecraft_dir.as_deref(), &log)
} else {
horizon_prepare::prepare(&options, &log)
let result = match assets.as_deref().and_then(|a| a.to_str()) {
Some("sounds") => {
horizon_prepare::sounds(&options.root, options.minecraft_dir.as_deref(), &log)
}
Some("panorama") => {
horizon_prepare::panorama(&options.root, options.minecraft_dir.as_deref(), &log)
}
_ => horizon_prepare::prepare(&options, &log),
};
match result {
Ok(_) => ExitCode::SUCCESS,
+156 -12
View File
@@ -1,4 +1,4 @@
//! The pinned version's sounds (sounds.json and the .ogg files) from the player's own official
//! The pinned version's sounds and title panorama from the player's own official
//! launcher install, each object checked against the asset index's SHA-1, copied into
//! `.local/horizon-client/<version>/assets` where the game reads them (tools/fetch_sounds.py and
//! the tools/lab.py functions it called). Nothing is downloaded.
@@ -76,6 +76,46 @@ fn is_sound(name: &str) -> bool {
/// `.local/horizon-client/<version>`; returns that folder. Files already there with the right
/// SHA-1 are kept.
pub fn sounds(root: &Path, minecraft: Option<&Path>, log: Log) -> Result<PathBuf, String> {
copy_assets(root, minecraft, log, is_sound, "Sound", &[])
}
/// Replaces the client JAR's 1x1 title placeholders with the full panorama from the
/// launcher's asset store. Also usable on already-prepared resources without Java.
pub fn panorama(root: &Path, minecraft: Option<&Path>, log: Log) -> Result<PathBuf, String> {
copy_assets(root, minecraft, log, is_panorama, "Panorama", &PANORAMA)
}
/// Full preparation can run from cached JARs without an official launcher install.
pub(crate) fn optional_panorama(root: &Path, minecraft: Option<&Path>, log: Log) {
if let Err(error) = panorama(root, minecraft, log) {
log(&format!(
"Title panorama not imported: {error}; run horizon-prepare panorama later"
));
}
}
const PANORAMA: [&str; 7] = [
"minecraft/textures/gui/title/background/panorama_0.png",
"minecraft/textures/gui/title/background/panorama_1.png",
"minecraft/textures/gui/title/background/panorama_2.png",
"minecraft/textures/gui/title/background/panorama_3.png",
"minecraft/textures/gui/title/background/panorama_4.png",
"minecraft/textures/gui/title/background/panorama_5.png",
"minecraft/textures/gui/title/background/panorama_overlay.png",
];
fn is_panorama(name: &str) -> bool {
PANORAMA.contains(&name)
}
fn copy_assets(
root: &Path,
minecraft: Option<&Path>,
log: Log,
wanted_asset: fn(&str) -> bool,
label: &str,
required: &[&str],
) -> Result<PathBuf, String> {
let lock = Lock::read(root)?;
let minecraft = artifacts::minecraft_dir(minecraft);
let manifest = artifacts::import_manifest(&lock, &minecraft)?;
@@ -95,13 +135,19 @@ pub fn sounds(root: &Path, minecraft: Option<&Path>, log: Log) -> Result<PathBuf
.ok_or_else(|| format!("{} has no objects", index.display()))?;
// A repeated name keeps its first place and its last value, as a Python dict does.
let mut wanted: Vec<(&str, &Value)> = Vec::new();
for (name, info) in objects.iter().filter(|(name, _)| is_sound(name)) {
for (name, info) in objects.iter().filter(|(name, _)| wanted_asset(name)) {
match wanted.iter_mut().find(|(n, _)| n == name) {
Some(entry) => entry.1 = info,
None => wanted.push((name, info)),
}
}
for name in required {
if !wanted.iter().any(|(n, _)| n == name) {
return Err(format!("{name} is missing from the asset index"));
}
}
let mut total: u64 = 0;
let mut copies = Vec::with_capacity(wanted.len());
for (name, info) in &wanted {
let hash = info
.get("hash")
@@ -115,17 +161,16 @@ pub fn sounds(root: &Path, minecraft: Option<&Path>, log: Log) -> Result<PathBuf
let relative = artifacts::safe_relative(name)
.ok_or_else(|| format!("Unsafe asset name {name:?} in the asset index"))?;
let source = launcher_object(&store, hash)?;
artifacts::import_copy(
&source,
&target.join("assets").join(relative),
hash,
"sha1",
"",
)?;
copies.push((source, target.join("assets").join(relative), hash));
total += size;
}
// Check the entire set before replacing any placeholders: a missing late face
// must not leave a mixture of real textures and gray faces in either entry point.
for (source, destination, hash) in copies {
artifacts::import_copy(&source, &destination, hash, "sha1", "")?;
}
log(&format!(
"Sound assets ready: {} files, {:.1} MB",
"{label} assets ready: {} files, {:.1} MB",
wanted.len(),
total as f64 / 1e6
));
@@ -142,7 +187,7 @@ mod tests {
}
/// A Horizon folder and an official launcher directory holding version `9.9` with
/// sounds.json, two sounds and a language file in its asset store.
/// sounds, a language file and the full title panorama in its asset store.
struct Fixture {
dir: PathBuf,
root: PathBuf,
@@ -152,6 +197,10 @@ mod tests {
impl Fixture {
fn new(name: &str) -> Fixture {
Self::with_panorama(name, &PANORAMA)
}
fn with_panorama(name: &str, panorama: &[&'static str]) -> Fixture {
let dir = std::env::temp_dir().join(format!(
"horizon-prepare-sounds-{name}-{}",
std::process::id()
@@ -159,12 +208,16 @@ mod tests {
let _ = fs::remove_dir_all(&dir);
let root = dir.join("horizon");
let minecraft = dir.join("minecraft");
let objects: Vec<(&'static str, Vec<u8>)> = vec![
let mut objects: Vec<(&'static str, Vec<u8>)> = vec![
("minecraft/sounds.json", b"{\"a\": {}}".to_vec()),
("minecraft/sounds/ambient/cave1.ogg", b"OggS cave".to_vec()),
("minecraft/sounds/dig/stone1.ogg", b"OggS stone".to_vec()),
("minecraft/lang/fr_fr.json", b"{}".to_vec()),
];
for &name in panorama {
// Distinct object bytes let the test catch swapped faces too.
objects.push((name, name.as_bytes().to_vec()));
}
let mut index = String::from("{\"objects\": {");
for (i, (name, data)) in objects.iter().enumerate() {
let hash = sha1_hex(data);
@@ -243,6 +296,7 @@ mod tests {
assert_eq!(&fs::read(target.join("assets").join(name)).unwrap(), data);
}
assert!(!target.join("assets/minecraft/lang").exists());
assert!(!target.join("assets/minecraft/textures").exists());
assert_eq!(
fs::read(target.join("asset-index.json")).unwrap(),
fs::read(f.minecraft.join("assets/indexes/7.json")).unwrap()
@@ -267,6 +321,96 @@ mod tests {
assert!(f.run().unwrap_err().starts_with("Missing asset object"));
}
#[test]
fn panorama_replaces_jar_placeholders_and_repairs_repeated_preparations() {
let f = Fixture::new("panorama");
let target = f.root.join(".local/horizon-client/9.9");
for _ in 0..2 {
// Full preparation extracts the JAR before importing the asset store.
for (name, _) in &f.objects[4..] {
let path = target.join("assets").join(name);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, b"1x1 gray placeholder").unwrap();
}
assert_eq!(
panorama(&f.root, Some(&f.minecraft), &|_| {}).unwrap(),
target
);
for (name, data) in &f.objects[4..] {
assert_eq!(&fs::read(target.join("assets").join(name)).unwrap(), data);
}
}
assert!(!target.join("assets/minecraft/sounds.json").exists());
assert!(!target.join("assets/minecraft/lang").exists());
}
#[test]
fn panorama_objects_are_verified_before_replacing_placeholders() {
let f = Fixture::new("panorama-corrupt");
fs::write(f.object(4), b"corrupt panorama").unwrap();
let path = f
.root
.join(".local/horizon-client/9.9/assets")
.join(f.objects[4].0);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(&path, b"placeholder").unwrap();
assert!(panorama(&f.root, Some(&f.minecraft), &|_| {})
.unwrap_err()
.starts_with("Corrupt asset object"));
assert_eq!(fs::read(path).unwrap(), b"placeholder");
fs::remove_file(f.object(4)).unwrap();
assert!(panorama(&f.root, Some(&f.minecraft), &|_| {})
.unwrap_err()
.starts_with("Missing asset object"));
}
#[test]
fn panorama_requires_every_face_and_the_overlay_in_the_index() {
let f = Fixture::with_panorama("panorama-incomplete", &PANORAMA[..6]);
let error = panorama(&f.root, Some(&f.minecraft), &|_| {}).unwrap_err();
assert_eq!(
error,
format!("{} is missing from the asset index", PANORAMA[6])
);
assert!(!f.root.join(".local/horizon-client/9.9/assets").exists());
}
#[test]
fn full_preparation_keeps_placeholders_when_panorama_is_unavailable() {
for missing in ["store", "install", "last-object"] {
let f = Fixture::new(&format!("optional-panorama-{missing}"));
// The JARs and manifest were imported earlier; the launcher need not remain.
artifacts::import_manifest(&Lock::read(&f.root).unwrap(), &f.minecraft).unwrap();
let target = f.root.join(".local/horizon-client/9.9/assets");
for name in PANORAMA {
let path = target.join(name);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, b"jar placeholder").unwrap();
}
match missing {
"store" => fs::remove_dir_all(f.minecraft.join("assets")).unwrap(),
"install" => fs::remove_dir_all(&f.minecraft).unwrap(),
_ => fs::remove_file(f.object(f.objects.len() - 1)).unwrap(),
}
// The repair subcommand remains strict, even for a missing final object.
let error = panorama(&f.root, Some(&f.minecraft), &|_| {}).unwrap_err();
let lines = std::cell::RefCell::new(Vec::new());
// This is the optional import step used by full preparation after extraction.
optional_panorama(&f.root, Some(&f.minecraft), &|line| {
lines.borrow_mut().push(line.to_string())
});
assert_eq!(
*lines.borrow(),
[format!(
"Title panorama not imported: {error}; run horizon-prepare panorama later"
)]
);
for name in PANORAMA {
assert_eq!(fs::read(target.join(name)).unwrap(), b"jar placeholder");
}
}
}
#[test]
fn the_index_must_be_the_pinned_one() {
let f = Fixture::new("index");
+3
View File
@@ -10,6 +10,9 @@ description = "Horizon's Minecraft Java Edition 26.3 network protocol (version 7
horizon-world = { path = "../horizon-world" }
flate2 = { version = "1.1.10", default-features = false, features = ["rust_backend"] }
serde_json = "1.0.151"
# The shared secret and RSA padding (OS randomness) and the server hash.
getrandom = "0.3"
sha1 = "0.10"
[lints]
workspace = true
+79 -2
View File
@@ -1,7 +1,9 @@
//! Connection encryption (Crypt.getCipher: AES/CFB8/NoPadding with the shared
//! secret as key and IV) and MD5 name-based UUIDs for offline-mode profiles
//! (UUIDUtil.createOfflinePlayerUUID). Only the AES forward cipher is needed:
//! CFB8 encrypts the shift register in both directions.
//! (UUIDUtil.createOfflinePlayerUUID), the online-mode server hash
//! (Crypt.digestData) and the shared secret. Only the AES forward cipher is
//! needed: CFB8 encrypts the shift register in both directions.
use sha1::{Digest, Sha1};
const SBOX: [u8; 256] = {
// Generated from the AES field inverse and affine transform at compile time.
@@ -138,6 +140,61 @@ impl Cfb8 {
}
}
/// Fill `out` with the operating system's cryptographic randomness.
pub fn random_bytes(out: &mut [u8]) -> crate::Result<()> {
getrandom::fill(out).map_err(|e| crate::Error::new(format!("No secure random source: {e}")))
}
/// Crypt.generateSecretKey: a random AES-128 key, the connection's shared secret.
pub fn generate_secret() -> crate::Result<[u8; 16]> {
let mut key = [0u8; 16];
random_bytes(&mut key)?;
Ok(key)
}
/// `new BigInteger(digest).toString(16)`: the digest read as a signed
/// two's-complement number, in lowercase hex without leading zeros.
pub fn java_hex_digest(digest: &[u8]) -> String {
let negative = digest.first().is_some_and(|b| b & 0x80 != 0);
let mut magnitude = digest.to_vec();
if negative {
// Two's complement: invert and add one.
let mut carry = true;
for b in magnitude.iter_mut().rev() {
*b = !*b;
if carry {
let (v, c) = b.overflowing_add(1);
*b = v;
carry = c;
}
}
}
let hex: String = magnitude.iter().map(|b| format!("{b:02x}")).collect();
let hex = hex.trim_start_matches('0');
let hex = if hex.is_empty() { "0" } else { hex };
if negative {
format!("-{hex}")
} else {
hex.to_owned()
}
}
/// The server id sent to the session service when joining an online-mode
/// server: SHA-1 over the server id (ISO-8859-1), the shared secret and the
/// server's encoded public key, as a signed hex number.
pub fn server_hash(server_id: &str, secret: &[u8], public_key: &[u8]) -> String {
let mut sha = Sha1::new();
// ISO-8859-1: characters above U+00FF become '?' like String.getBytes.
let latin1: Vec<u8> = server_id
.chars()
.map(|c| u8::try_from(u32::from(c)).unwrap_or(b'?'))
.collect();
sha.update(&latin1);
sha.update(secret);
sha.update(public_key);
java_hex_digest(&sha.finalize())
}
/// MD5 (RFC 1321).
pub fn md5(input: &[u8]) -> [u8; 16] {
const S: [u32; 64] = [
@@ -256,6 +313,26 @@ mod tests {
assert_eq!(data, plain);
}
/// The digests of single names published with the protocol docs.
#[test]
fn server_hash_vectors() {
let hash = |name: &str| java_hex_digest(&Sha1::digest(name.as_bytes()));
assert_eq!(hash("Notch"), "4ed1f46bbe04bc756bcb17c0c7ce3e4632f06a48");
assert_eq!(hash("jeb_"), "-7c9d5b0044c130109a5d7b5fb5c317c02b4e28c1");
assert_eq!(hash("simon"), "88e16a1019277b15d58faf0541e11910eb756f6");
// The three inputs are hashed in order: one update equals three.
assert_eq!(server_hash("", b"Not", b"ch"), hash("Notch"));
assert_eq!(java_hex_digest(&[0; 4]), "0");
assert_eq!(java_hex_digest(&[0xff; 2]), "-1");
assert_eq!(java_hex_digest(&[0x80, 0]), "-8000");
}
#[test]
fn secrets_are_random() {
let (a, b) = (generate_secret().unwrap(), generate_secret().unwrap());
assert_ne!(a, b);
}
#[test]
fn md5_and_offline_uuids() {
assert_eq!(md5(b"").to_vec(), hex("d41d8cd98f00b204e9800998ecf8427e"));
+1
View File
@@ -12,6 +12,7 @@ pub mod ids;
pub mod item;
pub mod packets;
pub mod registry;
pub mod rsa;
pub mod servers;
pub mod text;
+330
View File
@@ -0,0 +1,330 @@
//! RSA for the online-mode login: the server's X.509 public key
//! (Crypt.byteToPublicKey) and PKCS#1 v1.5 encryption of the shared secret
//! and challenge (Crypt.encryptUsingKey, Java's "RSA" cipher =
//! RSA/ECB/PKCS1Padding). Modular exponentiation uses Montgomery
//! multiplication on 32-bit limbs; RSA moduli are always odd.
use crate::{Error, Result};
/// A non-negative integer, little-endian 32-bit limbs.
#[derive(Clone, Debug, PartialEq, Eq)]
struct Big(Vec<u32>);
impl Big {
fn from_be_bytes(bytes: &[u8], limbs: usize) -> Self {
let mut v = vec![0u32; limbs];
for (i, b) in bytes.iter().rev().enumerate() {
if *b != 0 {
v[i / 4] |= u32::from(*b) << (8 * (i % 4));
}
}
Self(v)
}
fn to_be_bytes(&self, len: usize) -> Vec<u8> {
let mut out = vec![0u8; len];
for i in 0..len.min(self.0.len() * 4) {
out[len - 1 - i] = (self.0[i / 4] >> (8 * (i % 4))) as u8;
}
out
}
fn bits(&self) -> usize {
self.0
.iter()
.rposition(|&l| l != 0)
.map_or(0, |i| i * 32 + 32 - self.0[i].leading_zeros() as usize)
}
fn bit(&self, i: usize) -> bool {
self.0[i / 32] >> (i % 32) & 1 == 1
}
fn ge(&self, other: &Self) -> bool {
for (a, b) in self.0.iter().rev().zip(other.0.iter().rev()) {
if a != b {
return a > b;
}
}
true
}
fn sub_assign(&mut self, other: &Self) {
let mut borrow = 0i64;
for (a, b) in self.0.iter_mut().zip(&other.0) {
let d = i64::from(*a) - i64::from(*b) - borrow;
borrow = i64::from(d < 0);
*a = d.rem_euclid(1 << 32) as u32;
}
}
}
/// Montgomery arithmetic modulo an odd `n`.
struct Mont {
n: Big,
/// -n⁻¹ mod 2³².
n0: u32,
/// R² mod n, R = 2^(32·limbs).
r2: Big,
}
impl Mont {
fn new(n: Big) -> Self {
let k = n.0.len();
// Newton's iteration for n⁻¹ mod 2³².
let mut inv = 1u32;
for _ in 0..5 {
inv = inv.wrapping_mul(2u32.wrapping_sub(n.0[0].wrapping_mul(inv)));
}
// R² mod n by doubling 1 2·32·k times.
let mut r2 = Big(vec![0; k]);
r2.0[0] = 1;
for _ in 0..64 * k {
let carry = r2.0[k - 1] >> 31;
for i in (1..k).rev() {
r2.0[i] = r2.0[i] << 1 | r2.0[i - 1] >> 31;
}
r2.0[0] <<= 1;
if carry == 1 || r2.ge(&n) {
r2.sub_assign(&n);
}
}
Self {
n0: inv.wrapping_neg(),
n,
r2,
}
}
/// a·b·R⁻¹ mod n (CIOS).
fn mul(&self, a: &Big, b: &Big) -> Big {
let k = self.n.0.len();
let mut t = vec![0u32; k + 2];
for i in 0..k {
let mut carry = 0u64;
for j in 0..k {
let s = u64::from(t[j]) + u64::from(a.0[j]) * u64::from(b.0[i]) + carry;
t[j] = s as u32;
carry = s >> 32;
}
let s = u64::from(t[k]) + carry;
t[k] = s as u32;
t[k + 1] = (s >> 32) as u32;
let m = t[0].wrapping_mul(self.n0);
let mut carry = (u64::from(t[0]) + u64::from(m) * u64::from(self.n.0[0])) >> 32;
for j in 1..k {
let s = u64::from(t[j]) + u64::from(m) * u64::from(self.n.0[j]) + carry;
t[j - 1] = s as u32;
carry = s >> 32;
}
let s = u64::from(t[k]) + carry;
t[k - 1] = s as u32;
t[k] = t[k + 1] + (s >> 32) as u32;
}
let overflow = t[k] != 0;
let mut r = Big(t[..k].to_vec());
if overflow || r.ge(&self.n) {
r.sub_assign(&self.n);
}
r
}
/// base^exp mod n, base < n.
fn pow(&self, base: &Big, exp: &Big) -> Big {
let k = self.n.0.len();
let mut one = Big(vec![0; k]);
one.0[0] = 1;
let b = self.mul(base, &self.r2);
let mut x = self.mul(&one, &self.r2);
for i in (0..exp.bits()).rev() {
x = self.mul(&x, &x);
if exp.bit(i) {
x = self.mul(&x, &b);
}
}
self.mul(&x, &one)
}
}
/// A minimal DER reader: (tag, contents) of the element at the front.
fn der(input: &[u8]) -> Result<(u8, &[u8], &[u8])> {
let bad = || Error::new("Malformed public key");
let (&tag, rest) = input.split_first().ok_or_else(bad)?;
let (&first, mut rest) = rest.split_first().ok_or_else(bad)?;
let len = if first < 0x80 {
usize::from(first)
} else {
let n = usize::from(first & 0x7f);
if n == 0 || n > 4 || rest.len() < n {
return Err(bad());
}
let len = rest[..n]
.iter()
.fold(0usize, |l, b| l << 8 | usize::from(*b));
rest = &rest[n..];
len
};
if rest.len() < len {
return Err(bad());
}
Ok((tag, &rest[..len], &rest[len..]))
}
/// The DER of OID 1.2.840.113549.1.1.1 (rsaEncryption).
const RSA_ENCRYPTION: &[u8] = &[0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01];
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct RsaPublicKey {
/// Modulus and exponent, big-endian without leading zeros.
pub modulus: Vec<u8>,
pub exponent: Vec<u8>,
}
fn strip(int: &[u8]) -> Vec<u8> {
let start = int.iter().position(|&b| b != 0).unwrap_or(int.len());
int[start..].to_vec()
}
impl RsaPublicKey {
/// X509EncodedKeySpec: SubjectPublicKeyInfo { AlgorithmIdentifier, BIT STRING RSAPublicKey }.
pub fn from_der(spki: &[u8]) -> Result<Self> {
let bad = || Error::new("Malformed public key");
let (tag, body, _) = der(spki)?;
if tag != 0x30 {
return Err(bad());
}
let (tag, algorithm, rest) = der(body)?;
let (oid_tag, oid, _) = der(algorithm)?;
if tag != 0x30 || oid_tag != 0x06 || oid != RSA_ENCRYPTION {
return Err(Error::new("Not an RSA public key"));
}
let (tag, bits, _) = der(rest)?;
if tag != 0x03 || bits.first() != Some(&0) {
return Err(bad());
}
let (tag, key, _) = der(&bits[1..])?;
if tag != 0x30 {
return Err(bad());
}
let (n_tag, n, rest) = der(key)?;
let (e_tag, e, _) = der(rest)?;
if n_tag != 0x02 || e_tag != 0x02 {
return Err(bad());
}
let key = Self {
modulus: strip(n),
exponent: strip(e),
};
if key.modulus.len() < 64 || key.modulus.last().is_none_or(|b| b & 1 == 0) {
return Err(bad());
}
Ok(key)
}
/// Length of the modulus in bytes (and of every ciphertext).
pub fn size(&self) -> usize {
self.modulus.len()
}
/// The raw RSA operation m^e mod n on a `size()`-byte block.
fn apply(&self, block: &[u8], exponent: &[u8]) -> Vec<u8> {
let limbs = self.size().div_ceil(4);
let mont = Mont::new(Big::from_be_bytes(&self.modulus, limbs));
let m = Big::from_be_bytes(block, limbs);
mont.pow(
&m,
&Big::from_be_bytes(exponent, limbs.max(exponent.len().div_ceil(4))),
)
.to_be_bytes(self.size())
}
/// RSAES-PKCS1-v1_5 (RFC 8017 7.2.1) with random non-zero padding.
pub fn encrypt(&self, message: &[u8]) -> Result<Vec<u8>> {
let k = self.size();
if message.len() + 11 > k {
return Err(Error::new("Message too long for the RSA key"));
}
let mut block = vec![0u8; k];
block[1] = 2;
let padding = &mut block[2..k - message.len() - 1];
crate::crypto::random_bytes(padding)?;
for b in padding.iter_mut() {
while *b == 0 {
let mut one = [0u8];
crate::crypto::random_bytes(&mut one)?;
*b = one[0];
}
}
block[k - message.len()..].copy_from_slice(message);
Ok(self.apply(&block, &self.exponent))
}
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
pub fn hex(s: &str) -> Vec<u8> {
let s = if s.len() % 2 == 1 {
format!("0{s}")
} else {
s.to_owned()
};
(0..s.len())
.step_by(2)
.map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
.collect()
}
/// A 1024-bit test key made with `openssl genrsa 1024`.
pub const TEST_SPKI: &str = "30819f300d06092a864886f70d010101050003818d0030818902818100ab026074f92450a8f726f3895bb11176ca8f065f3100cd4143bac4f7d3674edcff95b41a0525d2365a549c106ec6685881b392177420fd31ff5c144ff11ba24311e751cd2c6b5d1817b6af6686a43c95d61243613005e6945b6093cd95223cec5e8856826da9d2ee1b323362ac1cebeab3659cbc45319a9b540dda816a4798ff0203010001";
pub const TEST_N: &str = "ab026074f92450a8f726f3895bb11176ca8f065f3100cd4143bac4f7d3674edcff95b41a0525d2365a549c106ec6685881b392177420fd31ff5c144ff11ba24311e751cd2c6b5d1817b6af6686a43c95d61243613005e6945b6093cd95223cec5e8856826da9d2ee1b323362ac1cebeab3659cbc45319a9b540dda816a4798ff";
pub const TEST_D: &str = "172bcb460e3c0d71d78b3f946d082105a78c99a06c535f7c6860f62f5e45b139e0a7b82f8e630188bbd49b10def1a351dac12a1a6371d4dce16ce893ac67c2247b9ee13e3a840abaf9ea685304558f1a93c4f354193f5713c3e53bd10dd275300db36e764fc081549afbd30cd00c31e6eb726720337a963913d96b50e4d8fd1";
/// SHA256withRSA signature of "hello" with the test key (openssl pkeyutl), for chat signing.
pub const TEST_SIG_HELLO: &str = "0bc8716622e44f9bf72432045e91bf1b40a96aae3c402fa86262b83758db1c90d2ed16b9fa86f29af175f2e6eedb864bf8da2667a7ada2bf5433fba36c1951af0c356e45bd5f90fb905b9a08f33a0666c4968ccffbf32fda643d736deec66f82c75fe4a8075c7f2b8a6c0ca630e0ffe4805a1f1d672506b82fc188510fb4ef80";
#[test]
fn montgomery_matches_small_numbers() {
// 4^13 mod 497 = 445 (the classic example), on one limb.
let mont = Mont::new(Big(vec![497]));
assert_eq!(mont.pow(&Big(vec![4]), &Big(vec![13])), Big(vec![445]));
// Two limbs: (2^40 + 5)^3 mod (2^61 - 1).
let n = (1u128 << 61) - 1;
let m = Mont::new(Big(vec![n as u32, (n >> 32) as u32]));
let b = (1u128 << 40) + 5;
let expected = b * b % n * b % n;
let r = m.pow(&Big(vec![b as u32, (b >> 32) as u32]), &Big(vec![3, 0]));
assert_eq!(u128::from(r.0[0]) | u128::from(r.0[1]) << 32, expected);
}
#[test]
fn parses_x509_public_keys() {
let key = RsaPublicKey::from_der(&hex(TEST_SPKI)).unwrap();
assert_eq!(key.modulus, hex(TEST_N));
assert_eq!(key.exponent, vec![1, 0, 1]);
assert_eq!(key.size(), 128);
assert!(RsaPublicKey::from_der(&hex(TEST_SPKI)[..100]).is_err());
assert!(RsaPublicKey::from_der(b"not a key").is_err());
}
/// Encrypted with the public key, decrypted with the private exponent:
/// a PKCS#1 v1.5 type 2 block with non-zero padding around the message.
#[test]
fn pkcs1_round_trip() {
let key = RsaPublicKey::from_der(&hex(TEST_SPKI)).unwrap();
let secret = [0x5au8; 16];
let a = key.encrypt(&secret).unwrap();
let b = key.encrypt(&secret).unwrap();
assert_eq!(a.len(), 128);
assert_ne!(a, b, "padding is random");
for c in [a, b] {
let block = key.apply(&c, &hex(TEST_D));
assert_eq!(&block[..2], &[0, 2]);
let zero = 2 + block[2..].iter().position(|&b| b == 0).unwrap();
assert_eq!(zero, 128 - 16 - 1);
assert_eq!(&block[zero + 1..], &secret);
}
assert!(key.encrypt(&[0; 118]).is_err());
}
/// An OpenSSL signature checked with the public exponent: the block ends
/// with SHA-256("hello"), so the modular arithmetic agrees with OpenSSL's.
#[test]
fn verifies_an_openssl_signature() {
let key = RsaPublicKey::from_der(&hex(TEST_SPKI)).unwrap();
let block = key.apply(&hex(TEST_SIG_HELLO), &key.exponent);
assert_eq!(&block[..2], &[0, 1]);
assert!(block.ends_with(&hex(
"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
)));
}
}
+187
View File
@@ -0,0 +1,187 @@
# Microsoft account sign-in and online-mode play
Horizon signs players in with their Microsoft account in the launcher and joins online-mode
(authenticated) servers like vanilla 26.3 does. Offline profiles and offline/LAN play stay exactly as
they are. This note is the design, the status of each part and what Ludovic has to register.
## What Ludovic registers (needs his accounts)
Nothing below can be done by an agent: the app registrations belong to Ludovic. Until the client ID
is set, the launcher's sign-in shows "Microsoft sign-in is not configured yet" and everything else
works as before.
1. **Azure app registration** (https://portal.azure.com → Microsoft Entra ID → App registrations →
New registration):
- Name: `Horizon` (shown to players on the Microsoft consent page).
- Supported account types: **Personal Microsoft accounts only** (Minecraft accounts are
consumer accounts; the launcher uses the `consumers` tenant).
- Redirect URI: none needed for the device-code flow. If the form insists, add a
"Mobile and desktop applications" redirect `https://login.microsoftonline.com/common/oauth2/nativeclient`.
- After creating it: Authentication → Advanced settings → **Allow public client flows: Yes**
(this enables the device-code flow; there is no client secret, Horizon is a public client).
- API permissions: none to add. The launcher requests the scopes `XboxLive.signin offline_access`
at sign-in time; `offline_access` gives the refresh token.
- Copy the **Application (client) ID** (a GUID).
2. **Minecraft API access** (Mojang): new Azure apps are refused by
`api.minecraftservices.com/authentication/login_with_xbox` (HTTP 403, "Invalid app registration")
until Mojang approves them. Apply with the form linked from https://aka.ms/mce-reviewappid
(Minecraft Java "App ID review"), giving the client ID above, the app name, the project URL
(https://github.com/ludovic111/horizon) and a short description ("open-source Minecraft Java
Edition client written in Rust; signs players in to join online-mode servers"). Approval takes
days to weeks; sign-in fails at the Minecraft step with "This app is not approved by Mojang yet"
until then.
3. **Where the ID goes**:
- Release builds: the GitHub repository variable (not a secret: client IDs are public)
`HORIZON_MSA_CLIENT_ID`; the launcher's build reads it with `option_env!` at compile time.
- Any build, at run time: the environment variable `HORIZON_MSA_CLIENT_ID` overrides the built-in
value (empty or unset = not configured).
Never use another application's client ID (the official launcher's or another launcher's).
## Flow (launcher)
All requests use HTTPS and JSON except the two OAuth calls (form-encoded):
1. **Device code**: `POST https://login.microsoftonline.com/consumers/oauth2/v2.0/devicecode`
(`client_id`, `scope=XboxLive.signin offline_access`). The launcher shows the `user_code` and
`verification_uri` (https://www.microsoft.com/link) with a copy button and opens the browser.
2. **Poll** `POST …/consumers/oauth2/v2.0/token` (`grant_type=urn:ietf:params:oauth:grant-type:device_code`)
every `interval` seconds; `authorization_pending` waits, `slow_down` adds 5 s, `authorization_declined`,
`expired_token` and `bad_verification_code` end the sign-in with a message. Result: the Microsoft
access token and refresh token.
3. **Xbox Live**: `POST https://user.auth.xboxlive.com/user/authenticate` with
`AuthMethod=RPS, SiteName=user.auth.xboxlive.com, RpsTicket=d=<MS access token>`,
`RelyingParty=http://auth.xboxlive.com`. Result: the XBL token and the user hash (`uhs`).
4. **XSTS**: `POST https://xsts.auth.xboxlive.com/xsts/authorize` with the XBL token,
`SandboxId=RETAIL`, `RelyingParty=rp://api.minecraftservices.com/`. The `XErr` codes become
messages: 2148916233 no Xbox profile yet, 2148916235 Xbox Live not available in the country,
2148916236/2148916237 adult verification (South Korea), 2148916238 child account (needs a family).
5. **Minecraft**: `POST https://api.minecraftservices.com/authentication/login_with_xbox`
(`identityToken = "XBL3.0 x=<uhs>;<XSTS token>"`). Result: the Minecraft access token (24 h).
6. **Entitlements**: `GET https://api.minecraftservices.com/entitlements/mcstore`: the account must
own `game_minecraft` or `product_minecraft` (Game Pass included), else "This account doesn't own
Minecraft Java Edition".
7. **Profile**: `GET https://api.minecraftservices.com/minecraft/profile`: UUID, name, skins, capes.
404 = owns the game but has no profile yet ("Create your Minecraft profile on minecraft.net first").
Refresh: the Minecraft token is renewed from the Microsoft refresh token (steps 2-5 with
`grant_type=refresh_token`) when it has less than an hour left, before every launch. A refused
refresh token (`invalid_grant`) asks the player to sign in again. Several accounts can be signed in;
one is selected. "Sign out" deletes the account's secrets from the keychain.
## Token storage
- Secrets (the Microsoft refresh token, the Minecraft access token and its expiry) go to the OS
keychain, one item per account: Keychain on macOS, Credential Manager on Windows, the Secret
Service (GNOME Keyring, KWallet) on Linux. Service name `dev.playhorizon.launcher`, account = the
Minecraft UUID.
- `accounts.json` in the launcher's data folder keeps only public data: UUID, name, skin URL, which
account is selected. Never a token.
- No keychain available (a Linux box without a Secret Service, a locked keychain): sign-in still
works for the session but nothing is saved, and the launcher says "No keychain available: you will
have to sign in again next time" (it never falls back to a plain file).
- Tokens never appear in logs, errors, `horizon-launcher` CLI output, MCP results or crash reports.
Requests are logged by endpoint name only.
## Handing the session to the game
Vanilla's launcher passes `--accessToken <token>` on the command line, where every user of the
machine can read it in the process list. Horizon keeps it out of argv:
- The launcher writes `session-<random>.json` (mode 0600 on Unix, created new, in the game home's
`sessions/` folder) with `{"name", "uuid", "access_token", "user_type": "msa", "xuid"}` and starts
the game with `--session-file PATH`.
- The game reads the file at start and deletes it at once; the token lives only in the game's memory.
A file older than two minutes is refused (and deleted), so a stale file can't be replayed.
- Without a session file the game is offline as today (`--name`, offline UUID).
- `HORIZON_SESSION_FILE` is the same as `--session-file` (development and harnesses).
## Online-mode login (game)
Vanilla's `ClientHandshakePacketListenerImpl.handleHello`, `Crypt` and authlib's
`MinecraftServicesSessionService.joinServer`:
1. `ClientboundHelloPacket` (server id, X.509 RSA public key, challenge, should_authenticate).
2. Generate a random 16-byte AES key (the shared secret).
3. Server hash: SHA-1 over `serverId` (ISO-8859-1), the shared secret, the encoded public key;
`new BigInteger(digest).toString(16)` (signed two's complement hex, e.g. "Notch" →
`4ed1f46bbe04bc756bcb17c0c7ce3e4632f06a48`, "jeb_" → `-7c9d5b0044c130109a5d7b5fb5c317c02b4e28c1`).
4. If `should_authenticate`: `POST` the session service's `join` endpoint
`{"accessToken", "selectedProfile" (undashed UUID), "serverId": hash}`, the URL taken from the
services discovery document (`https://discovery.minecraftservices.com/minecraft/client`, fetched
once per game). Errors map like authlib's `MinecraftClientHttpException`:
`ForbiddenOperationException` or 401 → "Failed to log in: Invalid session (Try restarting your
game and the launcher)", `InsufficientPrivilegesException` → "Multiplayer is disabled…",
`multiplayer.access.banned` / `FORCED_USERNAME_CHANGE` → "You are banned from playing online",
5xx or no network → "The authentication servers are currently not reachable…". Without a session
the game says "This server is in online mode. Sign in with your Microsoft account in the Horizon
launcher to join it." (Vanilla goes on after a failed join on LAN-discovered servers, which then
refuse the player anyway; Horizon stops at once.)
5. Send `ServerboundKeyPacket` (the secret and the challenge, each RSA PKCS#1 v1.5 encrypted with
the server key), then AES/CFB8 (key = IV = the secret) both ways.
The connecting screen follows vanilla's states: "Connecting to the server..." until the encryption
request, "Logging in..." while joining the session service, "Encrypting...", then "Joining world...".
Code: `horizon-protocol` (`rsa.rs`, `crypto::server_hash`), `horizon-client` (`auth.rs`, `net.rs`).
Horizon's own dedicated and LAN servers stay offline-mode (they don't verify players with the
session service); that is separate work.
`HORIZON_API_DISCOVERY` overrides the discovery URL, the counterpart of authlib's
`-Dminecraft.api.discovery.host`; it is how the harness points both the vanilla server and Horizon at
a local mock.
## Skins and capes (part b)
Profile properties (`textures`, base64 JSON) arrive in `ClientboundPlayerInfoUpdatePacket` for every
player and in the login profile for ourselves. Like authlib's `unpackTextures`, only URLs under the
discovery document's `profiles/getTexture` `validUris` (textures.minecraft.net) are fetched; skins
(classic/slim from the `metadata.model`), capes and elytra textures are downloaded over HTTPS on a
worker thread, cached on disk by texture hash (`assets/skins/xx/hash`, like vanilla's
`SkinManager`), converted from legacy 64×32 the way `SkinTextureDownloader` does and given to the
player renderer. Until a skin arrives the default skin for the UUID shows (as today).
## Chat signing (part d)
26.3's dedicated servers default to `enforce-secure-profile=true`. A client without a chat session
can join and play, but every chat message and signed command argument is refused with "Chat
disabled due to missing profile public key. Please try reconnecting." (`SignedMessageChain.Decoder.unsigned`).
To chat on such servers the game will:
- fetch the profile key pair from the services `player/getCertificates` endpoint (Minecraft token);
- send `ServerboundChatSessionUpdatePacket` (random session UUID, key expiry, public key, Mojang's
key signature) after joining;
- sign each chat message and signable command argument with SHA256withRSA over vanilla's
`SignedMessageBody` layout and keep the last-seen message tracker and acknowledgements.
Until part d lands, Horizon joins online servers but chat works only where
`enforce-secure-profile=false` (or the server can't validate keys).
## Harnesses
`tools/test_online_mode_parity.py` (dev only, needs no account): a local mock of the Minecraft
services (discovery document, `join`, `hasJoined`/`verify`, no public keys) and a vanilla 26.3
dedicated server in online mode started with `-Dminecraft.api.discovery.host=<mock>` (authlib
10.0.77's only override: it replaces the whole discovery URL; the old `minecraft.api.session.host`
style properties are gone). Horizon's
headless client (`HORIZON_NET_REPORT`) joins with a session file holding a mock token: the server
verifies the join through the mock with the hash it computed itself (so the RSA wrapping, the hash
and AES/CFB8 are all checked against vanilla's code), the player spawns, chats and runs `/list`.
Negative cases: a token the mock rejects (the client must show vanilla's "Invalid session" message)
and a client that skips the join (the server must say "Failed to verify username!").
Rust unit tests: server hash vectors (Notch, jeb_, simon), RSA wrapping round trip with a test key,
X.509 key parsing, AES/CFB8 vectors (already in `horizon-protocol`), the session file (permissions,
age, deletion), the error mapping. Launcher: the whole token chain against a local mock of the
Microsoft, Xbox and Minecraft endpoints, and the keychain abstraction with an in-memory backend.
## PR plan
- (a) Game: online-mode handshake, encryption, session join, session file, harness (15/15 checks
against vanilla 26.3 on macOS).
- (c) Launcher: device-code sign-in, token chain, keychain, accounts UI, CLI/MCP (`account list`,
`account sign-in`, `account sign-out`, never tokens), session file handoff.
- (b) Game: skins and capes over HTTPS, the real names and skins in game.
- (d) Game: chat signing (profile keys, chat session, signed messages and commands).
Each part ships on its own: online mode needs a session, which only (c) creates.
+7 -1
View File
@@ -23,7 +23,13 @@ verifies it against the pinned checksums, runs vanilla's data generator and smal
exporters against those jars, and extracts the jar's assets and data into ignored
`.local/horizon-client/26.3/`. Sounds (about 380 MB) are copied from your
launcher's asset store by `horizon-prepare sounds`, each file checked against the asset
index's SHA-1. Prepared resources are private; never commit them.
index's SHA-1. Preparation also tries to replace the JAR's gray 1×1 title panorama
placeholders with the full textures from that asset store. If the store is missing or
incomplete, preparation logs a warning and keeps the placeholders. To import the panorama
later without rerunning the Java exporters, run `horizon-prepare panorama` (or
`cargo run --release -p horizon-prepare -- panorama` in a checkout). Pass
`--minecraft-dir PATH` when using a different Minecraft installation.
Prepared resources are private; never commit them.
Preparation is `horizon-prepare` (`crates/horizon-prepare`, Rust): it needs no Python, only
the JDK, for the small exporters that call Mojang's own code. Release folders ship it beside
+41 -1
View File
@@ -2570,10 +2570,14 @@ dependencies = [
"clap",
"dirs 5.0.1",
"flate2",
"futures-lite 2.6.1",
"getrandom 0.3.4",
"gpui",
"horizon-prepare",
"horizon-theme",
"image",
"keyring",
"oo7",
"pulldown-cmark",
"self-replace",
"serde",
@@ -2992,6 +2996,20 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "keyring"
version = "3.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eebcc3aff044e5944a8fbaf69eb277d11986064cba30c468730e8b9909fb551c"
dependencies = [
"byteorder",
"log",
"security-framework 2.11.1",
"security-framework 3.7.0",
"windows-sys 0.60.2",
"zeroize",
]
[[package]]
name = "khronos-egl"
version = "6.0.0"
@@ -4645,7 +4663,7 @@ dependencies = [
"openssl-probe",
"rustls-pki-types",
"schannel",
"security-framework",
"security-framework 3.7.0",
]
[[package]]
@@ -4810,6 +4828,19 @@ version = "4.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
[[package]]
name = "security-framework"
version = "2.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
dependencies = [
"bitflags 2.13.2",
"core-foundation 0.9.4",
"core-foundation-sys",
"libc",
"security-framework-sys",
]
[[package]]
name = "security-framework"
version = "3.7.0"
@@ -6665,6 +6696,15 @@ dependencies = [
"windows-targets 0.52.6",
]
[[package]]
name = "windows-sys"
version = "0.60.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
dependencies = [
"windows-targets 0.53.5",
]
[[package]]
name = "windows-sys"
version = "0.61.2"
+12
View File
@@ -22,6 +22,18 @@ image = { version = "0.25", default-features = false, features = ["jpeg"] }
clap = { version = "4", features = ["derive"] }
horizon-theme = { path = "../crates/horizon-theme" }
horizon-prepare = { path = "../crates/horizon-prepare" }
# The session file's random name.
getrandom = "0.3"
# Microsoft account secrets in the OS keychain: the Secret Service on Linux through oo7 (the same
# build gpui uses), Keychain and Credential Manager through keyring.
[target.'cfg(any(target_os = "linux", target_os = "freebsd"))'.dependencies]
oo7 = { version = "0.5", default-features = false, features = ["async-std", "native_crypto"] }
futures-lite = "2"
[target.'cfg(target_os = "macos")'.dependencies]
keyring = { version = "3", features = ["apple-native"] }
[target.'cfg(target_os = "windows")'.dependencies]
keyring = { version = "3", features = ["windows-native"] }
[profile.release]
strip = true
+28 -4
View File
@@ -21,7 +21,10 @@ The opening, then Play ([clip](docs/opening.webm)):
server (`--dedicated --nogui`) in a folder you choose, with a live console. Preparing is
horizon-prepare: linked into the launcher, used in-process when a version ships the same
preparer sources, else that version's own `horizon-prepare`; versions released before it
still prepare with their Python script and need Python 3.10+.
still prepare with their Python script and need Python 3.10+. Before importing,
preparation reuses checksum-verified game jars and libraries from the current
or another installed Horizon version, so the original Minecraft install is
only required when no valid imported copy exists.
- **Patch notes**: each release's notes, newest first, with a link to GitHub Sponsors. Quiet "Join Discord" and "Website" links sit in the sidebar footer.
Data lives in the platform's data directory (`~/.local/share/horizon-launcher` on Linux,
@@ -70,9 +73,14 @@ The same binary is a command-line tool; without a subcommand it opens the window
horizon-launcher menu-style [horizon|classic] show or set the game's menu style
horizon-launcher update [--check] Horizon and the launcher
horizon-launcher logs [--lines N] [--crash] the end of the game's log, or its newest crash report
horizon-launcher account [list] the Microsoft accounts signed in (* = plays)
horizon-launcher account sign-in sign in in your browser with a code
horizon-launcher account sign-out <name>
horizon-launcher account select <name> play as this account
horizon-launcher account offline play without an account
`--json` prints JSON where there is something to report (`versions`, `install`, `notes`,
`next`, `links`, `menu-style`, `update --check`, `logs`). Errors go to stderr with exit code 1. `server` runs in the terminal,
`next`, `links`, `menu-style`, `update --check`, `logs`, `account`). Errors go to stderr with exit code 1. `server` runs in the terminal,
so lines you type reach its console. `HORIZON_LAUNCHER_HOME` replaces the data folder (for
scripts and tests).
@@ -84,13 +92,29 @@ scripts and tests).
(with the full path to the binary if it is not on your `PATH`). Its tools: `list_versions`,
`install_version`, `remove_version`, `prepare_resources`, `launch_client`, `start_server`,
`server_command`, `server_log`, `stop_server`, `patch_notes`, `links`, `menu_style`, `logs` and
`check_updates`.
`server_command`, `server_log`, `stop_server`, `patch_notes`, `links`, `menu_style`, `logs`,
`check_updates`, `accounts`, `sign_in` (returns the link and code for the player; the sign-in
finishes in the background), `sign_out` and `select_account`.
A server started through MCP stops (cleanly, with `stop`) when the session ends. Starting one
needs `accept_eula`, which an agent should only pass with the player's consent.
The window, the command line and the MCP server all call the same core, `src/backend.rs`.
## Microsoft accounts
Settings → Accounts signs in a Microsoft account to play on online-mode servers under your own
name and skin: the launcher shows a code, you enter it at microsoft.com/link, and the launcher
checks that the account owns Minecraft: Java Edition. The Play page says who plays ("Playing as");
without an account the game plays offline, as before. Tokens live in the system keychain (Keychain,
Credential Manager, or the Secret Service on Linux), never in a file, a log or the command line;
`accounts.json` in the data folder keeps only names and UUIDs. Without a keychain you stay signed
in until the launcher closes. When the game starts, it gets the session in a private file it
deletes as soon as it has read it. Sign out removes the tokens.
Sign-in needs Horizon's own Azure app registration: its client ID is built in from
`HORIZON_MSA_CLIENT_ID` (and `HORIZON_MSA_CLIENT_ID` at run time overrides it; empty = not
configured). How it works: [docs/microsoft-account.md](../docs/microsoft-account.md).
## Logs and crash reports
The game writes its log to `logs/latest.log` in the game folder (`HORIZON_HOME`, else
+815
View File
@@ -0,0 +1,815 @@
//! Microsoft account sign-in (docs/microsoft-account.md): the OAuth device-code flow, then Xbox
//! Live, XSTS and the Minecraft services, the game ownership check and the profile. Secrets (the
//! Microsoft refresh token, the Minecraft access token) live in the OS keychain; accounts.json
//! keeps only names and UUIDs. The game gets the session in a file it reads once
//! (`--session-file`), never on its command line. Tokens never reach logs, errors or output.
//!
//! The Azure app (client ID) is Horizon's own and is configuration: `HORIZON_MSA_CLIENT_ID` at
//! build time, or at run time to override it. Without one, sign-in says it is not configured.
use serde_json::{json, Value};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::{Mutex, OnceLock};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
/// The keychain service name every secret is stored under.
pub const SERVICE: &str = "dev.playhorizon.launcher";
const SCOPE: &str = "XboxLive.signin offline_access";
pub const NOT_CONFIGURED: &str =
"Microsoft sign-in is not configured yet in this build of the launcher (no client ID).";
const SIGN_IN_AGAIN: &str = "Your Microsoft sign-in expired. Sign in again.";
/// The Minecraft token is renewed when it has less than this left.
const RENEW_BEFORE: u64 = 3600;
/// The configured Azure app, if any: the run-time variable wins over the build-time one, and an
/// empty value means none.
pub fn client_id() -> Option<String> {
std::env::var("HORIZON_MSA_CLIENT_ID")
.ok()
.or_else(|| option_env!("HORIZON_MSA_CLIENT_ID").map(str::to_owned))
.map(|id| id.trim().to_owned())
.filter(|id| !id.is_empty())
}
/// Where the requests go: the real services, or a mock in tests.
#[derive(Clone, Debug)]
pub struct Endpoints {
/// The OAuth 2.0 v2 endpoints for personal accounts (`…/devicecode`, `…/token`).
pub microsoft: String,
pub xbox_user: String,
pub xsts: String,
/// api.minecraftservices.com.
pub minecraft: String,
}
impl Endpoints {
pub fn live() -> Self {
Self {
microsoft: "https://login.microsoftonline.com/consumers/oauth2/v2.0".into(),
xbox_user: "https://user.auth.xboxlive.com/user/authenticate".into(),
xsts: "https://xsts.auth.xboxlive.com/xsts/authorize".into(),
minecraft: "https://api.minecraftservices.com".into(),
}
}
}
fn agent() -> ureq::Agent {
ureq::AgentBuilder::new()
.timeout(Duration::from_secs(20))
.user_agent(concat!("horizon-launcher/", env!("CARGO_PKG_VERSION")))
.build()
}
/// One request's result: the status and the JSON body (empty when there is none). Transport
/// errors name the service, never the URL's query or the request.
fn send(request: ureq::Request, body: Option<Body>, service: &str) -> Result<(u16, Value), String> {
let result = match body {
None => request.call(),
Some(Body::Form(fields)) => request.send_form(&fields),
Some(Body::Json(value)) => request.set("Accept", "application/json").send_json(value),
};
let response = match result {
Ok(r) => r,
Err(ureq::Error::Status(_, r)) => r,
Err(ureq::Error::Transport(_)) => {
return Err(format!(
"Could not reach {service}. Check your internet connection."
))
}
};
let status = response.status();
let text = response.into_string().unwrap_or_default();
Ok((status, serde_json::from_str(&text).unwrap_or(Value::Null)))
}
enum Body<'a> {
Form(Vec<(&'a str, &'a str)>),
Json(Value),
}
fn str_field(v: &Value, key: &str) -> Option<String> {
v.get(key).and_then(Value::as_str).map(str::to_owned)
}
fn now() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_or(0, |d| d.as_secs())
}
// ----- The device-code flow ----------------------------------------------------------------------
/// What the player types at the verification page.
#[derive(Clone)]
pub struct DeviceCode {
pub user_code: String,
pub verification_uri: String,
pub interval: u64,
pub expires_at: u64,
device_code: String,
}
impl std::fmt::Debug for DeviceCode {
// The device code can be traded for tokens once the player approves: never shown.
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DeviceCode")
.field("user_code", &self.user_code)
.field("verification_uri", &self.verification_uri)
.finish_non_exhaustive()
}
}
/// The Microsoft tokens; the access token only lasts for the Xbox step.
pub struct MsTokens {
access: String,
refresh: String,
}
impl std::fmt::Debug for MsTokens {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("MsTokens(<hidden>)")
}
}
pub enum Poll {
Pending,
/// The server asked to poll less often: wait 5 s more.
SlowDown,
Done(MsTokens),
}
pub fn device_code(ep: &Endpoints, client_id: &str) -> Result<DeviceCode, String> {
let (status, v) = send(
agent().post(&format!("{}/devicecode", ep.microsoft)),
Some(Body::Form(vec![("client_id", client_id), ("scope", SCOPE)])),
"Microsoft",
)?;
match (
status,
str_field(&v, "user_code"),
str_field(&v, "device_code"),
) {
(200, Some(user_code), Some(device_code)) => Ok(DeviceCode {
user_code,
verification_uri: str_field(&v, "verification_uri")
.unwrap_or_else(|| "https://www.microsoft.com/link".into()),
interval: v
.get("interval")
.and_then(Value::as_u64)
.unwrap_or(5)
.max(1),
expires_at: now() + v.get("expires_in").and_then(Value::as_u64).unwrap_or(900),
device_code,
}),
_ => Err(oauth_error(&v)),
}
}
/// The OAuth error codes as messages for the player.
fn oauth_error(v: &Value) -> String {
match v.get("error").and_then(Value::as_str) {
Some("authorization_declined") => "Sign-in was declined in the browser.".into(),
Some("expired_token") => "The sign-in code expired. Start again.".into(),
Some("bad_verification_code") => "The sign-in code was not recognised. Start again.".into(),
Some("invalid_grant") => SIGN_IN_AGAIN.into(),
Some("invalid_client" | "unauthorized_client") => {
"Microsoft refused this launcher's app registration (client ID).".into()
}
Some(other) => format!("Microsoft sign-in failed ({other})."),
None => "Microsoft sign-in failed.".into(),
}
}
/// One poll of the token endpoint while the player signs in.
pub fn poll(ep: &Endpoints, client_id: &str, code: &DeviceCode) -> Result<Poll, String> {
let (status, v) = send(
agent().post(&format!("{}/token", ep.microsoft)),
Some(Body::Form(vec![
("grant_type", "urn:ietf:params:oauth:grant-type:device_code"),
("client_id", client_id),
("device_code", &code.device_code),
])),
"Microsoft",
)?;
match v.get("error").and_then(Value::as_str) {
Some("authorization_pending") => return Ok(Poll::Pending),
Some("slow_down") => return Ok(Poll::SlowDown),
_ => {}
}
ms_tokens(status, &v).map(Poll::Done)
}
fn ms_tokens(status: u16, v: &Value) -> Result<MsTokens, String> {
match (
status,
str_field(v, "access_token"),
str_field(v, "refresh_token"),
) {
(200, Some(access), Some(refresh)) => Ok(MsTokens { access, refresh }),
_ => Err(oauth_error(v)),
}
}
/// Wait for the player to finish in the browser, polling as asked, until the code expires or
/// `cancelled` says stop.
pub fn wait_for_sign_in(
ep: &Endpoints,
client_id: &str,
code: &DeviceCode,
cancelled: &dyn Fn() -> bool,
) -> Result<MsTokens, String> {
let mut interval = code.interval;
loop {
let until = std::time::Instant::now() + Duration::from_secs(interval);
while std::time::Instant::now() < until {
if cancelled() {
return Err("Sign-in cancelled.".into());
}
std::thread::sleep(Duration::from_millis(100));
}
if now() > code.expires_at {
return Err("The sign-in code expired. Start again.".into());
}
match poll(ep, client_id, code)? {
Poll::Pending => {}
Poll::SlowDown => interval += 5,
Poll::Done(tokens) => return Ok(tokens),
}
}
}
fn refresh_ms(ep: &Endpoints, client_id: &str, refresh: &str) -> Result<MsTokens, String> {
let (status, v) = send(
agent().post(&format!("{}/token", ep.microsoft)),
Some(Body::Form(vec![
("grant_type", "refresh_token"),
("client_id", client_id),
("refresh_token", refresh),
("scope", SCOPE),
])),
"Microsoft",
)?;
ms_tokens(status, &v)
}
// ----- Xbox Live, XSTS, Minecraft ----------------------------------------------------------------
/// The XSTS `XErr` codes, as the official launcher explains them.
fn xsts_error(code: u64) -> String {
match code {
2148916233 => "This Microsoft account has no Xbox profile yet. Sign in once at xbox.com to create one, then try again.".into(),
2148916235 => "Xbox Live is not available in your country or region.".into(),
2148916236 | 2148916237 => "This account needs adult verification on xbox.com before it can play.".into(),
2148916238 => "This is a child account: an adult has to add it to a Microsoft family first.".into(),
other => format!("Xbox Live refused the sign-in (error {other})."),
}
}
/// The Minecraft access token from the Microsoft one, through Xbox Live and XSTS.
struct Minecraft {
token: String,
expires_at: u64,
xuid: Option<String>,
}
fn minecraft_login(ep: &Endpoints, ms_access: &str) -> Result<Minecraft, String> {
let (status, xbl) = send(
agent().post(&ep.xbox_user),
Some(Body::Json(json!({
"Properties": {
"AuthMethod": "RPS",
"SiteName": "user.auth.xboxlive.com",
"RpsTicket": format!("d={ms_access}"),
},
"RelyingParty": "http://auth.xboxlive.com",
"TokenType": "JWT",
}))),
"Xbox Live",
)?;
let xbl_token = str_field(&xbl, "Token")
.filter(|_| status == 200)
.ok_or("Xbox Live refused the sign-in.")?;
let (status, xsts) = send(
agent().post(&ep.xsts),
Some(Body::Json(json!({
"Properties": { "SandboxId": "RETAIL", "UserTokens": [xbl_token] },
"RelyingParty": "rp://api.minecraftservices.com/",
"TokenType": "JWT",
}))),
"Xbox Live",
)?;
if let Some(code) = xsts.get("XErr").and_then(Value::as_u64) {
return Err(xsts_error(code));
}
let claims = xsts.pointer("/DisplayClaims/xui/0");
let (Some(xsts_token), Some(uhs)) = (
str_field(&xsts, "Token").filter(|_| status == 200),
claims.and_then(|c| str_field(c, "uhs")),
) else {
return Err("Xbox Live refused the sign-in.".into());
};
let xuid = claims.and_then(|c| str_field(c, "xid"));
let (status, mc) = send(
agent().post(&format!("{}/authentication/login_with_xbox", ep.minecraft)),
Some(Body::Json(
json!({ "identityToken": format!("XBL3.0 x={uhs};{xsts_token}") }),
)),
"the Minecraft services",
)?;
match (status, str_field(&mc, "access_token")) {
(200, Some(token)) => Ok(Minecraft {
token,
expires_at: now()
+ mc.get("expires_in")
.and_then(Value::as_u64)
.unwrap_or(86400),
xuid,
}),
// New Azure apps are refused until Mojang approves them (Minecraft API access).
(403, _) => Err(
"The Minecraft services refused this launcher: its app is not approved by Mojang yet."
.into(),
),
(429, _) => Err("Too many sign-ins in a short time. Wait a minute and try again.".into()),
_ => Err("The Minecraft services refused the sign-in.".into()),
}
}
fn bearer(request: ureq::Request, token: &str) -> ureq::Request {
request.set("Authorization", &format!("Bearer {token}"))
}
/// Whether the account owns Minecraft: Java Edition (Game Pass included).
fn owns_game(ep: &Endpoints, token: &str) -> Result<bool, String> {
let (status, v) = send(
bearer(
agent().get(&format!("{}/entitlements/mcstore", ep.minecraft)),
token,
),
None,
"the Minecraft services",
)?;
if status != 200 {
return Err("Could not check which games this account owns.".into());
}
Ok(v.get("items")
.and_then(Value::as_array)
.is_some_and(|items| {
items.iter().any(|i| {
matches!(
i.get("name").and_then(Value::as_str),
Some("game_minecraft" | "product_minecraft")
)
})
}))
}
/// A Minecraft profile, as the launcher shows and remembers it (no secrets).
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Account {
/// The profile UUID without dashes.
pub uuid: String,
pub name: String,
/// The active skin's URL (textures.minecraft.net) and model ("classic" or "slim").
#[serde(default)]
pub skin: Option<(String, String)>,
#[serde(default)]
pub cape: Option<String>,
}
fn profile(ep: &Endpoints, token: &str) -> Result<Account, String> {
let (status, v) = send(
bearer(
agent().get(&format!("{}/minecraft/profile", ep.minecraft)),
token,
),
None,
"the Minecraft services",
)?;
if status == 404 {
return Err("This account has no Minecraft profile yet. Create one at minecraft.net, then sign in again.".into());
}
let (Some(uuid), Some(name)) = (str_field(&v, "id"), str_field(&v, "name")) else {
return Err("Could not read the Minecraft profile.".into());
};
let active = |key: &str| {
v.get(key)
.and_then(Value::as_array)
.and_then(|list| {
list.iter()
.find(|s| s.get("state").and_then(Value::as_str) == Some("ACTIVE"))
})
.cloned()
};
Ok(Account {
uuid: uuid.replace('-', "").to_lowercase(),
name,
skin: active("skins").and_then(|s| {
Some((
str_field(&s, "url")?,
str_field(&s, "variant")
.unwrap_or_else(|| "CLASSIC".into())
.to_lowercase(),
))
}),
cape: active("capes").and_then(|c| str_field(&c, "url")),
})
}
/// What the keychain keeps for one account.
#[derive(Clone, serde::Serialize, serde::Deserialize)]
pub struct Secrets {
refresh_token: String,
minecraft_token: String,
minecraft_expires_at: u64,
#[serde(default)]
xuid: Option<String>,
}
impl std::fmt::Debug for Secrets {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("Secrets(<hidden>)")
}
}
/// From Microsoft tokens to a ready account: Xbox, XSTS, Minecraft, ownership, profile.
pub fn finish_sign_in(ep: &Endpoints, ms: MsTokens) -> Result<(Account, Secrets), String> {
let mc = minecraft_login(ep, &ms.access)?;
if !owns_game(ep, &mc.token)? {
return Err("This account doesn't own Minecraft: Java Edition.".into());
}
let account = profile(ep, &mc.token)?;
Ok((
account,
Secrets {
refresh_token: ms.refresh,
minecraft_token: mc.token,
minecraft_expires_at: mc.expires_at,
xuid: mc.xuid,
},
))
}
/// A Minecraft token with at least an hour left, renewed through the refresh token if needed.
/// The profile is read again on renewal (the name may have changed).
pub fn fresh(
ep: &Endpoints,
client_id: &str,
account: &Account,
secrets: Secrets,
) -> Result<(Account, Secrets), String> {
if secrets.minecraft_expires_at > now() + RENEW_BEFORE {
return Ok((account.clone(), secrets));
}
let ms = refresh_ms(ep, client_id, &secrets.refresh_token)?;
let (renewed, secrets) = finish_sign_in(ep, ms)?;
if renewed.uuid != account.uuid {
return Err(
"The Microsoft account now has another Minecraft profile. Sign in again.".into(),
);
}
Ok((renewed, secrets))
}
// ----- The keychain --------------------------------------------------------------------------------
/// Where secrets are kept: the OS keychain, or memory in tests and when there is none.
pub trait SecretStore: Send + Sync {
fn get(&self, key: &str) -> Result<Option<String>, String>;
fn set(&self, key: &str, secret: &str) -> Result<(), String>;
fn delete(&self, key: &str) -> Result<(), String>;
/// False for memory: secrets are gone when the launcher closes.
fn persistent(&self) -> bool;
}
#[derive(Default)]
pub struct MemoryStore(Mutex<HashMap<String, String>>);
impl SecretStore for MemoryStore {
fn get(&self, key: &str) -> Result<Option<String>, String> {
Ok(self.0.lock().unwrap().get(key).cloned())
}
fn set(&self, key: &str, secret: &str) -> Result<(), String> {
self.0.lock().unwrap().insert(key.into(), secret.into());
Ok(())
}
fn delete(&self, key: &str) -> Result<(), String> {
self.0.lock().unwrap().remove(key);
Ok(())
}
fn persistent(&self) -> bool {
false
}
}
/// The Secret Service (GNOME Keyring, KWallet) through oo7, as gpui itself uses it.
#[cfg(any(target_os = "linux", target_os = "freebsd"))]
pub struct SystemStore;
#[cfg(any(target_os = "linux", target_os = "freebsd"))]
impl SystemStore {
fn keyring() -> Result<oo7::Keyring, String> {
futures_lite::future::block_on(async {
let keyring = oo7::Keyring::new().await.map_err(|e| e.to_string())?;
keyring.unlock().await.map_err(|e| e.to_string())?;
Ok(keyring)
})
}
}
#[cfg(any(target_os = "linux", target_os = "freebsd"))]
impl SecretStore for SystemStore {
fn get(&self, key: &str) -> Result<Option<String>, String> {
let keyring = Self::keyring()?;
futures_lite::future::block_on(async {
let attributes = vec![("service", SERVICE), ("account", key)];
let items = keyring
.search_items(&attributes)
.await
.map_err(|e| e.to_string())?;
let Some(item) = items.into_iter().next() else {
return Ok(None);
};
item.unlock().await.map_err(|e| e.to_string())?;
let secret = item.secret().await.map_err(|e| e.to_string())?;
Ok(String::from_utf8(secret.to_vec()).ok())
})
}
fn set(&self, key: &str, secret: &str) -> Result<(), String> {
let keyring = Self::keyring()?;
futures_lite::future::block_on(async {
let attributes = vec![("service", SERVICE), ("account", key)];
keyring
.create_item(
"Horizon launcher: Minecraft account",
&attributes,
secret.as_bytes(),
true,
)
.await
.map_err(|e| e.to_string())
})
}
fn delete(&self, key: &str) -> Result<(), String> {
let keyring = Self::keyring()?;
futures_lite::future::block_on(async {
let attributes = vec![("service", SERVICE), ("account", key)];
keyring.delete(&attributes).await.map_err(|e| e.to_string())
})
}
fn persistent(&self) -> bool {
true
}
}
/// Keychain on macOS, Credential Manager on Windows (the keyring crate).
#[cfg(any(target_os = "macos", target_os = "windows"))]
pub struct SystemStore;
#[cfg(any(target_os = "macos", target_os = "windows"))]
impl SecretStore for SystemStore {
fn get(&self, key: &str) -> Result<Option<String>, String> {
match keyring::Entry::new(SERVICE, key).and_then(|e| e.get_password()) {
Ok(secret) => Ok(Some(secret)),
Err(keyring::Error::NoEntry) => Ok(None),
Err(e) => Err(e.to_string()),
}
}
fn set(&self, key: &str, secret: &str) -> Result<(), String> {
keyring::Entry::new(SERVICE, key)
.and_then(|e| e.set_password(secret))
.map_err(|e| e.to_string())
}
fn delete(&self, key: &str) -> Result<(), String> {
match keyring::Entry::new(SERVICE, key).and_then(|e| e.delete_credential()) {
Ok(()) | Err(keyring::Error::NoEntry) => Ok(()),
Err(e) => Err(e.to_string()),
}
}
fn persistent(&self) -> bool {
true
}
}
pub const NO_KEYCHAIN: &str = "No keychain available: you are signed in until the launcher closes, then you will have to sign in again.";
/// The keychain if it answers, else memory for this run (said once in the UI with NO_KEYCHAIN).
pub fn store() -> &'static dyn SecretStore {
static STORE: OnceLock<Box<dyn SecretStore>> = OnceLock::new();
STORE
.get_or_init(|| {
#[cfg(any(
target_os = "linux",
target_os = "freebsd",
target_os = "macos",
target_os = "windows"
))]
if std::env::var_os("HORIZON_NO_KEYCHAIN").is_none() && SystemStore.get("probe").is_ok()
{
return Box::new(SystemStore);
}
Box::<MemoryStore>::default()
})
.as_ref()
}
// ----- Accounts ------------------------------------------------------------------------------------
/// accounts.json: the signed-in accounts and the one that plays. Never a token.
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Accounts {
pub accounts: Vec<Account>,
/// The UUID of the account the game starts with; none plays offline.
pub selected: Option<String>,
}
impl Accounts {
fn path() -> PathBuf {
crate::backend::data_dir().join("accounts.json")
}
pub fn load() -> Self {
std::fs::read_to_string(Self::path())
.ok()
.and_then(|t| serde_json::from_str(&t).ok())
.unwrap_or_default()
}
pub fn save(&self) -> Result<(), String> {
let path = Self::path();
if let Some(dir) = path.parent() {
std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
}
let text = serde_json::to_string_pretty(self).map_err(|e| e.to_string())?;
std::fs::write(path, text + "\n").map_err(|e| e.to_string())
}
pub fn selected(&self) -> Option<&Account> {
let uuid = self.selected.as_ref()?;
self.accounts.iter().find(|a| &a.uuid == uuid)
}
/// Find an account by name (any case) or UUID (with or without dashes).
pub fn find(&self, who: &str) -> Option<&Account> {
let undashed = who.replace('-', "").to_lowercase();
self.accounts
.iter()
.find(|a| a.name.eq_ignore_ascii_case(who) || a.uuid == undashed)
}
/// Keep a new or renewed account, its secrets in the store, and select it.
pub fn add(
&mut self,
store: &dyn SecretStore,
account: Account,
secrets: &Secrets,
) -> Result<(), String> {
store.set(
&account.uuid,
&serde_json::to_string(secrets).map_err(|e| e.to_string())?,
)?;
self.selected = Some(account.uuid.clone());
match self.accounts.iter_mut().find(|a| a.uuid == account.uuid) {
Some(a) => *a = account,
None => self.accounts.push(account),
}
Ok(())
}
/// Sign out: the secrets leave the keychain, the account the list.
pub fn remove(&mut self, store: &dyn SecretStore, uuid: &str) -> Result<(), String> {
store.delete(uuid)?;
self.accounts.retain(|a| a.uuid != uuid);
if self.selected.as_deref() == Some(uuid) {
self.selected = None;
}
Ok(())
}
}
/// The selected account with a token good for this game, renewed and saved if needed.
pub fn session_for_launch(
ep: &Endpoints,
store: &dyn SecretStore,
accounts: &mut Accounts,
) -> Result<Option<(Account, Secrets)>, String> {
let Some(account) = accounts.selected().cloned() else {
return Ok(None);
};
let secrets: Secrets = store
.get(&account.uuid)?
.and_then(|s| serde_json::from_str(&s).ok())
.ok_or_else(|| {
format!(
"{} is no longer signed in on this computer. Sign in again.",
account.name
)
})?;
let client_id = client_id().ok_or(NOT_CONFIGURED)?;
let before = secrets.minecraft_token.clone();
let (renewed, secrets) = fresh(ep, &client_id, &account, secrets)?;
if renewed != account || secrets.minecraft_token != before {
accounts.add(store, renewed.clone(), &secrets)?;
accounts.save()?;
}
Ok(Some((renewed, secrets)))
}
/// Write the session for the game, readable by this user only, in a fresh file it deletes
/// when it reads it.
pub fn write_session_file(
dir: &Path,
account: &Account,
secrets: &Secrets,
) -> Result<PathBuf, String> {
std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
// Leftovers of games that never started (refused by the game after two minutes anyway).
if let Ok(entries) = std::fs::read_dir(dir) {
for e in entries.flatten() {
let old = e
.metadata()
.and_then(|m| m.modified())
.is_ok_and(|m| m.elapsed().is_ok_and(|age| age > Duration::from_secs(120)));
if old {
let _ = std::fs::remove_file(e.path());
}
}
}
let mut name = [0u8; 12];
getrandom::fill(&mut name).map_err(|e| e.to_string())?;
let path = dir.join(format!(
"session-{}.json",
name.iter().map(|b| format!("{b:02x}")).collect::<String>()
));
let mut options = std::fs::OpenOptions::new();
options.write(true).create_new(true);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
let mut file = options.open(&path).map_err(|e| e.to_string())?;
let body = json!({
"name": account.name,
"uuid": account.uuid,
"access_token": secrets.minecraft_token,
"user_type": "msa",
"xuid": secrets.xuid,
});
std::io::Write::write_all(&mut file, body.to_string().as_bytes()).map_err(|e| e.to_string())?;
Ok(path)
}
/// Where a background sign-in is (the window and the MCP server show it).
#[derive(Clone, Debug)]
pub enum SignInState {
Starting,
/// Waiting for the player at `verification_uri` with `user_code`.
Code(DeviceCode),
Done(Result<Account, String>),
}
/// A sign-in on its own thread, from the code to the saved account.
pub struct SignIn {
state: std::sync::Arc<Mutex<SignInState>>,
cancel: std::sync::Arc<std::sync::atomic::AtomicBool>,
}
impl SignIn {
pub fn start() -> Self {
use std::sync::atomic::Ordering;
let state = std::sync::Arc::new(Mutex::new(SignInState::Starting));
let cancel = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
let (thread_state, thread_cancel) = (state.clone(), cancel.clone());
std::thread::spawn(move || {
let set = |s| *thread_state.lock().unwrap() = s;
let result = (|| {
let ep = Endpoints::live();
let client_id = client_id().ok_or(NOT_CONFIGURED)?;
let code = device_code(&ep, &client_id)?;
set(SignInState::Code(code.clone()));
let ms = wait_for_sign_in(&ep, &client_id, &code, &|| {
thread_cancel.load(Ordering::Relaxed)
})?;
let (account, secrets) = finish_sign_in(&ep, ms)?;
let mut accounts = Accounts::load();
accounts.add(store(), account.clone(), &secrets)?;
accounts.save()?;
Ok(account)
})();
set(SignInState::Done(result));
});
Self { state, cancel }
}
pub fn state(&self) -> SignInState {
self.state.lock().unwrap().clone()
}
pub fn cancel(&self) {
self.cancel
.store(true, std::sync::atomic::Ordering::Relaxed);
}
}
/// Give the game the selected account's session, when there is one.
pub fn attach_session(
cmd: &mut std::process::Command,
game_home: &Path,
) -> Result<Option<Account>, String> {
let mut accounts = Accounts::load();
let Some((account, secrets)) = session_for_launch(&Endpoints::live(), store(), &mut accounts)?
else {
return Ok(None);
};
let file = write_session_file(&game_home.join("sessions"), &account, &secrets)?;
cmd.arg("--session-file").arg(file);
Ok(Some(account))
}
#[cfg(test)]
mod tests;
+410
View File
@@ -0,0 +1,410 @@
//! The sign-in chain against a local mock of the Microsoft, Xbox Live and Minecraft endpoints
//! (recorded response shapes, mock tokens only), and the keychain abstraction in memory.
use super::*;
use std::io::{BufRead, BufReader, Read, Write};
use std::net::TcpListener;
use std::sync::Arc;
const UUID: &str = "069a79f444e94726a5befca90e38aaf5";
/// What the mock answers and what it was asked.
#[derive(Default)]
struct Mock {
/// Polls left before the token endpoint stops saying authorization_pending.
pending: usize,
xerr: Option<u64>,
owns_game: bool,
no_profile: bool,
/// Every request: method, path and body.
log: Vec<(String, String, String)>,
}
fn reply(status: u16, body: Value) -> (u16, String) {
(status, body.to_string())
}
fn route(mock: &mut Mock, method: &str, path: &str, auth: &str, body: &str) -> (u16, String) {
let form = |key: &str| {
body.split('&')
.filter_map(|p| p.split_once('='))
.find(|(k, _)| *k == key)
.map(|(_, v)| v.replace('+', " ").replace("%3A", ":").replace("%20", " "))
};
match (method, path) {
("POST", "/ms/devicecode") => {
assert_eq!(form("client_id").as_deref(), Some("test-client"));
assert_eq!(form("scope").as_deref(), Some(SCOPE));
reply(
200,
json!({"user_code": "ABCD-EFGH", "device_code": "dev-1", "verification_uri": "https://www.microsoft.com/link", "expires_in": 900, "interval": 1}),
)
}
("POST", "/ms/token") => match form("grant_type").as_deref() {
Some("urn:ietf:params:oauth:grant-type:device_code") if mock.pending > 0 => {
mock.pending -= 1;
reply(400, json!({"error": "authorization_pending"}))
}
Some("urn:ietf:params:oauth:grant-type:device_code") => {
assert_eq!(form("device_code").as_deref(), Some("dev-1"));
reply(
200,
json!({"access_token": "ms-access-1", "refresh_token": "ms-refresh-1", "expires_in": 3600}),
)
}
Some("refresh_token") if form("refresh_token").as_deref() == Some("ms-refresh-1") => {
reply(
200,
json!({"access_token": "ms-access-2", "refresh_token": "ms-refresh-2"}),
)
}
_ => reply(400, json!({"error": "invalid_grant"})),
},
("POST", "/xbl") => {
let v: Value = serde_json::from_str(body).unwrap();
assert!(v["Properties"]["RpsTicket"]
.as_str()
.unwrap()
.starts_with("d=ms-access-"));
assert_eq!(v["RelyingParty"], "http://auth.xboxlive.com");
reply(
200,
json!({"Token": "xbl-token", "DisplayClaims": {"xui": [{"uhs": "uhs-1"}]}}),
)
}
("POST", "/xsts") => {
let v: Value = serde_json::from_str(body).unwrap();
assert_eq!(v["Properties"]["UserTokens"][0], "xbl-token");
assert_eq!(v["RelyingParty"], "rp://api.minecraftservices.com/");
match mock.xerr {
Some(code) => reply(401, json!({"Identity": "0", "XErr": code, "Message": ""})),
None => reply(
200,
json!({"Token": "xsts-token", "DisplayClaims": {"xui": [{"uhs": "uhs-1", "xid": "2535400000000000"}]}}),
),
}
}
("POST", "/mc/authentication/login_with_xbox") => {
let v: Value = serde_json::from_str(body).unwrap();
assert_eq!(v["identityToken"], "XBL3.0 x=uhs-1;xsts-token");
reply(
200,
json!({"username": "mock", "access_token": "mc-token", "token_type": "Bearer", "expires_in": 86400}),
)
}
("GET", "/mc/entitlements/mcstore") => {
assert_eq!(auth, "Bearer mc-token");
let items = if mock.owns_game {
json!([{"name": "product_minecraft", "signature": "x"}, {"name": "game_minecraft", "signature": "x"}])
} else {
json!([])
};
reply(200, json!({"items": items, "signature": "x", "keyId": "1"}))
}
("GET", "/mc/minecraft/profile") if mock.no_profile => reply(
404,
json!({"path": "/minecraft/profile", "errorType": "NOT_FOUND", "error": "NOT_FOUND"}),
),
("GET", "/mc/minecraft/profile") => reply(
200,
json!({
"id": UUID, "name": "Notch",
"skins": [{"id": "s1", "state": "ACTIVE", "url": "http://textures.minecraft.net/texture/abc", "variant": "SLIM"}],
"capes": [{"id": "c1", "state": "INACTIVE", "url": "http://textures.minecraft.net/texture/cape1", "alias": "Migrator"},
{"id": "c2", "state": "ACTIVE", "url": "http://textures.minecraft.net/texture/cape2", "alias": "Vanilla"}],
}),
),
_ => reply(404, json!({"error": "NotFound"})),
}
}
/// A one-thread HTTP/1.1 server: one request per connection.
fn serve(mock: Arc<Mutex<Mock>>) -> Endpoints {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
std::thread::spawn(move || {
for stream in listener.incoming() {
let Ok(mut stream) = stream else { continue };
let mut reader = BufReader::new(stream.try_clone().unwrap());
let mut line = String::new();
if reader.read_line(&mut line).is_err() {
continue;
}
let mut parts = line.split_whitespace();
let (method, path) = (
parts.next().unwrap_or("").to_owned(),
parts.next().unwrap_or("").to_owned(),
);
let (mut length, mut auth) = (0, String::new());
loop {
let mut header = String::new();
reader.read_line(&mut header).unwrap();
let header = header.trim_end();
if header.is_empty() {
break;
}
let (k, v) = header.split_once(':').unwrap();
match k.to_ascii_lowercase().as_str() {
"content-length" => length = v.trim().parse().unwrap(),
"authorization" => auth = v.trim().to_owned(),
_ => {}
}
}
let mut body = vec![0; length];
reader.read_exact(&mut body).unwrap();
let body = String::from_utf8(body).unwrap();
let (status, text) = {
let mut m = mock.lock().unwrap();
m.log.push((method.clone(), path.clone(), body.clone()));
route(&mut m, &method, &path, &auth, &body)
};
let _ = write!(
stream,
"HTTP/1.1 {status} X\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{text}",
text.len()
);
}
});
Endpoints {
microsoft: format!("{base}/ms"),
xbox_user: format!("{base}/xbl"),
xsts: format!("{base}/xsts"),
minecraft: format!("{base}/mc"),
}
}
fn mock(f: impl FnOnce(&mut Mock)) -> (Arc<Mutex<Mock>>, Endpoints) {
let mut m = Mock {
owns_game: true,
..Default::default()
};
f(&mut m);
let m = Arc::new(Mutex::new(m));
let ep = serve(m.clone());
(m, ep)
}
#[test]
fn the_whole_chain() {
let (m, ep) = mock(|m| m.pending = 2);
let code = device_code(&ep, "test-client").unwrap();
assert_eq!(
(code.user_code.as_str(), code.verification_uri.as_str()),
("ABCD-EFGH", "https://www.microsoft.com/link")
);
let ms = wait_for_sign_in(&ep, "test-client", &code, &|| false).unwrap();
let (account, secrets) = finish_sign_in(&ep, ms).unwrap();
assert_eq!(
account,
Account {
uuid: UUID.into(),
name: "Notch".into(),
skin: Some((
"http://textures.minecraft.net/texture/abc".into(),
"slim".into()
)),
cape: Some("http://textures.minecraft.net/texture/cape2".into()),
}
);
assert_eq!(secrets.minecraft_token, "mc-token");
assert_eq!(secrets.xuid.as_deref(), Some("2535400000000000"));
assert!(secrets.minecraft_expires_at > now() + 80000);
// Two pending polls, then the token; then Xbox, XSTS, Minecraft, entitlements, profile.
let paths: Vec<String> = m
.lock()
.unwrap()
.log
.iter()
.map(|(_, p, _)| p.clone())
.collect();
assert_eq!(
paths,
[
"/ms/devicecode",
"/ms/token",
"/ms/token",
"/ms/token",
"/xbl",
"/xsts",
"/mc/authentication/login_with_xbox",
"/mc/entitlements/mcstore",
"/mc/minecraft/profile"
]
);
assert!(!format!("{secrets:?}").contains("mc-token"));
}
#[test]
fn refresh_only_when_the_token_runs_out() {
let (m, ep) = mock(|_| {});
let account = Account {
uuid: UUID.into(),
name: "Notch".into(),
skin: None,
cape: None,
};
let good = Secrets {
refresh_token: "ms-refresh-1".into(),
minecraft_token: "old".into(),
minecraft_expires_at: now() + 7200,
xuid: None,
};
let (_, kept) = fresh(&ep, "test-client", &account, good).unwrap();
assert_eq!(kept.minecraft_token, "old");
assert!(m.lock().unwrap().log.is_empty());
let stale = Secrets {
minecraft_expires_at: now() + 60,
..kept.clone()
};
let (renewed_account, renewed) = fresh(&ep, "test-client", &account, stale).unwrap();
assert_eq!(
(
renewed.refresh_token.as_str(),
renewed.minecraft_token.as_str()
),
("ms-refresh-2", "mc-token")
);
assert!(renewed_account.skin.is_some());
let revoked = Secrets {
refresh_token: "revoked".into(),
minecraft_expires_at: 0,
..kept
};
assert_eq!(
fresh(&ep, "test-client", &account, revoked).unwrap_err(),
SIGN_IN_AGAIN
);
}
#[test]
fn refusals_have_messages() {
let tokens = || MsTokens {
access: "ms-access-1".into(),
refresh: "r".into(),
};
let (_, ep) = mock(|m| m.xerr = Some(2148916233));
assert!(finish_sign_in(&ep, tokens())
.unwrap_err()
.contains("no Xbox profile"));
let (_, ep) = mock(|m| m.xerr = Some(2148916238));
assert!(finish_sign_in(&ep, tokens())
.unwrap_err()
.contains("child account"));
let (_, ep) = mock(|m| m.owns_game = false);
assert_eq!(
finish_sign_in(&ep, tokens()).unwrap_err(),
"This account doesn't own Minecraft: Java Edition."
);
let (_, ep) = mock(|m| m.no_profile = true);
assert!(finish_sign_in(&ep, tokens())
.unwrap_err()
.contains("no Minecraft profile"));
assert_eq!(
oauth_error(&json!({"error": "authorization_declined"})),
"Sign-in was declined in the browser."
);
// Nothing listening: a message, not a URL.
let dead = Endpoints {
microsoft: "http://127.0.0.1:9/ms".into(),
..Endpoints::live()
};
assert_eq!(
device_code(&dead, "x").unwrap_err(),
"Could not reach Microsoft. Check your internet connection."
);
}
#[test]
fn cancelling_stops_the_wait() {
let (_, ep) = mock(|m| m.pending = 100);
let code = device_code(&ep, "test-client").unwrap();
assert_eq!(
wait_for_sign_in(&ep, "test-client", &code, &|| true).unwrap_err(),
"Sign-in cancelled."
);
}
#[test]
fn accounts_keep_secrets_in_the_store_only() {
let store = MemoryStore::default();
let mut accounts = Accounts::default();
let account = Account {
uuid: UUID.into(),
name: "Notch".into(),
skin: None,
cape: None,
};
let secrets = Secrets {
refresh_token: "r".into(),
minecraft_token: "mc-secret".into(),
minecraft_expires_at: 1,
xuid: None,
};
accounts.add(&store, account.clone(), &secrets).unwrap();
assert_eq!(accounts.selected(), Some(&account));
assert_eq!(accounts.find("notch"), Some(&account));
assert_eq!(
accounts.find("069a79f4-44e9-4726-a5be-fca90e38aaf5"),
Some(&account)
);
let saved = serde_json::to_string(&accounts).unwrap();
assert!(!saved.contains("mc-secret") && !saved.contains("\"r\""));
assert!(store.get(UUID).unwrap().unwrap().contains("mc-secret"));
accounts.remove(&store, UUID).unwrap();
assert_eq!(
(accounts.selected(), store.get(UUID).unwrap()),
(None, None)
);
assert!(!store.persistent());
}
#[test]
fn session_files_are_private_and_complete() {
let dir = std::env::temp_dir().join(format!("horizon-launcher-session-{}", std::process::id()));
let account = Account {
uuid: UUID.into(),
name: "Notch".into(),
skin: None,
cape: None,
};
let secrets = Secrets {
refresh_token: "r".into(),
minecraft_token: "mc-token".into(),
minecraft_expires_at: 1,
xuid: Some("25".into()),
};
let path = write_session_file(&dir, &account, &secrets).unwrap();
let v: Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
assert_eq!(
v,
json!({"name": "Notch", "uuid": UUID, "access_token": "mc-token", "user_type": "msa", "xuid": "25"})
);
// The refresh token never leaves the keychain.
assert!(!v.to_string().contains("\"r\""));
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
assert_eq!(
std::fs::metadata(&path).unwrap().permissions().mode() & 0o777,
0o600
);
}
let other = write_session_file(&dir, &account, &secrets).unwrap();
assert_ne!(path, other);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn client_id_is_configuration() {
// The run-time variable overrides; empty means not configured.
std::env::set_var("HORIZON_MSA_CLIENT_ID", " ");
assert_eq!(client_id(), None);
std::env::set_var(
"HORIZON_MSA_CLIENT_ID",
"00000000-1111-2222-3333-444444444444",
);
assert_eq!(
client_id().as_deref(),
Some("00000000-1111-2222-3333-444444444444")
);
std::env::remove_var("HORIZON_MSA_CLIENT_ID");
}
+30 -27
View File
@@ -591,17 +591,18 @@ fn preparer_binary(dir: &Path) -> Option<PathBuf> {
/// Java (and Python, for versions before horizon-prepare).
pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result<Preparer, String> {
let version = game_version(tag);
let dir = version_dir(tag);
let reused = horizon_prepare::artifacts::reuse_imported(&dir, &|line| log(line.to_string()))?;
let manifest = minecraft
.join("versions")
.join(&version)
.join(format!("{version}.json"));
if !manifest.exists() {
if !reused && !manifest.exists() {
return Err(format!(
"Minecraft {version} is not in {}. Play {version} once from the official launcher, or choose another folder.",
minecraft.display()
));
}
let dir = version_dir(tag);
let binary = preparer_binary(&dir);
let python = if binary.is_some() {
// The JDK the version pins, found as horizon-prepare finds it, so a missing one is
@@ -625,7 +626,7 @@ pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result<Pre
let jar = data_dir()
.join("server-jars")
.join(format!("{version}.jar"));
if !jar.exists() {
if !reused && !jar.exists() {
let json: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&manifest).map_err(|e| e.to_string())?)
.map_err(|e| e.to_string())?;
@@ -650,32 +651,26 @@ pub fn preparer(tag: &str, minecraft: &Path, log: &dyn Fn(String)) -> Result<Pre
{
return Ok(Preparer::InProcess(horizon_prepare::Options {
root: dir,
import: true,
import: !reused,
minecraft_dir: Some(minecraft.to_path_buf()),
server_jar: Some(jar),
server_jar: (!reused).then_some(jar),
}));
}
let mut cmd = Command::new(binary);
cmd.current_dir(&dir)
.arg("--root")
.arg(&dir)
.args(["--prepare", "--server-jar"])
.arg(&jar)
.arg("--minecraft-dir")
.arg(minecraft);
cmd.current_dir(&dir).arg("--root").arg(&dir);
if !reused {
cmd.args(["--prepare", "--server-jar"]).arg(&jar);
}
cmd.arg("--minecraft-dir").arg(minecraft);
return Ok(Preparer::Process(cmd));
}
let mut cmd = Command::new(python.unwrap());
cmd.current_dir(&dir)
.args([
"-u",
"tools/prepare_native_client.py",
"--prepare",
"--server-jar",
])
.arg(&jar)
.arg("--minecraft-dir")
.arg(minecraft);
.args(["-u", "tools/prepare_native_client.py"]);
if !reused {
cmd.args(["--prepare", "--server-jar"]).arg(&jar);
}
cmd.arg("--minecraft-dir").arg(minecraft);
Ok(Preparer::Process(cmd))
}
@@ -965,14 +960,12 @@ pub fn remove_version(tag: &str) -> Result<(), String> {
}
/// The Minecraft folder to prepare from: the one given, the one chosen in the launcher, or the
/// official launcher's default.
/// official launcher's default. It may be absent when imported files can be reused.
pub fn minecraft_dir(requested: Option<PathBuf>) -> Result<PathBuf, String> {
requested
Ok(requested
.or(Settings::load().minecraft_dir)
.or_else(default_minecraft_dir)
.ok_or_else(|| {
"No Minecraft folder found. Pass the official launcher's game folder.".into()
})
.unwrap_or_else(|| horizon_prepare::artifacts::minecraft_dir(None)))
}
/// The server folder: the one given, the one chosen in the launcher, or `server/` in the data folder.
@@ -996,7 +989,12 @@ fn need_prepared(tag: &str) -> Result<(), String> {
/// The client's command, once its resources are prepared.
pub fn client(tag: &str) -> Result<Command, String> {
need_prepared(tag)?;
Ok(client_command(tag))
let mut cmd = client_command(tag);
// A sign-in that can't be renewed (no network, expired) still lets the game start, offline.
if let Err(e) = crate::account::attach_session(&mut cmd, &game_home()) {
eprintln!("Playing offline: {e}");
}
Ok(cmd)
}
/// The dedicated server's command in `folder`, once prepared and the EULA is agreed to.
@@ -1387,6 +1385,11 @@ pub enum Msg {
LauncherUpdated(Result<(), String>),
/// `reuse_prepared_everywhere` prepared these versions.
Reused(Vec<(String, String)>),
/// Whether secrets are kept in the OS keychain (else only until the launcher closes).
Keychain(bool),
/// The selected account's session file for the game about to start (none = offline), or
/// why it could not be renewed.
Session(Result<Option<PathBuf>, String>),
}
/// A running process; its output arrives as `Msg::Line`, its end as `Msg::Exit`.
+97
View File
@@ -1,6 +1,7 @@
//! `horizon-launcher <subcommand>`: the same steps as the window, from a terminal. Every
//! command goes through `backend`; this file only parses arguments and prints.
use clap::{Parser, Subcommand};
use horizon_launcher::account::{self, Accounts};
use horizon_launcher::backend::{self, Release};
use std::io::{IsTerminal, Write};
use std::path::PathBuf;
@@ -20,6 +21,23 @@ struct Cli {
command: Option<Cmd>,
}
#[derive(Subcommand)]
enum AccountCmd {
/// The signed-in accounts and which one plays
List,
/// Sign in with a Microsoft account in your browser (device code)
SignIn,
/// Sign out: the account's tokens leave the keychain
SignOut {
/// Its name or UUID
who: String,
},
/// Play as this account
Select { who: String },
/// Play offline, without an account
Offline,
}
#[derive(Subcommand)]
enum Cmd {
/// List Horizon releases, or the installed versions
@@ -61,6 +79,11 @@ enum Cmd {
Notes { tag: Option<String> },
/// Show the Discord, sponsor and website links
Links,
/// Microsoft accounts: list them (the default), sign in, sign out, or pick the one that plays
Account {
#[command(subcommand)]
action: Option<AccountCmd>,
},
/// Show or set the game's menu style (classic is vanilla's own screens)
MenuStyle {
/// Omit to show the current style
@@ -254,6 +277,7 @@ fn execute(command: Cmd, as_json: bool) -> Result<(), String> {
);
}
}
Cmd::Account { action } => account_command(action.unwrap_or(AccountCmd::List), as_json)?,
Cmd::Links => {
let links = backend::links();
if as_json {
@@ -331,3 +355,76 @@ fn update(check: bool, as_json: bool) -> Result<(), String> {
}
Ok(())
}
/// `account …`: names and UUIDs only; tokens are never printed.
fn account_command(action: AccountCmd, as_json: bool) -> Result<(), String> {
let mut accounts = Accounts::load();
let find = |accounts: &Accounts, who: &str| {
accounts
.find(who)
.cloned()
.ok_or_else(|| format!("No signed-in account {who}. See `horizon-launcher account`."))
};
match action {
AccountCmd::List => {
if as_json {
json(serde_json::json!({
"accounts": accounts.accounts.iter().map(|a| serde_json::json!({
"name": a.name, "uuid": a.uuid,
"selected": accounts.selected.as_ref() == Some(&a.uuid),
})).collect::<Vec<_>>(),
"sign_in_configured": account::client_id().is_some(),
}));
} else if accounts.accounts.is_empty() {
println!("No Microsoft account signed in: the game plays offline.");
} else {
for a in &accounts.accounts {
let mark = if accounts.selected.as_ref() == Some(&a.uuid) {
"*"
} else {
" "
};
println!("{mark} {} {}", a.name, a.uuid);
}
if accounts.selected().is_none() {
println!("Playing offline (`account select NAME` to play as one).");
}
}
}
AccountCmd::SignIn => {
let client_id = account::client_id().ok_or(account::NOT_CONFIGURED)?;
let ep = account::Endpoints::live();
let code = account::device_code(&ep, &client_id)?;
eprintln!(
"To sign in, open {} in a browser and enter the code {}",
code.verification_uri, code.user_code
);
let ms = account::wait_for_sign_in(&ep, &client_id, &code, &|| false)?;
let (signed_in, secrets) = account::finish_sign_in(&ep, ms)?;
accounts.add(account::store(), signed_in.clone(), &secrets)?;
accounts.save()?;
println!("Signed in as {}.", signed_in.name);
if !account::store().persistent() {
eprintln!("{}", account::NO_KEYCHAIN);
}
}
AccountCmd::SignOut { who } => {
let a = find(&accounts, &who)?;
accounts.remove(account::store(), &a.uuid)?;
accounts.save()?;
println!("Signed out {}.", a.name);
}
AccountCmd::Select { who } => {
let a = find(&accounts, &who)?;
accounts.selected = Some(a.uuid);
accounts.save()?;
println!("The game plays as {}.", a.name);
}
AccountCmd::Offline => {
accounts.selected = None;
accounts.save()?;
println!("The game plays offline.");
}
}
Ok(())
}
+1
View File
@@ -1,2 +1,3 @@
//! The launcher's core, shared by the GUI, the CLI and the MCP server.
pub mod account;
pub mod backend;
+263 -11
View File
@@ -13,6 +13,7 @@ use gpui::{
RenderImage, ScrollHandle, SharedString, Stateful, Subscription, TitlebarOptions, Window,
WindowBounds, WindowOptions,
};
use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
use horizon_launcher::backend::{self, Job, Msg, Release, Running, Settings, Updates};
use std::borrow::Cow;
use std::collections::VecDeque;
@@ -147,6 +148,13 @@ struct Launcher {
client_started: Option<std::time::SystemTime>,
crash: Option<Crash>,
server: Option<Running>,
/// Microsoft accounts (accounts.json), the sign-in under way and what it last showed.
accounts: Accounts,
sign_in: Option<SignIn>,
sign_in_state: Option<SignInState>,
keychain: bool,
/// The game is waiting for its session (a token renewal) before it starts.
starting_client: Option<String>,
server_log: VecDeque<String>,
server_error: Option<String>,
input: String,
@@ -228,6 +236,11 @@ impl Launcher {
client_started: None,
crash: None,
server: None,
accounts: Accounts::load(),
sign_in: None,
sign_in_state: None,
keychain: true,
starting_client: None,
server_log: VecDeque::new(),
server_error: None,
input: String::new(),
@@ -239,6 +252,11 @@ impl Launcher {
_appearance: appearance,
};
let tx = this.tx.clone();
let keychain_tx = this.tx.clone();
// Asking the keychain can block (D-Bus), so not on this thread.
std::thread::spawn(move || {
let _ = keychain_tx.send(Msg::Keychain(account::store().persistent()));
});
std::thread::spawn(move || {
let reused = backend::reuse_prepared_everywhere();
if !reused.is_empty() {
@@ -331,6 +349,25 @@ impl Launcher {
Msg::Links(links) => self.links = links,
// The page reads is_prepared when drawn; `changed` redraws it.
Msg::Reused(_) => self.installed = backend::installed(),
Msg::Keychain(persistent) => self.keychain = persistent,
Msg::Session(session) => {
if let Some(tag) = self.starting_client.take() {
let mut cmd = backend::client_command(&tag);
match session {
Ok(Some(file)) => {
cmd.arg("--session-file").arg(file);
}
Ok(None) => {}
// Still play, offline, and say why.
Err(e) => self.client_error = Some(format!("Playing offline: {e}")),
}
self.accounts = Accounts::load();
match backend::spawn(Job::Client, cmd, self.tx.clone()) {
Ok(r) => self.client = Some(r),
Err(e) => self.client_error = Some(e),
}
}
}
Msg::Progress(tag, p) => {
self.bar = (self.bar.1, p);
self.installing = Some((tag, p));
@@ -454,6 +491,17 @@ impl Launcher {
}
}
}
if let Some(sign_in) = &self.sign_in {
let state = sign_in.state();
let changed_state = format!("{state:?}") != format!("{:?}", self.sign_in_state);
if changed_state {
if let SignInState::Done(Ok(_)) = state {
self.accounts = Accounts::load();
}
self.sign_in_state = Some(state);
changed = true;
}
}
if self.checked.is_some_and(|at| at.elapsed() > CHECK_EVERY) {
self.check_updates();
}
@@ -501,10 +549,11 @@ impl Launcher {
let Some(tag) = self.selected().cloned() else {
return;
};
let Some(minecraft) = self.settings.minecraft_dir.clone() else {
self.prepare_error = Some("Choose your Minecraft folder first.".into());
return;
};
let minecraft = self
.settings
.minecraft_dir
.clone()
.unwrap_or_else(|| horizon_prepare::artifacts::minecraft_dir(None));
self.prepare_log.clear();
self.prepare_error = None;
self.prepare_log
@@ -545,7 +594,7 @@ impl Launcher {
};
match self.mode {
Mode::Client => {
if self.client.is_some() {
if self.client.is_some() || self.starting_client.is_some() {
return;
}
self.client_error = None;
@@ -554,10 +603,30 @@ impl Launcher {
// A little earlier than the spawn: file times can be coarse.
self.client_started =
Some(std::time::SystemTime::now() - std::time::Duration::from_secs(2));
match backend::spawn(Job::Client, backend::client_command(&tag), self.tx.clone()) {
Ok(r) => self.client = Some(r),
Err(e) => self.client_error = Some(e),
}
// The session (a network round trip when the token needs renewing) comes first;
// `drain` starts the game when it arrives.
self.starting_client = Some(tag);
let tx = self.tx.clone();
std::thread::spawn(move || {
let session = (|| {
let mut accounts = Accounts::load();
let Some((a, secrets)) = account::session_for_launch(
&account::Endpoints::live(),
account::store(),
&mut accounts,
)?
else {
return Ok(None);
};
account::write_session_file(
&backend::game_home().join("sessions"),
&a,
&secrets,
)
.map(Some)
})();
let _ = tx.send(Msg::Session(session));
});
}
Mode::Server => {
if let Some(server) = &mut self.server {
@@ -1163,7 +1232,7 @@ impl Launcher {
let version = backend::game_version(&tag);
let hero = self.hero(&tag, &version, prepared, cx);
let running = match self.mode {
Mode::Client => self.client.is_some(),
Mode::Client => self.client.is_some() || self.starting_client.is_some(),
Mode::Server => self.server.is_some(),
};
let play_label = match (self.mode, running) {
@@ -1263,6 +1332,27 @@ impl Launcher {
)),
&t,
));
if self.mode == Mode::Client {
let who = match self.accounts.selected() {
Some(a) => div().child(format!("{} (Microsoft account)", a.name)),
None => div()
.text_color(t.muted)
.child("Offline: online servers need a Microsoft account."),
};
rows = rows.child(divider(&t)).child(row(
"Playing as",
who,
Some(
button("accounts", "Accounts…", Kind::Ghost, &t).on_click(cx.listener(
|this, _: &ClickEvent, _, cx| {
this.go(Page::Settings);
cx.notify();
},
)),
),
&t,
));
}
if self.mode == Mode::Server {
let folder = self
.settings
@@ -1754,13 +1844,14 @@ impl Launcher {
.gap(px(24.))
.child(page_header(
"Settings",
"Updates, menus, and the launcher itself.",
"Accounts, updates, menus, and the launcher itself.",
&t,
))
.child(
div()
.flex()
.flex_col()
.child(self.account_rows(cx))
.child(divider(&t))
.child(row("Updates", auto, Some(toggle), &t))
.child(divider(&t))
@@ -1808,6 +1899,167 @@ impl Launcher {
.child(agents)
}
/// Settings' Microsoft accounts: who is signed in and plays, the sign-in with its code.
fn account_rows(&mut self, cx: &mut Context<Self>) -> Div {
let t = self.theme;
let mut rows = div().flex().flex_col();
let selected = self.accounts.selected.clone();
for (i, a) in self.accounts.accounts.clone().into_iter().enumerate() {
let plays = selected.as_ref() == Some(&a.uuid);
let value = div()
.flex()
.flex_col()
.gap(px(2.))
.child(a.name.clone())
.child(
div()
.text_size(px(theme::SMALL))
.text_color(t.muted)
.child(if plays { "Plays" } else { "Signed in" }),
);
let uuid = a.uuid.clone();
let mut actions = div().flex().gap(px(4.));
if plays {
actions = actions.child(
button(format!("offline-{i}"), "Play offline", Kind::Ghost, &t).on_click(
cx.listener(|this, _: &ClickEvent, _, cx| {
this.accounts.selected = None;
let _ = this.accounts.save();
cx.notify();
}),
),
);
} else {
let uuid = uuid.clone();
actions = actions.child(
button(format!("select-{i}"), "Play as", Kind::Secondary, &t).on_click(
cx.listener(move |this, _: &ClickEvent, _, cx| {
this.accounts.selected = Some(uuid.clone());
let _ = this.accounts.save();
cx.notify();
}),
),
);
}
actions = actions.child(
button(format!("sign-out-{i}"), "Sign out", Kind::Ghost, &t).on_click(cx.listener(
move |this, _: &ClickEvent, _, cx| {
let store = account::store();
if let Err(e) = this.accounts.remove(store, &uuid) {
this.sign_in_state = Some(SignInState::Done(Err(e)));
}
let _ = this.accounts.save();
cx.notify();
},
)),
);
let label = if i == 0 { "Accounts" } else { "" };
rows = rows.child(divider(&t)).child(row(
label,
value,
Some(actions.id(SharedString::from(format!("account-{i}")))),
&t,
));
}
let configured = account::client_id().is_some();
let busy = matches!(
self.sign_in_state,
Some(SignInState::Starting | SignInState::Code(_))
);
let value = match &self.sign_in_state {
_ if !configured => div().text_color(t.muted).child(account::NOT_CONFIGURED),
Some(SignInState::Starting) => div().text_color(t.muted).child("Asking Microsoft…"),
Some(SignInState::Code(code)) => div()
.flex()
.flex_col()
.gap(px(4.))
.child(format!(
"Open {} in your browser and enter this code:",
code.verification_uri
))
.child(
div()
.font_family(theme::MONO)
.text_size(px(theme::LARGE))
.font_weight(FontWeight::MEDIUM)
.child(code.user_code.clone()),
),
Some(SignInState::Done(Ok(a))) => div().child(format!("Signed in as {}.", a.name)),
Some(SignInState::Done(Err(e))) => div().text_color(t.danger).child(e.clone()),
None if self.accounts.accounts.is_empty() => div().text_color(t.muted).child(
"Sign in to play on online servers with your name and skin. Without an account the game plays offline.",
),
None => div().text_color(t.muted).child("Add another account."),
};
let value = if self.keychain || self.accounts.accounts.is_empty() {
value
} else {
div().flex().flex_col().gap(px(4.)).child(value).child(
div()
.text_size(px(theme::SMALL))
.text_color(t.muted)
.child(account::NO_KEYCHAIN),
)
};
let action = if !configured {
None
} else if let Some(SignInState::Code(code)) = &self.sign_in_state {
let (uri, user_code) = (code.verification_uri.clone(), code.user_code.clone());
Some(
div()
.flex()
.gap(px(4.))
.child(
button("sign-in-copy", "Copy code", Kind::Secondary, &t).on_click(
move |_, _, cx| {
cx.write_to_clipboard(gpui::ClipboardItem::new_string(
user_code.clone(),
))
},
),
)
.child(
button("sign-in-open", "Open link", Kind::Secondary, &t)
.on_click(move |_, _, cx| cx.open_url(&uri)),
)
.child(
button("sign-in-cancel", "Cancel", Kind::Ghost, &t).on_click(cx.listener(
|this, _: &ClickEvent, _, cx| {
if let Some(s) = this.sign_in.take() {
s.cancel();
}
this.sign_in_state = None;
cx.notify();
},
)),
),
)
} else if busy {
None
} else {
Some(div().child(
button("sign-in", "Sign in with Microsoft", Kind::Secondary, &t).on_click(
cx.listener(|this, _: &ClickEvent, _, cx| {
this.sign_in = Some(SignIn::start());
this.sign_in_state = Some(SignInState::Starting);
cx.notify();
}),
),
))
};
let label = if self.accounts.accounts.is_empty() {
"Account"
} else {
""
};
rows.child(divider(&t)).child(row(
label,
value,
action.map(|a| a.id("sign-in-actions")),
&t,
))
}
fn console(&self, cx: &mut Context<Self>) -> Div {
let t = self.theme;
let running = self.server.is_some();
+73
View File
@@ -1,6 +1,7 @@
//! `horizon-launcher mcp`: the Model Context Protocol over stdin and stdout (JSON-RPC 2.0, one
//! message per line), so AI agents can install, prepare and run Horizon. Every tool goes through
//! `backend`. A server started here lives as long as the session.
use horizon_launcher::account::{self, Accounts, SignIn, SignInState};
use horizon_launcher::backend::{self, Job, Logged};
use serde_json::{json, Value};
use std::io::{BufRead, Write};
@@ -12,6 +13,7 @@ const PROTOCOL: &str = "2025-06-18";
struct Session {
server: Option<Logged>,
client: Option<Logged>,
sign_in: Option<SignIn>,
}
fn tools() -> Value {
@@ -42,6 +44,12 @@ fn tools() -> Value {
"inputSchema": { "type": "object", "properties": { "style": { "type": "string", "enum": ["horizon", "classic"], "description": "Omit to show the current style." } } } },
{ "name": "logs", "description": "Read the game's log: the last lines of logs/latest.log in the game folder, or with crash the newest crash report (what the game wrote when it last crashed). Read-only.",
"inputSchema": { "type": "object", "properties": { "lines": { "type": "integer", "minimum": 1, "maximum": 5000, "description": "How many lines of latest.log (default 100)." }, "crash": { "type": "boolean", "description": "Return the newest crash report instead." } } } },
{ "name": "accounts", "description": "The Microsoft accounts signed in to the launcher (names and UUIDs, never tokens), which one the game plays as (none = offline), and how a sign-in started with sign_in is going.", "inputSchema": none },
{ "name": "sign_in", "description": "Start signing in a Microsoft account: returns a link and a code the player enters in their browser. The sign-in finishes in the background; check it with accounts. Only when the player asks to sign in.", "inputSchema": none },
{ "name": "sign_out", "description": "Sign an account out of the launcher (its tokens leave the keychain).",
"inputSchema": { "type": "object", "properties": { "account": { "type": "string", "description": "Its name or UUID." } }, "required": ["account"] } },
{ "name": "select_account", "description": "Choose the account the game plays as, or \"offline\" to play without one.",
"inputSchema": { "type": "object", "properties": { "account": { "type": "string", "description": "A name or UUID, or \"offline\"." } }, "required": ["account"] } },
{ "name": "check_updates", "description": "Check GitHub for a Horizon release newer than every installed version, and for a newer launcher.", "inputSchema": none },
])
}
@@ -242,6 +250,70 @@ impl Session {
}))
.unwrap())
}
"accounts" => {
let accounts = Accounts::load();
let sign_in = self.sign_in.as_ref().map(|s| match s.state() {
SignInState::Starting => json!({ "state": "starting" }),
SignInState::Code(c) => json!({ "state": "waiting for the player", "link": c.verification_uri, "code": c.user_code }),
SignInState::Done(Ok(a)) => json!({ "state": "signed in", "name": a.name }),
SignInState::Done(Err(e)) => json!({ "state": "failed", "error": e }),
});
Ok(serde_json::to_string_pretty(&json!({
"accounts": accounts.accounts.iter().map(|a| json!({ "name": a.name, "uuid": a.uuid })).collect::<Vec<_>>(),
"plays_as": accounts.selected().map(|a| a.name.clone()),
"sign_in_configured": account::client_id().is_some(),
"keychain": account::store().persistent(),
"sign_in": sign_in,
}))
.unwrap())
}
"sign_in" => {
account::client_id().ok_or(account::NOT_CONFIGURED)?;
if let Some(s) = self.sign_in.take() {
s.cancel();
}
let sign_in = SignIn::start();
let deadline = std::time::Instant::now() + Duration::from_secs(30);
let state = loop {
match sign_in.state() {
SignInState::Starting if std::time::Instant::now() < deadline => {
std::thread::sleep(Duration::from_millis(100))
}
state => break state,
}
};
self.sign_in = Some(sign_in);
match state {
SignInState::Code(c) => Ok(format!(
"Ask the player to open {} and enter the code {}. Then check accounts.",
c.verification_uri, c.user_code
)),
SignInState::Done(Err(e)) => Err(e),
_ => Err("Microsoft did not answer. Try again.".into()),
}
}
"sign_out" | "select_account" => {
let who = arg_str(args, "account").ok_or("account is required")?;
let mut accounts = Accounts::load();
if name == "select_account" && who.eq_ignore_ascii_case("offline") {
accounts.selected = None;
accounts.save()?;
return Ok("The game plays offline.".into());
}
let a = accounts
.find(who)
.cloned()
.ok_or_else(|| format!("No signed-in account {who}."))?;
if name == "sign_out" {
accounts.remove(account::store(), &a.uuid)?;
accounts.save()?;
Ok(format!("Signed out {}.", a.name))
} else {
accounts.selected = Some(a.uuid);
accounts.save()?;
Ok(format!("The game plays as {}.", a.name))
}
}
_ => Err(format!("Unknown tool {name}")),
}
}
@@ -292,6 +364,7 @@ pub fn serve() -> Result<(), String> {
let mut session = Session {
server: None,
client: None,
sign_in: None,
};
let stdin = std::io::stdin();
let mut stdout = std::io::stdout();
@@ -281,6 +281,8 @@ public final class VanillaBlockUpdateOracle {
if (entities != null) entities.add(entity);
return true;
}
/** No players watch: the hurt animation and its sound are not sent. */
@Override public void broadcastDamageEvent(Entity entity, net.minecraft.world.damagesource.DamageSource source) { }
@Override public void levelEvent(Entity source, int type, BlockPos p, int data) { emit("L " + type + " " + pos(p) + " " + data); }
@Override public void playSeededSound(Entity except, double x, double y, double z, net.minecraft.core.Holder<SoundEvent> sound, SoundSource source, float volume, float pitch, long seed) {
emit("S " + pos(BlockPos.containing(x, y, z)) + " " + sound.value().location());
@@ -351,6 +353,28 @@ public final class VanillaBlockUpdateOracle {
return attributes;
}
@Override public net.minecraft.world.level.dimension.DimensionType dimensionType() { return type != null ? type : OVERWORLD_TYPE; }
/**
* ServerLevel.explode without the players to send the packet to: the
* ServerExplosion runs, then the explosion sound the client plays at
* the centre is logged.
*/
@Override public void explode(Entity source, net.minecraft.world.damagesource.DamageSource damageSource,
net.minecraft.world.level.ExplosionDamageCalculator calculator, double x, double y, double z, float r, boolean fire,
net.minecraft.world.level.Level.ExplosionInteraction type, net.minecraft.core.particles.ParticleOptions small,
net.minecraft.core.particles.ParticleOptions large, net.minecraft.util.random.WeightedList<net.minecraft.core.particles.ExplosionParticleInfo> blockParticles,
net.minecraft.core.Holder<SoundEvent> sound) {
java.util.function.Function<net.minecraft.world.level.gamerules.GameRule<Boolean>, net.minecraft.world.level.Explosion.BlockInteraction> destroy =
rule -> rules.get(rule) ? net.minecraft.world.level.Explosion.BlockInteraction.DESTROY_WITH_DECAY : net.minecraft.world.level.Explosion.BlockInteraction.DESTROY;
var interaction = switch (type) {
case NONE -> net.minecraft.world.level.Explosion.BlockInteraction.KEEP;
case BLOCK -> destroy.apply(GameRules.BLOCK_EXPLOSION_DROP_DECAY);
case MOB -> rules.get(GameRules.MOB_GRIEFING) ? destroy.apply(GameRules.MOB_EXPLOSION_DROP_DECAY) : net.minecraft.world.level.Explosion.BlockInteraction.KEEP;
case TNT -> destroy.apply(GameRules.TNT_EXPLOSION_DROP_DECAY);
case TRIGGER -> net.minecraft.world.level.Explosion.BlockInteraction.TRIGGER_BLOCK;
};
new net.minecraft.world.level.ServerExplosion(this, source, damageSource, calculator, new Vec3(x, y, z), r, fire, interaction).explode();
if (source == null || !source.isSilent()) emit("S " + pos(BlockPos.containing(x, y, z)) + " " + sound.value().location());
}
/** The overworld (fire in an obsidian frame lights a portal here). */
@Override public net.minecraft.resources.ResourceKey<net.minecraft.world.level.Level> dimension() { return dimensionKey != null ? dimensionKey : net.minecraft.world.level.Level.OVERWORLD; }
@Override public long getOverworldClockTime() { return DAY.totalTicks(); }
@@ -218,6 +218,19 @@ public final class VanillaDispenserOracle {
}
if (e.has("chest") && ent instanceof net.minecraft.world.entity.animal.equine.AbstractChestedHorse chested) chested.setChest(true);
if (e.has("loot") && ent instanceof Mob mob) mob.setCanPickUpLoot(true);
if (e.has("ground")) ent.setOnGround(true);
if (e.has("health") && ent instanceof LivingEntity living) {
living.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.MAX_HEALTH).setBaseValue(e.get("health").getAsDouble());
living.setHealth(e.get("health").getAsFloat());
}
if (e.has("knockback_resistance") && ent instanceof LivingEntity living) {
living.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.KNOCKBACK_RESISTANCE).setBaseValue(e.get("knockback_resistance").getAsDouble());
}
if (e.has("marker") && ent instanceof net.minecraft.world.entity.decoration.ArmorStand stand) {
Method marker = net.minecraft.world.entity.decoration.ArmorStand.class.getDeclaredMethod("setMarker", boolean.class);
marker.setAccessible(true);
marker.invoke(stand, true);
}
if (e.has("brown") && ent instanceof net.minecraft.world.entity.animal.cow.MushroomCow cow) {
Method variant = net.minecraft.world.entity.animal.cow.MushroomCow.class.getDeclaredMethod("setVariant", net.minecraft.world.entity.animal.cow.MushroomCow.Variant.class);
variant.setAccessible(true);
@@ -247,10 +260,24 @@ public final class VanillaDispenserOracle {
w.registries = ParityData.access;
w.server.loot.delegate = ParityData.loot;
VanillaBlockUpdateOracle.set(Level.class, w, "damageSources", new net.minecraft.world.damagesource.DamageSources(ParityData.access));
if (f.has("dim") && f.get("dim").getAsString().equals("nether")) {
// The Nether's dimension type and attributes (respawn anchors work, beds explode).
if (NETHER == null) NETHER = VanillaBlockUpdateOracle.loadDimensionType(net.minecraft.world.level.dimension.BuiltinDimensionTypes.NETHER);
w.type = NETHER;
w.dimensionKey = Level.NETHER;
w.attributes = net.minecraft.world.attribute.EnvironmentAttributeSystem.builder().addConstantLayer(NETHER.attributes()).build();
} else if (f.has("dim") && f.get("dim").getAsString().equals("end")) {
// The End's (beds explode, anchors do too).
if (END == null) END = VanillaBlockUpdateOracle.loadDimensionType(net.minecraft.world.level.dimension.BuiltinDimensionTypes.END);
w.type = END;
w.dimensionKey = Level.END;
w.attributes = net.minecraft.world.attribute.EnvironmentAttributeSystem.builder().addConstantLayer(END.attributes()).build();
}
if (f.has("rules")) {
for (var rule : f.getAsJsonObject("rules").entrySet()) {
if (rule.getKey().equals("tnt_explodes")) w.rules.set(GameRules.TNT_EXPLODES, rule.getValue().getAsBoolean(), null);
if (rule.getKey().equals("spawner_blocks_work")) w.rules.set(GameRules.SPAWNER_BLOCKS_WORK, rule.getValue().getAsBoolean(), null);
if (rule.getKey().equals("block_explosion_drop_decay")) w.rules.set(GameRules.BLOCK_EXPLOSION_DROP_DECAY, rule.getValue().getAsBoolean(), null);
}
}
if (f.has("items")) {
@@ -302,6 +329,10 @@ public final class VanillaDispenserOracle {
used = use(w, origin, f.getAsJsonObject("use"));
} else if (f.has("use_item")) {
used = useItem(w, origin, f.getAsJsonObject("use_item"));
} else if (f.has("respawn_at")) {
used = respawnAt(w, origin, f.getAsJsonObject("respawn_at"));
} else if (f.has("attack")) {
used = attack(w, f.getAsJsonObject("attack"), targets);
} else if (f.has("hopper")) {
// HopperBlockEntity.pushItemsTick, once.
var hopper = (net.minecraft.world.level.block.entity.HopperBlockEntity) w.getBlockEntity(origin);
@@ -379,6 +410,8 @@ public final class VanillaDispenserOracle {
result.add("rng " + w.rng.nextLong());
}
static net.minecraft.world.level.dimension.DimensionType NETHER, END;
/** The player of a "use" case: its main hand, game mode and the statistics it is awarded. */
static final class User extends net.minecraft.server.level.ServerPlayer {
VanillaBlockUpdateOracle.World world;
@@ -506,8 +539,15 @@ public final class VanillaDispenserOracle {
var advancements = (net.minecraft.server.PlayerAdvancements) VanillaBlockUpdateOracle.allocate.invoke(VanillaBlockUpdateOracle.unsafe, net.minecraft.server.PlayerAdvancements.class);
VanillaBlockUpdateOracle.set(net.minecraft.server.PlayerAdvancements.class, advancements, "activeTriggers", new HashMap<>());
VanillaBlockUpdateOracle.set(net.minecraft.server.level.ServerPlayer.class, player, "advancements", advancements);
// Standing three blocks south of the clicked block, looking down at it.
var at = net.minecraft.world.phys.Vec3.atBottomCenterOf(pos).add(0, 1, 3);
// Standing three blocks (or `distance`) south of the clicked block, looking down at it.
double distance = use.has("distance") ? use.get("distance").getAsDouble() : 3;
var at = net.minecraft.world.phys.Vec3.atBottomCenterOf(pos).add(0, 1, distance);
if (use.has("respawn")) {
var r = use.getAsJsonArray("respawn");
BlockPos point = new BlockPos(r.get(0).getAsInt(), r.get(1).getAsInt(), r.get(2).getAsInt());
player.setRespawnPosition(new net.minecraft.server.level.ServerPlayer.RespawnConfig(
net.minecraft.world.level.storage.LevelData.RespawnData.of(w.dimension(), point, 0.0F, 0.0F), false), false);
}
VanillaBlockUpdateOracle.set(Entity.class, player, "position", at);
VanillaBlockUpdateOracle.set(Entity.class, player, "blockPosition", BlockPos.containing(at));
VanillaBlockUpdateOracle.set(Entity.class, player, "xRot", 90f);
@@ -526,6 +566,172 @@ public final class VanillaDispenserOracle {
}
List<String> out = new ArrayList<>(player.stats);
out.add("held " + ParityData.canon(player.hand) + " using " + (player.using == null ? "-" : player.using));
var respawn = player.getRespawnConfig();
out.add("respawn " + (respawn == null ? "-" : respawn.respawnData().dimension().identifier() + " " + VanillaBlockUpdateOracle.pos(respawn.respawnData().pos())));
return out;
}
/**
* ServerPlayer.findRespawnAndUseSpawnBlock for a respawn point at `pos`
* (a respawn anchor, in the Nether or not): the position, the yaw that
* looks at the block, and the charge used (a block change).
*/
static List<String> respawnAt(VanillaBlockUpdateOracle.World w, BlockPos pos, JsonObject op) throws Exception {
var config = new net.minecraft.server.level.ServerPlayer.RespawnConfig(
net.minecraft.world.level.storage.LevelData.RespawnData.of(w.dimension(), pos, 0.0F, 0.0F), op.get("forced").getAsBoolean());
Method find = net.minecraft.server.level.ServerPlayer.class.getDeclaredMethod("findRespawnAndUseSpawnBlock",
ServerLevel.class, net.minecraft.server.level.ServerPlayer.RespawnConfig.class, boolean.class);
find.setAccessible(true);
var found = (Optional<?>) find.invoke(null, w, config, op.get("consume").getAsBoolean());
if (found.isEmpty()) return List.of("respawn none");
Object angle = found.get();
Method position = angle.getClass().getDeclaredMethod("position");
Method yaw = angle.getClass().getDeclaredMethod("yaw");
position.setAccessible(true);
yaw.setAccessible(true);
var p = (net.minecraft.world.phys.Vec3) position.invoke(angle);
return List.of("respawn " + num(p.x) + " " + num(p.y) + " " + num(p.z) + " " + Float.floatToRawIntBits((float) yaw.invoke(angle)));
}
/**
* The player of an "attack" case: a `ServerPlayer` with a place, a fall
* and a velocity, a stand-in connection and abilities.
*/
static final class Attacker extends net.minecraft.server.level.ServerPlayer {
VanillaBlockUpdateOracle.World world;
boolean creative, fallFlying;
ItemStack hand;
List<String> stats;
Attacker() {
super(null, null, null, null);
}
@Override public ServerLevel level() { return world; }
@Override public boolean hasInfiniteMaterials() { return creative; }
@Override public boolean isCreative() { return creative; }
@Override public boolean isSpectator() { return false; }
@Override public boolean isFallFlying() { return fallFlying; }
@Override public net.minecraft.world.phys.Vec3 getKnownMovement() { return getDeltaMovement(); }
@Override public EntityType<?> getType() { return EntityTypes.PLAYER; }
@Override public net.minecraft.core.Holder<EntityType<?>> typeHolder() { return EntityTypes.PLAYER.builtInRegistryHolder(); }
@Override public ItemStack getItemBySlot(EquipmentSlot slot) { return slot == EquipmentSlot.MAINHAND ? hand : ItemStack.EMPTY; }
@Override public ItemStack getItemInHand(net.minecraft.world.InteractionHand h) {
return h == net.minecraft.world.InteractionHand.MAIN_HAND ? hand : ItemStack.EMPTY;
}
@Override public void setItemInHand(net.minecraft.world.InteractionHand h, ItemStack stack) {
if (h == net.minecraft.world.InteractionHand.MAIN_HAND) hand = stack;
}
@Override public void awardStat(net.minecraft.stats.Stat<?> stat, int count) {
stats.add("stat " + User.key(stat) + " " + BuiltInRegistries.STAT_TYPE.getKey(stat.getType()) + " " + count);
}
}
/** The synched data `Entity`'s constructor defines (a player's air supply is 300). */
@SuppressWarnings({"unchecked", "rawtypes"})
static void defineData(Entity e) throws Exception {
var builder = new net.minecraft.network.syncher.SynchedEntityData.Builder(e);
Object[][] base = {{"DATA_SHARED_FLAGS_ID", (byte) 0}, {"DATA_AIR_SUPPLY_ID", 300}, {"DATA_CUSTOM_NAME_VISIBLE", false},
{"DATA_CUSTOM_NAME", Optional.empty()}, {"DATA_SILENT", false}, {"DATA_NO_GRAVITY", false}, {"DATA_POSE", Pose.STANDING},
{"DATA_TICKS_FROZEN", 0}};
for (Object[] d : base) {
Field f = Entity.class.getDeclaredField((String) d[0]);
f.setAccessible(true);
builder.define((net.minecraft.network.syncher.EntityDataAccessor) f.get(null), d[1]);
}
Method define = Entity.class.getDeclaredMethod("defineSynchedData", net.minecraft.network.syncher.SynchedEntityData.Builder.class);
define.setAccessible(true);
define.invoke(e, builder);
VanillaBlockUpdateOracle.set(Entity.class, e, "entityData", builder.build());
}
/** A connection to no client: the motion packets a smash sends go nowhere. */
static final class Silent extends net.minecraft.server.network.ServerGamePacketListenerImpl {
Silent() { super(null, null, null, null); }
@Override public void send(net.minecraft.network.protocol.Packet<?> packet) { }
}
/**
* A player hit on the first target with the case's item, as
* `Player.attack` and `itemAttackInteraction` run it after the attack
* strength scaled the base damage to `base`: the item's damage bonus
* (`MaceItem.getAttackDamageBonus`) and damage source, the target's real
* `hurtServer` (armor with the weapon's Breach), then `hurtEnemy` (the
* mace's smash), the post-attack enchantments (Wind Burst) and
* `postHurtEnemy` (the fall reset and the weapon's wear). Every target's
* health and velocity, the player's velocity, fall, impulse and the
* statistics follow.
*/
static List<String> attack(VanillaBlockUpdateOracle.World w, JsonObject op, List<Entity> targets) throws Exception {
if (VanillaBlockUpdateOracle.Server.players == null) {
VanillaBlockUpdateOracle.Server.players = (Ops) VanillaBlockUpdateOracle.allocate.invoke(VanillaBlockUpdateOracle.unsafe, Ops.class);
}
Attacker player = (Attacker) VanillaBlockUpdateOracle.allocate.invoke(VanillaBlockUpdateOracle.unsafe, Attacker.class);
player.world = w;
player.creative = op.get("creative").getAsBoolean();
player.fallFlying = op.get("fall_flying").getAsBoolean();
player.hand = stack(op.get("item").getAsString());
player.stats = new ArrayList<>();
var abilities = new net.minecraft.world.entity.player.Abilities();
abilities.invulnerable = abilities.instabuild = abilities.mayfly = player.creative;
abilities.flying = op.get("flying").getAsBoolean();
VanillaBlockUpdateOracle.set(net.minecraft.world.entity.player.Player.class, player, "abilities", abilities);
var advancements = (net.minecraft.server.PlayerAdvancements) VanillaBlockUpdateOracle.allocate.invoke(VanillaBlockUpdateOracle.unsafe, net.minecraft.server.PlayerAdvancements.class);
VanillaBlockUpdateOracle.set(net.minecraft.server.PlayerAdvancements.class, advancements, "activeTriggers", new HashMap<>());
VanillaBlockUpdateOracle.set(net.minecraft.server.level.ServerPlayer.class, player, "advancements", advancements);
player.connection = (Silent) VanillaBlockUpdateOracle.allocate.invoke(VanillaBlockUpdateOracle.unsafe, Silent.class);
defineData(player);
player.setId(w.getNextEntityId());
VanillaBlockUpdateOracle.set(LivingEntity.class, player, "attributes",
new net.minecraft.world.entity.ai.attributes.AttributeMap(net.minecraft.world.entity.player.Player.createAttributes().build()));
player.setUUID(new UUID(0L, 1L));
VanillaBlockUpdateOracle.set(net.minecraft.world.entity.player.Player.class, player, "gameProfile",
new com.mojang.authlib.GameProfile(new UUID(0L, 1L), "Player"));
var p = op.getAsJsonArray("player");
var at = new net.minecraft.world.phys.Vec3(p.get(0).getAsDouble(), p.get(1).getAsDouble(), p.get(2).getAsDouble());
VanillaBlockUpdateOracle.set(Entity.class, player, "position", at);
VanillaBlockUpdateOracle.set(Entity.class, player, "blockPosition", BlockPos.containing(at));
var standing = EntityTypes.PLAYER.getDimensions();
VanillaBlockUpdateOracle.set(Entity.class, player, "dimensions", standing);
VanillaBlockUpdateOracle.set(Entity.class, player, "eyeHeight", standing.eyeHeight());
player.setBoundingBox(standing.makeBoundingBox(at));
var m = op.getAsJsonArray("motion");
player.setDeltaMovement(m.get(0).getAsDouble(), m.get(1).getAsDouble(), m.get(2).getAsDouble());
player.fallDistance = op.get("fall").getAsDouble();
if (op.has("impact")) {
var i = op.getAsJsonArray("impact");
player.currentImpulseImpactPos = new net.minecraft.world.phys.Vec3(i.get(0).getAsDouble(), i.get(1).getAsDouble(), i.get(2).getAsDouble());
}
// The player stands in the level, for the bursts that push it.
w.entities.add(player);
LivingEntity target = (LivingEntity) targets.get(0);
ItemStack weapon = player.hand;
var source = weapon.getDamageSource(player);
float base = op.get("base").getAsFloat();
float bonus = weapon.getItem().getAttackDamageBonus(target, base, source);
boolean hurt = target.hurtServer(w, source, base + bonus);
if (hurt) {
boolean weaponHit = weapon.hurtEnemy(target, player);
net.minecraft.world.item.enchantment.EnchantmentHelper.doPostAttackEffectsWithItemSource(w, target, source, weapon);
if (weaponHit) weapon.postHurtEnemy(target, player);
}
w.entities.remove(player);
List<String> out = new ArrayList<>(player.stats);
out.add("attack bonus=" + num(bonus) + " source=" + source.typeHolder().getRegisteredName() + " hurt=" + hurt);
for (int i = 0; i < targets.size(); i++) {
Entity e = targets.get(i);
var v = e.getDeltaMovement();
String health = e instanceof LivingEntity living && !(e instanceof net.minecraft.world.entity.decoration.ArmorStand) ? num(living.getHealth()) : "-";
out.add("V " + i + " " + health + " " + num(v.x) + " " + num(v.y) + " " + num(v.z));
}
var v = player.getDeltaMovement();
var impact = player.currentImpulseImpactPos;
Field grace = LivingEntity.class.getDeclaredField("currentImpulseContextResetGraceTime");
grace.setAccessible(true);
Field extra = net.minecraft.server.level.ServerPlayer.class.getDeclaredField("spawnExtraParticlesOnFall");
extra.setAccessible(true);
out.add("P " + num(v.x) + " " + num(v.y) + " " + num(v.z) + " fall=" + num(player.fallDistance)
+ " impact=" + (impact == null ? "-" : num(impact.x) + "," + num(impact.y) + "," + num(impact.z))
+ " grace=" + grace.getInt(player) + " extra=" + extra.getBoolean(player));
out.add("held " + ParityData.canon(player.hand));
return out;
}
+144
View File
@@ -0,0 +1,144 @@
#!/usr/bin/env python3
"""Check LAN shutdown when leaving a singleplayer world through the pause menu.
Requires a built horizon-client, prepared resources and a display on Unix:
xvfb-run -a python3 tools/test_lan_lifecycle.py --client target/fast/horizon-client
Worlds and settings are created in a temporary directory.
"""
import argparse
import json
import os
from pathlib import Path
import socket
import subprocess
import tempfile
import time
ROOT = Path(__file__).resolve().parents[1]
GROUP = '224.0.2.60'
DISCOVERY_PORT = 4445
def command(endpoint, line):
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as connection:
connection.settimeout(60)
connection.connect(str(endpoint))
connection.sendall((line + '\n').encode())
with connection.makefile('r') as reply:
result = json.loads(reply.readline())
assert 'error' not in result, (line, result)
return result
def wait_for(endpoint, line, predicate, timeout=60):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
result = command(endpoint, line)
except (FileNotFoundError, ConnectionRefusedError):
time.sleep(0.1)
continue
if predicate(result):
return result
time.sleep(0.1)
raise AssertionError(f'timed out waiting for {line}')
def announcement(scanner, port, timeout):
deadline = time.monotonic() + timeout
marker = f'[AD]{port}[/AD]'.encode()
while time.monotonic() < deadline:
scanner.settimeout(max(0.001, deadline - time.monotonic()))
try:
message, _ = scanner.recvfrom(4096)
except socket.timeout:
return False
if marker in message:
return True
return False
def scenario(endpoint, scanner):
wait_for(endpoint, 'screen', lambda value: value['screen'] == 'title')
command(endpoint, 'open LanLifecycle 0 creative')
wait_for(endpoint, 'status', lambda value: value['player'] is not None
and value['pending_chunks'] == 0)
assert command(endpoint, 'lan status') == {'open': False}
port = 0
for _ in range(2):
port = command(endpoint, f'lan open {port}')['port']
with socket.create_connection(('127.0.0.1', port), timeout=2):
pass
assert announcement(scanner, port, 5), 'LAN world was not advertised'
command(endpoint, 'key esc tap')
screen = wait_for(endpoint, 'screen', lambda value: any(
button['label'] == 'Save and Quit to Title' for button in value['buttons']))
assert screen['screen'] == 'paused', screen
command(endpoint, 'click-button Save and Quit to Title')
wait_for(endpoint, 'screen', lambda value: value['screen'] == 'title')
assert command(endpoint, 'lan status') == {'open': False}, 'LAN stayed open after leaving'
try:
connection = socket.create_connection(('127.0.0.1', port), timeout=2)
except ConnectionRefusedError:
pass
else:
connection.close()
raise AssertionError('LAN still accepts connections after leaving')
# Discard datagrams queued before shutdown, then listen for more than
# two announcement intervals (the pinger sends every 1.5 seconds).
scanner.setblocking(False)
try:
while True:
scanner.recvfrom(4096)
except BlockingIOError:
pass
assert not announcement(scanner, port, 3.5), 'LAN kept advertising after leaving'
command(endpoint, 'open LanLifecycle')
wait_for(endpoint, 'status', lambda value: value['player'] is not None
and value['pending_chunks'] == 0)
assert command(endpoint, 'lan status') == {'open': False}, 'LAN reopened with the world'
command(endpoint, 'lan open 0')
command(endpoint, 'quit')
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--client', type=Path, required=True)
parser.add_argument('--resources', type=Path, default=ROOT / '.local/horizon-client/26.3')
args = parser.parse_args()
client, resources = args.client.resolve(), args.resources.resolve()
with tempfile.TemporaryDirectory(prefix='horizon-lan-') as directory:
work = Path(directory)
endpoint = work / 'control.sock'
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as scanner:
scanner.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
scanner.bind(('', DISCOVERY_PORT))
scanner.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP,
socket.inet_aton(GROUP) + socket.inet_aton('0.0.0.0'))
with (work / 'client.log').open('w+') as log:
process = subprocess.Popen([
str(client), '--resources', str(resources), '--render-distance', '2',
'--test-terrain', '--control-socket', str(endpoint), '--timeout-seconds', '180',
], cwd=work, env=dict(os.environ, HORIZON_HOME=str(work), HORIZON_NO_AUDIO='1',
HORIZON_MENU_STYLE='classic'),
stdout=log, stderr=subprocess.STDOUT)
try:
scenario(endpoint, scanner)
assert process.wait(timeout=20) == 0, 'client exited unsuccessfully'
except Exception:
log.seek(0)
print('\n'.join(log.read().splitlines()[-20:]))
raise
finally:
if process.poll() is None:
process.terminate()
try:
process.wait(timeout=10)
except subprocess.TimeoutExpired:
process.kill()
process.wait(timeout=10)
print('LAN lifecycle passed: leaving stops hosting and discovery; reopening stays private')
if __name__ == '__main__':
main()
+204
View File
@@ -0,0 +1,204 @@
"""Compare a player's melee hit with a mace (and other weapons) with vanilla's.
Every case has a stone floor, a target mob standing on it or hanging in the
air (health raised so no hit kills it, sometimes in armor), other mobs and
armor stands around it, and a player near the target holding a mace with
Density, Breach, Wind Burst and Unbreaking in any mix, or a sword, an axe, a
stick or nothing. The player has fallen some distance (sometimes gliding or
flying), moves, and may still have the impact point of an earlier impulse.
Vanilla runs, over the headless level of the dispenser harness
(`VanillaDispenserOracle.attack`), the steps of `Player.attack` after the
attack strength scaled the base damage: `Item.getAttackDamageBonus`
(`MaceItem`'s smash bonus with Density), the item's damage source
(`mace_smash` or `player_attack`), the target's real `hurtServer` (armor
thinned by Breach in `CombatRules.getDamageAfterAbsorb`), then
`itemAttackInteraction`: `ItemStack.hurtEnemy` (`MaceItem.hurtEnemy`: the
stopped fall, the waived fall damage, the smash sounds, the dust-pillar level
event and the knockback around the target), the post-attack enchantments
(Wind Burst's `ExplodeEffect` on the player) and `postHurtEnemy` (the fall
reset and the weapon's wear with Unbreaking). Horizon runs the same steps
through the helpers `Game::attack` uses (`smash_damage_bonus`,
`hurt_by_player`, `weapon_hit`) in a headless game
(`HORIZON_DISPENSE_FIXTURE`). Both print every target's health and
velocity, the player's velocity, fall distance, impulse impact and grace
time and its landing-particle flag, sounds, level and game events, the used
statistic, the held stack and the level random afterwards.
"""
import json
import math
import os
import random
try:
from . import block_update_harness as h, lab, test_dispenser_parity as d, test_rust_parity as base
except ImportError:
import block_update_harness as h
import lab
import test_dispenser_parity as d
import test_rust_parity as base
TARGETS = ['pig', 'cow', 'sheep', 'zombie', 'husk', 'skeleton', 'zombie', 'pig']
AROUND = ['pig', 'cow', 'zombie', 'sheep', 'armor_stand']
ARMOR = ['iron', 'diamond', 'golden', 'chainmail', 'leather']
FALLS = [0.0, 0.5, 1.0, 1.5, 1.5000001, 2.0, 2.75, 3.0, 3.25, 5.0, 5.0001, 6.5, 8.0, 8.5, 12.0, 25.3, 60.0]
def stack(item, enchantments=None, damage=0):
components = []
if enchantments:
levels = ','.join(f'"minecraft:{e}":{lvl}' for e, lvl in enchantments.items())
components.append('"minecraft:enchantments":{%s}' % levels)
if damage:
components.append(f'"minecraft:damage":{damage}')
extra = ',components:{%s}' % ','.join(components) if components else ''
return '{id:"minecraft:%s",count:1%s}' % (item, extra)
def weapon(rng):
roll = rng.random()
if roll < 0.75:
enchantments = {}
for name, top in [('density', 5), ('breach', 4), ('wind_burst', 3), ('unbreaking', 3)]:
if rng.random() < 0.35:
enchantments[name] = rng.randint(1, top)
return stack('mace', enchantments, rng.choice([0, 0, 0, 7, 300]))
if roll < 0.85:
return stack(rng.choice(['diamond_sword', 'iron_axe', 'stone_pickaxe']),
{'breach': 2} if rng.random() < 0.2 else None, rng.choice([0, 0, 10]))
return rng.choice([stack('stick'), '-'])
def cases(facts, count, seed):
rng = random.Random(seed)
states = d.States(facts)
floors = [states.get(b) for b in ['stone', 'grass_block', 'dirt', 'sand', 'oak_planks']]
for n in range(count):
case = {**h.environment(rng), 'pos': [0, 0, 0]}
case.pop('raining', None)
case.pop('thundering', None)
floor = rng.choice(floors)
case['cells'] = [[x, -1, z, floor] for x in range(-6, 7) for z in range(-6, 7)]
if rng.random() < 0.2:
# A wall the burst and the dust have to get past.
wall = states.get(rng.choice(['stone', 'glass', 'oak_planks']))
x = rng.choice([-3, -2, 2, 3])
case['cells'] += [[x, y, z, wall] for y in range(0, 3) for z in range(-2, 3)]
item = weapon(rng)
wind = 'wind_burst' in item
grounded = rng.random() < 0.75
tx, tz = rng.uniform(-0.5, 0.5), rng.uniform(-0.5, 0.5)
ty = 0.0 if grounded else rng.choice([0.5, 1.25, 2.0])
target = {'type': 'minecraft:' + rng.choice(TARGETS), 'pos': [tx, ty, tz], 'yaw': rng.uniform(-180, 180),
'health': 1000.0}
if grounded:
target['ground'] = True
if target['type'] in ('minecraft:zombie', 'minecraft:husk', 'minecraft:skeleton') and rng.random() < 0.6:
material = rng.choice(ARMOR)
target['equip'] = {'chest': d.plain(f'{material}_chestplate')}
if rng.random() < 0.5:
target['equip']['head'] = d.plain(f'{material}_helmet')
if rng.random() < 0.15:
target['knockback_resistance'] = rng.choice([0.25, 0.5, 1.0])
entities = [target]
for _ in range(rng.choice([0, 1, 2, 3, 5])):
kind = rng.choice(AROUND)
near = rng.random() < 0.8
spread = 3.2 if near else 5.0
e = {'type': 'minecraft:' + kind, 'pos': [tx + rng.uniform(-spread, spread), rng.choice([0.0, 0.0, 0.5, 1.0]),
tz + rng.uniform(-spread, spread)], 'yaw': rng.uniform(-180, 180)}
if kind == 'armor_stand':
# A marker is spared by the smash; Wind Burst's explosion would
# need its zero-size box.
if not wind and rng.random() < 0.4:
e['marker'] = True
else:
e['health'] = 1000.0
if rng.random() < 0.2:
e['knockback_resistance'] = rng.choice([0.4, 1.0])
if e['pos'][1] == 0.0 and rng.random() < 0.8:
e['ground'] = True
entities.append(e)
case['entities'] = entities
angle = rng.uniform(0, 6.283)
reach = rng.uniform(0.6, 2.8)
px, pz = tx + math.cos(angle) * reach, tz + math.sin(angle) * reach
py = ty + rng.choice([0.0, 0.3, 1.0, 1.7, 2.5])
fall = rng.choice(FALLS) if rng.random() < 0.7 else round(rng.uniform(0, 30), 3)
attack = {'item': item, 'creative': rng.random() < 0.15, 'player': [px, py, pz],
'motion': [rng.uniform(-0.3, 0.3), -rng.uniform(0, 2.5), rng.uniform(-0.3, 0.3)],
'fall': fall, 'fall_flying': rng.random() < 0.08, 'flying': rng.random() < 0.04,
'base': round(rng.uniform(1.2, 7.0), 3)}
if rng.random() < 0.3:
attack['impact'] = [px + rng.uniform(-1, 1), py + rng.choice([-3.0, -0.5, 0.0, 2.0]), pz + rng.uniform(-1, 1)]
case['attack'] = attack
case['items'] = []
case['mode'] = 'dispense'
yield case
def kind(case):
item = case['attack']['item']
name = item.split('"')[1].split(':')[1] if item != '-' else 'empty hand'
smash = case['attack']['fall'] > 1.5 and not case['attack']['fall_flying']
if name == 'mace':
name += ' smash' if smash else ' hit'
if 'wind_burst' in item:
name += ' with wind burst'
return name
def main():
parser = h.argument_parser(__doc__)
args = parser.parse_args()
if args.count == 40000:
args.count = 3000
lock, jars, libraries = base.verify_artifacts()
facts = h.load_facts()
resources = lab.LOCAL / 'horizon-client' / lock['minecraft']['version']
work = lab.LOCAL / 'mace-parity'
work.mkdir(parents=True, exist_ok=True)
all_cases = list(cases(facts, args.count, args.seed))
(work / 'cases.jsonl').write_text(''.join(json.dumps(case) + '\n' for case in all_cases))
classes = work / 'classes'
classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
java_root = lab.ROOT / 'mods/horizon/src/test/java'
d.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-sourcepath', str(java_root), '-nowarn',
'-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaDispenserOracle.java')])
d.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaDispenserOracle',
str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
d.run(['cargo', 'build', '-q', '--release', '-p', 'horizon-client', '--bin', 'horizon-client'], cwd=lab.ROOT,
env={**os.environ, 'CARGO_BUILD_JOBS': os.environ.get('CARGO_BUILD_JOBS', '3')})
d.run([str(lab.cargo_target() / 'release/horizon-client'), '--resources', str(resources)], cwd=work,
env={**os.environ, 'HORIZON_DISPENSE_FIXTURE': f'{work / "cases.jsonl"},{work / "rust.txt"}', 'HORIZON_NO_AUDIO': '1'})
ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix) + ('D ',)
native = h.split_cases((work / 'native.txt').read_text(), ignore)
rust = h.split_cases((work / 'rust.txt').read_text(), ignore)
assert len(native) == len(rust) == len(all_cases), (len(native), len(rust), len(all_cases))
groups, errors = {}, {}
smashed = burst = 0
for case, a, b in zip(all_cases, native, rust):
if a and a[0].startswith('error'):
errors.setdefault(a[0], []).append(case)
continue
smashed += any('source=minecraft:mace_smash hurt=true' in line for line in a)
burst += any(line.endswith('minecraft:entity.wind_charge.wind_burst') for line in a)
if not d.same(a, b):
groups.setdefault(kind(case), []).append((case, a, b))
for name, entries in sorted(errors.items(), key=lambda e: -len(e[1])):
print(f'oracle error x{len(entries)}: {name}')
for name, entries in sorted(groups.items(), key=lambda e: -len(e[1])):
print(f'{name}: {len(entries)} differing')
for case, a, b in entries[:args.show]:
print(' case entities=' + json.dumps(case['entities']) + ' attack=' + json.dumps(case['attack']) + f' seed={case["seed"]}')
print(' native ' + ' | '.join(sorted(a)))
print(' rust ' + ' | '.join(sorted(b)))
total = sum(len(v) for v in groups.values())
skipped = sum(len(v) for v in errors.values())
print(f'{len(all_cases) - total - skipped}/{len(all_cases) - skipped} cases match ({skipped} oracle errors); '
f'vanilla smashed in {smashed} and burst in {burst}')
h.finish(total + skipped)
if __name__ == '__main__':
main()
+269
View File
@@ -0,0 +1,269 @@
#!/usr/bin/env python3
"""Horizon's client joins vanilla's online-mode server, with no real account.
A small mock of the Minecraft services (dev only: the discovery document and
the session service's join and hasJoined endpoints) stands in for Mojang's.
The pinned vanilla 26.3 dedicated server runs in online mode and finds the
mock through authlib's own override, `-Dminecraft.api.discovery.host`;
Horizon's client finds it through `HORIZON_API_DISCOVERY` and signs in with a
session file holding a mock token, as the launcher hands it over.
The client must answer the server's encryption request: generate the shared
secret, hash the server id with it and the server's public key, join through
the mock, RSA-wrap the secret and the challenge for the server, then encrypt
the connection with AES/CFB8. The server decrypts the secret with its private
key, computes the hash itself and asks the mock whether the player joined
with that hash: so vanilla's own code checks the hash, the RSA wrapping and
the cipher. Then the client plays as in the dedicated-server harness (stands
in the world with its chunks, chats, runs /list, leaves).
Also checked, with vanilla's messages:
- a token the session service rejects ("Failed to log in: Invalid session");
- a join the session service forgets (the server: "Failed to verify username!");
- no account at all (the client refuses before joining).
Chat is unsigned here: the mock serves no Mojang public keys, so the server
can't validate profile keys and doesn't enforce secure chat.
"""
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import os
from pathlib import Path
import platform
import shutil
import subprocess
import sys
import threading
import urllib.parse
try:
from . import lab, oracle_harness as oh, test_rust_parity as base
from .test_dedicated_server_parity import Server, free_port
except ImportError:
import lab
import oracle_harness as oh
import test_rust_parity as base
from test_dedicated_server_parity import Server, free_port
NAME = 'online-mode-parity'
PLAYER = 'Tester'
PLAYER_UUID = '5f3c1e6a2b9d4c7e8a1f0b2c3d4e5f60'
GOOD, FORGET, BAD = 'mock-token-good', 'mock-token-forget', 'mock-token-rejected'
PROPERTIES = {
'online-mode': 'true',
'white-list': 'false',
'level-seed': '12345',
'view-distance': '4',
'simulation-distance': '4',
'spawn-protection': '0',
'max-players': '5',
'pause-when-empty-seconds': '-1',
}
def dashed(u):
return f'{u[:8]}-{u[8:12]}-{u[12:16]}-{u[16:20]}-{u[20:]}'
class Services:
"""The mock session service. Records what was asked, never the tokens."""
def __init__(self):
self.joined = {}
self.log = []
self.lock = threading.Lock()
services = self
class Handler(BaseHTTPRequestHandler):
def log_message(self, *args):
pass
def reply(self, status, body=None):
data = b'' if body is None else json.dumps(body).encode()
self.send_response(status)
if body is not None:
self.send_header('Content-Type', 'application/json')
self.send_header('Content-Length', str(len(data)))
self.end_headers()
self.wfile.write(data)
def do_GET(self):
url = urllib.parse.urlparse(self.path)
query = dict(urllib.parse.parse_qsl(url.query))
if url.path == '/minecraft/client':
return self.reply(200, services.discovery())
if url.path == '/session/minecraft/hasJoined':
with services.lock:
ok = services.joined.get(query.get('username')) == query.get('serverId')
services.log.append(('verify', query.get('username'), query.get('serverId'), ok))
if ok:
return self.reply(200, {'id': PLAYER_UUID, 'name': query['username'], 'properties': []})
return self.reply(204)
self.reply(404, {'error': 'NotFound', 'path': url.path})
def do_POST(self):
body = json.loads(self.rfile.read(int(self.headers.get('Content-Length', 0))) or b'{}')
if self.path != '/session/minecraft/join':
return self.reply(404, {'error': 'NotFound'})
token, profile, server_id = body.get('accessToken'), body.get('selectedProfile'), body.get('serverId')
accepted = token in (GOOD, FORGET) and profile == PLAYER_UUID
with services.lock:
services.log.append(('join', profile, server_id, accepted))
if token == GOOD and accepted:
services.joined[PLAYER] = server_id
if not accepted:
return self.reply(403, {'error': 'ForbiddenOperationException', 'errorMessage': 'Invalid token'})
self.reply(204)
self.server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
self.url = f'http://127.0.0.1:{self.server.server_address[1]}'
threading.Thread(target=self.server.serve_forever, daemon=True).start()
def discovery(self):
def endpoints(**names):
return {'endpoints': {k: {'uri': self.url + v} for k, v in names.items()}}
return {'environment': 'mock', 'product': 'minecraft', 'discovery': {
'authentication': endpoints(getPublicKeys='/publickeys'),
'session': endpoints(join='/session/minecraft/join', verify='/session/minecraft/hasJoined',
getProfileById='/session/minecraft/profile/{profileId}'),
'player': {'endpoints': {}},
'profiles': {'endpoints': {'getTexture': {'validUris': [self.url + '/texture/{textureId}']}}},
'telemetry': {'endpoints': {}},
}}
def take_log(self):
with self.lock:
log, self.log = self.log, []
return log
def stop(self):
self.server.shutdown()
def session_file(directory, token):
"""What the launcher writes: owner-only, read once by the game."""
path = directory / 'session.json'
path.unlink(missing_ok=True)
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
with os.fdopen(fd, 'w') as f:
json.dump({'name': PLAYER, 'uuid': dashed(PLAYER_UUID), 'access_token': token, 'user_type': 'msa'}, f)
return path
def run_client(binary, build, port, label, token, discovery):
directory = build / f'client-{label}'
shutil.rmtree(directory, ignore_errors=True)
directory.mkdir()
report = directory / 'report.json'
env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_NET_REPORT=str(report), HORIZON_API_DISCOVERY=discovery)
command = [binary, '--resources', lab.LOCAL / 'horizon-client/26.3', '--render-distance', 2,
'--server', f'127.0.0.1:{port}', '--name', PLAYER]
if token:
command += ['--session-file', session_file(directory, token)]
with (build / f'client-{label}.log').open('w') as log:
subprocess.run([str(c) for c in command], cwd=directory, env=env, stdout=log, stderr=subprocess.STDOUT,
timeout=300, check=True)
got = json.loads(report.read_text())
got['session file left'] = (directory / 'session.json').exists()
return got
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)
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')
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
services = Services()
discovery = services.url + '/minecraft/client'
port = free_port()
directory = build / 'server'
shutil.rmtree(directory, ignore_errors=True)
directory.mkdir()
props = dict(PROPERTIES, **{'server-port': str(port)})
(directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()))
(directory / 'eula.txt').write_text('eula=true\n')
command = ['java', '-Xmx2g', '-Duser.timezone=UTC', f'-Dminecraft.api.discovery.host={discovery}',
'-cp', dependencies, 'net.minecraft.server.Main', 'nogui']
server = Server(command, directory, 'vanilla-online')
checks = []
def check(label, actual, expected):
checks.append(f'{label}: ' + ('ok' if actual == expected else f'expected {expected!r}, got {actual!r}'))
try:
server.wait_for(r'Done \(', timeout=600)
services.take_log()
# 1. Signed in: the full encrypted handshake, then play.
got = run_client(binary, build, port, 'signed-in', GOOD, discovery)
server.wait_for(r'Tester left the game', timeout=30)
log = services.take_log()
joins = [e for e in log if e[0] == 'join']
verifies = [e for e in log if e[0] == 'verify']
check('signed-in: connected throughout', got['error'], None)
check('signed-in: joined the session service once', [(e[1], e[3]) for e in joins], [(PLAYER_UUID, True)])
check('signed-in: server verified the same hash',
[(e[1], e[2], e[3]) for e in verifies], [(PLAYER, joins[0][2] if joins else None, True)])
check('signed-in: own chat shown', any('<Tester> hello from the horizon client' in c for c in got['chat']), True)
check('signed-in: /list reply shown',
any('There are 1 of a max of 5 players online: Tester' in c for c in got['chat']), True)
check('signed-in: chunks received', got['chunks'] > 0, True)
check('signed-in: session file deleted', got['session file left'], False)
lines = '\n'.join(server.lines)
check('signed-in: server log', [k for k in [f'UUID of player Tester is {dashed(PLAYER_UUID)}',
'Tester joined the game',
'<Tester> hello from the horizon client',
'Tester left the game'] if k in lines], [
f'UUID of player Tester is {dashed(PLAYER_UUID)}', 'Tester joined the game',
'<Tester> hello from the horizon client', 'Tester left the game'])
# 2. A token the session service rejects: vanilla's message, no key sent.
mark = len(server.lines)
got = run_client(binary, build, port, 'rejected', BAD, discovery)
check('rejected token: client message', got['error'],
'disconnected: Failed to log in: Invalid session (Try restarting your game and the launcher)')
check('rejected token: no verification', [e[0] for e in services.take_log()], ['join'])
# 3. The session service forgets the join: the server refuses the player.
got = run_client(binary, build, port, 'forgotten', FORGET, discovery)
server.wait_for(r'Failed to verify username', timeout=30)
check('forgotten join: client message', got['error'], 'disconnected: Failed to verify username!')
check('forgotten join: server verified and refused',
[(e[0], e[3]) for e in services.take_log()], [('join', True), ('verify', False)])
# 4. No account: refused by the client before anything is sent to the services.
got = run_client(binary, build, port, 'no-account', None, discovery)
check('no account: client message', got['error'] or '', 'disconnected: This server is in online mode. '
'Sign in with your Microsoft account in the Horizon launcher to join it.')
check('no account: no service calls', services.take_log(), [])
check('no player joined after the first', 'joined the game' in '\n'.join(server.lines[mark:]), False)
finally:
server.stop()
services.stop()
for line in checks:
print(line)
failed = [c for c in checks if not c.endswith(': ok')]
if failed:
raise AssertionError(f'{len(failed)} of {len(checks)} checks failed (logs in {build})')
lab.write_json(report, dict(
schema=1, minecraft=lock['minecraft']['version'], platform=platform.platform(),
java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0], checks=len(checks),
scope='Online-mode login against vanilla\'s dedicated server and a mock session service: server hash, '
'RSA key packet, AES/CFB8, session join and verify, play; rejected token, forgotten join, no account.'))
print(f'online mode: {len(checks)} checks ok')
if __name__ == '__main__':
try:
main()
except AssertionError as error:
sys.exit(f'{NAME}: {error}')
+147 -9
View File
@@ -1,7 +1,8 @@
#!/usr/bin/env python3
"""Compare a player's right click on a block with vanilla's, for items that are
both food and blocks (sweet and glow berries, carrots, potatoes), for sweet
berry bushes and for spawn eggs used on a monster spawner.
berry bushes, for spawn eggs used on a monster spawner, for respawn anchors and
for beds in the Nether and the End.
Every case has a block at the origin, something above it, and a player three
blocks south, survival or creative, hungry or full, sneaking or not, who
@@ -11,12 +12,21 @@ harness (`VanillaDispenserOracle.useItem`): the block's `useItemOn` and
`useWithoutItem` (picking a bush's berries, `SweetBerryBushBlock.useItemOn`
passing bone meal on), then `ItemStack.useOn` (`BlockItem.place` with its
`mayPlaceOn` rules, `BoneMealItem.useOn`, eating a consumable that could
not be placed, and `SpawnEggItem.useOn` setting a spawner's mob). Horizon runs
not be placed, and `SpawnEggItem.useOn` setting a spawner's mob). Respawn
anchors are charged with glowstone, set the respawn point in the Nether and
explode elsewhere (`RespawnAnchorBlock`, through the stand-in level's real
`ServerExplosion`, with water at the anchor). Respawn cases call
`ServerPlayer.findRespawnAndUseSpawnBlock` on an anchor among blocks
(`RespawnAnchorBlock.findStandUpPosition` through `DismountHelper`): the
position, the yaw that faces the anchor and the charge it uses. Beds and straw
beds clicked (head or foot, whole or broken) in the Nether and the End blow up
or fall apart (`AbstractBedBlock.useWithoutItem` under the dimension's
`bed_rule`: `BedBlock.destroyOnUse`, `StrawBedBlock.destroyBed`). Horizon runs
`use_item_as_player` on that hit in a headless game
(`HORIZON_DISPENSE_FIXTURE`). Both print block changes, dropped items,
level events, sounds, game events, the used statistic, the held stack, the
item the player started using, spawners' next spawn data, potentials and
delay, system messages and the level random afterwards.
(`HORIZON_DISPENSE_FIXTURE`). Both print block changes, dropped items, level
events, sounds, game events, the used statistic, the held stack, the item the
player started using, spawners' next spawn data, potentials and delay, the
player's respawn point, system messages and the level random afterwards.
"""
import json
import os
@@ -37,6 +47,107 @@ ITEMS = ['sweet_berries', 'sweet_berries', 'sweet_berries', 'glow_berries', 'car
# What is in the way above the clicked block.
ABOVE = ['air'] * 8 + ['short_grass', 'snow', 'stone', 'water', 'dead_bush', 'fern']
EGGS = ['zombie', 'skeleton', 'spider', 'cave_spider', 'pig', 'creeper', 'blaze', 'ghast', 'villager', 'bee', 'cod']
# What stands around an anchor that explodes.
AROUND = ['stone', 'dirt', 'oak_planks', 'cobblestone', 'glass', 'obsidian', 'netherrack', 'water', 'tnt', 'oak_log',
'grass_block', 'soul_sand', 'gravel', 'crying_obsidian']
STAND = ['air'] * 6 + ['stone', 'stone', 'oak_slab', 'snow', 'lava', 'magma_block', 'fire', 'cactus', 'water',
'ladder', 'oak_trapdoor', 'short_grass', 'white_carpet', 'campfire', 'sweet_berry_bush',
'oak_fence', 'powder_snow', 'farmland', 'soul_sand', 'cobweb', 'end_portal']
def respawn_case(rng, states, case):
"""Respawning at an anchor with blocks around it."""
charges = rng.choice([0, 1, 1, 2, 4])
cells = [[0, 0, 0, states.get('respawn_anchor', charges=str(charges))]]
for dy in (-2, -1, 0, 1, 2):
for dx in range(-1, 2):
for dz in range(-1, 2):
if (dx, dy, dz) == (0, 0, 0):
continue
if dy == -1 or dy == -2:
name = rng.choice(['stone'] * 6 + STAND)
else:
name = rng.choice(['air'] * 3 + STAND)
if name == 'air':
continue
state = states.any(rng, name) if name in ('oak_trapdoor', 'oak_slab', 'snow', 'campfire', 'water', 'ladder') else states.get(name)
cells.append([dx, dy, dz, state])
if rng.random() < 0.6:
case['dim'] = 'nether'
case['respawn_at'] = {'forced': rng.random() < 0.2, 'consume': rng.random() < 0.8}
case['cells'] = cells
BED_COLORS = ['red', 'white', 'black', 'cyan', 'lime']
FACINGS = {'north': (0, -1), 'south': (0, 1), 'west': (-1, 0), 'east': (1, 0)}
def bed_case(rng, states, case):
"""A bed (or straw bed) clicked in the Nether or the End, among blocks."""
name = 'straw_bed' if rng.random() < 0.25 else rng.choice(BED_COLORS) + '_bed'
facing = rng.choice(list(FACINGS))
dx, dz = FACINGS[facing]
# The clicked block is the origin; the other half lies along the facing.
part = rng.choice(['head', 'foot'])
other = (-dx, 0, -dz) if part == 'head' else (dx, 0, dz)
cells = [[0, 0, 0, states.get(name, facing=facing, part=part, occupied='false')],
[0, -1, 0, states.get(rng.choice(['netherrack', 'end_stone', 'obsidian', 'stone']))],
[other[0], -1, other[2], states.get('stone')]]
if rng.random() < 0.9:
cells.append([*other, states.get(name, facing=facing, part='foot' if part == 'head' else 'head', occupied='false')])
taken = {tuple(c[:3]) for c in cells}
for _ in range(rng.choice([0, 3, 10, 30])):
p = (rng.randrange(-3, 4), rng.randrange(-2, 3), rng.randrange(-3, 4))
if p in taken:
continue
taken.add(p)
cells.append([*p, states.get(rng.choice(AROUND))])
case['dim'] = rng.choice(['nether', 'end'])
item = rng.choice(['-', '-', 'apple', 'stone', 'glowstone'])
case['use_item'] = {'item': '-' if item == '-' else d_plain(item, 1), 'creative': rng.random() < 0.2,
'sneaking': rng.random() < 0.1, 'food': 20, 'distance': 12}
if rng.random() < 0.2:
case['rules'] = {'block_explosion_drop_decay': False}
case['cells'] = cells
def anchor_case(rng, states, case):
"""A respawn anchor clicked in the Nether or the Overworld, with blocks
and water around it."""
charges = rng.choice([0, 0, 1, 2, 3, 4, 4])
cells = [[0, 0, 0, states.get('respawn_anchor', charges=str(charges))],
[0, -1, 0, states.get(rng.choice(['netherrack', 'stone', 'soul_sand', 'obsidian', 'soul_soil']))]]
taken = {(0, 0, 0), (0, -1, 0)}
for _ in range(rng.choice([0, 3, 8, 20, 40])):
p = (rng.randrange(-3, 4), rng.randrange(-2, 3), rng.randrange(-3, 4))
if p in taken:
continue
taken.add(p)
name = rng.choice(AROUND)
state = states.any(rng, 'water') if name == 'water' and rng.random() < 0.5 else states.get(name)
cells.append([*p, state])
if rng.random() < 0.2:
# Water that would flow into the anchor's place.
d = rng.choice([(1, 0, 0), (-1, 0, 0), (0, 0, 1), (0, 0, -1), (0, 1, 0)])
cells = [c for c in cells if tuple(c[:3]) != d]
cells.append([*d, states.any(rng, 'water') if rng.random() < 0.4 else states.get('water')])
nether = rng.random() < 0.5
if nether:
case['dim'] = 'nether'
item = rng.choice(['glowstone'] * 5 + ['apple', '-', 'stone', 'glowstone_dust'])
count = rng.choice([1, 1, 16, 64])
use = {'item': '-' if item == '-' else d_plain(item, count), 'creative': rng.random() < 0.2,
'sneaking': rng.random() < 0.1, 'food': 20,
# Away from the blast: the stand-in player is not an entity of the level.
'distance': 3 if nether else 12}
if rng.random() < 0.3:
use['respawn'] = rng.choice([[0, 0, 0], [5, 0, 5]])
if rng.random() < 0.2:
case['rules'] = {'block_explosion_drop_decay': False}
case['use_item'] = use
case['cells'] = cells
def cases(facts, count, seed):
@@ -46,6 +157,24 @@ def cases(facts, count, seed):
case = {**h.environment(rng), 'pos': [0, 0, 0]}
case.pop('raining', None)
case.pop('thundering', None)
if rng.random() < 0.1:
bed_case(rng, states, case)
case['items'] = []
case['mode'] = 'dispense'
yield case
continue
if rng.random() < 0.1:
respawn_case(rng, states, case)
case['items'] = []
case['mode'] = 'dispense'
yield case
continue
if rng.random() < 0.15:
anchor_case(rng, states, case)
case['items'] = []
case['mode'] = 'dispense'
yield case
continue
cells = []
item = rng.choice(ITEMS)
if rng.random() < 0.15:
@@ -83,8 +212,14 @@ def cases(facts, count, seed):
yield case
def d_plain(item, count):
return d.plain(item, count)
def kind(case, facts):
first = facts.states[case['cells'][0][3]][0].split(':')[1]
if 'respawn_at' in case:
return f'respawn at {first}'
item = case['use_item']['item']
item = item.split('"')[1].split(':')[1] if item != '-' else 'empty hand'
return f'{item} on {first}'
@@ -119,13 +254,15 @@ def main():
rust = h.split_cases((work / 'rust.txt').read_text(), ignore)
assert len(native) == len(rust) == len(all_cases), (len(native), len(rust), len(all_cases))
groups, errors = {}, {}
planted = eaten = 0
planted = eaten = respawned = exploded = 0
for case, a, b in zip(all_cases, native, rust):
if a and a[0].startswith('error'):
errors.setdefault(a[0], []).append(case)
continue
planted += any(line.startswith('set 0,1,0') for line in a)
eaten += any(line.startswith('held') and not line.endswith('using -') for line in a)
respawned += any(line.startswith('respawn ') and line != 'respawn none' and 'respawn_at' in case for line in a)
exploded += any(line.endswith(' minecraft:explode') for line in a)
if not d.same(a, b):
groups.setdefault(kind(case, facts), []).append((case, a, b))
for name, entries in sorted(errors.items(), key=lambda e: -len(e[1])):
@@ -133,13 +270,14 @@ def main():
for name, entries in sorted(groups.items(), key=lambda e: -len(e[1])):
print(f'{name}: {len(entries)} differing')
for case, a, b in entries[:args.show]:
print(' case ' + d.describe(case, facts) + ' use=' + json.dumps(case['use_item']))
print(' case ' + d.describe(case, facts) + ' use=' + json.dumps(case.get('use_item', case.get('respawn_at'))))
print(' native ' + ' | '.join(sorted(a)))
print(' rust ' + ' | '.join(sorted(b)))
total = sum(len(v) for v in groups.values())
skipped = sum(len(v) for v in errors.values())
print(f'{len(all_cases) - total - skipped}/{len(all_cases) - skipped} cases match ({skipped} oracle errors); '
f'vanilla planted in {planted} and started eating in {eaten}')
f'vanilla planted in {planted}, started eating in {eaten}, exploded {exploded} times and found a respawn '
f'spot in {respawned}')
h.finish(total + skipped)