Fix axolotl AI, fluid and fire integration, and world-local progress
Bind resident environment kernels and real fire clocks, fix sprite uploads and flame material, restore swim speed, throttle item lava audio, and emit fire extinguish events. Reset world-entry progress state without deleting saved data. Exact axolotl replay parity remains deferred to issue #64.
This commit is contained in:
@@ -571,6 +571,7 @@ pub fn conditions(v: &Value, ctx: &Entities, w: &dyn World) -> bool {
|
||||
w,
|
||||
)
|
||||
}
|
||||
"minecraft:match_block" => ctx.block_pos.is_some_and(|b| block(v, b, w)),
|
||||
"minecraft:block_state_property" => ctx.block_pos.is_some_and(|b| {
|
||||
let mut pred = serde_json::Map::new();
|
||||
pred.insert("blocks".into(), v["block"].clone());
|
||||
@@ -929,6 +930,24 @@ mod tests {
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn bucket_axolotl_block_advancements_require_the_placed_block() {
|
||||
let ctx = Entities {
|
||||
this: None,
|
||||
origin: [0.0; 3],
|
||||
tool: None,
|
||||
block_pos: Some([0; 3]),
|
||||
};
|
||||
let stone = serde_json::json!({"type":"minecraft:match_block","blocks":"minecraft:stone"});
|
||||
let wheat = serde_json::json!({"type":"minecraft:match_block","blocks":"minecraft:wheat"});
|
||||
assert!(conditions(&stone, &ctx, &Flat));
|
||||
assert!(!conditions(&wheat, &ctx, &Flat));
|
||||
let absent = Entities {
|
||||
block_pos: None,
|
||||
..ctx
|
||||
};
|
||||
assert!(!conditions(&stone, &absent, &Flat));
|
||||
}
|
||||
#[test]
|
||||
fn predicates_match_tags_ranges_and_locations() {
|
||||
let w = Flat;
|
||||
let stone = ItemView {
|
||||
|
||||
@@ -283,6 +283,7 @@ impl PlayerEffects {
|
||||
levitation: self.amplifier("levitation"),
|
||||
resistance: self.amplifier("resistance"),
|
||||
fire_resistance: self.get("fire_resistance").is_some(),
|
||||
dolphins_grace: self.get("dolphins_grace").is_some(),
|
||||
water_breathing: self.get("water_breathing").is_some()
|
||||
|| self.get("conduit_power").is_some(),
|
||||
protection: Vec::new(),
|
||||
@@ -378,6 +379,7 @@ pub struct StatusFlags {
|
||||
pub levitation: Option<i32>,
|
||||
pub resistance: Option<i32>,
|
||||
pub fire_resistance: bool,
|
||||
pub dolphins_grace: bool,
|
||||
pub water_breathing: bool,
|
||||
/// Armor enchantment protection per damage type id (`EnchantmentHelper.getDamageProtection`).
|
||||
pub protection: Vec<(String, f32)>,
|
||||
|
||||
@@ -12,6 +12,8 @@ use horizon_world::block_collision::BlockCollisionRegistry;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ItemEntity {
|
||||
pub health: i32,
|
||||
pub fire_ticks: i32,
|
||||
pub id: u32,
|
||||
pub stack: ItemStack,
|
||||
pub position: Vec3,
|
||||
@@ -22,6 +24,17 @@ pub struct ItemEntity {
|
||||
pub pickup_delay: u32,
|
||||
pub bob_offset: f32,
|
||||
}
|
||||
/// Environment results needed by the entity owner, including lethal lava damage.
|
||||
#[derive(Debug)]
|
||||
pub struct ItemEnvironmentTick {
|
||||
pub alive: bool,
|
||||
pub lava_hurt: bool,
|
||||
}
|
||||
impl ItemEnvironmentTick {
|
||||
pub fn should_play_lava_hurt_sound(&self, tick: u32) -> bool {
|
||||
self.lava_hurt && (!self.alive || tick.is_multiple_of(10))
|
||||
}
|
||||
}
|
||||
impl ItemEntity {
|
||||
pub const WIDTH: f64 = 0.25;
|
||||
pub fn bounds(&self) -> Aabb {
|
||||
@@ -35,6 +48,50 @@ impl ItemEntity {
|
||||
),
|
||||
)
|
||||
}
|
||||
pub fn environment_tick(
|
||||
&mut self,
|
||||
world: &World,
|
||||
facts: &BlockFacts,
|
||||
registry: &horizon_world::registry::BlockRegistry,
|
||||
items: &crate::items::Items,
|
||||
) -> ItemEnvironmentTick {
|
||||
let at = world.block(
|
||||
self.position.x.floor() as i32,
|
||||
(self.position.y + 0.1).floor() as i32,
|
||||
self.position.z.floor() as i32,
|
||||
);
|
||||
let fluid = facts.get(at).fluid;
|
||||
if fluid == Fluid::Water {
|
||||
self.fire_ticks = 0;
|
||||
}
|
||||
if self.fire_ticks > 0 {
|
||||
if self.fire_ticks % 20 == 0
|
||||
&& fluid != Fluid::Lava
|
||||
&& !items.resists_fire(&self.stack, "minecraft:on_fire")
|
||||
{
|
||||
self.health -= 1;
|
||||
}
|
||||
self.fire_ticks -= 1;
|
||||
}
|
||||
let mut lava_hurt = false;
|
||||
if fluid == Fluid::Lava {
|
||||
self.fire_ticks = self.fire_ticks.max(300);
|
||||
if !items.resists_fire(&self.stack, "minecraft:lava") {
|
||||
self.health -= 4;
|
||||
lava_hurt = true;
|
||||
}
|
||||
}
|
||||
if crate::motion::environment::fire_contact(world, registry, self.bounds()) > 0.0 {
|
||||
self.fire_ticks = self.fire_ticks.max(160);
|
||||
if !items.resists_fire(&self.stack, "minecraft:in_fire") {
|
||||
self.health -= 1;
|
||||
}
|
||||
}
|
||||
ItemEnvironmentTick {
|
||||
alive: self.health > 0,
|
||||
lava_hurt,
|
||||
}
|
||||
}
|
||||
/// Returns false when the item should be removed.
|
||||
pub fn tick(
|
||||
&mut self,
|
||||
@@ -59,6 +116,12 @@ impl ItemEntity {
|
||||
self.velocity.y + if self.velocity.y < 0.06 { 5.0e-4 } else { 0.0 },
|
||||
self.velocity.z * 0.99,
|
||||
);
|
||||
} else if facts.get(eye).fluid == Fluid::Lava {
|
||||
self.velocity = Vec3::new(
|
||||
self.velocity.x * 0.95,
|
||||
self.velocity.y + if self.velocity.y < 0.06 { 5.0e-4 } else { 0.0 },
|
||||
self.velocity.z * 0.95,
|
||||
);
|
||||
} else {
|
||||
self.velocity.y -= 0.04;
|
||||
}
|
||||
@@ -431,6 +494,8 @@ impl ItemFrame {
|
||||
/// An armor stand (`ArmorStand`).
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ArmorStand {
|
||||
pub fire_ticks: i32,
|
||||
pub health: f32,
|
||||
pub id: u32,
|
||||
pub position: Vec3,
|
||||
pub velocity: Vec3,
|
||||
@@ -450,6 +515,8 @@ impl ArmorStand {
|
||||
pub const SLOTS: [&'static str; 6] = ["mainhand", "offhand", "feet", "legs", "chest", "head"];
|
||||
pub fn new(id: u32, position: Vec3, yaw: f32) -> Self {
|
||||
Self {
|
||||
fire_ticks: 0,
|
||||
health: 20.0,
|
||||
id,
|
||||
position,
|
||||
velocity: Vec3::ZERO,
|
||||
@@ -464,6 +531,53 @@ impl ArmorStand {
|
||||
last_hit: i64::MIN / 2,
|
||||
}
|
||||
}
|
||||
pub fn environment_tick(
|
||||
&mut self,
|
||||
world: &World,
|
||||
facts: &BlockFacts,
|
||||
registry: &horizon_world::registry::BlockRegistry,
|
||||
) -> bool {
|
||||
let (lo, hi) = (self.bounds().min_position(), self.bounds().max_position());
|
||||
let mut water = false;
|
||||
let mut lava = false;
|
||||
for x in lo.x.floor() as i32..=hi.x.floor() as i32 {
|
||||
for y in lo.y.floor() as i32..hi.y.ceil() as i32 {
|
||||
for z in lo.z.floor() as i32..=hi.z.floor() as i32 {
|
||||
match facts.get(world.block(x, y, z)).fluid {
|
||||
Fluid::Water => water = true,
|
||||
Fluid::Lava => lava = true,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if water {
|
||||
self.fire_ticks = 0;
|
||||
}
|
||||
if self.fire_ticks > 0 {
|
||||
if self.fire_ticks % 20 == 0
|
||||
&& !lava
|
||||
&& !self.invisible
|
||||
&& !self.marker
|
||||
&& self.health > 0.5
|
||||
{
|
||||
self.health -= 4.0;
|
||||
}
|
||||
self.fire_ticks -= 1;
|
||||
}
|
||||
if lava {
|
||||
self.fire_ticks = self.fire_ticks.max(300);
|
||||
}
|
||||
let fire = crate::motion::environment::fire_contact(world, registry, self.bounds()) > 0.0;
|
||||
if (fire || lava) && !self.invisible && !self.marker {
|
||||
if self.fire_ticks > 0 {
|
||||
self.health -= 0.15;
|
||||
} else {
|
||||
self.fire_ticks = 100;
|
||||
}
|
||||
}
|
||||
self.health > 0.5
|
||||
}
|
||||
/// EntityType.ARMOR_STAND dimensions (0.5 x 1.975, half for small).
|
||||
pub fn bounds(&self) -> Aabb {
|
||||
let s = if self.small { 0.5 } else { 1.0 };
|
||||
@@ -495,3 +609,87 @@ impl ArmorStand {
|
||||
self.velocity = v;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod fire_environment_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn ordinary_items_burn_but_native_netherite_resists_lava() {
|
||||
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
|
||||
.join("../../.local/horizon-client/26.3");
|
||||
if !root.join("items.json").exists() {
|
||||
return;
|
||||
}
|
||||
let assets = crate::assets::Assets::load(&root).unwrap();
|
||||
let facts = BlockFacts::load(&root, assets.registry).unwrap();
|
||||
let items = crate::items::Items::load(&root, assets.registry, &facts).unwrap();
|
||||
let mut world = World::test_scene(&assets, 3).unwrap();
|
||||
let at = Vec3::new(20.5, 4.0, 20.5);
|
||||
world
|
||||
.set(
|
||||
20,
|
||||
4,
|
||||
20,
|
||||
assets.registry.default_state("minecraft:lava").unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
let make = |id: &str| ItemEntity {
|
||||
id: 1,
|
||||
stack: ItemStack {
|
||||
item: std::sync::Arc::from(id),
|
||||
count: 1,
|
||||
damage: 0,
|
||||
extra: None,
|
||||
},
|
||||
health: 5,
|
||||
fire_ticks: 0,
|
||||
position: at,
|
||||
previous: at,
|
||||
velocity: Vec3::ZERO,
|
||||
on_ground: false,
|
||||
age: 0,
|
||||
pickup_delay: 0,
|
||||
bob_offset: 0.0,
|
||||
};
|
||||
let mut wood = make("minecraft:oak_planks");
|
||||
let mut metal = make("minecraft:netherite_ingot");
|
||||
let first = wood.environment_tick(&world, &facts, assets.registry, &items);
|
||||
assert!(first.alive && first.lava_hurt);
|
||||
assert!(
|
||||
!first.should_play_lava_hurt_sound(1),
|
||||
"ordinary entry damage must not repeat the burn sound"
|
||||
);
|
||||
assert!(first.should_play_lava_hurt_sound(10));
|
||||
assert!(
|
||||
wood.fire_ticks > 0,
|
||||
"lava contact must ignite dropped items"
|
||||
);
|
||||
let last = wood.environment_tick(&world, &facts, assets.registry, &items);
|
||||
assert!(
|
||||
!last.alive && last.lava_hurt,
|
||||
"lethal lava damage still emits burn sound"
|
||||
);
|
||||
assert!(
|
||||
last.should_play_lava_hurt_sound(2),
|
||||
"the lethal hit must always play the sound"
|
||||
);
|
||||
for _ in 0..40 {
|
||||
let result = metal.environment_tick(&world, &facts, assets.registry, &items);
|
||||
assert!(result.alive && !result.lava_hurt);
|
||||
assert!(!result.should_play_lava_hurt_sound(10));
|
||||
}
|
||||
assert_eq!(metal.health, 5);
|
||||
world
|
||||
.set(
|
||||
20,
|
||||
4,
|
||||
20,
|
||||
assets.registry.default_state("minecraft:fire").unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
let mut burning = make("minecraft:oak_planks");
|
||||
let result = burning.environment_tick(&world, &facts, assets.registry, &items);
|
||||
assert!(result.alive && !result.lava_hurt);
|
||||
assert!(burning.fire_ticks > 0);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -98,6 +98,11 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
};
|
||||
let mut tag = base.tag(raw);
|
||||
for (key, value) in [
|
||||
(
|
||||
"Fire",
|
||||
Tag::Short(m.fire_ticks.clamp(i32::from(i16::MIN), i32::from(i16::MAX)) as i16),
|
||||
),
|
||||
("Air", Tag::Short(m.air as i16)),
|
||||
("Health", Tag::Float(m.health.max(0.0).to_bits())),
|
||||
(
|
||||
"HurtTime",
|
||||
@@ -324,6 +329,20 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
crate::mobs::villager::write_nbt(m, map);
|
||||
}
|
||||
"minecraft:wandering_trader" => put_offers(map, m),
|
||||
"minecraft:axolotl" => {
|
||||
if let Some(ttl) = crate::mobs::animal_brain::hunting_cooldown(m) {
|
||||
map.insert(
|
||||
"Brain".into(),
|
||||
Tag::compound([(
|
||||
"memories",
|
||||
Tag::compound([(
|
||||
"minecraft:has_hunting_cooldown",
|
||||
Tag::compound([("value", Tag::Byte(1)), ("ttl", Tag::Long(ttl))]),
|
||||
)]),
|
||||
)]),
|
||||
);
|
||||
}
|
||||
}
|
||||
"minecraft:allay" => {
|
||||
// InventoryCarrier: the fetched stack; the liked player memory.
|
||||
let mut inv = Vec::new();
|
||||
@@ -710,6 +729,17 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
|
||||
}
|
||||
crate::mobs::zombie_villager::read_nbt(&mut m, tag);
|
||||
}
|
||||
if m.species() == crate::mobs::Species::Axolotl
|
||||
&& let Some(memory) = tag
|
||||
.get("Brain")
|
||||
.and_then(|b| b.get("memories"))
|
||||
.and_then(|b| b.get("minecraft:has_hunting_cooldown"))
|
||||
&& let Some(ttl) = number(memory.get("ttl"))
|
||||
{
|
||||
crate::mobs::animal_brain::set_hunting_cooldown(&mut m, ttl);
|
||||
}
|
||||
m.fire_ticks = number(tag.get("Fire")).unwrap_or(0) as i32;
|
||||
m.air = number(tag.get("Air")).unwrap_or(300) as i32;
|
||||
if m.species() == crate::mobs::Species::Allay {
|
||||
if let Some(Tag::List(inv)) = tag.get("Inventory")
|
||||
&& let Some(first) = inv.first()
|
||||
@@ -853,6 +883,8 @@ pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> Option<ItemE
|
||||
let stack = item_from_nbt(tag.get("Item")?)?;
|
||||
let position = position(tag)?;
|
||||
Some(ItemEntity {
|
||||
health: number(tag.get("Health")).unwrap_or(5) as i32,
|
||||
fire_ticks: number(tag.get("Fire")).unwrap_or(0) as i32,
|
||||
id,
|
||||
stack,
|
||||
position,
|
||||
@@ -1141,11 +1173,8 @@ pub fn armor_stand_to_nbt(a: &ArmorStand, uuid: [i32; 4], raw: Option<&Tag>) ->
|
||||
} else if let Tag::Compound(map) = &mut tag {
|
||||
map.remove(&"Marker".into());
|
||||
}
|
||||
if let Tag::Compound(map) = &tag
|
||||
&& !map.contains_key(&horizon_world::nbt::JavaString::from("Health"))
|
||||
{
|
||||
put(&mut tag, "Health", Tag::Float(20f32.to_bits()));
|
||||
}
|
||||
put(&mut tag, "Health", Tag::Float(a.health.to_bits()));
|
||||
put(&mut tag, "Fire", Tag::Short(a.fire_ticks as i16));
|
||||
// LivingEntity.addAdditionalSaveData and ArmorStand's own fields.
|
||||
if let Tag::Compound(map) = &mut tag {
|
||||
for (key, value) in [
|
||||
@@ -1170,6 +1199,8 @@ pub fn armor_stand_to_nbt(a: &ArmorStand, uuid: [i32; 4], raw: Option<&Tag>) ->
|
||||
pub fn armor_stand_from_nbt(tag: &Tag, id: u32) -> Option<ArmorStand> {
|
||||
let mut a = ArmorStand::new(id, position(tag)?, rotation(tag)[0]);
|
||||
a.velocity = motion(tag);
|
||||
a.health = float(tag.get("Health")).unwrap_or(20.0) as f32;
|
||||
a.fire_ticks = number(tag.get("Fire")).unwrap_or(0) as i32;
|
||||
if let Some(eq) = tag.get("equipment") {
|
||||
for (i, slot) in ArmorStand::SLOTS.iter().enumerate() {
|
||||
a.equipment[i] = eq.get(slot).and_then(item_from_nbt);
|
||||
@@ -1421,6 +1452,8 @@ mod tests {
|
||||
#[test]
|
||||
fn item_entities_round_trip() {
|
||||
let e = ItemEntity {
|
||||
health: 5,
|
||||
fire_ticks: 0,
|
||||
id: 7,
|
||||
stack: ItemStack {
|
||||
item: Arc::from("minecraft:diamond_pickaxe"),
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
//! Animated burning-entity flames; the first-person overlay uses screen_effects.
|
||||
use crate::{hud::Rect, mesher::Vertex};
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn flames(
|
||||
position: [f64; 3],
|
||||
width: f32,
|
||||
height: f32,
|
||||
camera: glam::DVec3,
|
||||
yaw: f32,
|
||||
sprites: &HashMap<String, Rect>,
|
||||
scene_light: u8,
|
||||
out: &mut Vec<Vertex>,
|
||||
) {
|
||||
let (Some(a), Some(b)) = (sprites.get("block/fire_0"), sprites.get("block/fire_1")) else {
|
||||
return;
|
||||
};
|
||||
let scale = width * 1.4;
|
||||
if scale <= 0.0 {
|
||||
return;
|
||||
}
|
||||
let origin = glam::DVec3::from(position) - camera;
|
||||
let rotation = glam::Mat3::from_rotation_y(std::f32::consts::PI - yaw.to_radians());
|
||||
let mut remaining = height / scale;
|
||||
let mut half = 0.5f32;
|
||||
let mut y = 0.0f32;
|
||||
let mut z = 0.3 - (remaining as i32) as f32 * 0.02;
|
||||
let mut index = 0;
|
||||
while remaining > 0.0 {
|
||||
let r = if index % 2 == 0 { a } else { b };
|
||||
let (u0, u1) = if (index / 2) % 2 == 0 {
|
||||
(r.u0, r.u1)
|
||||
} else {
|
||||
(r.u1, r.u0)
|
||||
};
|
||||
for (p, uv) in [
|
||||
([-half, y, z], [u0, r.v1]),
|
||||
([half, y, z], [u1, r.v1]),
|
||||
([half, y + 1.4, z], [u1, r.v0]),
|
||||
([-half, y + 1.4, z], [u0, r.v0]),
|
||||
] {
|
||||
let p = origin.as_vec3() + rotation * (glam::Vec3::from(p) * scale);
|
||||
out.push(Vertex {
|
||||
pos: p.to_array(),
|
||||
uv,
|
||||
layer: 0,
|
||||
color: 0xffff_ffff,
|
||||
light: 0xf000 | (u32::from(scene_light >> 4) * 16),
|
||||
normal: [0; 4],
|
||||
});
|
||||
}
|
||||
remaining -= 0.45;
|
||||
y += 0.45;
|
||||
half *= 0.9;
|
||||
z -= 0.03;
|
||||
index += 1;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn flames_cover_entity_height_and_alternate_animated_sprites() {
|
||||
let rect = |u0| super::Rect {
|
||||
u0,
|
||||
v0: 0.0,
|
||||
u1: u0 + 0.1,
|
||||
v1: 0.1,
|
||||
w: 16,
|
||||
h: 16,
|
||||
};
|
||||
let sprites = super::HashMap::from([
|
||||
("block/fire_0".into(), rect(0.0)),
|
||||
("block/fire_1".into(), rect(0.5)),
|
||||
]);
|
||||
let mut out = Vec::new();
|
||||
super::flames(
|
||||
[0.0; 3],
|
||||
0.6,
|
||||
1.8,
|
||||
glam::DVec3::ZERO,
|
||||
0.0,
|
||||
&sprites,
|
||||
0,
|
||||
&mut out,
|
||||
);
|
||||
assert_eq!(out.len() % 4, 0);
|
||||
assert!(
|
||||
out[0].pos[2] < 0.0,
|
||||
"billboard depth bias must face the camera"
|
||||
);
|
||||
assert!(
|
||||
out.iter().all(|v| v.light == 0xf000),
|
||||
"fire forces block light to 15 but preserves scene sky light"
|
||||
);
|
||||
assert!(out.len() >= 20);
|
||||
assert!(out.iter().any(|v| v.pos[1] >= 1.8));
|
||||
assert!(
|
||||
out.iter().all(|v| v.layer == 0),
|
||||
"flames must not use the breaking-cracks UV-remap material"
|
||||
);
|
||||
assert!(out[..4].iter().all(|v| v.uv[0] <= 0.1));
|
||||
assert!(out[4..8].iter().all(|v| v.uv[0] >= 0.5));
|
||||
}
|
||||
}
|
||||
@@ -1162,6 +1162,8 @@ impl Game<'_> {
|
||||
// ItemEntity.bobOffs comes from the entity's own random, not the level's.
|
||||
let bob = self.particles.random().next_float() * std::f32::consts::PI * 2.0;
|
||||
self.dropped.push(ItemEntity {
|
||||
health: 5,
|
||||
fire_ticks: 0,
|
||||
id: self.next_entity,
|
||||
stack,
|
||||
position: p,
|
||||
@@ -1255,10 +1257,32 @@ impl Game<'_> {
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
items.retain_mut(|item| {
|
||||
!ticking(
|
||||
if !ticking(
|
||||
item.position.x.floor() as i32,
|
||||
item.position.z.floor() as i32,
|
||||
) || item.tick(&self.world, &self.res.facts, self.collision)
|
||||
) {
|
||||
return true;
|
||||
}
|
||||
if !item.tick(&self.world, &self.res.facts, self.collision) {
|
||||
return false;
|
||||
}
|
||||
let environment = item.environment_tick(
|
||||
&self.world,
|
||||
&self.res.facts,
|
||||
self.res.assets.registry,
|
||||
&self.res.items,
|
||||
);
|
||||
// shortcut: age is the fresh-drop clock; use entity ticks for saved/frozen-age phase parity.
|
||||
if environment.should_play_lava_hurt_sound(item.age) {
|
||||
let pitch = 2.0 + self.world.random.next_float() * 0.4;
|
||||
self.audio.play(
|
||||
"minecraft:entity.generic.burn",
|
||||
Some([item.position.x, item.position.y, item.position.z]),
|
||||
0.4,
|
||||
pitch,
|
||||
);
|
||||
}
|
||||
environment.alive
|
||||
});
|
||||
let Some(p) = self.player.as_ref() else {
|
||||
self.dropped = items;
|
||||
@@ -1569,7 +1593,13 @@ impl Game<'_> {
|
||||
_ => None,
|
||||
};
|
||||
if let Some((name, volume)) = sound {
|
||||
self.audio.play(name, c, volume, 1.0);
|
||||
let pitch = if id == 1009 {
|
||||
2.6 + (self.world.random.next_float() - self.world.random.next_float())
|
||||
* 0.8
|
||||
} else {
|
||||
1.0
|
||||
};
|
||||
self.audio.play(name, c, volume, pitch);
|
||||
}
|
||||
}
|
||||
LevelEvent::Sound {
|
||||
@@ -2568,10 +2598,25 @@ impl Game<'_> {
|
||||
};
|
||||
let mut player = PlayerMotion::new(self.motion, feet)?;
|
||||
player.yaw = self.yaw;
|
||||
player.fire_ticks = self
|
||||
.level
|
||||
.player_extra
|
||||
.as_ref()
|
||||
.and_then(|t| horizon_client::save::number(t.get("Fire")))
|
||||
.unwrap_or(0) as i32;
|
||||
player.air = self
|
||||
.level
|
||||
.player_extra
|
||||
.as_ref()
|
||||
.and_then(|t| horizon_client::save::number(t.get("Air")))
|
||||
.unwrap_or(300) as i32;
|
||||
let spectator = self.mode == horizon_client::command::args::GameMode::Spectator;
|
||||
player.may_fly = self.creative || spectator;
|
||||
player.invulnerable = self.creative || spectator;
|
||||
player.spectator = spectator;
|
||||
player.respiration = self.armor[0]
|
||||
.as_ref()
|
||||
.map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
|
||||
player.pitch = self.pitch;
|
||||
// LivingEntity.canGlideUsing: a glider in its slot that will not break next.
|
||||
player.glider = self.armor[1].as_ref().is_some_and(|s| {
|
||||
@@ -2671,6 +2716,9 @@ impl Game<'_> {
|
||||
player.auto_jump_enabled = self.settings.auto_jump;
|
||||
player.invulnerable = self.creative || spectator;
|
||||
player.spectator = spectator;
|
||||
player.respiration = self.armor[0]
|
||||
.as_ref()
|
||||
.map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
|
||||
player.pitch = self.pitch;
|
||||
// LivingEntity.canGlideUsing: a glider in its slot that will not break next.
|
||||
player.glider = self.armor[1].as_ref().is_some_and(|s| {
|
||||
@@ -2833,7 +2881,6 @@ impl Game<'_> {
|
||||
/// world's entities and blocks, and the network hub.
|
||||
fn tick_world(&mut self, running: bool) -> Result<()> {
|
||||
horizon_client::spans::time("tick_effects", || self.tick_effects());
|
||||
horizon_client::spans::time("tick_burning", || self.tick_burning());
|
||||
horizon_client::spans::time("tick_using", || self.tick_using());
|
||||
horizon_client::spans::time("tick_hud", || self.tick_hud());
|
||||
// The player's digging comes in with its packets, before the level
|
||||
@@ -3167,8 +3214,7 @@ impl Game<'_> {
|
||||
hunger: effects.get("hunger").is_some(),
|
||||
hardcore: self.level.hardcore,
|
||||
damage_cooldown: p.health.hurt.cooldown > 0,
|
||||
// Horizon does not track the player's air supply yet.
|
||||
air: 300,
|
||||
air: p.air,
|
||||
max_air: 300,
|
||||
under_water,
|
||||
vehicle_hearts,
|
||||
@@ -4342,6 +4388,89 @@ impl Game<'_> {
|
||||
/// ItemEntityRenderer: items bob and spin; blocks render as small cubes.
|
||||
fn entity_geometry(&mut self, camera: glam::DVec3, alpha: f64) -> Vec<Vertex> {
|
||||
let mut out = Vec::new();
|
||||
let fire_yaw = if self.camera_type == perspective::CameraType::ThirdPersonFront {
|
||||
self.yaw + 180.0
|
||||
} else {
|
||||
self.yaw
|
||||
};
|
||||
for m in &self.mobs {
|
||||
if m.fire_ticks > 0 && !m.removed {
|
||||
let at = m.previous.lerp(m.position, alpha);
|
||||
horizon_client::fire_render::flames(
|
||||
[at.x, at.y, at.z],
|
||||
m.width(),
|
||||
m.height(),
|
||||
camera,
|
||||
fire_yaw,
|
||||
&self.res.atlas.sprites,
|
||||
self.world.light(
|
||||
at.x.floor() as i32,
|
||||
at.y.floor() as i32,
|
||||
at.z.floor() as i32,
|
||||
),
|
||||
&mut out,
|
||||
);
|
||||
}
|
||||
}
|
||||
if !self.camera_type.first_person()
|
||||
&& let Some(p) = &self.player
|
||||
&& p.fire_ticks > 0
|
||||
&& !p.spectator
|
||||
{
|
||||
let feet = self.previous_position.lerp(p.position, alpha);
|
||||
horizon_client::fire_render::flames(
|
||||
[feet.x, feet.y, feet.z],
|
||||
p.dimensions.width,
|
||||
p.dimensions.height,
|
||||
camera,
|
||||
fire_yaw,
|
||||
&self.res.atlas.sprites,
|
||||
self.world.light(
|
||||
feet.x.floor() as i32,
|
||||
feet.y.floor() as i32,
|
||||
feet.z.floor() as i32,
|
||||
),
|
||||
&mut out,
|
||||
);
|
||||
}
|
||||
for item in &self.dropped {
|
||||
if item.fire_ticks > 0 {
|
||||
let at = item.previous.lerp(item.position, alpha);
|
||||
horizon_client::fire_render::flames(
|
||||
[at.x, at.y, at.z],
|
||||
0.25,
|
||||
0.25,
|
||||
camera,
|
||||
fire_yaw,
|
||||
&self.res.atlas.sprites,
|
||||
self.world.light(
|
||||
at.x.floor() as i32,
|
||||
at.y.floor() as i32,
|
||||
at.z.floor() as i32,
|
||||
),
|
||||
&mut out,
|
||||
);
|
||||
}
|
||||
}
|
||||
for stand in &self.armor_stands {
|
||||
if stand.fire_ticks > 0 && !stand.marker {
|
||||
let scale = if stand.small { 0.5 } else { 1.0 };
|
||||
horizon_client::fire_render::flames(
|
||||
[stand.position.x, stand.position.y, stand.position.z],
|
||||
0.5 * scale,
|
||||
1.975 * scale,
|
||||
camera,
|
||||
fire_yaw,
|
||||
&self.res.atlas.sprites,
|
||||
self.world.light(
|
||||
stand.position.x.floor() as i32,
|
||||
stand.position.y.floor() as i32,
|
||||
stand.position.z.floor() as i32,
|
||||
),
|
||||
&mut out,
|
||||
);
|
||||
}
|
||||
}
|
||||
// `ItemEntityRenderer`.
|
||||
self.dropped_item_geometry(camera, alpha, &mut out);
|
||||
// Mobs and their projectiles.
|
||||
@@ -5191,6 +5320,8 @@ impl Game<'_> {
|
||||
self.score = Default::default();
|
||||
self.fns = Default::default();
|
||||
self.bosses = Default::default();
|
||||
self.adv = Default::default();
|
||||
self.stats = Default::default();
|
||||
// RandomSequences: the world's data/minecraft/random_sequences.dat.
|
||||
self.rand_sequences =
|
||||
horizon_client::save::read_dat(&save_root.join("data/minecraft/random_sequences.dat"))
|
||||
@@ -5223,6 +5354,7 @@ impl Game<'_> {
|
||||
let (mut streaming, save) = self.make_streaming(&save_root, dim, level.seed)?;
|
||||
streaming.radius = self.settings.render_distance;
|
||||
let mut world = World::new(self.res.facts.air, level.seed);
|
||||
world.fast_lava = dim == Dim::Nether;
|
||||
world.game_time = level.time;
|
||||
world.day_time = self.options.time.unwrap_or(level.day_time);
|
||||
world.weather = level.weather;
|
||||
@@ -5452,6 +5584,7 @@ impl Game<'_> {
|
||||
let (streaming, save) =
|
||||
self.make_streaming(&self.world_root.clone(), target, self.level.seed)?;
|
||||
let mut world = World::new(self.res.facts.air, self.level.seed);
|
||||
world.fast_lava = target == Dim::Nether;
|
||||
world.game_time = self.world.game_time;
|
||||
world.day_time = self.world.day_time;
|
||||
world.weather = self.world.weather;
|
||||
@@ -6218,6 +6351,19 @@ impl Game<'_> {
|
||||
}
|
||||
if let Some(kind) = mob {
|
||||
if let Some(id) = self.spawn_mob_at(kind, (target[0], target[1], target[2]), true) {
|
||||
if kind == "axolotl"
|
||||
&& let Some(data) = stack.data().and_then(|d| {
|
||||
d.other
|
||||
.iter()
|
||||
.find(|(key, _)| key == "minecraft:bucket_entity_data")
|
||||
.map(|(_, v)| v)
|
||||
})
|
||||
&& let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
|
||||
&& let Some(horizon_world::nbt::Tag::Long(ticks)) =
|
||||
data.get("HuntingCooldown")
|
||||
{
|
||||
horizon_client::mobs::animal_brain::set_hunting_cooldown(m, *ticks);
|
||||
}
|
||||
self.mob_placed(id)?;
|
||||
}
|
||||
self.post_block_game_event(
|
||||
@@ -6227,7 +6373,7 @@ impl Game<'_> {
|
||||
None,
|
||||
);
|
||||
}
|
||||
self.trigger_item("minecraft:placed_block", stack);
|
||||
self.trigger_block("minecraft:placed_block", target, stack);
|
||||
if !self.creative {
|
||||
self.inventory[self.selected] = Some(ItemStack::new("minecraft:bucket", 1));
|
||||
}
|
||||
@@ -7171,6 +7317,19 @@ impl Game<'_> {
|
||||
if let Some(p) = &self.player {
|
||||
level.position = Some([p.position.x, p.position.y, p.position.z]);
|
||||
level.health = p.health.health();
|
||||
let extra = level
|
||||
.player_extra
|
||||
.get_or_insert_with(|| horizon_world::nbt::Tag::Compound(Default::default()));
|
||||
if let horizon_world::nbt::Tag::Compound(map) = extra {
|
||||
map.insert(
|
||||
"Fire".into(),
|
||||
horizon_world::nbt::Tag::Short(
|
||||
p.fire_ticks.clamp(i32::from(i16::MIN), i32::from(i16::MAX)) as i16,
|
||||
),
|
||||
);
|
||||
map.insert("Air".into(), horizon_world::nbt::Tag::Short(p.air as i16));
|
||||
}
|
||||
|
||||
level.food = p.health.food.food;
|
||||
level.saturation = p.health.food.saturation;
|
||||
}
|
||||
@@ -7827,7 +7986,16 @@ impl ApplicationHandler for Game<'_> {
|
||||
),
|
||||
(&self.res.forcefield.2, self.res.forcefield.0),
|
||||
)) {
|
||||
Ok(r) => self.renderer = Some(r),
|
||||
Ok(mut r) => {
|
||||
r.hud.fire_animations = self
|
||||
.res
|
||||
.atlas
|
||||
.fire_animations
|
||||
.iter()
|
||||
.map(|(rect, animation)| (*rect, animation.clone(), usize::MAX))
|
||||
.collect();
|
||||
self.renderer = Some(r);
|
||||
}
|
||||
Err(e) => {
|
||||
self.error = Some(e.to_string());
|
||||
event_loop.exit();
|
||||
@@ -8352,6 +8520,7 @@ impl ApplicationHandler for Game<'_> {
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
})();
|
||||
if let Err(e) = result {
|
||||
|
||||
@@ -366,8 +366,25 @@ impl Game<'_> {
|
||||
world: &self.world,
|
||||
binding: self.collision,
|
||||
};
|
||||
for a in &mut self.armor_stands {
|
||||
let mut dead = Vec::new();
|
||||
for (i, a) in self.armor_stands.iter_mut().enumerate() {
|
||||
a.tick(&mut scene);
|
||||
if !a.environment_tick(&self.world, &self.res.facts, self.res.assets.registry) {
|
||||
dead.push(i);
|
||||
}
|
||||
}
|
||||
for i in dead.into_iter().rev() {
|
||||
let a = self.armor_stands.remove(i);
|
||||
let at = [a.position.x, a.position.y, a.position.z];
|
||||
for stack in a.equipment.into_iter().flatten() {
|
||||
self.spawn_item(stack, at, [0.0; 3], 10);
|
||||
}
|
||||
self.audio
|
||||
.play("minecraft:entity.armor_stand.break", Some(at), 1.0, 1.0);
|
||||
self.world.modified.insert((
|
||||
a.position.x.floor() as i32 >> 4,
|
||||
a.position.z.floor() as i32 >> 4,
|
||||
));
|
||||
}
|
||||
}
|
||||
/// ArmorStandRenderer: the stand with its default pose, then armor layers.
|
||||
|
||||
@@ -28,7 +28,6 @@ use std::sync::Arc;
|
||||
pub(super) struct Creatures {
|
||||
pub projectiles: Vec<Projectile>,
|
||||
/// Player status effects applied by mobs: (effect, ticks left, amplifier).
|
||||
pub player_fire: i32,
|
||||
pub pearl_cooldown: u32,
|
||||
/// The wind charge's use cooldown (ticks).
|
||||
pub wind_cooldown: u32,
|
||||
@@ -908,6 +907,26 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
MobEvent::Experience { at, amount } => self.spawn_orbs(at, amount),
|
||||
MobEvent::AxolotlSupportPlayer => {
|
||||
let previous = self
|
||||
.potions
|
||||
.effects
|
||||
.get("regeneration")
|
||||
.map_or(0, |e| e.duration);
|
||||
if (0..=2399).contains(&previous) {
|
||||
self.potions
|
||||
.effects
|
||||
.add(horizon_client::effects::EffectInstance::new(
|
||||
"regeneration",
|
||||
(previous + 100).min(2400),
|
||||
0,
|
||||
));
|
||||
}
|
||||
self.potions
|
||||
.effects
|
||||
.list
|
||||
.retain(|e| e.id != "mining_fatigue");
|
||||
}
|
||||
MobEvent::EffectPlayer {
|
||||
effect,
|
||||
ticks,
|
||||
@@ -917,9 +936,10 @@ impl Game<'_> {
|
||||
}
|
||||
MobEvent::Ignite { target, seconds } => match target {
|
||||
Who::Player => {
|
||||
if !self.creative {
|
||||
self.creatures.player_fire =
|
||||
self.creatures.player_fire.max(seconds * 20);
|
||||
if !self.creative
|
||||
&& let Some(p) = self.player.as_mut()
|
||||
{
|
||||
p.fire_ticks = p.fire_ticks.max(seconds * 20);
|
||||
}
|
||||
}
|
||||
Who::Mob(id) => {
|
||||
@@ -1291,24 +1311,6 @@ impl Game<'_> {
|
||||
}
|
||||
/// Burning applied to the player by mobs.
|
||||
fn tick_player_effects(&mut self) {
|
||||
let in_water = self.player.as_ref().is_some_and(|p| {
|
||||
let (x, y, z) = (
|
||||
p.position.x.floor() as i32,
|
||||
p.position.y.floor() as i32,
|
||||
p.position.z.floor() as i32,
|
||||
);
|
||||
self.res.facts.get(self.world.block(x, y, z)).fluid == Fluid::Water
|
||||
});
|
||||
if self.creatures.player_fire > 0 {
|
||||
if in_water {
|
||||
self.creatures.player_fire = 0;
|
||||
} else {
|
||||
if self.creatures.player_fire % 20 == 0 {
|
||||
self.hurt_player_by("minecraft:on_fire", 1.0);
|
||||
}
|
||||
self.creatures.player_fire -= 1;
|
||||
}
|
||||
}
|
||||
self.creatures.wind_cooldown = self.creatures.wind_cooldown.saturating_sub(1);
|
||||
if self.creatures.pearl_cooldown > 0 {
|
||||
self.creatures.pearl_cooldown -= 1;
|
||||
@@ -1583,7 +1585,9 @@ impl Game<'_> {
|
||||
Hit::Entity { who, .. } => match who {
|
||||
Who::Player => {
|
||||
if !self.creative {
|
||||
self.creatures.player_fire = self.creatures.player_fire.max(100);
|
||||
if let Some(p) = self.player.as_mut() {
|
||||
p.fire_ticks = p.fire_ticks.max(100);
|
||||
}
|
||||
self.mob_hits_player(
|
||||
5.0,
|
||||
[p.previous.x, p.previous.y, p.previous.z],
|
||||
|
||||
@@ -159,32 +159,13 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
}
|
||||
if ignite > 0.0 {
|
||||
// Entity.igniteForSeconds; mobs burn for 1 damage per second.
|
||||
let id = self.mobs[mob].id;
|
||||
self.potions.burning.retain(|(m, _)| *m != id);
|
||||
self.potions.burning.push((id, (ignite * 20.0) as i32));
|
||||
if ignite > 0.0
|
||||
&& let Some(m) = self.mobs.get_mut(mob)
|
||||
&& !m.kind.flags.fire_immune
|
||||
{
|
||||
m.fire_ticks = m.fire_ticks.max((ignite * 20.0) as i32);
|
||||
}
|
||||
}
|
||||
/// Burning mobs (fire aspect): one damage every 20 ticks, flame particles.
|
||||
pub(super) fn tick_burning(&mut self) {
|
||||
let mut burning = std::mem::take(&mut self.potions.burning);
|
||||
burning.retain_mut(|(id, ticks)| {
|
||||
*ticks -= 1;
|
||||
let Some(m) = self.mobs.iter_mut().find(|m| m.id == *id && m.alive()) else {
|
||||
return false;
|
||||
};
|
||||
if *ticks % 20 == 0 {
|
||||
let at = [m.position.x, m.position.y, m.position.z];
|
||||
if m.hurt(1.0, None, &mut self.world.random) {
|
||||
self.last_hurt_by_player.insert(*id);
|
||||
let _ = at;
|
||||
}
|
||||
}
|
||||
*ticks > 0
|
||||
});
|
||||
self.potions.burning = burning;
|
||||
}
|
||||
/// Thorns on worn armor when a mob at `from` hits the player.
|
||||
pub(super) fn thorns(&mut self, from: [f64; 3]) {
|
||||
let attacker = self
|
||||
|
||||
@@ -322,8 +322,13 @@ impl Game<'_> {
|
||||
if let Some(p) = self.player.as_ref().map(|p| p.position)
|
||||
&& inside([p.x, p.y, p.z])
|
||||
{
|
||||
let fire = &mut self.creatures.player_fire;
|
||||
*fire = if *fire + 1 == 0 { 160 } else { *fire + 1 };
|
||||
if let Some(p) = self.player.as_mut() {
|
||||
p.fire_ticks = if p.fire_ticks + 1 == 0 {
|
||||
160
|
||||
} else {
|
||||
p.fire_ticks + 1
|
||||
};
|
||||
}
|
||||
self.hurt_player_by("minecraft:lightning_bolt", 5.0);
|
||||
}
|
||||
// Dropped items burn up (ItemEntity health 5), save fire-resistant ones.
|
||||
|
||||
@@ -57,8 +57,7 @@ pub(super) struct PotionState {
|
||||
applied: Vec<(&'static str, &'static str, f64, &'static str)>,
|
||||
/// Armor the protection table was computed for.
|
||||
protection_for: Option<Vec<Option<ItemStack>>>,
|
||||
/// Mobs set on fire by fire aspect: (mob id, ticks left).
|
||||
pub(super) burning: Vec<(u32, i32)>,
|
||||
|
||||
/// Enchantment attribute modifiers on the player: (attribute, id, amount, operation).
|
||||
pub(super) enchant_modifiers: Vec<(String, String, f64, String)>,
|
||||
}
|
||||
|
||||
@@ -1502,6 +1502,8 @@ impl Game<'_> {
|
||||
let at = Vec3::new(p[0], p[1], p[2]);
|
||||
let bob_offset = self.world.random.next_float() * std::f32::consts::PI * 2.0;
|
||||
self.dropped.push(ItemEntity {
|
||||
health: 5,
|
||||
fire_ticks: 0,
|
||||
id: id as u32,
|
||||
stack,
|
||||
position: at,
|
||||
|
||||
@@ -176,7 +176,9 @@ impl Game<'_> {
|
||||
partial,
|
||||
block_overlay,
|
||||
water,
|
||||
on_fire: false,
|
||||
on_fire: self.camera_type.first_person()
|
||||
&& !self.spectator()
|
||||
&& self.player.as_ref().is_some_and(|p| p.fire_ticks > 0),
|
||||
gui_overlays: &gui_overlays,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -1697,16 +1697,17 @@ impl Renderer {
|
||||
);
|
||||
}
|
||||
fn animate(&mut self, tick: u64) {
|
||||
let sprite_size = self.sprite_texture.width();
|
||||
for (animation, previous) in &mut self.animations {
|
||||
let frame = animation.frame(tick);
|
||||
if frame == *previous {
|
||||
continue;
|
||||
}
|
||||
*previous = frame;
|
||||
let (mips, levels) = mip_chain(animation.pixels(frame), 16, 1);
|
||||
let (mips, levels) = mip_chain(animation.pixels(frame), sprite_size, 1);
|
||||
let mut offset = 0;
|
||||
for level in 0..levels.min(self.mip_levels) {
|
||||
let size = 16 >> level;
|
||||
let size = sprite_size >> level;
|
||||
let bytes = (size * size * 4) as usize;
|
||||
self.queue.write_texture(
|
||||
wgpu::TexelCopyTextureInfo {
|
||||
@@ -1772,6 +1773,7 @@ impl Renderer {
|
||||
};
|
||||
if self.animated_textures {
|
||||
self.animate(frame.ticks);
|
||||
self.hud.animate_fire(&self.queue, frame.ticks);
|
||||
}
|
||||
self.update_lightmap(
|
||||
&frame.sky,
|
||||
|
||||
@@ -23,6 +23,7 @@ pub struct HudAtlas {
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
pub sprites: HashMap<String, Rect>,
|
||||
pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation)>,
|
||||
/// The default font (bitmap sheets in this atlas, unifont rasterized on demand).
|
||||
pub font: crate::font::Font,
|
||||
white: Rect,
|
||||
@@ -247,6 +248,35 @@ impl HudAtlas {
|
||||
},
|
||||
);
|
||||
}
|
||||
let mut fire_sprites = crate::sprites::Sprites::default();
|
||||
let mut fire_animations = Vec::new();
|
||||
for name in [
|
||||
"block/fire_0",
|
||||
"block/fire_1",
|
||||
"block/soul_fire_0",
|
||||
"block/soul_fire_1",
|
||||
] {
|
||||
if let Some(rect) = sprites.get(name).copied() {
|
||||
let layer = fire_sprites.insert(root, &format!("minecraft:{name}"))?;
|
||||
if let Some(animation) = fire_sprites
|
||||
.animations
|
||||
.iter()
|
||||
.find(|a| a.layer == layer)
|
||||
.cloned()
|
||||
{
|
||||
let image = animation.resized_pixels(animation.frame(0), rect.w, rect.h);
|
||||
let x = (rect.u0 * width as f32).round() as usize;
|
||||
let y = (rect.v0 * height as f32).round() as usize;
|
||||
for row in 0..rect.h as usize {
|
||||
let dst = ((y + row) * width as usize + x) * 4;
|
||||
let src = row * rect.w as usize * 4;
|
||||
pixels[dst..dst + rect.w as usize * 4]
|
||||
.copy_from_slice(&image[src..src + rect.w as usize * 4]);
|
||||
}
|
||||
fire_animations.push((rect, animation));
|
||||
}
|
||||
}
|
||||
}
|
||||
let white = sprites["horizon/white"];
|
||||
let font = crate::font::Font::load(
|
||||
root,
|
||||
@@ -261,6 +291,7 @@ impl HudAtlas {
|
||||
width,
|
||||
height,
|
||||
sprites,
|
||||
fire_animations,
|
||||
font,
|
||||
white,
|
||||
})
|
||||
@@ -592,6 +623,7 @@ struct HudUniform {
|
||||
size: [f32; 4],
|
||||
}
|
||||
pub struct HudRenderer {
|
||||
pub fire_animations: Vec<(Rect, crate::sprites::SpriteAnimation, usize)>,
|
||||
/// The shared atlas texture, for run-time glyph uploads.
|
||||
pub atlas_texture: Option<wgpu::Texture>,
|
||||
pipeline: wgpu::RenderPipeline,
|
||||
@@ -713,6 +745,7 @@ impl HudRenderer {
|
||||
});
|
||||
Ok(Self {
|
||||
atlas_texture: None,
|
||||
fire_animations: Vec::new(),
|
||||
pipeline,
|
||||
group,
|
||||
uniform,
|
||||
@@ -720,6 +753,42 @@ impl HudRenderer {
|
||||
capacity,
|
||||
})
|
||||
}
|
||||
pub fn animate_fire(&mut self, queue: &wgpu::Queue, tick: u64) {
|
||||
let Some(texture) = &self.atlas_texture else {
|
||||
return;
|
||||
};
|
||||
for (rect, animation, previous) in &mut self.fire_animations {
|
||||
let frame = animation.frame(tick);
|
||||
if frame == *previous {
|
||||
continue;
|
||||
}
|
||||
let pixels = animation.resized_pixels(frame, rect.w, rect.h);
|
||||
queue.write_texture(
|
||||
wgpu::TexelCopyTextureInfo {
|
||||
texture,
|
||||
mip_level: 0,
|
||||
origin: wgpu::Origin3d {
|
||||
x: (rect.u0 * texture.width() as f32).round() as u32,
|
||||
y: (rect.v0 * texture.height() as f32).round() as u32,
|
||||
z: 0,
|
||||
},
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
},
|
||||
&pixels,
|
||||
wgpu::TexelCopyBufferLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: Some(rect.w * 4),
|
||||
rows_per_image: Some(rect.h),
|
||||
},
|
||||
wgpu::Extent3d {
|
||||
width: rect.w,
|
||||
height: rect.h,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
);
|
||||
*previous = frame;
|
||||
}
|
||||
}
|
||||
pub fn draw(
|
||||
&mut self,
|
||||
device: &wgpu::Device,
|
||||
|
||||
@@ -20,6 +20,7 @@ pub struct ToolRule {
|
||||
}
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ItemInfo {
|
||||
pub fire_resistant: bool,
|
||||
pub id: Arc<str>,
|
||||
pub max_stack: u32,
|
||||
pub max_damage: u32,
|
||||
@@ -307,6 +308,26 @@ fn entity_spec(tags: &HashMap<String, HashSet<String>>, spec: &str) -> HashSet<S
|
||||
}
|
||||
}
|
||||
impl Items {
|
||||
pub fn resists_fire(&self, stack: &ItemStack, source: &str) -> bool {
|
||||
if let Some(data) = stack.data()
|
||||
&& let Some((_, v)) = data
|
||||
.other
|
||||
.iter()
|
||||
.find(|(key, _)| key == "minecraft:damage_resistant")
|
||||
{
|
||||
return match v.get("types") {
|
||||
Some(horizon_world::nbt::Tag::String(tag)) => {
|
||||
tag.to_string().is_ok_and(|id|id=="#minecraft:is_fire" || id==source)
|
||||
}
|
||||
Some(horizon_world::nbt::Tag::List(tags)) => tags.iter().any(
|
||||
|t| matches!(t,horizon_world::nbt::Tag::String(id) if id.to_string().is_ok_and(|id|id==source)),
|
||||
),
|
||||
_ => false,
|
||||
};
|
||||
}
|
||||
self.get(&stack.item).is_some_and(|i| i.fire_resistant)
|
||||
}
|
||||
|
||||
pub fn load(root: &Path, registry: &BlockRegistry, facts: &BlockFacts) -> Result<Self> {
|
||||
let mut block_for_item: HashMap<&str, BlockStateId> = HashMap::new();
|
||||
for (i, s) in facts.states.iter().enumerate() {
|
||||
@@ -370,6 +391,8 @@ impl Items {
|
||||
items.insert(
|
||||
id.clone(),
|
||||
ItemInfo {
|
||||
fire_resistant: c["minecraft:damage_resistant"]["types"].as_str()
|
||||
== Some("#minecraft:is_fire"),
|
||||
id: id.clone(),
|
||||
max_stack: c["minecraft:max_stack_size"].as_u64().unwrap_or(64) as u32,
|
||||
max_damage: c["minecraft:max_damage"].as_u64().unwrap_or(0) as u32,
|
||||
|
||||
@@ -44,6 +44,7 @@ pub mod entity_nbt;
|
||||
pub mod environment;
|
||||
pub mod fast_hash;
|
||||
pub mod fastutil_order;
|
||||
pub mod fire_render;
|
||||
pub mod first_person;
|
||||
pub mod flatgen;
|
||||
pub mod fog;
|
||||
|
||||
@@ -10,6 +10,7 @@ pub mod allay;
|
||||
pub mod anim;
|
||||
pub mod animal_brain;
|
||||
pub mod aquatic;
|
||||
pub mod axolotl;
|
||||
pub mod body_anim;
|
||||
pub mod brain;
|
||||
pub mod breeze;
|
||||
@@ -701,6 +702,7 @@ pub struct Extra {
|
||||
pub villager: Option<Box<villager::Ext>>,
|
||||
/// The sniffer's and the ghastling's brain.
|
||||
pub animal_brain: Option<Box<animal_brain::Brain>>,
|
||||
pub axolotl: axolotl::Animation,
|
||||
/// The mob this one rides, and the mob riding it (`getVehicle`, `getFirstPassenger`).
|
||||
pub mount: Option<u32>,
|
||||
pub rider: Option<u32>,
|
||||
@@ -937,6 +939,7 @@ pub enum MobEvent {
|
||||
amount: u32,
|
||||
},
|
||||
/// Apply an effect to the player (witch potions, bee stings, cave spider poison).
|
||||
AxolotlSupportPlayer,
|
||||
EffectPlayer {
|
||||
effect: &'static str,
|
||||
ticks: i32,
|
||||
@@ -1093,6 +1096,9 @@ pub struct SpawnSetup {
|
||||
/// A snapshot of another entity mobs can see this tick.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Seen {
|
||||
pub in_water: bool,
|
||||
pub playing_dead: bool,
|
||||
pub last_damage: Option<Damage>,
|
||||
pub id: u32,
|
||||
pub species: Species,
|
||||
pub position: Vec3,
|
||||
@@ -1151,6 +1157,9 @@ impl Mob {
|
||||
let m = self;
|
||||
let villager = m.species() == Species::Villager;
|
||||
Seen {
|
||||
in_water: self.fluids.in_water,
|
||||
playing_dead: axolotl::is_playing_dead(self),
|
||||
last_damage: self.last_damage.map(|(d, _)| d),
|
||||
id: m.id,
|
||||
species: m.species(),
|
||||
position: m.position,
|
||||
@@ -1502,6 +1511,7 @@ impl Mob {
|
||||
.fold((0.0, 0.0), |(a, t), (x, y)| (a + x, t + y))
|
||||
}
|
||||
pub fn damage(&mut self, amount: f32, source: Damage) -> bool {
|
||||
axolotl::before_damage(self, amount, &source);
|
||||
raider::note_hurt(self);
|
||||
if !self.alive() || self.removed || self.invulnerable_flag {
|
||||
return false;
|
||||
|
||||
@@ -126,7 +126,8 @@ pub fn family(s: Species) -> Family {
|
||||
| S::Salmon
|
||||
| S::TropicalFish
|
||||
| S::Pufferfish
|
||||
| S::Dolphin => Family::Aquatic,
|
||||
| S::Dolphin
|
||||
| S::Axolotl => Family::Aquatic,
|
||||
S::Giant => Family::Inert,
|
||||
S::Witch => Family::Witch,
|
||||
S::Wolf | S::Cat => Family::Tame,
|
||||
@@ -369,6 +370,7 @@ pub fn tick(
|
||||
}
|
||||
events.append(&mut m.outbox);
|
||||
m.update_walk_animation();
|
||||
super::axolotl::tick_animation(m);
|
||||
m.anim.end_tick(m.ai.swinging);
|
||||
tick_swing(m);
|
||||
if m.species() == Species::CopperGolem {
|
||||
@@ -397,6 +399,12 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
|
||||
if m.fluids.in_water {
|
||||
m.fall_distance = 0.0;
|
||||
}
|
||||
let fire = crate::motion::environment::fire_contact(w.world, w.registry, m.bounds());
|
||||
if fire > 0.0 && !m.kind.flags.fire_immune {
|
||||
m.fire_ticks =
|
||||
crate::motion::environment::ignite_contact(m.fire_ticks, false, &mut m.random);
|
||||
m.damage(fire, Damage::of(DamageKind::InFire));
|
||||
}
|
||||
// Fire: water extinguishes, lava ignites, burning hurts every second.
|
||||
if m.fluids.in_water && m.fire_ticks > 0 {
|
||||
m.fire_ticks = 0;
|
||||
@@ -413,7 +421,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
|
||||
}
|
||||
if m.fire_ticks > 0 {
|
||||
if m.kind.flags.fire_immune {
|
||||
m.fire_ticks = (m.fire_ticks - 4).max(0);
|
||||
m.fire_ticks = 0;
|
||||
} else {
|
||||
if m.fire_ticks % 20 == 0 && !m.fluids.in_lava {
|
||||
m.damage(1.0, Damage::of(DamageKind::OnFire));
|
||||
@@ -496,6 +504,9 @@ pub fn ambient_sound(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
|
||||
play_ambient(m, w, events);
|
||||
}
|
||||
fn play_ambient(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
|
||||
if super::axolotl::is_playing_dead(m) {
|
||||
return;
|
||||
}
|
||||
let sound = match m.species() {
|
||||
// Warden.getAmbientSound: by anger, silent while roaring or digging.
|
||||
Species::Warden => match super::warden::ambient_sound(m) {
|
||||
@@ -813,6 +824,7 @@ fn server_ai_step(
|
||||
if m.species() == Species::Sniffer
|
||||
|| m.species() == Species::HappyGhast && m.is_baby()
|
||||
|| m.species() == Species::CopperGolem
|
||||
|| m.species() == Species::Axolotl
|
||||
{
|
||||
super::animal_brain::tick(m, w, level_random, events);
|
||||
}
|
||||
@@ -824,8 +836,10 @@ fn server_ai_step(
|
||||
m.ai.jumping = false;
|
||||
return;
|
||||
}
|
||||
m.move_control_tick(w, events);
|
||||
m.look_control_tick();
|
||||
if !super::axolotl::is_playing_dead(m) {
|
||||
m.move_control_tick(w, events);
|
||||
m.look_control_tick();
|
||||
}
|
||||
m.jump_control_tick();
|
||||
}
|
||||
fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
|
||||
@@ -1352,3 +1366,12 @@ pub fn swim_sound(m: &Mob) -> &'static str {
|
||||
_ => "entity.generic.swim",
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod bucket_axolotl_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn bucket_axolotl_uses_aquatic_not_generic_land_ai() {
|
||||
assert_eq!(family(Species::Axolotl), Family::Aquatic);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -194,11 +194,21 @@ pub struct Memories {
|
||||
pub sniff_cooldown: Slot<()>,
|
||||
pub gaze_cooldown_ticks: Slot<i32>,
|
||||
pub transport_items_cooldown_ticks: Slot<i32>,
|
||||
pub nearest_attackable: Slot<Who>,
|
||||
pub attack_target: Slot<Who>,
|
||||
pub attack_cooling_down: Slot<bool>,
|
||||
pub hunting_cooldown: Slot<bool>,
|
||||
pub play_dead_ticks: Slot<i32>,
|
||||
pub visited_block_positions: Slot<Vec<[i32; 3]>>,
|
||||
pub unreachable_transport_block_positions: Slot<Vec<[i32; 3]>>,
|
||||
}
|
||||
impl Memories {
|
||||
fn tick(&mut self) {
|
||||
self.nearest_attackable.tick();
|
||||
self.attack_target.tick();
|
||||
self.attack_cooling_down.tick();
|
||||
self.hunting_cooldown.tick();
|
||||
self.play_dead_ticks.tick();
|
||||
self.mobs.tick();
|
||||
self.visible_mobs.tick();
|
||||
self.nearest_players.tick();
|
||||
@@ -231,6 +241,8 @@ impl Memories {
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Act {
|
||||
Core,
|
||||
Fight,
|
||||
PlayDead,
|
||||
Idle,
|
||||
Sniff,
|
||||
Dig,
|
||||
@@ -240,6 +252,8 @@ impl Act {
|
||||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
Act::Core => "core",
|
||||
Act::Fight => "fight",
|
||||
Act::PlayDead => "play_dead",
|
||||
Act::Idle => "idle",
|
||||
Act::Sniff => "sniff",
|
||||
Act::Dig => "dig",
|
||||
@@ -251,6 +265,7 @@ impl Act {
|
||||
/// Which brain.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Kind {
|
||||
Axolotl,
|
||||
Sniffer,
|
||||
/// A happy ghast (the brain ticks while it is a ghastling).
|
||||
Ghastling,
|
||||
@@ -261,6 +276,8 @@ pub enum Kind {
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
enum Sensor {
|
||||
Living,
|
||||
AxolotlAttackables,
|
||||
AdultSameType,
|
||||
HurtBy,
|
||||
Players,
|
||||
Tempting,
|
||||
@@ -270,6 +287,13 @@ impl Kind {
|
||||
/// `BRAIN_PROVIDER`'s sensors, in order (all scan every 20 ticks).
|
||||
fn sensors(self) -> &'static [Sensor] {
|
||||
match self {
|
||||
Kind::Axolotl => &[
|
||||
Sensor::Living,
|
||||
Sensor::AdultSameType,
|
||||
Sensor::HurtBy,
|
||||
Sensor::AxolotlAttackables,
|
||||
Sensor::Tempting,
|
||||
],
|
||||
Kind::Sniffer => &[
|
||||
Sensor::Living,
|
||||
Sensor::HurtBy,
|
||||
@@ -322,7 +346,11 @@ pub(super) fn mem_ref(m: &Mob) -> Option<&Memories> {
|
||||
|
||||
/// The brain kind a mob has, if any.
|
||||
pub fn kind_of(m: &Mob) -> Option<Kind> {
|
||||
match m.species() {
|
||||
kind_for_species(m.species())
|
||||
}
|
||||
fn kind_for_species(species: Species) -> Option<Kind> {
|
||||
match species {
|
||||
Species::Axolotl => Some(Kind::Axolotl),
|
||||
Species::Sniffer => Some(Kind::Sniffer),
|
||||
// Every happy ghast has the brain; only the ghastling's ticks.
|
||||
Species::HappyGhast => Some(Kind::Ghastling),
|
||||
@@ -353,6 +381,7 @@ pub fn init(m: &mut Mob, shuffle_seed: i64) {
|
||||
list: Vec::new(),
|
||||
};
|
||||
b.list = match kind {
|
||||
Kind::Axolotl => axolotl_package(shuffle_seed),
|
||||
Kind::Sniffer => sniffer_package(shuffle_seed),
|
||||
Kind::Ghastling => ghastling_package(shuffle_seed),
|
||||
Kind::CopperGolem => copper_golem_package(shuffle_seed),
|
||||
@@ -399,7 +428,16 @@ pub fn set_breed_partner(m: &mut Mob, partner: u32) {
|
||||
}
|
||||
let who = Who::Mob(partner);
|
||||
mem(m).breed_target.set(who);
|
||||
lock_gaze_and_walk(m, who, 1.0, 2);
|
||||
lock_gaze_and_walk(
|
||||
m,
|
||||
who,
|
||||
if m.species() == Species::Axolotl {
|
||||
0.2
|
||||
} else {
|
||||
1.0
|
||||
},
|
||||
2,
|
||||
);
|
||||
}
|
||||
|
||||
/// `AnimalMakeLove.tick` after the birth: the partner forgets this mob.
|
||||
@@ -413,7 +451,16 @@ pub fn lock_gaze(m: &mut Mob, partner: u32) {
|
||||
if m.extra.animal_brain.is_none() {
|
||||
return;
|
||||
}
|
||||
lock_gaze_and_walk(m, Who::Mob(partner), 1.0, 2);
|
||||
lock_gaze_and_walk(
|
||||
m,
|
||||
Who::Mob(partner),
|
||||
if m.species() == Species::Axolotl {
|
||||
0.2
|
||||
} else {
|
||||
1.0
|
||||
},
|
||||
2,
|
||||
);
|
||||
}
|
||||
|
||||
/// What behaviours read and emit during a brain tick.
|
||||
@@ -457,6 +504,13 @@ pub fn tick(m: &mut Mob, w: &MobWorld, lr: &mut LegacyRandom, events: &mut Vec<M
|
||||
brain_mut(m).list = list;
|
||||
update_activity(m);
|
||||
m.ai.panicking = is_panicking(m);
|
||||
if m.species() == Species::Axolotl {
|
||||
m.extra.axolotl.playing_dead = mem(m)
|
||||
.play_dead_ticks
|
||||
.value()
|
||||
.is_some_and(|ticks| ticks > 0);
|
||||
m.ai.target = mem(m).attack_target.value();
|
||||
}
|
||||
}
|
||||
|
||||
/// `SnifferAi.updateActivity` / `HappyGhastAi.updateActivity`:
|
||||
@@ -464,10 +518,15 @@ pub fn tick(m: &mut Mob, w: &MobWorld, lr: &mut LegacyRandom, events: &mut Vec<M
|
||||
fn update_activity(m: &mut Mob) {
|
||||
let b = brain_mut(m);
|
||||
let mm = &b.mem;
|
||||
if b.kind == Kind::Axolotl {
|
||||
update_axolotl_activity(b);
|
||||
return;
|
||||
}
|
||||
let order: &[Act] = match b.kind {
|
||||
Kind::Sniffer => &[Act::Dig, Act::Sniff, Act::Idle],
|
||||
Kind::Ghastling => &[Act::Panic, Act::Idle],
|
||||
Kind::CopperGolem => &[Act::Idle],
|
||||
Kind::Axolotl => unreachable!(),
|
||||
};
|
||||
for &a in order {
|
||||
let ok = match a {
|
||||
@@ -484,6 +543,7 @@ fn update_activity(m: &mut Mob) {
|
||||
Act::Idle => b.kind != Kind::Sniffer || !mm.sniffer_digging.present(),
|
||||
Act::Panic => mm.is_panicking.present(),
|
||||
Act::Core => true,
|
||||
Act::Fight | Act::PlayDead => false,
|
||||
};
|
||||
if ok {
|
||||
b.activity = a;
|
||||
@@ -523,6 +583,16 @@ fn tick_sensors(m: &mut Mob, w: &MobWorld) {
|
||||
}
|
||||
match sensor {
|
||||
Sensor::Living => sense_living(m, w),
|
||||
Sensor::AxolotlAttackables => sense_axolotl_attackables(m, w),
|
||||
Sensor::AdultSameType => {
|
||||
let found = find_closest(m, w, |m, who| match who {
|
||||
Who::Mob(id) => w
|
||||
.seen(id)
|
||||
.is_some_and(|s| !s.baby && s.species == m.species()),
|
||||
_ => false,
|
||||
});
|
||||
mem(m).nearest_visible_adult.set_opt(found);
|
||||
}
|
||||
Sensor::HurtBy => sense_hurt(m, w),
|
||||
Sensor::Players => sense_players(m, w),
|
||||
Sensor::Tempting => sense_tempting(m, w),
|
||||
@@ -571,7 +641,10 @@ fn targetable(m: &mut Mob, w: &MobWorld, who: Who) -> bool {
|
||||
}
|
||||
Who::Mob(id) => {
|
||||
let Some(s) = w.seen(id) else { return false };
|
||||
s.alive && m.distance_sqr(s.position) <= range * range && m.sees(w, who)
|
||||
s.alive
|
||||
&& !s.playing_dead
|
||||
&& m.distance_sqr(s.position) <= range * range
|
||||
&& m.sees(w, who)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -759,6 +832,8 @@ impl Timed {
|
||||
#[derive(Clone, Debug)]
|
||||
struct Gate {
|
||||
running: bool,
|
||||
shuffle: bool,
|
||||
try_all: bool,
|
||||
random: LegacyRandom,
|
||||
kids: Vec<(B, i32, f64)>,
|
||||
/// The gate's memory requirements.
|
||||
@@ -768,6 +843,8 @@ impl Gate {
|
||||
fn run_one(seed: i64, kids: Vec<(B, i32)>) -> Self {
|
||||
Self {
|
||||
running: false,
|
||||
shuffle: true,
|
||||
try_all: false,
|
||||
random: LegacyRandom::new(seed),
|
||||
kids: kids.into_iter().map(|(b, w)| (b, w, 0.0)).collect(),
|
||||
when: None,
|
||||
@@ -786,13 +863,15 @@ impl Gate {
|
||||
self.running = true;
|
||||
// ShufflingList.shuffle: a fresh weight for each entry in the
|
||||
// current order, then a stable sort.
|
||||
for k in &mut self.kids {
|
||||
let r = self.random.next_float();
|
||||
k.2 = -horizon_core::jmath::pow(f64::from(r), f64::from(1.0_f32 / k.1 as f32));
|
||||
if self.shuffle {
|
||||
for k in &mut self.kids {
|
||||
let r = self.random.next_float();
|
||||
k.2 = -horizon_core::jmath::pow(f64::from(r), f64::from(1.0_f32 / k.1 as f32));
|
||||
}
|
||||
self.kids.sort_by(|a, b| a.2.total_cmp(&b.2));
|
||||
}
|
||||
self.kids.sort_by(|a, b| a.2.total_cmp(&b.2));
|
||||
for k in &mut self.kids {
|
||||
if !k.0.running() && k.0.try_start(m, cx) {
|
||||
if !k.0.running() && k.0.try_start(m, cx) && !self.try_all {
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -820,6 +899,12 @@ impl Gate {
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum B {
|
||||
AxolotlAction {
|
||||
action: AxolotlAction,
|
||||
running: bool,
|
||||
until: i64,
|
||||
},
|
||||
PlayDead(Timed),
|
||||
Swim(Timed),
|
||||
/// `AnimalPanic`: flying (`AirAndWaterRandomPos`) or on land, and
|
||||
/// whether the sniffer's override resets its sniffing first.
|
||||
@@ -890,7 +975,8 @@ enum B {
|
||||
impl B {
|
||||
fn running(&self) -> bool {
|
||||
match self {
|
||||
B::Swim(t)
|
||||
B::PlayDead(t)
|
||||
| B::Swim(t)
|
||||
| B::AnimalPanic { t, .. }
|
||||
| B::MoveToTargetSink { t, .. }
|
||||
| B::CountDownTemptation(t)
|
||||
@@ -908,7 +994,8 @@ impl B {
|
||||
| B::CountDownTransport(t) => t.running,
|
||||
B::Transport(x) => x.running,
|
||||
B::LookAtPlayerSometimes(running, _) => *running,
|
||||
B::WalkToLookTarget { running, .. }
|
||||
B::AxolotlAction { running, .. }
|
||||
| B::WalkToLookTarget { running, .. }
|
||||
| B::LookAtPlayer(running)
|
||||
| B::Stroll { running, .. }
|
||||
| B::FollowAdult { running, .. } => *running,
|
||||
@@ -919,7 +1006,8 @@ impl B {
|
||||
/// cleared with the rest).
|
||||
fn reset(&mut self) {
|
||||
match self {
|
||||
B::Swim(t)
|
||||
B::PlayDead(t)
|
||||
| B::Swim(t)
|
||||
| B::AnimalPanic { t, .. }
|
||||
| B::CountDownTemptation(t)
|
||||
| B::MakeLove { t, .. }
|
||||
@@ -952,7 +1040,8 @@ impl B {
|
||||
fn one_shot(&self) -> bool {
|
||||
matches!(
|
||||
self,
|
||||
B::WalkToLookTarget { .. }
|
||||
B::AxolotlAction { .. }
|
||||
| B::WalkToLookTarget { .. }
|
||||
| B::LookAtPlayer(_)
|
||||
| B::LookAtPlayerSometimes(..)
|
||||
| B::Stroll { .. }
|
||||
@@ -961,7 +1050,8 @@ impl B {
|
||||
}
|
||||
fn set_one_shot(&mut self, on: bool) {
|
||||
match self {
|
||||
B::WalkToLookTarget { running, .. }
|
||||
B::AxolotlAction { running, .. }
|
||||
| B::WalkToLookTarget { running, .. }
|
||||
| B::LookAtPlayer(running)
|
||||
| B::LookAtPlayerSometimes(running, _)
|
||||
| B::Stroll { running, .. }
|
||||
@@ -982,6 +1072,19 @@ impl B {
|
||||
let now = cx.now;
|
||||
match self {
|
||||
B::Gate(g) => g.try_start(m, cx),
|
||||
B::PlayDead(t) => {
|
||||
if !m.fluids.in_water
|
||||
|| !mem(m).play_dead_ticks.present()
|
||||
|| !mem(m).hurt_by_entity.present()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
t.begin(cx);
|
||||
mem(m).walk_target.clear();
|
||||
mem(m).look_target.clear();
|
||||
m.add_effect("minecraft:regeneration", 200, 0);
|
||||
true
|
||||
}
|
||||
B::Swim(t) => {
|
||||
if !swim_condition(m) {
|
||||
return false;
|
||||
@@ -1082,7 +1185,12 @@ impl B {
|
||||
partner: m.id,
|
||||
});
|
||||
}
|
||||
lock_gaze_and_walk(m, partner, 1.0, 2);
|
||||
let speed = if m.species() == Species::Axolotl {
|
||||
0.2
|
||||
} else {
|
||||
1.0
|
||||
};
|
||||
lock_gaze_and_walk(m, partner, speed, 2);
|
||||
*spawn_at = now + 60 + i64::from(m.random.next_int_bound(50).unwrap_or(0));
|
||||
true
|
||||
}
|
||||
@@ -1196,7 +1304,8 @@ impl B {
|
||||
t.begin(cx);
|
||||
true
|
||||
}
|
||||
B::WalkToLookTarget { .. }
|
||||
B::AxolotlAction { .. }
|
||||
| B::WalkToLookTarget { .. }
|
||||
| B::LookAtPlayer(_)
|
||||
| B::LookAtPlayerSometimes(..)
|
||||
| B::Stroll { .. }
|
||||
@@ -1207,6 +1316,11 @@ impl B {
|
||||
/// A one-shot's trigger.
|
||||
fn trigger(&mut self, m: &mut Mob, cx: &mut Bx) -> bool {
|
||||
match *self {
|
||||
B::AxolotlAction {
|
||||
action,
|
||||
ref mut until,
|
||||
..
|
||||
} => axolotl_action(m, cx, action, until),
|
||||
B::WalkToLookTarget { speed, close, .. } => {
|
||||
let mm = mem(m);
|
||||
if mm.walk_target.present() {
|
||||
@@ -1252,7 +1366,11 @@ impl B {
|
||||
let Some(t) = found else { return false };
|
||||
// Ticker.tickDownAndCheck (UniformInt 40..80 on the level random).
|
||||
if *ticks == 0 {
|
||||
*ticks = 40 + cx.lr.next_int_bound(41).unwrap_or(0) - 1;
|
||||
*ticks = if m.species() == Species::Axolotl {
|
||||
30 + cx.lr.next_int_bound(31).unwrap_or(0) - 1
|
||||
} else {
|
||||
40 + cx.lr.next_int_bound(41).unwrap_or(0) - 1
|
||||
};
|
||||
return false;
|
||||
}
|
||||
*ticks -= 1;
|
||||
@@ -1265,6 +1383,9 @@ impl B {
|
||||
B::Stroll {
|
||||
fly, speed, range, ..
|
||||
} => {
|
||||
if m.species() == Species::Axolotl && m.fluids.in_water {
|
||||
return false;
|
||||
}
|
||||
if mem(m).walk_target.present() {
|
||||
return false;
|
||||
}
|
||||
@@ -1295,9 +1416,24 @@ impl B {
|
||||
};
|
||||
// closerThan(adult, 17) && !closerThan(adult, 3)
|
||||
let d = m.distance_sqr(at.position);
|
||||
if !(3.0 * 3.0..17.0 * 17.0).contains(&d) {
|
||||
let min = if m.species() == Species::Axolotl {
|
||||
5.0
|
||||
} else {
|
||||
3.0
|
||||
};
|
||||
if !(min * min..17.0 * 17.0).contains(&d) {
|
||||
return false;
|
||||
}
|
||||
let speed = if m.species() == Species::Axolotl {
|
||||
axolotl_speed(m, true)
|
||||
} else {
|
||||
1.1
|
||||
};
|
||||
let close = if m.species() == Species::Axolotl {
|
||||
4 + cx.lr.next_int_bound(12).unwrap_or(0)
|
||||
} else {
|
||||
2
|
||||
};
|
||||
let mm = mem(m);
|
||||
mm.walk_target.set(WalkTarget {
|
||||
target: Tracker::Entity {
|
||||
@@ -1305,8 +1441,8 @@ impl B {
|
||||
eye: true,
|
||||
block_eye: true,
|
||||
},
|
||||
speed: 1.1,
|
||||
close: 2,
|
||||
speed,
|
||||
close,
|
||||
});
|
||||
mm.look_target.set(Tracker::Entity {
|
||||
who: adult,
|
||||
@@ -1327,6 +1463,12 @@ impl B {
|
||||
}
|
||||
let now = cx.now;
|
||||
match self {
|
||||
B::AxolotlAction { .. } => {}
|
||||
B::PlayDead(t) => {
|
||||
if t.timed_out(now) || !m.fluids.in_water || !mem(m).play_dead_ticks.present() {
|
||||
self.do_stop(m, cx);
|
||||
}
|
||||
}
|
||||
B::Gate(g) => g.tick_or_stop(m, cx),
|
||||
B::Swim(t) => {
|
||||
if t.timed_out(now) || !swim_condition(m) {
|
||||
@@ -1419,7 +1561,16 @@ impl B {
|
||||
self.do_stop(m, cx);
|
||||
return;
|
||||
}
|
||||
lock_gaze_and_walk(m, partner, 1.0, 2);
|
||||
lock_gaze_and_walk(
|
||||
m,
|
||||
partner,
|
||||
if m.species() == Species::Axolotl {
|
||||
0.2
|
||||
} else {
|
||||
1.0
|
||||
},
|
||||
2,
|
||||
);
|
||||
if let Who::Mob(id) = partner {
|
||||
cx.events.push(MobEvent::LockGaze {
|
||||
mob: id,
|
||||
@@ -1476,7 +1627,11 @@ impl B {
|
||||
let near =
|
||||
cx.w.target_info(player)
|
||||
.is_some_and(|t| m.distance_sqr(t.position) < close * close);
|
||||
let speed = 1.25;
|
||||
let speed = if m.species() == Species::Axolotl {
|
||||
axolotl_speed(m, false)
|
||||
} else {
|
||||
1.25
|
||||
};
|
||||
let mm = mem(m);
|
||||
if near {
|
||||
mm.walk_target.clear();
|
||||
@@ -1560,6 +1715,8 @@ impl B {
|
||||
}
|
||||
let now = cx.now;
|
||||
match self {
|
||||
B::AxolotlAction { .. } => {}
|
||||
B::PlayDead(t) => t.running = false,
|
||||
B::Gate(g) => g.do_stop(m, cx),
|
||||
B::Swim(t) | B::DoNothing(t) => t.running = false,
|
||||
B::AnimalPanic { t, .. } => {
|
||||
@@ -1788,6 +1945,7 @@ fn follow_temptation_close(m: &mut Mob) -> f64 {
|
||||
3.5
|
||||
}
|
||||
}
|
||||
Kind::Axolotl => 2.5,
|
||||
Kind::Ghastling | Kind::CopperGolem => 3.0,
|
||||
}
|
||||
}
|
||||
@@ -1797,8 +1955,8 @@ fn can_mate_with(m: &Mob, w: &MobWorld, partner: Who) -> bool {
|
||||
s.species == m.species()
|
||||
&& s.in_love
|
||||
&& m.extra.in_love > 0
|
||||
&& sniffer::can_mate_state(sniffer::state(m))
|
||||
&& sniffer::can_mate_state(s.variant)
|
||||
&& (m.species() != Species::Sniffer
|
||||
|| sniffer::can_mate_state(sniffer::state(m)) && sniffer::can_mate_state(s.variant))
|
||||
}
|
||||
fn partner_panicking(_w: &MobWorld, _partner: Who) -> bool {
|
||||
false
|
||||
@@ -2093,6 +2251,431 @@ fn move_to_target_sink(min: i32, max: i32) -> B {
|
||||
}
|
||||
}
|
||||
|
||||
// ---- AxolotlAi -----------------------------------------------------------
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
enum AxolotlAction {
|
||||
ValidateDead,
|
||||
StartAttack,
|
||||
StopAttack,
|
||||
Chase,
|
||||
Bite,
|
||||
EraseAttackBreeding,
|
||||
EraseDeadBreeding,
|
||||
FindLiquid,
|
||||
SwimStroll,
|
||||
WalkFromLook,
|
||||
StayWater,
|
||||
StayGround,
|
||||
}
|
||||
fn axolotl_speed(m: &Mob, chase: bool) -> f32 {
|
||||
if m.fluids.in_water {
|
||||
if chase { 0.6 } else { 0.5 }
|
||||
} else {
|
||||
0.15
|
||||
}
|
||||
}
|
||||
pub fn set_play_dead(m: &mut Mob) {
|
||||
if m.extra.animal_brain.is_none() {
|
||||
init(m, i64::from(m.id));
|
||||
}
|
||||
mem(m).play_dead_ticks.set(super::axolotl::PLAY_DEAD_TICKS);
|
||||
}
|
||||
pub fn hunting_cooldown(m: &Mob) -> Option<i64> {
|
||||
mem_ref(m).and_then(|mm| mm.hunting_cooldown.get().map(|_| mm.hunting_cooldown.ttl))
|
||||
}
|
||||
pub fn set_hunting_cooldown(m: &mut Mob, ticks: i64) {
|
||||
if m.extra.animal_brain.is_none() {
|
||||
init(m, i64::from(m.id));
|
||||
}
|
||||
mem(m).hunting_cooldown.set_ttl(true, ticks);
|
||||
}
|
||||
fn validate_play_dead(b: &mut Brain) -> bool {
|
||||
let Some(ticks) = b.mem.play_dead_ticks.value() else {
|
||||
return false;
|
||||
};
|
||||
if ticks <= 0 {
|
||||
b.mem.play_dead_ticks.clear();
|
||||
b.mem.hurt_by_entity.clear();
|
||||
b.activity = Act::Idle;
|
||||
} else {
|
||||
b.mem.play_dead_ticks.set(ticks - 1);
|
||||
}
|
||||
true
|
||||
}
|
||||
fn update_axolotl_activity(b: &mut Brain) {
|
||||
let old = b.activity;
|
||||
// PLAY_DEAD remains active until ValidatePlayDead resets to default IDLE.
|
||||
if old == Act::PlayDead {
|
||||
return;
|
||||
}
|
||||
b.activity = if b.mem.play_dead_ticks.present() {
|
||||
Act::PlayDead
|
||||
} else if b.mem.attack_target.present() {
|
||||
Act::Fight
|
||||
} else {
|
||||
Act::Idle
|
||||
};
|
||||
if old != b.activity && old == Act::Fight {
|
||||
b.mem
|
||||
.hunting_cooldown
|
||||
.set_ttl(true, super::axolotl::HUNTING_COOLDOWN);
|
||||
b.mem.attack_target.clear();
|
||||
}
|
||||
}
|
||||
fn sense_axolotl_attackables(m: &mut Mob, w: &MobWorld) {
|
||||
let cooldown = mem(m).hunting_cooldown.present();
|
||||
let target = find_closest(m, w, |m, who| {
|
||||
let Who::Mob(id) = who else { return false };
|
||||
let Some(s) = w.seen(id) else { return false };
|
||||
let id = format!("minecraft:{}", super::species::def(s.species).name);
|
||||
super::axolotl::prey_eligible(
|
||||
m.distance_sqr(s.position),
|
||||
s.in_water,
|
||||
w.data.entity_has("minecraft:axolotl_always_hostiles", &id),
|
||||
w.data.entity_has("minecraft:axolotl_hunt_targets", &id),
|
||||
cooldown,
|
||||
s.alive && !s.playing_dead,
|
||||
)
|
||||
});
|
||||
mem(m).nearest_attackable.set_opt(target);
|
||||
}
|
||||
fn axolotl_action(m: &mut Mob, cx: &mut Bx, action: AxolotlAction, until: &mut i64) -> bool {
|
||||
use AxolotlAction::*;
|
||||
match action {
|
||||
ValidateDead => validate_play_dead(brain_mut(m)),
|
||||
StartAttack => {
|
||||
let mm = mem(m);
|
||||
if mm.attack_target.present() || mm.breed_target.present() {
|
||||
return false;
|
||||
}
|
||||
let Some(target) = mm.nearest_attackable.value() else {
|
||||
return false;
|
||||
};
|
||||
if !cx
|
||||
.w
|
||||
.target_info(target)
|
||||
.is_some_and(|t| t.alive && !t.creative)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
mem(m).attack_target.set(target);
|
||||
mem(m).cant_reach_walk_target_since.clear();
|
||||
m.ai.target = Some(target);
|
||||
true
|
||||
}
|
||||
StopAttack => {
|
||||
let Some(target) = mem(m).attack_target.value() else {
|
||||
return false;
|
||||
};
|
||||
let tired = mem(m)
|
||||
.cant_reach_walk_target_since
|
||||
.value()
|
||||
.is_some_and(|t| cx.now - t > 200);
|
||||
let valid =
|
||||
cx.w.target_info(target)
|
||||
.is_some_and(|t| t.alive && !t.creative)
|
||||
&& match target {
|
||||
Who::Mob(id) => cx.w.seen(id).is_some_and(|s| !s.playing_dead),
|
||||
Who::Player => true,
|
||||
};
|
||||
if tired || !valid {
|
||||
super::axolotl::on_stop_attacking(m, cx.w, target, cx.events);
|
||||
mem(m).attack_target.clear();
|
||||
m.ai.target = None;
|
||||
}
|
||||
true
|
||||
}
|
||||
Chase => {
|
||||
let Some(target) = mem(m).attack_target.value() else {
|
||||
return false;
|
||||
};
|
||||
let speed = axolotl_speed(m, true);
|
||||
if cx
|
||||
.w
|
||||
.target_info(target)
|
||||
.is_some_and(|t| m.within_melee_range(&t))
|
||||
&& visible_test(m, cx.w, target)
|
||||
{
|
||||
mem(m).walk_target.clear();
|
||||
} else {
|
||||
let tracker = Tracker::entity(target, true);
|
||||
mem(m).look_target.set(tracker);
|
||||
mem(m).walk_target.set(WalkTarget {
|
||||
target: Tracker::entity(target, false),
|
||||
speed,
|
||||
close: 0,
|
||||
});
|
||||
}
|
||||
true
|
||||
}
|
||||
Bite => {
|
||||
let mm = mem(m);
|
||||
if mm.attack_cooling_down.present() {
|
||||
return false;
|
||||
}
|
||||
let Some(target) = mm.attack_target.value() else {
|
||||
return false;
|
||||
};
|
||||
if !visible_test(m, cx.w, target)
|
||||
|| !cx
|
||||
.w
|
||||
.target_info(target)
|
||||
.is_some_and(|t| m.within_melee_range(&t))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
mem(m).look_target.set(Tracker::entity(target, true));
|
||||
m.swing();
|
||||
super::ai::do_hurt_target(
|
||||
m,
|
||||
target,
|
||||
&mut super::goals::Cx {
|
||||
w: cx.w,
|
||||
events: cx.events,
|
||||
},
|
||||
);
|
||||
m.sound("entity.axolotl.attack", cx.events);
|
||||
mem(m).attack_cooling_down.set_ttl(true, 20);
|
||||
true
|
||||
}
|
||||
EraseAttackBreeding | EraseDeadBreeding => {
|
||||
if !mem(m).breed_target.present() {
|
||||
return false;
|
||||
}
|
||||
if matches!(action, EraseAttackBreeding) {
|
||||
mem(m).attack_target.clear();
|
||||
} else {
|
||||
mem(m).play_dead_ticks.clear();
|
||||
}
|
||||
true
|
||||
}
|
||||
FindLiquid => {
|
||||
if mem(m).walk_target.present() || mem(m).attack_target.present() {
|
||||
return false;
|
||||
}
|
||||
let p = [
|
||||
m.position.x.floor() as i32,
|
||||
m.position.y.floor() as i32,
|
||||
m.position.z.floor() as i32,
|
||||
];
|
||||
if cx.w.fluid(p[0], p[1], p[2]) == crate::blocks::Fluid::Water {
|
||||
return false;
|
||||
}
|
||||
if cx.now < *until {
|
||||
*until = cx.now + 22;
|
||||
return true;
|
||||
}
|
||||
let mut positions = Vec::new();
|
||||
// BlockPos.withinManhattan: distance, x, y, then positive/negative z.
|
||||
for distance in 0..=18i32 {
|
||||
for x in -6..=6i32 {
|
||||
for y in -6..=6i32 {
|
||||
let z = distance - x.abs() - y.abs();
|
||||
if !(0..=6).contains(&z) {
|
||||
continue;
|
||||
}
|
||||
positions.push([p[0] + x, p[1] + y, p[2] + z]);
|
||||
if z != 0 {
|
||||
positions.push([p[0] + x, p[1] + y, p[2] - z]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut found = None;
|
||||
for q in positions {
|
||||
if (q[0] == p[0] && q[2] == p[2])
|
||||
|| cx.w.fluid(q[0], q[1], q[2]) != crate::blocks::Fluid::Water
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let name = cx.w.block_name(q[0], q[1], q[2]);
|
||||
if name != "minecraft:water" {
|
||||
continue;
|
||||
}
|
||||
if cx.w.block_name(q[0], q[1] + 1, q[2]).ends_with("air") {
|
||||
found = Some(q);
|
||||
break;
|
||||
}
|
||||
let v = Vec3::new(
|
||||
f64::from(q[0]) + 0.5,
|
||||
f64::from(q[1]) + 0.5,
|
||||
f64::from(q[2]) + 0.5,
|
||||
);
|
||||
if found.is_none() && m.distance_sqr(v) >= 2.25 {
|
||||
found = Some(q);
|
||||
}
|
||||
}
|
||||
if let Some(q) = found {
|
||||
mem(m).look_target.set(Tracker::Block(q));
|
||||
mem(m).walk_target.set(WalkTarget {
|
||||
target: Tracker::Block(q),
|
||||
speed: 0.15,
|
||||
close: 0,
|
||||
});
|
||||
}
|
||||
*until = cx.now + 40;
|
||||
true
|
||||
}
|
||||
SwimStroll => {
|
||||
if mem(m).walk_target.present() || !m.fluids.in_water {
|
||||
return false;
|
||||
}
|
||||
let mut fallback: Option<Vec3> = None;
|
||||
for (h, v) in [(1, 1), (3, 3), (5, 5), (6, 5), (7, 7), (10, 7)] {
|
||||
let point = if let Some(p) = fallback {
|
||||
let delta =
|
||||
Vec3::new(p.x - m.position.x, p.y - m.position.y, p.z - m.position.z);
|
||||
let length = (delta.x * delta.x + delta.y * delta.y + delta.z * delta.z).sqrt();
|
||||
let n = if length < 1.0e-5 {
|
||||
Vec3::ZERO
|
||||
} else {
|
||||
Vec3::new(delta.x / length, delta.y / length, delta.z / length)
|
||||
};
|
||||
Some(Vec3::new(
|
||||
m.position.x + n.x * f64::from(h),
|
||||
m.position.y + n.y * f64::from(v),
|
||||
m.position.z + n.z * f64::from(h),
|
||||
))
|
||||
} else {
|
||||
let mut p = m.default_random_pos(cx.w, h, v);
|
||||
let mut count = 0;
|
||||
while let Some(q) = p {
|
||||
let state = cx.w.world.block(
|
||||
q[0].floor() as i32,
|
||||
q[1].floor() as i32,
|
||||
q[2].floor() as i32,
|
||||
);
|
||||
if cx.w.data.state(state).flags & super::data::WATER != 0 || count >= 10 {
|
||||
break;
|
||||
}
|
||||
count += 1;
|
||||
p = m.default_random_pos(cx.w, h, v);
|
||||
}
|
||||
p.map(|q| Vec3::new(q[0], q[1], q[2]))
|
||||
};
|
||||
let Some(point) = point else { break };
|
||||
let q = [
|
||||
point.x.floor() as i32,
|
||||
point.y.floor() as i32,
|
||||
point.z.floor() as i32,
|
||||
];
|
||||
let restricted = m.restricted(f64::from(h), q);
|
||||
if cx.w.fluid(q[0], q[1], q[2]) == crate::blocks::Fluid::None || restricted {
|
||||
break;
|
||||
}
|
||||
fallback = Some(point);
|
||||
}
|
||||
mem(m)
|
||||
.walk_target
|
||||
.set_opt(fallback.map(|p| WalkTarget::point([p.x, p.y, p.z], 0.5, 0)));
|
||||
true
|
||||
}
|
||||
WalkFromLook => {
|
||||
if mem(m).walk_target.present() {
|
||||
return false;
|
||||
}
|
||||
let Some(t) = mem(m).look_target.value() else {
|
||||
return false;
|
||||
};
|
||||
let Some(p) = t.block(cx.w) else { return false };
|
||||
if (cx.w.fluid(p[0], p[1], p[2]) == crate::blocks::Fluid::Water) != m.fluids.in_water {
|
||||
return false;
|
||||
}
|
||||
let speed = axolotl_speed(m, false);
|
||||
mem(m).walk_target.set(WalkTarget {
|
||||
target: t,
|
||||
speed,
|
||||
close: 3,
|
||||
});
|
||||
true
|
||||
}
|
||||
StayWater => m.fluids.in_water,
|
||||
StayGround => m.on_ground,
|
||||
}
|
||||
}
|
||||
fn axolotl_package(seed: i64) -> Vec<Entry> {
|
||||
use Act::*;
|
||||
use AxolotlAction::*;
|
||||
let e = |act, b| Entry { act, b };
|
||||
let action = |action| B::AxolotlAction {
|
||||
action,
|
||||
running: false,
|
||||
until: 0,
|
||||
};
|
||||
vec![
|
||||
// Native activity slots, merged by behavior priority.
|
||||
e(Core, B::LookAtTargetSink(Timed::new(45, 90))),
|
||||
e(Idle, B::LookAtPlayerSometimes(false, 0)),
|
||||
e(Fight, action(StopAttack)),
|
||||
e(PlayDead, B::PlayDead(Timed::new(200, 200))),
|
||||
e(Core, move_to_target_sink(150, 250)),
|
||||
e(
|
||||
Idle,
|
||||
B::MakeLove {
|
||||
t: Timed::new(325, 325),
|
||||
spawn_at: 0,
|
||||
},
|
||||
),
|
||||
e(Fight, action(Chase)),
|
||||
e(PlayDead, action(EraseDeadBreeding)),
|
||||
e(Core, action(ValidateDead)),
|
||||
e(
|
||||
Idle,
|
||||
B::Gate(Box::new(Gate::run_one(
|
||||
seed,
|
||||
vec![
|
||||
(
|
||||
B::FollowTemptation {
|
||||
t: Timed::new(60, 60),
|
||||
look_in_the_eyes: false,
|
||||
},
|
||||
1,
|
||||
),
|
||||
(
|
||||
B::FollowAdult {
|
||||
running: false,
|
||||
player: false,
|
||||
},
|
||||
1,
|
||||
),
|
||||
],
|
||||
))),
|
||||
),
|
||||
e(Fight, action(Bite)),
|
||||
e(Core, B::CountDownTemptation(Timed::new(60, 60))),
|
||||
e(Idle, action(StartAttack)),
|
||||
e(Idle, action(FindLiquid)),
|
||||
e(Fight, action(EraseAttackBreeding)),
|
||||
e(
|
||||
Idle,
|
||||
B::Gate(Box::new(Gate {
|
||||
running: false,
|
||||
shuffle: false,
|
||||
try_all: true,
|
||||
random: horizon_core::random::LegacyRandom::new(seed),
|
||||
kids: vec![
|
||||
(action(SwimStroll), 2, 0.0),
|
||||
(
|
||||
B::Stroll {
|
||||
running: false,
|
||||
fly: false,
|
||||
speed: 0.15,
|
||||
range: (10, 7),
|
||||
},
|
||||
2,
|
||||
0.0,
|
||||
),
|
||||
(action(WalkFromLook), 3, 0.0),
|
||||
(action(StayWater), 5, 0.0),
|
||||
(action(StayGround), 5, 0.0),
|
||||
],
|
||||
when: Some(|mm| !mm.walk_target.present()),
|
||||
})),
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
// ---- Debug output (the mob AI harness) ------------------------------------
|
||||
|
||||
fn pos(p: [i32; 3]) -> String {
|
||||
@@ -2134,6 +2717,16 @@ pub fn describe(m: &Mob) -> Option<(String, String)> {
|
||||
};
|
||||
}
|
||||
let n = |l: &Vec<Who>| format!("n{}", l.len());
|
||||
slot!("nearest_attackable", mm.nearest_attackable, |v: &Who| who(
|
||||
*v
|
||||
));
|
||||
slot!("attack_target", mm.attack_target, |v: &Who| who(*v));
|
||||
slot!("attack_cooling_down", mm.attack_cooling_down, |v: &bool| v
|
||||
.to_string());
|
||||
slot!("has_hunting_cooldown", mm.hunting_cooldown, |v: &bool| v
|
||||
.to_string());
|
||||
slot!("play_dead_ticks", mm.play_dead_ticks, |v: &i32| v
|
||||
.to_string());
|
||||
slot!("mobs", mm.mobs, n);
|
||||
slot!("visible_mobs", mm.visible_mobs, |_: &Visible| {
|
||||
"NearestVisibleLivingEntities".to_string()
|
||||
@@ -2219,3 +2812,55 @@ pub fn describe(m: &Mob) -> Option<(String, String)> {
|
||||
out.sort();
|
||||
Some((acts.join("|"), out.join(" ")))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod axolotl_parity_tests {
|
||||
use super::*;
|
||||
fn empty_brain() -> Brain {
|
||||
Brain {
|
||||
kind: Kind::Axolotl,
|
||||
mem: Memories::default(),
|
||||
sensors: Vec::new(),
|
||||
activity: Act::Idle,
|
||||
list: Vec::new(),
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn fight_exit_sets_hunting_cooldown_and_play_dead_has_priority() {
|
||||
let mut b = empty_brain();
|
||||
b.mem.attack_target.set(Who::Mob(1));
|
||||
update_axolotl_activity(&mut b);
|
||||
assert_eq!(b.activity, Act::Fight);
|
||||
b.mem.play_dead_ticks.set(200);
|
||||
update_axolotl_activity(&mut b);
|
||||
assert_eq!(b.activity, Act::PlayDead);
|
||||
assert_eq!(b.mem.hunting_cooldown.ttl, 2400);
|
||||
assert!(!b.mem.attack_target.present());
|
||||
for _ in 0..2400 {
|
||||
b.mem.hunting_cooldown.tick();
|
||||
}
|
||||
assert!(b.mem.hunting_cooldown.present());
|
||||
b.mem.hunting_cooldown.tick();
|
||||
assert!(!b.mem.hunting_cooldown.present());
|
||||
}
|
||||
#[test]
|
||||
fn play_dead_flag_ends_at_zero_before_memory_is_erased() {
|
||||
let mut b = empty_brain();
|
||||
b.activity = Act::PlayDead;
|
||||
b.mem.play_dead_ticks.set(200);
|
||||
b.mem.hurt_by_entity.set(Who::Mob(7));
|
||||
for _ in 0..200 {
|
||||
assert!(validate_play_dead(&mut b));
|
||||
}
|
||||
assert_eq!(b.mem.play_dead_ticks.value(), Some(0));
|
||||
assert_eq!(b.activity, Act::PlayDead);
|
||||
assert!(validate_play_dead(&mut b));
|
||||
assert!(!b.mem.play_dead_ticks.present());
|
||||
assert!(!b.mem.hurt_by_entity.present());
|
||||
assert_eq!(b.activity, Act::Idle);
|
||||
}
|
||||
#[test]
|
||||
fn axolotl_has_native_activity_brain_not_fallback_goals() {
|
||||
assert!(kind_for_species(Species::Axolotl).is_some());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -35,6 +35,19 @@ pub fn register(m: &mut Mob) {
|
||||
let speed = 1.0 / (m.random.next_float() + 1.0) * 0.2;
|
||||
m.anim.v[TENTACLE_SPEED] = speed;
|
||||
}
|
||||
S::Axolotl => {
|
||||
// Native controller scaling is essential: the base speed attribute is 1.0.
|
||||
m.ai.mov.kind = MoveKind::SmoothSwimming {
|
||||
max_turn_x: 85.0,
|
||||
max_turn_y: 10.0,
|
||||
in_water: 0.1,
|
||||
outside: 0.5,
|
||||
gravity: false,
|
||||
};
|
||||
m.ai.look.kind = super::control::LookKind::SmoothSwimming(20.0);
|
||||
m.ai.nav.kind = NavKind::Amphibious;
|
||||
super::animal_brain::init(m, i64::from(m.id));
|
||||
}
|
||||
S::Tadpole => {
|
||||
// TadpoleAi: panic, swim around and look about.
|
||||
let g = &mut m.ai.goals;
|
||||
@@ -267,6 +280,13 @@ pub fn travel(m: &mut Mob, w: &MobWorld, input: Vec3, events: &mut Vec<MobEvent>
|
||||
m.do_move(w, events);
|
||||
true
|
||||
}
|
||||
// Axolotl.travelInWater: no fish sinking or generic water gravity.
|
||||
S::Axolotl if m.fluids.in_water => {
|
||||
m.move_relative(m.ai.speed, input);
|
||||
m.do_move(w, events);
|
||||
m.velocity = Vec3::new(m.velocity.x * 0.9, m.velocity.y * 0.9, m.velocity.z * 0.9);
|
||||
true
|
||||
}
|
||||
// AbstractFish.travelInWater / Dolphin.travelInWater.
|
||||
S::Cod | S::Salmon | S::TropicalFish | S::Pufferfish | S::Dolphin if m.fluids.in_water => {
|
||||
let speed = if m.species() == S::Dolphin {
|
||||
|
||||
@@ -0,0 +1,205 @@
|
||||
//! Axolotl-specific damage, animation and prey rules; activities live in animal_brain.
|
||||
use super::{Mob, MobEvent, MobWorld, Species, Who, animal_brain, keyframes::AnimationState};
|
||||
use horizon_core::random::RandomSource;
|
||||
pub const PLAY_DEAD_TICKS: i32 = 200;
|
||||
pub const HUNTING_COOLDOWN: i64 = 2400;
|
||||
|
||||
/// AxolotlAttackablesSensor: always-hostile targets bypass the hunting cooldown.
|
||||
pub fn prey_eligible(
|
||||
distance: f64,
|
||||
water: bool,
|
||||
hostile: bool,
|
||||
hunt: bool,
|
||||
cooldown: bool,
|
||||
attackable: bool,
|
||||
) -> bool {
|
||||
distance <= 64.0 && water && (hostile || hunt && !cooldown) && attackable
|
||||
}
|
||||
/// Preserve the ordered random draws in Axolotl.hurtServer, even out of water.
|
||||
fn roll_play_dead(
|
||||
random: &mut impl RandomSource,
|
||||
no_ai: bool,
|
||||
health: f32,
|
||||
max: f32,
|
||||
damage: f32,
|
||||
water: bool,
|
||||
entity_source: bool,
|
||||
already: bool,
|
||||
) -> bool {
|
||||
!no_ai
|
||||
&& random.next_int_bound(3).unwrap_or(0) == 0
|
||||
&& ((random.next_int_bound(3).unwrap_or(0) as f32) < damage || health / max < 0.5)
|
||||
&& damage < health
|
||||
&& water
|
||||
&& entity_source
|
||||
&& !already
|
||||
}
|
||||
pub fn before_damage(m: &mut Mob, damage: f32, source: &super::Damage) {
|
||||
if m.species() != Species::Axolotl {
|
||||
return;
|
||||
}
|
||||
let playing = m.extra.axolotl.playing_dead;
|
||||
if roll_play_dead(
|
||||
&mut m.random,
|
||||
m.no_ai,
|
||||
m.health,
|
||||
m.attrs.max_health,
|
||||
damage,
|
||||
m.fluids.in_water,
|
||||
source.attacker.is_some() || source.is_projectile(),
|
||||
playing,
|
||||
) {
|
||||
animal_brain::set_play_dead(m);
|
||||
}
|
||||
}
|
||||
pub fn is_playing_dead(m: &Mob) -> bool {
|
||||
m.species() == Species::Axolotl && m.extra.axolotl.playing_dead
|
||||
}
|
||||
/// Axolotl.onStopAttacking: help the player whose last damage killed the target.
|
||||
pub fn on_stop_attacking(m: &Mob, w: &MobWorld, target: Who, events: &mut Vec<MobEvent>) {
|
||||
if let Who::Mob(id) = target
|
||||
&& let Some(s) = w.seen(id)
|
||||
&& !s.alive
|
||||
&& s.last_damage
|
||||
.is_some_and(|d| d.attacker == Some(Who::Player))
|
||||
&& w.player.as_ref().is_some_and(|p| {
|
||||
m.bounds()
|
||||
.inflate(horizon_core::geometry::Vec3::new(20.0, 20.0, 20.0))
|
||||
.intersects(p.bounds)
|
||||
})
|
||||
{
|
||||
events.push(MobEvent::AxolotlSupportPlayer);
|
||||
}
|
||||
}
|
||||
/// BinaryAnimator(10, IN_OUT_SINE), plus the seven exclusive baby animation states.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Animation {
|
||||
pub playing_dead: bool,
|
||||
old: [u8; 4],
|
||||
value: [u8; 4],
|
||||
pub states: [AnimationState; 7],
|
||||
}
|
||||
impl Animation {
|
||||
pub fn tick(&mut self, baby: bool, water: bool, ground: bool, moving: bool, age: f32) {
|
||||
self.old = self.value;
|
||||
let flags = [
|
||||
self.playing_dead,
|
||||
!self.playing_dead && water,
|
||||
!self.playing_dead && !water && ground,
|
||||
moving,
|
||||
];
|
||||
for (v, on) in self.value.iter_mut().zip(flags) {
|
||||
*v = if on {
|
||||
(*v + 1).min(10)
|
||||
} else {
|
||||
v.saturating_sub(1)
|
||||
};
|
||||
}
|
||||
if baby {
|
||||
let selected = if self.playing_dead {
|
||||
6
|
||||
} else if moving {
|
||||
if water && !ground {
|
||||
1
|
||||
} else if !water && ground {
|
||||
0
|
||||
} else {
|
||||
2
|
||||
}
|
||||
} else if water && !ground {
|
||||
4
|
||||
} else if water && ground {
|
||||
5
|
||||
} else {
|
||||
3
|
||||
};
|
||||
for (i, state) in self.states.iter_mut().enumerate() {
|
||||
if i == selected {
|
||||
state.start_if_stopped(age);
|
||||
} else {
|
||||
state.stop();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn factor(&self, i: usize, partial: f32) -> f32 {
|
||||
let x = (f32::from(self.old[i])
|
||||
+ (f32::from(self.value[i]) - f32::from(self.old[i])) * partial)
|
||||
/ 10.0;
|
||||
((1.0 - horizon_core::jmath::cos(f64::from(x) * std::f64::consts::PI)) / 2.0) as f32
|
||||
}
|
||||
}
|
||||
pub fn tick_animation(m: &mut Mob) {
|
||||
if m.species() != Species::Axolotl {
|
||||
return;
|
||||
}
|
||||
let moving =
|
||||
m.limb_speed > 1.0e-5 || m.yaw != m.previous_yaw || m.head_pitch != m.previous_head_pitch;
|
||||
let baby = m.is_baby();
|
||||
m.extra
|
||||
.axolotl
|
||||
.tick(baby, m.fluids.in_water, m.on_ground, moving, m.age as f32);
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod axolotl_parity_tests {
|
||||
use super::*;
|
||||
use horizon_core::random::LegacyRandom;
|
||||
#[test]
|
||||
fn prey_water_range_and_cooldown_match_native() {
|
||||
assert!(prey_eligible(64.0, true, false, true, false, true));
|
||||
assert!(!prey_eligible(64.01, true, false, true, false, true));
|
||||
assert!(!prey_eligible(4.0, false, true, true, false, true));
|
||||
assert!(!prey_eligible(4.0, true, false, true, true, true));
|
||||
assert!(prey_eligible(4.0, true, true, false, true, true));
|
||||
assert!(!prey_eligible(4.0, true, false, false, false, true));
|
||||
assert!(!prey_eligible(4.0, true, true, true, false, false));
|
||||
}
|
||||
#[test]
|
||||
fn damage_roll_matches_native_draw_order_and_gates() {
|
||||
for seed in 0..100 {
|
||||
for (water, entity, already, no_ai) in [
|
||||
(true, true, false, false),
|
||||
(false, true, false, false),
|
||||
(true, false, false, false),
|
||||
(true, true, true, false),
|
||||
(true, true, false, true),
|
||||
] {
|
||||
let mut expected = LegacyRandom::new(seed);
|
||||
let mut actual = LegacyRandom::new(seed);
|
||||
let result = !no_ai
|
||||
&& expected.next_int_bound(3).unwrap() == 0
|
||||
&& ((expected.next_int_bound(3).unwrap() as f32) < 2.0 || 4.0f32 / 14.0 < 0.5)
|
||||
&& 2.0 < 4.0
|
||||
&& water
|
||||
&& entity
|
||||
&& !already;
|
||||
assert_eq!(
|
||||
roll_play_dead(&mut actual, no_ai, 4.0, 14.0, 2.0, water, entity, already),
|
||||
result
|
||||
);
|
||||
assert_eq!(actual.next_int(), expected.next_int());
|
||||
}
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn playing_dead_eases_and_selects_exclusive_baby_pose() {
|
||||
let mut x = Animation {
|
||||
playing_dead: true,
|
||||
..Animation::default()
|
||||
};
|
||||
for _ in 0..10 {
|
||||
x.tick(true, true, true, true, 20.0);
|
||||
}
|
||||
assert_eq!(x.factor(0, 1.0), 1.0);
|
||||
assert_eq!(x.factor(1, 1.0), 0.0);
|
||||
assert_eq!(x.states.iter().filter(|s| s.started.is_some()).count(), 1);
|
||||
assert!(x.states[6].started.is_some());
|
||||
x.playing_dead = false;
|
||||
for _ in 0..10 {
|
||||
x.tick(true, true, false, true, 30.0);
|
||||
}
|
||||
assert_eq!(x.factor(0, 1.0), 0.0);
|
||||
assert_eq!(x.factor(1, 1.0), 1.0);
|
||||
assert!(x.states[1].started.is_some());
|
||||
}
|
||||
}
|
||||
@@ -1011,7 +1011,7 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
|
||||
},
|
||||
a,
|
||||
),
|
||||
Species::Axolotl => axolotl(p, s, &Axolotl::from_mob(m), a),
|
||||
Species::Axolotl => axolotl(p, s, &Axolotl::from_mob(m, s.partial), a),
|
||||
Species::Frog => frog(
|
||||
p,
|
||||
s,
|
||||
@@ -1031,14 +1031,20 @@ pub fn anim(m: &Mob, s: &State, p: &mut Poses, a: &Animations) -> bool {
|
||||
true
|
||||
}
|
||||
impl Axolotl {
|
||||
pub fn from_mob(m: &Mob) -> Self {
|
||||
let in_water = m.fluids.in_water;
|
||||
pub fn from_mob(m: &Mob, partial: f32) -> Self {
|
||||
let x = &m.extra.axolotl;
|
||||
Self {
|
||||
in_water: if in_water { 1.0 } else { 0.0 },
|
||||
on_ground: if m.on_ground { 1.0 } else { 0.0 },
|
||||
walk: m.anim.states[0],
|
||||
swim: m.anim.states[1],
|
||||
..Self::default()
|
||||
playing_dead: x.factor(0, partial),
|
||||
in_water: x.factor(1, partial),
|
||||
on_ground: x.factor(2, partial),
|
||||
moving: x.factor(3, partial),
|
||||
// Native baby model deliberately reads walkAnimationState, not its underwater counterpart.
|
||||
walk: x.states[0],
|
||||
swim: x.states[1],
|
||||
idle_on_ground: x.states[3],
|
||||
idle_underwater: x.states[4],
|
||||
idle_underwater_on_ground: x.states[5],
|
||||
play_dead: x.states[6],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1000,7 +1000,7 @@ impl Goal for MeleeAttack {
|
||||
let Some(t) = m.target_info(cx.w) else {
|
||||
return false;
|
||||
};
|
||||
if !t.alive {
|
||||
if !t.alive || !t.can_be_seen_as_enemy {
|
||||
return false;
|
||||
}
|
||||
let path = m.create_path_to_entity(cx.w, [t.position.x, t.position.y, t.position.z], 0);
|
||||
@@ -1012,7 +1012,7 @@ impl Goal for MeleeAttack {
|
||||
let Some(t) = m.target_info(cx.w) else {
|
||||
return false;
|
||||
};
|
||||
if !t.alive {
|
||||
if !t.alive || !t.can_be_seen_as_enemy {
|
||||
return false;
|
||||
}
|
||||
if !self.follow_unseen {
|
||||
@@ -1229,7 +1229,7 @@ pub fn target_continue(st: &mut TargetState, must_see: bool, m: &mut Mob, cx: &m
|
||||
let Some(t) = cx.w.target_info(who) else {
|
||||
return false;
|
||||
};
|
||||
if !t.alive || t.is_player && t.creative {
|
||||
if !t.alive || !t.can_be_seen_as_enemy || t.is_player && t.creative {
|
||||
return false;
|
||||
}
|
||||
let follow = m.attrs.follow_range * st.follow_scale;
|
||||
@@ -1287,6 +1287,7 @@ impl Goal for NearestTarget {
|
||||
let candidates: Vec<(u32, Vec3)> =
|
||||
cx.w.nearby(pos, range, move |s| {
|
||||
s.id != id
|
||||
&& !s.playing_dead
|
||||
&& match prey {
|
||||
Prey::Species(list) => list.contains(&s.species),
|
||||
Prey::Filter(f) => f(s),
|
||||
@@ -1381,7 +1382,7 @@ impl Goal for HurtByTarget {
|
||||
let Some(t) = cx.w.target_info(by) else {
|
||||
return false;
|
||||
};
|
||||
t.alive && !(t.is_player && t.creative)
|
||||
t.alive && t.can_be_seen_as_enemy && !(t.is_player && t.creative)
|
||||
}
|
||||
fn can_continue(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
|
||||
target_continue(&mut self.st, true, m, cx)
|
||||
@@ -2060,7 +2061,12 @@ impl Goal for TryFindWater {
|
||||
!m.ai.nav.is_done()
|
||||
}
|
||||
fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
|
||||
m.nav_move_to(cx.w, self.wanted, 1.0);
|
||||
let speed = if m.species() == Species::Axolotl {
|
||||
0.15
|
||||
} else {
|
||||
1.0
|
||||
};
|
||||
m.nav_move_to(cx.w, self.wanted, speed);
|
||||
}
|
||||
}
|
||||
/// `MoveToBlockGoal`'s shared state: search, walk to and stay at a block.
|
||||
|
||||
@@ -364,7 +364,9 @@ fn can_attack(m: &Mob, w: &MobWorld, who: Who) -> bool {
|
||||
.is_some_and(|p| p.alive && !p.creative && !p.spectator),
|
||||
Who::Mob(id) => {
|
||||
let Some(s) = w.seen(id) else { return false };
|
||||
s.alive && (m.species() != Species::Breeze || s.species == Species::IronGolem)
|
||||
s.alive
|
||||
&& !s.playing_dead
|
||||
&& (m.species() != Species::Breeze || s.species == Species::IronGolem)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -15,6 +15,7 @@ pub struct TargetInfo {
|
||||
pub eye_y: f64,
|
||||
pub bounds: Aabb,
|
||||
pub alive: bool,
|
||||
pub can_be_seen_as_enemy: bool,
|
||||
pub is_player: bool,
|
||||
pub creative: bool,
|
||||
}
|
||||
@@ -200,6 +201,7 @@ impl MobWorld<'_> {
|
||||
eye_y: p.eye[1],
|
||||
bounds: p.bounds,
|
||||
alive: p.alive,
|
||||
can_be_seen_as_enemy: true,
|
||||
is_player: true,
|
||||
creative: p.creative,
|
||||
}),
|
||||
@@ -208,6 +210,7 @@ impl MobWorld<'_> {
|
||||
eye_y: s.eye_y,
|
||||
bounds: s.bounds,
|
||||
alive: s.alive,
|
||||
can_be_seen_as_enemy: !s.playing_dead,
|
||||
is_player: false,
|
||||
creative: false,
|
||||
}),
|
||||
|
||||
@@ -41,7 +41,10 @@ use std::{
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
pub(crate) mod environment;
|
||||
|
||||
pub struct MotionResources {
|
||||
pub facts: crate::blocks::BlockFacts,
|
||||
pub attributes: Arc<Catalog>,
|
||||
pub blocks: BoundMovementProperties,
|
||||
pub climbable: BTreeSet<String>,
|
||||
@@ -82,6 +85,7 @@ impl MotionResources {
|
||||
.collect())
|
||||
};
|
||||
Ok(Self {
|
||||
facts: crate::blocks::BlockFacts::load(root, assets.registry)?,
|
||||
landing: crate::landing::load(root, &properties)?,
|
||||
health: crate::health::HealthResources::load(root)?,
|
||||
attributes,
|
||||
@@ -128,6 +132,16 @@ pub enum MotionEvent {
|
||||
},
|
||||
}
|
||||
pub struct PlayerMotion {
|
||||
pub fluids: horizon_world::entity_fluid::EntityFluidInteraction,
|
||||
pub in_water: bool,
|
||||
pub eye_in_water: bool,
|
||||
pub in_lava: bool,
|
||||
pub swimming: bool,
|
||||
pub fire_ticks: i32,
|
||||
pub air: i32,
|
||||
pub respiration: i32,
|
||||
pub(crate) first_tick: bool,
|
||||
|
||||
pub position: Vec3,
|
||||
pub velocity: Vec3,
|
||||
pub ground: GroundState,
|
||||
@@ -257,6 +271,18 @@ impl PlayerMotion {
|
||||
local_crouching: false,
|
||||
pose: crate::pose::Pose::Standing,
|
||||
dimensions: crate::pose::Pose::Standing.dimensions(1.0),
|
||||
fluids: horizon_world::entity_fluid::EntityFluidInteraction::new([
|
||||
environment::WATER,
|
||||
environment::LAVA,
|
||||
]),
|
||||
in_water: false,
|
||||
eye_in_water: false,
|
||||
in_lava: false,
|
||||
swimming: false,
|
||||
fire_ticks: 0,
|
||||
air: 300,
|
||||
respiration: 0,
|
||||
first_tick: true,
|
||||
speed: 0.0,
|
||||
item_use_speed: None,
|
||||
last_climbable: None,
|
||||
@@ -358,6 +384,9 @@ impl PlayerMotion {
|
||||
horizontal_collision: self.collision.horizontal,
|
||||
minor_horizontal_collision: self.collision.minor,
|
||||
moving_slowly: self.moving_slowly(),
|
||||
in_water: self.in_water,
|
||||
under_water: self.eye_in_water,
|
||||
swimming: self.swimming,
|
||||
..Default::default()
|
||||
};
|
||||
// The sprint setter edits attributes and flags, independent of local
|
||||
@@ -506,14 +535,20 @@ impl MotionWorld<'_, '_, '_> {
|
||||
}
|
||||
let toggled = flying_before != self.player.flying;
|
||||
// Player.tryToStartFallFlying (canGlide: airborne, not flying, a glider).
|
||||
let can_glide = self.player.glider && !self.player.ground.on_ground && !self.player.flying;
|
||||
let can_glide = self.player.glider
|
||||
&& !self.player.ground.on_ground
|
||||
&& !self.player.flying
|
||||
&& !self.player.in_water;
|
||||
if jumping && !toggled && !was_jumping && !self.player.fall_flying && can_glide {
|
||||
self.player.fall_flying = true;
|
||||
}
|
||||
// LivingEntity.tick fallFlyTicks, then updateFallFlying.
|
||||
if self.player.fall_flying {
|
||||
self.player.fall_fly_ticks += 1;
|
||||
let still = self.player.glider && !self.player.ground.on_ground && !self.player.flying;
|
||||
let still = self.player.glider
|
||||
&& !self.player.ground.on_ground
|
||||
&& !self.player.flying
|
||||
&& !self.player.in_water;
|
||||
if !still {
|
||||
self.player.fall_flying = false;
|
||||
} else if (self.player.fall_fly_ticks + 1) % 10 == 0
|
||||
@@ -553,8 +588,16 @@ impl MotionWorld<'_, '_, '_> {
|
||||
/// services are still incomplete; this composes clocks, movement and hunger.
|
||||
pub fn simulation_tick(&mut self, direction: [f32; 2], jumping: bool) -> Result<()> {
|
||||
self.player.health.advance_clock();
|
||||
self.update_fluid_environment()?;
|
||||
self.tick_environment_damage()?;
|
||||
let previous = self.player.position;
|
||||
self.player.swimming = self.player.sprinting
|
||||
&& self.player.in_water
|
||||
&& (self.player.swimming || self.player.eye_in_water)
|
||||
&& !self.player.flying
|
||||
&& !self.player.spectator;
|
||||
self.player_movement_tick(direction, jumping)?;
|
||||
self.apply_fire_contact()?;
|
||||
self.player.refresh_attributes()?;
|
||||
self.update_player_pose()?;
|
||||
// The resident scene accepts the resolved local movement directly.
|
||||
@@ -573,6 +616,7 @@ impl MotionWorld<'_, '_, '_> {
|
||||
self.player.auto_jump_time -= 1;
|
||||
keys.jump = true;
|
||||
}
|
||||
self.sample_fluid_environment(false)?;
|
||||
self.player.sprint_input_tick(keys)?;
|
||||
self.player.shift_key_down = keys.shift;
|
||||
let direction = keys.direction();
|
||||
@@ -621,8 +665,27 @@ impl MotionWorld<'_, '_, '_> {
|
||||
input.x = 0.0;
|
||||
input.z = 0.0;
|
||||
}
|
||||
if self.player.shift_key_down
|
||||
&& !self.player.flying
|
||||
&& (self.player.in_water || self.player.in_lava)
|
||||
{
|
||||
self.player.velocity.y -= 0.04;
|
||||
}
|
||||
if self.player.jumping {
|
||||
if self.player.ground.on_ground && self.player.no_jump_delay == 0 {
|
||||
let height = self.player.fluids.fluid_height(
|
||||
self,
|
||||
if self.player.in_water {
|
||||
environment::WATER
|
||||
} else {
|
||||
environment::LAVA
|
||||
},
|
||||
);
|
||||
if !self.player.flying
|
||||
&& (self.player.in_water || self.player.in_lava)
|
||||
&& (!self.player.ground.on_ground || height > 0.4)
|
||||
{
|
||||
self.player.velocity.y += 0.04;
|
||||
} else if self.player.ground.on_ground && self.player.no_jump_delay == 0 {
|
||||
self.jump_from_ground()?;
|
||||
self.player.no_jump_delay = 10;
|
||||
}
|
||||
@@ -636,6 +699,8 @@ impl MotionWorld<'_, '_, '_> {
|
||||
let y = self.player.velocity.y;
|
||||
self.travel_in_air(input)?;
|
||||
self.player.velocity.y = y * 0.6;
|
||||
} else if !self.player.flying && (self.player.in_water || self.player.in_lava) {
|
||||
horizon_world::living_fluid::travel_in_fluid(self, input)?;
|
||||
} else {
|
||||
self.travel_in_air(input)?;
|
||||
}
|
||||
@@ -771,13 +836,13 @@ impl MovementStatisticsWorld for MotionWorld<'_, '_, '_> {
|
||||
Ok(false)
|
||||
}
|
||||
fn swimming(&mut self) -> Result<bool> {
|
||||
Ok(false)
|
||||
Ok(self.player.swimming)
|
||||
}
|
||||
fn eyes_in_water(&mut self) -> Result<bool> {
|
||||
Ok(false)
|
||||
Ok(self.player.eye_in_water)
|
||||
}
|
||||
fn in_water(&mut self) -> Result<bool> {
|
||||
Ok(false)
|
||||
Ok(self.player.in_water)
|
||||
}
|
||||
fn on_climbable(&mut self) -> Result<bool> {
|
||||
self.climbable()
|
||||
@@ -900,7 +965,7 @@ impl EntityMoveWorld for MotionWorld<'_, '_, '_> {
|
||||
self.player.fall_distance
|
||||
}
|
||||
fn fall_reset_clip(&mut self, from: Vec3, to: Vec3) -> Result<bool> {
|
||||
// Every fluid in this controlled scene is empty. Tagged reset blocks use
|
||||
// Fluid immersion is handled before travel. Tagged reset blocks use
|
||||
// a full block in ClipContext.FALLDAMAGE_RESETTING, not their collider.
|
||||
let hit = traverse_blocks(from, to, 1_000_000, |p| {
|
||||
let name = &self.assets.registry.state(self.block(p)).unwrap().name;
|
||||
@@ -1086,10 +1151,10 @@ impl MovementEmissionWorld for MotionWorld<'_, '_, '_> {
|
||||
Ok(false)
|
||||
}
|
||||
fn swimming(&mut self) -> Result<bool> {
|
||||
Ok(false)
|
||||
Ok(self.player.swimming)
|
||||
}
|
||||
fn in_water(&mut self) -> Result<bool> {
|
||||
Ok(false)
|
||||
Ok(self.player.in_water)
|
||||
}
|
||||
fn walking_step_sound(&mut self, position: BlockPos, state: BlockStateId) -> Result<()> {
|
||||
self.player
|
||||
@@ -1367,6 +1432,144 @@ mod tests {
|
||||
/// Footsteps on the prepared vanilla resources, when they are present:
|
||||
/// none while standing (gravity still moves the player every tick), one
|
||||
/// per `nextStep` metre while walking.
|
||||
#[test]
|
||||
fn resident_water_and_lava_are_not_treated_as_air() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
|
||||
if !root.join("movement-properties.nbt").exists() {
|
||||
return;
|
||||
}
|
||||
let assets = Assets::load(&root).unwrap();
|
||||
let binding = crate::collisions::load(&root, assets.registry).unwrap();
|
||||
let resources = MotionResources::load(&root, &assets).unwrap();
|
||||
let mut scene = World::test_scene(&assets, 3).unwrap();
|
||||
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
|
||||
let water = assets.registry.default_state("minecraft:water").unwrap();
|
||||
for x in 19..=21 {
|
||||
for y in 3..=7 {
|
||||
for z in 19..=21 {
|
||||
scene.set(x, y, z, water).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut w = MotionWorld {
|
||||
player: &mut player,
|
||||
scene: &mut scene,
|
||||
assets: &assets,
|
||||
collision_binding: &binding,
|
||||
resources: &resources,
|
||||
};
|
||||
w.controlled_simulation_tick(Default::default()).unwrap();
|
||||
assert!(
|
||||
MovementStatisticsWorld::in_water(&mut w).unwrap(),
|
||||
"resident water must reach the player movement adapter"
|
||||
);
|
||||
assert!(MovementStatisticsWorld::eyes_in_water(&mut w).unwrap());
|
||||
assert!(
|
||||
(w.player.velocity.y + 0.005).abs() < 1e-5,
|
||||
"water drag/gravity must replace air travel: {:?}",
|
||||
w.player.velocity
|
||||
);
|
||||
let lava = assets.registry.default_state("minecraft:lava").unwrap();
|
||||
for x in 19..=21 {
|
||||
for y in 3..=7 {
|
||||
for z in 19..=21 {
|
||||
w.scene.set(x, y, z, lava).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
w.controlled_simulation_tick(Default::default()).unwrap();
|
||||
assert!(
|
||||
w.player.health.health() < 20.0,
|
||||
"lava must damage a survival player"
|
||||
);
|
||||
// Water extinguishes, swimming is a real pose, and deep water consumes air.
|
||||
for x in 19..=21 {
|
||||
for y in 3..=7 {
|
||||
for z in 19..=21 {
|
||||
w.scene.set(x, y, z, water).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
w.player.fire_ticks = 160;
|
||||
w.controlled_simulation_tick(Default::default()).unwrap();
|
||||
assert_eq!(w.player.fire_ticks, 0);
|
||||
w.player.air = -19;
|
||||
w.player.health.hurt.cooldown = 0;
|
||||
let hp = w.player.health.health();
|
||||
w.controlled_simulation_tick(Default::default()).unwrap();
|
||||
assert_eq!(w.player.air, 0);
|
||||
assert!(w.player.health.health() < hp, "drowning must hurt");
|
||||
w.player.invulnerable = true;
|
||||
let hp = w.player.health.health();
|
||||
w.player.air = -19;
|
||||
w.controlled_simulation_tick(Default::default()).unwrap();
|
||||
assert_eq!(w.player.health.health(), hp);
|
||||
w.player.invulnerable = false;
|
||||
w.player.air = 300;
|
||||
w.controlled_simulation_tick(crate::sprint::Keys {
|
||||
forward: true,
|
||||
sprint: true,
|
||||
..Default::default()
|
||||
})
|
||||
.unwrap();
|
||||
assert!(w.player.swimming);
|
||||
assert_eq!(w.player.pose, crate::pose::Pose::Swimming);
|
||||
// Direct fire contact ignites; resistance prevents damage but does not hide flames.
|
||||
let fire = assets.registry.default_state("minecraft:fire").unwrap();
|
||||
for x in 19..=21 {
|
||||
for y in 3..=7 {
|
||||
for z in 19..=21 {
|
||||
w.scene.set(x, y, z, fire).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
w.player.position = Vec3::new(20.5, 4.0, 20.5);
|
||||
w.player.velocity = Vec3::ZERO;
|
||||
w.player.health.hurt.cooldown = 0;
|
||||
let hp = w.player.health.health();
|
||||
w.controlled_simulation_tick(Default::default()).unwrap();
|
||||
assert!(w.player.fire_ticks > 0);
|
||||
assert!(w.player.health.health() < hp);
|
||||
w.player.status.fire_resistance = true;
|
||||
w.player.health.hurt.cooldown = 0;
|
||||
let hp = w.player.health.health();
|
||||
w.controlled_simulation_tick(Default::default()).unwrap();
|
||||
assert_eq!(w.player.health.health(), hp);
|
||||
// Sprint swimming must keep full input, not the dry crawl/sneak multiplier.
|
||||
for x in 19..=21 {
|
||||
for y in 2..=7 {
|
||||
for z in 19..=30 {
|
||||
w.scene.set(x, y, z, water).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
w.player.position = Vec3::new(20.5, 4.0, 20.5);
|
||||
w.player.velocity = Vec3::ZERO;
|
||||
w.player.local_crouching = false;
|
||||
w.player.swimming = true;
|
||||
w.player.sprinting = true;
|
||||
w.player.set_pose(crate::pose::Pose::Swimming).unwrap();
|
||||
for _ in 0..30 {
|
||||
w.controlled_simulation_tick(crate::sprint::Keys {
|
||||
forward: true,
|
||||
sprint: true,
|
||||
..Default::default()
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
assert!(
|
||||
w.player.velocity.z > 0.165,
|
||||
"native sprint swim speed must not receive crawl slowdown: {:?}",
|
||||
w.player.velocity
|
||||
);
|
||||
assert!(!w.player.moving_slowly());
|
||||
w.player.in_water = false;
|
||||
assert!(
|
||||
w.player.moving_slowly(),
|
||||
"dry crawling must still slow input"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn footsteps_follow_the_walked_distance_not_the_tick() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
|
||||
|
||||
@@ -0,0 +1,320 @@
|
||||
//! Resident bindings for the existing native immersion, current and liquid-travel kernels.
|
||||
use super::*;
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use horizon_world::{
|
||||
entity_fluid::{
|
||||
CurrentTarget, FluidInteractionWorld, FluidMembership, FluidSections, FluidTagId,
|
||||
},
|
||||
fluid::{FluidHeightWorld, FluidKind, FluidState},
|
||||
fluid_flow::{FluidFlowWorld, flow_at},
|
||||
living_fluid::{LivingFluidWorld, TravelFluidTag},
|
||||
};
|
||||
pub(super) const WATER: FluidTagId = FluidTagId(0);
|
||||
pub(super) const LAVA: FluidTagId = FluidTagId(1);
|
||||
impl MotionWorld<'_, '_, '_> {
|
||||
fn fluid_at(&self, p: BlockPos) -> Result<FluidState> {
|
||||
Ok(FluidState::from_block(
|
||||
self.assets
|
||||
.registry
|
||||
.state(self.block(p))
|
||||
.ok_or("missing fluid state")?,
|
||||
)?)
|
||||
}
|
||||
pub(super) fn update_fluid_environment(&mut self) -> Result<()> {
|
||||
self.sample_fluid_environment(true)
|
||||
}
|
||||
pub(super) fn sample_fluid_environment(&mut self, push: bool) -> Result<()> {
|
||||
let mut fluids = std::mem::take(&mut self.player.fluids);
|
||||
let result = fluids
|
||||
.update(self, false, 4096)
|
||||
.map_err(|e| io::Error::other(e.to_string()));
|
||||
if let Err(e) = result {
|
||||
self.player.fluids = fluids;
|
||||
return Err(e.into());
|
||||
}
|
||||
self.player.in_water = fluids.is_in_fluid(self, WATER);
|
||||
self.player.in_lava = fluids.is_in_fluid(self, LAVA);
|
||||
self.player.eye_in_water = fluids.is_eye_in_fluid(self, WATER);
|
||||
if self.player.in_water {
|
||||
self.player.fall_distance = 0.0;
|
||||
}
|
||||
if push && !self.player.flying && !self.player.spectator {
|
||||
fluids.apply_current(self, WATER, 0.014)?;
|
||||
fluids.apply_current(
|
||||
self,
|
||||
LAVA,
|
||||
if self.scene.fast_lava {
|
||||
0.007
|
||||
} else {
|
||||
0.0023333333333333335
|
||||
},
|
||||
)?;
|
||||
}
|
||||
self.player.fluids = fluids;
|
||||
self.player.first_tick = false;
|
||||
Ok(())
|
||||
}
|
||||
fn environment_hurt(&mut self, source: &str, damage: f32) -> Result<()> {
|
||||
if self.player.invulnerable || self.player.spectator {
|
||||
return Ok(());
|
||||
}
|
||||
let id = self
|
||||
.resources
|
||||
.health
|
||||
.damage
|
||||
.id(source)
|
||||
.ok_or("missing environment damage type")?;
|
||||
self.player
|
||||
.hurt(&self.resources.health, self.scene.health_rules, id, damage)?;
|
||||
Ok(())
|
||||
}
|
||||
pub(super) fn tick_environment_damage(&mut self) -> Result<()> {
|
||||
if self.player.in_water || self.player.invulnerable || self.player.spectator {
|
||||
self.player.fire_ticks = 0;
|
||||
}
|
||||
if self.player.fire_ticks > 0 {
|
||||
if self.player.fire_ticks % 20 == 0 && !self.player.in_lava {
|
||||
self.environment_hurt("minecraft:on_fire", 1.0)?;
|
||||
}
|
||||
self.player.fire_ticks -= 1;
|
||||
}
|
||||
if self.player.eye_in_water
|
||||
&& !self.player.status.water_breathing
|
||||
&& !self.player.invulnerable
|
||||
&& !self.player.spectator
|
||||
{
|
||||
let oxygen = self
|
||||
.player
|
||||
.attribute("minecraft:oxygen_bonus")?
|
||||
.max(f64::from(self.player.respiration));
|
||||
if oxygen <= 0.0 || self.scene.random.next_double() < 1.0 / (oxygen + 1.0) {
|
||||
self.player.air -= 1;
|
||||
}
|
||||
if self.player.air <= -20 {
|
||||
self.player.air = 0;
|
||||
self.environment_hurt("minecraft:drown", 2.0)?;
|
||||
}
|
||||
} else {
|
||||
self.player.air = (self.player.air + 4).min(300);
|
||||
}
|
||||
if self.player.in_lava {
|
||||
self.player.fire_ticks = self.player.fire_ticks.max(300);
|
||||
self.environment_hurt("minecraft:lava", 4.0)?;
|
||||
self.player.fall_distance *= 0.5;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub(super) fn apply_fire_contact(&mut self) -> Result<()> {
|
||||
if self.player.spectator || self.player.invulnerable {
|
||||
self.player.fire_ticks = 0;
|
||||
return Ok(());
|
||||
}
|
||||
let damage = fire_contact(self.scene, self.assets.registry, self.player.bounds());
|
||||
if damage > 0.0 {
|
||||
if !self.player.in_water {
|
||||
self.player.fire_ticks =
|
||||
ignite_contact(self.player.fire_ticks, true, &mut self.scene.random);
|
||||
}
|
||||
self.environment_hurt("minecraft:in_fire", damage)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
pub(crate) fn fire_contact(
|
||||
world: &World,
|
||||
registry: &horizon_world::registry::BlockRegistry,
|
||||
bounds: Aabb,
|
||||
) -> f32 {
|
||||
let b = bounds.deflate(Vec3::new(1e-5, 1e-5, 1e-5));
|
||||
let mut damage = 0.0f32;
|
||||
for x in b.min_position().x.floor() as i32..=b.max_position().x.floor() as i32 {
|
||||
for y in b.min_position().y.floor() as i32..=b.max_position().y.floor() as i32 {
|
||||
for z in b.min_position().z.floor() as i32..=b.max_position().z.floor() as i32 {
|
||||
damage = damage.max(
|
||||
match registry
|
||||
.state(world.block(x, y, z))
|
||||
.map(|s| s.name.as_str())
|
||||
{
|
||||
Some("minecraft:fire") => 1.0,
|
||||
Some("minecraft:soul_fire") => 2.0,
|
||||
_ => 0.0,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
damage
|
||||
}
|
||||
impl FluidMembership for MotionWorld<'_, '_, '_> {
|
||||
fn fluid_in_tag(&self, kind: FluidKind, tag: FluidTagId) -> bool {
|
||||
if tag == WATER {
|
||||
matches!(kind, FluidKind::Water | FluidKind::FlowingWater)
|
||||
} else {
|
||||
matches!(kind, FluidKind::Lava | FluidKind::FlowingLava)
|
||||
}
|
||||
}
|
||||
}
|
||||
impl CurrentTarget for MotionWorld<'_, '_, '_> {
|
||||
type Error = Box<dyn std::error::Error>;
|
||||
fn is_player_class(&self) -> bool {
|
||||
true
|
||||
}
|
||||
fn velocity(&mut self) -> Result<Vec3> {
|
||||
Ok(self.player.velocity)
|
||||
}
|
||||
fn add_delta_movement(&mut self, v: Vec3) -> Result<()> {
|
||||
let old = self.player.velocity;
|
||||
self.player.velocity = Vec3::new(old.x + v.x, old.y + v.y, old.z + v.z);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
impl FluidInteractionWorld for MotionWorld<'_, '_, '_> {
|
||||
type Error = Box<dyn std::error::Error>;
|
||||
type Chunk = (i32, i32);
|
||||
fn interaction_box(&mut self) -> Result<Option<Aabb>> {
|
||||
Ok(Some(
|
||||
self.player.bounds().deflate(Vec3::new(1e-5, 1e-5, 1e-5)),
|
||||
))
|
||||
}
|
||||
fn loaded_chunk(&mut self, x: i32, z: i32) -> Result<Option<Self::Chunk>> {
|
||||
Ok(self.scene.chunks.contains_key(&(x, z)).then_some((x, z)))
|
||||
}
|
||||
fn chunk_sections(&mut self, _: Self::Chunk) -> Result<FluidSections<'_>> {
|
||||
// Resident sections have no fluid-count cache; scan the small interaction box rather than skipping sections.
|
||||
static SECTIONS: [bool; crate::chunk::SECTIONS] = [true; crate::chunk::SECTIONS];
|
||||
Ok(FluidSections {
|
||||
minimum_section_y: crate::chunk::MIN_Y >> 4,
|
||||
has_fluid: &SECTIONS,
|
||||
})
|
||||
}
|
||||
fn bounding_box_min_y(&self) -> f64 {
|
||||
self.player.bounds().min_position().y
|
||||
}
|
||||
fn block_x(&self) -> i32 {
|
||||
self.player.position.x.floor() as i32
|
||||
}
|
||||
fn block_z(&self) -> i32 {
|
||||
self.player.position.z.floor() as i32
|
||||
}
|
||||
fn eye_y(&mut self) -> Result<f64> {
|
||||
Ok(self.player.position.y + f64::from(self.player.dimensions.eye_height))
|
||||
}
|
||||
fn fluid_state(&mut self, p: BlockPos) -> Result<FluidState> {
|
||||
self.fluid_at(p)
|
||||
}
|
||||
fn fluid_height(&mut self, f: FluidState, p: BlockPos) -> Result<f32> {
|
||||
f.height_at(self, [p.x, p.y, p.z])
|
||||
}
|
||||
fn camera_height(&mut self, f: FluidState, p: BlockPos) -> Result<f32> {
|
||||
f.camera_height_at(self, [p.x, p.y, p.z])
|
||||
}
|
||||
fn flow(&mut self, f: FluidState, p: BlockPos) -> Result<Vec3> {
|
||||
flow_at(self, f, p)
|
||||
}
|
||||
}
|
||||
impl FluidHeightWorld for MotionWorld<'_, '_, '_> {
|
||||
type Error = Box<dyn std::error::Error>;
|
||||
fn fluid(&mut self, p: [i32; 3]) -> Result<FluidState> {
|
||||
self.fluid_at(BlockPos::new(p[0], p[1], p[2]))
|
||||
}
|
||||
fn sturdy_down(&mut self, p: [i32; 3]) -> Result<bool> {
|
||||
Ok(self
|
||||
.resources
|
||||
.facts
|
||||
.get(MotionWorld::block(self, BlockPos::new(p[0], p[1], p[2])))
|
||||
.sturdy_full
|
||||
& 1
|
||||
!= 0)
|
||||
}
|
||||
}
|
||||
impl FluidFlowWorld for MotionWorld<'_, '_, '_> {
|
||||
type Error = Box<dyn std::error::Error>;
|
||||
type Block = BlockStateId;
|
||||
fn fluid(&mut self, p: BlockPos) -> Result<FluidState> {
|
||||
self.fluid_at(p)
|
||||
}
|
||||
fn block(&mut self, p: BlockPos) -> Result<BlockStateId> {
|
||||
Ok(MotionWorld::block(self, p))
|
||||
}
|
||||
fn blocks_fluid_flow(&self, s: BlockStateId) -> bool {
|
||||
self.assets
|
||||
.blocks_fluid_flow
|
||||
.contains(&self.assets.registry.state(s).unwrap().name)
|
||||
}
|
||||
fn is_ice_class(&self, s: BlockStateId) -> bool {
|
||||
self.resources
|
||||
.facts
|
||||
.get(s)
|
||||
.classes
|
||||
.iter()
|
||||
.any(|c| c.as_ref() == "IceBlock")
|
||||
}
|
||||
fn is_face_sturdy(&mut self, s: BlockStateId, _: BlockPos, d: Direction) -> Result<bool> {
|
||||
Ok(self.resources.facts.get(s).sturdy_full & (1 << d as u8) != 0)
|
||||
}
|
||||
}
|
||||
impl LivingFluidWorld for MotionWorld<'_, '_, '_> {
|
||||
fn in_water(&mut self) -> Result<bool> {
|
||||
Ok(self.player.in_water)
|
||||
}
|
||||
fn sprinting(&mut self) -> Result<bool> {
|
||||
Ok(self.player.sprinting)
|
||||
}
|
||||
fn water_slow_down(&mut self) -> Result<f32> {
|
||||
Ok(0.8)
|
||||
}
|
||||
fn water_movement_efficiency(&mut self) -> Result<f64> {
|
||||
self.player.attribute("minecraft:water_movement_efficiency")
|
||||
}
|
||||
fn dolphins_grace(&mut self) -> Result<bool> {
|
||||
Ok(self.player.status.dolphins_grace)
|
||||
}
|
||||
fn fluid_height(&mut self, tag: TravelFluidTag) -> Result<f64> {
|
||||
Ok(self.player.fluids.fluid_height(
|
||||
self,
|
||||
if tag == TravelFluidTag::Lava {
|
||||
LAVA
|
||||
} else {
|
||||
WATER
|
||||
},
|
||||
))
|
||||
}
|
||||
fn fluid_jump_threshold(&mut self) -> Result<f64> {
|
||||
Ok(0.4)
|
||||
}
|
||||
fn is_free(&mut self, v: Vec3) -> Result<bool> {
|
||||
let b = self.player.bounds().move_by(v);
|
||||
Ok(self.no_player_collision(b)? && !self.has_liquid(b)?)
|
||||
}
|
||||
fn is_vehicle(&mut self) -> Result<bool> {
|
||||
Ok(false)
|
||||
}
|
||||
fn can_float_while_ridden(&mut self) -> Result<bool> {
|
||||
Ok(false)
|
||||
}
|
||||
}
|
||||
impl MotionWorld<'_, '_, '_> {
|
||||
fn has_liquid(&self, b: Aabb) -> Result<bool> {
|
||||
for x in b.min_position().x.floor() as i32..=b.max_position().x.floor() as i32 {
|
||||
for y in b.min_position().y.floor() as i32..=b.max_position().y.floor() as i32 {
|
||||
for z in b.min_position().z.floor() as i32..=b.max_position().z.floor() as i32 {
|
||||
if self.fluid_at(BlockPos::new(x, y, z))?.kind() != FluidKind::Empty {
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn ignite_contact(ticks: i32, player: bool, random: &mut impl RandomSource) -> i32 {
|
||||
let ticks = if ticks < 0 {
|
||||
ticks + 1
|
||||
} else if player {
|
||||
ticks + 1 + random.next_int_bound(2).unwrap_or(0)
|
||||
} else {
|
||||
ticks
|
||||
};
|
||||
if ticks >= 0 { ticks.max(160) } else { ticks }
|
||||
}
|
||||
@@ -72,7 +72,7 @@ impl PlayerMotion {
|
||||
Ok(())
|
||||
}
|
||||
pub fn moving_slowly(&self) -> bool {
|
||||
self.local_crouching || self.pose == Pose::Swimming // dry scene: not in water
|
||||
self.local_crouching || (self.pose == Pose::Swimming && !self.in_water)
|
||||
}
|
||||
}
|
||||
impl MotionWorld<'_, '_, '_> {
|
||||
@@ -87,6 +87,7 @@ impl MotionWorld<'_, '_, '_> {
|
||||
/// the old shift input. This is distinct from Entity's current pose.
|
||||
pub fn update_local_crouching(&mut self) -> Result<()> {
|
||||
self.player.local_crouching = !self.player.flying
|
||||
&& !self.player.swimming
|
||||
&& self.can_fit_pose(Pose::Crouching)?
|
||||
&& (self.player.shift_key_down || !self.can_fit_pose(Pose::Standing)?);
|
||||
Ok(())
|
||||
@@ -99,6 +100,8 @@ impl MotionWorld<'_, '_, '_> {
|
||||
}
|
||||
let desired = if self.player.fall_flying {
|
||||
Pose::FallFlying
|
||||
} else if self.player.swimming {
|
||||
Pose::Swimming
|
||||
} else if self.player.shift_key_down && !self.player.flying {
|
||||
Pose::Crouching
|
||||
} else {
|
||||
|
||||
@@ -19,6 +19,18 @@ impl SpriteAnimation {
|
||||
pub fn frame(&self, tick: u64) -> usize {
|
||||
self.clip.sample(tick).frame as usize
|
||||
}
|
||||
pub fn resized_pixels(&self, frame: usize, width: u32, height: u32) -> Vec<u8> {
|
||||
let source = self.pixels(frame);
|
||||
let mut out = Vec::with_capacity((width * height * 4) as usize);
|
||||
for y in 0..height {
|
||||
for x in 0..width {
|
||||
let offset = ((y * SPRITE_SIZE / height * SPRITE_SIZE + x * SPRITE_SIZE / width)
|
||||
* 4) as usize;
|
||||
out.extend_from_slice(&source[offset..offset + 4]);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
pub fn pixels(&self, frame: usize) -> &[u8] {
|
||||
&self.frames[frame]
|
||||
}
|
||||
@@ -142,6 +154,40 @@ impl Sprites {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn native_fire_sprites_register_full_animation_sequences() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
|
||||
if !root
|
||||
.join("assets/minecraft/textures/block/fire_0.png")
|
||||
.exists()
|
||||
{
|
||||
return;
|
||||
}
|
||||
let mut sprites = Sprites::default();
|
||||
for name in ["fire_0", "fire_1", "soul_fire_0", "soul_fire_1"] {
|
||||
let layer = sprites
|
||||
.insert(&root, &format!("minecraft:block/{name}"))
|
||||
.unwrap();
|
||||
let animation = sprites
|
||||
.animations
|
||||
.iter()
|
||||
.find(|a| a.layer == layer)
|
||||
.expect("fire must be animated");
|
||||
assert_ne!(
|
||||
animation.pixels(animation.frame(0)),
|
||||
animation.pixels(animation.frame(1))
|
||||
);
|
||||
assert_ne!(
|
||||
animation.resized_pixels(animation.frame(0), 16, 16),
|
||||
animation.resized_pixels(animation.frame(1), 16, 16)
|
||||
);
|
||||
assert_eq!(
|
||||
animation.pixels(animation.frame(0)).len(),
|
||||
(SPRITE_SIZE * SPRITE_SIZE * 4) as usize
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_32_pixel_animation_frames_keep_every_texel() {
|
||||
let root = std::env::temp_dir().join(format!(
|
||||
|
||||
@@ -9,6 +9,7 @@ use std::{
|
||||
};
|
||||
|
||||
pub struct World {
|
||||
pub fast_lava: bool,
|
||||
pub chunks: crate::fast_hash::FxHashMap<(i32, i32), Arc<Chunk>>,
|
||||
pub random: LegacyRandom,
|
||||
pub revision: u64,
|
||||
@@ -113,6 +114,7 @@ impl World {
|
||||
revision: 0,
|
||||
health_rules: crate::health::HealthRules::default(),
|
||||
air,
|
||||
fast_lava: false,
|
||||
dirty_sections: Default::default(),
|
||||
dirty_light: Default::default(),
|
||||
light_edits: Vec::new(),
|
||||
|
||||
@@ -424,7 +424,12 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
|
||||
if !creative && data.is(Class::Tnt) && b.table.bool(state, p.unstable) {
|
||||
self.prime_tnt(pos);
|
||||
}
|
||||
self.level_event(2001, pos, state.0 as i32);
|
||||
// BaseFireBlock emits extinguish and suppresses generic destroy particles/sound.
|
||||
if data.is(Class::BaseFire) {
|
||||
self.level_event(1009, pos, 0);
|
||||
} else {
|
||||
self.level_event(2001, pos, state.0 as i32);
|
||||
}
|
||||
self.game_event(pos, "minecraft:block_destroy");
|
||||
self.remove_block(pos, false)
|
||||
}
|
||||
|
||||
@@ -1192,3 +1192,38 @@ fn creaking_heart_follows_its_logs_and_the_night() {
|
||||
}
|
||||
assert_eq!(w.prop(heart_at, "creaking_heart_state"), "uprooted");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn player_breaks_fire_with_extinguish_not_generic_break_event() {
|
||||
for name in ["fire", "soul_fire", "white_wool"] {
|
||||
let mut w = world!();
|
||||
let pos = BlockPos::new(0, 1, 0);
|
||||
let support = w.id("soul_soil", &[]);
|
||||
w.put(BlockPos::new(0, 0, 0), support);
|
||||
let state = w.id(name, &[]);
|
||||
w.put(pos, state);
|
||||
w.level.events.clear();
|
||||
assert!(
|
||||
w.f.behaviours
|
||||
.player_destroy_block(&mut w.level, &mut w.ticks, pos, false)
|
||||
);
|
||||
let is_fire = name != "white_wool";
|
||||
assert_eq!(
|
||||
w.level
|
||||
.events
|
||||
.iter()
|
||||
.any(|e| matches!(e,LevelEvent::LevelEvent {id:1009,pos:p,..} if *p==pos)),
|
||||
is_fire,
|
||||
"extinguish for {name}"
|
||||
);
|
||||
assert_eq!(
|
||||
w.level
|
||||
.events
|
||||
.iter()
|
||||
.any(|e| matches!(e,LevelEvent::LevelEvent {id:2001,pos:p,..} if *p==pos)),
|
||||
!is_fire,
|
||||
"generic break for {name}"
|
||||
);
|
||||
assert_eq!(w.get(pos), w.b().air());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
"""Exercise the actual animation uploader with a recording queue, without a GPU/window."""
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from test_item_action_animation import block
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
class SpriteAnimationUploadTests(unittest.TestCase):
|
||||
@unittest.skipUnless(shutil.which("rustc"), "rustc is required")
|
||||
def test_animation_updates_entire_layer_and_every_mip(self):
|
||||
source = (ROOT / "crates/horizon-client/src/gfx.rs").read_text()
|
||||
animate = block(source, source.index("fn animate(&mut self, tick: u64)"))
|
||||
mips = block(source, source.index("fn mip_chain("))
|
||||
program = r"""
|
||||
use std::cell::RefCell;
|
||||
mod wgpu {
|
||||
pub struct Texture(pub u32);
|
||||
impl Texture {pub fn width(&self)->u32 {self.0}}
|
||||
pub struct Origin3d {pub x:u32,pub y:u32,pub z:u32}
|
||||
pub enum TextureAspect {All}
|
||||
pub struct TexelCopyTextureInfo<LIFETIME> {
|
||||
pub texture:&LIFETIME Texture,pub mip_level:u32,pub origin:Origin3d,pub aspect:TextureAspect,
|
||||
}
|
||||
pub struct TexelCopyBufferLayout {pub offset:u64,pub bytes_per_row:Option<u32>,pub rows_per_image:Option<u32>}
|
||||
pub struct Extent3d {pub width:u32,pub height:u32,pub depth_or_array_layers:u32}
|
||||
}
|
||||
struct Queue {writes:RefCell<Vec<Vec<u8>>>}
|
||||
impl Queue {
|
||||
fn write_texture(&self, info:wgpu::TexelCopyTextureInfo, pixels:&[u8], layout:wgpu::TexelCopyBufferLayout, extent:wgpu::Extent3d) {
|
||||
let size=info.texture.width() >> info.mip_level;
|
||||
assert_eq!((extent.width,extent.height,extent.depth_or_array_layers),(size,size,1),"animation must update the entire mip, not a quarter");
|
||||
assert_eq!((layout.bytes_per_row,layout.rows_per_image,layout.offset),(Some(size*4),Some(size),0));
|
||||
assert_eq!((info.origin.x,info.origin.y,info.origin.z),(0,0,7));
|
||||
assert_eq!(pixels.len(),(size*size*4) as usize);
|
||||
self.writes.borrow_mut().push(pixels.to_vec());
|
||||
}
|
||||
}
|
||||
struct Animation {layer:u32,pixels:Vec<u8>}
|
||||
impl Animation {fn frame(&self,tick:u64)->usize {if tick==0 {0} else {1}} fn pixels(&self,_:usize)->&[u8] {&self.pixels}}
|
||||
struct Gfx {animations:Vec<(Animation,usize)>,mip_levels:u32,sprite_texture:wgpu::Texture,queue:Queue}
|
||||
MIPS
|
||||
impl Gfx {ANIMATE}
|
||||
fn main() {
|
||||
for size in [16u32,32] {
|
||||
let pixels:Vec<u8>=(0..size*size).flat_map(|i|[(i%size) as u8,(i/size) as u8,99,255]).collect();
|
||||
let (expected,levels)=mip_chain(&pixels,size,1);
|
||||
let mut gfx=Gfx {animations:vec![(Animation {layer:7,pixels:pixels.clone()},0)],mip_levels:levels,sprite_texture:wgpu::Texture(size),queue:Queue {writes:RefCell::default()}};
|
||||
gfx.animate(0);assert!(gfx.queue.writes.borrow().is_empty());
|
||||
gfx.animate(1);
|
||||
assert_eq!(gfx.queue.writes.borrow().len(),levels as usize);
|
||||
assert_eq!(gfx.queue.writes.borrow()[0],pixels,"the bottom-right texel must animate too");
|
||||
assert_eq!(gfx.queue.writes.borrow().concat(),expected);
|
||||
gfx.animate(1);assert_eq!(gfx.queue.writes.borrow().len(),levels as usize);
|
||||
}
|
||||
}
|
||||
""".replace("LIFETIME", chr(39)+"a").replace("MIPS", mips).replace("ANIMATE", animate)
|
||||
with tempfile.TemporaryDirectory(prefix="horizon-animation-upload-") as directory:
|
||||
path = Path(directory)
|
||||
(path / "probe.rs").write_text(program)
|
||||
subprocess.run(["rustc", "--edition=2024", "-Awarnings", str(path / "probe.rs"), "-o", str(path / "probe")], check=True, capture_output=True)
|
||||
result = subprocess.run([str(path / "probe")], capture_output=True, text=True)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,39 @@
|
||||
"""The actual world-entry reset must invalidate previously loaded player progress."""
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def run_reset(source):
|
||||
start = source.index(" self.persist = Default::default();", source.index(" fn open_world("))
|
||||
reset = source[start:source.index(" // RandomSequences", start)]
|
||||
program = """
|
||||
#[derive(Default)] struct Game {persist:bool,score:bool,fns:bool,bosses:bool,adv:bool,stats:bool}
|
||||
impl Game {fn enter_world(&mut self) {RESET}}
|
||||
fn main() {
|
||||
let mut game=Game {persist:true,score:true,fns:true,bosses:true,adv:true,stats:true};
|
||||
game.enter_world();
|
||||
assert!(!game.adv,"loaded advancement progress must not survive world entry");
|
||||
assert!(!game.stats,"loaded statistics must not survive world entry");
|
||||
}
|
||||
""".replace("RESET", reset)
|
||||
with tempfile.TemporaryDirectory(prefix="horizon-world-reset-") as directory:
|
||||
path = Path(directory)
|
||||
(path / "probe.rs").write_text(program)
|
||||
subprocess.run(["rustc", "--edition=2024", str(path / "probe.rs"), "-o", str(path / "probe")], check=True, capture_output=True)
|
||||
return subprocess.run([str(path / "probe")], capture_output=True, text=True)
|
||||
|
||||
|
||||
class WorldRuntimeResetTests(unittest.TestCase):
|
||||
@unittest.skipUnless(shutil.which("rustc"), "rustc is required")
|
||||
def test_world_entry_invalidates_loaded_progress(self):
|
||||
result = run_reset((ROOT / "crates/horizon-client/src/game.rs").read_text())
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user