e2473aafd8
AbstractArrow.onHitEntity: an entity that takes no damage from the arrow (a raised shield, invulnerability) turns it back with ProjectileDeflection.REVERSE at power 0.2: a tenth of the speed, a half turn give or take ten degrees from the arrow's own random; one left almost still drops its pickup and is discarded. Arrows used to vanish. The arrow tick now stops at the entity it hits: the game hurts the entity, then arrows::finish_entity_hit spends the arrow (with its hit sound, from the arrow's random) or turns it back, and ends the tick (drag, gravity, fluids). The damage is taken from the speed at the hit, the crit bonus from the arrow's random, the entity search follows ProjectileUtil.getManyEntityHitResult (the box first, then computeMargin's margin, which needs tickCount), Punch pushes only what was hurt, and a refused burning arrow leaves the player's fire as it was. Mobs' refusals keep the old ending until their hurt results follow hurtServer. The arrow harness gains an entity in the way that takes or refuses the damage: squarely, grazing, slow enough to drop. Part of #277 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
365 lines
16 KiB
Rust
365 lines
16 KiB
Rust
//! Arrows over the client's resident scene (`arrows::tick`), for
|
|
//! tools/test_arrow_parity.py: one line of state and one of events per operation.
|
|
#![forbid(unsafe_code)]
|
|
use horizon_client::{
|
|
Result,
|
|
arrows::{
|
|
self, ArrowEvent, ArrowParticle, ArrowScene, ArrowSound, BlockReaction, EntityHit, Pickup,
|
|
Touch,
|
|
},
|
|
assets::Assets,
|
|
blocks::BlockFacts,
|
|
collisions,
|
|
items::ItemStack,
|
|
mobs::Who,
|
|
motion::{LAVA, MotionResources, WATER},
|
|
projectiles::{Hit, Projectile, ProjectileKind},
|
|
world::World,
|
|
};
|
|
use horizon_core::{
|
|
geometry::{Aabb, Vec3},
|
|
random::{LegacyRandom, RandomSource},
|
|
};
|
|
use serde_json::Value;
|
|
use std::{
|
|
fs,
|
|
io::{BufRead, Write},
|
|
path::PathBuf,
|
|
};
|
|
fn number(v: &Value) -> f64 {
|
|
f64::from_bits(u64::from_str_radix(v.as_str().unwrap(), 16).unwrap())
|
|
}
|
|
fn vector(v: &Value) -> Vec3 {
|
|
Vec3::new(number(&v[0]), number(&v[1]), number(&v[2]))
|
|
}
|
|
fn bits(v: Vec3) -> String {
|
|
format!(
|
|
"{:016x},{:016x},{:016x}",
|
|
v.x.to_bits(),
|
|
v.y.to_bits(),
|
|
v.z.to_bits()
|
|
)
|
|
}
|
|
fn seed(v: &Value) -> i64 {
|
|
v.as_str().unwrap().parse().unwrap()
|
|
}
|
|
fn particle(k: ArrowParticle) -> &'static str {
|
|
match k {
|
|
ArrowParticle::Bubble => "bubble",
|
|
ArrowParticle::Crit => "crit",
|
|
ArrowParticle::Splash => "splash",
|
|
}
|
|
}
|
|
fn main() -> Result<()> {
|
|
let args: Vec<_> = std::env::args().skip(1).collect();
|
|
if args.len() != 3 {
|
|
return Err("usage: arrow_probe RESOURCES FIXTURE_DIRECTORY --describe|REFERENCE".into());
|
|
}
|
|
let root = PathBuf::from(&args[0]);
|
|
let dir = PathBuf::from(&args[1]);
|
|
let assets = Assets::load(&root)?;
|
|
let mut scene = World::test_scene(&assets, 1)?;
|
|
fs::write(
|
|
dir.join("scene.json"),
|
|
serde_json::to_vec(
|
|
&serde_json::json!({"radius":1,"resident_chunks":scene.chunks.len(),"model_gallery":assets.model_gallery}),
|
|
)?,
|
|
)?;
|
|
if args[2] == "--describe" {
|
|
return Ok(());
|
|
}
|
|
let binding = collisions::load(&root, assets.registry)?;
|
|
let motion = MotionResources::load(&root, &assets)?;
|
|
let facts = BlockFacts::load(&root, assets.registry)?;
|
|
let side = &args[2];
|
|
let mut out = std::io::BufWriter::new(fs::File::create(dir.join(format!("rust-{side}.txt")))?);
|
|
let mut level_random = LegacyRandom::new(0);
|
|
for line in std::io::BufReader::new(fs::File::open(dir.join("inputs.txt"))?).lines() {
|
|
let f: Value = serde_json::from_str(&line?)?;
|
|
let kind = ProjectileKind::Arrow {
|
|
base_damage: 2.0,
|
|
critical: f["crit"].as_bool().unwrap(),
|
|
effect: None,
|
|
};
|
|
let mut arrow = Projectile::new(kind, vector(&f["position"]), None)
|
|
.with_arrow_random(LegacyRandom::new(seed(&f["seed"])));
|
|
arrow.velocity = vector(&f["velocity"]);
|
|
arrow.arrow.as_mut().unwrap().no_physics = f["no_physics"].as_bool().unwrap();
|
|
// ProjectileWeaponItem.useAmmo's stack, intangible when no ammo was used.
|
|
arrow.arrow.as_mut().unwrap().set_item(&arrows::drawn_ammo(
|
|
&ItemStack::new("minecraft:arrow", 1),
|
|
f["intangible"].as_bool().unwrap(),
|
|
));
|
|
// The entity in the way: its box and whether it takes the damage.
|
|
let mut target: Option<(Aabb, bool)> = None;
|
|
for op in f["ops"].as_array().unwrap() {
|
|
let mut events = Vec::new();
|
|
let mut touched = "-".to_string();
|
|
match op["mode"].as_str().unwrap() {
|
|
"tick" => {
|
|
// The game's part of an entity hit: the damage it deals
|
|
// (recorded after the tick's own events).
|
|
let mut hurt = None;
|
|
if !arrow.arrow.as_ref().unwrap().removed {
|
|
let no_rain = |_| false;
|
|
let view = ArrowScene {
|
|
world: &scene,
|
|
registry: assets.registry,
|
|
facts: &facts,
|
|
collision: &binding,
|
|
fluids: &motion.fluids,
|
|
raining: &no_rain,
|
|
mob_griefing: true,
|
|
tnt_explodes: true,
|
|
};
|
|
let targets: Vec<_> = target.iter().map(|t| (Who::Mob(2), t.0)).collect();
|
|
let (_, hit) = arrows::tick(&mut arrow, &view, &targets);
|
|
if let (Hit::Entity { .. }, Some((_, takes))) = (hit, target) {
|
|
let mut st = arrow.arrow.take().unwrap();
|
|
let damage = arrow.arrow_damage(&mut st.random);
|
|
hurt = Some((st.events.len(), damage));
|
|
arrow.arrow = Some(st);
|
|
let outcome = if takes {
|
|
EntityHit::Hurt
|
|
} else {
|
|
EntityHit::Refused
|
|
};
|
|
arrows::finish_entity_hit(&mut arrow, &view, outcome);
|
|
}
|
|
}
|
|
let a = arrow.arrow.as_mut().unwrap();
|
|
let (drop_at, dropped) = (arrow.position, a.pickup_item.count);
|
|
let raised = std::mem::take(&mut a.events);
|
|
let count = raised.len();
|
|
for (i, event) in raised.into_iter().map(Some).chain([None]).enumerate() {
|
|
if let Some((at, damage)) = hurt
|
|
&& at == i
|
|
{
|
|
events.push(format!("hurt {:08x}", damage.to_bits()));
|
|
}
|
|
let Some(event) = event else {
|
|
debug_assert_eq!(i, count);
|
|
break;
|
|
};
|
|
match event {
|
|
ArrowEvent::Particle {
|
|
kind,
|
|
position,
|
|
velocity,
|
|
} => events.push(format!(
|
|
"particle {} {} {}",
|
|
particle(kind),
|
|
bits(position),
|
|
bits(velocity)
|
|
)),
|
|
ArrowEvent::Sound {
|
|
sound,
|
|
volume,
|
|
pitch,
|
|
} => events.push(format!(
|
|
"sound {} {:08x} {:08x}",
|
|
match sound {
|
|
ArrowSound::HitGround => "hit",
|
|
ArrowSound::Splash => "splash",
|
|
ArrowSound::Extinguish => "extinguish",
|
|
},
|
|
volume.to_bits(),
|
|
pitch.to_bits()
|
|
)),
|
|
ArrowEvent::BubbleColumnParticles { pos } => {
|
|
for _ in 0..2 {
|
|
let x = f64::from(pos.x) + level_random.next_double();
|
|
let z = f64::from(pos.z) + level_random.next_double();
|
|
let at = Vec3::new(x, f64::from(pos.y + 1), z);
|
|
events.push(format!(
|
|
"sent splash {} {} {:016x}",
|
|
bits(at),
|
|
bits(Vec3::ZERO),
|
|
1.0f64.to_bits()
|
|
));
|
|
let x = f64::from(pos.x) + level_random.next_double();
|
|
let z = f64::from(pos.z) + level_random.next_double();
|
|
let at = Vec3::new(x, f64::from(pos.y + 1), z);
|
|
events.push(format!(
|
|
"sent bubble {} {} {:016x}",
|
|
bits(at),
|
|
bits(Vec3::new(0.0, 0.01, 0.0)),
|
|
0.2f64.to_bits()
|
|
));
|
|
}
|
|
}
|
|
ArrowEvent::Block { pos, reaction } => match reaction {
|
|
BlockReaction::PrimeTnt => {
|
|
// TntBlock.prime: PrimedTnt draws its push from the
|
|
// level random, then removeBlock(pos, false).
|
|
let _ = level_random.next_double();
|
|
let at = Vec3::new(
|
|
f64::from(pos.x) + 0.5,
|
|
f64::from(pos.y),
|
|
f64::from(pos.z) + 0.5,
|
|
);
|
|
events.push(format!("spawn tnt {} 80", bits(at)));
|
|
events.push(format!(
|
|
"sound tnt_primed {:08x} {:08x}",
|
|
1.0f32.to_bits(),
|
|
1.0f32.to_bits()
|
|
));
|
|
events.push("prime-event".into());
|
|
let air =
|
|
assets.registry.default_state("minecraft:air").unwrap();
|
|
scene.set(pos.x, pos.y, pos.z, air)?;
|
|
events.push(format!(
|
|
"write {},{},{} {} 3",
|
|
pos.x, pos.y, pos.z, air.0
|
|
));
|
|
}
|
|
BlockReaction::Light(lit) => {
|
|
scene.set(pos.x, pos.y, pos.z, lit)?;
|
|
events.push(format!(
|
|
"write {},{},{} {} 11",
|
|
pos.x, pos.y, pos.z, lit.0
|
|
));
|
|
}
|
|
},
|
|
ArrowEvent::SplashEvent => events.push("splash-event".into()),
|
|
ArrowEvent::ShootEvent => events.push("shoot-event".into()),
|
|
ArrowEvent::Drop => events.push(format!(
|
|
"drop {} {dropped}",
|
|
bits(Vec3::new(
|
|
drop_at.x,
|
|
drop_at.y + f64::from(0.1f32),
|
|
drop_at.z
|
|
))
|
|
)),
|
|
}
|
|
}
|
|
}
|
|
"target" => {
|
|
// EntityDimensions.scalable(0.6, 1.8).makeBoundingBox.
|
|
let at = vector(&op["position"]);
|
|
let w = f64::from(0.6f32) / 2.0;
|
|
let h = f64::from(1.8f32);
|
|
let b = Aabb::new(
|
|
Vec3::new(at.x - w, at.y, at.z - w),
|
|
Vec3::new(at.x + w, at.y + h, at.z + w),
|
|
);
|
|
target = Some((b, op["takes"].as_bool().unwrap()));
|
|
}
|
|
"block" => {
|
|
let p = &op["position"];
|
|
let mut state = assets
|
|
.registry
|
|
.default_state(op["name"].as_str().unwrap())
|
|
.ok_or("missing fixture block")?;
|
|
if let Some(properties) = op["properties"].as_object() {
|
|
let mut definition = assets.registry.state(state).unwrap().clone();
|
|
for (name, value) in properties {
|
|
definition
|
|
.properties
|
|
.insert(name.clone(), value.as_str().unwrap().into());
|
|
}
|
|
state = assets
|
|
.registry
|
|
.id(&definition)
|
|
.ok_or("missing fixture state")?;
|
|
}
|
|
scene.set(
|
|
p[0].as_i64().unwrap() as i32,
|
|
p[1].as_i64().unwrap() as i32,
|
|
p[2].as_i64().unwrap() as i32,
|
|
state,
|
|
)?;
|
|
}
|
|
"velocity" => arrow.velocity = vector(&op["value"]),
|
|
"ignite" => arrow
|
|
.arrow
|
|
.as_mut()
|
|
.unwrap()
|
|
.ignite_for_seconds(f32::from_bits(
|
|
u32::from_str_radix(op["value"].as_str().unwrap(), 16).unwrap(),
|
|
)),
|
|
"level_seed" => level_random.set_seed(seed(&op["value"])),
|
|
"owner" => arrow
|
|
.arrow
|
|
.as_mut()
|
|
.unwrap()
|
|
.set_owner(match op["value"].as_str() {
|
|
Some("player") => Some(Who::Player),
|
|
Some("mob") => Some(Who::Mob(1)),
|
|
_ => None,
|
|
}),
|
|
"pickup" => {
|
|
arrow.arrow.as_mut().unwrap().pickup =
|
|
Pickup::from_byte(op["value"].as_i64().unwrap())
|
|
}
|
|
// The game's touch: the inventory takes the arrow unless full,
|
|
// and a creative player takes it anyway.
|
|
"touch" => {
|
|
let creative = op["creative"].as_bool().unwrap();
|
|
let full = op["inventory"] == "full";
|
|
let a = arrow.arrow.as_mut().unwrap();
|
|
let (taken, arrows) = match a.player_touch(creative) {
|
|
Touch::Ignore => (false, 0),
|
|
Touch::Take => (true, 0),
|
|
Touch::Give(_) => (!full || creative, u32::from(!full)),
|
|
};
|
|
if taken {
|
|
a.removed = true;
|
|
}
|
|
touched = format!("{taken} {arrows}");
|
|
}
|
|
other => return Err(format!("unknown operation {other}").into()),
|
|
}
|
|
let a = arrow.arrow.as_ref().unwrap();
|
|
writeln!(
|
|
out,
|
|
"arrow {} {} {:08x} {:08x} {} {} {} {} {} {} {} {} {} {:016x} {:016x} {} {} {:016x} {}",
|
|
bits(arrow.position),
|
|
bits(arrow.velocity),
|
|
arrow.pitch.to_bits(),
|
|
arrow.yaw.to_bits(),
|
|
a.in_ground,
|
|
a.in_ground_time,
|
|
a.life,
|
|
a.shake,
|
|
a.last_state.map_or("none".into(), |s| s.0.to_string()),
|
|
a.fire_ticks,
|
|
a.was_touching_water,
|
|
a.was_eye_in_water,
|
|
a.first_tick,
|
|
a.fluids.fluid_height(&Tags, WATER).to_bits(),
|
|
a.fluids.fluid_height(&Tags, LAVA).to_bits(),
|
|
a.removed,
|
|
arrow.critical(),
|
|
a.fall_distance.to_bits(),
|
|
bits(arrow.previous)
|
|
)?;
|
|
writeln!(out, "events {}", events.join(" | "))?;
|
|
let a = arrow.arrow.as_ref().unwrap();
|
|
let intangible = a
|
|
.pickup_item
|
|
.data()
|
|
.and_then(|d| d.other(arrows::INTANGIBLE))
|
|
.is_some();
|
|
writeln!(out, "pickup {} {intangible} {touched}", a.pickup.byte())?;
|
|
}
|
|
writeln!(out, "end")?;
|
|
}
|
|
Ok(())
|
|
}
|
|
struct Tags;
|
|
impl horizon_world::entity_fluid::FluidMembership for Tags {
|
|
fn fluid_in_tag(
|
|
&self,
|
|
kind: horizon_world::fluid::FluidKind,
|
|
tag: horizon_world::entity_fluid::FluidTagId,
|
|
) -> bool {
|
|
use horizon_world::fluid::FluidKind;
|
|
if tag == WATER {
|
|
matches!(kind, FluidKind::Water | FluidKind::FlowingWater)
|
|
} else {
|
|
matches!(kind, FluidKind::Lava | FluidKind::FlowingLava)
|
|
}
|
|
}
|
|
}
|