Merge origin/main into fix/enchanted-item-trigger

advancements.rs keeps main's new triggers and the PR's own.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-27 12:33:27 +01:00
93 changed files with 3977 additions and 526 deletions
@@ -61,6 +61,16 @@ fn f32_tag(v: f32) -> Tag {
Tag::Float(v.to_bits())
}
/// `TheEndGatewayBlockEntity.loadAdditional`: BlockPos.CODEC and Level.isInSpawnableBounds.
pub fn gateway_exit(tag: &Tag) -> Option<[i32; 3]> {
let Tag::IntArray(v) = tag else { return None };
let p: [i32; 3] = v.as_slice().try_into().ok()?;
((-30_000_000..30_000_000).contains(&p[0])
&& (-20_000_000..20_000_000).contains(&p[1])
&& (-30_000_000..30_000_000).contains(&p[2]))
.then_some(p)
}
/// What a block entity reads and writes, in `saveAdditional` order.
struct Fields<'a> {
input: &'a Tag,
@@ -424,10 +434,7 @@ pub fn canonical(tag: &Tag) -> Option<Tag> {
}
"minecraft:end_gateway" => {
f.long("Age", 0);
f.keep("exit_portal", |t| {
is_pos(t)
&& matches!(t, Tag::IntArray(v) if v[1].abs() <= 30_000_000 && v[0].abs() <= 30_000_000 && v[2].abs() <= 30_000_000)
});
f.keep("exit_portal", |t| gateway_exit(t).is_some());
if flag(tag.get("ExactTeleport")) == Some(true) {
f.put("ExactTeleport", boolean(true));
}
+4 -2
View File
@@ -1,8 +1,9 @@
//! The client's lowest layer, below commands and gameplay: chat text and
//! translations, SNBT and NBT paths, text components, the scoreboard, boss
//! bars, game rules, block entity NBT tables, and the registry, particle and
//! sound source tables commands name. horizon-client re-exports each module
//! under its old path (`horizon_client::text`, ...).
//! sound source tables commands name, and the `pack.mcmeta` filter regex.
//! horizon-client re-exports each module under its old path
//! (`horizon_client::text`, ...).
#![forbid(unsafe_code)]
pub mod block_entity_nbt;
pub mod bossbar;
@@ -14,6 +15,7 @@ pub mod key_display;
pub mod lang;
pub mod nbt_path;
pub mod particle_type;
pub mod pattern;
pub mod registries;
pub mod scoreboard;
pub mod snbt;
@@ -580,7 +580,7 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool {
match e {
MobEvent::AttackPlayer(amount, _) | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0,
// ServerExplosion.hurtEntities: within twice the radius every hit does damage.
MobEvent::Explode(at, radius) => {
MobEvent::Explode(at, radius, _) => {
let d = Vec3::new(at[0], at[1], at[2])
.distance_squared(p.position)
.sqrt();
@@ -1050,6 +1050,7 @@ pub fn main() -> horizon_client::Result<()> {
off_hand: None,
head: None,
armor_cover: 0.0,
invisible: false,
spectator: false,
gold_armor: false,
hurt_by: None,
@@ -1100,6 +1101,7 @@ pub fn main() -> horizon_client::Result<()> {
block_tags: &items.block_tags,
biomes: &biomes,
mob_griefing: true,
mob_drops: true,
difficulty: LocalDifficulty::new(s.difficulty, world.day_time, 0, 0.0),
end: false,
world_seed: 0,
+91
View File
@@ -473,6 +473,51 @@ pub fn id_matches(v: &Value, registry: &str, id: &str, w: &dyn World) -> bool {
_ => false,
}
}
/// `PotionsPredicate`: the potion in a `HolderSet`, plus a `CollectionPredicate`
/// over the potion's effects (`contains`, `count`, `size`).
pub fn potions(v: &Value, potion: Option<&str>, w: &dyn World) -> bool {
if v.is_null() {
return true;
}
if !v["potions"].is_null() && !potion.is_some_and(|p| id_matches(&v["potions"], "potion", p, w))
{
return false;
}
let c = &v["effects"];
if c.is_null() {
return true;
}
let effects: Vec<(String, i32, i32)> = potion
.and_then(crate::brewing::potion)
.map(|d| {
d.effects
.iter()
.map(|(id, dur, amp)| (format!("minecraft:{id}"), *amp, *dur))
.collect()
})
.unwrap_or_default();
// `MobEffectsPredicate.test`: the one listed effect, amplifier and duration.
let test = |pred: &Value, e: &(String, i32, i32)| {
pred.as_object().is_some_and(|m| {
m.get(&e.0).is_some_and(|want| {
range_i(&want["amplifier"], i64::from(e.1))
&& range_i(&want["duration"], i64::from(e.2))
&& want["ambient"].as_bool().is_none_or(|b| !b)
&& want["visible"].as_bool().is_none_or(|b| b)
})
})
};
c["contains"]
.as_array()
.is_none_or(|l| l.iter().all(|p| effects.iter().any(|e| test(p, e))))
&& c["count"].as_array().is_none_or(|l| {
l.iter().all(|entry| {
let n = effects.iter().filter(|e| test(&entry["test"], e)).count();
range_i(&entry["count"], n as i64)
})
})
&& range_i(&c["size"], effects.len() as i64)
}
/// `ItemPredicate`.
pub fn item(v: &Value, it: &ItemView, w: &dyn World) -> bool {
if v.is_null() {
@@ -703,6 +748,52 @@ pub fn entity(v: &Value, e: &EntityView, w: &dyn World, origin: [f64; 3]) -> boo
}
true
}
/// A damage event as `DamagePredicate` sees it.
#[derive(Clone, Debug, Default)]
pub struct DamageView {
/// The damage type id (`minecraft:arrow`).
pub kind: String,
/// `DamageSource.getDirectEntity` and `getEntity`.
pub direct: Option<EntityView>,
pub source: Option<EntityView>,
/// `DamageSource.isDirect`: the direct entity is the causing one.
pub is_direct: bool,
/// The damage before and after the shield took its share.
pub original: f32,
pub actual: f32,
pub blocked: bool,
}
/// `DamagePredicate`, with its `DamageSourcePredicate` as `type`.
pub fn damage(v: &Value, d: &DamageView, w: &dyn World, origin: [f64; 3]) -> bool {
if v.is_null() {
return true;
}
let by = |key: &str, e: &Option<EntityView>| {
v[key].is_null() || e.as_ref().is_some_and(|e| entity(&v[key], e, w, origin))
};
if !range_f(&v["dealt"], f64::from(d.original))
|| !range_f(&v["taken"], f64::from(d.actual))
|| !by("source_entity", &d.source)
|| v["blocked"].as_bool().is_some_and(|b| b != d.blocked)
{
return false;
}
let ty = &v["type"];
let tags_ok = ty["tags"].as_array().into_iter().flatten().all(|t| {
let tag = t["id"].as_str().unwrap_or("");
let tag = tag.strip_prefix('#').unwrap_or(tag);
w.in_tag("damage_type", tag, &d.kind) == t["expected"].as_bool().unwrap_or(true)
});
let direct_ok = ty["direct_entity"].is_null()
|| d.direct
.as_ref()
.is_some_and(|e| entity(&ty["direct_entity"], e, w, origin));
let source_ok = ty["source_entity"].is_null()
|| d.source
.as_ref()
.is_some_and(|e| entity(&ty["source_entity"], e, w, origin));
tags_ok && direct_ok && source_ok && ty["is_direct"].as_bool().is_none_or(|b| b == d.is_direct)
}
/// The entities a loot-style condition list may refer to.
pub struct Entities<'a> {
pub this: Option<&'a EntityView>,
+137 -28
View File
@@ -36,8 +36,9 @@ enum Animate {
spawn_particles: bool,
},
/// Leaves: optional falling-leaf particle and chance; a tinted leaf takes
/// the biome foliage colour unless a fixed colour is given (azalea).
Leaves(Option<(T, f32)>, Option<u32>),
/// the biome foliage colour unless a fixed colour is given (azalea); and
/// whether they have the poplar ambient sound (`AmbientLeavesBlockSoundPlayer`).
Leaves(Option<(T, f32)>, Option<u32>, bool),
NetherPortal,
EnchantingTable,
EndRod([i32; 3]),
@@ -48,8 +49,9 @@ enum Animate {
CandleCake,
BrewingStand,
EnderChest,
/// FallingBlock with its dust colour.
Falling(u32),
/// FallingBlock with its dust colour; sand also has the ambient desert sound
/// (`SandBlock.animateTick`).
Falling(u32, bool),
/// A beehive or bee nest full of honey (`BeehiveBlock.animateTick`).
Beehive,
RedstoneOre,
@@ -109,17 +111,17 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
spawn_particles: false,
},
"oak_leaves" | "birch_leaves" | "jungle_leaves" | "acacia_leaves" | "dark_oak_leaves"
| "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01)), None),
"cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1)), None),
"pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02)), None),
"red_poplar_leaves" => Animate::Leaves(Some((T::RedPoplarLeaves, 0.01)), None),
"orange_poplar_leaves" => Animate::Leaves(Some((T::OrangePoplarLeaves, 0.01)), None),
"yellow_poplar_leaves" => Animate::Leaves(Some((T::YellowPoplarLeaves, 0.01)), None),
| "mangrove_leaves" => Animate::Leaves(Some((T::TintedLeaves, 0.01)), None, false),
"cherry_leaves" => Animate::Leaves(Some((T::CherryLeaves, 0.1)), None, false),
"pale_oak_leaves" => Animate::Leaves(Some((T::PaleOakLeaves, 0.02)), None, false),
"red_poplar_leaves" => Animate::Leaves(Some((T::RedPoplarLeaves, 0.01)), None, true),
"orange_poplar_leaves" => Animate::Leaves(Some((T::OrangePoplarLeaves, 0.01)), None, true),
"yellow_poplar_leaves" => Animate::Leaves(Some((T::YellowPoplarLeaves, 0.01)), None, true),
// The azalea blocks drop tinted leaves of the fixed colour -9399763.
"azalea_leaves" | "flowering_azalea_leaves" => {
Animate::Leaves(Some((T::TintedLeaves, 0.01)), Some(0x0070_922D))
Animate::Leaves(Some((T::TintedLeaves, 0.01)), Some(0x0070_922D), false)
}
"spruce_leaves" => Animate::Leaves(None, None),
"spruce_leaves" => Animate::Leaves(None, None, false),
"nether_portal" => Animate::NetherPortal,
"enchanting_table" => Animate::EnchantingTable,
"end_rod" => Animate::EndRod(facing()),
@@ -128,16 +130,17 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
"mycelium" => Animate::Mycelium,
"brewing_stand" => Animate::BrewingStand,
"ender_chest" => Animate::EnderChest,
"sand" => Animate::Falling(0xDBD3A0),
"red_sand" => Animate::Falling(0xA95821),
"gravel" => Animate::Falling(0x807C7B),
"sand" => Animate::Falling(0xDBD3A0, true),
"red_sand" => Animate::Falling(0xA95821, true),
"gravel" => Animate::Falling(0x807C7B, false),
// AnvilBlock/ConcretePowderBlock.getDustColor is the map colour;
// DragonEggBlock's is black.
"anvil" | "chipped_anvil" | "damaged_anvil" => Animate::Falling(0xA7A7A7),
"dragon_egg" => Animate::Falling(0x000000),
_ if name.ends_with("_concrete_powder") => Animate::Falling(concrete_powder_color(
name.trim_end_matches("_concrete_powder"),
)),
"anvil" | "chipped_anvil" | "damaged_anvil" => Animate::Falling(0xA7A7A7, false),
"dragon_egg" => Animate::Falling(0x000000, false),
_ if name.ends_with("_concrete_powder") => Animate::Falling(
concrete_powder_color(name.trim_end_matches("_concrete_powder")),
false,
),
"beehive" | "bee_nest" if prop("honey_level").as_deref() == Some("5") => Animate::Beehive,
"redstone_ore" | "deepslate_redstone_ore" if lit => Animate::RedstoneOre,
"redstone_wire" => {
@@ -171,8 +174,8 @@ fn classify(name: &str, prop: &dyn Fn(&str) -> Option<String>) -> Animate {
"end_portal" => Animate::EndPortal,
"wet_sponge" => Animate::WetSponge,
// BrushableBlock has no dust colour of its own, so the dust is the map colour.
"suspicious_sand" => Animate::Falling(0xF7E9A3),
"suspicious_gravel" => Animate::Falling(0x707070),
"suspicious_sand" => Animate::Falling(0xF7E9A3, false),
"suspicious_gravel" => Animate::Falling(0x707070, false),
"sculk_sensor" | "calibrated_sculk_sensor"
if prop("sculk_sensor_phase").as_deref() == Some("active") =>
{
@@ -239,6 +242,10 @@ pub struct AnimateTables {
power_transmitter: Vec<bool>,
/// `#triggers_ambient_dried_ghast_block_sounds` (soul sand, soul soil).
dried_ghast_sounds: Vec<bool>,
/// `#triggers_ambient_desert_sand_block_sounds` (sand, red sand).
desert_sand_sounds: Vec<bool>,
/// `#required_for_poplar_leaf_ambience` (overworld natural logs).
poplar_leaf_logs: Vec<bool>,
/// `FireBlock.canBurn`: states with ignite odds above zero (none waterlogged).
burnable: Vec<bool>,
/// Biome id -> ambient particles and probabilities (`minecraft:visual/ambient_particles`).
@@ -314,6 +321,8 @@ impl AnimateTables {
power_provider: by_state("minecraft:enchantment_power_provider"),
power_transmitter: by_state("minecraft:enchantment_power_transmitter"),
dried_ghast_sounds: by_state("minecraft:triggers_ambient_dried_ghast_block_sounds"),
desert_sand_sounds: by_state("minecraft:triggers_ambient_desert_sand_block_sounds"),
poplar_leaf_logs: by_state("minecraft:required_for_poplar_leaf_ambience"),
burnable,
ambient,
})
@@ -402,6 +411,10 @@ impl AnimateContext<'_> {
fn add(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
engine.add(&ParticleOptions::simple(ty), p, v);
}
/// `Level.addAlwaysVisibleParticle`: still shown under the Minimal option now and then.
fn add_visible(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
engine.add_with(&ParticleOptions::simple(ty), p, v, false, true);
}
fn sound(engine: &mut ParticleEngine, name: &'static str, p: [f64; 3], volume: f32, pitch: f32) {
engine.sounds.push((name, p, volume, pitch));
}
@@ -777,7 +790,7 @@ fn block_animate_tick(
}
}
}
Animate::Leaves(falling, fixed_tint) => {
Animate::Leaves(falling, fixed_tint, poplar) => {
let below = [pos[0], pos[1] - 1, pos[2]];
// LeavesBlock.makeDrippingWaterParticles.
if (ctx.raining_at)([pos[0], pos[1] + 1, pos[2]]) && next_int(engine.random(), 15) == 1
@@ -789,6 +802,9 @@ fn block_animate_tick(
add(engine, T::DrippingWater, p, [0.0; 3]);
}
}
if poplar {
leaves_ambient_sound(tables, engine, ctx, state, pos);
}
// FallingParticlesLeavesBlock.makeFallingLeavesParticles.
if let Some((ty, chance)) = falling
&& engine.random().next_float() < chance
@@ -961,7 +977,7 @@ fn block_animate_tick(
fy + 1.0 + f64::from(r.next_float()),
fz + f64::from(r.next_float()),
];
add(engine, T::SulfurBubbles, p, [0.0; 3]);
add_visible(engine, T::SulfurBubbles, p, [0.0; 3]);
}
if next_int(engine.random(), 10) == 0 {
let name = "minecraft:block.potent_sulfur.noxious_gas";
@@ -1081,7 +1097,7 @@ fn block_animate_tick(
add(engine, T::Portal, p, v);
}
}
Animate::Falling(color) => {
Animate::Falling(color, sand) => {
if next_int(engine.random(), 16) == 0 {
let below = ctx.facts.get(ctx.state([pos[0], pos[1] - 1, pos[2]]));
// FallingBlock.isFree: air, fire, liquids or replaceable.
@@ -1098,6 +1114,14 @@ fn block_animate_tick(
);
}
}
// AmbientDesertBlockSoundsPlayer.playAmbientSandSounds: only for the air block.
if sand
&& ctx.state([pos[0], pos[1] + 1, pos[2]]) == ctx.world.air
&& next_int(engine.random(), 2100) == 0
&& sand_sound_nearby(tables, ctx, pos)
{
sound(engine, "minecraft:block.sand.idle", [fx, fy, fz], 1.0, 1.0);
}
}
Animate::Beehive => {
// BeehiveBlock.animateTick: nextInt(1) + 1 attempts.
@@ -1215,7 +1239,7 @@ fn block_animate_tick(
}
Animate::BubbleColumn { drag } => {
if drag {
add(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]);
add_visible(engine, T::CurrentDown, [fx + 0.5, fy + 0.8, fz], [0.0; 3]);
let r = engine.random();
if next_int(r, 200) == 0 {
let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15);
@@ -1228,7 +1252,7 @@ fn block_animate_tick(
);
}
} else {
add(
add_visible(
engine,
T::BubbleColumnUp,
[fx + 0.5, fy, fz + 0.5],
@@ -1240,7 +1264,7 @@ fn block_animate_tick(
fy + f64::from(r.next_float()),
fz + f64::from(r.next_float()),
];
add(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]);
add_visible(engine, T::BubbleColumnUp, p, [0.0, 0.04, 0.0]);
let r = engine.random();
if next_int(r, 200) == 0 {
let (volume, pitch) = (0.2 + r.next_float() * 0.2, 0.9 + r.next_float() * 0.15);
@@ -1318,6 +1342,91 @@ fn block_animate_tick(
}
}
}
/// `AmbientLeavesBlockSoundPlayer.playAmbientLeavesSounds` for the poplar leaves:
/// one log and three leaves of the same kind around the block.
fn leaves_ambient_sound(
tables: &AnimateTables,
engine: &mut ParticleEngine,
ctx: &AnimateContext,
state: BlockStateId,
pos: [i32; 3],
) {
if next_int(engine.random(), 300) != 0 {
return;
}
let Some(name) = ctx.registry.state(state).map(|s| &s.name) else {
return;
};
let (mut logs, mut leaves) = (0, 0);
for d in [[0, -1], [1, 0], [0, 1], [-1, 0]] {
let neighbor = ctx.state([pos[0] + d[0], pos[1], pos[2] + d[1]]);
if tables
.poplar_leaf_logs
.get(neighbor.0 as usize)
.copied()
.unwrap_or(false)
{
logs += 1;
}
if ctx
.registry
.state(neighbor)
.is_some_and(|s| &s.name == name)
{
leaves += 1;
}
if logs == 1 && leaves == 3 {
let p = pos.map(f64::from);
sound(engine, "minecraft:block.poplar_leaves.ambient", p, 1.0, 1.0);
return;
}
}
}
/// `AmbientDesertBlockSoundsPlayer.shouldPlayAmbientSandSound`: sand in the
/// surface column eight blocks away on all four sides.
fn sand_sound_nearby(tables: &AnimateTables, ctx: &AnimateContext, pos: [i32; 3]) -> bool {
let is_sand = |p: [i32; 3]| {
tables
.desert_sand_sounds
.get(ctx.state(p).0 as usize)
.copied()
.unwrap_or(false)
};
let (mut found, mut checked) = (0, 0);
for d in [[0, -8], [8, 0], [0, 8], [-8, 0]] {
let (x, z) = (pos[0] + d[0], pos[2] + d[1]);
// columnContainsTriggeringBlock.
let surface = ctx.world.world_surface(x, z, |s| ctx.facts.is_air(s)) - 1;
let matches = if (surface - pos[1]).abs() > 5 {
let mut y = pos[1] + 6;
let mut above_air = ctx.is_air([x, y, z]);
y -= 1;
let mut hit = false;
for _ in 0..10 {
if above_air && is_sand([x, y, z]) {
hit = true;
break;
}
above_air = ctx.is_air([x, y, z]);
y -= 1;
}
hit
} else {
ctx.is_air([x, surface + 1, z]) && is_sand([x, surface, z])
};
if matches {
found += 1;
if found > 3 {
return true;
}
}
checked += 1;
if 4 - checked + found < 3 {
return false;
}
}
false
}
/// `AbstractCandleBlock.addParticlesAndSound`.
fn candle(engine: &mut ParticleEngine, p: [f64; 3]) {
let r = engine.random();
+1 -1
View File
@@ -3,8 +3,8 @@
//! `filter`, `unstitch` and `paletted_permutations` sources run in order
//! against the resource tree; a later source replaces an earlier sprite of
//! the same id and a filter removes the matching ones.
use crate::packs::pattern::Pattern;
use horizon_assets::palette::apply_palette;
use horizon_client_core::pattern::Pattern;
use serde_json::Value;
use std::{
collections::BTreeMap,
+56 -1
View File
@@ -2,6 +2,7 @@
//! threads can mesh and light immutable snapshots while the game thread edits
//! (copy-on-write through `Arc::make_mut`).
use horizon_core::paletted::{PalettedContainer, Strategy};
use horizon_world::nbt::{Compound, Tag};
use horizon_world::registry::BlockStateId;
use std::sync::{Arc, OnceLock};
@@ -155,7 +156,7 @@ pub struct Chunk {
/// positions, applied once by LevelChunk.postProcessGeneration.
pub postprocess: Vec<[i32; 3]>,
/// Saved data Horizon keeps but does not simulate (save.rs).
pub saved: Option<Arc<crate::save::ChunkExtras>>,
pub saved: Option<Arc<ChunkExtras>>,
/// Entities read from a save (vanilla entity NBT), spawned on arrival.
pub entities: Vec<horizon_world::nbt::Tag>,
/// Structure starts reaching into this chunk (`structures.References`):
@@ -432,3 +433,57 @@ mod tests {
}
}
}
/// A container's loot table and what Horizon rolled from it. Vanilla keeps
/// `LootTable` and `LootTableSeed` until the container is first opened;
/// Horizon rolls when it generates or loads the chunk, and saves the table
/// again while the container still holds exactly the rolled items.
#[derive(Clone, Debug, PartialEq)]
pub struct RolledLoot {
pub pos: (i32, i32, i32),
pub table: String,
/// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
pub seed: Option<i64>,
/// The rolled `Items`.
pub items: Tag,
}
impl RolledLoot {
/// Puts the loot table back in place of `Items` while they are still the
/// roll; false once the container holds anything else.
pub fn restore(&self, map: &mut Compound) -> bool {
if map.get(&"Items".into()) != Some(&self.items) {
return false;
}
map.remove(&"Items".into());
map.insert("LootTable".into(), Tag::String(self.table.as_str().into()));
if let Some(seed) = self.seed.filter(|s| *s != 0) {
map.insert("LootTableSeed".into(), Tag::Long(seed));
}
true
}
}
/// Save data loaded with a chunk that Horizon keeps but does not simulate.
#[derive(Clone, Debug, Default)]
pub struct ChunkExtras {
/// Chunk root keys written back as loaded (structures, PostProcessing,
/// InhabitedTime, blending data, ...).
pub root: Compound,
/// Block entities Horizon does not model.
pub block_entities: Vec<Tag>,
/// The NBT of the modelled block entities as loaded, to restore the fields and
/// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
/// Every saved block entity's position in the order of the save's list,
/// the order `SerializableChunkData` puts them in the chunk's maps.
pub block_entity_order: Vec<(i32, i32, i32)>,
/// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
/// save time. Registered with the level's tick scheduler on arrival and
/// replaced with the scheduler's pending ticks when saving.
pub block_ticks: Vec<horizon_core::ticks::SavedTick>,
pub fluid_ticks: Vec<horizon_core::ticks::SavedTick>,
/// Game time written as `LastUpdate`.
pub last_update: i64,
/// Containers still holding their loot table's roll.
pub rolled_loot: Vec<RolledLoot>,
}
+16
View File
@@ -98,10 +98,19 @@ pub enum BlockEntity {
Campfire(Box<Campfire>),
/// `SkullBlockEntity` of every skull and head block.
Skull(Skull),
/// `TheEndGatewayBlockEntity`: its age and configured destination.
EndGateway(EndGateway),
/// `DaylightDetectorBlockEntity`: no data, only the ticker
/// (`DaylightDetectorBlock.tickEntity`).
DaylightDetector,
}
/// `TheEndGatewayBlockEntity`.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct EndGateway {
pub age: i64,
pub exit_portal: Option<[i32; 3]>,
pub exact_teleport: bool,
}
/// `CampfireBlockEntity`: four cooking slots, each with its
/// `cookingProgress` and `cookingTime` (the recipe's).
#[derive(Clone, Debug, Default, PartialEq)]
@@ -380,6 +389,9 @@ impl BlockEntity {
if is_skull(name) {
return Some(Self::Skull(Skull::default()));
}
if name == "minecraft:end_gateway" {
return Some(Self::EndGateway(EndGateway::default()));
}
if name == "minecraft:daylight_detector" {
return Some(Self::DaylightDetector);
}
@@ -432,6 +444,7 @@ impl BlockEntity {
Self::Beehive(_) => "minecraft:beehive",
Self::CommandBlock(_) => "minecraft:command_block",
Self::Skull(_) => "minecraft:skull",
Self::EndGateway(_) => "minecraft:end_gateway",
Self::DaylightDetector => "minecraft:daylight_detector",
Self::Campfire(_) => "minecraft:campfire",
}
@@ -450,6 +463,7 @@ impl BlockEntity {
| Self::Vault(_)
| Self::Beehive(_)
| Self::CommandBlock(_)
| Self::EndGateway(_)
| Self::Skull(_)
| Self::DaylightDetector => Vec::new(),
Self::Lectern(l) => l.book.iter().cloned().collect(),
@@ -470,6 +484,7 @@ impl BlockEntity {
| Self::Lectern(_)
| Self::Sculk(_)
| Self::Banner(_)
| Self::EndGateway(_)
| Self::Skull(_)
| Self::DaylightDetector => &[],
Self::Crafter(c) => &c.items,
@@ -494,6 +509,7 @@ impl BlockEntity {
| Self::Lectern(_)
| Self::Sculk(_)
| Self::Banner(_)
| Self::EndGateway(_)
| Self::Skull(_)
| Self::DaylightDetector => &mut [],
Self::Crafter(c) => &mut c.items,
+14
View File
@@ -244,6 +244,20 @@ fn celestial_color(in: Out) -> vec4<f32> {
return vec4(added, smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b))));
}
// RenderPipelines.ENERGY_SWIRL (entity.fsh with EMISSIVE and NO_OVERLAY): the sprite, scrolled by
// the UV and repeated within itself, times the layer colour 0xFF808080, unlit; the pipeline adds
// it to the frame. The light bytes carry the sprite's origin and the colour bytes its size, both
// as breaking::stage_light packs them.
@fragment fn fs_energy_swirl(in: Out) -> @location(0) vec4<f32> {
let bytes = round(in.color * 255.0);
let size = vec2(bytes.x + bytes.y * 256.0, bytes.z + bytes.w * 256.0) / 65535.0;
let color = textureSample(atlas, atlas_sampler, crumbling_uv(in.uv, in.wrap, size, textureDimensions(atlas)));
if color.a < 0.1 { discard; }
let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
return vec4(mix(color.rgb * (128.0 / 255.0), globals.fog_color.rgb, f * globals.fog_color.a), color.a);
}
// RenderPipelines.WATER_MASK: depth only (the pipeline masks the colour off).
@fragment fn fs_water_mask() -> @location(0) vec4<f32> {
return vec4(0.0);
+10
View File
@@ -577,6 +577,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
map.insert("anger".into(), Tag::compound(Vec::<(&str, Tag)>::new()));
}
}
// Armadillo.addAdditionalSaveData: the time left to the next scute.
"minecraft:armadillo" => {
map.insert("scute_time".into(), Tag::Int(m.extra.egg_time));
}
"minecraft:ravager" => {
map.insert("AttackTick".into(), Tag::Int(m.extra.counter));
map.insert("StunTick".into(), Tag::Int(m.extra.counter2));
@@ -1198,6 +1202,12 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
st.vibration = crate::sculk::Data::from_nbt(listener);
}
}
// Armadillo.readAdditionalSaveData: keeps the constructor's time when absent.
if m.species() == crate::mobs::Species::Armadillo
&& let Some(t) = number(tag.get("scute_time"))
{
m.extra.egg_time = t as i32;
}
if m.species() == crate::mobs::Species::Ravager {
m.extra.counter = number(tag.get("AttackTick")).unwrap_or(0) as i32;
m.extra.counter2 = number(tag.get("StunTick")).unwrap_or(0) as i32;
+66 -67
View File
@@ -1609,6 +1609,12 @@ struct Game<'a> {
/// Map textures waiting for the next HUD batch to upload them.
map_patches: Vec<horizon_client::font::Patch>,
text_displays: std::collections::HashMap<i32, text_displays::RemoteTextDisplay>,
/// The fence knots a server tracks to this client, by entity id, at their
/// block (`LeashFenceKnotEntity`).
remote_knots: HashMap<u32, [i32; 3]>,
/// The entity ids a hosted server gives the knots its mobs hang on, by
/// block, while a lead is tied there.
knot_ids: HashMap<[i32; 3], u32>,
text_display_vertices: usize,
/// Player skin downloads, and which skin each atlas skin slot holds
/// (least recently shown first).
@@ -2517,6 +2523,15 @@ impl Game<'_> {
no_physics,
&self.res.motion().fluids,
);
// Entity.applyEffectsFromBlocks: bubble columns lift or drag the item.
horizon_client::motion::bubble_column_push(
&self.world,
self.pack.assets.registry,
self.res.facts(),
self.collision,
item.bounds(),
&mut item.velocity,
);
cells.moved(i, item.previous, item.position);
// ItemEntity.tick: merge every 2 ticks while moving between
// blocks, every 40 otherwise, before the lifetime check.
@@ -2787,9 +2802,13 @@ impl Game<'_> {
self.process_level_events()
}
fn attack_block(&mut self, pos: [i32; 3]) -> Result<()> {
self.with_level(|b, level, ticks| {
b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]));
let note = self.with_level(|b, level, ticks| {
b.attack_block(level, ticks, BlockPos::new(pos[0], pos[1], pos[2]))
});
// NoteBlock.attack awards the statistic.
if note {
self.stats.custom("play_noteblock", 1);
}
self.process_level_events()
}
/// Track which chunks are ticking (Ticks needs chunk load/unload).
@@ -3459,15 +3478,9 @@ impl Game<'_> {
self.open_ender_chest(key);
// EnderChestBlock.useWithoutItem
self.stats.custom("open_enderchest", 1);
self.container_opener_event(key, true);
let at = [
f64::from(key.0) + 0.5,
f64::from(key.1) + 0.5,
f64::from(key.2) + 0.5,
];
let pitch = self.world.random.next_float() * 0.1 + 0.9;
self.audio
.play("minecraft:block.ender_chest.open", Some(at), 0.5, pitch);
if self.container_opener_event(key, true) {
self.container_edge_sound(key, true);
}
} else if &*name == "minecraft:beacon" && self.open_station(pos, &name) {
self.world.block_entities.get_or_insert_with(key, || {
BlockEntity::for_block(&name).unwrap_or(BlockEntity::Chest(Vec::new()))
@@ -3483,7 +3496,7 @@ impl Game<'_> {
];
self.resolve_container_maps(key, centre);
self.container = Some(key);
self.container_opener_event(key, true);
let first = self.container_opener_event(key, true);
self.post_block_game_event(
"minecraft:container_open",
[key.0, key.1, key.2],
@@ -3507,26 +3520,8 @@ impl Game<'_> {
if self.guarded_by_piglins(&name) {
self.anger_piglins(true);
}
let sound = if storage::is_shulker_box(&name) {
Some("minecraft:block.shulker_box.open")
} else if name.contains("chest") {
Some("minecraft:block.chest.open")
} else if &*name == "minecraft:barrel" {
Some("minecraft:block.barrel.open")
} else {
None
};
if let Some(sound) = sound {
self.audio.play(
sound,
Some([
f64::from(key.0) + 0.5,
f64::from(key.1) + 0.5,
f64::from(key.2) + 0.5,
]),
0.5,
1.0,
);
if first {
self.container_edge_sound(key, true);
}
} else if self.open_station(pos, &name) {
// Workstation menus: game/stations.rs.
@@ -4010,6 +4005,10 @@ impl Game<'_> {
self.swing_arm();
return Ok(true);
}
if self.use_beehive(hit.pos, held.as_ref())? {
self.swing_arm();
return Ok(true);
}
if self.use_campfire_douse(hit.pos, held.as_ref())? {
self.swing_arm();
return Ok(true);
@@ -5858,6 +5857,7 @@ impl Game<'_> {
| BlockEntity::Vault(_)
| BlockEntity::Beehive(_)
| BlockEntity::CommandBlock(_)
| BlockEntity::EndGateway(_)
| BlockEntity::Skull(_)
| BlockEntity::DaylightDetector
| BlockEntity::Campfire(_),
@@ -6130,6 +6130,7 @@ impl Game<'_> {
| BlockEntity::Vault(_)
| BlockEntity::Beehive(_)
| BlockEntity::CommandBlock(_)
| BlockEntity::EndGateway(_)
| BlockEntity::Skull(_)
| BlockEntity::DaylightDetector
| BlockEntity::Campfire(_),
@@ -6211,41 +6212,15 @@ impl Game<'_> {
if let Some(key) = self.container.take() {
// A cart's or chest boat's items go back to it.
self.close_cart_container(key);
self.container_opener_event(key, false);
let last = self.container_opener_event(key, false);
self.post_block_game_event(
"minecraft:container_close",
[key.0, key.1, key.2],
Some(horizon_client::mobs::Who::Player),
None,
);
let name = self
.res
.facts()
.get(self.world.block(key.0, key.1, key.2))
.name
.clone();
let sound = if storage::is_shulker_box(&name) {
Some("minecraft:block.shulker_box.close")
} else if &*name == "minecraft:ender_chest" {
Some("minecraft:block.ender_chest.close")
} else if name.contains("chest") {
Some("minecraft:block.chest.close")
} else if &*name == "minecraft:barrel" {
Some("minecraft:block.barrel.close")
} else {
None
};
if let Some(sound) = sound {
self.audio.play(
sound,
Some([
f64::from(key.0) + 0.5,
f64::from(key.1) + 0.5,
f64::from(key.2) + 0.5,
]),
0.5,
1.0,
);
if last {
self.container_edge_sound(key, false);
}
self.world.modified.insert((key.0 >> 4, key.2 >> 4));
}
@@ -6765,6 +6740,7 @@ impl Game<'_> {
self.player_menu_sound(sound);
}
let crafted = std::mem::take(&mut menu.crafted);
let brewed = std::mem::take(&mut menu.brewed);
let equipped = std::mem::take(&mut menu.equipped);
for (i, stack) in after.into_iter().enumerate() {
if let Some(g) = game_of[i] {
@@ -6780,6 +6756,9 @@ impl Game<'_> {
self.player_drop(stack);
}
self.award_crafted(&crafted);
for stack in &brewed {
self.trigger_brewed_potion(stack);
}
if furnace_before > furnace_after
&& self.remote.is_none()
&& let (Some(pos), Some(p)) = (self.container, self.player.as_ref())
@@ -8276,6 +8255,15 @@ impl Game<'_> {
None => horizon_client::mobs::Damage::of(horizon_client::mobs::DamageKind::Generic),
};
let landed = self.hurt_by_player(index, amount, source);
if landed {
let victim = self.mob_entity(&self.mobs[index]);
self.player_hit(
&victim,
creatures::damage_type(source.kind, true),
None,
amount,
);
}
if let Some(p) = self.player.as_mut() {
if p.attack_log.len() >= 64 {
p.attack_log.remove(0);
@@ -8369,15 +8357,24 @@ impl Game<'_> {
// The hurt or death sound the mob raised (getHurtSound / getDeathSound,
// its voice pitch from its own random).
let queued = std::mem::take(&mut self.mobs[index].outbox);
let mut infested = false;
for event in queued {
if let horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) = event {
self.audio
.play(&format!("minecraft:{s}"), Some(at), volume, pitch);
} else {
// Left for the end of the tick.
self.mobs[index].outbox.push(event);
match event {
horizon_client::mobs::MobEvent::Sound(s, at, volume, pitch) => {
self.audio
.play(&format!("minecraft:{s}"), Some(at), volume, pitch);
}
horizon_client::mobs::MobEvent::Infested { .. } => infested = true,
other => {
// Left for the end of the tick.
self.mobs[index].outbox.push(other);
}
}
}
if infested {
let id = self.mobs[index].id;
self.mob_infested(id);
}
self.weapon_hit(index);
// Player.attack: causeFoodExhaustion(0.1F) only when the hit hurt
// (inside `if (wasHurt)`), after damageStatsAndHearts.
@@ -13348,6 +13345,8 @@ impl<'a> Game<'a> {
dragon_model: prepared.dragon_model,
map_patches: Vec::new(),
text_displays: Default::default(),
remote_knots: Default::default(),
knot_ids: Default::default(),
text_display_vertices: 0,
skin_downloads: RefCell::new(horizon_client::skins::Downloader::new(
std::env::current_dir()
@@ -180,6 +180,14 @@ impl adv::World for View<'_, '_> {
"block" => items.block_tags.get(tag).is_some_and(|t| t.contains(id)),
"entity_type" => self.0.res.mob_data().entity_has(tag, id),
"worldgen/biome" => self.0.res.mob_data().biome_has(tag, id),
"damage_type" => self
.0
.res
.stations()
.enchantments
.damage_tags
.get(tag)
.is_some_and(|t| t.contains(id)),
_ => false,
}
}
@@ -681,6 +689,69 @@ impl Game<'_> {
adv::conditions(&c["player"], &pctx, w) && adv::conditions(&c[&key], &ectx, w)
});
}
/// `PlayerHurtEntityTrigger`: the player, the damage and the victim.
pub(super) fn trigger_player_hurt_entity(
&mut self,
victim: &EntityView,
damage: &adv::DamageView,
) {
let me = self.player_entity();
let (victim, damage) = (victim.clone(), damage.clone());
self.trigger("minecraft:player_hurt_entity", move |c, w| {
let pctx = adv::Entities {
this: Some(&me),
origin: me.position,
tool: None,
block_pos: None,
};
let vctx = adv::Entities {
this: Some(&victim),
..pctx
};
adv::conditions(&c["player"], &pctx, w)
&& adv::damage(&c["damage"], &damage, w, me.position)
&& adv::conditions(&c["entity"], &vctx, w)
});
}
/// The player's hit on `victim` as `LivingEntity.hurtServer` reports it:
/// `kind` damage of `amount` from `direct` (the player's own hand when
/// `None`), nothing blocked.
pub(super) fn player_hit(
&mut self,
victim: &EntityView,
kind: &str,
direct: Option<EntityView>,
amount: f32,
) {
let me = self.player_entity();
self.trigger_player_hurt_entity(
victim,
&adv::DamageView {
kind: kind.to_owned(),
is_direct: direct.is_none(),
direct: direct.or_else(|| Some(me.clone())),
source: Some(me),
original: amount,
actual: amount,
blocked: false,
},
);
}
/// `EntityHurtPlayerTrigger`: the player and the damage it took.
pub(super) fn trigger_entity_hurt_player(&mut self, damage: &adv::DamageView) {
let me = self.player_entity();
let damage = damage.clone();
self.trigger("minecraft:entity_hurt_player", move |c, w| {
let pctx = adv::Entities {
this: Some(&me),
origin: me.position,
tool: None,
block_pos: None,
};
adv::conditions(&c["player"], &pctx, w)
&& adv::damage(&c["damage"], &damage, w, me.position)
});
}
/// A player condition plus one item (`item` key).
pub(super) fn trigger_item(&mut self, name: &str, stack: &ItemStack) {
let me = self.player_entity();
@@ -724,6 +795,22 @@ impl Game<'_> {
&& adv::range_i(&c["levels"], i64::from(levels))
});
}
/// `BrewedPotionTrigger`: the potion contents of a stack taken from a
/// brewing stand.
pub(super) fn trigger_brewed_potion(&mut self, stack: &ItemStack) {
let me = self.player_entity();
let potion = stack.potion().map(str::to_owned);
self.trigger("minecraft:brewed_potion", move |c, w| {
let pctx = adv::Entities {
this: Some(&me),
origin: me.position,
tool: None,
block_pos: None,
};
adv::conditions(&c["player"], &pctx, w)
&& adv::potions(&c["potion"], potion.as_deref(), w)
});
}
/// `TradeTrigger`: the villager and the item the trade gave.
pub(super) fn trigger_trade(&mut self, villager: &EntityView, stack: &ItemStack) {
let me = self.player_entity();
@@ -745,6 +832,35 @@ impl Game<'_> {
&& adv::item(&c["item"], &it, w)
});
}
/// `FishingRodHookedTrigger`: the rod, what the hook is in (or the hook)
/// and the items it caught.
pub(super) fn trigger_fishing_rod_hooked(
&mut self,
rod: &ItemStack,
hooked: &EntityView,
items: &[ItemStack],
) {
let me = self.player_entity();
let rod = item_view(rod);
let hooked = hooked.clone();
let items: Vec<ItemView> = items.iter().map(item_view).collect();
self.trigger("minecraft:fishing_rod_hooked", move |c, w| {
let pctx = adv::Entities {
this: Some(&me),
origin: me.position,
tool: None,
block_pos: None,
};
let ectx = adv::Entities {
this: Some(&hooked),
..pctx
};
adv::conditions(&c["player"], &pctx, w)
&& adv::item(&c["rod"], &rod, w)
&& adv::conditions(&c["entity"], &ectx, w)
&& (c["item"].is_null() || items.iter().any(|i| adv::item(&c["item"], i, w)))
});
}
/// `EnterBlockTrigger`: the block, its state properties and the player.
pub(super) fn trigger_enter_block(&mut self, state: horizon_world::registry::BlockStateId) {
let Some(definition) = self.pack.assets.registry.state(state).cloned() else {
+16
View File
@@ -568,6 +568,22 @@ impl Game<'_> {
"generate_structures": options.structures,
"bonus_chest": options.bonus_chest(),
}),
Mode::CreateFlat {
name,
seed,
options,
flat,
..
} => json!({
"mode": "customize-flat",
"fields": { "name": name, "seed": seed },
"superflat": options.flat,
"biome": flat.settings().biome,
"layers": flat.settings().layers.iter().map(|layer| json!({
"block": layer.block,
"height": layer.height,
})).collect::<Vec<_>>(),
}),
Mode::Edit {
world,
name,
+1 -1
View File
@@ -161,7 +161,7 @@ impl Game<'_> {
}
// Allay.duplicateAllay: entity event 18, three spawnHeartParticle.
let id = self.mobs[index].id;
self.particles_around_mob(id, "heart", horizon_client::particles::Burst::ALLAY);
self.mob_event_particles(id, 18);
self.audio
.play("minecraft:block.amethyst_block.chime", Some(at), 2.0, 1.0);
self.consume_held();
+138 -5
View File
@@ -3,8 +3,10 @@
//! player breaks the hive or fire reaches it.
use super::Game;
use horizon_client::{
Result,
beehive::{self, Beehive, HiveHost, Release},
containers::BlockEntity,
items::ItemStack,
mobs::{Mob, Who, bee},
};
use horizon_core::{
@@ -194,19 +196,139 @@ impl Game<'_> {
}
self.anger_nearby_bees(at);
}
/// `BeehiveBlock.useItemOn` with `held` in the acting hand: shears take
/// the honeycombs and a glass bottle a honey bottle from a full hive
/// (honey level 5), then the honey level resets and, unless a campfire
/// smokes the hive, the bees come out angry. True when it took the click.
pub(super) fn use_beehive(&mut self, pos: [i32; 3], held: Option<&ItemStack>) -> Result<bool> {
let Some(held) = held else { return Ok(false) };
let shears = &*held.item == "minecraft:shears";
if !shears && &*held.item != "minecraft:glass_bottle" {
return Ok(false);
}
let state = self.world.block(pos[0], pos[1], pos[2]);
if !matches!(
&*self.res.facts().get(state).name,
"minecraft:beehive" | "minecraft:bee_nest"
) {
return Ok(false);
}
let prop = |key: &str| {
self.pack
.assets
.registry
.state(state)
.and_then(|s| s.properties.get(key).cloned())
};
if prop("honey_level").and_then(|v| v.parse::<i32>().ok()) != Some(5) {
return Ok(false);
}
let facing = beehive::facing_step(prop("facing").as_deref());
let at = self
.player
.as_ref()
.map(|p| [p.position.x, p.position.y, p.position.z]);
if shears {
// dropHoneycomb (harvest/beehive), the shear sound, hurtAndBreak.
for stack in self.sequence_loot(
"minecraft:harvest/beehive",
"minecraft:harvest/beehive",
Some(held),
) {
self.pop_resource(pos, stack);
}
self.audio
.play("minecraft:block.beehive.shear", at, 1.0, 1.0);
self.damage_held(1);
self.post_block_game_event("minecraft:shear", pos, self.sculk_actor(), None);
} else {
// shrink(1), then the honey bottle in the hand, the inventory or
// on the ground.
self.audio.play("minecraft:item.bottle.fill", at, 1.0, 1.0);
let cell = self.held_mut();
if let Some(s) = cell.as_mut() {
s.count -= 1;
if s.count == 0 {
*cell = None;
}
}
let bottle = ItemStack::new("minecraft:honey_bottle", 1);
if self.held().is_none() {
*self.held_mut() = Some(bottle);
} else if let Some(rest) = self.give(bottle)
&& let Some(eye) = self.eye_position()
{
self.spawn_item(rest, eye, [0.0, 0.1, 0.0], 40);
}
self.post_block_game_event("minecraft:fluid_pickup", pos, self.sculk_actor(), None);
}
self.stats.add("used", &held.item, 1);
let smokey = beehive::smokey(&self.mob_world_base(&[]), pos);
let key = (pos[0], pos[1], pos[2]);
if !smokey
&& matches!(self.world.block_entities.get(&key), Some(BlockEntity::Beehive(h)) if !h.bees.is_empty())
{
self.anger_nearby_bees(pos);
}
// resetHoneyLevel.
if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) {
self.level_set(pos, reset)?;
}
if !smokey
&& let Some(BlockEntity::Beehive(mut hive)) = self.world.block_entities.take(&key)
{
// emptyAllLivingFromHive: the bees within 4 blocks of the player
// go for them.
let released = hive.release_all(
pos,
facing,
None,
Release::Emergency,
&mut GameHive { game: self },
);
self.world
.block_entities
.put(key, BlockEntity::Beehive(hive));
if let Some(p) = self.player_view().map(|p| p.position) {
for m in self.mobs.iter_mut().filter(|m| released.contains(&m.id)) {
if m.distance_sqr(p) <= 16.0 {
m.ai.target = Some(Who::Player);
}
}
}
}
// ServerPlayerGameMode.useItemOn: the action was consumed.
self.trigger_block("minecraft:item_used_on_block", pos, held);
Ok(true)
}
/// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down)
/// without a target go for a player in the same box.
fn anger_nearby_bees(&mut self, at: [i32; 3]) {
/// without a target go for a random player in the same box, the window's
/// own or a guest (`None` is the window's player).
pub(super) fn anger_nearby_bees(&mut self, at: [i32; 3]) {
let min = Vec3::new(
f64::from(at[0]) - 8.0,
f64::from(at[1]) - 6.0,
f64::from(at[2]) - 8.0,
);
let area = Aabb::new(min, Vec3::new(min.x + 17.0, min.y + 13.0, min.z + 17.0));
if !self
let mut players: Vec<Option<u32>> = Vec::new();
if self
.player_view()
.is_some_and(|p| p.bounds.intersects(area))
{
players.push(None);
}
if let Some(host) = self.lan.as_ref() {
players.extend(
host.hub
.guests
.iter()
.filter(|g| host.hub.here(g) && g.loaded && !g.dead)
.filter(|g| super::lan_mobs::guest_bounds(g).intersects(area))
.map(|g| Some(g.conn)),
);
}
if players.is_empty() {
return;
}
let mut bees: Vec<usize> = (0..self.mobs.len())
@@ -219,9 +341,20 @@ impl Game<'_> {
.collect();
bees.retain(|&i| self.mobs[i].ai.target.is_none());
for i in bees {
// Util.getRandom over the one player.
let _ = self.world.random.next_int_bound(1);
// Util.getRandom over the players.
let pick = self
.world
.random
.next_int_bound(players.len() as i32)
.unwrap_or(0) as usize;
self.mobs[i].ai.target = Some(Who::Player);
// The player a mob sees is its guest binding, else the window's.
if let Some(host) = self.lan.as_mut() {
match players[pick] {
Some(conn) => host.mob_players.insert(self.mobs[i].id, conn),
None => host.mob_players.remove(&self.mobs[i].id),
};
}
}
}
}
@@ -76,23 +76,24 @@ impl Game<'_> {
/// A player opened (`open`) or closed the container at `key`: the opener
/// count block event (`ContainerOpenersCounter` / `ShulkerBoxBlockEntity`
/// `startOpen`/`stopOpen`) for chests, ender chests and shulker boxes,
/// on both halves of a double chest (`CompoundContainer`).
pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) {
/// on both halves of a double chest (`CompoundContainer`). True when the
/// count went from 0 to 1 or back to 0: the only moments the container
/// plays its open or close sound.
pub(super) fn container_opener_event(&mut self, key: (i32, i32, i32), open: bool) -> bool {
// Spectators never count as openers.
if !self.spectator() {
self.container_openers_changed(key, open);
}
!self.spectator() && self.container_openers_changed(key, open)
}
/// `container_opener_event` for a player who is not a spectator (a guest).
pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
pub(super) fn container_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
let pos = [key.0, key.1, key.2];
let state = self.world.block(pos[0], pos[1], pos[2]).0;
match self.be_anims.ticker(state) {
Some(Ticker::Lid) => {
self.lid_openers_changed(key, open);
let edge = self.lid_openers_changed(key, open);
if let Some(other) = self.chest_other_half(key) {
self.lid_openers_changed(other, open);
}
edge
}
_ if self
.res
@@ -102,26 +103,27 @@ impl Game<'_> {
.as_ref()
== "minecraft:barrel" =>
{
self.barrel_openers_changed(key, open);
self.barrel_openers_changed(key, open)
}
Some(Ticker::Shulker { .. }) => {
let shulker = self.be_anims.shulkers.entry(pos).or_default();
let (count, _) = if open {
let (count, edge) = if open {
shulker.start_open()
} else {
shulker.stop_open()
};
self.block_entity_event(pos, 1, count);
self.lan_block_event(pos, 1, count);
edge
}
_ => {}
_ => false,
}
}
/// `ContainerOpenersCounter.incrementOpeners` / `decrementOpeners` of the
/// chest at `key` (the host and the guests are counted), then
/// `ChestBlockEntity.signalOpenCount`: block event 1 with the count, here
/// and for the guests.
fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
/// and for the guests. True when the count crossed zero.
fn lid_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
let (before, count) = self.count_opener(key, open);
let pos = [key.0, key.1, key.2];
self.block_entity_event(pos, 1, count);
@@ -139,12 +141,15 @@ impl Game<'_> {
b.update_neighbors_at(level, ticks, p.offset(0, -1, 0), block);
});
}
(before == 0) != (count == 0)
}
/// `BarrelBlockEntity.openersCounter`: the first opener opens the barrel
/// (`open=true`), the last one to leave closes it (`updateBlockState`).
fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) {
/// True when the count crossed zero.
fn barrel_openers_changed(&mut self, key: (i32, i32, i32), open: bool) -> bool {
let (before, count) = self.count_opener(key, open);
if (before == 0) != (count == 0) {
let edge = (before == 0) != (count == 0);
if edge {
self.set_bool_prop(
key,
"open",
@@ -152,6 +157,7 @@ impl Game<'_> {
horizon_world::level::flags::UPDATE_ALL,
);
}
edge
}
/// One opener more (`open`) or less at `key`: the count before and after
/// (`ContainerOpenersCounter.incrementOpeners` / `decrementOpeners`).
+21
View File
@@ -45,6 +45,10 @@ pub(super) struct CombatTracker {
/// The mob exploding now (`ServerExplosion.source`): its team's friendly
/// fire decides whom the blast may hurt.
pub(super) explosion_source: Option<u32>,
/// The blast now going off comes from a primed TNT, creeper, wither
/// skull, wither or TNT minecart, the sources that empty a hive they
/// destroy (`BeehiveBlock.getDrops`).
pub(super) hive_emptying_blast: bool,
/// Charged creepers whose blast just went off and that have not dropped
/// a head yet (`Creeper.droppedSkulls`): they are gone from the mob list,
/// but the mobs they killed still ask for their loot.
@@ -131,6 +135,19 @@ impl Game<'_> {
self.recheck_combat();
for e in events {
let (name, amount) = match e {
// LivingEntity.getDamageAfterMagicAbsorb (Resistance) and
// Player.actuallyHurt (absorption hearts) and
// LivingEntity.hurtServer (the shield, only for an accepted
// hit), in tenths.
MotionEvent::Health(HealthEvent::Statistic { name, amount }) => {
match *name {
"resisted" => self.stats.custom("damage_resisted", *amount),
"absorbed" => self.stats.custom("damage_absorbed", *amount),
"blocked" => self.stats.custom("damage_blocked_by_shield", *amount),
_ => {}
}
continue;
}
MotionEvent::Health(HealthEvent::RecordedDamage { source, amount }) => {
let Some(d) = self.motion.health.damage.definition(*source) else {
continue;
@@ -177,6 +194,10 @@ impl Game<'_> {
direct,
});
self.combat.last_damage = now;
// InfestedMobEffect.onMobHurt.
if self.potions.effects.get("infested").is_some() {
self.player_infested();
}
}
self.combat.pending.clear();
self.combat.pending_direct.clear();
+1 -2
View File
@@ -2049,8 +2049,7 @@ impl Game<'_> {
return false;
}
self.world.block_entities.insert(key, new);
let state = self.world.block(pos[0], pos[1], pos[2]);
let _ = self.world.set(pos[0], pos[1], pos[2], state);
self.world.modified.insert((pos[0] >> 4, pos[2] >> 4));
true
}
/// RandomizableContainer.tryLoadLootTable for a tag a command gives a
+200 -33
View File
@@ -199,6 +199,7 @@ impl Game<'_> {
off_hand: None,
head: self.armor[0].as_ref().map(|s| s.item.clone()),
armor_cover: self.armor.iter().filter(|a| a.is_some()).count() as f32 / 4.0,
invisible: self.potions.effects.get("invisibility").is_some(),
spectator: self.spectator(),
gold_armor: self.wearing_gold(),
hurt_by: self.player_hurt_by(),
@@ -433,6 +434,7 @@ impl Game<'_> {
block_tags: &self.res.items().block_tags,
biomes: self.res.biomes(),
mob_griefing: self.ui.rules.bool("mob_griefing"),
mob_drops: self.ui.rules.bool("mob_drops"),
end: self.dim == Dim::End,
world_seed: self.level.seed,
sea_level: if self.dim == Dim::Nether { 32 } else { 63 },
@@ -526,6 +528,7 @@ impl Game<'_> {
let mut events = Vec::new();
let mut mobs = std::mem::take(&mut self.mobs);
let mut dead = Vec::new();
let mut corpses = Vec::new();
let mut died = std::mem::take(&mut self.died);
let ticking = self.entity_ticking_area();
// With guests on, each mob sees its nearest player (game/lan_mobs.rs).
@@ -620,6 +623,11 @@ impl Game<'_> {
horizon_client::mobs::apply_mob_pushes(m, &mut pushes);
let from = events.len();
let kept = m.tick(&w, &mut scratch, &mut events);
// A killed mob's body is removed: its effects that act on
// death run (`LivingEntity.remove` with KILLED).
if !kept && !m.alive() && !m.removed && !m.extra.effects.is_empty() {
corpses.push(m.clone());
}
horizon_client::mobs::take_mob_pushes(&mut events, from, &mut pushes);
// LivingEntity.tickDeath: after twenty ticks the body is removed.
if !kept && !m.removed && !m.alive() && m.death_time >= 20 {
@@ -700,6 +708,16 @@ impl Game<'_> {
for m in dead {
self.mob_died(&m);
}
for mut m in corpses {
let names: Vec<&'static str> = m
.extra
.effects
.iter()
.map(|e| e.0.trim_start_matches("minecraft:"))
.collect();
let bounds = m.bounds();
self.effects_on_death(&names, bounds, false, Some(m.id), Some(&mut m.random));
}
self.handle_mob_events(events)?;
self.lan_guest_mob_events(guest_events);
self.tick_projectiles()?;
@@ -902,6 +920,18 @@ impl Game<'_> {
}
}
}
/// `InfestedMobEffect.onMobHurt` for a mob: silverfish from half its height up.
pub(super) fn mob_infested(&mut self, mob: u32) {
if let Some(m) = self.mobs.iter().find(|m| m.id == mob) {
let at = [
m.position.x,
m.position.y + f64::from(m.height()) / 2.0,
m.position.z,
];
let look = m.view_vector();
self.infested_hurt(at, look, Some(mob));
}
}
/// `LivingEntity.dropFromGiftLootTable`: the gift table from its random
/// sequence with the mob as `this` (a chicken's egg depends on its
/// variant); the loot data of the game's resources decides, and without it
@@ -966,6 +996,9 @@ impl Game<'_> {
.map_or([0.0; 3], |m| [m.velocity.x, m.velocity.y, m.velocity.z]);
self.drown_particles(at, v);
}
MobEvent::EntityEvent { mob, event, at } => {
self.lan_entity_event(mob as i32, event, at)
}
MobEvent::Sound(name, at, volume, pitch)
| MobEvent::LocalSound(name, at, volume, pitch) => {
self.audio
@@ -1047,7 +1080,7 @@ impl Game<'_> {
self.combat.charged_exploders.push(mob);
}
}
MobEvent::Explode(at, radius) => {
MobEvent::Explode(at, radius, species) => {
// The exploding mob causes the damage (Creeper.explodeCreeper).
let source_mob = self.combat.explosion_source.or_else(|| {
self.mobs
@@ -1063,7 +1096,14 @@ impl Game<'_> {
self.note_attacker("minecraft:explosion", id);
}
self.combat.explosion_source = source_mob;
let result = self.explode(at, radius);
// Only a creeper or a wither empties the hives it blows up.
// The creeper is already gone from the list, so the event
// carries its kind.
let result = if matches!(species, Species::Creeper | Species::Wither) {
self.with_hive_emptying_blast(|g| g.explode(at, radius))
} else {
self.explode(at, radius)
};
self.combat.explosion_source = None;
result?
}
@@ -1074,6 +1114,7 @@ impl Game<'_> {
} => {
let mut killed = false;
let mut hurt = false;
let mut infested = false;
if let Some(t) = self.mobs.iter_mut().find(|m| m.id == target) {
let hit = t.damage(amount, source);
hurt = hit;
@@ -1082,20 +1123,27 @@ impl Game<'_> {
// The hurt or death sound the mob raised.
let center = t.center();
for event in std::mem::take(&mut t.outbox) {
if let MobEvent::Sound(s, _, volume, pitch) = event {
self.audio.play(
&format!("minecraft:{s}"),
Some(center),
volume,
pitch,
);
} else {
// Left for the end of the tick.
t.outbox.push(event);
match event {
MobEvent::Sound(s, _, volume, pitch) => {
self.audio.play(
&format!("minecraft:{s}"),
Some(center),
volume,
pitch,
);
}
MobEvent::Infested { .. } => infested = true,
other => {
// Left for the end of the tick.
t.outbox.push(other);
}
}
}
}
}
if infested {
self.mob_infested(target);
}
if hurt
&& let Some(Who::Mob(attacker)) = source.attacker
&& let Some(m) = self
@@ -1141,6 +1189,7 @@ impl Game<'_> {
}
MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob),
MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive),
MobEvent::Infested { mob } => self.mob_infested(mob),
MobEvent::Gift { target, item } => {
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target)
&& m.saddle_item().is_none()
@@ -1304,12 +1353,17 @@ impl Game<'_> {
}
}
MobEvent::AroundSelf {
mob,
event,
kind,
feet,
width,
height,
burst,
} => self.particles_around(kind, feet, [width, height], burst),
} => {
self.lan_entity_event(mob as i32, event, feet);
self.particles_around(kind, feet, [width, height], burst)
}
MobEvent::ParticleAt { kind, at, velocity } => {
if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) {
let options = horizon_client::particles::ParticleOptions::simple(ty);
@@ -1420,6 +1474,22 @@ impl Game<'_> {
m.ai.aggressive |= aggressive;
}
}
MobEvent::ShedScute { mob, at, pitch } => {
// The mob already checked `shouldDropLoot` (a baby, `mob_drops`).
let table = "minecraft:gameplay/armadillo_shed";
let drops = self.sequence_loot(table, table, None);
for d in drops {
self.spawn_at_location(Vec3::new(at[0], at[1], at[2]), 0.0, d);
}
self.audio.play(
"minecraft:entity.armadillo.scute_drop",
Some(at),
1.0,
pitch,
);
let ctx = self.who_context(Some(Who::Mob(mob)), None);
self.post_game_event("minecraft:entity_place", at, ctx);
}
MobEvent::GiftLoot { mob, table, at } => {
// Turtle.ageBoundaryReached: only with mob loot on.
if table == "minecraft:gameplay/turtle_grow" && !self.ui.rules.bool("mob_drops")
@@ -1548,6 +1618,8 @@ impl Game<'_> {
q.extra.in_love = 0;
}
let q = self.mobs.iter().find(|m| m.id == partner).cloned();
// Animal.finalizeSpawnChildFromBreeding: entity event 18 for the parent.
self.mob_event_particles(parent, 18);
// Sniffer.spawnChildFromBreeding: an egg instead of a baby.
if p.species() == Species::Sniffer {
self.lay_sniffer_egg(&p);
@@ -1820,6 +1892,10 @@ impl Game<'_> {
let (xd, zd) = from.map_or((0.0, 0.0), |from| {
(from[0] - player.position.x, from[2] - player.position.z)
});
// dealDefaultKnockback's `indicateDamage`, unless blocked.
if o.blocked <= 0.0 {
player.health.indicate_damage(xd, zd, player.yaw);
}
self.knock_back_player(f64::from(0.4_f32), xd, zd);
if let Some(p) = self.player.as_mut()
&& let Some(r) = p.hurt_log.last_mut()
@@ -1832,6 +1908,23 @@ impl Game<'_> {
self.thorns(a);
}
}
// LivingEntity.hurtServer: ENTITY_HURT_PLAYER, unless it returned
// early (invulnerable, or inside the hurt cooldown).
if outcome.hurt || outcome.sound {
let source = attacker
.or(owner)
.and_then(|id| self.mobs.iter().find(|m| m.id == id))
.map(|m| self.mob_entity(m));
self.trigger_entity_hurt_player(&horizon_client::advancements::DamageView {
kind: damage_type.to_owned(),
direct: source.clone().filter(|_| !projectile),
is_direct: !projectile,
source,
original: amount,
actual: amount - outcome.blocked,
blocked: outcome.blocked > 0.0,
});
}
if raised {
self.after_block(outcome, amount, attacker, projectile);
}
@@ -2064,6 +2157,21 @@ impl Game<'_> {
if super::remote_projectiles::has_smoke_trail(&p.kind) {
trails.push(p.position);
}
// ThrownEnderpearl.onAboveBubbleColumn / onInsideBubbleColumn.
if keep && hit == Hit::None && matches!(p.kind, ProjectileKind::EnderPearl) {
let (at, h) = (p.position, 0.125);
horizon_client::motion::bubble_column_push(
w.world,
w.registry,
w.facts,
w.collision,
Aabb::new(
Vec3::new(at.x - h, at.y, at.z - h),
Vec3::new(at.x + h, at.y + 2.0 * h, at.z + h),
),
&mut p.velocity,
);
}
if let Some(a) = p.arrow.as_mut() {
arrow_events.extend(a.events.drain(..).map(|e| (p.position, e)));
}
@@ -2489,6 +2597,24 @@ impl Game<'_> {
.is_some_and(|m| m.damage(amount, source));
if p.owner == Some(Who::Player) {
self.last_hurt_by_player.insert(id, self.lan_acting);
if hurt && let Some(m) = self.mobs.iter().find(|m| m.id == id) {
// LivingEntity.hurtServer: PLAYER_HURT_ENTITY.
let victim = self.mob_entity(m);
let spectral = p.arrow.as_ref().is_some_and(|a| {
&*a.pickup_item.item == "minecraft:spectral_arrow"
});
let direct = horizon_client::advancements::EntityView {
kind: if spectral {
"minecraft:spectral_arrow"
} else {
"minecraft:arrow"
}
.into(),
position: [p.position.x, p.position.y, p.position.z],
..Default::default()
};
self.player_hit(&victim, "minecraft:arrow", Some(direct), amount);
}
}
hurt
}
@@ -2532,6 +2658,7 @@ impl Game<'_> {
};
m.damage(amount, source);
}
self.thrown_break_event(p.id, atp);
self.item_burst(atp, "minecraft:snowball");
}
(ProjectileKind::Egg, hit) => {
@@ -2557,6 +2684,7 @@ impl Game<'_> {
}
}
}
self.thrown_break_event(p.id, atp);
self.item_burst(atp, "minecraft:egg");
}
(ProjectileKind::EnderPearl, hit) => {
@@ -2806,10 +2934,17 @@ impl Game<'_> {
}
Ok(())
}
/// `Snowball`/`ThrownEgg.onHit`: entity event 3 for the guests, before the
/// projectile is discarded (the clients lose it when the tracker next runs).
fn thrown_break_event(&mut self, id: u32, at: [f64; 3]) {
if id != 0 {
self.lan_entity_event(id as i32, 3, at);
}
}
/// `Snowball`/`ThrownEgg.handleEntityEvent(3)`: eight crumbs of the
/// thrown item where it broke, at rest for a snowball, scattered by the
/// client entity's random (the particle engine's here) for an egg.
fn item_burst(&mut self, at: [f64; 3], item: &str) {
pub(super) fn item_burst(&mut self, at: [f64; 3], item: &str) {
let options = self.item_particle(&horizon_client::items::ItemStack::new(item, 1));
let egg = item != "minecraft:snowball";
for _ in 0..8 {
@@ -2845,6 +2980,10 @@ impl Game<'_> {
if self.name_mob(index) {
return Ok(true);
}
if self.spawn_egg_offspring(index) {
self.swing_arm();
return Ok(true);
}
{
let item = self.held().map(|h| h.item.to_string()).unwrap_or_default();
if self.interact_leash(index, &item) {
@@ -3099,14 +3238,8 @@ impl Game<'_> {
m.ai.target = None;
m.extra.sitting = true;
}
// TamableAnimal.spawnTamingParticles.
let kind = if tamed { "heart" } else { "smoke" };
// TamableAnimal.spawnTamingParticles (entity event 7 or 6).
self.particles_around_mob(
self.mobs[index].id,
kind,
horizon_client::particles::Burst::TAMING,
);
self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
if tamed {
let view = self.mob_entity(&self.mobs[index]);
self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -3173,13 +3306,8 @@ impl Game<'_> {
m.extra.sitting = true;
}
eat = eating_sound(m, &mut self.world.random);
let kind = if tamed { "heart" } else { "smoke" };
// TamableAnimal.spawnTamingParticles (entity event 7 or 6).
self.particles_around_mob(
self.mobs[index].id,
kind,
horizon_client::particles::Burst::TAMING,
);
self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
if tamed {
let view = self.mob_entity(&self.mobs[index]);
self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -3227,13 +3355,8 @@ impl Game<'_> {
m.extra.tame = true;
m.extra.owner = self.level.player_uuid.or(Some([0, 0, 0, 1]));
}
let kind = if tamed { "heart" } else { "smoke" };
// TamableAnimal.spawnTamingParticles (entity event 7 or 6).
self.particles_around_mob(
self.mobs[index].id,
kind,
horizon_client::particles::Burst::TAMING,
);
self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
if tamed {
let view = self.mob_entity(&self.mobs[index]);
self.trigger_entity("minecraft:tame_animal", "entity", &view);
@@ -3264,6 +3387,11 @@ impl Game<'_> {
Some(sound) => {
consume = true;
eat = sound;
// Animal.setInLove: entity event 18 (a baby that
// only grew is not in love).
if self.mobs[index].extra.in_love > 0 {
self.mob_event_particles(self.mobs[index].id, 18);
}
}
// Animal.mobInteract still consumes the client click when
// an adult cannot breed, without swinging or taking food.
@@ -3460,6 +3588,45 @@ impl Game<'_> {
}
Ok(true)
}
/// `Mob.checkAndHandleImportantInteractions` with a spawn egg of mob
/// `index`'s own kind (`SpawnEggItem.spawnOffspringFromSpawnEgg`): a baby
/// at the mob's feet, taking the parent's variant as `getBreedOffspring`
/// does, and one egg used. False (PASS) when the mob has no baby form.
fn spawn_egg_offspring(&mut self, index: usize) -> bool {
let Some(stack) = self.held().cloned() else {
return false;
};
let parent = &self.mobs[index];
if !parent.alive()
|| stack.item.strip_suffix("_spawn_egg") != Some(parent.kind.id.as_str())
|| !horizon_client::mobs::drops::can_be_baby(parent.species())
// WanderingTrader.getBreedOffspring returns null: no offspring, the
// click carries on to trading.
|| parent.species() == Species::WanderingTrader
{
return false;
}
let (kind, at) = (
parent.kind.id.clone(),
[parent.position.x, parent.position.y, parent.position.z],
);
let (species, variant, color) =
(parent.species(), parent.extra.variant, parent.extra.color);
let target = self.mob_entity(&self.mobs[index]);
let Some(id) = self.spawn_mob(&kind, at, true) else {
return false;
};
if let Some(child) = self.mobs.iter_mut().find(|m| m.id == id) {
horizon_client::mobs::finalize::set_baby(child, true);
child.extra.variant = variant;
if species == Species::Sheep {
child.extra.color = color;
}
}
self.trigger_item_entity("minecraft:player_interacted_with_entity", &stack, &target);
self.consume_held();
true
}
fn use_spawn_egg(&mut self, stack: &ItemStack) -> Result<bool> {
let Some(hit) = self.pick() else {
return Ok(false);
+3 -1
View File
@@ -2165,10 +2165,12 @@ impl Game<'_> {
c.at[1],
c.at[2] + f64::from(a.sin() * d),
];
self.particles.add(
self.particles.add_with(
&ParticleOptions::simple(ParticleType::DragonBreath),
at,
[0.0, 0.0, 0.0],
false,
true,
);
}
// AreaEffectCloud: after its 20-tick wait, every 20 ticks per entity.
+216 -24
View File
@@ -5,6 +5,7 @@
use super::{Dim, Game};
use horizon_client::{
Result,
containers::{BlockEntity, EndGateway},
environment::Environment,
items::ItemStack,
mesher::Vertex,
@@ -27,14 +28,64 @@ const GATEWAY_Y: i32 = 75;
const GATEWAY_FILE: &str = "horizon-end-gateways.json";
/// A gateway teleport waiting for its destination chunks.
#[derive(Clone, Copy, Debug)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum GatewayJob {
/// TheEndGatewayBlockEntity.findOrCreateValidTeleportPos from this gateway.
Find { gateway: [i32; 3] },
/// `exact` is the gateway's own `ExactTeleport`, read while its chunk is loaded.
Find { gateway: [i32; 3], exact: bool },
/// A known exit (exact, or findExitPosition around it).
Known { exit: [i32; 3], exact: bool },
}
impl GatewayJob {
/// TheEndGatewayBlockEntity.getPortalPosition, with legacy save fallbacks.
fn for_gateway(
gateway: [i32; 3],
entity: Option<&BlockEntity>,
legacy: Option<([i32; 3], bool)>,
) -> Self {
let configured = match entity {
Some(BlockEntity::EndGateway(g)) => g.exit_portal.map(|exit| (exit, g.exact_teleport)),
_ => None,
};
match configured.or(legacy) {
Some((exit, exact)) => Self::Known { exit, exact },
// Worldgen return gateways (end_gateway_return) lead exactly to the End spawn.
None if f64::from(gateway[0]).hypot(f64::from(gateway[2])) > 512.0 => Self::Known {
exit: END_SPAWN,
exact: true,
},
None => Self::Find {
gateway,
exact: exact_teleport(entity),
},
}
}
}
/// `TheEndGatewayBlockEntity.exactTeleport` of the block entity at a gateway
/// (false without one).
fn exact_teleport(entity: Option<&BlockEntity>) -> bool {
matches!(entity, Some(BlockEntity::EndGateway(g)) if g.exact_teleport)
}
/// Moves an exit that only the side file knew into the gateway's block entity, unless the block
/// entity has its own; true when it took the saved one.
fn adopt_saved_exit(entity: &mut EndGateway, (exit, exact): ([i32; 3], bool)) -> bool {
if entity.exit_portal.is_some() {
return false;
}
entity.exit_portal = Some(exit);
entity.exact_teleport = exact;
true
}
/// The end of `getPortalPosition`: the exit itself when the teleport is exact,
/// else the spot [`Game::resolve_gateway`] finds around it (`findExitPosition`).
fn exit_target(exit: [i32; 3], exact: bool, find: impl FnOnce([i32; 3]) -> [i32; 3]) -> [i32; 3] {
if exact { exit } else { find(exit) }
}
#[derive(Default)]
pub(super) struct EndState {
/// Gateway position -> (exit, exact teleport); loaded lazily from the save.
@@ -761,6 +812,11 @@ impl Game<'_> {
}
}
}
self.world
.block_entities
.get_or_insert_with((origin[0], origin[1], origin[2]), || {
BlockEntity::EndGateway(Default::default())
});
Ok(())
}
@@ -782,8 +838,7 @@ impl Game<'_> {
self.end.exits.as_mut().expect("loaded exits")
}
fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> {
self.gateway_exits().insert(gateway, (exit, exact));
fn save_gateway_exits(&mut self) -> Result<()> {
let list: Vec<_> = self
.gateway_exits()
.iter()
@@ -795,6 +850,35 @@ impl Game<'_> {
Ok(())
}
/// Drops a gateway's entry from the side file: its block entity is the source of truth.
fn forget_gateway_exit(&mut self, gateway: [i32; 3]) -> Result<()> {
if self.gateway_exits().remove(&gateway).is_some() {
self.save_gateway_exits()?;
}
Ok(())
}
fn set_gateway_exit(&mut self, gateway: [i32; 3], exit: [i32; 3], exact: bool) -> Result<()> {
// TheEndGatewayBlockEntity.setExitPosition (also EndGatewayFeature.knownExit).
let key = (gateway[0], gateway[1], gateway[2]);
let chunk = (gateway[0] >> 4, gateway[2] >> 4);
// The gateway's chunk can be unloaded by now (travel waits for the destination): the
// exit then waits in the side file until the gateway is used again (`gateway_job`).
if self.world.chunks.contains_key(&chunk)
&& let BlockEntity::EndGateway(g) = self
.world
.block_entities
.get_or_insert_with(key, || BlockEntity::EndGateway(Default::default()))
{
g.exit_portal = Some(exit);
g.exact_teleport = exact;
self.world.modified.insert(chunk);
return self.forget_gateway_exit(gateway);
}
self.gateway_exits().insert(gateway, (exit, exact));
self.save_gateway_exits()
}
/// EndGatewayBlock.entityInside and TheEndGatewayBlockEntity.getPortalPosition:
/// travel within the End, waiting for the destination chunks to load.
fn enter_gateway(&mut self, gateway: [i32; 3]) -> Result<()> {
@@ -814,25 +898,39 @@ impl Game<'_> {
/// its exit, or the search for one, and the spot to load before either
/// is resolved ([`Game::resolve_gateway`]).
pub(super) fn gateway_job(&mut self, gateway: [i32; 3]) -> (GatewayJob, Vec3) {
let known = self.gateway_exits().get(&gateway).copied();
let job = match known {
Some((exit, exact)) => GatewayJob::Known { exit, exact },
// Worldgen return gateways (end_gateway_return) lead exactly to the End spawn.
None if f64::from(gateway[0]).hypot(f64::from(gateway[2])) > 512.0 => {
GatewayJob::Known {
exit: END_SPAWN,
exact: true,
}
let mut known = self.gateway_exits().get(&gateway).copied();
// Once the gateway's chunk is loaded its block entity is the source of truth: an exit the
// side file kept for it moves there, and the entry is dropped, so removing or replacing
// the exit (`/data remove block`) is not undone by an old entry.
let key = (gateway[0], gateway[1], gateway[2]);
let chunk = (gateway[0] >> 4, gateway[2] >> 4);
if let Some(saved) = known
&& self.world.chunks.contains_key(&chunk)
&& let BlockEntity::EndGateway(g) = self
.world
.block_entities
.get_or_insert_with(key, || BlockEntity::EndGateway(Default::default()))
{
if adopt_saved_exit(g, saved) {
self.world.modified.insert(chunk);
}
None => GatewayJob::Find { gateway },
};
known = None;
let _ = self.forget_gateway_exit(gateway);
}
let job = GatewayJob::for_gateway(
gateway,
self.world
.block_entities
.get(&(gateway[0], gateway[1], gateway[2])),
known,
);
let destination = match job {
GatewayJob::Known { exit, .. } => Vec3::new(
f64::from(exit[0]) + 0.5,
f64::from(exit[1]),
f64::from(exit[2]) + 0.5,
),
GatewayJob::Find { gateway } => {
GatewayJob::Find { gateway, .. } => {
let d = glam::DVec2::new(f64::from(gateway[0]), f64::from(gateway[2]))
.normalize_or_zero()
* 1024.0;
@@ -889,12 +987,10 @@ impl Game<'_> {
[p[0], p[1] + 1, p[2]]
};
match job {
GatewayJob::Known { exit, exact } => Ok(bottom_center(if exact {
exit
} else {
find_exit(self, exit)
})),
GatewayJob::Find { gateway } => {
GatewayJob::Known { exit, exact } => Ok(bottom_center(exit_target(exit, exact, |e| {
find_exit(self, e)
}))),
GatewayJob::Find { gateway, exact } => {
// findExitPortalXZPosTentative over the loaded chunks.
let dir = glam::DVec2::new(f64::from(gateway[0]), f64::from(gateway[2]))
.normalize_or_zero();
@@ -954,8 +1050,11 @@ impl Game<'_> {
let exit = [tallest[0], tallest[1] + 10, tallest[2]];
self.place_gateway(exit)?;
self.set_gateway_exit(exit, gateway, false)?;
self.set_gateway_exit(gateway, exit, false)?;
Ok(bottom_center(find_exit(self, exit)))
// setExitPosition keeps the gateway's own exactTeleport.
self.set_gateway_exit(gateway, exit, exact)?;
Ok(bottom_center(exit_target(exit, exact, |e| {
find_exit(self, e)
})))
}
}
}
@@ -1252,3 +1351,96 @@ impl Game<'_> {
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use horizon_client::containers::EndGateway;
#[test]
fn a_saved_exit_moves_into_a_gateway_without_one() {
let saved = ([8, 100, 0], true);
let mut bare = EndGateway::default();
assert!(adopt_saved_exit(&mut bare, saved));
assert_eq!(bare.exit_portal, Some([8, 100, 0]));
assert!(bare.exact_teleport);
// The block entity's own exit wins over a stale entry.
let mut own = EndGateway {
exit_portal: Some([1, 2, 3]),
..Default::default()
};
assert!(!adopt_saved_exit(&mut own, saved));
assert_eq!(own.exit_portal, Some([1, 2, 3]));
assert!(!own.exact_teleport);
}
#[test]
fn a_new_exit_keeps_the_gateways_exact_teleport() {
let exact = BlockEntity::EndGateway(EndGateway {
exact_teleport: true,
..Default::default()
});
let plain = BlockEntity::EndGateway(EndGateway::default());
assert!(exact_teleport(Some(&exact)));
assert!(!exact_teleport(Some(&plain)));
assert!(!exact_teleport(None));
assert!(!exact_teleport(Some(&BlockEntity::DaylightDetector)));
let exit = [8, 100, 0];
// Exact: the exit itself, nothing is searched for.
assert_eq!(exit_target(exit, true, |_| panic!("searched")), exit);
assert_eq!(
exit_target(exit, false, |e| [e[0], e[1] + 11, e[2]]),
[8, 111, 0]
);
}
#[test]
fn end_gateway_job_prefers_block_entity_then_legacy_then_heuristic() {
let gateway = [702, 100, 0];
let exit = [8, 100, 0];
for exact in [true, false] {
let entity = BlockEntity::EndGateway(EndGateway {
exit_portal: Some(exit),
exact_teleport: exact,
..Default::default()
});
assert_eq!(
GatewayJob::for_gateway(gateway, Some(&entity), Some((END_SPAWN, !exact))),
GatewayJob::Known { exit, exact },
);
}
let empty = BlockEntity::EndGateway(EndGateway::default());
for entity in [None, Some(&empty)] {
assert_eq!(
GatewayJob::for_gateway(gateway, entity, Some((exit, false))),
GatewayJob::Known { exit, exact: false }
);
assert_eq!(
GatewayJob::for_gateway(gateway, entity, None),
GatewayJob::Known {
exit: END_SPAWN,
exact: true
}
);
let nearby = [96, 75, 0];
let exact = BlockEntity::EndGateway(EndGateway {
exact_teleport: true,
..Default::default()
});
assert_eq!(
GatewayJob::for_gateway(nearby, Some(&exact), None),
GatewayJob::Find {
gateway: nearby,
exact: true
}
);
assert_eq!(
GatewayJob::for_gateway(nearby, entity, None),
GatewayJob::Find {
gateway: nearby,
exact: false
}
);
}
}
}
@@ -307,6 +307,12 @@ impl Game<'_> {
)
{
outcome = o;
// dealDefaultKnockback's `indicateDamage` points at the blast
// (the source position), not the no-direction fallback.
if o.knockback && o.blocked <= 0.0 {
p.health
.indicate_damage(center[0] - feet[0], center[2] - feet[2], p.yaw);
}
}
if !spectator && !(creative && flying) {
p.velocity = Vec3::new(
@@ -490,6 +496,15 @@ impl Game<'_> {
);
}
}
/// Runs an explosion whose source empties the hives it destroys
/// (`BeehiveBlock.getDrops`: primed TNT, creeper, wither skull, wither,
/// TNT minecart).
pub(super) fn with_hive_emptying_blast<R>(&mut self, blast: impl FnOnce(&mut Self) -> R) -> R {
self.combat.hive_emptying_blast = true;
let result = blast(self);
self.combat.hive_emptying_blast = false;
result
}
/// `Level.explode` on the server: positions, entities, blocks, fire; then
/// the client's explosion sound.
pub(super) fn server_explode(
@@ -606,6 +621,22 @@ impl Game<'_> {
// Block.onExplosionHit: the drops copy from the block entity, which
// then spills its contents as the block turns to air.
let key = (pos[0], pos[1], pos[2]);
let is_hive = matches!(&*name, "minecraft:beehive" | "minecraft:bee_nest");
// BeehiveBlock.getDrops: the bees of a hive blown up by TNT, a
// creeper, a wither skull, a wither or a TNT minecart come out.
if is_hive && self.combat.hive_emptying_blast {
let facing = self
.pack
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("facing").cloned());
self.empty_hive(
pos,
horizon_client::beehive::facing_step(facing.as_deref()),
horizon_client::beehive::Release::Emergency,
);
}
if let Some(entity) = self.world.block_entities.get(&key).cloned() {
let custom = self.world.block_names.get(&key).cloned();
self.pending.record(pos, &entity, &name, custom);
@@ -638,6 +669,10 @@ impl Game<'_> {
}
self.pending.clear(pos);
self.level_set(pos, self.world.air)?;
// BeehiveBlock.onExplosionHit: the bees about turn on the player.
if is_hive {
self.anger_nearby_bees(pos);
}
// TntBlock.wasExploded: new PrimedTnt (its push drawn first), then
// getRandomShortFuse(80); no game event.
if is_tnt && self.ui.rules.bool("tnt_explodes") {
+23 -2
View File
@@ -2,6 +2,7 @@
//! bobbing, lure and bite timers, open water, hooking mobs, retrieving the
//! `gameplay/fishing` loot) and `FishingHookRenderer` (bobber and line).
use super::{Game, view_vector};
use horizon_client::advancements::EntityView;
use horizon_client::lan::{entity::States, hub::Hub};
use horizon_client::{
blocks::Fluid,
@@ -77,7 +78,7 @@ impl Game<'_> {
let at = [p.position.x, p.position.y, p.position.z];
let pitch = 0.4 / (self.world.random.next_float() * 0.4 + 0.8);
if self.hook.is_some() {
let damage = self.retrieve_hook();
let damage = self.retrieve_hook(stack);
self.damage_held(damage);
self.audio.play(
"minecraft:entity.fishing_bobber.retrieve",
@@ -143,7 +144,7 @@ impl Game<'_> {
true
}
/// `FishingHook.retrieve`: the rod damage it costs.
fn retrieve_hook(&mut self) -> u32 {
fn retrieve_hook(&mut self, rod: &ItemStack) -> u32 {
let Some(hook) = self.hook.take() else {
return 0;
};
@@ -167,6 +168,15 @@ impl Game<'_> {
item.velocity = pulled(item.velocity);
hooked_item = true;
}
// CriteriaTriggers.FISHING_ROD_HOOKED with no items.
let hooked = self
.mobs
.iter()
.find(|m| m.id == id)
.map(|m| self.mob_entity(m));
if let Some(hooked) = hooked {
self.trigger_fishing_rod_hooked(rod, &hooked, &[]);
}
// `hookedIn instanceof ItemEntity ? 3 : 5`.
damage = if hooked_item { 3 } else { 5 };
} else if hook.nibble > 0 {
@@ -191,6 +201,7 @@ impl Game<'_> {
Some(hook.open_water),
);
self.world.random = random;
let mut caught = Vec::new();
for stack in items {
// FishingHook.retrieve: fish_caught for each catch in #minecraft:fishes.
if self
@@ -222,6 +233,7 @@ impl Game<'_> {
if let Some(potion) = &stack.potion {
item = item.with_potion(potion);
}
caught.push(item.clone());
let (dx, dy, dz) = (
owner.x - hook.position.x,
owner.y - hook.position.y,
@@ -241,6 +253,15 @@ impl Game<'_> {
let xp = self.world.random.next_int_bound(6).unwrap_or(0) as u32 + 1;
self.spawn_orbs([owner.x, owner.y + 0.5, owner.z + 0.5], xp);
}
// CriteriaTriggers.FISHING_ROD_HOOKED: the hook itself is the entity.
let bobber = EntityView {
kind: "minecraft:fishing_bobber".into(),
position: [hook.position.x, hook.position.y, hook.position.z],
on_ground: hook.on_ground,
fishing_open_water: Some(hook.open_water),
..Default::default()
};
self.trigger_fishing_rod_hooked(rod, &bobber, &caught);
damage = 1;
}
if hook.on_ground {
+1 -1
View File
@@ -114,7 +114,7 @@ impl Game<'_> {
living: Some(HurtBob {
hurt_time: p.health.hurt_animation_time as f32 - partial,
hurt_duration: hurt.hurt_duration,
hurt_dir: 0.0,
hurt_dir: p.health.hurt_dir,
death_time: self.death_time().map(|t| t as f32 + partial),
}),
player: Some((
@@ -420,6 +420,8 @@ impl Game<'_> {
s.flags.published.store(0, Ordering::Relaxed);
}
if let Some(mut host) = self.lan.take() {
// PlayerList.removeAll: the owner and every guest leave the game.
host.award_leave_game_to_all();
for g in &host.hub.guests {
self.save_guest(&host, g);
}
+95 -3
View File
@@ -92,6 +92,33 @@ pub(super) struct LanHost {
states: lan::entity::States,
}
impl LanHost {
/// `PlayerList.remove`: `player.awardStat(Stats.LEAVE_GAME)` before the
/// player is saved. Once per guest, however often they are saved.
pub(super) fn award_leave_game(&mut self, conn: u32) {
if let Some(play) = self.play.get_mut(&conn)
&& !play.left_game
{
play.left_game = true;
play.stats.custom("leave_game", 1);
}
}
/// `PlayerList.removeAll`: every player who joined leaves with the world.
pub(super) fn award_leave_game_to_all(&mut self) {
let conns: Vec<u32> = self
.hub
.guests
.iter()
.filter(|g| g.placed)
.map(|g| g.conn)
.collect();
for conn in conns {
self.award_leave_game(conn);
}
}
}
/// The player who owns an integrated server's world: a guest whose state is
/// the world's own player (`players/data/<singleplayer_uuid>.dat`), as in
/// single player.
@@ -162,6 +189,7 @@ fn mob_meta(
m: &Mob,
hub: &Hub,
player_entity: Option<i32>,
game_time: i64,
meta: &mut Vec<(u8, i32, Value)>,
defaults: &mut Vec<(u8, i32, Value)>,
) {
@@ -172,6 +200,12 @@ fn mob_meta(
if shared != 0 {
meta.push((0, serializer::BYTE, Value::Byte(shared)));
}
// Entity.DATA_POSE: the pose the species keeps in its own fields (a
// pose back at standing goes out by the entity's own default).
let pose = horizon_client::mobs::sync::pose_id(m);
if pose != 0 {
meta.push((6, serializer::POSE, Value::Id(i32::from(pose))));
}
if let Some(name) = &m.custom_name {
meta.push((
2,
@@ -401,6 +435,41 @@ fn mob_meta(
}
defaults.push((17, serializer::BYTE, Value::Byte(0)));
}
// Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace.
"minecraft:warden" => {
let anger = e.warden.as_ref().map_or(0, |w| w.client_anger);
if anger != 0 {
meta.push((16, serializer::INT, Value::Int(anger)));
}
defaults.push((16, serializer::INT, Value::Int(0)));
}
// Sniffer.DATA_STATE (after AgeableMob's two).
"minecraft:sniffer" => {
if e.variant != 0 {
meta.push((
18,
serializer::SNIFFER_STATE,
Value::Id(i32::from(e.variant)),
));
}
defaults.push((18, serializer::SNIFFER_STATE, Value::Id(0)));
}
// Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID (16
// for none).
"minecraft:shulker" => {
if e.variant3 != 0 {
meta.push((16, serializer::DIRECTION, Value::Id(i32::from(e.variant3))));
}
defaults.push((16, serializer::DIRECTION, Value::Id(0)));
if e.counter != 0 {
meta.push((17, serializer::BYTE, Value::Byte(e.counter as i8)));
}
defaults.push((17, serializer::BYTE, Value::Byte(0)));
if e.color != 16 {
meta.push((18, serializer::BYTE, Value::Byte(e.color as i8)));
}
defaults.push((18, serializer::BYTE, Value::Byte(16)));
}
// Enderman.DATA_CARRY_STATE.
"minecraft:enderman" => {
if let Some(state) = e.carried {
@@ -413,6 +482,18 @@ fn mob_meta(
}
_ => {}
}
// Camel.DASH and LAST_POSE_CHANGE_TICK (after AbstractHorse's flags).
if horizon_client::mobs::camel::is_camel(m.species()) {
if e.flag2 {
meta.push((19, serializer::BOOLEAN, Value::Bool(true)));
}
defaults.push((19, serializer::BOOLEAN, Value::Bool(false)));
let tick = horizon_client::mobs::camel::synced_pose_tick(m, game_time);
if tick != 0 {
meta.push((20, serializer::LONG, Value::Long(tick)));
}
defaults.push((20, serializer::LONG, Value::Long(0)));
}
}
/// What a client shakes a mob by: Entity.DATA_TICKS_FROZEN (7), whose full
@@ -731,6 +812,7 @@ impl Game<'_> {
let Some(mut host) = self.lan.take() else {
return;
};
host.award_leave_game_to_all();
for g in &host.hub.guests {
self.save_guest(&host, g);
}
@@ -938,7 +1020,7 @@ impl Game<'_> {
out.clear();
for m in self.mobs.iter().filter(|m| !m.removed) {
// The lead's holder: the player the mob sees (a guest, else the
// host) or another mob. A fence knot isn't an entity here.
// host), another mob or a fence knot (game/lan_entities.rs).
let player_entity = mob_players
.get(&m.id)
.and_then(|conn| hub.guest(*conn))
@@ -947,7 +1029,7 @@ impl Game<'_> {
let leash = m.extra.leash.and_then(|h| match h {
Holder::Player => player_entity,
Holder::Mob(id) => Some(id as i32),
Holder::Knot(_) => None,
Holder::Knot(p) => self.knot_ids.get(&p).map(|&id| id as i32),
});
let e = out.add(m.id as i32, entity_uuid(m.id), m.kind.id.as_str());
e.position = [m.position.x, m.position.y, m.position.z];
@@ -955,7 +1037,14 @@ impl Game<'_> {
e.on_ground = m.on_ground;
e.velocity = [m.velocity.x, m.velocity.y, m.velocity.z];
e.needs_sync = m.needs_sync;
mob_meta(m, hub, player_entity, &mut e.meta, &mut e.defaults);
mob_meta(
m,
hub,
player_entity,
self.world.game_time,
&mut e.meta,
&mut e.defaults,
);
mob_freeze_meta(m, &mut e.meta, &mut e.defaults);
mob_equipment(m, hub, &mut e.equipment);
self.mob_attributes(m, &mut e.attributes);
@@ -1150,6 +1239,9 @@ impl Game<'_> {
}
}
self.lan_crafting_left(&mut host, &mut guest);
if guest.placed {
host.award_leave_game(guest.conn);
}
self.save_guest(&host, &guest);
host.models.remove(&guest.conn);
host.play.remove(&guest.conn);
+30 -2
View File
@@ -74,6 +74,9 @@ pub(super) struct GuestPlay {
potions: super::potions::BodyPotions,
/// `ServerPlayer.getStats` and the inventory `inventory_changed` last saw.
pub(super) stats: super::stats::Stats,
/// `Stats.LEAVE_GAME` is counted: a guest is saved more than once on the
/// way out, the statistic is awarded once (`LanHost::award_leave_game`).
pub(super) left_game: bool,
last_inventory: u64,
/// `Entity.portalProcess` and `portalCooldown` (game/server_travel.rs).
pub(super) portal: horizon_client::nether_portal::PortalState,
@@ -681,6 +684,13 @@ impl Game<'_> {
g.sprinting = false;
}
m.sprinting = false;
// ServerPlayer.indicateDamage: the hit's direction to the player.
if let Some(yaw) = m.health.indicated_dir.take() {
g.send(&C::HurtAnimation(play::HurtAnimation {
id: g.entity_id,
yaw,
}));
}
let teleported = std::mem::take(&mut m.teleported);
let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum();
g.motion = Some(Box::new(m));
@@ -882,13 +892,17 @@ impl Game<'_> {
}
/// The guest's open container is closing (`AbstractContainerMenu.removed`):
/// it no longer counts among the openers of the lid.
/// it no longer counts among the openers of the lid, and the lid's close
/// sound is played for everyone around (`ChestBlockEntity.onClose`, a
/// `playSound` with no player), the guest included, once the last opener
/// has left.
pub(super) fn guest_container_closed(&mut self, host: &mut LanHost, conn: u32) {
if let Some(g) = host.hub.guest(conn)
&& let Some(pos) = g.menu.as_ref().and_then(|m| m.pos)
&& !g.spectator()
&& self.container_openers_changed(pos, false)
{
self.container_openers_changed(pos, false);
self.container_edge_sound(pos, false);
}
}
@@ -982,6 +996,20 @@ impl Game<'_> {
// The pause between two blocks is the client's (MultiPlayerGameMode's
// destroyDelay); the server digs from the START it receives.
play.destroy_delay = 0;
// ServerPlayerGameMode.handleBlockBreakAction: a survival START
// attacks the block at once, so a tap released in the same tick
// still plays a note. The dig is marked begun for tick_mining.
let pos = a.pos;
self.as_guest(host, conn, |g| {
if g.may_build() && !g.creative {
let _ = g.attack_block(pos);
g.mining = Some(Mining {
pos,
progress: 0.0,
ticks: 0,
});
}
});
}
1 => {}
3 => {
+15 -4
View File
@@ -127,9 +127,18 @@ impl Game<'_> {
}
let dropped = std::mem::take(&mut menu.dropped);
let equipped = std::mem::take(&mut menu.equipped);
let brewed = std::mem::take(&mut menu.brewed);
menu.drops.clear();
menu.crafted.clear();
store_player(menu, &mut host.hub.guests[gi]);
if !brewed.is_empty() {
let conn = host.hub.guests[gi].conn;
self.as_guest(host, conn, |g| {
for stack in &brewed {
g.trigger_brewed_potion(stack);
}
});
}
if !equipped.is_empty() {
let conn = host.hub.guests[gi].conn;
self.as_guest(host, conn, |g| {
@@ -576,16 +585,18 @@ impl Game<'_> {
/// A guest left: what their crafting grids and workstation held goes back into their
/// inventory before it is saved (dropped where they stood if full).
pub(super) fn lan_crafting_left(&mut self, host: &mut LanHost, g: &mut Guest) {
let play = host.play.remove(&g.conn);
// The guest's play state stays: their statistics are awarded and saved
// after this (`HostEvent::Left`), which removes it.
let play = host.play.get_mut(&g.conn);
let mut grid: Vec<ItemStack> = g.craft_grid.iter_mut().filter_map(Option::take).collect();
g.craft_result = None;
if let Some(play) = play {
if let Some((_, _, menu, _)) = play.crafting.table {
if let Some((_, _, menu, _)) = play.crafting.table.take() {
grid.extend((1..10).filter_map(|s| menu.slot(s).cloned()));
}
// A workstation's inputs too.
if let Some(station) = &play.station {
grid.extend(super::lan_stations::station_inputs(station));
if let Some(station) = play.station.take() {
grid.extend(super::lan_stations::station_inputs(&station));
}
}
if grid.is_empty() {
@@ -225,6 +225,16 @@ impl Game<'_> {
}
out.push(e);
}
for (p, &id) in &self.knot_ids {
// LeashFenceKnotEntity.getAddEntityPacket: the fence's block.
out.push(state(
id,
"minecraft:leash_knot",
p.map(f64::from),
0.0,
false,
));
}
for p in &self.paintings {
let mut e = state(p.id, "minecraft:painting", p.pos.map(f64::from), 0.0, false);
// Direction.get2DDataValue (south 0, west 1, north 2, east 3) to its
@@ -270,6 +280,24 @@ impl Game<'_> {
/// Gives the entities Horizon keeps without an id one (`Entity.id`, from
/// the same counter as the rest) before they are first tracked.
pub(super) fn lan_assign_ids(&mut self) {
// LeashFenceKnotEntity: one per fence post with a lead on it
// (`notifyLeasheeRemoved` discards it once the last lead is gone).
let knots: Vec<[i32; 3]> = self
.mobs
.iter()
.filter(|m| !m.removed)
.filter_map(|m| match m.extra.leash {
Some(horizon_client::mobs::leash::Holder::Knot(p)) => Some(p),
_ => None,
})
.collect();
self.knot_ids.retain(|p, _| knots.contains(p));
for p in knots {
self.knot_ids.entry(p).or_insert_with(|| {
self.next_entity += 1;
self.next_entity
});
}
let next = &mut self.next_entity;
let mut give = |id: &mut u32| {
if *id == 0 {
@@ -358,6 +358,7 @@ mod tests {
off_hand: None,
head: None,
armor_cover: 0.0,
invisible: false,
spectator: false,
gold_armor: false,
hurt_by: None,
@@ -247,14 +247,10 @@ impl Game<'_> {
return;
};
let (d, s) = (p.dist.map(f64::from), p.max_speed.map(f64::from));
// ClientLevel.addParticle: the camera's 32 blocks unless the packet
// (`force`) or the type overrides the limiter.
// ClientLevel.addParticle: the camera's 32 blocks and the Particles
// option, unless the packet or the type overrides the limiter.
let add = |particles: &mut horizon_client::particles::ParticleEngine, at, v| {
if p.override_limiter {
particles.create(&options, at, v);
} else {
particles.add(&options, at, v);
}
particles.add_with(&options, at, v, p.override_limiter, p.always_show);
};
if p.count == 0 {
add(
+24
View File
@@ -267,6 +267,30 @@ impl Game<'_> {
} else {
Default::default()
};
// ServerPlayer.awardKillScore: the blow that kills a player.
if hurt {
let died = match victim {
// A totem that fired is applied on the next tick_totem, so the
// victim is still at zero health but is not dying.
Victim::Host => self
.player
.as_ref()
.is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used),
Victim::Guest(conn) => host
.hub
.guest(conn)
.and_then(|g| g.motion.as_deref())
.is_some_and(|p| p.health.dead_or_dying() && !p.health.totem_used),
};
if died {
match s.attacker {
Some(conn) => {
self.as_guest(host, conn, |g| g.stats.custom("player_kills", 1));
}
None => self.stats.custom("player_kills", 1),
}
}
}
if hurt && (s.crit || s.magic) {
let target = match victim {
Victim::Host => self.player.as_ref().map(|p| (host.host_entity, p)),
@@ -12,19 +12,17 @@ use horizon_world::registry::BlockStateId;
impl Game<'_> {
pub(super) fn dragon_egg_particles(&mut self, pos: [i32; 3], data: i32) {
self.particles
.block_teleportation(pos, data, [16, 8, 16], self.settings.particles);
self.particles.block_teleportation(pos, data, [16, 8, 16]);
}
/// Event 2016: `Shulker.teleportSomewhere`'s particles between the
/// shell's old and new cells.
pub(super) fn shulker_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
self.particles
.block_teleportation(pos, data, [8, 8, 8], self.settings.particles);
self.particles.block_teleportation(pos, data, [8, 8, 8]);
}
/// Event 2017: `TeleportRandomlyConsumeEffect`'s directional particles.
pub(super) fn consume_teleport_particles(&mut self, pos: [i32; 3], data: i32) {
self.particles
.block_teleportation(pos, data, [127, 127, 127], self.settings.particles);
.block_teleportation(pos, data, [127, 127, 127]);
}
/// `LevelEventHandler.levelEvent` 3002 to 3005, drawing from the client
/// level's random.
+4
View File
@@ -66,6 +66,8 @@ pub(super) struct Parked {
tnts: Vec<tnt::PrimedTnt>,
hoppers: HashMap<(i32, i32, i32), machines::HopperState>,
mobs: Vec<Mob>,
/// The entity ids of the level's fence knots (`knot_ids`).
knot_ids: HashMap<[i32; 3], u32>,
projectiles: Vec<horizon_client::projectiles::Projectile>,
dropped: Vec<ItemEntity>,
orbs: Vec<ExperienceOrb>,
@@ -170,6 +172,7 @@ impl Game<'_> {
tnts: Vec::new(),
hoppers: HashMap::new(),
mobs: Vec::new(),
knot_ids: HashMap::new(),
projectiles: Vec::new(),
dropped: Vec::new(),
orbs: Vec::new(),
@@ -223,6 +226,7 @@ impl Game<'_> {
swap(&mut self.tnts, &mut p.tnts);
swap(&mut self.hoppers, &mut p.hoppers);
swap(&mut self.mobs, &mut p.mobs);
swap(&mut self.knot_ids, &mut p.knot_ids);
swap(&mut self.creatures.projectiles, &mut p.projectiles);
swap(&mut self.dropped, &mut p.dropped);
swap(&mut self.orbs, &mut p.orbs);
@@ -278,6 +278,13 @@ impl Game<'_> {
}
self.strike_rod(b.at);
}
// LightningBolt.tick runs clearCopperOnLightningStrike for
// every server bolt, a skeleton trap's visual one included;
// a client's copy of a server bolt (spawn_remote_bolt) only
// flashes.
if self.remote.is_none() {
self.bolt_clear_copper(b.at);
}
}
b.life -= 1;
if b.life < 0 {
@@ -334,6 +341,16 @@ impl Game<'_> {
self.level_event_at(3002, p, axis);
}
}
/// `LightningBolt.clearCopperOnLightningStrike` at the block the bolt struck.
fn bolt_clear_copper(&mut self, at: [f64; 3]) {
let p = BlockPos::new(
at[0].floor() as i32,
(at[1] - 1.0e-6).floor() as i32,
at[2].floor() as i32,
);
self.with_level(|b, level, ticks| b.lightning_clear_copper(level, ticks, p));
let _ = self.process_level_events();
}
/// `thunderHit` for entities within 3 blocks (up to 9 above).
fn thunder_hit(&mut self, b: &mut Bolt) {
let at = b.at;
+6
View File
@@ -25,11 +25,13 @@ impl Game<'_> {
};
let m = &mut self.mobs[index];
let mut used = false;
let mut loved = false;
if item == "minecraft:hay_block" && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0
{
m.extra.in_love = 600;
m.extra.love_player = true;
used = true;
loved = true;
}
if m.health < m.attrs.max_health {
m.health = (m.health + heal).min(m.attrs.max_health);
@@ -57,6 +59,10 @@ impl Game<'_> {
if !used {
return false;
}
// Animal.setInLove: entity event 18.
if loved {
self.mob_event_particles(self.mobs[index].id, 18);
}
self.llama_sound(index, "entity.llama.eat", 1.0);
self.consume_held();
true
+112 -40
View File
@@ -626,46 +626,8 @@ impl Game<'_> {
/// `HopperBlockEntity.suckInItems`: from the container above, or item entities.
fn hopper_suck(&mut self, pos: Pos, hopper: &View) -> bool {
let above = (pos.0, pos.1 + 1, pos.2);
let c = self.containers();
if let Some(source) = c.view(above, false) {
if let Kind::Composter(level) = source.kind {
if level != 8 {
return false;
}
// tryTakeInItemFromSlot on the OutputContainer: removeItem calls
// its setChanged, which empties the composter, and so does the
// second setChanged after the move or, when the hopper has no
// room, the setItem putting the bone meal back into the detached
// container (whose bone meal is lost with it).
let bone_meal = c.bone_meal.clone();
let at = BlockPos::new(above.0, above.1, above.2);
self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
let moved = self.add_item(None, hopper, bone_meal, None).is_none();
self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
self.world.modified.insert((above.0 >> 4, above.2 >> 4));
return moved;
}
let source_hopper = (source.kind == Kind::Hopper).then_some(above);
for slot in source.slots_for_face(Some(Direction::Down)) {
let c = self.containers();
let Some(stack) = c.get(&source, slot) else {
continue;
};
if !c.can_take(&source, slot, stack, Direction::Down) {
continue;
}
let Some(one) = self.take_one(&source, slot) else {
continue;
};
match self.add_item(source_hopper, hopper, one, None) {
None => {
self.view_changed(&source);
return true;
}
Some(rest) => self.put_back(&source, slot, rest),
}
}
return false;
if let Some(took) = self.suck_from_container(above, hopper) {
return took;
}
let above_state = self.world.block(above.0, above.1, above.2);
let blocked = self.res.facts().get(above_state).full_collision
@@ -695,6 +657,56 @@ impl Game<'_> {
{
return false;
}
self.suck_item_entities(hopper, min, max)
}
/// The container half of `HopperBlockEntity.suckInItems`: one item from the
/// container at `above`, through its bottom face. `None` when there is no
/// container there.
fn suck_from_container(&mut self, above: Pos, hopper: &View) -> Option<bool> {
let c = self.containers();
let source = c.view(above, false)?;
if let Kind::Composter(level) = source.kind {
if level != 8 {
return Some(false);
}
// tryTakeInItemFromSlot on the OutputContainer: removeItem calls
// its setChanged, which empties the composter, and so does the
// second setChanged after the move or, when the hopper has no
// room, the setItem putting the bone meal back into the detached
// container (whose bone meal is lost with it).
let bone_meal = c.bone_meal.clone();
let at = BlockPos::new(above.0, above.1, above.2);
self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
let moved = self.add_item(None, hopper, bone_meal, None).is_none();
self.with_level(|b, level, ticks| b.composter_empty(level, ticks, at));
self.world.modified.insert((above.0 >> 4, above.2 >> 4));
return Some(moved);
}
let source_hopper = (source.kind == Kind::Hopper).then_some(above);
for slot in source.slots_for_face(Some(Direction::Down)) {
let c = self.containers();
let Some(stack) = c.get(&source, slot) else {
continue;
};
if !c.can_take(&source, slot, stack, Direction::Down) {
continue;
}
let Some(one) = self.take_one(&source, slot) else {
continue;
};
match self.add_item(source_hopper, hopper, one, None) {
None => {
self.view_changed(&source);
return Some(true);
}
Some(rest) => self.put_back(&source, slot, rest),
}
}
Some(false)
}
/// The item half of `HopperBlockEntity.suckInItems` (`getItemsAtAndAbove`):
/// adds the item entities that meet the box, until one is taken whole.
fn suck_item_entities(&mut self, hopper: &View, min: [f64; 3], max: [f64; 3]) -> bool {
let mut i = 0;
while i < self.dropped.len() {
let b = self.dropped[i].bounds();
@@ -719,6 +731,66 @@ impl Game<'_> {
}
false
}
/// `MinecartHopper.tick`'s `tryConsumeItems` (`suckInItems`) for an enabled
/// hopper minecart: one item from the container above, else the item
/// entities over it or touching it, each tick without a cooldown.
pub(super) fn hopper_cart_suck(&mut self, cart: &mut super::minecarts::Minecart) {
// The cart's slots are edited as a container under the placeholder key
// its menu uses; when that menu is open the placeholder is the live copy.
let key = (i32::MAX - 15, super::minecarts::CART_KEY_Y, cart.id as i32);
let open = self.world.block_entities.contains_key(&key);
if !open {
let items = BlockEntity::Chest(std::mem::take(&mut cart.items));
self.world.block_entities.insert(key, items);
}
let size = self
.world
.block_entities
.get(&key)
.map_or(0, |e| e.slots().len());
let view = View {
parts: vec![(key, size)],
kind: Kind::Generic,
};
let p = cart.position;
// getLevelY is the cart's y + 0.5, so the container is the block at
// y + 1.5, and Hopper.SUCK_AABB (moved by getLevel - 0.5) starts 11/16
// above the cart.
let above = (
p.x.floor() as i32,
(p.y + 1.5).floor() as i32,
p.z.floor() as i32,
);
let took = match self.suck_from_container(above, &view) {
Some(took) => took,
None => self.suck_item_entities(
&view,
[p.x - 0.5, p.y + 11.0 / 16.0, p.z - 0.5],
[p.x + 0.5, p.y + 2.0, p.z + 0.5],
),
};
if !took {
// The cart's own box, inflated by 0.25 sideways.
let b = cart.bounds();
let (lo, hi) = (b.min_position(), b.max_position());
self.suck_item_entities(
&view,
[lo.x - 0.25, lo.y, lo.z - 0.25],
[hi.x + 0.25, hi.y, hi.z + 0.25],
);
}
// The cart's own items stay the one source of truth: a menu copy that
// is still around (open, or left by a guest's close) gets the pulled
// items back into `cart.items`, so reopening never restores a stale copy.
let slots = if open {
self.world.block_entities.get(&key).cloned()
} else {
self.world.block_entities.remove(&key)
};
if let Some(BlockEntity::Chest(items)) = slots {
cart.items = items;
}
}
// ---- dispensers and droppers ----
+16 -55
View File
@@ -558,7 +558,6 @@ impl Game<'_> {
// applyGravity
c.velocity.y -= if self.cart_in_water(c) { 0.005 } else { 0.04 };
let pos = self.rail_block(c.position);
let fall_speed = c.velocity;
if let Some(rail) = self.rail(pos[0], pos[1], pos[2]) {
self.move_along_track(c, pos, &rail, intent);
if &*rail.name == "minecraft:activator_rail" {
@@ -600,22 +599,26 @@ impl Game<'_> {
}
}
CartKind::Tnt => {
let speed = fall_speed.x * fall_speed.x + fall_speed.z * fall_speed.z;
// MinecartTNT.tick: the fuse and the collision check are separate.
if c.fuse > 0 {
c.fuse -= 1;
let at = [c.position.x, c.position.y + 0.5, c.position.z];
self.particles
.add(&ParticleOptions::simple(ParticleType::Smoke), at, [0.0; 3]);
} else if c.fuse == 0 || (c.horizontal_collision && speed >= 0.01) {
} else if c.fuse == 0 {
// explode(horizontalDistanceSqr()): a rising cart's
// vertical speed adds nothing.
let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z;
let speed = if c.fuse == 0 && c.velocity.y > 0.0 {
c.velocity.y * c.velocity.y
} else {
speed
};
self.explode_cart(c, speed);
return false;
}
if c.horizontal_collision {
let speed = c.velocity.x * c.velocity.x + c.velocity.z * c.velocity.z;
if speed >= f64::from(0.01_f32) {
self.explode_cart(c, speed);
return false;
}
}
}
_ => {}
}
@@ -659,51 +662,9 @@ impl Game<'_> {
// The cart is the explosion's source: it is gone before the blast
// looks for entities, so it can't hit itself.
self.carts.retain(|x| x.id != c.id);
let _ = self.server_explode(at, power, BlockInteraction::Destroy, false);
}
/// `MinecartHopper.suckInItems`: items above, into the five slots.
fn hopper_cart_pickup(&mut self, c: &mut Minecart) {
if !c.enabled {
return;
}
let p = c.position;
let zone = Aabb::new(
Vec3::new(p.x - 0.5, p.y - 0.5 + 0.0, p.z - 0.5),
Vec3::new(p.x + 0.5, p.y + 1.5, p.z + 0.5),
);
let mut i = 0;
while i < self.dropped.len() {
let e = &self.dropped[i];
if e.pickup_delay > 0 || !zone.contains(e.position) {
i += 1;
continue;
}
let mut stack = e.stack.clone();
for slot in c.items.iter_mut() {
match slot {
None => {
*slot = Some(stack.clone());
stack.count = 0;
}
Some(s) if s.same_item_same_components(&stack) => {
let max = self.res.items().get(&s.item).map_or(64, |i| i.max_stack);
let moved = stack.count.min(max.saturating_sub(s.count));
s.count += moved;
stack.count -= moved;
}
_ => {}
}
if stack.count == 0 {
break;
}
}
if stack.count == 0 {
self.dropped.remove(i);
} else {
self.dropped[i].stack = stack;
i += 1;
}
}
let _ = self.with_hive_emptying_blast(|g| {
g.server_explode(at, power, BlockInteraction::Destroy, false)
});
}
/// `AbstractMinecart.push` from each player walking into a cart
/// (`LivingEntity.pushEntities`): the window's player and every server
@@ -837,8 +798,8 @@ impl Game<'_> {
}
let mut c = self.carts[i].clone();
let alive = self.tick_cart(&mut c, [0.0; 2]);
if c.kind == CartKind::Hopper {
self.hopper_cart_pickup(&mut c);
if c.kind == CartKind::Hopper && c.enabled {
self.hopper_cart_suck(&mut c);
}
let Some(i) = self.carts.iter().position(|c| c.id == id) else {
continue;
+15 -6
View File
@@ -228,10 +228,12 @@ impl Game<'_> {
return false;
}
let mut used = false;
let mut loved = false;
if love && m.extra.tame && m.extra.age == 0 && m.extra.in_love <= 0 {
m.extra.in_love = 600;
m.extra.love_player = true;
used = true;
loved = true;
}
if m.health < m.attrs.max_health && heal > 0.0 {
m.health = (m.health + heal).min(m.attrs.max_health);
@@ -251,6 +253,7 @@ impl Game<'_> {
// eating(): the mouth opens and the horse eats.
m.anim.v[2] = 1.0;
let at = m.center();
let id = m.id;
let sound = match m.species() {
Species::Camel => "minecraft:entity.camel.eat",
Species::CamelHusk => "minecraft:entity.camel_husk.eat",
@@ -260,6 +263,10 @@ impl Game<'_> {
};
let pitch = (self.world.random.next_float() - self.world.random.next_float()) * 0.2 + 1.0;
self.audio.play(sound, Some(at), 1.0, pitch);
// Animal.setInLove: entity event 18.
if loved {
self.mob_event_particles(id, 18);
}
self.consume_held();
true
}
@@ -465,14 +472,16 @@ impl Game<'_> {
m.extra.owner = owner;
m.persistent = true;
// AbstractHorse.tameWithName: entity event 7, spawnTamingParticles(true).
self.particles_around_mob(
mob,
"heart",
horizon_client::particles::Burst::TAMING,
);
self.mob_event_particles(mob, 7);
}
}
MobEvent::Buck { mob } if self.riding == Some(mob) => self.dismount_mount(),
MobEvent::Buck { mob } => {
if self.riding == Some(mob) {
self.dismount_mount();
}
// RunAroundLikeCrazyGoal.tick: entity event 6, smoke.
self.mob_event_particles(mob, 6);
}
_ => {}
}
}
+3 -6
View File
@@ -85,13 +85,8 @@ impl Game<'_> {
m.ai.target = None;
}
let sound = nautilus::eat_sound(m);
let kind = if tamed { "heart" } else { "smoke" };
// TamableAnimal.spawnTamingParticles (entity event 7 or 6).
self.particles_around_mob(
self.mobs[index].id,
kind,
horizon_client::particles::Burst::TAMING,
);
self.mob_event_particles(self.mobs[index].id, if tamed { 7 } else { 6 });
self.nautilus_sound(index, sound);
if tamed {
let view = self.mob_entity(&self.mobs[index]);
@@ -145,6 +140,8 @@ impl Game<'_> {
let sound = nautilus::eat_sound(m);
self.use_nautilus_food(item);
self.nautilus_sound(index, sound);
// Animal.setInLove: entity event 18.
self.mob_event_particles(self.mobs[index].id, 18);
return true;
}
false
+173 -4
View File
@@ -21,8 +21,8 @@ use horizon_client::{
text::Text,
};
use horizon_core::{
geometry::{Aabb, Vec3},
random::RandomSource,
geometry::{Aabb, Direction, Vec3},
random::{LegacyRandom, RandomSource},
};
/// A thrown splash or lingering potion in flight.
@@ -120,6 +120,153 @@ fn mob_can_be_affected(
}
}
impl Game<'_> {
/// `LivingEntity.triggerOnDeathMobEffects` (`onMobRemoved` with the reason
/// KILLED) for what Oozing, Weaving and Wind Charged do when their bearer
/// dies. `bearer` is the dying mob's id, `player` whether it is a player,
/// `random` the dying mob's own (`mob.getRandom()`; the world's for the
/// player).
pub(super) fn effects_on_death(
&mut self,
effects: &[&str],
bounds: Aabb,
player: bool,
bearer: Option<u32>,
mut random: Option<&mut LegacyRandom>,
) {
let feet = bounds.bottom_center();
if effects.contains(&"oozing") {
// OozingMobEffect.numberOfSlimesToSpawn: two, fewer when the
// slimes close by already fill the cramming limit.
let limit = self.ui.rules.int("max_entity_cramming");
let mut count = 2;
if limit >= 1 {
let near = bounds.inflate(Vec3::new(2.0, 2.0, 2.0));
let nearby = self
.mobs
.iter()
.filter(|m| {
m.species() == horizon_client::mobs::Species::Slime
&& Some(m.id) != bearer
&& m.bounds().intersects(near)
})
.count()
.min(limit as usize) as i32;
count = (limit - nearby).clamp(0, count);
}
for _ in 0..count {
// spawnSlimeOffspring: a size 2 slime half a block up.
if let Some(id) = self.spawn_mob_for(
"minecraft:slime",
[feet.x, feet.y + 0.5, feet.z],
false,
true,
) && let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
{
horizon_client::mobs::cube::set_size(m, 2);
}
}
}
if effects.contains(&"weaving") && (player || self.ui.rules.bool("mob_griefing")) {
self.spawn_cobwebs_around(
[
feet.x.floor() as i32,
feet.y.floor() as i32,
feet.z.floor() as i32,
],
random.as_deref_mut(),
);
}
if effects.contains(&"wind_charged") {
// A burst centred at half the height, radius 3 to 5.
let center = [feet.x, feet.y + bounds.size().y / 2.0, feet.z];
let r = random.unwrap_or(&mut self.world.random);
let radius = 3.0 + r.next_float() * 2.0;
let _ = self.wind_burst(center, radius, 1.0, false, false);
}
}
/// `WeavingMobEffect.spawnCobwebsRandomlyAround`: two or three cobwebs in
/// free spaces with a solid floor, picked among 15 random blocks within one
/// block of `pos`.
fn spawn_cobwebs_around(&mut self, pos: [i32; 3], mut random: Option<&mut LegacyRandom>) {
let r = random.as_deref_mut().unwrap_or(&mut self.world.random);
let wanted = 2 + r.next_int_bound(2).unwrap_or(0) as usize;
let mut chosen: Vec<[i32; 3]> = Vec::new();
for _ in 0..15 {
let r = random.as_deref_mut().unwrap_or(&mut self.world.random);
let at = [
pos[0] - 1 + r.next_int_bound(3).unwrap_or(0),
pos[1] - 1 + r.next_int_bound(3).unwrap_or(0),
pos[2] - 1 + r.next_int_bound(3).unwrap_or(0),
];
let facts = self.res.facts();
let here = facts.get(self.world.block(at[0], at[1], at[2]));
let below = facts.get(self.world.block(at[0], at[1] - 1, at[2]));
if !chosen.contains(&at)
&& here.replaceable
&& below.sturdy_full & (1 << Direction::Up as u8) != 0
{
chosen.push(at);
if chosen.len() >= wanted {
break;
}
}
}
for at in chosen {
if self.set_state_named(at, "minecraft:cobweb", &[]).is_ok() {
self.level_event_at(3018, at, 0);
}
}
}
/// `InfestedMobEffect.onMobHurt` for the player: from half its height up,
/// along where it looks.
pub(super) fn player_infested(&mut self) {
if let Some(p) = self.player.as_ref() {
let at = [
p.position.x,
p.position.y + f64::from(p.dimensions.height) / 2.0,
p.position.z,
];
let look = super::view_vector(self.yaw, self.pitch);
self.infested_hurt(at, look, None);
}
}
/// A living mob's own random (`Entity.random`), else the world's.
fn bearer_random(&mut self, bearer: Option<u32>) -> &mut LegacyRandom {
match bearer.and_then(|id| self.mobs.iter().position(|m| m.id == id)) {
Some(i) => &mut self.mobs[i].random,
None => &mut self.world.random,
}
}
/// `InfestedMobEffect.onMobHurt`: a 10% chance of one or two silverfish at
/// `at` (half the bearer's height up), thrown along its look direction.
/// The draws are the bearer's (`mob.getRandom()`): `bearer` is the mob,
/// none for the player (the world's random).
pub(super) fn infested_hurt(&mut self, at: [f64; 3], look: [f64; 3], bearer: Option<u32>) {
if self.bearer_random(bearer).next_float() > 0.1 {
return;
}
let count = 1 + self.bearer_random(bearer).next_int_bound(2).unwrap_or(0);
for _ in 0..count {
// Mth.randomBetween(-PI / 2, PI / 2), then the look direction
// scaled by (0.3, 0.45, 0.3) and turned about the y axis.
let half = std::f32::consts::FRAC_PI_2;
let angle = self.bearer_random(bearer).next_float() * (2.0 * half) - half;
let (sin, cos) = angle.sin_cos();
let (x, z) = (look[0] * 0.3, look[2] * 0.3);
let velocity = Vec3::new(
f64::from(x as f32 * cos + z as f32 * sin),
look[1] * 0.3 * 1.5,
f64::from(-x as f32 * sin + z as f32 * cos),
);
if let Some(id) = self.spawn_mob_for("minecraft:silverfish", at, false, true)
&& let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
{
m.velocity = velocity;
}
self.audio
.play("minecraft:entity.silverfish.hurt", Some(at), 1.0, 1.0);
}
}
/// A splash potion, lingering potion or experience bottle in flight (the
/// player's throws and dispensers both end up here).
pub(super) fn launch_thrown(
@@ -473,12 +620,34 @@ impl Game<'_> {
return;
};
if player.health.dead_or_dying() {
// LivingEntity.die → removeAllEffects.
// LivingEntity.die → removeAllEffects. Vanilla runs the effects
// that act on death (`onMobRemoved`) when the dead player is
// removed, up to 20 ticks later; here it is as the effects go.
let w = f64::from(player.dimensions.width) / 2.0;
let bounds = Aabb::new(
Vec3::new(
player.position.x - w,
player.position.y,
player.position.z - w,
),
Vec3::new(
player.position.x + w,
player.position.y + f64::from(player.dimensions.height),
player.position.z + w,
),
);
let ids: Vec<&'static str> = self.potions.effects.list.iter().map(|e| e.id).collect();
self.potions.effects.clear();
if !ids.is_empty() {
self.effects_on_death(&ids, bounds, true, None, None);
}
}
// The omens act from inside the effect tick (BadOmenMobEffect,
// RaidOmenMobEffect).
let absorption_empty = player.health.absorption() <= 0.0;
let absorption_empty = self
.player
.as_ref()
.is_some_and(|p| p.health.absorption() <= 0.0);
let mut effects = std::mem::take(&mut self.potions.effects);
let (actions, raid_omen_added) =
effects.tick_with(&mut |e| self.omen_tick(e), absorption_empty);
+67 -3
View File
@@ -1914,7 +1914,8 @@ impl Game<'_> {
}
C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers),
// ClientPacketListener.handleEntityLinkPacket: who holds a mob's
// lead (this player, another player or a mob), for the rope.
// lead (this player, another player, a mob or a fence knot), for
// the rope.
C::SetEntityLink(p) => {
let me = self.remote.as_ref().map(|r| r.entity_id);
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.source as u32) {
@@ -1922,7 +1923,12 @@ impl Game<'_> {
m.extra.leash = match p.dest {
0 => None,
d if Some(d) == me => Some(Holder::Player),
d => Some(Holder::Mob(d as u32)),
d => match self.remote_knots.get(&(d as u32)) {
Some(&block) => Some(Holder::Knot(block)),
// Not a known knot yet: kept by id until the knot
// arrives (game/remote_objects.rs).
None => Some(Holder::Mob(d as u32)),
},
};
}
}
@@ -2194,8 +2200,9 @@ impl Game<'_> {
}
C::HurtAnimation(p) => {
if self.remote.as_ref().is_some_and(|r| r.entity_id == p.id) {
// Player.animateHurt: the tilt turns around the yaw.
if let Some(pl) = self.player.as_mut() {
pl.health.animate_hurt();
pl.health.animate_hurt_dir(p.yaw);
}
} else if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
m.hurt_time = 10;
@@ -2232,6 +2239,10 @@ impl Game<'_> {
{
m.health = 0.0;
}
// The events that start a mob's animation (the warden's).
if let Some(m) = self.mobs.iter_mut().find(|m| m.id == p.id as u32) {
horizon_client::mobs::sync::entity_event(m, p.event as u8);
}
// LivingEntity.handleEntityEvent 60: the poof as the dead body goes.
if p.event == 60
&& let Some(m) = self.mobs.iter().find(|m| m.id == p.id as u32)
@@ -2242,6 +2253,37 @@ impl Game<'_> {
if p.event == super::totem::TOTEM_EVENT {
self.remote_totem(p.id);
}
// Mob.handleEntityEvent 20: the spawn poof.
if p.event == 20 && self.mobs.iter().any(|m| m.id == p.id as u32) {
self.poof_particles(p.id as u32);
}
// Villager 12, 13 and 14, TamableAnimal and AbstractHorse 6 and
// 7, Animal and Allay 18: the particles about the mob.
if matches!(p.event, 6 | 7 | 12 | 13 | 14 | 18) {
self.entity_event_particles(p.id as u32, p.event);
}
// Snowball and ThrownEgg.handleEntityEvent 3: the crumbs where
// the projectile is (the server removes it right after).
if p.event == 3 {
let crumbs = self
.creatures
.projectiles
.iter()
.find(|pr| pr.id == p.id as u32)
.and_then(|pr| {
let item = match pr.kind {
horizon_client::projectiles::ProjectileKind::Snowball => {
"minecraft:snowball"
}
horizon_client::projectiles::ProjectileKind::Egg => "minecraft:egg",
_ => return None,
};
Some(([pr.position.x, pr.position.y, pr.position.z], item))
});
if let Some((at, item)) = crumbs {
self.item_burst(at, item);
}
}
if p.event == super::combat::DROWN_EVENT {
self.remote_drown(p.id);
}
@@ -3291,6 +3333,15 @@ impl Game<'_> {
fn tick_remote_level(&mut self) -> Result<()> {
self.ticks += 1;
// AbstractSignEditScreen.tick: the editor closes once its sign is removed.
if let Some(edit) = &self.sign_edit
&& !matches!(
self.world.block_entities.get(&edit.pos),
Some(BlockEntity::Sign(_))
)
{
self.close_sign_editor();
}
self.track_experience_display();
// Leaving a slot clears its bundle's selection here and on the server.
self.tick_bundle_hover();
@@ -3666,6 +3717,7 @@ impl Game<'_> {
m.fluids = fluids;
}
}
let game_time = self.world.game_time;
let Some(r) = self.remote.as_mut() else {
return;
};
@@ -3789,6 +3841,8 @@ impl Game<'_> {
if m.species() == horizon_client::mobs::Species::Bat {
horizon_client::mobs::bat::setup_animation_states(m);
}
// The animation states a server computes in its own `ai_step`.
horizon_client::mobs::sync::client_tick(m, game_time);
}
for o in self.orbs.iter_mut().filter(|_| running) {
o.previous = o.position;
@@ -4390,6 +4444,16 @@ impl Game<'_> {
if self.keys.contains(&KeyCode::ShiftLeft) && hands_full {
return (false, DryUse::default());
}
// BeehiveBlock.useItemOn: shears or a glass bottle on a full hive
// (honey level 5) is SUCCESS, so the click ends after UseItemOn and
// no UseItem follows (the server does the harvest, see `use_beehive`).
if held.is_some_and(|s| matches!(&*s.item, "minecraft:shears" | "minecraft:glass_bottle"))
&& self
.hive_state(hit.pos)
.is_some_and(|(honey, _)| honey == Some(5))
{
return (true, DryUse::default());
}
use horizon_core::geometry::Direction;
let face = match hit.face {
[0, 1, 0] => Direction::Up,
@@ -4,7 +4,7 @@
//! own simulation, which a client of a server doesn't run.
use super::Game;
use horizon_client::mobs::render::{PROFESSIONS, VILLAGER_TYPES};
use horizon_client::mobs::{Mob, Species, Who, bat, tame};
use horizon_client::mobs::{Mob, Species, Who, bat, camel, sniffer, sync, tame};
use horizon_client::particles::{ParticleOptions, ParticleType};
use horizon_protocol::entity_data::{Particle, ParticleData, Value};
use horizon_protocol::registry::Builtin;
@@ -27,6 +27,8 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
// client, which draws the flames. A client doesn't count the
// fire down: the flag goes off when the server's fire is out.
(0, Value::Byte(flags)) => m.fire_ticks = i32::from(flags & 1),
// Entity.DATA_POSE: the pose the species animates by.
(6, Value::Id(pose)) => sync::set_pose(m, (*pose).clamp(0, 17) as u8),
// LivingEntity.DATA_LIVING_ENTITY_FLAGS: using an item 1, in the
// off hand 2. The flag starts and stops the use; the client ticks
// the count itself (a bow's pull follows it).
@@ -100,6 +102,29 @@ fn apply(m: &mut Mob, values: &[(u8, i32, Value)], builtin: &Builtin, local_enti
(Species::Slime | Species::MagmaCube, 18, Value::Int(size)) => {
m.extra.size = (*size).clamp(1, 127);
}
// Warden.CLIENT_ANGER_LEVEL: the heartbeat's pace.
(Species::Warden, 16, Value::Int(anger)) => {
if let Some(st) = m.extra.warden.as_mut() {
st.client_anger = *anger;
}
}
// Sniffer.DATA_STATE (after AgeableMob's two): the animation
// follows it in `sync::client_tick`.
(Species::Sniffer, 18, Value::Id(state)) => {
sniffer::set_state(m, (*state).clamp(0, 6) as u8);
}
// Shulker.DATA_ATTACH_FACE_ID, DATA_PEEK_ID and DATA_COLOR_ID.
(Species::Shulker, 16, Value::Id(face)) => m.extra.variant3 = (*face).clamp(0, 5) as u8,
(Species::Shulker, 17, Value::Byte(peek)) => m.extra.counter = i32::from(*peek),
(Species::Shulker, 18, Value::Byte(color)) => m.extra.color = *color as u8,
// Camel.DASH and LAST_POSE_CHANGE_TICK (after AbstractHorse's
// flags).
(Species::Camel | Species::CamelHusk, 19, Value::Bool(dashing)) => {
camel::set_dashing(m, *dashing);
}
(Species::Camel | Species::CamelHusk, 20, Value::Long(tick)) => {
camel::set_synced_pose_tick(m, *tick);
}
// Pillager.IS_CHARGING_CROSSBOW: the charge pose (Raider's
// IS_CELEBRATING takes 16).
(Species::Pillager, 17, Value::Bool(charging)) => m.extra.flag = *charging,
@@ -1,9 +1,10 @@
//! Boats, minecarts, armor stands, item frames and paintings on a server's
//! Boats, minecarts, armor stands, item frames, paintings and fence knots on a server's
//! client (`ClientPacketListener.handleAddEntity`, `handleSetEntityData`,
//! `handleSetEquipment`): the server simulates them, the client places them
//! where it says and interpolates their moves like a mob's.
use super::Game;
use horizon_client::entities::{ArmorStand, Cushion, ItemFrame, Painting};
use horizon_client::mobs::leash::Holder;
use horizon_core::geometry::Vec3;
use horizon_protocol::entity_data::Value;
use std::sync::Arc;
@@ -24,7 +25,17 @@ impl Game<'_> {
let at = Vec3::new(position[0], position[1], position[2]);
let block = position.map(|v| v.floor() as i32);
self.remove_remote_object(id);
if kind == "minecraft:text_display" {
if kind == "minecraft:leash_knot" {
// A lead that came before its knot waits as a mob holder with the
// knot's id (handleEntityLinkPacket's delayed holder); now it can
// be tied to the fence.
self.remote_knots.insert(id, block);
for m in &mut self.mobs {
if m.extra.leash == Some(Holder::Mob(id)) {
m.extra.leash = Some(Holder::Knot(block));
}
}
} else if kind == "minecraft:text_display" {
self.text_displays.insert(
id as i32,
super::text_displays::RemoteTextDisplay::new(position, yaw),
@@ -304,6 +315,7 @@ impl Game<'_> {
/// Every object a server sent (a new connection, level or dimension).
pub(super) fn clear_remote_objects(&mut self) {
self.text_displays.clear();
self.remote_knots.clear();
self.carts.clear();
self.boats.clear();
self.armor_stands.clear();
@@ -314,6 +326,7 @@ impl Game<'_> {
pub(super) fn remove_remote_object(&mut self, id: u32) {
self.text_displays.remove(&(id as i32));
self.remote_knots.remove(&id);
self.carts.retain(|c| c.id != id);
self.boats.retain(|b| b.id != id);
self.armor_stands.retain(|a| a.id != id);
@@ -74,7 +74,8 @@ pub(super) fn cloud_client_tick(
];
(particle.clone(), v)
};
particles.add(&options, at, velocity);
// `addAlwaysVisibleParticle`.
particles.add_with(&options, at, velocity, false, true);
}
}
@@ -245,6 +245,7 @@ impl Game<'_> {
1.0,
);
}
self.particles.particle_level = self.settings.particles;
if let Some(e) = eye {
self.particles.camera = e;
}
@@ -294,7 +295,8 @@ impl Game<'_> {
let mut random = LegacyRandom::new(self.world.game_time.wrapping_mul(312_987_231));
let radius = self.settings.weather_radius;
let diameter = 2 * radius + 1;
let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32;
let count = (0.225 * (diameter * diameter) as f32 * rain * rain) as i32
/ if self.settings.particles == 1 { 2 } else { 1 };
for _ in 0..count {
let x = block[0] + random.next_int_bound(diameter).unwrap_or(0) - radius;
let z = block[2] + random.next_int_bound(diameter).unwrap_or(0) - radius;
@@ -306,6 +308,10 @@ impl Game<'_> {
{
continue;
}
// The Minimal option stops at the first spot that rains.
if self.settings.particles >= 2 {
break;
}
let below = top - 1;
let (bx, bz) = (random.next_double(), random.next_double());
let state = world.block(x, below, z);
+21 -9
View File
@@ -21,6 +21,9 @@ pub(super) struct SignEditor {
pub line: usize,
/// The line being edited (`AbstractSignEditScreen`'s text field).
edit: EditBox,
/// `AbstractSignEditScreen.messages`: the side's lines as edited, sent
/// when the editor closes, even if the sign is gone by then.
lines: [String; 4],
}
fn sign_box() -> EditBox {
@@ -185,11 +188,19 @@ impl Game<'_> {
}
/// `SignBlock.openTextEdit` for the front side after placement.
pub(super) fn open_sign_editor(&mut self, pos: (i32, i32, i32), front: bool) {
// Minecraft.setScreen: the editor already open is removed first.
self.close_sign_editor();
let lines = match self.world.block_entities.get(&pos) {
Some(BlockEntity::Sign(sign)) if front => sign.front.lines.clone(),
Some(BlockEntity::Sign(sign)) => sign.back.lines.clone(),
_ => Default::default(),
};
self.sign_edit = Some(SignEditor {
pos,
front,
line: 0,
edit: sign_box(),
lines,
});
self.sign_load();
self.keys.clear();
@@ -202,14 +213,11 @@ impl Game<'_> {
pub(super) fn close_sign_editor(&mut self) {
if let Some(edit) = self.sign_edit.take() {
if self.remote.is_some() {
if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&edit.pos) {
let side = if edit.front { &sign.front } else { &sign.back };
self.send(S::SignUpdate(play::SignUpdate {
pos: [edit.pos.0, edit.pos.1, edit.pos.2],
lines: side.lines.clone(),
front: edit.front,
}));
}
self.send(S::SignUpdate(play::SignUpdate {
pos: [edit.pos.0, edit.pos.1, edit.pos.2],
lines: edit.lines,
front: edit.front,
}));
} else {
self.mark_block_entity_updated(edit.pos);
}
@@ -358,7 +366,8 @@ impl Game<'_> {
edit.edit.set_value(&text);
}
}
/// The box's text onto the sign, when it still fits the line.
/// The box's text onto the editor's lines and the sign
/// (`AbstractSignEditScreen.setMessage`), when it still fits the line.
fn sign_write(&mut self) {
let Some(edit) = self.sign_edit.as_ref() else {
return;
@@ -367,6 +376,9 @@ impl Game<'_> {
if !self.sign_fits(&value) {
return;
}
if let Some(edit) = self.sign_edit.as_mut() {
edit.lines[line].clone_from(&value);
}
let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&pos) else {
return;
};
+10 -1
View File
@@ -257,8 +257,17 @@ impl Game<'_> {
let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
return;
};
let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height()));
let at = m.position;
self.lan_entity_event(id as i32, 20, [at.x, at.y, at.z]);
self.poof_particles(id);
}
/// `Mob.handleEntityEvent` 20 (`spawnAnim` on a client): the poof about
/// mob `id`.
pub(super) fn poof_particles(&mut self, id: u32) {
let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
return;
};
let (at, w, h) = (m.position, f64::from(m.width()), f64::from(m.height()));
let options = ParticleOptions::simple(ParticleType::Poof);
for _ in 0..20 {
let r = self.particles.level_random();
+74
View File
@@ -3,6 +3,7 @@
//! player's `PlayerEnderChestContainer`, saved as `EnderItems`).
use super::Game;
use horizon_client::{containers::BlockEntity, items::ItemStack, text::Text};
use horizon_core::random::RandomSource;
pub(super) fn is_shulker_box(name: &str) -> bool {
name.ends_with("shulker_box")
@@ -156,6 +157,79 @@ impl Game<'_> {
);
paired.then_some((other, kind == "right"))
}
/// The open or close sound of a container block (`ChestBlockEntity.playSound`,
/// `BarrelBlockEntity.playSound`, `ShulkerBoxBlockEntity.startOpen`): volume
/// 0.5 and pitch 0.9 to 1.0. A double chest sounds once from the middle of
/// both halves, a barrel from the face it opens on.
pub(super) fn container_sound(&mut self, sound: &str, key: (i32, i32, i32), name: &str) {
let mut at = [
f64::from(key.0) + 0.5,
f64::from(key.1) + 0.5,
f64::from(key.2) + 0.5,
];
if let Some((other, _)) = self.chest_partner(key) {
at[0] = f64::from(key.0 + other.0) / 2.0 + 0.5;
at[2] = f64::from(key.2 + other.2) / 2.0 + 0.5;
} else if name == "minecraft:barrel"
&& let Some(state) = self
.pack
.assets
.registry
.state(self.world.block(key.0, key.1, key.2))
&& let Some(facing) = state.properties.get("facing")
{
let (dx, dy, dz) = match facing.as_str() {
"up" => (0.0, 0.5, 0.0),
"down" => (0.0, -0.5, 0.0),
f => {
let (x, z) = facing_step(f);
(f64::from(x) / 2.0, 0.0, f64::from(z) / 2.0)
}
};
at = [at[0] + dx, at[1] + dy, at[2] + dz];
}
let pitch = self.world.random.next_float() * 0.1 + 0.9;
self.audio.play(sound, Some(at), 0.5, pitch);
}
/// The open or close sound of the container block at `key`, if it has one.
/// Callers play it only when the opener count crosses zero
/// (`ContainerOpenersCounter.onOpen` / `onClose`).
pub(super) fn container_edge_sound(&mut self, key: (i32, i32, i32), open: bool) {
let name = self
.res
.facts()
.get(self.world.block(key.0, key.1, key.2))
.name
.clone();
let sound = if is_shulker_box(&name) {
if open {
"minecraft:block.shulker_box.open"
} else {
"minecraft:block.shulker_box.close"
}
} else if &*name == "minecraft:ender_chest" {
if open {
"minecraft:block.ender_chest.open"
} else {
"minecraft:block.ender_chest.close"
}
} else if name.contains("chest") {
if open {
"minecraft:block.chest.open"
} else {
"minecraft:block.chest.close"
}
} else if &*name == "minecraft:barrel" {
if open {
"minecraft:block.barrel.open"
} else {
"minecraft:block.barrel.close"
}
} else {
return;
};
self.container_sound(sound, key, &name);
}
/// The other half of a double chest at `key`, for neighbour updates.
pub(super) fn chest_other_half(&self, key: (i32, i32, i32)) -> Option<(i32, i32, i32)> {
self.chest_partner(key).map(|p| p.0)
+3 -1
View File
@@ -178,7 +178,9 @@ impl Game<'_> {
];
self.tnts.remove(i);
count -= 1;
self.server_explode(center, 4.0, BlockInteraction::Destroy, false)?;
self.with_hive_emptying_blast(|g| {
g.server_explode(center, 4.0, BlockInteraction::Destroy, false)
})?;
} else {
i += 1;
}
+37
View File
@@ -32,6 +32,8 @@ pub(super) struct ThrownTrident {
pub(super) no_physics: bool,
returning: u32,
creative_only: bool,
/// The guest that threw it (`Projectile.getOwner`); `None` for the host.
guest: Option<u32>,
}
impl ThrownTrident {
/// A trident a server sent (`handleAddEntity`): placed and moved by it.
@@ -51,6 +53,7 @@ impl ThrownTrident {
no_physics: false,
returning: 0,
creative_only: false,
guest: None,
}
}
/// One tick of a server's client: the previous position, then `step`.
@@ -302,11 +305,33 @@ impl Game<'_> {
no_physics: false,
returning: 0,
creative_only: self.creative,
guest: self.lan_acting,
});
self.player_projectile_shot();
self.audio
.play("minecraft:item.trident.throw", at, 1.0, 1.0);
}
/// The thrower's `PLAYER_HURT_ENTITY` for a trident hit: run as the
/// guest that threw it, and not at all once they have left.
fn thrower_hit(
&mut self,
guest: Option<u32>,
victim: &horizon_client::advancements::EntityView,
direct: horizon_client::advancements::EntityView,
damage: f32,
) {
let Some(conn) = guest.filter(|c| self.lan_acting != Some(*c)) else {
self.player_hit(victim, "minecraft:trident", Some(direct), damage);
return;
};
let Some(mut host) = self.lan.take() else {
return;
};
self.as_guest(&mut host, conn, |g| {
g.player_hit(victim, "minecraft:trident", Some(direct), damage)
});
self.lan = Some(host);
}
pub(super) fn tick_tridents(&mut self) {
let Some(eye) = self.eye_position() else {
return;
@@ -394,6 +419,18 @@ impl Game<'_> {
{
self.channel_lightning(at);
}
if hurt_at.is_some()
&& let Some(m) = self.mobs.iter().find(|m| m.id == id)
{
// LivingEntity.hurtServer: PLAYER_HURT_ENTITY.
let victim = self.mob_entity(m);
let direct = horizon_client::advancements::EntityView {
kind: "minecraft:trident".into(),
position: [t.position.x, t.position.y, t.position.z],
..Default::default()
};
self.thrower_hit(t.guest, &victim, direct, damage);
}
self.audio.play(
"minecraft:item.trident.hit",
Some([t.position.x, t.position.y, t.position.z]),
+27 -8
View File
@@ -148,7 +148,7 @@ impl Game<'_> {
// VillagerMakeLove: entity event 13 for the partner, then the parent.
for i in [ib, ia] {
let id = self.mobs[i].id;
self.villager_particles(id, "angry_villager");
self.mob_event_particles(id, 13);
}
return;
};
@@ -173,12 +173,31 @@ impl Game<'_> {
child.extra.bed = Some(bed);
}
// VillagerMakeLove.giveBirth: entity event 12 for the child.
self.villager_particles(id, "heart");
self.mob_event_particles(id, 12);
}
/// `Villager.handleEntityEvent` 12, 13, 14 and 42:
/// `AbstractVillager.addParticlesAroundSelf`.
pub(super) fn villager_particles(&mut self, id: u32, kind: &'static str) {
self.particles_around_mob(id, kind, horizon_client::particles::Burst::VILLAGER);
/// `Level.broadcastEntityEvent` of an event whose `handleEntityEvent`
/// draws particles about the mob (villager 12, 13 and 14, taming 6 and 7,
/// love 18): the guests get the byte, and this game draws it as its own
/// client would.
pub(super) fn mob_event_particles(&mut self, id: u32, event: i8) {
let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
return;
};
let at = [m.position.x, m.position.y, m.position.z];
self.lan_entity_event(id as i32, event, at);
self.entity_event_particles(id, event);
}
/// `handleEntityEvent(event)`'s particles about mob `id`
/// (`Villager`, `TamableAnimal`, `AbstractHorse`, `Animal`, `Allay`).
pub(super) fn entity_event_particles(&mut self, id: u32, event: i8) {
let Some(m) = self.mobs.iter().find(|m| m.id == id) else {
return;
};
if let Some((kind, burst)) =
horizon_client::particles::entity_event_burst(&m.kind.id, event as u8)
{
self.particles_around_mob(id, kind, burst);
}
}
/// `particles::around_self` about mob `id`.
pub(super) fn particles_around_mob(
@@ -315,7 +334,7 @@ impl Game<'_> {
}
// Villager.setLastHurtByMob: entity event 13.
for id in angry {
self.villager_particles(id, "angry_villager");
self.mob_event_particles(id, 13);
}
}
/// `Villager.tellWitnessesThatIWasMurdered`: the villagers that saw a
@@ -370,7 +389,7 @@ impl Game<'_> {
gossip::REPUTATION_CHANGE_PER_TRADE,
);
// Villager.customServerAiStep after a trade: entity event 14.
self.villager_particles(id, "happy_villager");
self.mob_event_particles(id, 14);
}
/// `Villager.getPlayerReputation` of the local player.
pub(super) fn villager_reputation(&self, id: u32) -> i32 {
+1 -1
View File
@@ -130,7 +130,7 @@ impl Game<'_> {
if let Some(id) = owner {
self.note_attacker("minecraft:explosion", id);
}
self.explode(at, 1.0)
self.with_hive_emptying_blast(|g| g.explode(at, 1.0))
}
}
/// Wither skulls drawn as the skull model, blue when dangerous.
@@ -93,7 +93,12 @@ impl WorldRequest {
level.hardcore = o.hardcore;
level.difficulty = horizon_client::title::DIFFICULTIES[o.difficulty()].into();
level.allow_commands = Some(o.commands(creative));
horizon_client::save::write_world_gen_settings(&save_root, level.seed, o.world_gen())?;
horizon_client::save::write_world_gen_settings_with(
&save_root,
level.seed,
o.world_gen(),
o.flat_settings(),
)?;
// WorldCreationUiState.getGameRules, written with the level.
level.game_rules = o.rules.by_name();
}
+43 -2
View File
@@ -39,7 +39,7 @@ mod entity_outline;
mod weather;
use entity_batch::EntityBatch;
pub use entity_batch::{
SHADOW_OVERLAY, TRANSLUCENT_GLINT_ITEM_OVERLAY, TRANSLUCENT_ITEM_OVERLAY,
ENERGY_SWIRL_OVERLAY, SHADOW_OVERLAY, TRANSLUCENT_GLINT_ITEM_OVERLAY, TRANSLUCENT_ITEM_OVERLAY,
TRANSLUCENT_PARTICLE_OVERLAY, WATER_MASK_OVERLAY,
};
@@ -411,6 +411,8 @@ pub struct Renderer {
cloud_uniform: wgpu::Buffer,
cloud_group: wgpu::BindGroup,
additive_pipeline: wgpu::RenderPipeline,
/// `RenderPipelines.ENERGY_SWIRL`: additive, unlit, the sprite repeated within itself.
energy_swirl_pipeline: wgpu::RenderPipeline,
lightning_pipeline: wgpu::RenderPipeline,
lightning: lightning::Renderer,
see_through_pipeline: wgpu::RenderPipeline,
@@ -1899,6 +1901,27 @@ impl Renderer {
alpha_blend,
false,
);
// RenderPipelines.ENERGY_SWIRL: BlendFunction.ADDITIVE (one, one), no culling; no depth
// writes either: vanilla sorts the quads far to near, so every face passes the test.
let one_one = wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::One,
operation: wgpu::BlendOperation::Add,
};
let energy_swirl_pipeline = entity_pipeline_with(
"Energy swirls",
None,
false,
wgpu::CompareFunction::GreaterEqual,
Default::default(),
wgpu::BlendState {
color: one_one,
alpha: one_one,
},
false,
"fs_energy_swirl",
wgpu::ColorWrites::ALL,
);
let lightning_attributes = wgpu::vertex_attr_array![6=>Float32x3];
let lightning_vertex = [
entity_vertex[0].clone(),
@@ -2421,6 +2444,7 @@ impl Renderer {
cloud_uniform,
cloud_group,
additive_pipeline,
energy_swirl_pipeline,
lightning_pipeline,
lightning: lightning::Renderer::new(),
see_through_pipeline,
@@ -4053,6 +4077,7 @@ impl Renderer {
crumbling_quads,
translucent_crumbling_quads,
water_mask_quads,
swirl_quads,
shadow_quads,
translucent_particle_quads,
translucent_item_quads,
@@ -4064,6 +4089,7 @@ impl Renderer {
+ crumbling_quads
+ translucent_crumbling_quads
+ water_mask_quads
+ swirl_quads
+ shadow_quads
+ translucent_particle_quads
+ translucent_item_quads;
@@ -4653,6 +4679,21 @@ impl Renderer {
self.lightning.draw(&mut pass, &frame.lightning);
pass.set_bind_group(0, &self.group, &[]);
}
if swirl_quads > 0 {
pass.set_pipeline(&self.energy_swirl_pipeline);
pass.set_bind_group(0, &self.entity_group, &[]);
pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
pass.draw_indexed(
0..swirl_quads * 6,
((entity_quads
+ crumbling_quads
+ translucent_crumbling_quads
+ water_mask_quads)
* 4) as i32,
0..1,
);
pass.set_bind_group(0, &self.group, &[]);
}
if additive_quads > 0 {
pass.set_pipeline(&self.additive_pipeline);
pass.set_bind_group(0, &self.entity_group, &[]);
@@ -5343,7 +5384,7 @@ mod tests {
let mut batch = super::EntityBatch::default();
let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8));
let vertices = &batch.combined;
assert_eq!(counts, [4, 1, 1, 0, 1, 1, 0]);
assert_eq!(counts, [4, 1, 1, 0, 0, 1, 1, 0]);
assert_eq!(
vertices
.as_chunks::<4>()
+15 -8
View File
@@ -3,13 +3,18 @@ use super::Vertex;
/// Entity materials by a quad's overlay (`Vertex::layer`), in draw order:
/// ordinary entities, breaking cracks (11), translucent breaking cracks (12),
/// the boat water mask (13, `RenderPipelines.WATER_MASK`), entity shadows
/// (14, `RenderPipelines.ENTITY_SHADOW`) and translucent-layer particles (15,
/// drawn after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`)
/// the boat water mask (13, `RenderPipelines.WATER_MASK`), energy swirls
/// (34, `RenderPipelines.ENERGY_SWIRL`), entity shadows (14,
/// `RenderPipelines.ENTITY_SHADOW`), translucent-layer particles (15, drawn
/// after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`)
/// and translucent item quads (32, drawn without depth writes).
const MATERIALS: usize = 7;
const MATERIALS: usize = 8;
/// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
pub const WATER_MASK_OVERLAY: u32 = 13;
/// The overlay of energy swirl quads (`RenderTypes.energySwirl`: the charged creeper's and the
/// powered wither's armour). The light bytes carry the sprite's origin and the colour bytes its
/// size (`breaking::stage_light`), the UV the scrolled position in the sprite.
pub const ENERGY_SWIRL_OVERLAY: u32 = 34;
/// The overlay of entity shadow quads (`RenderTypes.entityShadow`).
pub const SHADOW_OVERLAY: u32 = 14;
/// The overlay of translucent-layer particles (`SingleQuadParticle.Layer.translucent`).
@@ -49,9 +54,10 @@ impl EntityBatch {
11 => 1,
12 => 2,
WATER_MASK_OVERLAY => 3,
SHADOW_OVERLAY => 4,
TRANSLUCENT_PARTICLE_OVERLAY => 5,
TRANSLUCENT_ITEM_OVERLAY | TRANSLUCENT_GLINT_ITEM_OVERLAY => 6,
ENERGY_SWIRL_OVERLAY => 4,
SHADOW_OVERLAY => 5,
TRANSLUCENT_PARTICLE_OVERLAY => 6,
TRANSLUCENT_ITEM_OVERLAY | TRANSLUCENT_GLINT_ITEM_OVERLAY => 7,
_ => 0,
};
self.buckets[material][counts[material]] = index;
@@ -103,12 +109,13 @@ mod tests {
) -> (Vec<Vertex>, [u32; MATERIALS]) {
let mut combined = Vec::with_capacity(entities.len() + additive.len() + hand.len());
let mut counts = [0; MATERIALS];
for (i, layer) in [0, 11, 12, 13, 14, 15].into_iter().enumerate() {
for (i, layer) in [0, 11, 12, 13, 34, 14, 15].into_iter().enumerate() {
for quad in entities.as_chunks::<4>().0 {
let material = match quad[0].layer {
11 => 11,
12 => 12,
13 => 13,
34 => 34,
14 => 14,
15 => 15,
_ => 0,
@@ -405,12 +405,12 @@ pub(super) fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
}
/// Whether a run holds only geometry a gbuffers program can draw from the shared atlas: no
/// celestial body, cloud, beam, End portal or crack (overlay codes Horizon's entity shader
/// draws in its own way; entity.wgsl).
/// celestial body, cloud, beam, End portal, crack or energy swirl (overlay codes Horizon's entity
/// shader draws in its own way; entity.wgsl).
fn plain(run: &[Vertex]) -> bool {
run.iter()
.step_by(4)
.all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12))
.all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12 | 34))
}
/// The programs of entity runs, in the order they draw.
+27
View File
@@ -180,6 +180,12 @@ pub struct PlayerHealth {
pub hurt: State,
/// Client hurt animation; fully blocked hits only refresh the server's hurt state.
pub hurt_animation_time: i32,
/// `Player.hurtDir` on a client: the yaw `ClientboundHurtAnimationPacket`
/// gave, which `GameRenderer.bobHurt` tilts the camera around.
pub hurt_dir: f32,
/// `ServerPlayer.hurtDir` of a hit the player's client hasn't been told
/// of yet (`indicateDamage`).
pub indicated_dir: Option<f32>,
pub dead: bool,
pub sync_velocity: bool,
pub game_time: i64,
@@ -230,6 +236,8 @@ impl PlayerHealth {
last_stamp: 0,
},
hurt_animation_time: 0,
hurt_dir: 0.0,
indicated_dir: None,
dead: false,
sync_velocity: false,
game_time: 0,
@@ -277,6 +285,18 @@ impl PlayerHealth {
self.hurt.hurt_time = 10;
self.hurt_animation_time = 10;
}
/// `LivingEntity.animateHurt(yaw)` on a player: the tilt restarts around
/// `yaw` (`Player.animateHurt` keeps it as `hurtDir`).
pub fn animate_hurt_dir(&mut self, yaw: f32) {
self.animate_hurt();
self.hurt_dir = yaw;
}
/// `ServerPlayer.indicateDamage`: the hit's direction relative to where
/// the player looks, kept for the packet to its client.
pub fn indicate_damage(&mut self, xd: f64, zd: f64, yaw: f32) {
use horizon_core::geometry::trig::{RAD_TO_DEG, atan2};
self.indicated_dir = Some((atan2(zd, xd) * f64::from(RAD_TO_DEG) - f64::from(yaw)) as f32);
}
/// `LocalPlayer.hurtTo` with `flashOnSetHealth`: a drop below the current
/// health starts the hurt animation; `damageCooldownTime` (20 on a drop,
/// 10 on a gain) is what lets `Hud.extractPlayerHealth` blink the hearts.
@@ -380,6 +400,13 @@ impl PlayerMotion {
if outcome.hurt {
h.hurt_animation_time = h.hurt.hurt_time;
}
// `dealDefaultKnockback` ends in `indicateDamage` unless blocked: a
// hit with no direction of its own (`xd` and `zd` zero) is sent as
// the opposite of the player's yaw. A hit that has a direction
// replaces this (`mob_hits_player`).
if outcome.knockback && outcome.blocked <= 0.0 {
h.indicate_damage(0.0, 0.0, self.yaw);
}
let after = h.health() + h.absorption();
if self.hurt_log.len() >= HURT_LOG {
self.hurt_log.remove(0);
+23 -9
View File
@@ -288,6 +288,9 @@ pub struct Menu {
pub player_sounds: Vec<&'static str>,
/// Recipes whose result was taken (`awardUsedRecipes`), for the caller.
pub crafted: Vec<String>,
/// Potions taken from a brewing stand's bottle slots
/// (`PotionSlot.onTake`), for the caller.
pub brewed: Vec<ItemStack>,
/// `LivingEntity.onEquipItem` calls that change the item: the
/// `EquipmentSlot` name and the new stack, in order, for the caller.
pub equipped: Vec<(&'static str, Option<ItemStack>)>,
@@ -683,6 +686,7 @@ impl Menu {
sounds: Vec::new(),
player_sounds: Vec::new(),
crafted: Vec::new(),
brewed: Vec::new(),
equipped: Vec::new(),
merchant: None,
stone: Stonecutter::default(),
@@ -1504,7 +1508,17 @@ impl Menu {
}
/// `ResultSlot.onTake` and the other `Slot.onTake` overrides.
fn on_take(&mut self, env: &Env, s: usize) {
fn on_take(&mut self, env: &Env, s: usize, taken: &ItemStack) {
if self.slots[s].role == Role::Potion {
// BrewingStandMenu.PotionSlot.onTake: a stack with potion contents.
if matches!(
&*taken.item,
"minecraft:potion" | "minecraft:splash_potion" | "minecraft:lingering_potion"
) {
self.brewed.push(taken.clone());
}
return;
}
if self.slots[s].role == Role::MerchantResult {
self.merchant_take(env);
return;
@@ -1671,7 +1685,7 @@ impl Menu {
max_amount: u32,
) -> Option<ItemStack> {
let mut result = self.try_remove(env, s, amount, max_amount)?;
self.on_take(env, s);
self.on_take(env, s, &result);
if self.slots[s].role == Role::CartoResult {
Self::map_crafted(env, &mut result);
}
@@ -2346,7 +2360,7 @@ impl Menu {
return None;
}
if after_take || matches!(self.kind, Kind::Inventory | Kind::Crafting) {
self.on_take(env, index);
self.on_take(env, index, &clicked);
}
// What the result slot's move left over is dropped.
if (index == 0 && matches!(self.kind, Kind::Inventory | Kind::Crafting))
@@ -2594,7 +2608,7 @@ impl Menu {
};
if let Some(mut taken) = self.try_remove(env, s, amount, u32::MAX) {
self.carried = Some(taken.clone());
self.on_take(env, s);
self.on_take(env, s, &taken);
if self.slots[s].role == Role::CartoResult {
// onTake's onCraftedBy edits the carried stack.
Self::map_crafted(env, &mut taken);
@@ -2628,7 +2642,7 @@ impl Menu {
if let Some(c) = self.carried.as_mut() {
c.count += taken.count;
}
self.on_take(env, s);
self.on_take(env, s, &taken);
if self.slots[s].role == Role::CartoResult {
// onCraftedBy edits the taken stack, not the carried one.
Self::map_crafted(env, &mut taken);
@@ -2656,7 +2670,7 @@ impl Menu {
if self.may_pickup(env, target) {
self.containers[PLAYER][inv_slot] = Some(taken.clone());
self.set_by_player(env, target, None);
self.on_take(env, target);
self.on_take(env, target, &taken);
if self.slots[target].role == Role::CartoResult
&& let Some(stack) = self.containers[PLAYER][inv_slot].as_mut()
{
@@ -2684,14 +2698,14 @@ impl Menu {
let part = split(&mut source, max);
self.containers[PLAYER][inv_slot] = Some(source);
self.set_by_player(env, target, Some(part));
self.on_take(env, target);
self.on_take(env, target, &taken);
if !self.inventory_add(env, &mut taken) {
self.drop_stack(&taken);
}
} else {
self.containers[PLAYER][inv_slot] = Some(taken);
self.containers[PLAYER][inv_slot] = Some(taken.clone());
self.set_by_player(env, target, Some(source));
self.on_take(env, target);
self.on_take(env, target, &taken);
}
}
}
+49 -7
View File
@@ -66,6 +66,7 @@ pub mod spawning;
pub mod species;
pub mod strider;
pub mod sulfur_cube;
pub mod sync;
pub mod tame;
pub mod trader;
pub mod transport_items;
@@ -802,6 +803,8 @@ pub struct Extra {
pub memories: Vec<(&'static str, i64, i64)>,
/// A camel's `LAST_POSE_CHANGE_TICK`.
pub pose_change_tick: i64,
/// `Entity.DATA_POSE` as a mob of a server has it (`sync::pose_id`).
pub pose: u8,
/// The school leader a fish follows, and a tropical fish that swims alone.
pub leader: Option<u32>,
pub lone: bool,
@@ -920,6 +923,12 @@ pub enum MobEvent {
mob: u32,
at: [f64; 3],
},
/// `Level.broadcastEntityEvent` for a mob: guests run `sync::entity_event`.
EntityEvent {
mob: u32,
event: i8,
at: [f64; 3],
},
Sound(&'static str, [f64; 3], f32, f32),
/// `ChestBlockEntity.startOpen` / `stopOpen` by a copper golem: the
/// chest's opener count goes up or down (interaction range 3).
@@ -943,6 +952,10 @@ pub enum MobEvent {
slot: usize,
stack: Option<crate::items::ItemStack>,
},
/// `InfestedMobEffect.onMobHurt`: the mob was hurt while infested.
Infested {
mob: u32,
},
/// `OfferFlowerGoal.stop`: the item goes to the target's antenna (saddle)
/// slot if it is empty, as a guaranteed drop.
Gift {
@@ -1026,7 +1039,9 @@ pub enum MobEvent {
mob: u32,
charged: bool,
},
Explode([f64; 3], f32),
/// The centre, the radius and the kind of the mob blowing up (it may be
/// gone from the list by the time the blast is handled).
Explode([f64; 3], f32, Species),
/// Melee or ranged damage to another mob.
AttackMob {
target: u32,
@@ -1090,8 +1105,11 @@ pub enum MobEvent {
at: [f64; 3],
count: u32,
},
/// Client particles about a mob's box (`particles::around_self`).
/// Client particles about a mob's box (`particles::around_self`) and the
/// entity event `event` that shows them, sent for mob `mob`.
AroundSelf {
mob: u32,
event: i8,
kind: &'static str,
feet: [f64; 3],
width: f64,
@@ -1219,6 +1237,12 @@ pub enum MobEvent {
table: &'static str,
at: [f64; 3],
},
/// `Armadillo.customServerAiStep`: the armadillo sheds a scute.
ShedScute {
mob: u32,
at: [f64; 3],
pitch: f32,
},
/// A lead snaps or loses its holder: the lead item drops when asked.
LeashBreak {
mob: u32,
@@ -1575,6 +1599,8 @@ pub struct PlayerView {
pub off_hand: Option<Arc<str>>,
pub head: Option<Arc<str>>,
pub armor_cover: f32,
/// The Invisibility effect (`isInvisible`).
pub invisible: bool,
pub spectator: bool,
/// `PiglinAi.isWearingSafeArmor`: some golden armour.
pub gold_armor: bool,
@@ -1600,6 +1626,17 @@ pub struct PlayerView {
pub passenger: bool,
}
impl PlayerView {
/// `LivingEntity.getVisibilityPercent` without the worn-skull scaling.
pub fn visibility_percent(&self) -> f64 {
let mut visibility = 1.0;
if self.sneaking {
visibility *= 0.8;
}
if self.invisible {
visibility *= 0.7 * f64::from(self.armor_cover).max(0.1);
}
visibility
}
/// `LivingEntity.hasEffect`, by id without namespace.
pub fn has_effect(&self, effect: &str) -> bool {
self.effects.contains(&effect)
@@ -1634,6 +1671,8 @@ pub struct MobWorld<'a> {
pub biomes: &'a crate::biome::Biomes,
/// The `mob_griefing` game rule.
pub mob_griefing: bool,
/// The `mob_drops` game rule (`shouldDropLoot`).
pub mob_drops: bool,
/// `getCurrentDifficultyAt` near the player.
pub difficulty: spawning::LocalDifficulty,
/// The End (its dimension type's monster spawn light rules).
@@ -1942,6 +1981,9 @@ impl Mob {
}
}
}
if self.has_effect("minecraft:infested") {
self.outbox.push(MobEvent::Infested { mob: self.id });
}
// Squid.hurtServer: a squid hurt after a living entity hit it squirts ink.
if matches!(self.species(), Species::Squid | Species::GlowSquid)
&& self.ai.last_hurt_by.is_some()
@@ -2019,14 +2061,14 @@ impl Mob {
}
pub fn add_effect(&mut self, effect: &'static str, ticks: i32, amplifier: i32) {
if let Some(e) = self.extra.effects.iter_mut().find(|e| e.0 == effect) {
// MobEffectInstance.update: a stronger effect replaces the old one
// with its own duration, an equal one keeps the longer duration,
// and a weaker one never changes the active effect.
// MobEffectInstance.update: a stronger effect replaces with its
// own duration, an equal one only extends it; a weaker one is
// ignored (vanilla keeps it hidden behind the active one).
if amplifier > e.2 {
e.1 = ticks;
e.2 = amplifier;
} else if amplifier == e.2 {
e.1 = e.1.max(ticks);
} else if amplifier == e.2 && e.1 != -1 && (ticks == -1 || e.1 < ticks) {
e.1 = ticks;
}
} else {
self.extra.effects.push((effect, ticks, amplifier));
+37 -5
View File
@@ -353,6 +353,10 @@ fn generic(m: &mut Mob) {
g.add(5, Stroll::avoiding_water(if rabbit { 0.6 } else { 1.0 }));
g.add(6, LookAtPlayer::new(6.0));
g.add(7, RandomLookAround::default());
if m.kind.species == Species::Armadillo {
// Armadillo's constructor: pickNextScuteDropTime.
m.extra.egg_time = next_scute_time(m);
}
}
}
/// Subclasses of `net.minecraft.world.entity.monster.Monster`.
@@ -1080,9 +1084,31 @@ fn server_ai_step(
}
m.jump_control_tick();
}
/// `Armadillo.pickNextScuteDropTime`: 5 to 10 minutes.
fn next_scute_time(m: &mut Mob) -> i32 {
m.random.next_int_bound(20 * 60 * 5).unwrap_or(0) + 20 * 60 * 5
}
/// `Armadillo.customServerAiStep`: the scute timer keeps counting down and is
/// only reset once `shouldDropLoot` (not a baby, `mob_drops` on) lets it shed.
fn armadillo_server_ai_step(m: &mut Mob, mob_drops: bool, events: &mut Vec<MobEvent>) {
if !m.alive() {
return;
}
m.extra.egg_time -= 1;
if m.extra.egg_time <= 0 && !m.is_baby() && mob_drops {
let pitch = (m.random.next_float() - m.random.next_float()) * 0.2 + 1.0;
events.push(MobEvent::ShedScute {
mob: m.id,
at: [m.position.x, m.position.y, m.position.z],
pitch,
});
m.extra.egg_time = next_scute_time(m);
}
}
fn custom_server_ai_step(m: &mut Mob, cx: &mut Cx) {
match m.species() {
Species::Rabbit => super::rabbit::server_ai_step(m),
Species::Armadillo => armadillo_server_ai_step(m, cx.w.mob_drops, cx.events),
Species::Sheep => {}
Species::Zombie
| Species::Husk
@@ -1682,25 +1708,31 @@ fn tick_effects(m: &mut Mob) {
let mut effects = std::mem::take(&mut m.extra.effects);
for (effect, ticks, amp) in &mut effects {
let interval = |base: i32| (base >> (*amp).max(0)).max(1);
// MobEffectInstance.tickServer: an infinite (-1) effect times its
// ticks by the mob's tickCount and never counts down.
let infinite = *ticks == -1;
let count = if infinite { m.age as i32 } else { *ticks };
match *effect {
"minecraft:poison"
if *ticks % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 =>
if count % interval(25) == 0 && !m.kind.flags.undead && m.health > 1.0 =>
{
m.damage(1.0, Damage::of(DamageKind::Magic));
}
"minecraft:wither" if *ticks % interval(40) == 0 => {
"minecraft:wither" if count % interval(40) == 0 => {
m.damage(1.0, Damage::of(DamageKind::Magic));
}
"minecraft:regeneration"
if *ticks % interval(50) == 0 && !m.kind.flags.undead && m.alive() =>
if count % interval(50) == 0 && !m.kind.flags.undead && m.alive() =>
{
m.health = (m.health + 1.0).min(m.attrs.max_health);
}
_ => {}
}
*ticks -= 1;
if !infinite {
*ticks -= 1;
}
}
effects.retain(|e| e.1 > 0);
effects.retain(|e| e.1 > 0 || e.1 == -1);
m.extra
.hidden_effects
.retain(|h| effects.iter().any(|e| e.0 == *h));
@@ -625,8 +625,7 @@ fn targetable(m: &mut Mob, w: &MobWorld, who: Who) -> bool {
// TargetingConditions.forNonCombat(): in range (scaled by the
// player's visibility, at least 2) and in sight.
let Some(p) = &w.player else { return false };
let visibility = if p.sneaking { 0.8 } else { 1.0 };
let r = (range * visibility).max(2.0);
let r = (range * p.visibility_percent()).max(2.0);
p.alive && !p.spectator && m.distance_sqr(p.position) <= r * r && m.sees(w, who)
}
Who::Mob(id) => {
+22
View File
@@ -31,6 +31,28 @@ pub fn pose(m: &Mob) -> u8 {
pub(super) fn set_pose(m: &mut Mob, pose: u8) {
m.extra.variant3 = pose;
}
/// `Pose.id` of the pose (`sync::pose_id`), and its inverse.
pub fn pose_id(m: &Mob) -> u8 {
match pose(m) {
SHOOTING => 16,
INHALING => 17,
LONG_JUMPING => 6,
SLIDING => 15,
_ => 0,
}
}
pub(super) fn set_pose_id(m: &mut Mob, id: u8) {
set_pose(
m,
match id {
16 => SHOOTING,
17 => INHALING,
6 => LONG_JUMPING,
15 => SLIDING,
_ => STANDING,
},
);
}
/// `Breeze.getFiringYPosition`.
pub fn firing_y(m: &Mob) -> f64 {
m.position.y + f64::from(m.height()) / 2.0 + f64::from(0.3_f32)
+45 -4
View File
@@ -46,6 +46,25 @@ pub fn sitting(m: &Mob) -> bool {
fn in_transition(m: &Mob) -> bool {
pose_time(m) < if sitting(m) { SIT_DOWN } else { STAND_UP }
}
/// `Camel.getPoseTime` of a client mob from the `LAST_POSE_CHANGE_TICK` it
/// was sent and the client's game time, and whether that value says it sits.
fn client_pose(m: &Mob, game_time: i64) -> (i64, bool) {
let tick = m.extra.pose_change_tick;
(game_time - tick.abs(), tick < 0)
}
/// The camel's `LAST_POSE_CHANGE_TICK` as the server sends it: in game time
/// (a mob counts its own age), negative while sitting.
pub fn synced_pose_tick(m: &Mob, game_time: i64) -> i64 {
let tick = (game_time - pose_time(m)).max(0);
if sitting(m) { -tick.max(1) } else { tick }
}
/// `Entity.onSyncedDataUpdated` for the pose tick of a client mob: its sign
/// is whether it sits. `client_tick` keeps `egg_time` (in the mob's age, for
/// `sitting` and `refuse_to_move`) with it.
pub fn set_synced_pose_tick(m: &mut Mob, tick: i64) {
m.extra.pose_change_tick = tick;
m.extra.egg_time = if tick < 0 { -1 } else { 0 };
}
/// `Camel.refuseToMove`: sitting or getting up or down.
pub fn refuse_to_move(m: &Mob) -> bool {
sitting(m) || in_transition(m)
@@ -167,7 +186,29 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
m.ai.zza = 0.0;
m.ai.nav.stop();
}
// setupAnimationStates.
animation_states(m, pose_time(m), sitting(m));
}
/// `Camel.tick` on a client that is not the server: the dash cooldown, which
/// the dash flag starts, and the keyframe states from the synced pose tick.
pub fn client_tick(m: &mut Mob, game_time: i64) {
if m.extra.anim_ticks > 0 {
m.extra.anim_ticks -= 1;
}
let (pose_time, sitting) = client_pose(m, game_time);
let since = (i64::from(m.age) - pose_time).max(0) as i32;
m.extra.egg_time = if sitting { -since.max(1) } else { since };
animation_states(m, pose_time, sitting);
}
/// `Camel.onSyncedDataUpdated(DASH)`: a dash starts the cooldown unless it
/// runs. Not on the first tick.
pub fn set_dashing(m: &mut Mob, dashing: bool) {
if m.age > 0 && m.extra.anim_ticks == 0 {
m.extra.anim_ticks = DASH_COOLDOWN;
}
m.extra.flag2 = dashing;
}
/// `Camel.setupAnimationStates` for a pose time and whether it sits.
fn animation_states(m: &mut Mob, pose_time: i64, sitting: bool) {
let age = m.age as f32;
if m.extra.ints[0] <= 0 {
m.extra.ints[0] = m.random.next_int_bound(40).unwrap_or(0) + 80;
@@ -176,9 +217,9 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
m.extra.ints[0] -= 1;
}
// isCamelVisuallySitting: (poseTime < 0) != sitting.
let visually_sitting = (pose_time(m) < 0) != sitting(m);
let sitting_down = sitting(m) && pose_time(m) < SIT_DOWN && pose_time(m) >= 0;
let transition = in_transition(m) && pose_time(m) >= 0;
let visually_sitting = (pose_time < 0) != sitting;
let sitting_down = sitting && (0..SIT_DOWN).contains(&pose_time);
let transition = (0..if sitting { SIT_DOWN } else { STAND_UP }).contains(&pose_time);
let dashing = m.extra.flag2;
let st = &mut m.anim.states;
if visually_sitting {
+22 -8
View File
@@ -588,24 +588,38 @@ impl Mob {
if p.creative || p.allies.contains(&self.id) {
return false;
}
self.player_in_range(w, range, check_sight)
self.player_in_range(w, range, check_sight, true)
}
/// forCombat().ignoreInvisibilityTesting() for the player: the check for
/// a target the mob already has, which ignores the visibility scaling.
pub fn can_keep_target_player(&mut self, w: &MobWorld, range: f64) -> bool {
let Some(p) = &w.player else { return false };
if p.creative || p.allies.contains(&self.id) {
return false;
}
self.player_in_range(w, range, true, false)
}
/// TargetingConditions.forNonCombat().range(range).test for the player
/// (seen by anyone, within range scaled by visibility, in sight).
pub fn can_see_player(&mut self, w: &MobWorld, range: f64) -> bool {
self.player_in_range(w, range, true)
self.player_in_range(w, range, true, true)
}
fn player_in_range(&mut self, w: &MobWorld, range: f64, check_sight: bool) -> bool {
/// `scale` is `TargetingConditions.testInvisible`: scale the range by
/// the player's visibility.
fn player_in_range(
&mut self,
w: &MobWorld,
range: f64,
check_sight: bool,
scale: bool,
) -> bool {
let Some(p) = &w.player else { return false };
if !p.alive || p.spectator {
return false;
}
// LivingEntity.getVisibilityPercent
let mut visibility = 1.0;
if p.sneaking {
visibility *= 0.8;
}
if let Some(head) = &p.head {
let mut visibility = if scale { p.visibility_percent() } else { 1.0 };
if let Some(head) = p.head.as_ref().filter(|_| scale) {
let skull = match self.species() {
Species::Zombie | Species::Husk | Species::Drowned | Species::ZombieVillager => {
"minecraft:zombie_head"
@@ -364,8 +364,7 @@ impl Goal for GhastTempt {
let Some(p) = &cx.w.player else { return false };
// getNearestPlayer(TargetingConditions.forNonCombat()
// .ignoreLineOfSight().range(TEMPT_RANGE 16)): creative players too.
let visibility = if p.sneaking { 0.8 } else { 1.0 };
let range = (16.0_f64 * visibility).max(2.0);
let range = (16.0_f64 * p.visibility_percent()).max(2.0);
p.alive
&& !p.spectator
&& (Self::wants(m, &p.main_hand) || Self::wants(m, &p.off_hand))
@@ -184,6 +184,7 @@ pub fn creeper_tick(m: &mut Mob, events: &mut Vec<MobEvent>) {
events.push(MobEvent::Explode(
[m.position.x, m.position.y, m.position.z],
radius,
m.species(),
));
m.removed = true;
}
+11
View File
@@ -563,6 +563,17 @@ impl Mob {
// Entity.checkSupportingBlock
self.supporting = self.supporting_block(w, moved);
self.movement_emission(w, moved, events);
// Entity.applyEffectsFromBlocks: bubble columns push the mob.
if crate::motion::bubble_column_push(
w.world,
w.registry,
w.facts,
w.collision,
self.bounds(),
&mut self.velocity,
) {
self.fall_distance = 0.0;
}
}
/// LivingEntity.checkFallDamage: the fluid state refreshed out of water
/// (touching water resets the fall), then Entity.checkFallDamage.
@@ -359,11 +359,14 @@ fn can_attack(m: &Mob, w: &MobWorld, who: Who) -> bool {
/// `Sensor.isEntityAttackable`: `TargetingConditions.forCombat()` within the
/// follow range, in sight.
fn attackable(m: &mut Mob, w: &MobWorld, who: Who) -> bool {
// The current ATTACK_TARGET is tested with ignoreInvisibilityTesting.
let current = mem_ref(m).attack_target.value() == Some(who);
let range = m.attrs.follow_range;
if !can_attack(m, w, who) {
return false;
}
match who {
Who::Player if current => m.can_keep_target_player(w, range),
Who::Player => m.can_target_player(w, range, true),
Who::Mob(id) => {
let Some(s) = w.seen(id) else { return false };
+40 -8
View File
@@ -664,14 +664,6 @@ pub fn layers(m: &Mob) -> Vec<Layer> {
white,
false,
),
// EnergySwirlLayer (the scroll is not reproduced: atlas sprites do not wrap).
S::Creeper if m.extra.charged => push(
&mut v,
"creeper#armor",
"entity/creeper/creeper_armor",
0x80FF_FFFF,
true,
),
S::TropicalFish => {
// TropicalFishPatternLayer: the pattern tinted with the pattern colour.
let (model, letter, n) = if m.extra.variant < 6 {
@@ -1226,10 +1218,50 @@ fn render_visible(
}
}
}
// EnergySwirlLayer: the armour model, additive, scrolling over the sprite.
if let Some((model, texture, x_offset)) = energy_swirl(m, s.age)
&& let Some(part) = m.kind.layer(model)
&& let Some([u0, v0, u1, v1]) = atlas(texture)
{
layer_poses.reset(part);
anim::setup(m, &s, &mut layer_poses, &data.animations);
// `RenderTypes.energySwirl`'s texture offset, as the sprite-local UV.
let (du, dv) = (x_offset % 1.0, s.age * 0.01 % 1.0);
let start = out.len();
draw(
part,
base,
&layer_poses,
[du, dv, 1.0 + du, 1.0 + dv],
crate::breaking::stage_light([u1 - u0, v1 - v0]),
crate::breaking::stage_light([u0, v0]),
crate::gfx::ENERGY_SWIRL_OVERLAY,
out,
);
// No lighting: the colour bytes carry the sprite's size (fs_energy_swirl).
for vertex in &mut out[start..] {
vertex.normal = [0; 4];
}
}
if shell_last {
draw_body(out);
}
}
/// `EnergySwirlLayer`'s model, texture and `xOffset(t)` for a charged creeper
/// (`CreeperPowerLayer`) or a powered wither (`WitherArmorLayer`); `t` is `ageInTicks`.
fn energy_swirl(m: &Mob, t: f32) -> Option<(&'static str, &'static str, f32)> {
match m.species() {
Species::Creeper if m.extra.charged => {
Some(("creeper#armor", "entity/creeper/creeper_armor", t * 0.01))
}
Species::Wither if super::wither::powered(m) => Some((
"wither#armor",
"entity/wither/wither_armor",
(t * 0.02).mcos() * 3.0,
)),
_ => None,
}
}
/// The equipment slot of a `HumanoidArmorLayer` model (`zombie#helmet`).
fn armor_slot(model: &str) -> Option<usize> {
Some(match model.rsplit('#').next()? {
@@ -325,6 +325,13 @@ pub fn look_yaw(m: &Mob, at: [f64; 3]) -> Option<f32> {
f64::from(delta_forward),
))
}
/// `Shulker.tick` on a client that is not the server: the lid eases to the
/// peek it was sent, and its body stays square (`ShulkerBodyRotationControl`).
pub fn client_tick(m: &mut Mob) {
m.anim.vo = m.anim.v;
ease_peek(m);
m.body_yaw = 0.0;
}
/// `Shulker.hurtServer` before the damage: arrows bounce off a closed shell.
pub fn accepts(m: &Mob, source: &Damage) -> bool {
!(m.extra.counter == 0 && source.kind == DamageKind::Arrow)
+22 -16
View File
@@ -74,23 +74,8 @@ pub fn head_block(m: &Mob) -> [i32; 3] {
/// the dropped seed and the water malus.
pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
use super::path::PathType;
let age = m.age as f32;
let current = state(m);
if current != m.extra.scratch[0] as u8 {
// resetAnimations, then the state's own.
for s in &mut m.anim.states[..5] {
s.stop();
}
match current {
FEELING_HAPPY => m.anim.states[0].start_if_stopped(age),
SCENTING => m.anim.states[1].start_if_stopped(age),
SNIFFING => m.anim.states[2].start_if_stopped(age),
DIGGING => m.anim.states[3].start_if_stopped(age),
RISING => m.anim.states[4].start_if_stopped(age),
_ => {}
}
m.extra.scratch[0] = i32::from(current);
}
animate(m);
if current == DIGGING && now(m) == m.extra.ints[3] {
let h = head_block(m);
events.push(MobEvent::GiftLoot {
@@ -110,6 +95,27 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
let wet = m.fluids.in_water || m.fire_ticks > 0;
m.set_malus(PathType::Water, if wet { 0.0 } else { -1.0 });
}
/// `Sniffer.onSyncedDataUpdated(DATA_STATE)`: the animation states of the
/// state it changed to (on a client, each tick for the state it has).
pub fn animate(m: &mut Mob) {
let age = m.age as f32;
let current = state(m);
if current != m.extra.scratch[0] as u8 {
// resetAnimations, then the state's own.
for s in &mut m.anim.states[..5] {
s.stop();
}
match current {
FEELING_HAPPY => m.anim.states[0].start_if_stopped(age),
SCENTING => m.anim.states[1].start_if_stopped(age),
SNIFFING => m.anim.states[2].start_if_stopped(age),
DIGGING => m.anim.states[3].start_if_stopped(age),
RISING => m.anim.states[4].start_if_stopped(age),
_ => {}
}
m.extra.scratch[0] = i32::from(current);
}
}
/// The brain memory holding the explored positions
/// (`SNIFFER_EXPLORED_POSITIONS`).
pub fn to_nbt(m: &Mob, map: &mut horizon_world::nbt::Compound) {
@@ -371,6 +371,7 @@ pub fn ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
events.push(MobEvent::Explode(
[m.position.x, m.position.y + 0.0625, m.position.z],
power,
m.species(),
));
m.removed = true;
return;
+85
View File
@@ -0,0 +1,85 @@
//! A server's mobs as a client animates them. The server thread, a LAN host
//! and a dedicated server run each mob's animation state (`ai::tick`); a
//! client of a server only gets synched data and entity events, and runs the
//! animation steps vanilla runs on the client (`Entity.onSyncedDataUpdated`,
//! `handleEntityEvent` and the per tick animation states). The server's half
//! is `game/lan.rs` (`mob_meta`, with `pose_id` here for index 6) and
//! `MobEvent::EntityEvent`; the client's half is `game/remote_mob_data.rs`,
//! `game/remote.rs` (`C::EntityEvent`) and `client_tick` here.
//!
//! To animate another species for a client:
//! - send its synched data in `mob_meta` and read it in
//! `remote_mob_data::apply`;
//! - send its poses in `pose_id` and read them in `set_pose`;
//! - broadcast its entity events with `MobEvent::EntityEvent` and handle
//! them in `entity_event`;
//! - run its client side animation in `client_tick`, sharing the function
//! with the server's `ai_step` where the server computes the same.
use super::{Mob, Species, breeze, camel, shulker, sniffer, warden};
// `Pose.id` of the poses mobs take.
pub const STANDING: u8 = 0;
pub const LONG_JUMPING: u8 = 6;
pub const SITTING: u8 = 10;
pub const ROARING: u8 = 11;
pub const SNIFFING: u8 = 12;
pub const EMERGING: u8 = 13;
pub const DIGGING: u8 = 14;
pub const SLIDING: u8 = 15;
pub const SHOOTING: u8 = 16;
pub const INHALING: u8 = 17;
/// `Entity.DATA_POSE` (index 6) of a mob of a server: the pose its species
/// keeps in its own fields.
pub fn pose_id(m: &Mob) -> u8 {
match m.species() {
Species::Warden => warden::pose_id(m),
Species::Breeze => breeze::pose_id(m),
Species::Camel | Species::CamelHusk if camel::sitting(m) => SITTING,
_ => STANDING,
}
}
/// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client.
pub fn set_pose(m: &mut Mob, id: u8) {
m.extra.pose = id;
match m.species() {
Species::Warden => warden::set_pose_id(m, id),
Species::Breeze => breeze::set_pose_id(m, id),
_ => {}
}
}
/// The per tick animation steps of a client's mobs (after `m.age` moved on),
/// for the species whose server runs them in `ai_step`. `game_time` is the
/// client level's.
pub fn client_tick(m: &mut Mob, game_time: i64) {
match m.species() {
Species::Warden => warden::client_tick(m),
Species::Sniffer => sniffer::animate(m),
Species::Breeze => breeze::ai_step(m),
Species::Camel | Species::CamelHusk => camel::client_tick(m, game_time),
Species::Shulker => shulker::client_tick(m),
_ => {}
}
}
/// `handleEntityEvent` of the mob types that start animations by an event
/// (`ClientboundEntityEventPacket` for a mob of a client).
pub fn entity_event(m: &mut Mob, event: u8) {
let age = m.age as f32;
if m.species() == Species::Warden {
match event {
// Attack: the roar ends, the swing starts.
4 => {
m.anim.states[warden::ROAR].stop();
m.anim.states[warden::ATTACK].start(age);
}
// The tendrils twitch.
61 => m.anim.v[warden::TENDRIL] = 10.0,
// The sonic boom.
62 => m.anim.states[warden::SONIC_BOOM].start(age),
_ => {}
}
}
}
@@ -2918,11 +2918,18 @@ impl B {
let mut bodies = Vec::new();
if let Some(t) = cx.w.target_info(target) {
let (min, max) = (t.bounds.min_position(), t.bounds.max_position());
bodies.push((t.position, max.x - min.x, max.y - min.y));
bodies.push((partner, t.position, max.x - min.x, max.y - min.y));
}
bodies.push((m.position, f64::from(m.width()), f64::from(m.height())));
for (feet, width, height) in bodies {
bodies.push((
m.id,
m.position,
f64::from(m.width()),
f64::from(m.height()),
));
for (mob, feet, width, height) in bodies {
cx.events.push(MobEvent::AroundSelf {
mob,
event: 12,
kind: "heart",
feet: [feet.x, feet.y, feet.z],
width,
@@ -3605,6 +3612,8 @@ fn pois_scan_order(_m: &Mob, found: &[(Poi, [i32; 3])]) -> Vec<usize> {
/// `AbstractVillager.addParticlesAroundSelf(HAPPY_VILLAGER)` on the client.
fn happy_particles(m: &Mob, cx: &mut Bx) {
cx.events.push(MobEvent::AroundSelf {
mob: m.id,
event: 14,
kind: "happy_villager",
feet: [m.position.x, m.position.y, m.position.z],
width: f64::from(m.width()),
+58 -7
View File
@@ -67,6 +67,29 @@ impl Pose {
}
}
}
/// `Pose.id` of the poses a warden takes (`sync::pose_id`).
pub fn pose_id(m: &Mob) -> u8 {
match pose(m) {
Pose::Standing => 0,
Pose::Roaring => 11,
Pose::Sniffing => 12,
Pose::Emerging => 13,
Pose::Digging => 14,
}
}
/// `Entity.onSyncedDataUpdated(DATA_POSE)` on a client.
pub(super) fn set_pose_id(m: &mut Mob, id: u8) {
set_pose(
m,
match id {
11 => Pose::Roaring,
12 => Pose::Sniffing,
13 => Pose::Emerging,
14 => Pose::Digging,
_ => Pose::Standing,
},
);
}
/// The warden's pose (kept in `Extra.counter` so it can be read while the
/// brain is being ticked).
pub fn pose(m: &Mob) -> Pose {
@@ -434,6 +457,11 @@ pub fn do_push(m: &mut Mob, w: &MobWorld, who: Who, events: &mut Vec<MobEvent>)
pub(super) fn do_hurt_target(m: &mut Mob, target: Who, w: &MobWorld, events: &mut Vec<MobEvent>) {
m.anim.states[ROAR].stop();
m.anim.states[ATTACK].start(m.age as f32);
events.push(MobEvent::EntityEvent {
mob: m.id,
event: 4,
at: at(m),
});
let pitch = voice_pitch(m);
sound(m, "entity.warden.attack_impact", 10.0, pitch, events);
warden_brain::mem(m).sonic_boom_cooldown.set_ttl((), 40);
@@ -546,6 +574,11 @@ fn receive_vibration(m: &mut Mob, w: &MobWorld, info: Info, events: &mut Vec<Mob
warden_brain::mem(m).vibration_cooldown.set_ttl((), 40);
// Entity event 61: the tendrils twitch.
m.anim.v[TENDRIL] = 10.0;
events.push(MobEvent::EntityEvent {
mob: m.id,
event: 61,
at: at(m),
});
let pitch = voice_pitch(m);
sound(m, "entity.warden.tendril_clicks", 5.0, pitch, events);
let origin = [
@@ -731,13 +764,7 @@ pub(super) fn tick_sonic_boom(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEve
/// of the warden: a level event sound here), the tendril and heart
/// animations, digging crumbs, and keyframes that ended.
pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
let Some(st) = m.extra.warden.as_ref() else {
return;
};
let client_anger = st.client_anger;
let delay = heart_beat_delay(client_anger);
if i64::from(m.age) % i64::from(delay) == 0 {
m.anim.v[HEART] = 10.0;
if heartbeat(m) {
events.push(MobEvent::LevelEventSound {
sound: "entity.warden.heartbeat",
at: at(m),
@@ -745,6 +772,30 @@ pub fn ai_step(m: &mut Mob, events: &mut Vec<MobEvent>) {
spread: 0.2,
});
}
animate(m, events);
}
/// The heart's beat on its clock, from the client's anger level: whether
/// this tick has one (its sound is the caller's).
fn heartbeat(m: &mut Mob) -> bool {
let Some(st) = m.extra.warden.as_ref() else {
return false;
};
let delay = heart_beat_delay(st.client_anger);
let beat = i64::from(m.age) % i64::from(delay) == 0;
if beat {
m.anim.v[HEART] = 10.0;
}
beat
}
/// `Warden.tick` on a client that is not the server: the heart and tendril
/// animations and the keyframes that ended. Its sounds and particles come
/// from the server.
pub fn client_tick(m: &mut Mob) {
m.anim.vo = m.anim.v;
heartbeat(m);
animate(m, &mut Vec::new());
}
fn animate(m: &mut Mob, events: &mut Vec<MobEvent>) {
// The animation values count down after the sync of the last tick.
for slot in [TENDRIL, HEART] {
if m.anim.v[slot] > 0.0 {
@@ -937,6 +937,11 @@ impl B {
mm.sonic_boom_sound_delay.set_ttl((), SONIC_SOUND_DELAY);
// Entity event 62: the sonic boom keyframes start.
m.anim.states[warden::SONIC_BOOM].start(m.age as f32);
cx.events.push(MobEvent::EntityEvent {
mob: m.id,
event: 62,
at: [m.position.x, m.position.y, m.position.z],
});
sound(m, "entity.warden.sonic_charge", 3.0, 1.0, cx.events);
true
}
+1
View File
@@ -221,6 +221,7 @@ pub fn custom_server_ai_step(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEven
events.push(MobEvent::Explode(
[m.position.x, m.eye_y(), m.position.z],
7.0,
m.species(),
));
// Global level event 1023.
if !m.silent {
+1 -1
View File
@@ -44,7 +44,7 @@ use std::{
pub(crate) mod environment;
mod fluids;
pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER};
pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER, bubble_column_push};
pub struct MotionResources {
pub attributes: Arc<Catalog>,
@@ -119,6 +119,67 @@ impl PlayerMotion {
!self.fluids.first_tick && self.fluids.interaction.is_in_fluid(&FluidTags, LAVA)
}
}
/// `BubbleColumnBlock.entityInside` for an entity that is not the player (a mob,
/// a dropped item, an ender pearl): the bubble columns its box touches push it
/// up or drag it down, harder at the surface (`Entity.handleOnAboveBubbleColumn`
/// and `handleOnInsideBubbleColumn`). Returns whether it was inside a column
/// below the surface, which resets its fall distance.
pub fn bubble_column_push(
world: &World,
registry: &horizon_world::registry::BlockRegistry,
facts: &crate::blocks::BlockFacts,
collision: &horizon_world::block_collision::BlockCollisionRegistry<'_>,
bounds: Aabb,
velocity: &mut Vec3,
) -> bool {
let b = bounds.deflate(Vec3::new(
f64::from(1.0e-5f32),
f64::from(1.0e-5f32),
f64::from(1.0e-5f32),
));
let (lo, hi) = (b.min_position(), b.max_position());
let mut reset_fall = false;
for x in lo.x.floor() as i32..=(hi.x.ceil() as i32 - 1) {
for y in lo.y.floor() as i32..=(hi.y.ceil() as i32 - 1) {
for z in lo.z.floor() as i32..=(hi.z.ceil() as i32 - 1) {
let state = world.block(x, y, z);
if &*facts.get(state).name != "minecraft:bubble_column" {
continue;
}
let drag = registry
.state(state)
.and_then(|s| s.properties.get("drag"))
.is_some_and(|d| d == "true");
let above = world.block(x, y + 1, z);
// stateAbove.getCollisionShape(level, pos): the shape is asked
// at the column's own position.
let mut scene = SceneCollisions {
world,
binding: collision,
subject: None,
};
let context = horizon_world::collision_context::CollisionContext::empty(false);
let nothing_above = collision
.collision_shape_with_context(
&mut scene,
above,
BlockPos::new(x, y, z),
&context,
)
.is_ok_and(|shape| shape.is_empty())
&& facts.get(above).fluid == crate::blocks::Fluid::None;
velocity.y = match (nothing_above, drag) {
(true, true) => (-0.9_f64).max(velocity.y - 0.03),
(true, false) => 1.8_f64.min(velocity.y + 0.1),
(false, true) => (-0.3_f64).max(velocity.y - 0.03),
(false, false) => 0.7_f64.min(velocity.y + 0.06),
};
reset_fall |= !nothing_above;
}
}
}
reset_fall
}
/// Which fluids `FluidTags.WATER` and `FluidTags.LAVA` hold.
pub struct FluidTags;
impl FluidMembership for FluidTags {
+1 -1
View File
@@ -4,9 +4,9 @@
//! and an overlay resource root that layers the enabled packs over the
//! vanilla resources (later packs win), so every loader sees one tree.
mod cache;
pub mod pattern;
use crate::text::Style;
use crate::{text::Text, zip::Zip};
pub use horizon_client_core::pattern;
use pattern::Pattern;
use std::{
collections::{BTreeMap, BTreeSet},
+41 -23
View File
@@ -994,6 +994,8 @@ pub struct ParticleEngine {
emitters: Vec<(ParticleOptions, [f64; 3], f64, f64, u32)>,
/// Camera position for the 32-block spawn limiter.
pub camera: [f64; 3],
/// The Particles option (`ParticleStatus`): 0 all, 1 decreased, 2 minimal.
pub particle_level: u8,
/// FireworkParticles.Starter instances.
starters: Vec<Starter>,
/// Local sounds requested by particles (dripstone drips): (event, position, volume, pitch).
@@ -1024,6 +1026,7 @@ impl ParticleEngine {
emitters: Vec::new(),
starters: Vec::new(),
camera: [0.0; 3],
particle_level: 0,
sounds: Vec::new(),
made: Default::default(),
item_sprites: HashMap::new(),
@@ -1134,30 +1137,48 @@ impl ParticleEngine {
&mut self.level_random
}
/// `ClientLevel.addParticle`: dropped beyond 32 blocks of the camera unless
/// the type overrides the limiter.
/// the type overrides the limiter, and thinned by the Particles option.
pub fn add(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
self.add_with(options, p, v, false, false);
}
/// `ClientLevel.addParticle(particle, overrideLimiter, alwaysShow, ...)`
/// (`doAddParticle`). `always_show` is `addAlwaysVisibleParticle`'s flag.
pub fn add_with(
&mut self,
options: &ParticleOptions,
p: [f64; 3],
v: [f64; 3],
override_limiter: bool,
always_show: bool,
) {
let c = self.camera;
let d2 = (p[0] - c[0]).powi(2) + (p[1] - c[1]).powi(2) + (p[2] - c[2]).powi(2);
if let Some(requested) = &mut self.requested {
requested.push((options.clone(), p, v));
return;
}
if !options.ty.override_limiter() && d2 > 1024.0 {
return;
let minimal = self.calculate_particle_level(always_show) == 2;
if override_limiter || options.ty.override_limiter() || (d2 <= 1024.0 && !minimal) {
self.create(options, p, v);
}
self.create(options, p, v);
}
/// `ClientLevel.calculateParticleLevel`: minimal still shows one in ten
/// always-visible particles as decreased, and decreased drops a third.
fn calculate_particle_level(&mut self, always_show: bool) -> u8 {
let mut level = self.particle_level.min(2);
if always_show && level == 2 && self.level_random.next_int_bound(10).unwrap_or(0) == 0 {
level = 1;
}
if level == 1 && self.level_random.next_int_bound(3).unwrap_or(0) == 0 {
level = 2;
}
level
}
/// `LevelEventHandler.singleBlockTeleportationParticles` towards
/// `BlockUtil.unpackDifferenceInPosition(from, data, radius)`: the dragon
/// egg's event 2015 packs offsets within (16, 8, 16), a consumable's
/// teleport (2017) within (127, 127, 127).
pub fn block_teleportation(
&mut self,
from: [i32; 3],
data: i32,
radius: [i32; 3],
particle_level: u8,
) {
pub fn block_teleportation(&mut self, from: [i32; 3], data: i32, radius: [i32; 3]) {
let to = [
from[0].wrapping_add(((data >> 16) & 255) - radius[0]),
from[1].wrapping_add(((data >> 8) & 255) - radius[1]),
@@ -1175,15 +1196,7 @@ impl ParticleEngine {
to[1] + t * (from[1] - to[1]) + r.next_double() - 0.5,
to[2] + t * (from[2] - to[2]) + (r.next_double() - 0.5) + 0.5,
];
// The option roll shares the level random and precedes the distance check.
let limited = match particle_level {
1 => r.next_int_bound(3).unwrap_or(0) == 0,
2 => true,
_ => false,
};
if !limited {
self.add(&options, position, velocity);
}
self.add(&options, position, velocity);
}
}
/// `ClientPacketListener.handleExplosion` + `ClientExplosionTracker`: the
@@ -1225,6 +1238,10 @@ impl ParticleEngine {
block_count: usize,
is_air: &dyn Fn([i32; 3]) -> bool,
) {
// ClientExplosionTracker.tick: only the All option throws the debris.
if self.particle_level != 0 {
return;
}
for _ in 0..block_count.min(512) {
let r = &mut self.random;
let d = Vec3::new(
@@ -3789,7 +3806,7 @@ mod tests {
let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
engine.seed_randoms(0, 0, 0);
// Destination offset (-15, 7, 15); the unused top byte is ignored.
engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16], 0);
engine.block_teleportation([4, 12, -5], 0xff01_0f1fu32 as i32, [16, 8, 16]);
assert_eq!(engine.pending.len(), 128);
assert!(engine.pending.iter().all(|p| p.ty == ParticleType::Portal));
let first = &engine.pending[0];
@@ -3816,7 +3833,7 @@ mod tests {
// TeleportRandomlyConsumeEffect: BlockUtil.clampedPackDifferenceInPosition
// of the move (-7, -3, 9) with radii 127, from (4, 12, -5) to (-3, 9, 4).
let data = (-7 + 127) << 16 | (-3 + 127) << 8 | (9 + 127);
engine.block_teleportation([4, 12, -5], data, [127, 127, 127], 0);
engine.block_teleportation([4, 12, -5], data, [127, 127, 127]);
assert_eq!(engine.pending.len(), 128);
for p in &engine.pending {
let [x, y, z] = p.position;
@@ -3842,7 +3859,8 @@ mod tests {
if distant {
engine.camera = [1000.0; 3];
}
engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16], option);
engine.particle_level = option;
engine.block_teleportation([4, 12, -5], 0x010f1f, [16, 8, 16]);
assert_eq!(engine.pending.len(), if distant { 0 } else { count });
assert_eq!(engine.level_random.state(), state);
}
+98 -53
View File
@@ -339,59 +339,7 @@ impl SaveTables {
}
}
/// A container's loot table and what Horizon rolled from it. Vanilla keeps
/// `LootTable` and `LootTableSeed` until the container is first opened;
/// Horizon rolls when it generates or loads the chunk, and saves the table
/// again while the container still holds exactly the rolled items.
#[derive(Clone, Debug, PartialEq)]
pub struct RolledLoot {
pub pos: (i32, i32, i32),
pub table: String,
/// The saved `LootTableSeed`, written back unless 0 (trySaveLootTable).
pub seed: Option<i64>,
/// The rolled `Items`.
pub items: Tag,
}
impl RolledLoot {
/// Puts the loot table back in place of `Items` while they are still the
/// roll; false once the container holds anything else.
pub fn restore(&self, map: &mut Compound) -> bool {
if map.get(&"Items".into()) != Some(&self.items) {
return false;
}
map.remove(&"Items".into());
map.insert("LootTable".into(), string(&self.table));
if let Some(seed) = self.seed.filter(|s| *s != 0) {
map.insert("LootTableSeed".into(), Tag::Long(seed));
}
true
}
}
/// Save data loaded with a chunk that Horizon keeps but does not simulate.
#[derive(Clone, Debug, Default)]
pub struct ChunkExtras {
/// Chunk root keys written back as loaded (structures, PostProcessing,
/// InhabitedTime, blending data, ...).
pub root: Compound,
/// Block entities Horizon does not model.
pub block_entities: Vec<Tag>,
/// The NBT of the modelled block entities as loaded, to restore the fields and
/// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
/// Every saved block entity's position in the order of the save's list,
/// the order `SerializableChunkData` puts them in the chunk's maps.
pub block_entity_order: Vec<(i32, i32, i32)>,
/// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
/// save time. Registered with the level's tick scheduler on arrival and
/// replaced with the scheduler's pending ticks when saving.
pub block_ticks: Vec<SavedTick>,
pub fluid_ticks: Vec<SavedTick>,
/// Game time written as `LastUpdate`.
pub last_update: i64,
/// Containers still holding their loot table's roll.
pub rolled_loot: Vec<RolledLoot>,
}
pub use crate::chunk::{ChunkExtras, RolledLoot};
fn tick_list(ticks: &[SavedTick], name: impl Fn(u32) -> Option<String>) -> Tag {
Tag::List(
@@ -643,6 +591,16 @@ pub fn encode_block_entity(
entries.push(("custom_name", name.clone()));
}
}
// TheEndGatewayBlockEntity.saveAdditional.
BlockEntity::EndGateway(g) => {
entries.push(("Age", Tag::Long(g.age)));
if let Some(exit) = g.exit_portal {
entries.push(("exit_portal", Tag::IntArray(exit.to_vec())));
}
if g.exact_teleport {
entries.push(("ExactTeleport", Tag::Byte(1)));
}
}
BlockEntity::Spawner(s) => entries.extend(s.save()),
BlockEntity::TrialSpawner(s) => entries.extend(s.save()),
BlockEntity::Vault(v) => entries.extend(v.save()),
@@ -702,11 +660,24 @@ fn roll_loaded_loot(
biome,
))
}
/// `TheEndGatewayBlockEntity.loadAdditional`.
pub fn decode_end_gateway(tag: &Tag) -> crate::containers::EndGateway {
crate::containers::EndGateway {
age: number(tag.get("Age")).unwrap_or(0),
exit_portal: tag
.get("exit_portal")
.and_then(crate::block_entity_nbt::gateway_exit),
exact_teleport: number(tag.get("ExactTeleport")).unwrap_or(0) != 0,
}
}
pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers::BlockEntity)> {
use crate::containers::BlockEntity;
let int = |k: &str| number(tag.get(k)).map(|v| v as i32);
let id = text(tag.get("id"))?;
let pos = (int("x")?, int("y")?, int("z")?);
if id == "minecraft:end_gateway" {
return Some((pos, BlockEntity::EndGateway(decode_end_gateway(tag))));
}
if id == "minecraft:jukebox" {
let record = tag.get("RecordItem").and_then(item_from_nbt);
let ticks = number(tag.get("ticks_since_song_started")).unwrap_or(0);
@@ -846,6 +817,7 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain
| BlockEntity::Lectern(_)
| BlockEntity::Banner(_)
| BlockEntity::CreakingHeart(_)
| BlockEntity::EndGateway(_)
| BlockEntity::Skull(_)
| BlockEntity::DaylightDetector => {}
BlockEntity::Spawner(s) => **s = crate::mobs::spawner::Spawner::load(tag),
@@ -4642,6 +4614,79 @@ mod tests {
}
use super::*;
#[test]
fn end_gateway_block_entity_round_trips() {
use crate::containers::{BlockEntity, EndGateway};
let plain = BlockEntity::for_block("minecraft:end_gateway").expect("gateway");
assert!(matches!(&plain, BlockEntity::EndGateway(g) if *g == EndGateway::default()));
for exit in [None, Some([8, 100, 0])] {
for exact in [false, true] {
let gateway = EndGateway {
age: 201,
exit_portal: exit,
exact_teleport: exact,
};
let tag = encode_block_entity(
(702, 100, 0),
&BlockEntity::EndGateway(gateway.clone()),
"minecraft:end_gateway",
);
assert_eq!(
text(tag.get("id")).as_deref(),
Some("minecraft:end_gateway")
);
assert_eq!(tag.get("Age"), Some(&Tag::Long(201)));
assert_eq!(
tag.get("exit_portal"),
exit.map(|p| Tag::IntArray(p.to_vec())).as_ref()
);
assert_eq!(
tag.get("ExactTeleport"),
exact.then_some(Tag::Byte(1)).as_ref()
);
let (pos, back) = decode_block_entity(&tag).expect("gateway");
assert_eq!(pos, (702, 100, 0));
assert!(matches!(back, BlockEntity::EndGateway(g) if g == gateway));
}
}
}
#[test]
fn end_gateway_exit_requires_spawnable_bounds() {
for (exit, valid) in [
(vec![-30_000_000, -20_000_000, -30_000_000], true),
(vec![29_999_999, 19_999_999, 29_999_999], true),
(vec![30_000_000, 0, 0], false),
(vec![0, 0, 30_000_000], false),
(vec![-30_000_001, 0, 0], false),
(vec![0, 0, -30_000_001], false),
(vec![0, 20_000_000, 0], false),
(vec![0, -20_000_001, 0], false),
(vec![i32::MIN, 0, 0], false),
(vec![0, 100], false),
] {
let tag = Tag::compound([
("id", string("minecraft:end_gateway")),
("x", Tag::Int(702)),
("y", Tag::Int(100)),
("z", Tag::Int(0)),
("exit_portal", Tag::IntArray(exit)),
]);
let (_, crate::containers::BlockEntity::EndGateway(g)) =
decode_block_entity(&tag).unwrap()
else {
panic!("gateway");
};
assert_eq!(g.exit_portal.is_some(), valid);
let canonical = crate::block_entity_nbt::canonical(&tag).expect("gateway NBT");
assert_eq!(canonical.get("exit_portal").is_some(), valid);
}
assert_eq!(
decode_end_gateway(&Tag::Compound(Compound::new())),
crate::containers::EndGateway::default()
);
}
#[test]
fn skull_block_entity_keeps_its_profile() {
// A placed `player_head` as vanilla saves it: the owning player's
+4 -4
View File
@@ -147,10 +147,10 @@ fn component_text(tag: &Tag) -> String {
_ => s,
}
}
Tag::Compound(_) => match tag.get("text") {
Some(Tag::String(t)) => t.to_string_lossy(),
_ => String::new(),
},
// Component.getString: translations and key binds resolved.
Tag::Compound(_) => {
crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(tag)).plain()
}
_ => String::new(),
}
}
@@ -257,6 +257,23 @@ mod tests {
use super::*;
use horizon_world::loot::{ExplorationMap, LootStack};
#[test]
fn generated_end_gateway_keeps_its_exit() {
let Tag::Compound(nbt) = Tag::compound([
("exit_portal", Tag::IntArray(vec![100, 50, 0])),
("ExactTeleport", Tag::Byte(1)),
]) else {
unreachable!()
};
let Some(BlockEntity::EndGateway(g)) =
generated_block_entity("minecraft:end_gateway", &nbt)
else {
panic!("gateway");
};
assert_eq!(g.exit_portal, Some([100, 50, 0]));
assert!(g.exact_teleport);
}
#[test]
fn placed_chest_loot_keeps_its_enchantments_and_potions() {
let stack =
+125
View File
@@ -14,10 +14,12 @@ use std::{
};
mod create_world;
mod flat;
#[cfg(test)]
mod tests;
pub mod world_management;
pub use create_world::{DIFFICULTIES, WorldOptions};
pub use flat::{FlatLayer, FlatSettings, State as FlatEditor};
/// SelectWorldScreen's `HeaderAndFooterLayout(8 + 9 + 8 + 20 + 4, 60)`.
const LIST_TOP: f32 = 49.0;
@@ -102,6 +104,16 @@ pub enum Mode {
return_to: Box<Mode>,
},
Multiplayer(crate::multiplayer::Screen),
/// CreateFlatWorldScreen over Create New World: the fields that screen
/// keeps and the superflat editor on top of them.
CreateFlat {
name: String,
seed: String,
creative: bool,
focus: u8,
options: WorldOptions,
flat: flat::State,
},
}
#[derive(Clone, Debug, PartialEq)]
pub enum Action {
@@ -129,6 +141,8 @@ pub struct Title {
/// Direct Connection's address, synchronized with `options.txt`'s `lastServer`.
pub last_server: String,
pub saves: PathBuf,
/// The prepared resource root: the flat preset list and block registry.
resources: PathBuf,
pub started: std::time::Instant,
search: String,
search_focused: bool,
@@ -234,6 +248,7 @@ impl Title {
mode,
last_server: String::new(),
saves,
resources: resources.to_owned(),
started: now,
search: String::new(),
search_focused: false,
@@ -320,6 +335,64 @@ impl Title {
self.return_to_list(None);
}
}
/// A press on the superflat screens: their list, share box or buttons.
fn flat_click(&mut self, x: f32, y: f32, size: (f32, f32), hit: Option<u8>) {
match hit {
Some(70) => {
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat.remove_selected();
}
}
Some(71) => {
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat.open_presets();
}
}
Some(72) => self.close_flat(true),
Some(73) => self.close_flat(false),
Some(74) => {
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat.apply_share();
}
}
Some(75) => {
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat.back_to_layers();
}
}
None => {
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat::click(flat, (x, y), size);
}
}
_ => {}
}
}
/// Return to Create New World, keeping (`apply`) or dropping the layers.
fn close_flat(&mut self, apply: bool) {
let mode = std::mem::replace(&mut self.mode, Mode::Main);
if let Mode::CreateFlat {
name,
seed,
creative,
focus,
mut options,
flat,
} = mode
{
if apply {
options.flat = true;
options.flat_settings = Some(flat.settings);
}
self.mode = Mode::Create {
name,
seed,
creative,
focus,
options,
};
}
}
fn matches_search(&self, world: &WorldEntry) -> bool {
let filter = self.search.to_lowercase();
world.name.to_lowercase().contains(&filter) || world.folder.to_lowercase().contains(&filter)
@@ -370,6 +443,10 @@ impl Title {
if let Mode::Multiplayer(screen) = &mut self.mode {
return screen.drag(cursor.1, size);
}
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat::drag(flat, cursor, size);
return;
}
if let Mode::Select { worlds, .. } = &self.mode {
let (top, bottom, _, content) = self.world_list(worlds, size);
let mut scroll = self.scroll.get();
@@ -385,6 +462,9 @@ impl Title {
if let Mode::Multiplayer(screen) = &mut self.mode {
screen.release();
}
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat::release(flat);
}
self.scroll.get_mut().release();
}
/// Mouse wheel over the classic world and server lists.
@@ -396,6 +476,10 @@ impl Title {
screen.wheel(delta, cursor, size);
return;
}
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat::wheel(flat, delta, cursor, size);
return;
}
let Mode::Select { worlds, .. } = &self.mode else {
return;
};
@@ -720,6 +804,7 @@ impl Title {
Mode::Create {
creative, options, ..
} => create_world::buttons(w, h, *creative, options),
Mode::CreateFlat { flat, .. } => flat::buttons(w, h, flat),
Mode::Edit { world, name, .. } => {
let x = (w / 2.0).floor() - 100.0;
let top = edit_top(h);
@@ -1042,6 +1127,7 @@ impl Title {
options,
..
} => self.draw_create(atlas, batch, cursor, name, seed, *focus, options),
Mode::CreateFlat { flat, .. } => flat::draw(self, atlas, batch, cursor, flat),
Mode::Edit { name, focused, .. } => {
crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
centered(
@@ -1248,6 +1334,10 @@ impl Title {
.into_iter()
.find(|b| b.enabled && x >= b.x && x < b.x + b.w && y >= b.y && y < b.y + 20.0)
.map(|b| b.id);
if matches!(self.mode, Mode::CreateFlat { .. }) {
self.flat_click(x, y, (w, h), hit);
return (Action::None, hit.is_some());
}
let action = self.click_action(x, y, (w, h), hit);
// World list selection is silent; launching its selected entry sounds.
let sound = hit.is_some() || matches!(action, Action::Play { .. });
@@ -1416,6 +1506,27 @@ impl Title {
*self.rules.get_mut() = Some(RulesScreen::for_creation(&options.rules));
Action::None
}
(
Mode::Create {
name,
seed,
creative,
focus,
options,
},
Some(26),
) => {
let flat = flat::State::new(&self.resources, options.flat_settings.clone());
self.mode = Mode::CreateFlat {
name: name.clone(),
seed: seed.clone(),
creative: *creative,
focus: *focus,
options: options.clone(),
flat,
};
Action::None
}
(
Mode::Create {
creative, options, ..
@@ -1669,6 +1780,16 @@ impl Title {
self.return_to_list(Some(&folder));
}
Mode::Error { return_to, .. } => self.mode = *return_to.clone(),
Mode::CreateFlat { .. } => {
if matches!(&self.mode, Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets)
{
if let Mode::CreateFlat { flat, .. } = &mut self.mode {
flat.back_to_layers();
}
} else {
self.close_flat(false);
}
}
Mode::Create { .. } => self.cancel_create(),
_ => self.mode = Mode::Main,
}
@@ -1697,6 +1818,7 @@ const SEARCH: crate::clipboard::FieldId = ("world.search", 0);
const EDIT_NAME: crate::clipboard::FieldId = ("world.edit-name", 0);
const WORLD_NAME: crate::clipboard::FieldId = ("world.name", 0);
const WORLD_SEED: crate::clipboard::FieldId = ("world.seed", 0);
const FLAT_SHARE: crate::clipboard::FieldId = ("world.flat-share", 0);
/// The focused field of the world screens and the server screens: the list's
/// search, a world name or seed, or Add Server, Direct Connection and Join a
/// Friend.
@@ -1720,6 +1842,9 @@ fn caret_field<'a>(
_ => None,
},
Mode::Multiplayer(screen) => screen.focused_text(),
Mode::CreateFlat { flat, .. } if flat.page == flat::Page::Presets && flat.share_focused => {
Some((FLAT_SHARE, &mut flat.share, 1230))
}
_ => None,
}
}
@@ -32,6 +32,8 @@ pub struct WorldOptions {
pub commands: Option<bool>,
/// The Superflat world preset instead of Default.
pub flat: bool,
/// CreateFlatWorldScreen's layers and biome, kept with the world type.
pub flat_settings: Option<super::flat::FlatSettings>,
pub structures: bool,
pub bonus_chest: bool,
/// `getGameRules`: the Game Rules screen's values, saved with the world.
@@ -45,6 +47,7 @@ impl Default for WorldOptions {
difficulty: 2,
commands: None,
flat: false,
flat_settings: None,
structures: true,
bonus_chest: false,
rules: crate::gamerules::GameRules::default(),
@@ -67,6 +70,10 @@ impl WorldOptions {
.unwrap_or(2),
commands: Some(commands),
flat: generation.flat,
flat_settings: generation
.flat
.then(|| super::flat::FlatSettings::from_world(dir))
.flatten(),
structures: generation.structures,
bonus_chest: generation.bonus_chest,
rules: crate::gamerules::GameRules::load(dir),
@@ -92,6 +99,12 @@ impl WorldOptions {
bonus_chest: self.bonus_chest(),
}
}
/// The custom layers, as `write_world_gen_settings_with` takes them.
pub fn flat_settings(&self) -> Option<horizon_world::nbt::Tag> {
self.flat_settings
.as_ref()
.map(super::flat::FlatSettings::to_tag)
}
/// A press on one of the open tab's cycle buttons or switches.
pub(super) fn press(&mut self, id: u8, creative: &mut bool) {
match id {
@@ -105,7 +118,13 @@ impl WorldOptions {
}
23 => self.difficulty = (self.difficulty + 1) % DIFFICULTIES.len(),
24 => self.commands = Some(!self.commands(*creative)),
25 => self.flat = !self.flat,
25 => {
self.flat = !self.flat;
if self.flat {
// setWorldType starts the generator from the flat preset.
self.flat_settings = Some(super::flat::FlatSettings::default());
}
}
27 => self.structures = !self.structures,
28 => self.bonus_chest = !self.bonus_chest,
_ => {}
@@ -247,13 +266,13 @@ pub(super) fn buttons(w: f32, h: f32, creative: bool, o: &WorldOptions) -> Vec<B
true,
25,
),
// Horizon has no preset editor (CreateFlatWorldScreen) yet.
// CreateFlatWorldScreen: only a flat generator has a preset editor.
b(
gx + 160.0,
gy,
150.0,
tr("selectWorld.customizeType"),
false,
o.flat,
26,
),
// SwitchGrid: 44-wide value-only buttons at the grid's right.
+884
View File
@@ -0,0 +1,884 @@
//! CreateFlatWorldScreen and PresetFlatWorldScreen: the Superflat layer list,
//! the preset chooser and the settings they hand back to Create New World.
use super::{Button, Title};
use crate::{
hud::{HudAtlas, HudBatch, rgba},
lang,
text::{Text, format_translation},
ui,
};
use horizon_world::nbt::Tag;
use serde_json::Value;
use std::{collections::BTreeSet, path::Path};
/// DimensionType.Y_SIZE: the most blocks a flat generator takes.
const Y_SIZE: i32 = 4064;
/// The list's row width (ObjectSelectionList.getRowWidth).
const ROW_WIDTH: f32 = 220.0;
/// The header row above the layers.
const HEADER: f32 = 14.0;
/// A layer or preset row.
const LAYER_ROW: f32 = 20.0;
const PRESET_ROW: f32 = 24.0;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct FlatLayer {
/// A block id such as `minecraft:dirt`.
pub block: String,
/// How many blocks tall this layer is (0..=4064).
pub height: i32,
}
/// FlatLevelGeneratorSettings: the layers (bottom to top), the biome and the
/// decorations CreateFlatWorldScreen edits.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct FlatSettings {
pub biome: String,
pub features: bool,
pub lakes: bool,
pub layers: Vec<FlatLayer>,
pub structure_overrides: Vec<String>,
}
impl Default for FlatSettings {
fn default() -> Self {
// worldgen/world_preset/flat.json's overworld.
Self {
biome: "minecraft:plains".into(),
features: false,
lakes: false,
layers: vec![
FlatLayer {
block: "minecraft:bedrock".into(),
height: 1,
},
FlatLayer {
block: "minecraft:dirt".into(),
height: 2,
},
FlatLayer {
block: "minecraft:grass_block".into(),
height: 1,
},
],
structure_overrides: vec!["minecraft:strongholds".into(), "minecraft:villages".into()],
}
}
}
impl FlatSettings {
/// A saved world's flat generator settings, for Re-Create.
pub fn from_world(dir: &Path) -> Option<Self> {
let settings = crate::save::world_gen_settings(dir)?;
let generator = settings
.get("dimensions")?
.get("minecraft:overworld")?
.get("generator")?;
if crate::save::text(generator.get("type"))?.trim_start_matches("minecraft:") != "flat" {
return None;
}
Self::from_tag(generator.get("settings")?)
}
pub fn from_tag(tag: &Tag) -> Option<Self> {
let Some(Tag::List(list)) = tag.get("layers") else {
return None;
};
let layers: Vec<FlatLayer> = list
.iter()
.filter_map(|layer| {
Some(FlatLayer {
block: crate::save::text(layer.get("block"))?,
height: crate::save::number(layer.get("height"))?.clamp(0, Y_SIZE as i64)
as i32,
})
})
.collect();
// `layers: []` is a valid void flat world; a list whose entries all
// fail to parse is not.
if layers.is_empty() && !list.is_empty() {
return None;
}
let flag = |key: &str, default: bool| {
crate::save::number(tag.get(key)).map_or(default, |value| value != 0)
};
let structure_overrides = match tag.get("structure_overrides") {
Some(Tag::String(text)) => vec![text.to_string_lossy()],
Some(Tag::List(list)) => list
.iter()
.filter_map(|value| crate::save::text(Some(value)))
.collect(),
_ => Vec::new(),
};
Some(Self {
biome: crate::save::text(tag.get("biome")).unwrap_or_else(|| "minecraft:plains".into()),
features: flag("features", false),
lakes: flag("lakes", false),
layers,
structure_overrides,
})
}
/// FlatLevelGeneratorSettings.CODEC, as world_gen_settings stores it.
pub fn to_tag(&self) -> Tag {
let string = |text: &str| Tag::String(text.into());
Tag::compound([
("biome", string(&self.biome)),
("features", Tag::Byte(i8::from(self.features))),
("lakes", Tag::Byte(i8::from(self.lakes))),
(
"layers",
Tag::List(
self.layers
.iter()
.map(|layer| {
Tag::compound([
("block", string(&layer.block)),
("height", Tag::Int(layer.height)),
])
})
.collect(),
),
),
(
"structure_overrides",
Tag::List(
self.structure_overrides
.iter()
.map(|id| string(id))
.collect(),
),
),
])
}
/// `CreateFlatWorldScreen.save`: the text the preset screen shows.
pub fn to_share(&self) -> String {
let layers = self
.layers
.iter()
.map(|layer| {
if layer.height == 1 {
layer.block.clone()
} else {
format!("{}*{}", layer.height, layer.block)
}
})
.collect::<Vec<_>>()
.join(",");
format!("{layers};{}", self.biome)
}
/// `PresetFlatWorldScreen.fromString`: `layers;biome`, keeping the
/// decorations the screen was opened with. `None` for a malformed list,
/// as vanilla falls back to the preset's own settings.
pub fn parse(
text: &str,
blocks: &BTreeSet<String>,
biomes: &BTreeSet<String>,
base: &Self,
) -> Option<Self> {
let (layer_text, biome_text) = text.split_once(';').unwrap_or((text, ""));
let mut layers = Vec::new();
let mut total = 0;
for part in layer_text.split(',') {
let part = part.trim();
if part.is_empty() {
continue;
}
let (height, block) = match part.split_once('*') {
Some((height, block)) => (height.trim().parse::<i32>().ok()?, block.trim()),
None => (1, part),
};
let block = namespaced(block);
if !blocks.is_empty() && !blocks.contains(&block) {
return None;
}
let height = height.max(0).min(Y_SIZE - total);
if height == 0 {
continue;
}
total += height;
layers.push(FlatLayer { block, height });
}
if layers.is_empty() {
return None;
}
let mut biome = namespaced(biome_text.trim());
if biome == "minecraft:" || biome.is_empty() {
biome = "minecraft:plains".into();
}
if !biomes.is_empty() && !biomes.contains(&biome) {
biome = "minecraft:plains".into();
}
Some(Self {
biome,
layers,
..base.clone()
})
}
}
/// `Identifier.parse`: bare names get the default namespace.
fn namespaced(id: &str) -> String {
if id.is_empty() || id.contains(':') {
id.to_owned()
} else {
format!("minecraft:{id}")
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) enum Page {
Layers,
Presets,
}
#[derive(Clone, Debug)]
pub struct State {
pub(super) page: Page,
pub(super) settings: FlatSettings,
/// The preset screen's share box (`createWorld.customize.presets.share`).
pub(super) share: String,
pub(super) share_focused: bool,
/// The selected layer, in the list's top-first order.
pub(super) selected: Option<usize>,
pub(super) scroll: ui::Scroll,
preset_selected: Option<usize>,
preset_scroll: ui::Scroll,
presets: Vec<Preset>,
blocks: BTreeSet<String>,
biomes: BTreeSet<String>,
}
#[derive(Clone, Debug)]
struct Preset {
id: String,
display: String,
settings: FlatSettings,
}
impl State {
/// The layers the editor holds, for the control socket's state.
pub fn settings(&self) -> &FlatSettings {
&self.settings
}
pub(super) fn new(root: &Path, current: Option<FlatSettings>) -> Self {
let settings = current.unwrap_or_default();
let (presets, blocks, biomes) = load(root);
Self {
page: Page::Layers,
share: settings.to_share(),
settings,
share_focused: false,
selected: None,
scroll: ui::Scroll::default(),
preset_selected: None,
preset_scroll: ui::Scroll::default(),
presets,
blocks,
biomes,
}
}
pub(super) fn open_presets(&mut self) {
self.page = Page::Presets;
self.preset_selected = None;
self.preset_scroll = ui::Scroll::default();
self.share = self.settings.to_share();
self.share_focused = false;
}
pub(super) fn back_to_layers(&mut self) {
self.page = Page::Layers;
self.share_focused = false;
}
pub(super) fn remove_selected(&mut self) {
let Some(row) = self.selected else {
return;
};
let index = self.settings.layers.len().wrapping_sub(1 + row);
if index < self.settings.layers.len() {
self.settings.layers.remove(index);
}
self.selected = None;
}
/// PresetFlatWorldScreen's Select: parse the share text into the settings
/// the Create New World screen keeps.
pub(super) fn apply_share(&mut self) {
// PresetFlatWorldScreen keeps the selected preset's decorations while
// the share text supplies its layers and biome.
let base = self
.preset_selected
.and_then(|index| self.presets.get(index))
.map(|preset| preset.settings.clone())
.unwrap_or_else(|| self.settings.clone());
// A malformed list falls back to FlatLevelGeneratorSettings.getDefault.
let settings =
FlatSettings::parse(&self.share, &self.blocks, &self.biomes, &base).unwrap_or_default();
self.settings = settings;
self.share = self.settings.to_share();
self.page = Page::Layers;
self.share_focused = false;
self.selected = None;
}
fn select_preset(&mut self, index: usize) {
let Some(preset) = self.presets.get(index) else {
return;
};
self.preset_selected = Some(index);
self.share = preset.settings.to_share();
self.share_focused = false;
}
fn selecting(&self) -> Option<usize> {
self.preset_selected
}
}
/// `<root>/data/<namespace>/worldgen/flat_level_generator_preset/<path>.json`,
/// in the order of the `visible` tag, plus the block and biome ids the share
/// text is checked against.
fn load(root: &Path) -> (Vec<Preset>, BTreeSet<String>, BTreeSet<String>) {
let mut presets = Vec::new();
let tag_path =
root.join("data/minecraft/tags/worldgen/flat_level_generator_preset/visible.json");
if let Ok(text) = std::fs::read_to_string(tag_path)
&& let Ok(Value::Object(tag)) = serde_json::from_str(&text)
&& let Some(Value::Array(ids)) = tag.get("values")
{
for id in ids.iter().filter_map(Value::as_str) {
let Some((namespace, path)) = id.split_once(':') else {
continue;
};
let path = root.join(format!(
"data/{namespace}/worldgen/flat_level_generator_preset/{path}.json"
));
let Ok(text) = std::fs::read_to_string(path) else {
continue;
};
let Ok(value) = serde_json::from_str::<Value>(&text) else {
continue;
};
let Some(settings) = preset_settings(&value) else {
continue;
};
presets.push(Preset {
id: id.to_owned(),
display: value["display"]
.as_str()
.unwrap_or("minecraft:grass_block")
.to_owned(),
settings,
});
}
}
let blocks = registry_ids(root, "minecraft:block");
let biomes = json_keys(&root.join("worldgen/biomes.json"));
(presets, blocks, biomes)
}
fn preset_settings(value: &Value) -> Option<FlatSettings> {
let settings = value.get("settings")?;
let layers = settings
.get("layers")?
.as_array()?
.iter()
.filter_map(|layer| {
Some(FlatLayer {
block: layer.get("block")?.as_str()?.to_owned(),
height: layer.get("height")?.as_i64()? as i32,
})
})
.collect::<Vec<_>>();
if layers.is_empty() {
return None;
}
let structure_overrides = match settings.get("structure_overrides") {
Some(Value::String(id)) => vec![id.clone()],
Some(Value::Array(ids)) => ids
.iter()
.filter_map(Value::as_str)
.map(str::to_owned)
.collect(),
_ => Vec::new(),
};
Some(FlatSettings {
biome: settings
.get("biome")
.and_then(Value::as_str)
.unwrap_or("minecraft:plains")
.to_owned(),
features: settings
.get("features")
.and_then(Value::as_bool)
.unwrap_or(false),
lakes: settings
.get("lakes")
.and_then(Value::as_bool)
.unwrap_or(false),
layers,
structure_overrides,
})
}
/// The ids of a registry in the prepared `registries.json`.
fn registry_ids(root: &Path, registry: &str) -> BTreeSet<String> {
let Ok(text) = std::fs::read_to_string(root.join("registries.json")) else {
return BTreeSet::new();
};
let Ok(value) = serde_json::from_str::<Value>(&text) else {
return BTreeSet::new();
};
value
.get(registry)
.and_then(|registry| registry.get("entries"))
.and_then(Value::as_object)
.map(|entries| entries.keys().cloned().collect())
.unwrap_or_default()
}
fn json_keys(path: &Path) -> BTreeSet<String> {
let Ok(text) = std::fs::read_to_string(path) else {
return BTreeSet::new();
};
let Ok(value) = serde_json::from_str::<Value>(&text) else {
return BTreeSet::new();
};
value
.as_object()
.map(|entries| entries.keys().cloned().collect())
.unwrap_or_default()
}
/// CreateFlatWorldScreen's list and the preset screen's list.
fn list_area(state: &State, size: (f32, f32)) -> (f32, f32, f32, f32) {
let (w, h) = (size.0.ceil(), size.1.ceil());
let (top, bottom) = match state.page {
Page::Layers => (43.0, h - 60.0),
Page::Presets => (80.0, h - 37.0),
};
let left = ((w - ROW_WIDTH) * 0.5).floor();
let rows = match state.page {
Page::Layers => HEADER + state.settings.layers.len() as f32 * LAYER_ROW + 4.0,
Page::Presets => state.presets.len() as f32 * PRESET_ROW + 4.0,
};
(top, bottom, left, rows)
}
pub(super) fn buttons(w: f32, h: f32, state: &State) -> Vec<Button> {
let b = |x: f32, y: f32, w: f32, key: &str, fallback: &str, enabled: bool, id: u8| Button {
x,
y,
w,
label: lang::get_or(key, fallback),
enabled,
id,
icon: None,
};
match state.page {
Page::Layers => {
let x = ((w - 308.0) * 0.5).trunc();
vec![
b(
x,
h - 52.0,
150.0,
"createWorld.customize.flat.removeLayer",
"Remove Layer",
state.selected.is_some(),
70,
),
b(
x + 158.0,
h - 52.0,
150.0,
"createWorld.customize.presets",
"Presets",
true,
71,
),
b(x, h - 28.0, 150.0, "gui.done", "Done", true, 72),
b(x + 158.0, h - 28.0, 150.0, "gui.cancel", "Cancel", true, 73),
]
}
Page::Presets => vec![
b(
w / 2.0 - 155.0,
h - 28.0,
150.0,
"createWorld.customize.presets.select",
"Select",
state.selecting().is_some() || state.share.len() > 1,
74,
),
b(
w / 2.0 + 5.0,
h - 28.0,
150.0,
"gui.cancel",
"Cancel",
true,
75,
),
],
}
}
/// The layer under the pointer (top-first), and whether the pointer is on the
/// list at all.
fn layer_row(state: &State, cursor: (f32, f32), size: (f32, f32)) -> Option<usize> {
let (top, bottom, _, _) = list_area(state, size);
if cursor.1 < top || cursor.1 >= bottom {
return None;
}
let y = cursor.1 - top - 2.0 + state.scroll.amount;
if y < HEADER {
return None;
}
let row = ((y - HEADER) / LAYER_ROW).floor() as usize;
(row < state.settings.layers.len()).then_some(row)
}
fn preset_row(state: &State, cursor: (f32, f32), size: (f32, f32)) -> Option<usize> {
let (top, bottom, _, _) = list_area(state, size);
if cursor.1 < top || cursor.1 >= bottom {
return None;
}
let row = ((cursor.1 - top - 2.0 + state.preset_scroll.amount) / PRESET_ROW).floor() as usize;
(row < state.presets.len()).then_some(row)
}
/// A press on the list, the share box or its scrollbar.
pub(super) fn click(state: &mut State, cursor: (f32, f32), size: (f32, f32)) {
let (top, bottom, left, content) = list_area(state, size);
let bar = left + ROW_WIDTH + 6.0;
match state.page {
Page::Layers => {
if state.scroll.press(cursor, bar, top, bottom, content) {
return;
}
state.selected = layer_row(state, cursor, size);
}
Page::Presets => {
let field = share_field(size);
state.share_focused = ui::hovered(cursor, field[0], field[1], field[2], field[3]);
if state.preset_scroll.press(cursor, bar, top, bottom, content) {
return;
}
if let Some(row) = preset_row(state, cursor, size) {
state.select_preset(row);
}
}
}
}
fn share_field(size: (f32, f32)) -> [f32; 4] {
[50.0, 40.0, (size.0.ceil() - 100.0).max(1.0), 20.0]
}
pub(super) fn wheel(state: &mut State, delta: f32, cursor: (f32, f32), size: (f32, f32)) {
let (top, bottom, _, content) = list_area(state, size);
if cursor.1 < top || cursor.1 >= bottom {
return;
}
match state.page {
Page::Layers => state.scroll.wheel(delta, LAYER_ROW, top, bottom, content),
Page::Presets => state
.preset_scroll
.wheel(delta, PRESET_ROW, top, bottom, content),
}
}
pub(super) fn drag(state: &mut State, cursor: (f32, f32), size: (f32, f32)) {
let (top, bottom, _, content) = list_area(state, size);
match state.page {
Page::Layers => state.scroll.drag(cursor.1, top, bottom, content),
Page::Presets => state.preset_scroll.drag(cursor.1, top, bottom, content),
}
}
pub(super) fn release(state: &mut State) {
state.scroll.release();
state.preset_scroll.release();
}
pub(super) fn draw(
title: &Title,
atlas: &HudAtlas,
batch: &mut HudBatch,
cursor: (f32, f32),
state: &State,
) {
let (w, h) = (batch.width.ceil(), batch.height.ceil());
ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
match state.page {
Page::Layers => draw_layers(title, atlas, batch, cursor, state, (w, h)),
Page::Presets => draw_presets(title, atlas, batch, cursor, state, (w, h)),
}
}
fn draw_layers(
_title: &Title,
atlas: &HudAtlas,
batch: &mut HudBatch,
cursor: (f32, f32),
state: &State,
(w, h): (f32, f32),
) {
super::centered(
atlas,
batch,
&lang::get_or(
"createWorld.customize.flat.title",
"Superflat Customization",
),
8.0,
u32::MAX,
);
let (top, bottom, left, content) = list_area(state, (w, h));
ui::list_background(batch, atlas, top, bottom, false);
crate::ui::separators(batch, atlas, top, bottom, false);
let first = batch.vertices.len();
let right = left + ROW_WIDTH;
batch.text_styled(
atlas,
&Text::translate("createWorld.customize.flat.tile", &[]).underlined(),
left + 2.0,
top + 3.0,
u32::MAX,
true,
);
let height_header = Text::translate("createWorld.customize.flat.height", &[]).underlined();
let hw = HudBatch::text_width(atlas, &height_header.plain());
batch.text_styled(
atlas,
&height_header,
right - hw - 2.0,
top + 3.0,
u32::MAX,
true,
);
let offset = state.scroll.amount.trunc();
let selected = state.selected;
for (row, layer) in state.settings.layers.iter().rev().enumerate() {
let y = top + 2.0 + HEADER + row as f32 * LAYER_ROW - offset;
let target = [left - 2.0, y - 1.0, ROW_WIDTH + 4.0, LAYER_ROW];
let hovered = ui::hovered(cursor, target[0], target[1], target[2], target[3]);
if selected == Some(row) {
batch.fill(
atlas,
target[0],
target[1],
target[2],
target[3],
rgba(255, 255, 255, 70),
);
} else if hovered {
batch.fill(
atlas,
target[0],
target[1],
target[2],
target[3],
rgba(255, 255, 255, 25),
);
}
slot(
atlas,
batch,
layer_icon(atlas, &layer.block),
left + 2.0,
y + 1.0,
);
batch.text(
atlas,
&item_name(&layer.block),
left + 2.0 + 18.0 + 5.0,
y + 5.0,
u32::MAX,
true,
);
let (key, fallback) = if row == 0 {
("createWorld.customize.flat.layer.top", "Top - %s")
} else if row + 1 == state.settings.layers.len() {
("createWorld.customize.flat.layer.bottom", "Bottom - %s")
} else {
("createWorld.customize.flat.layer", "%s")
};
let label = format_translation(
&lang::get_or(key, fallback),
&[Text::literal(layer.height.to_string())],
)
.plain();
let text_width = HudBatch::text_width(atlas, &label);
batch.text(
atlas,
&label,
right - text_width - 2.0,
y + 5.0,
u32::MAX,
true,
);
}
batch.clip_since(first, 0.0, top, w, bottom);
ui::scrollbar(
batch,
atlas,
left + ROW_WIDTH + 6.0,
top,
bottom,
content,
state.scroll.amount,
);
}
fn draw_presets(
title: &Title,
atlas: &HudAtlas,
batch: &mut HudBatch,
cursor: (f32, f32),
state: &State,
(w, h): (f32, f32),
) {
super::centered(
atlas,
batch,
&lang::get_or("createWorld.customize.presets.title", "Select a Preset"),
8.0,
u32::MAX,
);
batch.text(
atlas,
&lang::get_or(
"createWorld.customize.presets.share",
"Want to share your preset with someone? Use the box below!",
),
51.0,
30.0,
rgba(160, 160, 160, 255),
true,
);
// The share box: EditBox at 50,40, width - 100 by 20.
let field = share_field((w, h));
title.caret.borrow_mut().draw(
batch,
atlas,
(super::FLAT_SHARE, &state.share, 1230),
field,
state.share_focused,
title.started,
);
batch.text(
atlas,
&lang::get_or(
"createWorld.customize.presets.list",
"Alternatively, here are some we made earlier!",
),
51.0,
68.0,
rgba(160, 160, 160, 255),
true,
);
let (top, bottom, left, content) = list_area(state, (w, h));
ui::list_background(batch, atlas, top, bottom, false);
crate::ui::separators(batch, atlas, top, bottom, false);
let first = batch.vertices.len();
let offset = state.preset_scroll.amount.trunc();
for (row, preset) in state.presets.iter().enumerate() {
let y = top + 2.0 + row as f32 * PRESET_ROW - offset;
let target = [left - 2.0, y - 1.0, ROW_WIDTH + 4.0, PRESET_ROW];
let hovered = ui::hovered(cursor, target[0], target[1], target[2], target[3]);
if state.preset_selected == Some(row) {
batch.fill(
atlas,
target[0],
target[1],
target[2],
target[3],
rgba(255, 255, 255, 70),
);
} else if hovered {
batch.fill(
atlas,
target[0],
target[1],
target[2],
target[3],
rgba(255, 255, 255, 25),
);
}
slot(
atlas,
batch,
layer_icon(atlas, &preset.display),
left + 2.0,
y + 2.0,
);
batch.text(
atlas,
&preset_name(&preset.id),
left + 2.0 + 18.0 + 5.0,
y + 7.0,
u32::MAX,
true,
);
}
batch.clip_since(first, 0.0, top, w, bottom);
ui::scrollbar(
batch,
atlas,
left + ROW_WIDTH + 6.0,
top,
bottom,
content,
state.preset_scroll.amount,
);
}
/// The 18x18 slot behind a layer's item icon (`container/slot`).
fn slot(atlas: &HudAtlas, batch: &mut HudBatch, icon: Option<String>, x: f32, y: f32) {
if let Some(rect) = atlas.sprites.get("gui/sprites/container/slot").copied() {
batch.rect_uv(x, y, 18.0, 18.0, rect, u32::MAX);
} else {
batch.fill(atlas, x, y, 18.0, 18.0, rgba(139, 139, 139, 255));
batch.fill(atlas, x + 1.0, y + 1.0, 16.0, 16.0, rgba(55, 55, 55, 255));
}
if let Some(icon) = icon {
batch.sprite_scaled(atlas, &icon, x + 1.0, y + 1.0, 16.0, 16.0, u32::MAX);
}
}
fn layer_icon(atlas: &HudAtlas, id: &str) -> Option<String> {
let name = id.strip_prefix("minecraft:").unwrap_or(id);
let candidates: Vec<String> = if name == "water" {
vec!["item/water_bucket".into()]
} else if name == "lava" {
vec!["item/lava_bucket".into()]
} else {
vec![
format!("item/{name}"),
format!("block/{name}"),
format!("block/{name}_side"),
format!("block/{name}_top"),
]
};
candidates
.into_iter()
.find(|sprite| atlas.sprites.contains_key(sprite))
}
fn item_name(id: &str) -> String {
let name = id.strip_prefix("minecraft:").unwrap_or(id);
if name == "water" {
return lang::get_or("item.minecraft.water_bucket", "Water Bucket");
}
if name == "lava" {
return lang::get_or("item.minecraft.lava_bucket", "Lava Bucket");
}
for key in [
format!("block.minecraft.{name}"),
format!("item.minecraft.{name}"),
] {
if lang::has(&key) {
return lang::get(&key);
}
}
pretty(name)
}
fn preset_name(id: &str) -> String {
let key = format!("flat_world_preset.{}", id.replace(':', "."));
lang::get_or(&key, &pretty(id.strip_prefix("minecraft:").unwrap_or(id)))
}
fn pretty(name: &str) -> String {
name.split('_')
.filter(|word| !word.is_empty())
.map(|word| {
let mut chars = word.chars();
match chars.next() {
Some(first) => first.to_uppercase().chain(chars).collect::<String>(),
None => String::new(),
}
})
.collect::<Vec<_>>()
.join(" ")
}
+30 -5
View File
@@ -559,20 +559,26 @@ impl Behaviours {
sim.game_event_state(pos, "minecraft:block_change", next);
}
/// The state change of `RedStoneOreBlock.attack` when mining begins.
/// `BlockBehaviour.attack` when mining begins: `RedStoneOreBlock.attack`
/// lights the ore, `NoteBlock.attack` plays the note. True for a note
/// block, whose player also earns the `play_noteblock` statistic.
pub fn attack_block<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
pos: BlockPos,
) {
) -> bool {
let mut sim = self.sim(level, ticks);
let state = sim.state(pos);
if self.data(state).chain.contains(&Class::RedStoneOre)
&& !self.table.bool(state, self.props.lit)
{
let chain = &self.data(state).chain;
if chain.contains(&Class::Note) {
sim.note_play(pos, state);
return true;
}
if chain.contains(&Class::RedStoneOre) && !self.table.bool(state, self.props.lit) {
sim.set_block_and_update(pos, self.table.set_bool(state, self.props.lit, true));
}
false
}
/// `BlockState.useWithoutItem` for a right-click on `pos` (hit face and
@@ -641,6 +647,25 @@ impl Behaviours {
if self.data(state).chain.contains(&Class::CopperGolemStatue) {
return self.turn_statue(level, ticks, pos, state, item);
}
// NoteBlock.useItemOn: a mob head on the top face is placed, not tuned
// (`#minecraft:noteblock_top_instruments`).
if face == Direction::Up
&& self.data(state).chain.contains(&Class::Note)
&& item.is_some_and(|i| {
matches!(
i,
"minecraft:zombie_head"
| "minecraft:skeleton_skull"
| "minecraft:creeper_head"
| "minecraft:dragon_head"
| "minecraft:wither_skeleton_skull"
| "minecraft:piglin_head"
| "minecraft:player_head"
)
})
{
return InteractionResult::Pass;
}
self.use_without_item(level, ticks, pos, face, hit, player)
}
+83
View File
@@ -1478,6 +1478,80 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
let block = b.table.block_by_name(&format!("minecraft:{next}"))?;
Some(b.table.with_properties_of(block, state))
}
/// `WeatheringCopper.getPrevious` (and `getFirst` by repeating it) by
/// registry naming: the block one oxidation step back.
fn copper_previous_name(path: &str) -> Option<String> {
if let Some(rest) = path.strip_prefix("oxidized_") {
Some(format!("weathered_{rest}"))
} else if let Some(rest) = path.strip_prefix("weathered_") {
Some(format!("exposed_{rest}"))
} else {
path.strip_prefix("exposed_").map(|rest| {
if rest == "copper" {
"copper_block".to_owned()
} else {
rest.to_owned()
}
})
}
}
fn copper_stepped(&self, state: BlockStateId, all_the_way: bool) -> Option<BlockStateId> {
let b = self.b;
let name = &*b.table.info(b.block(state)).name;
let mut path = Self::copper_previous_name(name.strip_prefix("minecraft:")?)?;
while all_the_way && let Some(earlier) = Self::copper_previous_name(&path) {
path = earlier;
}
let block = b.table.block_by_name(&format!("minecraft:{path}"))?;
Some(b.table.with_properties_of(block, state))
}
/// `LightningBolt.clearCopperOnLightningStrike`: the struck copper goes
/// back to unoxidized, then 3 to 5 random walks of up to 8 steps each
/// scrape one step of oxidation off the weathering copper they land on.
/// A waxed block is left as it is but still starts the walks.
pub(crate) fn lightning_clear_copper(&mut self, struck: BlockPos) {
let b = self.b;
let state = self.state(struck);
let weathering = b
.data(state)
.implements(super::classes::Interface::WeatheringCopper);
let waxed = b.table.name(state).starts_with("minecraft:waxed_");
if !(weathering || waxed) {
return;
}
if weathering && let Some(first) = self.copper_stepped(state, true) {
self.set_block_and_update(struck, first);
}
for _ in 0..self.rand_int(3) + 3 {
let mut at = struck;
for _ in 0..self.rand_int(8) + 1 {
// randomStepCleaningCopper: up to 10 random blocks in the
// 3x3x3 cube around the walk's position.
let mut next = None;
for _ in 0..10 {
let x = at.x - 1 + self.rand_int(3);
let y = at.y - 1 + self.rand_int(3);
let z = at.z - 1 + self.rand_int(3);
let candidate = BlockPos::new(x, y, z);
let state = self.state(candidate);
if b.data(state)
.implements(super::classes::Interface::WeatheringCopper)
{
if let Some(previous) = self.copper_stepped(state, false) {
self.set_block_and_update(candidate, previous);
}
self.level_event(3002, candidate, -1);
next = Some(candidate);
break;
}
}
match next {
Some(p) => at = p,
None => break,
}
}
}
}
}
/// `Biome.Precipitation` at a position.
@@ -1661,6 +1735,15 @@ impl Behaviours {
) {
self.sim(level, ticks).random_tick_at(pos);
}
/// `LightningBolt.clearCopperOnLightningStrike` for the block at `struck`.
pub fn lightning_clear_copper<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
struck: BlockPos,
) {
self.sim(level, ticks).lightning_clear_copper(struck);
}
/// Run one scheduled block tick at `pos` immediately (no queue check).
pub fn scheduled_block_tick<L: LevelAccess + ?Sized>(
&self,
+1 -1
View File
@@ -31,7 +31,7 @@ harness named checks that loader against vanilla).
| --- | --- | --- | --- |
| Pack metadata: description, icon, `min_format`/`max_format`, old `supported_formats`, compatibility warning | `pack.mcmeta`, `pack.png` | works | `test_pack_screen_parity`, `test_pack_selection_parity` |
| Overlays per format | `pack.mcmeta` `overlays` | works | `test_resource_pack_parity` (an overlay for 26.3 applied, an older one not) |
| Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`packs/pattern.rs` regex subset) |
| Filters | `pack.mcmeta` `filter` | works | `test_resource_pack_parity` (`horizon-client-core/src/pattern.rs` regex subset) |
| Folder and zip packs, order, built-in packs | `resourcepacks/` | works | `test_resource_pack_parity`, `test_pack_selection_parity` |
| Server resource packs: the prompt, the server list's Server Resource Packs setting, download (250 MiB, SHA-1, `downloads/` keeps 20), download toasts, a progress screen while the packs reload, applied on top of the player's packs, removed on leaving | the server's `resource_pack_push`/`_pop` | works | `tools/server_pack_e2e.py` (against vanilla's server and Horizon's), unit tests in `server_packs.rs`; `test_server_resource_pack_parity` for Horizon's server |
| Other namespaces | `assets/<namespace>/` | works | `test_resource_pack_parity` |
+32 -3
View File
@@ -24,7 +24,7 @@ address. The script then checks, from both sides, what a guest's game used to ge
- pvp: the guest and the host hit each other with a sword; with the pvp game rule off, or on one
team without friendly fire, nothing;
- kills: a pig the guest kills counts in the guest's killed statistic, not the host's (#484);
- leave: a guest who leaves has leave_game in their saved statistics, and again after the next leave;
- arrows: the guest and the host shoot each other with a bow; with the pvp game rule off, nothing (#484);
- looks: mobs look on both sides as the server has them (their synched data): a calf is a
@@ -301,7 +301,7 @@ GUEST_NAME = 'Guest'
# Match normal single player; --in-frame is the comparison path.
SERVER_THREAD = True
CHECKS = ['tab', 'self', 'armour', 'nametags', 'walls', 'chest', 'crafting', 'spawned', 'sign', 'damage', 'mobs', 'hazards', 'pvp',
'arrows', 'kills', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles',
'arrows', 'kills', 'leave', 'hurt', 'looks', 'leads', 'respawn', 'containers', 'feedback', 'titles', 'chat', 'styles',
'commands', 'recipes', 'machines', 'brewing', 'loom', 'stonecutter', 'grindstone', 'anvil', 'smithing',
'enchanting', 'beacon', 'crafter', 'lectern', 'cartography', 'trials', 'clicks', 'sleep', 'predict', 'push',
'piston-push', 'piston-slime', 'eat', 'eating', 'xp', 'objects', 'projectiles', 'thrown', 'sparks', 'hud', 'sidebar', 'border', 'particles',
@@ -1196,6 +1196,35 @@ def check_pvp(host, guest, out):
return hits
def leave_game_total(host):
"""The leave_game statistic summed over the stats files the host's world holds."""
total = 0
for path in (host.work / 'saves' / 'Lan' / 'players' / 'stats').glob('*.json'):
custom = json.loads(path.read_text()).get('stats', {}).get('minecraft:custom', {})
total += custom.get('minecraft:leave_game', 0)
return total
def check_leave(host, guest, out):
# PlayerList.remove awards Stats.LEAVE_GAME before it saves the player: a guest who leaves has it in
# their saved statistics, and it counts again the next time they leave.
port = host.raw('lan', 'status')['port']
before = leave_game_total(host)
counts = []
for _ in range(2):
guest.raw('disconnect')
for _ in range(20):
time.sleep(0.5)
if leave_game_total(host) > (counts[-1] if counts else before):
break
counts.append(leave_game_total(host))
guest.raw('connect', f'127.0.0.1:{port}', GUEST_NAME)
guest.raw('wait-for', 'loaded', '--timeout', 300)
guest.wait(20)
assert counts == [before + 1, before + 2], f'leave_game was {before}, then {counts} after two leaves'
return {'leave_game': counts}
def check_kills(host, guest, out):
# A mob the guest kills is the guest's kill (#484): LivingEntity.die credits lastHurtByPlayer, so the
# killed statistic (and its scoreboard criterion) counts for the guest, not the host.
@@ -4938,7 +4967,7 @@ CHECK_FNS = {'tab': check_tab, 'self': check_self, 'armour': check_armour,
'light': check_light, 'plates': check_plates, 'swings': check_swings,
'cracks': check_cracks, 'time': check_time, 'growth': check_growth, 'doors': check_doors,
'flight': check_flight, 'fireball': check_fireball, 'deflect': check_deflect,
'barter': check_barter, 'worn': check_worn, 'kills': check_kills,
'barter': check_barter, 'worn': check_worn, 'kills': check_kills, 'leave': check_leave,
'arrows': check_arrows, 'predict': check_predict, 'ladder': check_ladder,
'boats': check_boats, 'minecarts': check_minecarts, 'frames': check_frames, 'hands': check_hands,
'lightning': check_lightning, 'riding': check_riding, 'occupied_horse': check_occupied_horse, 'mounts': check_mounts,