diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index f9f2a0363..f34eef456 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -1555,6 +1555,8 @@ struct Game<'a> { /// position) for the guests. lan_block_events: Vec<([i32; 3], i32, i32, u32)>, lan_entity_events: Vec<(i32, i8, [f64; 3])>, + /// Successful crits (attacking guest, hit entity), queued while the hub is taken. + lan_critical_hits: Vec<(Option, i32)>, /// Global level events for every guest (`ServerLevel.globalLevelEvent`). lan_global_events: Vec<(i32, [i32; 3], i32)>, /// `ContainerOpenersCounter`: how many players (the host and the guests) @@ -7437,10 +7439,9 @@ impl Game<'_> { self.stats .custom("damage_dealt", (actual * 10.0).round() as i32); if crit { - self.particles.tracking_emitter( - horizon_client::particles::ParticleOptions::simple( - horizon_client::particles::ParticleType::Crit, - ), + self.critical_hit( + self.lan_acting, + self.mobs[index].id as i32, feet, width, height, @@ -12118,6 +12119,7 @@ impl<'a> Game<'a> { lan_events: Vec::new(), lan_block_events: Vec::new(), lan_entity_events: Vec::new(), + lan_critical_hits: Vec::new(), lan_global_events: Vec::new(), lid_openers: HashMap::new(), lan_acting: None, diff --git a/crates/horizon-client/src/game/lan.rs b/crates/horizon-client/src/game/lan.rs index ee7477f28..e2b853b07 100644 --- a/crates/horizon-client/src/game/lan.rs +++ b/crates/horizon-client/src/game/lan.rs @@ -634,6 +634,7 @@ impl Game<'_> { self.world.light_log = None; self.audio.capture = None; self.lan_events.clear(); + self.lan_critical_hits.clear(); self.streaming.extra.clear(); if announce { self.system_message(Text::translate( @@ -1162,8 +1163,30 @@ impl Game<'_> { self.lan_entity_events.push((id, event, at)); } } + /// `ServerPlayer.crit`: this window's emitter, and an animation for the + /// attacker's client and observers once the hub is back in place. + pub(super) fn critical_hit( + &mut self, + attacker: Option, + id: i32, + feet: [f64; 3], + width: f64, + height: f64, + ) { + use horizon_client::particles::{ParticleOptions, ParticleType}; + self.particles.tracking_emitter( + ParticleOptions::simple(ParticleType::Crit), + feet, + width, + height, + ); + if self.audio.capture.is_some() { + self.lan_critical_hits.push((attacker, id)); + } + } /// Send the tick's level events, sounds and mob animations. fn lan_flush_effects(&mut self, host: &mut LanHost) { + let critical_hits = std::mem::take(&mut self.lan_critical_hits); for (kind, pos, data, acting) in std::mem::take(&mut self.lan_events) { if kind == 2001 { host.broken @@ -1236,6 +1259,14 @@ impl Game<'_> { seen.insert(m.id, (m.hurt_time, dead, swing)); } host.mob_state.insert(self.dim, seen); + for (attacker, target) in critical_hits { + let Some(attacker) = attacker.map_or(Some(host.host_entity), |conn| { + host.hub.guest(conn).map(|g| g.entity_id) + }) else { + continue; + }; + host.hub.critical_hit(attacker, target); + } } /// Keep the chunks around every guest loaded. diff --git a/crates/horizon-client/src/game/lan_pvp.rs b/crates/horizon-client/src/game/lan_pvp.rs index 467c4537c..c7c6b6525 100644 --- a/crates/horizon-client/src/game/lan_pvp.rs +++ b/crates/horizon-client/src/game/lan_pvp.rs @@ -32,6 +32,8 @@ pub(super) enum Victim { /// The attacker's side of the hit. pub(super) struct Strike { + /// The attacking guest, kept after their turn through `as_guest` ends. + attacker: Option, amount: f32, scale: f32, crit: bool, @@ -119,6 +121,7 @@ impl Game<'_> { } self.swing_arm(); Some(Strike { + attacker: self.lan_acting, amount, scale, crit, @@ -250,6 +253,25 @@ impl Game<'_> { Victim::Host => land(self), Victim::Guest(conn) => self.guest_struck_by(host, conn, land).unwrap_or(false), }; + if hurt && s.crit { + let target = match victim { + Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)), + Victim::Guest(conn) => host + .hub + .guest(conn) + .and_then(|g| g.motion.as_deref().map(|p| (g.entity_id, p))), + }; + if let Some((id, p)) = target { + let d = p.dimensions; + self.critical_hit( + s.attacker, + id, + [p.position.x, p.position.y, p.position.z], + f64::from(d.width), + f64::from(d.height), + ); + } + } let sound = match (hurt, s.crit, s.scale > 0.9) { (false, ..) => "minecraft:entity.player.attack.nodamage", (true, true, _) => "minecraft:entity.player.attack.crit", diff --git a/crates/horizon-client/src/game/levels.rs b/crates/horizon-client/src/game/levels.rs index 588f425a4..65bf4940f 100644 --- a/crates/horizon-client/src/game/levels.rs +++ b/crates/horizon-client/src/game/levels.rs @@ -73,6 +73,7 @@ pub(super) struct Parked { lan_events: Vec<(i32, [i32; 3], i32, Option)>, lan_block_events: Vec<([i32; 3], i32, i32, u32)>, lan_entity_events: Vec<(i32, i8, [f64; 3])>, + lan_critical_hits: Vec<(Option, i32)>, /// Only the per-level parts of these are used (`swap_level`). anims: BlockEntityAnims, raiding: Raiding, @@ -150,6 +151,7 @@ impl Game<'_> { lan_events: Vec::new(), lan_block_events: Vec::new(), lan_entity_events: Vec::new(), + lan_critical_hits: Vec::new(), anims: Default::default(), raiding: Default::default(), sculk: Default::default(), @@ -197,6 +199,7 @@ impl Game<'_> { swap(&mut self.lan_events, &mut p.lan_events); swap(&mut self.lan_block_events, &mut p.lan_block_events); swap(&mut self.lan_entity_events, &mut p.lan_entity_events); + swap(&mut self.lan_critical_hits, &mut p.lan_critical_hits); let (a, b) = (&mut self.be_anims, &mut p.anims); swap(&mut a.chests, &mut b.chests); swap(&mut a.books, &mut b.books); diff --git a/crates/horizon-client/src/lan/containers.rs b/crates/horizon-client/src/lan/containers.rs index 7e150e7bd..002f95cbb 100644 --- a/crates/horizon-client/src/lan/containers.rs +++ b/crates/horizon-client/src/lan/containers.rs @@ -120,6 +120,21 @@ impl Hub { ); } + /// `ServerPlayer.crit`: send the victim's animation to the players tracking + /// the attacker and the attacker themselves (`sendToTrackingPlayersAndSelf`). + pub fn critical_hit(&self, attacker: i32, target: i32) { + let body = C::Animate(play::Animate { + id: target, + action: 1, + }) + .encode(); + for g in self.guests.iter().filter(|g| { + self.here(g) && (g.entity_id == attacker || g.tracker.is_tracking(attacker)) + }) { + g.sender.send(body.clone()); + } + } + /// `ServerLevel.broadcastDamageEvent`: the clients around show the hurt /// entity's flash and hear its hurt sound. pub fn damage_event( diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 0ec7218d8..84e03fe03 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -6398,5 +6398,93 @@ CHECKS += ['sprint-fov'] CHECK_FNS['sprint-fov'] = check_sprint_fov +def check_critical_hits(host, guest, out): + """#1898: a real falling melee hit emits crits on the attacker and observer. + Grounded hits and refused falling hits emit none, against mobs and players. + """ + x, y, z = map(math.floor, pos_of(host)) + target = [x + 2.5, y, z + 0.5] + tag = 'critical_hit_particles' + seen = {} + host('command', command=f'fill {x - 3} {y - 1} {z - 3} {x + 6} {y - 1} {z + 6} minecraft:stone') + host('command', command=f'fill {x - 3} {y} {z - 3} {x + 6} {y + 5} {z + 6} minecraft:air') + host('command', command='time set midnight') + host('command', command='gamerule natural_health_regeneration false') + try: + for label, player, other in (('host', host, guest), ('guest', guest, host)): + for kind in ('zombie', 'player'): + for hit in ('grounded', 'critical', 'refused'): + case = f'{label}-{kind}-{hit}' + for game in (player, other): + game('command', command='gamemode survival') + game('command', command='clear @s') + game('command', command='effect clear @s') + game('command', command='effect give @s minecraft:instant_health 1 5 true') + player('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}') + other_at = target if kind == 'player' else [x + 0.5, y, z + 4.5] + other('command', command=f'tp @s {other_at[0]} {other_at[1]} {other_at[2]}') + host('command', command=f'gamerule pvp {str(hit != "refused").lower()}') + mob_id = None + if kind == 'zombie': + host('command', command=f'summon minecraft:zombie {target[0]} {y} {target[2]} ' + f'{{NoAI:1b,PersistenceRequired:1b,Invulnerable:{int(hit == "refused")}b,Tags:["{tag}"]}}') + player.wait(20) # full attack charge and paired entities + if kind == 'zombie': + mob = next(m for m in player.raw('mobs', 16)['near'] + if m['kind'] == 'minecraft:zombie' and math.dist(m['pos'], target) < 0.1) + mob_id = mob['id'] + assert mob_seen(other, mob_id), f'{case}: observer has not paired the zombie' + health_before = mob_seen(player, mob_id)['health'] if mob_id is not None else hearts(other)[1] + sound = 'minecraft:entity.player.attack.crit' + sounds_before = {side: heard(g, sound) for side, g in (('own', player), ('other', other))} + + def strike(): + if hit != 'grounded': + player.raw('key', 'space', 'down') + player.wait(1) + player.raw('key', 'space', 'up') + body = None + for _ in range(15): + body = player('state')['player'] + # Let the server record the fall before the attack packet. + if not body['on_ground'] and body['velocity'][1] < -0.2: + break + player.wait(1) + assert body and not body['on_ground'] and body['velocity'][1] < -0.2, \ + f'{case}: jump never reached its falling phase: {body}' + player.raw('look-at', target[0], y + 1, target[2]) + player.raw('mouse', 'left', 'click') + + particles = sparked(player, other, ['crit'], strike) + player.shot(out, f'critical-hits-{kind}-{hit}-{label}') + player.wait(10) # finish the three-tick emitter and health replication + health_after = mob_seen(player, mob_id)['health'] if mob_id is not None else hearts(other)[1] + sounds = {side: heard(g, sound) - sounds_before[side] + for side, g in (('own', player), ('other', other))} + seen[case] = {'particles': particles, 'crit_sounds': sounds, + 'health': [health_before, health_after]} + host('command', command=f'kill @e[tag={tag}]') + assert (health_after == health_before) if hit == 'refused' else (health_after < health_before), \ + f'{case}: unexpected damage: {seen[case]}' + assert all(n == int(hit == 'critical') for n in sounds.values()), \ + f'{case}: the server did not recognize the expected crit: {seen[case]}' + wrong = {case: result for case, result in seen.items() + if any((n <= 0 if case.endswith('-critical') else n != 0) + for n in result['particles'].values())} + assert not wrong, f'critical-hit particles: {wrong}' + return seen + finally: + host('command', command=f'kill @e[tag={tag}]') + host('command', command='gamerule pvp true') + host('command', command='gamerule natural_health_regeneration true') + host('command', command='time set day') + for game in (host, guest): + game.raw('key', 'space', 'up') + + +CHECKS += ['critical-hits'] +CHECK_FNS['critical-hits'] = check_critical_hits + + if __name__ == '__main__': main()