A player's blow turns a ghast's fireball back

Player.attack on a #minecraft:redirectable_projectile (a ghast's fireball,
a wind charge) deflects it with ProjectileDeflection.AIM_DEFLECT: its
movement becomes the attacker's unit view vector and the attacker its
owner, with the no-damage sound. The crosshair finds these projectiles a
block round their box (AbstractHurtingProjectile.getPickRadius), a remote
client sends the attack for them, and the host turns one a guest strikes
along that guest's view. A fireball a player turned back kills the ghast
it hits (Ghast.isReflectedFireball: no fire immunity, 1000 damage).

lan_e2e.py --check deflect: the host strikes a caged ghast's fireball and
the ghast dies; before, the fireball hit the host.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 6ba02f5205ba0f6ca2e68d4b0dfa53c86b768d82)
This commit is contained in:
Ludovic Marie
2026-10-21 10:40:58 +02:00
parent c1b5fe95d2
commit ba72a097fa
7 changed files with 253 additions and 5 deletions
+5
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;
@@ -6829,6 +6830,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()
+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);
}
}
+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 {
@@ -1127,6 +1127,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;
+12 -1
View File
@@ -3468,7 +3468,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 {
+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()
+57 -2
View File
@@ -91,6 +91,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 +112,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', 'hurt', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'commands', 'recipes', 'machines', 'brewing', 'trials', 'clicks', 'sleep', 'push', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'deflect', 'light', 'time', 'swings', 'cracks', 'plates', 'effects', 'portals', 'distance', 'growth']
class Game:
@@ -1697,6 +1698,60 @@ def check_light(host, guest, out):
return results
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)}
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,
@@ -1712,7 +1767,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour, 'name
'xp': check_xp, 'objects': check_objects, 'projectiles': check_projectiles,
'light': check_light, 'plates': check_plates,
'swings': check_swings, 'cracks': check_cracks,
'time': check_time, 'growth': check_growth}
'time': check_time, 'growth': check_growth, 'deflect': check_deflect}
def run(ctl, out, resources, checks):