Merge pull request #1106 from ludovic111/fix/attack-knockback

🤖 Agent: merged. Verify passes; CI parity passes except dedicated_server, which fails the same way on main (play-pearl teleported 0 vs 1, the known flake in FEATURES.md LATER).
This commit is contained in:
Ludovic Marie
2026-10-21 23:02:44 +02:00
committed by GitHub
4 changed files with 123 additions and 47 deletions
+10
View File
@@ -6718,6 +6718,7 @@ impl Game<'_> {
let target_kind = format!("minecraft:{}", target_kind.trim_start_matches("minecraft:"));
let (amount, scale, crit) = self.melee_damage(&target_kind);
let sweep = self.sweep_attack_position(scale, crit);
let (knockback, knockback_attack) = self.extra_knockback(&target_kind, scale);
self.attack_ticks = 0;
if let Some(p) = self.player.as_mut()
&& !self.creative
@@ -6726,6 +6727,10 @@ impl Game<'_> {
}
let player = self.player.as_ref();
let from = player.map(|p| [p.position.x, p.position.y, p.position.z]);
if knockback_attack {
self.audio
.play("minecraft:entity.player.attack.knockback", from, 1.0, 1.0);
}
self.swing_arm();
// LivingEntity.setLastHurtMob (tamed wolves join in).
self.combat.last_hurt_mob = Some((self.mobs[index].id, self.world.game_time));
@@ -6735,6 +6740,11 @@ impl Game<'_> {
None => horizon_client::mobs::Damage::of(horizon_client::mobs::DamageKind::Generic),
};
if self.hurt_by_player(index, amount, source) {
if knockback > 0.0 {
let (xd, zd) = self.extra_knockback_direction();
self.mobs[index].knockback(f64::from(knockback), xd, zd);
self.stop_sprint_after_extra_knockback();
}
let mob = &self.mobs[index];
// Player.damageStatsAndHearts: the damage the hit actually did.
let actual = old_health - mob.health;
+31 -7
View File
@@ -1440,13 +1440,8 @@ impl Game<'_> {
o.hurt
}
{
let (dx, dz) = (player.position.x - from[0], player.position.z - from[2]);
let l = (dx * dx + dz * dz).sqrt().max(1e-4);
player.velocity = Vec3::new(
player.velocity.x / 2.0 + dx / l * 0.4,
(player.velocity.y / 2.0 + 0.4).min(0.4),
player.velocity.z / 2.0 + dz / l * 0.4,
);
let (xd, zd) = (from[0] - player.position.x, from[2] - player.position.z);
self.knock_back_player(f64::from(0.4_f32), xd, zd);
self.hurt_armor(amount);
self.thorns(from);
}
@@ -1455,6 +1450,35 @@ impl Game<'_> {
}
outcome.hurt
}
/// `LivingEntity.knockback` on the player: pushed `power` away from the
/// direction (`xd`, `zd`), less its knockback resistance, and up only from
/// the ground.
pub(super) fn knock_back_player(&mut self, power: f64, mut xd: f64, mut zd: f64) {
let Some(p) = self.player.as_mut() else {
return;
};
let resistance = p.attribute("minecraft:knockback_resistance").unwrap_or(0.0);
let power = power * (1.0 - resistance);
if power <= 0.0 {
return;
}
while xd * xd + zd * zd < f64::from(1.0e-5_f32) {
let r = &mut self.world.random;
xd = (r.next_double() - r.next_double()) * 0.01;
zd = (r.next_double() - r.next_double()) * 0.01;
}
let l = (xd * xd + zd * zd).sqrt();
let v = p.velocity;
p.velocity = Vec3::new(
v.x / 2.0 - xd / l * power,
if p.ground.on_ground {
(v.y / 2.0 + power).min(0.4)
} else {
v.y
},
v.z / 2.0 - zd / l * power,
);
}
/// A status effect from a mob, arrow or splash potion (`addEffect`).
pub(super) fn give_player_effect(&mut self, effect: &'static str, ticks: i32, amplifier: i32) {
if self.creative || self.spectator() {
@@ -6,7 +6,7 @@
//! the armor attribute effects (respiration, depth strider, ...).
use super::Game;
use horizon_client::{enchant::EffectContext, items::ItemStack};
use horizon_core::{geometry::Vec3, random::RandomSource};
use horizon_core::random::RandomSource;
impl Game<'_> {
/// `Player.getDestroySpeed` after the tool speed: mining efficiency, haste
@@ -84,7 +84,50 @@ impl Game<'_> {
- fx.amplifier("weakness")
.map_or(0.0, |a| 4.0 * (a + 1) as f32)
}
/// After a successful melee hit: knockback enchantment and fire aspect.
/// `Player.attack`'s extra knockback: `getKnockback` (the weapon's knockback
/// enchantment, halved) plus 0.5 for a sprinting full-strength hit, and
/// whether the hit is that knockback attack.
pub(super) fn extra_knockback(&mut self, target_kind: &str, scale: f32) -> (f32, bool) {
let knockback_attack = scale > 0.9 && self.player.as_ref().is_some_and(|p| p.sprinting);
let enchanted = match self.inventory[self.selected].clone() {
Some(held) => {
let ctx = EffectContext {
this: Some(target_kind),
attacker: Some("minecraft:player"),
direct_attacker: Some("minecraft:player"),
is_direct: true,
items: Some(self.res.items()),
..Default::default()
};
self.res.stations().enchantments.modify_value(
Some(&held),
"minecraft:knockback",
&ctx,
&mut self.world.random,
0.0,
)
}
None => 0.0,
};
let bonus = if knockback_attack { 0.5 } else { 0.0 };
(enchanted / 2.0 + bonus, knockback_attack)
}
/// `causeExtraKnockback`'s direction, `(sin yRot, -cos yRot)`: the target
/// flies where the attacker looks, not away from it.
pub(super) fn extra_knockback_direction(&self) -> (f64, f64) {
let yaw = self.yaw.to_radians();
(f64::from(yaw.sin()), -f64::from(yaw.cos()))
}
/// The attacker's side of `causeExtraKnockback` as the attacking client
/// sees it: the server's player stops sprinting, and its flag reaches the
/// client. (The server's 0.6 speed cut never does: the client's own
/// `Player.attack` simulates no hurt, so it skips the knockback.)
pub(super) fn stop_sprint_after_extra_knockback(&mut self) {
if let Some(p) = self.player.as_mut() {
let _ = p.set_sprinting(false);
}
}
/// After a successful melee hit: fire aspect and wind burst.
pub(super) fn post_attack(&mut self, mob: usize) {
let Some(held) = self.inventory[self.selected].clone() else {
return;
@@ -99,34 +142,6 @@ impl Game<'_> {
items: Some(self.res.items()),
..Default::default()
};
let knockback = self.res.stations().enchantments.modify_value(
Some(&held),
"minecraft:knockback",
&ctx,
&mut self.world.random,
0.0,
);
if knockback > 0.0 {
// LivingEntity.knockback(strength * 0.5, sin(yRot), -cos(yRot)).
let strength = f64::from(knockback) * 0.5;
let (s, c) = (
f64::from(self.yaw.to_radians().sin()),
f64::from(self.yaw.to_radians().cos()),
);
let (dx, dz) = (s, -c);
let l = (dx * dx + dz * dz).sqrt().max(1e-5);
let m = &mut self.mobs[mob];
let v = m.velocity;
m.velocity = Vec3::new(
v.x / 2.0 - dx / l * strength,
if m.on_ground {
(v.y / 2.0 + strength).min(0.4)
} else {
v.y
},
v.z / 2.0 - dz / l * strength,
);
}
// minecraft:post_attack ignite effects of the attacker's weapon (fire aspect).
let mut ignite = 0.0f32;
for (id, level) in held.enchantments() {
+37 -10
View File
@@ -20,6 +20,10 @@ pub(super) struct Strike {
crit: bool,
from: [f64; 3],
sweep: Option<[f64; 3]>,
/// `causeExtraKnockback`: its strength and direction (the attacker's
/// yaw), and whether the hit is a sprinting knockback attack.
knockback: (f32, f64, f64),
knockback_attack: bool,
/// The attacker's team, for the victim's `Player.canHarmPlayer`.
team: Option<horizon_client::scoreboard::Team>,
}
@@ -51,8 +55,11 @@ impl Game<'_> {
let Some(mut host) = self.lan.take() else {
return false;
};
if let Some(strike) = self.pvp_strike() {
self.pvp_land(&mut host, Victim::Guest(conn), &strike);
if let Some(strike) = self.pvp_strike()
&& self.pvp_land(&mut host, Victim::Guest(conn), &strike)
&& strike.knockback.0 > 0.0
{
self.stop_sprint_after_extra_knockback();
}
self.lan = Some(host);
true
@@ -77,6 +84,8 @@ impl Game<'_> {
let from = [p.position.x, p.position.y, p.position.z];
let (amount, scale, crit) = self.melee_damage("minecraft:player");
let sweep = self.sweep_attack_position(scale, crit);
let (strength, knockback_attack) = self.extra_knockback("minecraft:player", scale);
let (xd, zd) = self.extra_knockback_direction();
self.attack_ticks = 0;
if let Some(p) = self.player.as_mut()
&& !self.creative
@@ -90,12 +99,15 @@ impl Game<'_> {
crit,
from,
sweep,
knockback: (strength, xd, zd),
knockback_attack,
team: self.player_team().cloned(),
})
}
/// The hit landing on the victim, then the attacker's attack sound.
pub(super) fn pvp_land(&mut self, host: &mut LanHost, victim: Victim, s: &Strike) {
/// 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 {
// ServerPlayer.canHarmPlayer: the pvp game rule, then the victim's
// team (Player.canHarmPlayer: allies only with friendly fire on).
let team = match victim {
@@ -106,15 +118,29 @@ impl Game<'_> {
.and_then(|g| self.score.board.players_team(&g.name)),
};
let harm = horizon_client::scoreboard::teams_allow_damage(team, s.team.as_ref());
if s.knockback_attack {
self.audio.play(
"minecraft:entity.player.attack.knockback",
Some(s.from),
1.0,
1.0,
);
}
// Player.attack: the hurt (with its knockback away from the
// attacker), then causeExtraKnockback along the attacker's yaw.
let land = |g: &mut Self| {
let hurt = g.mob_hits_player(s.amount, s.from, "minecraft:player_attack");
let (strength, xd, zd) = s.knockback;
if hurt && strength > 0.0 {
g.knock_back_player(f64::from(strength), xd, zd);
}
hurt
};
let hurt = self.ui.rules.bool("pvp")
&& harm
&& match victim {
Victim::Host => self.mob_hits_player(s.amount, s.from, "minecraft:player_attack"),
Victim::Guest(conn) => self
.guest_hit_by(host, conn, |g| {
g.mob_hits_player(s.amount, s.from, "minecraft:player_attack")
})
.unwrap_or(false),
Victim::Host => land(self),
Victim::Guest(conn) => self.guest_hit_by(host, conn, land).unwrap_or(false),
};
let sound = match (hurt, s.crit, s.scale > 0.9) {
(false, ..) => "minecraft:entity.player.attack.nodamage",
@@ -127,5 +153,6 @@ impl Game<'_> {
} else {
self.audio.play(sound, Some(s.from), 1.0, 1.0);
}
hurt
}
}