Address PR59 review: axolotl timers, fluid and fire parity, persistence and Rust tests

This commit is contained in:
Cosmic
2026-10-14 10:05:41 -04:00
parent 726f88fcfc
commit f3dda9c412
22 changed files with 730 additions and 365 deletions
+35 -5
View File
@@ -61,7 +61,8 @@ impl ItemEntity {
self.position.z.floor() as i32,
);
let fluid = facts.get(at).fluid;
if fluid == Fluid::Water {
let fire_immune = items.resists_fire(&self.stack, "minecraft:in_fire");
if fluid == Fluid::Water || fire_immune {
self.fire_ticks = 0;
}
if self.fire_ticks > 0 {
@@ -74,17 +75,18 @@ impl ItemEntity {
self.fire_ticks -= 1;
}
let mut lava_hurt = false;
if fluid == Fluid::Lava {
if fluid == Fluid::Lava && !fire_immune {
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 {
let fire_damage = crate::motion::environment::fire_contact(world, registry, self.bounds());
if fire_damage > 0.0 && !fire_immune {
self.fire_ticks = self.fire_ticks.max(160);
if !items.resists_fire(&self.stack, "minecraft:in_fire") {
self.health -= 1;
self.health -= fire_damage as i32;
}
}
ItemEnvironmentTick {
@@ -569,7 +571,7 @@ impl ArmorStand {
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 fire && !self.invisible && !self.marker {
if self.fire_ticks > 0 {
self.health -= 0.15;
} else {
@@ -679,6 +681,7 @@ mod fire_environment_tests {
assert!(!result.should_play_lava_hurt_sound(10));
}
assert_eq!(metal.health, 5);
assert_eq!(metal.fire_ticks, 0, "fire-resistant items must not ignite");
world
.set(
20,
@@ -691,5 +694,32 @@ mod fire_environment_tests {
let result = burning.environment_tick(&world, &facts, assets.registry, &items);
assert!(result.alive && !result.lava_hurt);
assert!(burning.fire_ticks > 0);
world
.set(
20,
4,
20,
assets
.registry
.default_state("minecraft:soul_fire")
.unwrap(),
)
.unwrap();
let mut soul = make("minecraft:oak_planks");
soul.environment_tick(&world, &facts, assets.registry, &items);
assert_eq!(soul.health, 3);
let mut stand = ArmorStand::new(2, at, 0.0);
world
.set(
20,
4,
20,
assets.registry.default_state("minecraft:lava").unwrap(),
)
.unwrap();
for _ in 0..150 {
assert!(stand.environment_tick(&world, &facts, assets.registry));
}
assert_eq!(stand.health, 20.0, "lava does not hurt armor stands");
}
}
+181 -27
View File
@@ -329,20 +329,7 @@ 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:axolotl" => write_axolotl_memories(m, map),
"minecraft:allay" => {
// InventoryCarrier: the fetched stack; the liked player memory.
let mut inv = Vec::new();
@@ -729,14 +716,8 @@ 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);
if m.species() == crate::mobs::Species::Axolotl {
restore_axolotl_memories(&mut m, tag);
}
m.fire_ticks = number(tag.get("Fire")).unwrap_or(0) as i32;
m.air = number(tag.get("Air")).unwrap_or(300) as i32;
@@ -866,6 +847,8 @@ pub fn item_entity_to_nbt(e: &ItemEntity, uuid: [i32; 4], raw: Option<&Tag>) ->
let mut tag = base.tag(raw);
for (key, value) in [
("Item", item_to_nbt(&e.stack)),
("Health", Tag::Short(e.health as i16)),
("Fire", Tag::Short(e.fire_ticks as i16)),
("Age", Tag::Short(e.age.min(i16::MAX as u32) as i16)),
(
"PickupDelay",
@@ -874,9 +857,6 @@ pub fn item_entity_to_nbt(e: &ItemEntity, uuid: [i32; 4], raw: Option<&Tag>) ->
] {
put(&mut tag, key, value);
}
if let Tag::Compound(map) = &mut tag {
map.entry("Health".into()).or_insert(Tag::Short(5));
}
tag
}
pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> Option<ItemEntity> {
@@ -1452,8 +1432,8 @@ mod tests {
#[test]
fn item_entities_round_trip() {
let e = ItemEntity {
health: 5,
fire_ticks: 0,
health: 2,
fire_ticks: 73,
id: 7,
stack: ItemStack {
item: Arc::from("minecraft:diamond_pickaxe"),
@@ -1474,6 +1454,7 @@ mod tests {
assert_eq!(uuid(&tag), Some([1, 2, 3, 4]));
let back = item_entity_from_nbt(&tag, 9, 0.0).unwrap();
assert_eq!(back.stack.damage, 5);
assert_eq!((back.health, back.fire_ticks), (2, 73));
assert_eq!(
(back.age, back.pickup_delay, back.on_ground),
(120, 10, true)
@@ -1513,3 +1494,176 @@ mod tests {
assert_eq!(back[0].value, 7);
}
}
fn write_axolotl_memories(m: &Mob, map: &mut Compound) {
let brain = map
.entry("Brain".into())
.or_insert_with(|| Tag::Compound(Compound::new()));
if !matches!(brain, Tag::Compound(_)) {
*brain = Tag::Compound(Compound::new());
}
let Tag::Compound(brain) = brain else { return };
let memories = brain
.entry("memories".into())
.or_insert_with(|| Tag::Compound(Compound::new()));
if !matches!(memories, Tag::Compound(_)) {
*memories = Tag::Compound(Compound::new());
}
let Tag::Compound(memories) = memories else {
return;
};
let mm = m.extra.animal_brain.as_deref().map(|b| &b.mem);
let hunting = crate::mobs::animal_brain::hunting_cooldown(m)
.map(|ttl| Tag::compound([("value", Tag::Byte(1)), ("ttl", Tag::Long(ttl))]));
let play_dead = mm
.and_then(|m| m.play_dead_ticks.value())
.map(|v| Tag::compound([("value", Tag::Int(v))]));
let temptation = mm
.and_then(|m| m.temptation_cooldown_ticks.value())
.map(|v| Tag::compound([("value", Tag::Int(v))]));
for (key, value) in [
("minecraft:has_hunting_cooldown", hunting),
("minecraft:play_dead_ticks", play_dead),
("minecraft:temptation_cooldown_ticks", temptation),
] {
if let Some(value) = value {
memories.insert(key.into(), value);
} else {
memories.remove(&key.into());
}
}
}
fn restore_axolotl_memories(m: &mut Mob, tag: &Tag) {
let memories = tag.get("Brain").and_then(|b| b.get("memories"));
let ttl = memories
.and_then(|b| b.get("minecraft:has_hunting_cooldown"))
.and_then(|v| number(v.get("ttl")))
.unwrap_or(0);
crate::mobs::animal_brain::set_hunting_cooldown(m, ttl);
if let Some(b) = m.extra.animal_brain.as_mut() {
if let Some(v) = memories
.and_then(|b| b.get("minecraft:play_dead_ticks"))
.and_then(|v| number(v.get("value")))
{
b.mem.play_dead_ticks.set(v as i32);
}
if let Some(v) = memories
.and_then(|b| b.get("minecraft:temptation_cooldown_ticks"))
.and_then(|v| number(v.get("value")))
{
b.mem.temptation_cooldown_ticks.set(v as i32);
}
}
}
pub fn bucket_data(m: &Mob) -> Tag {
let mut data = Tag::compound([
("Age", Tag::Int(m.extra.age)),
("Variant", Tag::Int(i32::from(m.extra.variant))),
("Health", Tag::Float(m.health.to_bits())),
]);
if let Some(ttl) = crate::mobs::animal_brain::hunting_cooldown(m) {
put(&mut data, "HuntingCooldown", Tag::Long(ttl));
}
data
}
pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
let data = stack.data().and_then(|d| {
d.other
.iter()
.find(|(key, _)| key == "minecraft:bucket_entity_data")
.map(|(_, v)| v)
});
let Some(data) = data else { return };
if let Some(v) = number(data.get("Age")) {
m.extra.age = v as i32;
}
if let Some(v) = number(data.get("Variant")) {
m.extra.variant = v as u8;
}
if let Some(v) = float(data.get("Health")) {
m.health = v as f32;
}
if m.species() == crate::mobs::Species::Axolotl {
crate::mobs::animal_brain::set_hunting_cooldown(
m,
number(data.get("HuntingCooldown")).unwrap_or(0),
);
}
}
#[cfg(test)]
mod axolotl_nbt_tests {
use super::*;
#[test]
fn bucket_cooldown_and_brain_memories_survive_and_expired_cooldown_is_removed() {
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client/26.3");
if !root.join("items.json").exists() {
return;
}
let data = crate::mobs::MobTypes::load(&root).unwrap();
let kind = Arc::new(data.types.get("minecraft:axolotl").unwrap().clone());
let mut m = Mob::new(1, kind.clone(), Vec3::new(0.0, 4.0, 0.0), 0.0);
crate::mobs::animal_brain::set_hunting_cooldown(&mut m, 123);
{
let mm = &mut m.extra.animal_brain.as_mut().unwrap().mem;
mm.play_dead_ticks.set(78);
mm.temptation_cooldown_ticks.set(42);
}
let raw = Tag::compound([(
"Brain",
Tag::compound([(
"memories",
Tag::compound([("test:unrelated", Tag::compound([("value", Tag::Int(9))]))]),
)]),
)]);
let tag = mob_to_nbt(&m, [1, 2, 3, 4], Some(&raw));
let memories = tag.get("Brain").unwrap().get("memories").unwrap();
assert!(memories.get("test:unrelated").is_some());
assert_eq!(
number(
memories
.get("minecraft:play_dead_ticks")
.unwrap()
.get("value")
),
Some(78)
);
assert_eq!(
number(
memories
.get("minecraft:temptation_cooldown_ticks")
.unwrap()
.get("value")
),
Some(42)
);
let mut stack = crate::items::ItemStack::new("minecraft:axolotl_bucket", 1);
stack.extra = Some(Box::new(crate::item_data::StackData {
other: vec![("minecraft:bucket_entity_data".into(), bucket_data(&m))],
..Default::default()
}));
let mut restored = Mob::new(2, kind, Vec3::new(0.0, 4.0, 0.0), 0.0);
load_bucket_data(&mut restored, &stack);
assert_eq!(
crate::mobs::animal_brain::hunting_cooldown(&restored),
Some(123)
);
crate::mobs::animal_brain::set_hunting_cooldown(&mut m, 0);
assert!(bucket_data(&m).get("HuntingCooldown").is_none());
let saved = mob_to_nbt(&m, [1, 2, 3, 4], Some(&tag));
assert!(
saved
.get("Brain")
.unwrap()
.get("memories")
.unwrap()
.get("minecraft:has_hunting_cooldown")
.is_none()
);
restore_axolotl_memories(&mut restored, &saved);
let mm = &restored.extra.animal_brain.as_ref().unwrap().mem;
assert_eq!(mm.play_dead_ticks.value(), Some(78));
assert_eq!(mm.temptation_cooldown_ticks.value(), Some(42));
}
}
+49
View File
@@ -330,6 +330,23 @@ pub enum UseResult {
Fail,
}
impl UseResult {
pub fn should_swing(self, before: u32, after: u32) -> bool {
matches!(self, Self::Success { swing: true }) && before == after
}
}
pub fn consumable_animation(v: &serde_json::Value) -> horizon_world::consumable::UseAnimation {
use horizon_world::consumable::UseAnimation;
match v
.get("animation")
.and_then(serde_json::Value::as_str)
.unwrap_or("eat")
{
"eat" => UseAnimation::Eat,
"drink" => UseAnimation::Drink,
_ => UseAnimation::None,
}
}
/// What the click handling reads and does in the world.
pub trait HandWorld {
fn hit(&mut self) -> Hit;
@@ -839,3 +856,35 @@ mod continuous_use_tests {
assert_ne!(swing, item_pose(false, 0.0, 0.3, ItemPose::Using));
}
}
#[cfg(test)]
mod action_result_tests {
use super::*;
#[test]
fn only_successful_actions_swing_once() {
assert!(UseResult::Success { swing: true }.should_swing(2, 2));
for result in [
UseResult::Fail,
UseResult::Pass,
UseResult::Success { swing: false },
] {
assert!(!result.should_swing(2, 2));
}
assert!(!UseResult::Success { swing: true }.should_swing(2, 3));
}
#[test]
fn consumption_pose_requires_eat_or_drink_animation() {
use horizon_world::consumable::UseAnimation::*;
assert_eq!(consumable_animation(&serde_json::json!({})), Eat);
assert_eq!(
consumable_animation(&serde_json::json!({"animation":"drink"})),
Drink
);
for animation in ["none", "block", "bow", "brush"] {
assert_eq!(
consumable_animation(&serde_json::json!({"animation":animation})),
None
);
}
}
}
+61 -40
View File
@@ -847,6 +847,7 @@ struct Game<'a> {
tab_list: horizon_client::tab_list::TabList,
subtitles: subtitle_hud::SubtitleState,
adv: advancements::AdvState,
restore_player_environment: bool,
stats_ui: stats_screen::StatsUi,
adv_ui: advancements_screen::AdvUi,
camera_type: perspective::CameraType,
@@ -1215,18 +1216,11 @@ impl Game<'_> {
if self.eye_position().is_none() {
return;
}
let Some(stack) = self.inventory[self.selected].as_mut() else {
let Some(thrown) =
horizon_client::items::take_held_drop(&mut self.inventory[self.selected], all)
else {
return;
};
let count = if all { stack.count } else { 1 };
let thrown = ItemStack {
count,
..stack.clone()
};
stack.count -= count;
if stack.count == 0 {
self.inventory[self.selected] = None;
}
self.player_drop(thrown);
self.swing_arm();
}
@@ -2105,7 +2099,7 @@ impl Game<'_> {
let swings = self.swings_started;
match self.use_tool(&stack)? {
UseResult::Success { swing } => {
if swing && self.swings_started == swings {
if (UseResult::Success { swing }).should_swing(swings, self.swings_started) {
self.swing_arm();
}
return Ok(());
@@ -2598,18 +2592,10 @@ 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;
player.load_environment_once(
&mut self.restore_player_environment,
self.level.player_extra.as_ref(),
);
let spectator = self.mode == horizon_client::command::args::GameMode::Spectator;
player.may_fly = self.creative || spectator;
player.invulnerable = self.creative || spectator;
@@ -4434,7 +4420,12 @@ impl Game<'_> {
);
}
for item in &self.dropped {
if item.fire_ticks > 0 {
if item.fire_ticks > 0
&& !self
.res
.items
.resists_fire(&item.stack, "minecraft:in_fire")
{
let at = item.previous.lerp(item.position, alpha);
horizon_client::fire_render::flames(
[at.x, at.y, at.z],
@@ -5320,8 +5311,8 @@ impl Game<'_> {
self.score = Default::default();
self.fns = Default::default();
self.bosses = Default::default();
self.adv = Default::default();
self.stats = Default::default();
reset_world_progress(&mut self.adv, &mut self.stats);
self.restore_player_environment = true;
// 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"))
@@ -6351,18 +6342,8 @@ 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);
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
horizon_client::entity_nbt::load_bucket_data(m, stack);
}
self.mob_placed(id)?;
}
@@ -6422,7 +6403,12 @@ impl Game<'_> {
},
Some(at(hit.pos)),
1.0,
self.world.random.next_float() * 0.4 + 0.8,
if item == "fire_charge" {
(self.world.random.next_float() - self.world.random.next_float()) * 0.2
+ 1.0
} else {
self.world.random.next_float() * 0.4 + 0.8
},
);
if item == "fire_charge" {
self.consume_held();
@@ -6777,7 +6763,16 @@ impl Game<'_> {
.item_renderer
.models
.components(&horizon_client::item_render::stack_view(&stack));
if components.contains_key("minecraft:consumable") {
let animation = components
.get("minecraft:consumable")
.map(horizon_client::first_person::consumable_animation);
if matches!(
animation,
Some(
horizon_world::consumable::UseAnimation::Eat
| horizon_world::consumable::UseAnimation::Drink
)
) {
ItemPose::Eat {
remaining: owner.use_item_remaining_ticks as f32,
duration: owner.use_duration as f32,
@@ -8928,6 +8923,7 @@ pub fn run() -> Result<()> {
tab_list: Default::default(),
subtitles: Default::default(),
adv: Default::default(),
restore_player_environment: true,
stats_ui: Default::default(),
adv_ui: Default::default(),
camera_type: Default::default(),
@@ -9003,3 +8999,28 @@ pub fn run() -> Result<()> {
}
Ok(())
}
fn reset_world_progress(adv: &mut advancements::AdvState, stats: &mut stats::Stats) {
*adv = Default::default();
*stats = Default::default();
}
#[cfg(test)]
mod runtime_reset_tests {
use super::*;
#[test]
fn world_entry_invalidates_loaded_progress() {
let mut adv = advancements::AdvState::default();
let mut stats = stats::Stats::default();
adv.loaded = true;
stats.loaded = true;
adv.progress
.criteria
.insert("minecraft:story/root".into(), Default::default());
stats.add("mined", "minecraft:stone", 4);
reset_world_progress(&mut adv, &mut stats);
assert!(!adv.loaded && !stats.loaded);
assert!(adv.progress.criteria.is_empty());
assert!(stats.values.is_empty());
}
}
@@ -45,7 +45,7 @@ impl Toast {
pub(super) struct AdvState {
pub(super) tree: Arc<Tree>,
pub(super) progress: Progress,
loaded: bool,
pub(super) loaded: bool,
pub(super) toasts: VecDeque<Toast>,
/// Awards skip the toast (`/advancement grant ... everything`).
pub(super) quiet: bool,
+50 -4
View File
@@ -751,8 +751,10 @@ impl Game<'_> {
source,
} => {
let mut killed = false;
let mut hurt = false;
if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) {
let hit = t.damage(amount, source);
hurt = hit;
if hit {
killed = !t.alive();
// The hurt or death sound the mob raised.
@@ -769,6 +771,20 @@ impl Game<'_> {
}
}
}
if hurt
&& let Some(Who::Mob(attacker)) = source.attacker
&& let Some(m) = self
.mobs
.iter()
.find(|m| m.id == attacker && m.species() == Species::Axolotl)
{
self.audio.play(
"minecraft:entity.axolotl.attack",
Some([m.position.x, m.eye_y(), m.position.z]),
1.0,
1.0,
);
}
if killed && let Some(Who::Mob(killer)) = source.attacker {
self.zombie_killed(killer, target);
}
@@ -939,12 +955,12 @@ impl Game<'_> {
if !self.creative
&& let Some(p) = self.player.as_mut()
{
p.fire_ticks = p.fire_ticks.max(seconds * 20);
p.ignite_for_ticks(seconds * 20)?;
}
}
Who::Mob(id) => {
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
m.fire_ticks = m.fire_ticks.max(seconds * 20);
m.ignite_for_ticks(seconds * 20);
}
}
},
@@ -1586,7 +1602,7 @@ impl Game<'_> {
Who::Player => {
if !self.creative {
if let Some(p) = self.player.as_mut() {
p.fire_ticks = p.fire_ticks.max(100);
p.ignite_for_ticks(100)?;
}
self.mob_hits_player(
5.0,
@@ -1598,7 +1614,7 @@ impl Game<'_> {
Who::Mob(id) => {
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
if !m.kind.flags.fire_immune {
m.fire_ticks = m.fire_ticks.max(100);
m.ignite_for_ticks(100);
}
m.damage(5.0, source);
}
@@ -1811,6 +1827,36 @@ impl Game<'_> {
.as_ref()
.map(|h| h.item.to_string())
.unwrap_or_default();
if item == "minecraft:water_bucket"
&& self.mobs[index].species() == Species::Axolotl
&& self.mobs[index].alive()
{
let mut filled = ItemStack::new("minecraft:axolotl_bucket", 1);
filled.extra = Some(Box::new(horizon_client::item_data::StackData {
other: vec![(
"minecraft:bucket_entity_data".into(),
horizon_client::entity_nbt::bucket_data(&self.mobs[index]),
)],
..Default::default()
}));
self.audio.play(
"minecraft:item.bucket.fill_axolotl",
Some(self.mobs[index].center()),
1.0,
1.0,
);
self.trigger_item("minecraft:filled_bucket", &filled);
self.mobs[index].removed = true;
if self.creative {
if let Some(rest) = self.give(filled) {
self.spawn_item(rest, self.eye_position().unwrap_or([0.0; 3]), [0.0; 3], 40);
}
} else {
self.inventory[self.selected] = Some(filled);
}
self.swing_arm();
return Ok(true);
}
let creative = self.creative;
let selected = self.selected;
if self.interact_zombie_villager(index, &item) {
@@ -1177,6 +1177,9 @@ impl Game<'_> {
// MobBucketItem.checkExtraContent: the mob (from the bucket, so
// persistent) calls out, then ENTITY_PLACE.
if let Some(id) = self.spawn_mob_at(kind, target, true) {
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) {
horizon_client::entity_nbt::load_bucket_data(m, &stack);
}
self.mob_placed(id)?;
}
self.post_block_game_event(
+11 -10
View File
@@ -309,11 +309,11 @@ impl Game<'_> {
_ => {}
}
// Entity.thunderHit: burning (8 seconds) and 5 lightning damage.
m.fire_ticks = if m.fire_ticks + 1 == 0 {
160
} else {
m.fire_ticks + 1
};
m.fire_ticks += 1;
if m.fire_ticks == 0 {
m.ignite_for_ticks(160);
}
m.damage(5.0, damage);
}
if !events.is_empty() {
@@ -323,11 +323,12 @@ impl Game<'_> {
&& inside([p.x, p.y, p.z])
{
if let Some(p) = self.player.as_mut() {
p.fire_ticks = if p.fire_ticks + 1 == 0 {
160
} else {
p.fire_ticks + 1
};
p.fire_ticks += 1;
if p.fire_ticks == 0
&& let Err(error) = p.ignite_for_ticks(160)
{
self.error = Some(error.to_string());
}
}
self.hurt_player_by("minecraft:lightning_bolt", 5.0);
}
+1 -1
View File
@@ -10,7 +10,7 @@ use std::collections::BTreeMap;
#[derive(Default)]
pub(super) struct Stats {
pub(super) values: BTreeMap<String, BTreeMap<String, i32>>,
loaded: bool,
pub(super) loaded: bool,
/// Ticks until the phantom spawner runs again.
phantom_tick: i32,
/// Statistic changes (type, key, amount; `None` = reset) for the
+73 -18
View File
@@ -1569,7 +1569,7 @@ impl Renderer {
/// The Mipmap Levels option: block textures sample at most `levels`
/// reduced copies (0: none).
pub fn set_mipmap_levels(&mut self, levels: u32) {
let levels = levels.min(self.mip_levels - 1);
let levels = sprite_mipmap_limit(levels, self.sprite_texture.width(), self.mip_levels);
if levels == self.mipmaps {
return;
}
@@ -1697,18 +1697,12 @@ 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), sprite_size, 1);
let mut offset = 0;
for level in 0..levels.min(self.mip_levels) {
let size = sprite_size >> level;
let bytes = (size * size * 4) as usize;
animate_sprites(
&mut self.animations,
tick,
self.sprite_texture.width(),
self.mip_levels,
|layer, level, size, pixels| {
self.queue.write_texture(
wgpu::TexelCopyTextureInfo {
texture: &self.sprite_texture,
@@ -1716,11 +1710,11 @@ impl Renderer {
origin: wgpu::Origin3d {
x: 0,
y: 0,
z: animation.layer,
z: layer,
},
aspect: wgpu::TextureAspect::All,
},
&mips[offset..offset + bytes],
pixels,
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(size * 4),
@@ -1732,9 +1726,8 @@ impl Renderer {
depth_or_array_layers: 1,
},
);
offset += bytes;
}
}
},
);
}
pub fn render(&mut self, frame: &Frame) -> Result<bool> {
if self.suspended {
@@ -2540,3 +2533,65 @@ mod tests {
assert!(super::outline_vertices(&[], glam::DVec3::ZERO).is_empty());
}
}
fn sprite_mipmap_limit(requested: u32, size: u32, available: u32) -> u32 {
// 16px textures are doubled in this atlas; mip1 retains their original texels.
let upscale = (size / 16).max(1).ilog2();
requested.saturating_add(upscale).min(available - 1)
}
fn animate_sprites(
animations: &mut [(crate::sprites::SpriteAnimation, usize)],
tick: u64,
size: u32,
max_levels: u32,
mut write: impl FnMut(u32, u32, u32, &[u8]),
) {
for (animation, previous) in animations {
let frame = animation.frame(tick);
if frame == *previous {
continue;
}
*previous = frame;
let (mips, levels) = mip_chain(animation.pixels(frame), size, 1);
let mut offset = 0;
for level in 0..levels.min(max_levels) {
let edge = size >> level;
let bytes = (edge * edge * 4) as usize;
write(animation.layer, level, edge, &mips[offset..offset + bytes]);
offset += bytes;
}
}
}
#[cfg(test)]
mod sprite_upload_tests {
use super::*;
#[test]
fn mipmap_option_keeps_real_16px_reductions() {
for levels in 0..=4 {
assert_eq!(sprite_mipmap_limit(levels, 32, 6), levels + 1);
assert_eq!(sprite_mipmap_limit(levels, 16, 5), levels);
}
}
#[test]
fn animation_updates_entire_layer_every_mip_once() {
for size in [16, 32] {
let animation = crate::sprites::test_animation(size, 7);
let pixels = animation.pixels(animation.frame(1)).to_vec();
let (expected, levels) = mip_chain(&pixels, size, 1);
let mut animations = vec![(animation, 0)];
let mut writes = Vec::new();
let mut record = |layer, level, edge, data: &[u8]| {
assert_eq!(layer, 7);
assert_eq!(edge, size >> level);
assert_eq!(data.len(), (edge * edge * 4) as usize);
writes.push(data.to_vec());
};
animate_sprites(&mut animations, 0, size, levels, &mut record);
animate_sprites(&mut animations, 1, size, levels, &mut record);
animate_sprites(&mut animations, 1, size, levels, &mut record);
assert_eq!(writes.len(), levels as usize);
assert_eq!(writes[0], pixels);
assert_eq!(writes.concat(), expected);
}
}
}
+30
View File
@@ -1375,3 +1375,33 @@ mod tests {
);
}
}
pub fn take_held_drop(slot: &mut Option<ItemStack>, all: bool) -> Option<ItemStack> {
let stack = slot.as_mut()?;
if stack.count == 0 {
return None;
}
let count = if all { stack.count } else { 1 };
let thrown = ItemStack {
count,
..stack.clone()
};
stack.count -= count;
if stack.count == 0 {
*slot = None;
}
Some(thrown)
}
#[cfg(test)]
mod held_drop_tests {
use super::*;
#[test]
fn one_all_and_empty_drop() {
let mut slot = Some(ItemStack::new("minecraft:stone", 4));
assert_eq!(take_held_drop(&mut slot, false).unwrap().count, 1);
assert_eq!(slot.as_ref().unwrap().count, 3);
assert_eq!(take_held_drop(&mut slot, true).unwrap().count, 3);
assert!(slot.is_none());
assert!(take_held_drop(&mut slot, false).is_none());
}
}
+16 -1
View File
@@ -938,8 +938,9 @@ pub enum MobEvent {
at: [f64; 3],
amount: u32,
},
/// Apply an effect to the player (witch potions, bee stings, cave spider poison).
/// Regeneration support after an axolotl-assisted kill.
AxolotlSupportPlayer,
/// Apply an effect to the player (witch potions, bee stings, cave spider poison).
EffectPlayer {
effect: &'static str,
ticks: i32,
@@ -1151,6 +1152,20 @@ pub struct Seen {
pub stats: [f64; 3],
}
impl Mob {
pub fn burning_time(&self) -> f64 {
let base = finalize::value(self, finalize::Attr::BurningTime);
let protection: u32 = gear::ARMOR
.into_iter()
.map(|slot| gear::level(self, slot, "minecraft:fire_protection"))
.sum();
(base - 0.15 * f64::from(protection)).max(0.0)
}
pub fn ignite_for_ticks(&mut self, ticks: i32) {
self.fire_ticks = self
.fire_ticks
.max((f64::from(ticks) * self.burning_time()).ceil() as i32);
}
/// What other mobs see of this one this tick (`player`: the player's
/// UUID, which villagers' reputation is keyed by).
pub fn seen(&self, player: Option<[i32; 4]>) -> Seen {
+9 -4
View File
@@ -401,8 +401,13 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
}
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);
let multiplier = m.burning_time();
m.fire_ticks = crate::motion::environment::ignite_contact(
m.fire_ticks,
false,
&mut m.random,
multiplier,
);
m.damage(fire, Damage::of(DamageKind::InFire));
}
// Fire: water extinguishes, lava ignites, burning hurts every second.
@@ -416,7 +421,7 @@ fn base_tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
));
}
if m.fluids.in_lava && !m.kind.flags.fire_immune {
m.fire_ticks = m.fire_ticks.max(300);
m.ignite_for_ticks(300);
m.damage(4.0, Damage::of(DamageKind::Lava));
}
if m.fire_ticks > 0 {
@@ -666,7 +671,7 @@ fn ai_step(m: &mut Mob, w: &MobWorld, level_random: &mut LegacyRandom, events: &
}
// Mob.aiStep: undead burn in daylight.
if m.kind.flags.burns_in_day && m.alive() && sun_burn_tick(m, w) && m.extra.head.is_none() {
m.fire_ticks = m.fire_ticks.max(160);
m.ignite_for_ticks(160);
}
species_ai_step(m, w, events);
}
+35 -11
View File
@@ -641,10 +641,7 @@ fn targetable(m: &mut Mob, w: &MobWorld, who: Who) -> bool {
}
Who::Mob(id) => {
let Some(s) = w.seen(id) else { return false };
s.alive
&& !s.playing_dead
&& m.distance_sqr(s.position) <= range * range
&& m.sees(w, who)
s.alive && m.distance_sqr(s.position) <= range * range && m.sees(w, who)
}
}
}
@@ -1430,7 +1427,7 @@ impl B {
1.1
};
let close = if m.species() == Species::Axolotl {
4 + cx.lr.next_int_bound(12).unwrap_or(0)
4
} else {
2
};
@@ -2282,13 +2279,21 @@ pub fn set_play_dead(m: &mut Mob) {
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))
mem_ref(m).and_then(|mm| {
mm.hunting_cooldown
.get()
.and_then(|_| (mm.hunting_cooldown.ttl > 0).then_some(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);
if ticks > 0 {
mem(m).hunting_cooldown.set_ttl(true, ticks);
} else {
mem(m).hunting_cooldown.clear();
}
}
fn validate_play_dead(b: &mut Brain) -> bool {
let Some(ticks) = b.mem.play_dead_ticks.value() else {
@@ -2395,7 +2400,7 @@ fn axolotl_action(m: &mut Mob, cx: &mut Bx, action: AxolotlAction, until: &mut i
.w
.target_info(target)
.is_some_and(|t| m.within_melee_range(&t))
&& visible_test(m, cx.w, target)
&& visible_contains(m, cx.w, target)
{
mem(m).walk_target.clear();
} else {
@@ -2417,7 +2422,7 @@ fn axolotl_action(m: &mut Mob, cx: &mut Bx, action: AxolotlAction, until: &mut i
let Some(target) = mm.attack_target.value() else {
return false;
};
if !visible_test(m, cx.w, target)
if !visible_contains(m, cx.w, target)
|| !cx
.w
.target_info(target)
@@ -2435,7 +2440,6 @@ fn axolotl_action(m: &mut Mob, cx: &mut Bx, action: AxolotlAction, until: &mut i
events: cx.events,
},
);
m.sound("entity.axolotl.attack", cx.events);
mem(m).attack_cooling_down.set_ttl(true, 20);
true
}
@@ -2613,7 +2617,7 @@ fn axolotl_package(seed: i64) -> Vec<Entry> {
e(
Idle,
B::MakeLove {
t: Timed::new(325, 325),
t: Timed::new(110, 110),
spawn_at: 0,
},
),
@@ -2864,3 +2868,23 @@ mod axolotl_parity_tests {
assert!(kind_for_species(Species::Axolotl).is_some());
}
}
#[cfg(test)]
mod breeding_duration_tests {
use super::*;
#[test]
fn axolotl_breeding_uses_native_110_tick_timeout() {
let package = axolotl_package(1);
let timed = package
.iter()
.find_map(|e| {
if let B::MakeLove { t, .. } = &e.b {
Some(t)
} else {
None
}
})
.unwrap();
assert_eq!((timed.min, timed.max), (110, 110));
}
}
+7 -3
View File
@@ -404,9 +404,10 @@ pub enum Attr {
SpawnReinforcements,
JumpStrength,
Armor,
BurningTime,
}
impl Attr {
pub const ALL: [Self; 8] = [
pub const ALL: [Self; 9] = [
Self::MaxHealth,
Self::MovementSpeed,
Self::FollowRange,
@@ -415,6 +416,7 @@ impl Attr {
Self::SpawnReinforcements,
Self::JumpStrength,
Self::Armor,
Self::BurningTime,
];
pub fn name(self) -> &'static str {
match self {
@@ -426,6 +428,7 @@ impl Attr {
Self::SpawnReinforcements => "spawn_reinforcements",
Self::JumpStrength => "jump_strength",
Self::Armor => "armor",
Self::BurningTime => "burning_time",
}
}
/// `RangedAttribute` bounds.
@@ -438,6 +441,7 @@ impl Attr {
Self::KnockbackResistance | Self::SpawnReinforcements => (0.0, 1.0),
Self::JumpStrength => (0.0, 32.0),
Self::Armor => (0.0, 30.0),
Self::BurningTime => (0.0, 1024.0),
}
}
}
@@ -476,7 +480,7 @@ pub fn base_value(m: &Mob, a: Attr) -> f64 {
.as_ref()
.and_then(|s| s.bases.iter().find(|(x, _)| *x == a).map(|(_, v)| *v))
.or_else(|| default_value(m, a))
.unwrap_or(0.0)
.unwrap_or(if a == Attr::BurningTime { 1.0 } else { 0.0 })
}
/// The transient modifiers of the mob's state (`SPEED_MODIFIER_BABY`).
fn transient(m: &Mob, a: Attr) -> Option<(f64, Op)> {
@@ -560,7 +564,7 @@ fn refresh(m: &mut Mob, a: Attr) {
Attr::KnockbackResistance => m.attrs.knockback_resistance = value(m, a),
Attr::SpawnReinforcements => m.attrs.spawn_reinforcements = value(m, a),
Attr::JumpStrength => m.attrs.jump_strength = value(m, a),
Attr::Armor => {}
Attr::Armor | Attr::BurningTime => {}
}
}
/// The value without the transient baby modifier (`speed_bonus` applies
+3 -8
View File
@@ -1000,7 +1000,7 @@ impl Goal for MeleeAttack {
let Some(t) = m.target_info(cx.w) else {
return false;
};
if !t.alive || !t.can_be_seen_as_enemy {
if !t.alive {
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 || !t.can_be_seen_as_enemy {
if !t.alive {
return false;
}
if !self.follow_unseen {
@@ -2061,12 +2061,7 @@ impl Goal for TryFindWater {
!m.ai.nav.is_done()
}
fn start(&mut self, m: &mut Mob, cx: &mut Cx) {
let speed = if m.species() == Species::Axolotl {
0.15
} else {
1.0
};
m.nav_move_to(cx.w, self.wanted, speed);
m.nav_move_to(cx.w, self.wanted, 1.0);
}
}
/// `MoveToBlockGoal`'s shared state: search, walk to and stay at a block.
+99 -16
View File
@@ -140,7 +140,6 @@ pub struct PlayerMotion {
pub fire_ticks: i32,
pub air: i32,
pub respiration: i32,
pub(crate) first_tick: bool,
pub position: Vec3,
pub velocity: Vec3,
@@ -205,6 +204,26 @@ fn attribute_error(error: impl std::fmt::Debug) -> io::Error {
io::Error::other(format!("movement attribute: {error:?}"))
}
impl PlayerMotion {
pub fn load_environment_once(
&mut self,
pending: &mut bool,
extra: Option<&horizon_world::nbt::Tag>,
) {
if std::mem::take(pending) {
self.fire_ticks = extra
.and_then(|t| crate::save::number(t.get("Fire")))
.unwrap_or(-20) as i32;
self.air = extra
.and_then(|t| crate::save::number(t.get("Air")))
.unwrap_or(300) as i32;
}
}
pub fn ignite_for_ticks(&mut self, ticks: i32) -> Result<()> {
let scaled = (f64::from(ticks) * self.attribute("minecraft:burning_time")?).ceil() as i32;
self.fire_ticks = self.fire_ticks.max(scaled);
Ok(())
}
pub fn new(resources: &MotionResources, position: Vec3) -> Result<Self> {
// Process-owned identities determine native collection callback order.
// Differential fixtures can replay a reference process's identities.
@@ -279,10 +298,9 @@ impl PlayerMotion {
eye_in_water: false,
in_lava: false,
swimming: false,
fire_ticks: 0,
fire_ticks: -20,
air: 300,
respiration: 0,
first_tick: true,
speed: 0.0,
item_use_speed: None,
last_climbable: None,
@@ -538,7 +556,8 @@ impl MotionWorld<'_, '_, '_> {
let can_glide = self.player.glider
&& !self.player.ground.on_ground
&& !self.player.flying
&& !self.player.in_water;
&& !self.player.in_water
&& !self.player.in_lava;
if jumping && !toggled && !was_jumping && !self.player.fall_flying && can_glide {
self.player.fall_flying = true;
}
@@ -548,7 +567,8 @@ impl MotionWorld<'_, '_, '_> {
let still = self.player.glider
&& !self.player.ground.on_ground
&& !self.player.flying
&& !self.player.in_water;
&& !self.player.in_water
&& !self.player.in_lava;
if !still {
self.player.fall_flying = false;
} else if (self.player.fall_fly_ticks + 1) % 10 == 0
@@ -587,8 +607,11 @@ impl MotionWorld<'_, '_, '_> {
/// Resident simulation phases in native order. Enclosing entity/world tick
/// 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.simulation_tick_with_fluids(direction, jumping)
}
fn simulation_tick_with_fluids(&mut self, direction: [f32; 2], jumping: bool) -> Result<()> {
self.player.health.advance_clock();
self.tick_environment_damage()?;
let previous = self.player.position;
self.player.swimming = self.player.sprinting
@@ -616,7 +639,7 @@ impl MotionWorld<'_, '_, '_> {
self.player.auto_jump_time -= 1;
keys.jump = true;
}
self.sample_fluid_environment(false)?;
self.update_fluid_environment()?;
self.player.sprint_input_tick(keys)?;
self.player.shift_key_down = keys.shift;
let direction = keys.direction();
@@ -628,7 +651,7 @@ impl MotionWorld<'_, '_, '_> {
} else {
None
};
self.simulation_tick(
self.simulation_tick_with_fluids(
crate::input::modify_input(direction, self.player.item_use_speed, sneak),
keys.jump,
)
@@ -665,11 +688,8 @@ 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.shift_key_down && !self.player.flying && self.player.in_water {
self.player.velocity.y -= f64::from(0.04f32);
}
if self.player.jumping {
let height = self.player.fluids.fluid_height(
@@ -684,7 +704,7 @@ impl MotionWorld<'_, '_, '_> {
&& (self.player.in_water || self.player.in_lava)
&& (!self.player.ground.on_ground || height > 0.4)
{
self.player.velocity.y += 0.04;
self.player.velocity.y += f64::from(0.04f32);
} else if self.player.ground.on_ground && self.player.no_jump_delay == 0 {
self.jump_from_ground()?;
self.player.no_jump_delay = 10;
@@ -692,6 +712,21 @@ impl MotionWorld<'_, '_, '_> {
} else {
self.player.no_jump_delay = 0;
}
if self.player.swimming {
let look_y = f64::from(-self.player.pitch.to_radians().sin());
let near_surface = BlockPos::containing(Vec3::new(
self.player.position.x,
self.player.position.y + 0.9,
self.player.position.z,
));
if look_y <= 0.0
|| self.player.jumping
|| self.fluid_at(near_surface)?.kind() != horizon_world::fluid::FluidKind::Empty
{
let blend = if look_y < -0.2 { 0.085 } else { 0.06 };
self.player.velocity.y += (look_y - self.player.velocity.y) * blend;
}
}
if self.player.fall_flying {
self.travel_fall_flying()?;
} else if self.player.flying {
@@ -1492,7 +1527,7 @@ mod tests {
}
w.player.fire_ticks = 160;
w.controlled_simulation_tick(Default::default()).unwrap();
assert_eq!(w.player.fire_ticks, 0);
assert!(w.player.fire_ticks <= 0);
w.player.air = -19;
w.player.health.hurt.cooldown = 0;
let hp = w.player.health.health();
@@ -1525,16 +1560,28 @@ mod tests {
}
w.player.position = Vec3::new(20.5, 4.0, 20.5);
w.player.velocity = Vec3::ZERO;
w.player.fire_ticks = -20;
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.fire_ticks < 0,
"direct fire hurts during the immunity delay"
);
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);
w.player.invulnerable = true;
w.player.fire_ticks = -20;
w.controlled_simulation_tick(Default::default()).unwrap();
assert_eq!(
w.player.fire_ticks, 1,
"creative fire contact must remain visible"
);
w.player.invulnerable = false;
// Sprint swimming must keep full input, not the dry crawl/sneak multiplier.
for x in 19..=21 {
for y in 2..=7 {
@@ -1563,6 +1610,42 @@ mod tests {
w.player.velocity
);
assert!(!w.player.moving_slowly());
w.player.position = Vec3::new(20.5, 4.0, 20.5);
w.player.velocity = Vec3::ZERO;
w.player.pitch = 45.0;
w.controlled_simulation_tick(crate::sprint::Keys {
forward: true,
sprint: true,
..Default::default()
})
.unwrap();
assert!(
w.player.velocity.y < -0.04,
"look down must steer a swimming player downward"
);
w.player.position = Vec3::new(20.5, 4.0, 20.5);
w.player.velocity = Vec3::ZERO;
w.player.pitch = -45.0;
w.controlled_simulation_tick(crate::sprint::Keys {
forward: true,
sprint: true,
..Default::default()
})
.unwrap();
assert!(
w.player.velocity.y > 0.02,
"look up must steer a submerged swimmer upward"
);
let extra = horizon_world::nbt::Tag::compound([
("Fire", horizon_world::nbt::Tag::Short(160)),
("Air", horizon_world::nbt::Tag::Short(8)),
]);
let mut pending = true;
w.player.load_environment_once(&mut pending, Some(&extra));
assert_eq!((w.player.fire_ticks, w.player.air), (160, 8));
let mut respawn = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
respawn.load_environment_once(&mut pending, Some(&extra));
assert_eq!((respawn.fire_ticks, respawn.air), (-20, 300));
w.player.in_water = false;
assert!(
w.player.moving_slowly(),
+51 -13
View File
@@ -12,7 +12,7 @@ use horizon_world::{
pub(super) const WATER: FluidTagId = FluidTagId(0);
pub(super) const LAVA: FluidTagId = FluidTagId(1);
impl MotionWorld<'_, '_, '_> {
fn fluid_at(&self, p: BlockPos) -> Result<FluidState> {
pub(super) fn fluid_at(&self, p: BlockPos) -> Result<FluidState> {
Ok(FluidState::from_block(
self.assets
.registry
@@ -21,9 +21,6 @@ impl MotionWorld<'_, '_, '_> {
)?)
}
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)
@@ -38,7 +35,7 @@ impl MotionWorld<'_, '_, '_> {
if self.player.in_water {
self.player.fall_distance = 0.0;
}
if push && !self.player.flying && !self.player.spectator {
if !self.player.flying && !self.player.spectator {
fluids.apply_current(self, WATER, 0.014)?;
fluids.apply_current(
self,
@@ -51,7 +48,6 @@ impl MotionWorld<'_, '_, '_> {
)?;
}
self.player.fluids = fluids;
self.player.first_tick = false;
Ok(())
}
fn environment_hurt(&mut self, source: &str, damage: f32) -> Result<()> {
@@ -69,9 +65,12 @@ impl MotionWorld<'_, '_, '_> {
Ok(())
}
pub(super) fn tick_environment_damage(&mut self) -> Result<()> {
if self.player.in_water || self.player.invulnerable || self.player.spectator {
if self.player.in_water || self.player.spectator {
self.player.fire_ticks = 0;
}
if self.player.invulnerable && self.player.fire_ticks > 1 {
self.player.fire_ticks = 1;
}
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)?;
@@ -98,24 +97,39 @@ impl MotionWorld<'_, '_, '_> {
self.player.air = (self.player.air + 4).min(300);
}
if self.player.in_lava {
self.player.fire_ticks = self.player.fire_ticks.max(300);
if self.player.invulnerable {
self.player.fire_ticks = 1;
} else {
self.player.ignite_for_ticks(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 {
if self.player.spectator {
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);
if self.player.invulnerable {
self.player.fire_ticks = 1;
} else {
let multiplier = self.player.attribute("minecraft:burning_time")?;
self.player.fire_ticks = ignite_contact(
self.player.fire_ticks,
true,
&mut self.scene.random,
multiplier,
);
}
}
self.environment_hurt("minecraft:in_fire", damage)?;
} else if self.player.fire_ticks <= 0 {
self.player.fire_ticks = -20;
}
Ok(())
}
@@ -308,7 +322,12 @@ impl MotionWorld<'_, '_, '_> {
}
}
pub(crate) fn ignite_contact(ticks: i32, player: bool, random: &mut impl RandomSource) -> i32 {
pub(crate) fn ignite_contact(
ticks: i32,
player: bool,
random: &mut impl RandomSource,
multiplier: f64,
) -> i32 {
let ticks = if ticks < 0 {
ticks + 1
} else if player {
@@ -316,5 +335,24 @@ pub(crate) fn ignite_contact(ticks: i32, player: bool, random: &mut impl RandomS
} else {
ticks
};
if ticks >= 0 { ticks.max(160) } else { ticks }
if ticks >= 0 {
ticks.max((160.0 * multiplier).ceil() as i32)
} else {
ticks
}
}
#[cfg(test)]
mod fire_ignition_tests {
use super::*;
#[test]
fn fire_hurts_before_twenty_tick_ignition_and_scales_duration() {
let mut r = horizon_core::random::LegacyRandom::new(3);
let mut ticks = -20;
for _ in 0..19 {
ticks = ignite_contact(ticks, true, &mut r, 0.4);
assert!(ticks < 0);
}
assert_eq!(ignite_contact(ticks, true, &mut r, 0.4), 64);
}
}
+15
View File
@@ -151,6 +151,21 @@ impl Sprites {
}
}
#[cfg(test)]
pub(crate) fn test_animation(size: u32, layer: u32) -> SpriteAnimation {
let frame = |blue: u8| {
(0..size * size)
.flat_map(|i| [(i % size) as u8, (i / size) as u8, blue, 255])
.collect()
};
let metadata = AnimationMetadata::from_json(r#"{"frametime":1,"frames":[0,1]}"#).unwrap();
SpriteAnimation {
layer,
frames: Arc::new(vec![frame(0), frame(99)]),
clip: Arc::new(metadata.clip(2).unwrap().unwrap()),
}
}
#[cfg(test)]
mod tests {
use super::*;
-93
View File
@@ -1,93 +0,0 @@
"""Compile the actual drop and ignition branches with world effects stubbed."""
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
def block(source, start):
opening = source.index("{", start)
depth, end = 1, opening + 1
while depth:
depth += (source[end] == "{") - (source[end] == "}")
end += 1
return source[start:end]
class ItemActionAnimationTests(unittest.TestCase):
@unittest.skipUnless(shutil.which("rustc"), "rustc is required for action-policy tests")
def test_successful_drop_and_ignition_start_a_swing(self):
source = (ROOT / "crates/horizon-client/src/game.rs").read_text()
drop = block(source, source.index("fn drop_held("))
ignition = block(source, source.index("if self.can_place_used_fire(target)"))
caller_start = source.index(" let swings = self.swings_started;", source.index("fn use_item_as_player("))
caller = source[caller_start:source.index(" if self.use_potion_item", caller_start)]
program = """
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
enum UseResult { Pass, Fail, Success { swing: bool } }
#[derive(Clone)] struct ItemStack { count: u32, item: String }
struct Hit { pos: [i32; 3], face: [i32; 3] }
struct Facts; impl Facts { fn is_air(&self, state:u8)->bool { state == 0 } }
struct Res { facts:Facts }
struct Random; impl Random { fn next_float(&mut self)->f32 { 0.5 } }
struct World { air:bool, path:bool, random:Random }
impl World { fn block(&self,_:i32,_:i32,_:i32)->u8 { if self.air {0} else {1} } }
struct Audio { sounds:u32 } impl Audio { fn play(&mut self,_:&str,_:Option<[f64;3]>,_:f32,_:f32) {self.sounds+=1;} }
struct Game { selected:usize, inventory:[Option<ItemStack>;1], alive:bool, swings:u32, drops:u32, res:Res, world:World, audio:Audio }
impl Game {
DROP
fn ignite(&mut self,item:&str)->Result<()> {
let stack=ItemStack {count:1,item:item.into()};
CALLER
Ok(())
}
fn use_tool(&mut self,stack:&ItemStack)->Result<UseResult> {
let item=stack.item.as_str();
let hit = Hit { pos:[0;3], face:[0,1,0] };
let at = |p:[i32;3]| p.map(f64::from);
let target = [0,1,0];
IGNITION
Ok(UseResult::Fail)
}
fn eye_position(&self)->Option<[f64;3]> { self.alive.then_some([0.0;3]) }
fn player_drop(&mut self,stack:ItemStack) { self.drops += stack.count; }
fn swing_arm(&mut self) { self.swings += 1; }
fn try_light_portal(&mut self,_:[i32;3])->Result<bool> {Ok(false)}
fn may_build(&self)->bool {true}
fn can_place_used_fire(&self,_:[i32;3])->bool {self.world.air&&!self.world.path}
fn place_used_fire(&mut self,_:[i32;3])->Result<()> {Ok(())}
fn consume_held(&mut self) {} fn damage_held(&mut self,_:u32) {}
}
fn game()->Game { Game { selected:0, inventory:[Some(ItemStack { count:4,item:"minecraft:stone".into() })], alive:true, swings:0, drops:0, res:Res {facts:Facts}, world:World {air:true,path:false,random:Random}, audio:Audio {sounds:0} } }
#[test] fn dropping_one_and_all_swings_only_on_success() {
let mut g=game();g.drop_held(false);assert_eq!((g.drops,g.swings),(1,1));
g.drop_held(true);assert_eq!((g.drops,g.swings),(4,2));
g.drop_held(false);assert_eq!(g.swings,2);
let mut g=game();g.alive=false;g.drop_held(false);assert_eq!(g.swings,0);
}
#[test] fn successful_ignition_swings_but_blocked_ignition_does_not() {
for item in ["flint_and_steel","fire_charge"] {
let mut g=game();g.ignite(item).unwrap();assert_eq!((g.swings,g.audio.sounds),(1,1));
let mut g=game();g.world.air=false;g.ignite(item).unwrap();assert_eq!((g.swings,g.audio.sounds),(0,0));
let mut g=game();g.world.path=true;g.ignite(item).unwrap();assert_eq!((g.swings,g.audio.sounds),(0,0));
}
}
""".replace("DROP", drop).replace("IGNITION", ignition).replace("CALLER", caller)
program = program.replace("self.swings_started", "self.swings")
with tempfile.TemporaryDirectory(prefix="horizon-item-action-") as directory:
path = Path(directory)
(path / "probe.rs").write_text(program)
compiled = subprocess.run(
["rustc", "--edition=2024", "--test", str(path / "probe.rs"), "-o", str(path / "probe")],
capture_output=True, text=True, check=False,
)
self.assertEqual(compiled.returncode, 0, compiled.stderr)
tested = subprocess.run([str(path / "probe")], capture_output=True, text=True, check=False)
self.assertEqual(tested.returncode, 0, tested.stdout + tested.stderr)
if __name__ == "__main__":
unittest.main()
-71
View File
@@ -1,71 +0,0 @@
"""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()
-39
View File
@@ -1,39 +0,0 @@
"""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()