Merge pull request #1160 from ludovic111/integ/b5-lan-rest

🤖 Agent: merged. Verify passes. Proof: the B5 integration of these eight heads (parity --changed 102/102, lan_e2e 46–47/48 with only order-dependent flakes), and the conflict resolution in tools/lan_e2e.py checked def by def against each branch.
This commit is contained in:
Ludovic Marie
2026-10-22 07:03:15 +02:00
committed by GitHub
16 changed files with 1070 additions and 96 deletions
+7
View File
@@ -158,6 +158,9 @@ pub struct Audio {
/// Positional sounds played since the last drain, kept while the world
/// is open to the network so guests hear them too.
pub capture: Option<Vec<(String, [f64; 3], f32, f32)>>,
/// How many times each positional sound played (the control socket's `status`),
/// with or without an audio device.
pub heard: std::collections::BTreeMap<String, u32>,
}
fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
use symphonia::core::{
@@ -591,6 +594,7 @@ impl Audio {
random: LegacyRandom::new(crate::sound_engine::unique_seed()),
source_override: None,
capture: None,
heard: Default::default(),
}
}
#[cfg(not(feature = "audio"))]
@@ -733,6 +737,9 @@ impl Audio {
if let (Some(capture), Some(at)) = (self.capture.as_mut(), at) {
capture.push((event.to_owned(), at, volume, pitch));
}
if at.is_some() {
*self.heard.entry(event.to_owned()).or_default() += 1;
}
self.sync_volumes();
let event = crate::sound_events::normalize(event);
let source = self
+11 -3
View File
@@ -34,6 +34,7 @@ mod crossbow;
mod debug_keys;
mod decorated_pot;
mod dedicated;
mod deflect;
mod dispense_fixture;
mod dispenser;
mod dragon;
@@ -1236,7 +1237,9 @@ struct Game<'a> {
/// swap just before an attack keeps them, with the new item's enchantments
/// (attribute swapping).
attack_item: Option<Arc<str>>,
last_hurt_by_player: HashSet<u32>,
/// Mobs a player hurt (`LivingEntity.lastHurtByPlayer`), with the guest
/// it was by connection (None: the host).
last_hurt_by_player: HashMap<u32, Option<u32>>,
/// Mobs whose death (`LivingEntity.die`) has been handled.
died: HashSet<u32>,
/// Client-ticked block-entity animation state (`game/block_entity_anims.rs`).
@@ -6830,6 +6833,10 @@ impl Game<'_> {
self.break_painting(i, true);
return true;
}
// A ghast's fireball or a wind charge in front: turned back.
if self.attack_redirectable() {
return true;
}
let hand_damage = 1.0
+ self
.held()
@@ -6938,7 +6945,8 @@ impl Game<'_> {
(actual * 0.5) as u32,
);
}
self.last_hurt_by_player.insert(self.mobs[index].id);
self.last_hurt_by_player
.insert(self.mobs[index].id, self.lan_acting);
let sound = if crit {
"minecraft:entity.player.attack.crit"
} else if scale > 0.9 {
@@ -11324,7 +11332,7 @@ impl<'a> Game<'a> {
raiding: Default::default(),
attack_ticks: 100,
attack_item: None,
last_hurt_by_player: HashSet::new(),
last_hurt_by_player: HashMap::new(),
died: HashSet::new(),
be_anims: {
let mut anims = horizon_client::block_entity_anim::BlockEntityAnims::default();
+3
View File
@@ -25,6 +25,9 @@ pub(super) struct CombatTracker {
pub(super) last_hurt_mob: Option<(u32, i64)>,
/// The mob whose projectile is hitting the player now.
pub(super) projectile_owner: Option<u32>,
/// The projectile hitting the player now is another player's that
/// `ServerPlayer.canHarmPlayer` refuses (the `pvp` rule, an ally).
pub(super) refuse_player_hit: bool,
/// The mob exploding now (`ServerExplosion.source`): its team's friendly
/// fire decides whom the blast may hurt.
pub(super) explosion_source: Option<u32>,
@@ -912,6 +912,7 @@ impl Game<'_> {
status["pending_uploads"] = self.pending_uploads.len().into();
status["destroying"] = json!(destroying);
status["physical_keys"] = json!(physical_keys);
status["heard"] = json!(self.audio.heard);
// Boats, minecarts, armor stands, item frames and paintings.
status["objects"] = json!(self.objects_status());
// Primed TNT, falling blocks, projectiles, tridents and end crystals.
+65 -16
View File
@@ -623,7 +623,8 @@ impl Game<'_> {
}
/// LivingEntity.die / dropAllDeathLoot.
fn mob_died(&mut self, m: &Mob) {
let by_player = self.last_hurt_by_player.remove(&m.id) || m.ai.last_hurt_by_player > 0;
let killer = self.last_hurt_by_player.remove(&m.id);
let by_player = killer.is_some() || m.ai.last_hurt_by_player > 0;
let mut dying = m.clone();
// LivingEntity.die: the death is heard, and a sculk catalyst nearby
// takes the experience (before the loot is dropped).
@@ -637,11 +638,22 @@ impl Game<'_> {
}
});
if by_player {
self.stats.add("killed", &m.kind.id, 1);
self.stats.custom("mob_kills", 1);
self.score_player_killed(super::commands::Target::Mob(m.id));
let view = self.mob_entity(m);
self.trigger_entity("minecraft:player_killed_entity", "entity", &view);
// A guest's kill is theirs: their statistics, scores and
// advancements (LivingEntity.die credits lastHurtByPlayer).
let guest = killer.flatten().filter(|_| self.lan_acting.is_none());
let credited = guest.is_some_and(|conn| {
let Some(mut host) = self.lan.take() else {
return false;
};
let done = self
.as_guest(&mut host, conn, |g| g.credit_kill(m))
.is_some();
self.lan = Some(host);
done
});
if !credited {
self.credit_kill(m);
}
}
self.score_entity_removed(m.id);
self.raider_died(m, by_player);
@@ -676,6 +688,15 @@ impl Game<'_> {
}
}
}
/// The killer's side of a mob's death: `ServerPlayer.awardKillScore`'s
/// statistics and scores, and the `player_killed_entity` trigger.
fn credit_kill(&mut self, m: &Mob) {
self.stats.add("killed", &m.kind.id, 1);
self.stats.custom("mob_kills", 1);
self.score_player_killed(super::commands::Target::Mob(m.id));
let view = self.mob_entity(m);
self.trigger_entity("minecraft:player_killed_entity", "entity", &view);
}
/// `dropAllDeathLoot` through `mobs::drops`: the entity loot table from the
/// world's random sequence, equipment by drop chance, species extras and
/// the experience orbs, spawned in order.
@@ -1394,7 +1415,8 @@ impl Game<'_> {
from: [f64; 3],
damage_type: &str,
) -> bool {
if self.creative {
// ServerPlayer.canHarmPlayer refused another player's projectile.
if self.creative || self.combat.refuse_player_hit {
return false;
}
let projectile = self
@@ -1632,14 +1654,30 @@ impl Game<'_> {
w: &w,
targets: targets_guests,
};
let guest_entities = self.lan_guest_entities();
projectiles.retain_mut(|p| {
let mob_shot = !matches!(p.owner, Some(Who::Player));
let (keep, hit) = match (p.arrow.is_some(), mob_shot) {
// A player's arrows, snowballs and eggs meet every player; a
// guest's flies from that guest (Projectile.getOwner), not
// from the host, until it has left them.
let pvp = !mob_shot && super::lan_pvp::meets_players(&p.kind);
let shooter = p
.guest
.filter(|_| pvp)
.and_then(|c| guest_entities.iter().find(|(g, _)| *g == c))
.map(|&(_, id)| Who::Mob(id));
if shooter.is_some() {
p.owner = shooter;
}
let (keep, hit) = match (p.arrow.is_some(), mob_shot || pvp) {
(true, false) => horizon_client::arrows::tick(p, &scene, &arrow_targets),
(true, true) => horizon_client::arrows::tick(p, &scene, &arrow_targets_guests),
(false, false) => p.tick(&pw),
(false, true) => p.tick(&pw_guests),
};
if shooter.is_some() {
p.owner = Some(Who::Player);
}
if let Some(a) = p.arrow.as_mut() {
arrow_events.extend(a.events.drain(..).map(|e| (p.position, e)));
}
@@ -1691,6 +1729,11 @@ impl Game<'_> {
}
self.creatures.projectiles.append(&mut projectiles);
for (p, hit) in hits {
// A player's arrow on another player lands as the victim's hurt.
if let Some(victim) = self.projectile_pvp_victim(&p, hit) {
self.projectile_hits_player(&p, hit, victim)?;
continue;
}
// A guest's projectile lands as theirs: a pearl takes them, what
// it hurts answers to them. One hitting the host (`Who::Player`
// here) stays the host's hit.
@@ -1974,7 +2017,7 @@ impl Game<'_> {
.find(|m| m.id == id)
.is_some_and(|m| m.damage(amount, source));
if p.owner == Some(Who::Player) {
self.last_hurt_by_player.insert(id);
self.last_hurt_by_player.insert(id, self.lan_acting);
}
hurt
}
@@ -2099,15 +2142,21 @@ impl Game<'_> {
}
},
Hit::Block { pos, face, .. } => {
// SmallFireball.onHitBlock: a mob's only with mobGriefing;
// BaseFireBlock.getState placed with updates (the fire
// ticks, ages and goes out where it can't stay).
let fire = [pos[0] + face[0], pos[1] + face[1], pos[2] + face[2]];
if self
.res
.facts()
.is_air(self.world.block(fire[0], fire[1], fire[2]))
&& let Some(state) =
self.pack.assets.registry.default_state("minecraft:fire")
let mob = matches!(p.owner, Some(Who::Mob(_)));
if (!mob || self.ui.rules.bool("mob_griefing"))
&& self
.res
.facts()
.is_air(self.world.block(fire[0], fire[1], fire[2]))
{
self.world.set(fire[0], fire[1], fire[2], state)?;
let at = BlockPos::new(fire[0], fire[1], fire[2]);
let state =
self.with_level(|b, level, ticks| b.fire_state_for(level, ticks, at));
self.level_set(fire, state)?;
}
}
Hit::None => {}
+155
View File
@@ -0,0 +1,155 @@
//! A player's blow at a ghast's fireball or a wind charge
//! (`#minecraft:redirectable_projectile`): `Player.attack` turns it with
//! `ProjectileDeflection.AIM_DEFLECT` instead of hurting anything. It flies on
//! along the player's view and is the player's now (`Projectile.deflect`
//! sets the owner), so a ghast it meets dies of it (`Ghast.isReflectedFireball`).
use super::{Game, ray_box, view_vector};
use horizon_client::{
mobs::Who,
projectiles::{Projectile, ProjectileKind},
};
use horizon_core::geometry::{Aabb, Vec3};
/// `AbstractHurtingProjectile.getPickRadius`: the crosshair finds it a block
/// round its box.
const PICK_RADIUS: f64 = 1.0;
/// `#minecraft:redirectable_projectile`: a ghast's fireball and both wind charges.
pub(super) fn redirectable(p: &Projectile) -> bool {
!p.stuck
&& matches!(
p.kind,
ProjectileKind::LargeFireball { .. }
| ProjectileKind::WindCharge
| ProjectileKind::BreezeWindCharge
)
}
/// Its box for the crosshair: the entity's (a fireball 1 x 1, a wind charge
/// 0.3125, from its feet up) grown by the pick radius.
fn pick_box(p: &Projectile) -> Aabb {
let size = match p.kind {
ProjectileKind::LargeFireball { .. } => 1.0,
_ => 0.3125,
};
let half = size / 2.0 + PICK_RADIUS;
Aabb::new(
Vec3::new(
p.position.x - half,
p.position.y - PICK_RADIUS,
p.position.z - half,
),
Vec3::new(
p.position.x + half,
p.position.y + size + PICK_RADIUS,
p.position.z + half,
),
)
}
impl Game<'_> {
/// The redirectable projectile under the crosshair within the attack
/// reach, and how far along the view it is.
pub(super) fn redirectable_hit(&self) -> Option<(usize, f64)> {
let eye = self.eye_position()?;
let dir = view_vector(self.yaw, self.pitch);
let reach: f64 = if self.creative { 5.0 } else { 3.0 };
self.creatures
.projectiles
.iter()
.enumerate()
.filter(|(_, p)| redirectable(p))
.filter_map(|(i, p)| ray_box(eye, dir, reach, pick_box(p)).map(|t| (i, t)))
.min_by(|a, b| a.1.total_cmp(&b.1))
}
/// `Player.attack` on a redirectable projectile nearer than any mob or
/// block in view: `AIM_DEFLECT` (its movement the unit view vector), the
/// player its owner, its acceleration power back to 0.1
/// (`onDeflection` by an attack), and the no-damage sound. True when a
/// projectile was turned.
pub(super) fn attack_redirectable(&mut self) -> bool {
let Some((i, t)) = self.redirectable_hit() else {
return false;
};
if self.mob_hit().is_some_and(|(_, d)| d < t) {
return false;
}
if let (Some(hit), Some(eye)) = (self.pick(), self.eye_position()) {
let d = (0..3)
.map(|a| (hit.point[a] - eye[a]).powi(2))
.sum::<f64>()
.sqrt();
if d < t {
return false;
}
}
self.deflect(i);
true
}
/// `Player.canInteractWithEntity(box, 3.0)` as the server checks an
/// attack packet: the projectile's box within the reach plus 3 of the eyes.
pub(super) fn within_interaction_range(&self, i: usize) -> bool {
let (Some(eye), Some(p)) = (self.eye_position(), self.creatures.projectiles.get(i)) else {
return false;
};
let b = pick_box(p);
let (lo, hi) = (b.min_position(), b.max_position());
let (lo, hi) = (
[lo.x + PICK_RADIUS, lo.y + PICK_RADIUS, lo.z + PICK_RADIUS],
[hi.x - PICK_RADIUS, hi.y - PICK_RADIUS, hi.z - PICK_RADIUS],
);
let d2: f64 = (0..3)
.map(|a| (eye[a] - eye[a].clamp(lo[a], hi[a])).powi(2))
.sum();
let range = if self.creative { 5.0 } else { 3.0 } + 3.0;
d2 < range * range
}
/// `Projectile.deflect(AIM_DEFLECT, player, player, true)`.
pub(super) fn deflect(&mut self, i: usize) {
let dir = view_vector(self.yaw, self.pitch);
let guest = self.lan_acting;
let p = &mut self.creatures.projectiles[i];
p.velocity = Vec3::new(dir[0], dir[1], dir[2]);
p.yaw = dir[0].atan2(dir[2]).to_degrees() as f32;
p.pitch = dir[1].atan2(dir[0].hypot(dir[2])).to_degrees() as f32;
p.owner = Some(Who::Player);
// On a server, the guest who struck it (their projectile now).
p.guest = guest;
// Not into the one who turned it on its way out.
p.left_owner = false;
self.reset_attack_strength();
self.swing_arm();
let from = self
.player
.as_ref()
.map(|p| [p.position.x, p.position.y, p.position.z]);
self.audio
.play("minecraft:entity.player.attack.nodamage", from, 1.0, 1.0);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_ghast_fireballs_and_wind_charges_are_redirectable() {
let at = Vec3::new(0.0, 64.0, 0.0);
let large = Projectile::fireball(
ProjectileKind::LargeFireball { power: 1 },
at,
None,
[1.0, 0.0, 0.0],
);
let small = Projectile::fireball(ProjectileKind::SmallFireball, at, None, [1.0, 0.0, 0.0]);
assert!(redirectable(&large));
assert!(!redirectable(&small));
// The pick box: a block round the fireball's 1 x 1 box.
let b = pick_box(&large);
assert_eq!(b.min_position().x, -1.5);
assert_eq!(b.max_position().y, 66.0);
}
}
+112 -50
View File
@@ -226,6 +226,102 @@ impl Game<'_> {
}
/// `ServerExplosion.hurtEntities` (player, mobs, items, primed TNT);
/// the player takes `damage_type`.
/// `ServerExplosion.hurtEntities` for the player: damage scaled by
/// distance and exposure, through a raised shield (`hurtServer` blocks
/// explosions like any attack from where the blast is), then the push
/// (less with explosion knockback resistance; none for spectators or a
/// creative player flying).
pub(super) fn explosion_hurt_player(
&mut self,
center: [f64; 3],
radius: f32,
damage_type: &str,
exploding: Option<u32>,
) {
let diameter = f64::from(radius * 2.0);
// Blast protection: `EXPLOSION_KNOCKBACK_RESISTANCE` (0.15 per level and
// piece, so two Blast Protection IV pieces cancel it).
let resistance = self
.player
.as_mut()
.and_then(|p| p.attribute("minecraft:explosion_knockback_resistance").ok())
.unwrap_or(0.0);
let Some(p) = self.player.as_ref() else {
return;
};
let feet = [p.position.x, p.position.y, p.position.z];
let dist = ((feet[0] - center[0]).powi(2)
+ (feet[1] - center[1]).powi(2)
+ (feet[2] - center[2]).powi(2))
.sqrt()
/ diameter;
if dist > 1.0 || p.health.dead_or_dying() {
return;
}
let w = f64::from(p.dimensions.width) / 2.0;
let h = f64::from(p.dimensions.height);
let eye = [
feet[0],
feet[1] + f64::from(p.dimensions.eye_height),
feet[2],
];
let exposure = self.seen_percent(
center,
[feet[0] - w, feet[1], feet[2] - w],
[feet[0] + w, feet[1] + h, feet[2] + w],
);
let pow = (1.0 - dist) * f64::from(exposure);
let amount = ((pow * pow + pow) / 2.0 * 7.0 * diameter + 1.0) as f32;
let d = [eye[0] - center[0], eye[1] - center[1], eye[2] - center[2]];
let l = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt();
let dir = if l < 1.0e-4 {
[0.0; 3]
} else {
[d[0] / l, d[1] / l, d[2] / l]
};
let power = pow * (1.0 - resistance);
// `source.doTeamsAllowDamage(entity)`.
let hurtable = exploding.is_none_or(|id| {
horizon_client::scoreboard::teams_allow_damage(self.mob_team(id), self.player_team())
});
let blocking = self.player_blocking(Some(center), damage_type, false);
let raised = blocking.is_some();
let (creative, spectator) = (self.creative, self.spectator());
let flying = self.player.as_ref().is_some_and(|p| p.flying);
let mut outcome = horizon_client::health::BlockOutcome::default();
if let Some(p) = self.player.as_mut()
&& let Some(id) = self.motion.health.damage.id(damage_type)
{
// Creative players are invulnerable to explosions.
if !creative
&& !spectator
&& hurtable
&& let Ok(o) = p.hurt_blocking(
&self.motion.health,
self.world.health_rules,
id,
amount,
blocking,
)
{
outcome = o;
}
if !spectator && !(creative && flying) {
p.velocity = Vec3::new(
p.velocity.x + dir[0] * power,
p.velocity.y + dir[1] * power,
p.velocity.z + dir[2] * power,
);
}
}
if outcome.hurt && !creative {
self.hurt_armor(amount);
}
if raised {
self.after_block(outcome, amount, None, false);
}
}
fn explosion_hurt_entities(&mut self, center: [f64; 3], radius: f32, damage_type: &str) {
if radius < 1.0e-5 {
return;
@@ -261,57 +357,23 @@ impl Game<'_> {
horizon_client::scoreboard::teams_allow_damage(g.mob_team(id), victim)
})
};
let player_hurtable = teams_allow(self, self.player_team());
// Player.
if let Some(p) = self.player.as_ref() {
let feet = [p.position.x, p.position.y, p.position.z];
let dist = distance(feet) / diameter;
if dist <= 1.0 && !p.health.dead_or_dying() {
let w = f64::from(p.dimensions.width) / 2.0;
let h = f64::from(p.dimensions.height);
let eye = [
feet[0],
feet[1] + f64::from(p.dimensions.eye_height),
feet[2],
];
let exposure = self.seen_percent(
center,
[feet[0] - w, feet[1], feet[2] - w],
[feet[0] + w, feet[1] + h, feet[2] + w],
);
let amount = damage(dist, exposure);
let dir = direction(eye);
let mut hurt = false;
let creative = self.creative;
if let Some(p) = self.player.as_mut()
&& let Some(id) = self.motion.health.damage.id(damage_type)
{
// Creative players are invulnerable to explosions.
if !creative && player_hurtable {
hurt = p
.hurt(&self.motion.health, self.world.health_rules, id, amount)
.unwrap_or(false);
}
// Blast protection: `EXPLOSION_KNOCKBACK_RESISTANCE` (0.15 per
// level and piece, so two Blast Protection IV pieces cancel it).
let resistance = p
.attribute("minecraft:explosion_knockback_resistance")
.unwrap_or(0.0);
let power = (1.0 - dist) * f64::from(exposure) * (1.0 - resistance);
// `hitPlayers` skips creative players who are flying: the
// client gets no knockback in the explode packet.
if !(creative && p.flying) {
p.velocity = Vec3::new(
p.velocity.x + dir[0] * power,
p.velocity.y + dir[1] * power,
p.velocity.z + dir[2] * power,
);
}
}
if hurt && !self.creative {
self.hurt_armor(amount);
}
// The player, then every other player in the level (LAN guests),
// each swapped in as the player.
self.explosion_hurt_player(center, radius, damage_type, exploding);
if let Some(mut host) = self.lan.take() {
let guests: Vec<u32> = host
.hub
.guests
.iter()
.filter(|g| host.hub.here(g) && g.loaded && !g.dead)
.map(|g| g.conn)
.collect();
for conn in guests {
self.guest_hit_by(&mut host, conn, |g| {
g.explosion_hurt_player(center, radius, damage_type, exploding);
});
}
self.lan = Some(host);
}
// Mobs.
let mut mobs = std::mem::take(&mut self.mobs);
+1
View File
@@ -156,6 +156,7 @@ impl Game<'_> {
|| before(self.dragon_hit().map(|h| h.1))
|| before(self.mob_hit().map(|h| h.1))
|| before(self.guest_hit().map(|h| h.1))
|| before(self.redirectable_hit().map(|h| h.1))
}
/// `LocalPlayer.isHandsBusy`: paddling a boat.
fn hands_busy(&self) -> bool {
+74 -1
View File
@@ -64,6 +64,12 @@ pub(super) struct GuestPlay {
xp_delay: u32,
/// What last killed the guest outright (`/kill`): the death message's key.
death_cause: Option<String>,
/// The equipment modifiers on the guest's attributes (`apply_equipment`)
/// and the armour and main hand they were put on for: the hub's player
/// is a `ServerPlayer` too, whose worn armour counts
/// (`LivingEntity.collectEquipmentChanges`).
modifiers: Vec<(String, String)>,
equipped: Option<Vec<Option<ItemStack>>>,
}
/// A guest's command waiting for the hub (`LanHost::commands`).
@@ -130,6 +136,8 @@ pub(super) struct GuestSwap {
swings: u32,
/// How many projectiles there were: those added since are the guest's.
projectiles: usize,
/// The host's equipment modifiers.
modifiers: Vec<(String, String)>,
}
impl GuestPlay {
@@ -193,7 +201,8 @@ impl Game<'_> {
return None;
}
let i = host.hub.guests.iter().position(|g| g.conn == conn)?;
if host.hub.guests[i].motion.is_none() {
let fresh = host.hub.guests[i].motion.is_none();
if fresh {
let p = Vec3::new(
host.hub.guests[i].position[0],
host.hub.guests[i].position[1],
@@ -207,6 +216,10 @@ impl Game<'_> {
}
}
let mut play = host.play.remove(&conn).unwrap_or_default();
if fresh {
// A new body (joined, respawned, changed level): nothing on it yet.
play.equipped = None;
}
let g = &mut host.hub.guests[i];
// The guest's body.
let Some(mut motion) = g.motion.take() else {
@@ -310,6 +323,17 @@ impl Game<'_> {
let packets = std::mem::take(&mut self.guest_packets);
let swings = self.swings_started;
let projectiles = self.creatures.projectiles.len();
let modifiers = std::mem::replace(
&mut self.applied_modifiers,
std::mem::take(&mut play.modifiers),
);
// Its worn armour on its attributes, when it changed.
let mut equipped: Vec<Option<ItemStack>> = self.armor.to_vec();
equipped.push(self.inventory.get(self.selected).cloned().flatten());
if play.equipped.as_ref() != Some(&equipped) {
self.apply_equipment();
play.equipped = Some(equipped);
}
Some(GuestSwap {
conn,
i,
@@ -355,6 +379,7 @@ impl Game<'_> {
packets,
swings,
projectiles,
modifiers,
})
}
@@ -406,7 +431,9 @@ impl Game<'_> {
packets,
swings,
projectiles,
modifiers,
} = swap;
play.modifiers = std::mem::replace(&mut self.applied_modifiers, modifiers);
// What the guest shot is theirs (Projectile.setOwner).
for p in self.creatures.projectiles.iter_mut().skip(projectiles) {
if p.owner == Some(horizon_client::mobs::Who::Player) && p.guest.is_none() {
@@ -805,6 +832,8 @@ impl Game<'_> {
],
};
let hand = if p.hand == 1 { Hand::Off } else { Hand::Main };
let logged = self.world.block_log.as_ref().map_or(0, Vec::len);
let heard = self.audio.capture.as_ref().map_or(0, Vec::len);
let swung = self.as_guest(host, conn, |g| {
g.forced_hit = Some(hit);
g.guest_use = Some(GuestUse::OnBlock(hand));
@@ -815,6 +844,7 @@ impl Game<'_> {
g.swings_started != swings
});
self.lan_swing_back(host, conn, swung);
self.guest_use_sounds(host, conn, logged, heard);
// The client predicted a result: correct it with what really is.
for pos in [
p.pos,
@@ -1127,6 +1157,22 @@ impl Game<'_> {
}
return;
}
// A ghast's fireball or a wind charge: turned along the guest's own
// view (ServerGamePacketListenerImpl.handleInteract, then
// Player.attack's AIM_DEFLECT).
if let Some(i) = self
.creatures
.projectiles
.iter()
.position(|p| p.id != 0 && p.id as i32 == id && super::deflect::redirectable(p))
{
self.as_guest(host, conn, |g| {
if g.within_interaction_range(i) {
g.deflect(i);
}
});
return;
}
let (old_yaw, old_pitch) = (host.hub.guests[gi].yaw, host.hub.guests[gi].pitch);
if self.look_at_entity(host, gi, id).is_none() {
return;
@@ -1962,6 +2008,33 @@ impl Game<'_> {
}
}
/// `level.playSound(player, ...)` of a guest's use it predicted (`remote::hand_operated`
/// blocks only, as the guest decides): the others hear it now, the guest already did.
fn guest_use_sounds(&mut self, host: &mut LanHost, conn: u32, logged: usize, heard: usize) {
let changed: Vec<(i32, i32, i32)> = self
.world
.block_log
.as_ref()
.map_or(&[][..], |log| log.get(logged..).unwrap_or(&[]))
.to_vec();
let facts = self.res.facts();
if changed.is_empty()
|| !changed.iter().all(|&(x, y, z)| {
super::remote::hand_operated(&facts.get(self.world.block(x, y, z)).name)
})
{
return;
}
let Some(capture) = self.audio.capture.as_mut() else {
return;
};
let sounds: Vec<_> = capture.drain(heard.min(capture.len())..).collect();
for (name, at, volume, pitch) in sounds {
let source = horizon_client::settings::sound_source(&name) as i32;
host.hub.sound(&name, at, volume, pitch, source, Some(conn));
}
}
/// Positional sounds and level events of the tick, for the guests.
pub(super) fn lan_broadcast_effects(&mut self, host: &mut LanHost) {
let sounds = self.audio.capture.take().unwrap_or_default();
+101 -1
View File
@@ -3,9 +3,26 @@
//! is worked out as the attacker (weapon, attack strength, critical hit,
//! enchantments, a mace's smash) and lands on the victim like any player
//! attack (blocking, armour, knockback), when the `pvp` game rule allows it
//! (`ServerPlayer.canHarmPlayer`, `isPvpAllowed`).
//! (`ServerPlayer.canHarmPlayer`, `isPvpAllowed`). A player's arrow on
//! another player lands the same way.
use super::{Game, lan::LanHost, lan_mobs::guest_bounds, ray_box, view_vector};
use horizon_client::{
Result,
mobs::Who,
projectiles::{Hit, Projectile, ProjectileKind},
};
/// The player projectiles that meet other players: arrows (their hurt), and
/// snowballs and eggs, which break on them (`Player.hurtServer` takes no 0
/// damage). Pearls, potions and wind charges fly past players as before.
pub(super) fn meets_players(kind: &ProjectileKind) -> bool {
matches!(
kind,
ProjectileKind::Arrow { .. } | ProjectileKind::Snowball | ProjectileKind::Egg
)
}
/// Who a player's attack lands on.
#[derive(Clone, Copy)]
pub(super) enum Victim {
@@ -105,6 +122,89 @@ impl Game<'_> {
})
}
/// The guests by connection, with their entity ids.
pub(super) fn lan_guest_entities(&self) -> Vec<(u32, u32)> {
self.lan.as_ref().map_or_else(Vec::new, |host| {
host.hub
.guests
.iter()
.map(|g| (g.conn, g.entity_id as u32))
.collect()
})
}
/// The player a player's projectile hit, when it hit one: the host for a
/// guest's shot, or a guest.
pub(super) fn projectile_pvp_victim(&self, p: &Projectile, hit: Hit) -> Option<Victim> {
if p.owner != Some(Who::Player) || !meets_players(&p.kind) {
return None;
}
let Hit::Entity { who, .. } = hit else {
return None;
};
match who {
Who::Player => p.guest.map(|_| Victim::Host),
Who::Mob(id) => self
.lan
.as_ref()?
.hub
.guests
.iter()
.find(|g| g.entity_id as u32 == id)
.map(|g| Victim::Guest(g.conn)),
}
}
/// A player's projectile on a player: the hit runs as the victim, whose
/// hurt refuses it when the `pvp` game rule or their teams forbid it
/// (`ServerPlayer.canHarmPlayer`; `AbstractArrow.onHitEntity` then turns
/// the arrow back).
pub(super) fn projectile_hits_player(
&mut self,
p: &Projectile,
hit: Hit,
victim: Victim,
) -> Result<()> {
let Hit::Entity { at, .. } = hit else {
return Ok(());
};
let Some(mut host) = self.lan.take() else {
return self.projectile_hit(p, hit);
};
let team_of = |game: &Self, name: &str| game.score.board.players_team(name).cloned();
let attacker = match p.guest {
Some(conn) => host.hub.guest(conn).and_then(|g| team_of(self, &g.name)),
None => self.player_team().cloned(),
};
let target = match victim {
Victim::Host => self.player_team().cloned(),
Victim::Guest(conn) => host.hub.guest(conn).and_then(|g| team_of(self, &g.name)),
};
let refused = !(self.ui.rules.bool("pvp")
&& horizon_client::scoreboard::teams_allow_damage(target.as_ref(), attacker.as_ref()));
let on_player = Hit::Entity {
who: Who::Player,
at,
};
let result = match victim {
Victim::Host => {
self.lan = Some(host);
self.combat.refuse_player_hit = refused;
let r = self.projectile_hit(p, on_player);
self.combat.refuse_player_hit = false;
return r;
}
Victim::Guest(conn) => self.guest_hit_by(&mut host, conn, |g| {
g.combat.refuse_player_hit = refused;
let r = g.projectile_hit(p, on_player);
g.combat.refuse_player_hit = false;
r
}),
};
self.lan = Some(host);
result.unwrap_or(Ok(()))
}
/// The hit landing on the victim with its extra knockback, then the
/// attacker's attack sound. Whether the victim was hurt.
pub(super) fn pvp_land(&mut self, host: &mut LanHost, victim: Victim, s: &Strike) -> bool {
+22 -5
View File
@@ -6,7 +6,7 @@ use horizon_client::{
items::ItemStack,
mobs::{Species, Who, piglin::ADMIRE},
};
use horizon_core::random::RandomSource;
use horizon_core::{geometry::Vec3, random::RandomSource};
impl Game<'_> {
fn piglin_loved(&self, item: &str) -> bool {
@@ -132,12 +132,29 @@ impl Game<'_> {
} else {
vec![ItemStack::new(&item, 1)]
};
// BehaviorUtils.throwItem toward the nearest visible player, else nearby.
let target = self
// BehaviorUtils.throwItem toward the nearest visible player
// (NEAREST_VISIBLE_PLAYER: within 16, alive, no spectators; the
// guests count as much as the host), else nearby.
let at = m.position;
let host = self
.player
.as_ref()
.filter(|p| p.position.distance_squared(m.position) < 256.0)
.map(|p| [p.position.x, p.position.y + 1.0, p.position.z]);
.filter(|p| !p.health.dead_or_dying() && !self.spectator())
.map(|p| [p.position.x, p.position.y, p.position.z]);
let guests = self.lan.iter().flat_map(|h| {
h.hub
.guests
.iter()
.filter(|g| h.hub.here(g) && g.loaded && !g.dead && !g.spectator())
.map(|g| g.position)
});
let d = |p: &[f64; 3]| at.distance_squared(Vec3::new(p[0], p[1], p[2]));
let target = host
.into_iter()
.chain(guests)
.filter(|p| d(p) < 256.0)
.min_by(|a, b| d(a).total_cmp(&d(b)))
.map(|p| [p[0], p[1] + 1.0, p[2]]);
for stack in items {
let to = target.unwrap_or_else(|| {
let r = &mut self.world.random;
+130 -11
View File
@@ -3244,7 +3244,11 @@ impl Game<'_> {
.and_then(|h| self.res.items().get(&h.item))
.is_some_and(|i| i.block.is_some());
if let Some(hit) = self.pick() {
let reacts = hand == Hand::Main && self.remote_block_reacts(&hit, held.as_ref());
let (reacts, changes) = if hand == Hand::Main {
self.remote_block_reacts(&hit, held.as_ref())
} else {
(false, DryUse::default())
};
let seq = self.next_sequence();
let cursor = [
(hit.point[0] - f64::from(hit.pos[0])) as f32,
@@ -3270,6 +3274,9 @@ impl Game<'_> {
r.use_target = Some(hit.pos);
r.placing = Some((target, ticks));
}
if reacts {
self.predict_use(&changes, seq);
}
if held_block {
self.with_hand(hand, Game::swing_arm);
return true;
@@ -3279,15 +3286,61 @@ impl Game<'_> {
false
}
/// MultiPlayerGameMode.useItemOn inside startPrediction: the blocks the
/// use changed on this client's level at once, each kept as predicted
/// under the use's sequence until the server acknowledges it (a use the
/// server refused goes back). Only the blocks a hand opens or flips: a
/// wooden or copper door, trapdoor or fence gate, a lever or a button;
/// whatever else the use changes waits for the server.
fn predict_use(&mut self, (changes, sounds): &DryUse, seq: i32) {
let facts = self.res.facts();
let predicted = |state: BlockStateId| hand_operated(&facts.get(state).name);
if changes.is_empty()
|| !changes
.iter()
.all(|(p, s)| predicted(*s) && predicted(self.world.block(p.x, p.y, p.z)))
{
return;
}
for &(p, state) in changes {
let pos = [p.x, p.y, p.z];
let before = self.world.block(p.x, p.y, p.z);
// BlockStatePredictionHandler.retainKnownServerState.
if let Some(r) = self.remote.as_mut() {
r.predictions
.entry(pos)
.and_modify(|e| e.0 = seq)
.or_insert((seq, before.0 as i32));
}
self.set_block(pos, state.0 as i32);
}
// `level.playSound(player, ...)`: the clicker hears it from its own use; the
// server sends it to the others only.
for (pos, sound, volume, pitch) in sounds {
let at = [
f64::from(pos.x) + 0.5,
f64::from(pos.y) + 0.5,
f64::from(pos.z) + 0.5,
];
let name = if sound.contains(':') {
sound.to_string()
} else {
format!("minecraft:{sound}")
};
self.audio.play(&name, Some(at), *volume, *pitch);
}
}
/// Whether the block hit takes a main-hand right click with `held`
/// (`BlockState.useItemOn`, then `useWithoutItem`): a door, a button, a
/// container. Vanilla's client runs it on its own level first; this runs
/// it on a copy that keeps no change.
fn remote_block_reacts(&self, hit: &super::Hit, held: Option<&ItemStack>) -> bool {
/// container, and the blocks it changed. Vanilla's client runs it on its
/// own level first; this runs it on a copy, and `predict_use` keeps the
/// changes it predicts.
fn remote_block_reacts(&self, hit: &super::Hit, held: Option<&ItemStack>) -> (bool, DryUse) {
// Player.isSecondaryUseActive with something in either hand.
let hands_full = self.stack_in(self.selected).is_some() || self.offhand.is_some();
if self.keys.contains(&KeyCode::ShiftLeft) && hands_full {
return false;
return (false, DryUse::default());
}
use horizon_core::geometry::Direction;
let face = match hit.face {
@@ -3302,8 +3355,10 @@ impl Game<'_> {
world: &self.world,
changed: HashMap::new(),
random: horizon_core::random::LegacyRandom::new(0),
sounds: Vec::new(),
};
self.res
let reacts = self
.res
.behaviours()
.use_item_on(
&mut level,
@@ -3314,7 +3369,8 @@ impl Game<'_> {
self.use_context(),
held.map(|s| &*s.item),
)
.consumes_action()
.consumes_action();
(reacts, (level.changed.into_iter().collect(), level.sounds))
}
/// MultiPlayerGameMode.useItem for `hand`, if it holds something: whether
@@ -3336,6 +3392,16 @@ impl Game<'_> {
// MultiPlayerGameMode.useItem runs the use here too: food starts
// being eaten (Consumable.startConsuming).
self.with_hand(hand, |g| g.start_eating(&info));
// BowItem.use: startUsingItem here too (with an arrow, or in creative), so that letting
// go sends RELEASE_USE_ITEM (Minecraft.handleKeybinds) and the server shoots.
if &*held.item == "minecraft:bow" {
self.with_hand(hand, |g| {
if g.using.is_none() && (g.creative || g.projectile_slot("minecraft:bow").is_some())
{
g.using = Some((g.held_slot(), 0));
}
});
}
item_has_use(&info)
}
@@ -3351,14 +3417,20 @@ impl Game<'_> {
}
self.remote_use_item(Hand::Off);
}
/// `LivingEntity.updatingUsingItem` for a consumable on a server client: the
/// eating animation and its crumbs. The server eats it and sends the
/// stack, the hunger and the sounds.
/// `LivingEntity.updatingUsingItem` on a server client: a drawn bow, and a
/// consumable's eating animation and its crumbs. The server eats it and
/// sends the stack, the hunger and the sounds.
fn remote_tick_using(&mut self) {
let Some((slot, ticks)) = self.using else {
return;
};
let stack = self.stack_in(slot).cloned();
// A drawn bow: held until the button lets go (or another slot is picked).
if stack.as_ref().is_some_and(|s| &*s.item == "minecraft:bow") {
self.using = (slot == self.selected || slot == super::shield::OFFHAND_SLOT)
.then_some((slot, ticks + 1));
return;
}
let consumable = stack
.as_ref()
.and_then(|s| self.res.items().get(&s.item))
@@ -3468,7 +3540,18 @@ impl Game<'_> {
return true;
}
let mut instant = false;
if let Some((i, distance)) = self.mob_hit()
// A ghast's fireball or a wind charge nearer than any mob: the
// server turns it (game/deflect.rs).
if let Some((i, distance)) = self.redirectable_hit()
&& self.mob_hit().is_none_or(|(_, d)| distance <= d)
&& self.before_block(distance)
&& self.creatures.projectiles[i].id != 0
{
self.send(S::Attack(play::Attack {
id: self.creatures.projectiles[i].id as i32,
}));
self.reset_attack_strength();
} else if let Some((i, distance)) = self.mob_hit()
&& self.before_block(distance)
{
self.send(S::Attack(play::Attack {
@@ -4216,9 +4299,45 @@ struct DryLevel<'w> {
world: &'w horizon_client::world::World,
changed: HashMap<horizon_core::position::BlockPos, BlockStateId>,
random: horizon_core::random::LegacyRandom,
/// The sounds the use plays (a door's creak).
sounds: Vec<DrySound>,
}
type DrySound = (
horizon_core::position::BlockPos,
std::sync::Arc<str>,
f32,
f32,
);
/// What a use on the dry level changed, and the sounds it played.
type DryUse = (
Vec<(horizon_core::position::BlockPos, BlockStateId)>,
Vec<DrySound>,
);
/// The blocks a guest's hand flips that its use predicts (and hears at once): a wooden or
/// copper door, trapdoor or fence gate, a lever or a button. An iron door or trapdoor has
/// no hand use.
pub(super) fn hand_operated(name: &str) -> bool {
let name = name.trim_start_matches("minecraft:");
((name.ends_with("_door") || name.ends_with("_trapdoor")) && !name.starts_with("iron_"))
|| name.ends_with("_fence_gate")
|| name.ends_with("_button")
|| name == "lever"
}
impl horizon_world::level::LevelAccess for DryLevel<'_> {
fn emit(&mut self, event: horizon_world::level::LevelEvent) {
if let horizon_world::level::LevelEvent::Sound {
pos,
sound,
volume,
pitch,
} = event
{
self.sounds.push((pos, sound, volume, pitch));
}
}
fn block_state(&self, pos: horizon_core::position::BlockPos) -> BlockStateId {
self.changed
.get(&pos)
@@ -665,7 +665,7 @@ impl Game<'_> {
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
m.damage(amount, horizon_client::mobs::Damage::player(at));
}
self.last_hurt_by_player.insert(id);
self.last_hurt_by_player.insert(id, self.lan_acting);
}
"set" => {
let n = |i: usize| words[i].parse::<i32>().unwrap_or(0);
+1 -1
View File
@@ -131,7 +131,7 @@ impl Game<'_> {
m.damage(1.0, source);
}
if p.owner == Some(Who::Player) {
self.last_hurt_by_player.insert(id);
self.last_hurt_by_player.insert(id, self.lan_acting);
}
}
}
+7 -2
View File
@@ -1623,13 +1623,18 @@ impl Mob {
if !self.alive() || self.removed || self.invulnerable_flag {
return false;
}
if source.is_fire() && (self.kind.flags.fire_immune) {
// Ghast.isReflectedFireball: a fireball a player turned back is
// no fire to it, and kills it (Ghast.hurtServer: 1000 damage).
let reflected = &*self.kind.id == "minecraft:ghast"
&& source.kind == DamageKind::Fireball
&& source.attacker == Some(Who::Player);
if source.is_fire() && (self.kind.flags.fire_immune) && !reflected {
return false;
}
if !ai::accepts_damage(self, &source, amount) {
return false;
}
let mut amount = amount;
let mut amount = if reflected { 1000.0 } else { amount };
if source.kind == DamageKind::FallingBlock
&& !species::body_slot(self.species())
&& self.extra.head.is_some()
+379 -5
View File
@@ -20,6 +20,10 @@ address. The script then checks, from both sides, what a guest's game used to ge
drowning and the void (then respawns);
- pvp: the guest and the host hit each other with a sword; with the pvp game rule off, or on one
team without friendly fire, nothing;
- kills: a pig the guest kills counts in the guest's killed statistic, not the host's (#484);
- arrows: the guest and the host shoot each other with a bow; with the pvp game rule off, nothing (#484);
- respawn: a player killed is drawn dead by the other side, and alive again once it respawns (the
respawned player is a new entity to the others); the host dies, and on the server thread
the guest too;
@@ -52,6 +56,9 @@ address. The script then checks, from both sides, what a guest's game used to ge
its crafting grid and gathers a stack with a double click; the server has each.
- sleep: at night the guest lies down in its own bed (not the host); alone it stays night, it
gets up with Escape, and once the host sleeps too the night ends and both wake.
- predict: with the host frozen, the oak door the guest opens opens on the guest's screen at once (its
prediction) and creaks there at once, stays open once the server answers, and each side hears
it once; an iron door stays shut (#869).
- push: a cow standing in the guest pushes it just clear of the cow (the guest's own client
pushes it, as in vanilla), not ever faster across the ground.
- eat: holding right click with bread, the guest's own screen plays the eating (the item in use
@@ -64,6 +71,17 @@ address. The script then checks, from both sides, what a guest's game used to ge
guest as the host has them (kind, place, rotation, what they hold or wear, the variant).
- projectiles: primed TNT (one falling), an end crystal and an arrow that lands reach the guest where
the host has them; a falling block lands on both sides.
- fireball: a fire charge a dispenser shoots onto stone lights a fire both sides see, and the fire
goes out on its own within a minute (it ticks: FireBlock.tick on a floor that doesn't burn)
- blast: primed TNT going off beside a guest in survival hurts the guest and pushes it away
(ServerExplosion.hurtEntities takes every player); facing it behind a raised shield, the
guest takes nothing.
- worn: iron armour the guest puts on in its inventory protects it: a 10-damage blow takes 6
(armour 15, LivingEntity.getDamageAfterArmorAbsorb), and the full 10 without it.
- plates: a stone pressure plate the guest steps on is pressed on both sides, and comes up once
the guest steps off (#848).
- swings: each side sees the other's arm swing while it mines a block, and the guest sees its own
@@ -91,6 +109,7 @@ macOS both games render offscreen. Games started here have no audio (HORIZON_NO_
"""
import argparse
import json
import math
import os
import re
import shutil
@@ -111,7 +130,7 @@ ROOT = Path(__file__).resolve().parents[1]
GUEST_NAME = 'Guest'
# The host plays single player on its server thread (--server-thread).
SERVER_THREAD = False
CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'trials', 'clicks', 'sleep', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth']
CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'sign', 'damage', 'mobs', 'hazards', 'pvp', 'arrows', 'kills', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'trials', 'clicks', 'sleep', 'predict', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'worn', 'blast', 'barter', 'deflect', 'fireball', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth']
class Game:
@@ -607,12 +626,76 @@ def check_pvp(host, guest, out):
host('command', command='team remove parity_allies')
assert hits['guest hits host'][1] < hits['guest hits host'][0], f'the guest did not hurt the host: {hits}'
assert hits['host hits guest'][1] < hits['host hits guest'][0], f'the host did not hurt the guest: {hits}'
assert hits['pvp off'][1] == hits['pvp off'][0], f'pvp off still hurts: {hits}'
# Natural regeneration may heal the victim meanwhile.
assert hits['pvp off'][1] >= hits['pvp off'][0], f'pvp off still hurts: {hits}'
for name in ('guest hits teammate', 'host hits teammate'):
assert hits[name][1] == hits[name][0], f'friendly fire off still hurts ({name}): {hits}'
return hits
def check_kills(host, guest, out):
# A mob the guest kills is the guest's kill (#484): LivingEntity.die credits lastHurtByPlayer, so the
# killed statistic (and its scoreboard criterion) counts for the guest, not the host.
host('command', command='scoreboard objectives add parity_kills minecraft.killed:minecraft.pig')
for g in (host, guest):
g('command', command='gamemode survival')
guest('command', command='item replace entity @s weapon.mainhand with minecraft:iron_sword')
face_each_other(host, guest)
hx, hy, hz = pos_of(host)
try:
# Between the two, in front of the guest, with one health left.
host('command', command=f'summon minecraft:pig {hx + 1.5:.2f} {hy:.2f} {hz:.2f} {{NoAI:1b,Health:1.0f}}')
guest.wait(30)
guest.raw('look-at', f'{hx + 1.5:.2f}', f'{hy + 0.5:.2f}', f'{hz:.2f}')
guest.wait(10)
guest.raw('attack')
guest.wait(20)
host('command', command=f'scoreboard players get {GUEST_NAME} parity_kills')
host('command', command=f'scoreboard players get {host.player} parity_kills')
host.wait(10)
chat = host.raw('messages', 10)['chat']
guest.shot(out, 'kills')
finally:
host('command', command='kill @e[type=minecraft:pig]')
host('command', command='scoreboard objectives remove parity_kills')
assert any(f'{GUEST_NAME} has 1 [parity_kills]' in line for line in chat), f"the guest's kill is not theirs: {chat}"
assert not any(f'{host.player} has 1 [parity_kills]' in line for line in chat), f"the host got the guest's kill: {chat}"
return chat
def check_arrows(host, guest, out):
# A player's arrow on another player (#484): AbstractArrow.onHitEntity, refused by
# ServerPlayer.canHarmPlayer with the pvp game rule off (the arrow turns back).
for g in (host, guest):
g('command', command='gamemode survival')
g('command', command='clear @s')
g('command', command='item replace entity @s weapon.mainhand with minecraft:bow')
g('command', command='give @s minecraft:arrow 16')
hits = {}
try:
for name, rule, shooter in (('guest shoots host', 'true', guest), ('host shoots guest', 'true', host),
('pvp off', 'false', guest)):
host('command', command=f'gamerule pvp {rule}')
for g in (host, guest):
g('command', command='effect give @s minecraft:instant_health 1 5')
face_each_other(host, guest)
shooter.wait(20)
victim = (lambda: host('state')['player']['health']) if shooter is guest else (lambda: remote(guest)['health'])
before = victim()
shooter.raw('use-item', '--hold', 1.3) # a full draw (BowItem: 20 ticks)
shooter.wait(20)
hits[name] = (before, victim())
shooter.shot(out, 'arrows-' + name.replace(' ', '-'))
finally:
host('command', command='gamerule pvp true')
for g in (host, guest):
g('command', command='clear @s')
assert hits['guest shoots host'][1] < hits['guest shoots host'][0], f"the guest's arrow did not hurt the host: {hits}"
assert hits['host shoots guest'][1] < hits['host shoots guest'][0], f"the host's arrow did not hurt the guest: {hits}"
assert hits['pvp off'][1] >= hits['pvp off'][0], f'pvp off, an arrow still hurts: {hits}'
return hits
def dead_players(game, want, ticks=60):
"""The other players `game`'s client draws dead, once that is `want` (empty or not) or after `ticks`."""
for _ in range(ticks // 5):
@@ -1255,6 +1338,50 @@ def check_sleep(host, guest, out):
assert lying['host'] and lying['guest'], f'a sleeping player is drawn standing: {detail}'
assert not lying['after'], f'a player up again is still drawn lying: {detail}'
return detail
def check_predict(host, guest, out):
# MultiPlayerGameMode.useItemOn under startPrediction (#869): the guest's door opens on its own screen
# at once, with the host (the server) frozen, and the server's answer later agrees; an iron door
# (no hand use) stays shut on both sides.
guest('command', command='gamemode survival')
guest('command', command='clear @s')
x, y, z = (int(v // 1) for v in pos_of(guest))
wood, iron = (x - 1, y, z + 2), (x + 1, y, z + 2)
for (bx, by, bz), kind in ((wood, 'oak_door'), (iron, 'iron_door')):
for half, dy in (('lower', 0), ('upper', 1)):
host('command', command=f'setblock {bx} {by + dy} {bz} minecraft:{kind}[facing=north,hinge=right,half={half}]')
guest.wait(20)
state = lambda game, at: game.raw('block', *at)['state']
seen = {}
creaks = lambda game: sum(n for s, n in game('status')['heard'].items() if 'door' in s)
heard = {'guest': creaks(guest), 'host': creaks(host)}
os.kill(host.pid, signal.SIGSTOP)
try:
guest.raw('interact', *wood)
seen['guest_frozen'] = (state(guest, wood), state(guest, (wood[0], wood[1] + 1, wood[2])))
# level.playSound(player, ...): the clicker hears its own door at once.
seen['guest_heard_frozen'] = creaks(guest) - heard['guest']
guest.raw('interact', *iron)
seen['guest_iron_frozen'] = state(guest, iron)
finally:
os.kill(host.pid, signal.SIGCONT)
guest.wait(20)
seen['guest_after'] = state(guest, wood)
seen['host_after'] = state(host, wood)
seen['iron_after'] = (state(guest, iron), state(host, iron))
# ... and not a second time from the server; the host hears it once.
seen['heard_after'] = {'guest': creaks(guest) - heard['guest'], 'host': creaks(host) - heard['host']}
guest.shot(out, 'predict')
for (bx, by, bz) in (wood, iron):
host('command', command=f'fill {bx} {by} {bz} {bx} {by + 1} {bz} minecraft:air')
assert all('open=true' in s for s in seen['guest_frozen']), f'the door waited for the server: {seen}'
assert 'open=true' in seen['guest_after'] and 'open=true' in seen['host_after'], f'the door did not stay open: {seen}'
assert 'open=false' in seen['guest_iron_frozen'], f'the guest opened an iron door by hand: {seen}'
assert all('open=false' in s for s in seen['iron_after']), f'an iron door opened: {seen}'
assert seen['guest_heard_frozen'] == 1 and seen['heard_after'] == {'guest': 1, 'host': 1}, \
f'the door is not heard once on each side: {seen}'
return seen
def check_push(host, guest, out):
guest('command', command='gamemode survival')
x, y, z = (int(v // 1) + 0.5 for v in pos_of(guest))
@@ -1584,6 +1711,56 @@ def check_projectiles(host, guest, out):
return f'{len(theirs)} identical, fuses (host, guest) {fuses}'
def check_blast(host, guest, out):
guest('command', command='gamemode survival')
guest('command', command='clear @s')
host('command', command='gamemode creative')
x, y, z = (int(v // 1) for v in pos_of(host))
gx, gz = x + 6, z
floor = f'fill {gx - 6} {y - 1} {gz - 4} {gx + 6} {y - 1} {gz + 4} minecraft:bedrock'
detail = {}
try:
for shielded in (False, True):
if remote(guest)['health'] <= 0:
guest.raw('respawn')
guest.wait(40)
host('command', command=floor)
host('command', command=f'fill {gx - 6} {y} {gz - 4} {gx + 6} {y + 3} {gz + 4} minecraft:air')
guest('command', command=f'tp @s {gx + 0.5} {y} {gz + 0.5}')
guest('command', command='effect give @s minecraft:instant_health 1 5')
guest.wait(30)
hold = None
if shielded:
guest('command', command='item replace entity @s weapon.offhand with minecraft:shield')
guest.wait(5)
guest.raw('look-at', gx + 5.5, y + 0.5, gz + 0.5)
hold = threading.Thread(target=guest.raw, args=('use-item', '--hold', 2.5))
hold.start()
time.sleep(0.5)
before = remote(guest)['health']
at = pos_of(guest)
# Five blocks off: a blast that hurts without killing (about 14 at full exposure).
host('command', command=f'summon minecraft:tnt {gx + 5.5} {y} {gz + 0.5} {{fuse:10s}}')
# The guest's own controller is busy holding the shield up: the host waits.
host.wait(14)
after = remote(guest)['health']
moved = pos_of(guest)
if hold:
hold.join()
guest.shot(out, f'blast-{"shield" if shielded else "open"}')
detail['shield' if shielded else 'open'] = {
'before': before, 'after': after, 'pushed': round(at[0] - moved[0], 2)}
finally:
host('command', command='gamemode survival')
guest('command', command='clear @s')
host('command', command=floor)
open_, shield = detail['open'], detail['shield']
assert open_['after'] < open_['before'], f'the blast never hurt the guest: {detail}'
assert open_['pushed'] > 0, f'the blast never pushed the guest away: {detail}'
assert shield['after'] >= shield['before'], f'the shield did not stop the blast: {detail}'
return detail
def light_differences(host, guest, lo, hi):
"""Positions of the box loaded on both sides, and those whose sky or block light differ."""
h, g = host.raw('light', *lo, *hi), guest.raw('light', *lo, *hi)
@@ -1697,6 +1874,203 @@ def check_light(host, guest, out):
return results
def check_fireball(host, guest, out):
x, y, z = (int(v // 1) for v in pos_of(host))
fx, fz = x + 4, z
# A stone floor, a dispenser facing down three blocks over it, a fire charge in it, powered.
host('command', command=f'fill {fx - 2} {y - 1} {fz - 2} {fx + 2} {y - 1} {fz + 2} minecraft:stone')
host('command', command=f'fill {fx - 2} {y} {fz - 2} {fx + 2} {y + 4} {fz + 2} minecraft:air')
host('command', command=f'setblock {fx} {y + 3} {fz} minecraft:dispenser[facing=down]')
host('command', command=f'item replace block {fx} {y + 3} {fz} container.0 with minecraft:fire_charge')
seen, gone = {}, None
try:
host('command', command=f'setblock {fx} {y + 4} {fz} minecraft:redstone_block')
host.wait(10)
seen = {'host': host.raw('block', fx, y, fz).get('block'),
'guest': guest.raw('block', fx, y, fz).get('block')}
# FireBlock.tick every 30-39 ticks ages it by one a third of the time; past age 3 it goes.
for waited in range(40, 1240, 40):
host.wait(40)
if host.raw('block', fx, y, fz).get('block') == 'minecraft:air':
gone = waited
break
guest.wait(5)
seen['guest_after'] = guest.raw('block', fx, y, fz).get('block')
finally:
host('command', command=f'fill {fx - 2} {y} {fz - 2} {fx + 2} {y + 4} {fz + 2} minecraft:air')
assert seen.get('host') == 'minecraft:fire' and seen.get('guest') == 'minecraft:fire', \
f'no fire where the fire charge landed: {seen}'
assert gone is not None, f'the fire on stone never went out (1200 ticks): {seen}'
assert seen['guest_after'] == 'minecraft:air', f'the guest still sees the fire: {seen}'
return {'out_after_ticks': gone, **seen}
def check_deflect(host, guest, out):
"""The host punches a ghast's fireball back: it flies along the host's view and kills the ghast
(Player.attack: AIM_DEFLECT on #redirectable_projectile; Ghast.isReflectedFireball). The ghast is caged
(a window toward the host); the game runs at 4 ticks a second, and once the fireball is within 4.5 blocks
the host looks at the ghast and clicks."""
if SERVER_THREAD:
# The fireball's position and the host's hurts are read from the host's own level.
return 'skipped (in-frame only)'
x, y, z = (int(v // 1) for v in pos_of(host))
guest('command', command='gamemode creative')
host('command', command='gamemode survival')
host('command', command='difficulty normal')
gx, gz = x, z + 30
gy = y + 20
host('command', command=f'fill {gx - 3} {gy - 1} {gz - 3} {gx + 24} {gy - 1} {gz + 3} minecraft:glass')
host('command', command=f'fill {gx - 3} {gy} {gz - 3} {gx + 24} {gy + 8} {gz + 3} minecraft:air')
host('command', command=f'tp @s {gx + 0.5} {gy} {gz + 0.5} -90 0')
host.wait(20)
host.raw('hurtlog')
# The ghast in a glass cage it can't drift out of, a 3 x 3 window toward the host.
host('command', command=f'fill {gx + 13} {gy} {gz - 3} {gx + 19} {gy + 6} {gz + 3} minecraft:glass hollow')
host('command', command=f'fill {gx + 13} {gy + 2} {gz - 1} {gx + 13} {gy + 4} {gz + 1} minecraft:air')
host('command', command=f'summon minecraft:ghast {gx + 16.5} {gy + 1} {gz + 0.5}')
eye = (gx + 0.5, gy + 1.62, gz + 0.5)
host('command', command='tick rate 4')
turned, near, ghast, hurt = None, None, None, []
try:
deadline = time.monotonic() + 120
while time.monotonic() < deadline:
balls = [q for q in host.raw('status')['projectiles'] if q['kind'] == 'LargeFireball']
near = min((math.dist(q['position'], eye) for q in balls), default=None)
if near is not None and near < 4.5:
g = [m['pos'] for m in host.raw('mobs', 60).get('near', []) if m['kind'].endswith('ghast')][0]
host.raw('look-at', f'{g[0]:.2f}', f'{g[1] + 2:.2f}', f'{g[2]:.2f}')
host.raw('mouse', 'left', 'down')
host.raw('mouse', 'left', 'up')
turned = near
break
host('command', command='tick rate 20')
host.wait(60)
ghast = [m for m in host.raw('mobs', 60).get('near', []) if m['kind'].endswith('ghast') and m['health'] > 0]
hurt = [h for pl in host.raw('hurtlog')['players'] if pl['name'] == 'host' for h in pl['hurts']
if 'fireball' in h['source'] or 'explosion' in h['source']]
finally:
host('command', command='tick rate 20')
host('command', command='kill @e[type=minecraft:ghast]')
host('command', command=f'fill {gx - 3} {gy - 1} {gz - 3} {gx + 24} {gy + 8} {gz + 3} minecraft:air')
guest('command', command='gamemode survival')
assert turned is not None, f'no fireball came within 4.5 blocks (nearest {near})'
assert not hurt, f'the host was hit: {hurt}'
assert not ghast, f'the ghast lived: the fireball was not turned back ({ghast})'
return {'struck_at': round(turned, 2)}
def check_barter(host, guest, out):
"""The guest, in gold boots, drops a gold ingot to a piglin: the piglin stays calm, takes it, and throws its
barter toward the nearest player, the guest (PiglinAi.throwItemsTowardPlayer: NEAREST_VISIBLE_PLAYER), who
picks it up. The host is nearby on the other side, so a barter thrown at the host misses the guest. A glass
corridor (the hollow box) keeps the piglin between them."""
x, y, z = (int(v // 1) for v in pos_of(host))
cz = z + 4
host('command', command='gamemode creative')
guest('command', command='gamemode survival')
guest('command', command='clear @s')
guest('command', command='effect give @s minecraft:instant_health 1 5')
host('command', command=f'fill {x + 1} {y - 1} {cz - 1} {x + 8} {y + 2} {cz + 1} minecraft:glass hollow')
host('command', command=f'fill {x + 2} {y - 1} {cz} {x + 7} {y - 1} {cz} minecraft:stone')
host('command', command=f'tp @s {x - 0.5} {y} {cz + 0.5} -90 0')
guest('command', command=f'tp @s {x + 7.3} {y} {cz + 0.5} 90 30')
guest('command', command='item replace entity @s armor.feet with minecraft:golden_boots')
guest('command', command='give @s minecraft:gold_ingot 1')
host('command', command=f'summon minecraft:piglin {x + 4.5} {y} {cz + 0.5} {{IsImmuneToZombification:1b}}')
guest.wait(20)
before = remote(guest)['health']
kept = dict(guest('inventory')['counts'])
try:
guest.raw('select', 'minecraft:gold_ingot')
guest.raw('key', 'q', 'tap')
bought, trace = {}, []
for _ in range(20):
guest.wait(20)
trace.append([(e['type'].split(':')[-1], round(e['pos'][0] - x, 1), round(e['pos'][2] - cz, 1))
for e in host.raw('entities', 24)['entities'] if e['type'] in ('minecraft:item', 'minecraft:piglin')])
counts = guest('inventory')['counts']
bought = {k: n - kept.get(k, 0) for k, n in counts.items()
if k not in ('minecraft:gold_ingot', 'minecraft:golden_boots') and n > kept.get(k, 0)}
if bought:
guest.wait(40)
break
counts = guest('inventory')['counts']
bought = {k: n - kept.get(k, 0) for k, n in counts.items()
if k not in ('minecraft:gold_ingot', 'minecraft:golden_boots') and n > kept.get(k, 0)}
piglins = [m for m in host.raw('mobs', 20).get('near', []) if m['kind'].split(':')[-1] == 'piglin']
health = remote(guest)['health']
finally:
host('command', command=f'kill @e[type=minecraft:piglin,x={x},y={y - 2},z={cz - 2},dx=10,dy=6,dz=4]')
# What lies on the floor, on the host's side of the piglin's start and on the guest's.
floor = [host('command', command=f'kill @e[type=minecraft:item,x={x0},y={y - 2},z={cz - 3},dx={dx},dy=6,dz=6]')
['chat'][0] for x0, dx in ((x - 2, 6.5), (x + 4.5, 6))]
host('command', command=f'fill {x + 1} {y - 1} {cz - 1} {x + 8} {y + 2} {cz + 1} minecraft:air')
host('command', command=f'fill {x - 8} {y - 1} {z - 8} {x + 8} {y - 1} {z + 8} minecraft:stone')
guest('command', command='clear @s')
host('command', command='gamemode survival')
assert piglins, 'the piglin is gone'
assert health >= before, f'the piglin hurt the guest in gold boots: {before} -> {health}'
assert bought, f'no barter reached the guest (on the floor, host side then guest side: {floor}; items and the piglin, every second: {trace})'
return {'bought': bought, 'floor': floor}
def check_worn(host, guest, out):
pieces = ['iron_helmet', 'iron_chestplate', 'iron_leggings', 'iron_boots']
guest('command', command='gamemode survival')
taken = {}
try:
for worn in (False, True):
guest('command', command='clear @s')
if remote(guest)['health'] <= 0:
guest.raw('respawn')
guest.wait(40)
if worn:
for piece in pieces:
guest('command', command=f'give @s minecraft:{piece}')
guest.wait(10)
# Shift-clicked from the hotbar onto the body in the inventory menu (the hub moves them).
guest.raw('key', 'e', 'tap')
guest.raw('wait-for', 'screen', 'inventory')
for piece in pieces:
guest.raw('click-slot', hotbar_slot(guest, f'minecraft:{piece}'), 'shift')
guest.wait(2)
guest.raw('key', 'esc', 'tap')
guest.wait(5)
guest('command', command='effect give @s minecraft:instant_health 1 5')
guest.wait(30)
before = remote(guest)['health']
if not SERVER_THREAD:
host.raw('hurtlog')
# A mob's blow (no attacker: no difficulty scaling); armour counts against it.
guest('command', command='damage @s 10 minecraft:mob_attack')
if SERVER_THREAD:
# The server's hurt log isn't on a control socket here: the health the guest is
# sent, read as soon as it drops (natural regeneration heals it again after).
health = before
for _ in range(40):
guest.wait(1)
health = remote(guest)['health']
if health < before:
break
taken['worn' if worn else 'bare'] = [round(before - health, 2)]
continue
guest.wait(10)
log = [h for p in host.raw('hurtlog')['players'] if p['name'] == GUEST_NAME for h in p['hurts']]
taken['worn' if worn else 'bare'] = [(h['amount'], h['armor'], round(h['taken'], 2)) for h in log]
finally:
guest('command', command='clear @s')
guest('command', command='effect give @s minecraft:instant_health 1 5')
if SERVER_THREAD:
# Natural regeneration may heal up to a point before the health arrives.
assert len(taken['bare']) == 1 and 9.0 <= taken['bare'][0] <= 10.0, f'10 damage on no armour: {taken}'
assert len(taken['worn']) == 1 and 5.0 <= taken['worn'][0] <= 6.0, \
f'10 damage through iron armour (15) should take 6: {taken}'
return taken
assert taken['bare'] == [(10.0, 0.0, 10.0)], f'10 damage on no armour: {taken}'
assert taken['worn'] == [(10.0, 15.0, 6.0)], f'10 damage through iron armour (15) should take 6: {taken}'
return taken
CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'nametags': check_nametags,
'chest': check_chest, 'crafting': check_crafting, 'sign': check_sign, 'damage': check_damage,
'mobs': check_mobs, 'hazards': check_hazards, 'pvp': check_pvp,
@@ -1709,10 +2083,10 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name
'recipes': check_recipes, 'trials': check_trials, 'walls': check_walls,
'effects': check_effects, 'portals': check_portals, 'distance': check_distance, 'clicks': check_clicks,
'sleep': check_sleep, 'push': check_push, 'eat': check_eat, 'eating': check_eating,
'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles,
'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles, 'blast': check_blast,
'light': check_light, 'plates': check_plates,
'swings': check_swings, 'cracks': check_cracks,
'time': check_time, 'growth': check_growth}
'time': check_time, 'growth': check_growth, 'fireball': check_fireball, 'deflect': check_deflect, 'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'arrows': check_arrows, 'predict': check_predict}
def run(ctl, out, resources, checks):
@@ -1721,7 +2095,7 @@ def run(ctl, out, resources, checks):
host.d.env['HORIZON_SERVER_THREAD'] = '1'
results = {}
try:
host('launch', wait=False, offscreen=sys.platform == 'darwin')
host.pid = host('launch', wait=False, offscreen=sys.platform == 'darwin')['pid']
# Guests' commands need the world's Allow Commands as well as the LAN's (#372): a creative
# world has them; everyone plays in survival.
host.raw('open', 'Lan', 5, 'creative')