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:
@@ -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,
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user