Give polar bears their attack AI and rearing pose

Polar bears only panicked and strolled. They now follow vanilla's goals: melee attack that rears up and growls before each strike, hurt-by and cub-defending targets, anger at the player, and fox hunting. A hurt cub calls the adults. The standing flag is synched and the client animates it.
This commit is contained in:
Kacpherek
2026-10-26 20:50:13 +01:00
parent b6a2bb2c0d
commit c85f6f2e39
8 changed files with 250 additions and 3 deletions
+8
View File
@@ -337,6 +337,14 @@ fn mob_meta(
}
defaults.push((17, serializer::BOOLEAN, Value::Bool(false)));
}
// PolarBear.DATA_STANDING_ID (after AgeableMob's two): the bear
// rears up; the client animates it.
"minecraft:polar_bear" => {
if e.flag {
meta.push((18, serializer::BOOLEAN, Value::Bool(true)));
}
defaults.push((18, serializer::BOOLEAN, Value::Bool(false)));
}
// SpellcasterIllager.DATA_SPELL_CASTING_ID: the casting pose.
"minecraft:evoker" | "minecraft:illusioner" => {
if e.variant2 != 0 {
+4
View File
@@ -3517,6 +3517,10 @@ impl Game<'_> {
) {
horizon_client::mobs::guardian::client_tick(m);
}
// PolarBear.tick: the stand animation follows the synched flag.
if m.species() == horizon_client::mobs::Species::PolarBear {
horizon_client::mobs::polar_bear::client_tick(m);
}
if m.hurt_time > 0 {
m.hurt_time -= 1;
}
@@ -59,6 +59,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
Who::Mob(*target as u32)
});
}
// PolarBear.DATA_STANDING_ID: the client animates the rearing.
(Species::PolarBear, 18, Value::Bool(standing)) => m.extra.flag = *standing,
// Bat.DATA_ID_FLAGS: resting in bit 0.
(Species::Bat, 16, Value::Byte(flags)) => bat::set_resting(m, flags & 1 != 0),
// Sheep.DATA_WOOL_ID: the colour in the low nibble, 16 sheared.
+1
View File
@@ -50,6 +50,7 @@ pub mod nether;
pub mod path;
pub mod phantom;
pub mod piglin;
pub mod polar_bear;
pub mod rabbit;
pub mod raider;
pub mod ravager;
+4
View File
@@ -106,6 +106,7 @@ pub enum Family {
Strider,
Bat,
Bee,
PolarBear,
}
pub fn family(s: Species) -> Family {
use Species as S;
@@ -167,6 +168,7 @@ pub fn family(s: Species) -> Family {
S::Strider => Family::Strider,
S::Bat => Family::Bat,
S::Bee => Family::Bee,
S::PolarBear => Family::PolarBear,
_ => Family::Generic,
}
}
@@ -224,6 +226,7 @@ pub fn register(m: &mut Mob) {
Family::Strider => super::strider::register(m),
Family::Bat => super::bat::register(m),
Family::Bee => super::bee::register(m),
Family::PolarBear => super::polar_bear::register(m),
}
// FloatGoal's constructor lets the navigation float, as do the
// constructors of these brain-driven and flying mobs. A floater rises
@@ -984,6 +987,7 @@ fn species_ai_step(
Species::Wither => super::wither::ai_step(m, w, events),
Species::Allay => super::allay::ai_step(m),
Species::Bee => super::bee::ai_step(m, w),
Species::PolarBear => super::polar_bear::ai_step(m, w),
Species::Breeze => super::breeze::ai_step(m),
Species::Sniffer => super::sniffer::ai_step(m, events),
Species::HappyGhast => super::happy_ghast::ai_step(m, w),
+1 -1
View File
@@ -959,7 +959,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
let st = &m.anim.states;
match m.species() {
Species::Goat => goat(p, s, &Goat::from_mob(m)),
Species::PolarBear => polar_bear(p, s, 0.0),
Species::PolarBear => polar_bear(p, s, super::polar_bear::standing_scale(m, s.partial)),
Species::Panda => panda(p, s, &Panda::default()),
Species::Llama | Species::TraderLlama => {
llama(p, s, m.extra.chested && !s.baby);
+39 -2
View File
@@ -1017,6 +1017,8 @@ pub struct MeleeAttack {
pub speed: f64,
pub follow_unseen: bool,
pub zombie: bool,
/// `PolarBear.PolarBearMeleeAttackGoal`: rears up before each strike.
pub polar_bear: bool,
path_target: [f64; 3],
recalc: i32,
pub until_attack: i32,
@@ -1031,6 +1033,7 @@ impl MeleeAttack {
speed,
follow_unseen,
zombie: false,
polar_bear: false,
path_target: [0.0; 3],
recalc: 0,
until_attack: 0,
@@ -1043,6 +1046,10 @@ impl MeleeAttack {
self.zombie = true;
self
}
pub fn polar_bear(mut self) -> Self {
self.polar_bear = true;
self
}
pub fn interval(mut self, ticks: i32) -> Self {
self.interval = ticks;
self
@@ -1098,6 +1105,9 @@ impl Goal for MeleeAttack {
}
m.ai.aggressive = false;
m.nav_stop();
if self.polar_bear {
super::polar_bear::set_standing(m, false);
}
}
fn every_tick(&self) -> bool {
true
@@ -1131,7 +1141,17 @@ impl Goal for MeleeAttack {
self.recalc = adjusted(true, self.recalc);
}
self.until_attack = (self.until_attack - 1).max(0);
if self.until_attack <= 0 && m.within_melee_range(&t) && m.sees(cx.w, who) {
if self.polar_bear {
let cooldown = adjusted(true, self.interval);
super::polar_bear::check_and_perform_attack(
&mut self.until_attack,
cooldown,
m,
who,
&t,
cx,
);
} else if self.until_attack <= 0 && m.within_melee_range(&t) && m.sees(cx.w, who) {
self.until_attack = adjusted(true, self.interval);
m.swing();
super::ai::do_hurt_target(m, who, cx);
@@ -1422,6 +1442,9 @@ pub struct HurtByTarget {
/// `Bee.BeeHurtByOtherGoal`: kept only while angry, and alerting others
/// only when the attacker is in sight.
pub bee: bool,
/// `PolarBear.PolarBearHurtByTargetGoal`: a hurt cub only calls the
/// adult bears and drops the target itself.
pub polar_bear: bool,
timestamp: i32,
st: TargetState,
}
@@ -1432,6 +1455,7 @@ impl HurtByTarget {
alert_except: vec![],
ignore: vec![],
bee: false,
polar_bear: false,
timestamp: 0,
st: TargetState {
unseen_memory: 300,
@@ -1451,6 +1475,10 @@ impl HurtByTarget {
self.bee = true;
self
}
pub fn polar_bear(mut self) -> Self {
self.polar_bear = true;
self
}
}
impl Default for HurtByTarget {
fn default() -> Self {
@@ -1462,6 +1490,8 @@ impl Goal for HurtByTarget {
fn name(&self) -> &'static str {
if self.bee {
"BeeHurtByOtherGoal"
} else if self.polar_bear {
"PolarBearHurtByTargetGoal"
} else {
"HurtByTarget"
}
@@ -1500,7 +1530,9 @@ impl Goal for HurtByTarget {
self.timestamp = m.ai.last_hurt_by_time;
self.st.unseen_memory = 300;
self.st.unseen = 0;
if self.alert
// PolarBearHurtByTargetGoal.start: a cub alerts the adults itself.
let cub = self.polar_bear && m.is_baby();
if (self.alert || cub)
&& let Some(by) = m.ai.target
{
let range = m.attrs.follow_range;
@@ -1520,6 +1552,8 @@ impl Goal for HurtByTarget {
&& (s.position.z - pos.z).abs() <= range + 1.0
})
.filter(|s| !self.alert_except.contains(&s.species))
// PolarBearHurtByTargetGoal.alertOther: adults only.
.filter(|s| !(self.polar_bear && s.baby))
.filter(|s| Who::Mob(s.id) != by)
.map(|s| s.id)
.collect();
@@ -1534,6 +1568,9 @@ impl Goal for HurtByTarget {
});
}
}
if cub {
m.ai.target = None;
}
}
fn stop(&mut self, m: &mut Mob, _: &mut Cx) {
m.ai.target = None;
@@ -0,0 +1,191 @@
//! Polar bears (`PolarBear`): a neutral animal that defends its cubs,
//! fights back when hurt, and rears up before each swing. A cub flees what
//! hurts it and calls the adults.
//!
//! `extra.flag` is `DATA_STANDING_ID`, `extra.counter` the warning sound's
//! delay, `extra.anger` the `NeutralMob` anger left and `extra.flag2` whether
//! the player is who it is angry at. `anim.v[STAND]` is
//! `clientSideStandAnimation`.
use horizon_core::{geometry::Vec3, random::RandomSource};
use super::{
DamageKind, Mob, MobWorld, Species, Who,
goals::{
Cx, Float, FollowParent, Goal, HurtByTarget, LookAtPlayer, MOVE, MeleeAttack,
NearestTarget, Panic, RandomLookAround, Stroll, goal_clone,
},
world::TargetInfo,
};
/// `anim.v` slot of `clientSideStandAnimation`.
pub const STAND: usize = 0;
/// `STAND_ANIMATION_TICKS`.
const STAND_TICKS: f32 = 6.0;
pub fn register(m: &mut Mob) {
let g = &mut m.ai.goals;
g.add(0, Float);
g.add(1, MeleeAttack::new(1.25, true).polar_bear());
g.add(1, PolarBearPanic(Panic::new(2.0)));
g.add(4, FollowParent::new(1.25));
g.add(5, Stroll::new(1.0));
g.add(6, LookAtPlayer::new(6.0));
g.add(7, RandomLookAround::default());
let t = &mut m.ai.targets;
t.add(1, HurtByTarget::new().polar_bear());
// PolarBearAttackPlayersGoal: players near a cub, within half the
// follow range, never for a cub itself.
t.add(
2,
NearestTarget::player(true)
.interval(20)
.follow_scale(0.5)
.reach()
.gate(|m, _| !m.is_baby())
.when(cub_nearby)
.named("PolarBearAttackPlayersGoal"),
);
t.add(
3,
NearestTarget::player(true).when(|m, _| m.extra.anger > 0 && m.extra.flag2),
);
t.add(
4,
NearestTarget::species(&[Species::Fox], true)
.interval(10)
.reach()
.when(|m, _| !m.is_baby()),
);
}
/// `PolarBearAttackPlayersGoal.canUse`: a polar bear cub within 8 blocks
/// (4 up and down).
fn cub_nearby(m: &Mob, w: &MobWorld) -> bool {
let area = m.bounds().inflate(Vec3::new(8.0, 4.0, 8.0));
w.others_near(area)
.any(|s| s.species == Species::PolarBear && s.baby && s.bounds.intersects(area))
}
/// `PanicGoal` with a function of the bear's age for the damage tag: a cub
/// panics at `PANIC_CAUSES`, an adult only at `PANIC_ENVIRONMENTAL_CAUSES`.
#[derive(Clone, Debug)]
struct PolarBearPanic(Panic);
impl Goal for PolarBearPanic {
goal_clone!();
fn flags(&self) -> u8 {
MOVE
}
fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
(m.is_baby() || environmental_panic(m)) && self.0.can_use(m, cx)
}
fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
self.0.can_continue(m, cx)
}
fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
self.0.start(m, cx)
}
fn stop(&mut self, m: &mut Mob, cx: &mut Cx) {
self.0.stop(m, cx)
}
}
/// `DamageTypeTags.PANIC_ENVIRONMENTAL_CAUSES` (fire, lava, cactus), or
/// burning.
fn environmental_panic(m: &Mob) -> bool {
m.fire_ticks > 0 && !m.kind.flags.fire_immune
|| m.last_damage.is_some_and(|(d, t)| {
matches!(
d.kind,
DamageKind::OnFire | DamageKind::InFire | DamageKind::Lava | DamageKind::Cactus
) && i64::from(m.age) - t <= 40
})
}
/// `PolarBear.setStanding`.
pub fn set_standing(m: &mut Mob, standing: bool) {
m.extra.flag = standing;
}
/// `PolarBear.playWarningSound`.
fn play_warning_sound(m: &mut Mob, cx: &mut Cx) {
if m.extra.counter <= 0 {
m.voice("entity.polar_bear.warning", cx.events);
m.extra.counter = 40;
}
}
/// `PolarBearMeleeAttackGoal.checkAndPerformAttack`: strike when ready and
/// in reach, rear up and growl in the last 10 ticks while close.
pub fn check_and_perform_attack(
until_attack: &mut i32,
cooldown: i32,
m: &mut Mob,
who: Who,
t: &TargetInfo,
cx: &mut Cx,
) {
if *until_attack <= 0 && m.within_melee_range(t) && m.sees(cx.w, who) {
*until_attack = cooldown;
super::ai::do_hurt_target(m, who, cx);
set_standing(m, false);
return;
}
let reach = t.bounds.size().x as f32 + 3.0;
if m.distance_sqr(t.position) < f64::from(reach * reach) {
if *until_attack <= 0 {
set_standing(m, false);
*until_attack = cooldown;
}
if *until_attack <= 10 {
set_standing(m, true);
play_warning_sound(m, cx);
}
} else {
*until_attack = cooldown;
set_standing(m, false);
}
}
/// `PolarBear.tick`'s client half: `clientSideStandAnimation` follows the
/// synched standing flag by one tick a tick. A client of a server runs it
/// too.
pub fn client_tick(m: &mut Mob) {
let v = m.anim.v[STAND];
m.anim.vo[STAND] = v;
let step = if m.extra.flag { 1.0 } else { -1.0 };
m.anim.v[STAND] = (v + step).clamp(0.0, STAND_TICKS);
}
/// `PolarBear.getStandingAnimationScale`.
pub fn standing_scale(m: &Mob, partial: f32) -> f32 {
m.anim.lerp(STAND, partial) / STAND_TICKS
}
/// `PolarBear.tick`: the stand animation, the warning sound's delay and
/// `NeutralMob.updatePersistentAnger`.
pub fn ai_step(m: &mut Mob, w: &MobWorld) {
client_tick(m);
if m.extra.counter > 0 {
m.extra.counter -= 1;
}
if m.ai.target.is_some() {
// Anger follows the target and starts over every tick it is held:
// 20 to 39 seconds (`PERSISTENT_ANGER_TIME`).
m.extra.flag2 = m.ai.target == Some(Who::Player);
m.extra.anger = 400 + m.random.next_int_bound(381).unwrap_or(0);
} else if m.extra.anger > 0 {
m.extra.anger -= 1;
if m.extra.anger == 0 {
stop_being_angry(m);
}
}
// A player in creative or spectator mode is forgiven at once.
if m.extra.flag2 && w.player.as_ref().is_some_and(|p| p.creative || p.spectator) {
stop_being_angry(m);
}
}
/// `NeutralMob.stopBeingAngry`.
fn stop_being_angry(m: &mut Mob) {
m.ai.last_hurt_by = None;
m.ai.target = None;
m.extra.anger = 0;
m.extra.flag2 = false;
}