Show critical-hit particles on server clients

Queue successful mob and player crit animations until the hub can send them to the attacker and tracking clients. Cover falling, grounded and refused attacks in both host modes. Fixes #1898.

Co-Authored-By: OpenCode (agentrouter/gpt-6.1-sol) <noreply@openai.com>
This commit is contained in:
rdbtCVS
2026-10-26 01:39:30 +00:00
parent 80e1eb20cc
commit 5e2871dbfd
6 changed files with 165 additions and 4 deletions
+6 -4
View File
@@ -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<u32>, 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,
+31
View File
@@ -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<u32>,
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.
+22
View File
@@ -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<u32>,
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",
+3
View File
@@ -73,6 +73,7 @@ pub(super) struct Parked {
lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
lan_entity_events: Vec<(i32, i8, [f64; 3])>,
lan_critical_hits: Vec<(Option<u32>, 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);
@@ -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(
+88
View File
@@ -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()