Fix falling block collisions with partial blocks

This commit is contained in:
LookImEcho-Rick
2026-10-18 03:02:53 -05:00
parent c1b4ccd571
commit 7ddb4ddae5
3 changed files with 189 additions and 50 deletions
+14 -1
View File
@@ -131,12 +131,25 @@ impl SceneCollisions<'_, '_> {
movement: Vec3,
max_step: f32,
on_ground: bool,
) -> Result<Vec3> {
self.resolve_with_context(bounds, movement, max_step, on_ground, self.context(bounds))
}
/// Resolve movement with the entity's captured collision context. Most
/// callers only need the position context; entities such as falling blocks
/// also affect contextual block shapes (for example powder snow).
pub fn resolve_with_context(
&mut self,
bounds: Aabb,
movement: Vec3,
max_step: f32,
on_ground: bool,
context: CollisionContext<'_>,
) -> Result<Vec3> {
Ok(resolve_world_movement(
self,
MovementRequest {
entity: EntityIdentity(0),
context: self.context(bounds),
context,
bounds,
movement,
max_step,
+162 -46
View File
@@ -193,6 +193,8 @@ use horizon_core::{
use horizon_core::{geometry::Vec3, random::RandomSource};
use horizon_world::{
block_collision::BlockCollisionRegistry,
collision_context::{CollisionContext, CollisionEntity, CollisionItem},
entity_obstruction::{EntityIdentity, EntityObstructionWorld, ObstructionEntity},
level::{
Behaviours, Dimension as LevelDimension, EntityQuery, Landing, LevelAccess, LevelEvent,
PlaceContext, PlaceOutcome, PlayerContext, PlayerEffect, Ticks, flags as level_flags,
@@ -451,12 +453,14 @@ struct Hit {
struct GameLevel<'w> {
world: &'w mut World,
facts: &'w BlockFacts,
collision: &'w BlockCollisionRegistry<'w>,
events: &'w mut Vec<LevelEvent>,
dimension: LevelDimension,
darken: i32,
raining: bool,
thundering: bool,
player_box: Option<([f64; 3], [f64; 3])>,
player_collision: Option<PlayerCollision>,
/// Minecart boxes (detector rails).
cart_boxes: Vec<([f64; 3], [f64; 3])>,
biomes: &'w Biomes,
@@ -472,6 +476,32 @@ struct GameLevel<'w> {
pending: &'w mut spill::Pending,
spill: &'w mut spill::Spill,
}
struct PlayerCollision {
y: f64,
descending: bool,
fall_distance: f64,
main_hand_item: Arc<str>,
main_hand_count: i32,
leather_boots: bool,
}
struct PlayerObstruction(Aabb);
impl EntityObstructionWorld for PlayerObstruction {
type Error = std::convert::Infallible;
fn obstruction_candidates(
&mut self,
_excluded: Option<EntityIdentity>,
_bounds: Aabb,
) -> std::result::Result<Vec<ObstructionEntity>, Self::Error> {
Ok(vec![ObstructionEntity {
identity: EntityIdentity(0),
root_vehicle: EntityIdentity(0),
bounds: self.0,
removed: false,
spectator: false,
blocks_building: true,
}])
}
}
impl LevelAccess for GameLevel<'_> {
fn precipitation(&self, pos: BlockPos) -> Option<horizon_world::level::Precipitation> {
self.behaviours.precipitation_info(self, pos)
@@ -584,21 +614,63 @@ impl LevelAccess for GameLevel<'_> {
fn dimension(&self) -> LevelDimension {
self.dimension
}
/// Level.isUnobstructed against the player for full-collision blocks.
/// `Level.isUnobstructed`: the placed state's collision shape against the player.
fn is_unobstructed(&self, pos: BlockPos, state: BlockStateId) -> bool {
let Some((lo, hi)) = self.player_box else {
return true;
};
if !self.facts.get(state).full_collision {
let player = self.player_collision.as_ref();
let context = player.map_or_else(
|| CollisionContext::position(lo[1]),
|player| {
CollisionContext::for_entity(
CollisionEntity {
identity: EntityIdentity(0),
y: player.y,
descending: player.descending,
main_hand: Some(CollisionItem {
item: &player.main_hand_item,
count: player.main_hand_count,
}),
},
false,
)
},
);
let mut scene = collisions::SceneCollisions {
world: &*self.world,
binding: self.collision,
subject: player.map(|player| horizon_client::collisions::PowderSnowSubject {
fall_distance: player.fall_distance,
falling_block: false,
leather_boots: player.leather_boots,
walkable_type: false,
lava_walker: false,
}),
};
let Ok(shape) = self
.collision
.collision_shape_with_context(&mut scene, state, pos, &context)
else {
return false;
};
if shape.is_empty() {
return true;
}
let (x, y, z) = (f64::from(pos.x), f64::from(pos.y), f64::from(pos.z));
!(x < hi[0] - 1e-7
&& x + 1.0 > lo[0] + 1e-7
&& y < hi[1] - 1e-7
&& y + 1.0 > lo[1] + 1e-7
&& z < hi[2] - 1e-7
&& z + 1.0 > lo[2] + 1e-7)
let shape = shape.moved(horizon_core::geometry::Vec3::new(
f64::from(pos.x),
f64::from(pos.y),
f64::from(pos.z),
));
horizon_world::entity_obstruction::is_unobstructed(
&mut PlayerObstruction(Aabb::new(
horizon_core::geometry::Vec3::new(lo[0], lo[1], lo[2]),
horizon_core::geometry::Vec3::new(hi[0], hi[1], hi[2]),
)),
None,
&shape,
)
.unwrap_or(false)
}
/// Entities that trigger pressure plates, tripwires and detector rails:
/// the player (a mob) and the minecarts.
@@ -1769,6 +1841,22 @@ impl Game<'_> {
],
)
});
let player_collision = self.player.as_ref().filter(|_| !spectator).map(|p| {
let main_hand = self.inventory.get(self.selected).and_then(Option::as_ref);
PlayerCollision {
y: p.position.y,
descending: p.velocity.y < 0.0,
fall_distance: p.fall_distance,
main_hand_item: main_hand.map_or_else(
|| Arc::from("minecraft:air"),
|stack| Arc::clone(&stack.item),
),
main_hand_count: main_hand.map_or(0, |stack| stack.count as i32),
leather_boots: self.armor[3]
.as_ref()
.is_some_and(|stack| stack.item.as_ref() == "minecraft:leather_boots"),
}
});
let cart_boxes = self
.carts
.iter()
@@ -1790,12 +1878,14 @@ impl Game<'_> {
cart_boxes,
world: &mut self.world,
facts: &self.res.facts,
collision: self.collision,
events: &mut self.level_events,
dimension,
darken,
raining: rain > 0.2,
thundering: thunder > 0.9,
player_box,
player_collision,
biomes: &self.res.biomes,
seed: self.level.seed,
behaviours: &self.res.behaviours,
@@ -2297,65 +2387,87 @@ impl Game<'_> {
let mut falling = std::mem::take(&mut self.falling);
let mut landed = Vec::new();
let mut dropped = Vec::new();
let mut collision_error = None;
let entity_drops = self.ui.rules.bool("entity_drops");
falling.retain_mut(|f| {
let original = f.clone();
f.previous = f.position;
f.age = f.age.wrapping_add(1);
if !f.no_gravity {
f.velocity.y -= 0.04;
}
let wanted = f.velocity;
let mut scene = collisions::SceneCollisions {
world: &self.world,
binding: self.collision,
subject: Some(collisions::PowderSnowSubject {
fall_distance: f.fall_distance,
falling_block: true,
..Default::default()
}),
};
let context = CollisionContext::for_entity(
CollisionEntity {
identity: EntityIdentity(0),
y: f.position.y,
descending: wanted.y < 0.0,
main_hand: None,
},
false,
);
let movement = match scene.resolve_with_context(
horizon_client::falling_block::bounds(f.position),
wanted,
0.0,
false,
context,
) {
Ok(movement) => movement,
Err(error) => {
*f = original;
collision_error.get_or_insert(error);
return true;
}
};
let next = Vec3::new(
f.position.x + f.velocity.x,
f.position.y + f.velocity.y,
f.position.z + f.velocity.z,
f.position.x + movement.x,
f.position.y + movement.y,
f.position.z + movement.z,
);
let below = self.world.block(
next.x.floor() as i32,
next.y.floor() as i32,
next.z.floor() as i32,
);
let below_facts = self.res.facts.get(below);
// PowderSnowBlock.getCollisionShape for a FallingBlockEntity: the
// whole block, or 0.9 high after a fall of more than 2.5 blocks,
// where the block it rests in is the snow itself.
let powder_snow = &*below_facts.name == "minecraft:powder_snow";
let sunk = powder_snow
&& f.fall_distance > 2.5
&& next.y - next.y.floor() < f64::from(0.9_f32);
let solid =
(below_facts.full_collision || powder_snow && f.fall_distance <= 2.5 || sunk)
&& f.velocity.y < 0.0;
let on_ground = wanted.y < 0.0 && movement.y != wanted.y;
// FallingBlockEntity.tick: off the ground, it gives up after 600
// ticks (100 outside the world) and drops itself as an item.
let y = next.y.floor() as i32;
let outside =
y <= horizon_client::chunk::MIN_Y || y >= horizon_client::chunk::MIN_Y + 384;
if !solid && (f.age > 100 && outside || f.age > 600) {
if !on_ground && (f.age > 100 && outside || f.age > 600) {
if f.drop_item && entity_drops {
dropped.push((f.state, next));
}
return false;
}
if solid {
let pos = [
next.x.floor() as i32,
next.y.floor() as i32 + i32::from(!sunk),
next.z.floor() as i32,
];
let landing_y = if sunk {
next.y.floor() + f64::from(0.9_f32)
} else {
f64::from(pos[1])
};
f.fall_distance += (f.position.y - landing_y).max(0.0);
f.position = Vec3::new(next.x, landing_y, next.z);
landed.push((f.clone(), pos));
return false;
}
if next.y < f.position.y {
f.fall_distance += f.position.y - next.y;
}
f.position = next;
if on_ground {
let pos = [
f.position.x.floor() as i32,
f.position.y.floor() as i32,
f.position.z.floor() as i32,
];
landed.push((f.clone(), pos));
return false;
}
if movement.x != wanted.x {
f.velocity.x = 0.0;
}
if movement.y != wanted.y {
f.velocity.y = 0.0;
}
if movement.z != wanted.z {
f.velocity.z = 0.0;
}
f.velocity = Vec3::new(
f.velocity.x * 0.98,
f.velocity.y * 0.98,
@@ -2386,7 +2498,11 @@ impl Game<'_> {
for (block, pos) in landed {
self.finish_falling_block(block, pos);
}
self.process_level_events()
self.process_level_events()?;
if let Some(error) = collision_error {
return Err(error);
}
Ok(())
}
fn break_block(&mut self, pos: [i32; 3]) -> Result<()> {
self.with_player_actor(|game| game.break_block_as_player(pos))
+13 -3
View File
@@ -18,18 +18,28 @@ except ImportError:
def corpus(facts):
def bits(v):return struct.pack('>d',float(v)).hex()
def row(state,delta=(1,-0.08,0),step=0.6,grounded=True,context=2,offset=0,fail=-1,extra=(),entities=(),border=None):
def row(state,delta=(1,-0.08,0),step=0.6,grounded=True,context=2,offset=0,fail=-1,extra=(),entities=(),border=None,box=None):
blocks=[[x+offset,-1,z,facts['defaults']['minecraft:stone']] for x in range(-2,4) for z in range(-2,3)]
blocks.append([offset,0,0,state]);blocks.extend(extra)
return dict(chunks=[[x,z] for x in range((offset>>4)-1,(offset>>4)+2) for z in range(-1,2)],
blocks=blocks,context=context,y=bits(0),entities=[0,0],fail=fail,limit=100000,suffocating=False,
box=list(map(bits,[-0.6+offset,0,0.2,-0.2+offset,1.8,0.8])),
box=list(map(bits,box if box is not None else [-0.6+offset,0,0.2,-0.2+offset,1.8,0.8])),
movement=dict(delta=list(map(bits,delta)),step=bits(step),grounded=grounded,
entities=[list(map(bits,b)) for b in entities],border=None if border is None else list(map(bits,border))))
states=facts['states']
for state in range(len(states)):
yield row(state,context=state%4)
defaults=facts['defaults']
falling_surfaces=[('minecraft:stone_slab',0.5),('minecraft:oak_stairs',1.0),('minecraft:snow',0.125),
('minecraft:oak_fence',1.5),('minecraft:iron_bars',1.0),('minecraft:soul_sand',0.875),
('minecraft:farmland',0.9375)]
for block_id,top in falling_surfaces:
state=defaults[block_id]
size=struct.unpack('>f',struct.pack('>f',0.98))[0]
half=size/2
bottom=top+0.1
box=[0.5-half,bottom,0.5-half,0.5+half,bottom+size,0.5+half]
yield row(state,delta=(0,-0.25,0),step=0,grounded=False,context=2,box=box)
obstacles=[i for i,s in enumerate(states) if s['id'] in ['minecraft:oak_stairs','minecraft:stone_slab',
'minecraft:snow','minecraft:scaffolding','minecraft:powder_snow','minecraft:water',
'minecraft:shulker_box','minecraft:moving_piston','minecraft:piston','minecraft:soul_sand',
@@ -114,7 +124,7 @@ def main():
'definition_counts':dict(collections.Counter(definitions.values())),
'native_chunk_storage':'ProtoChunk', 'rust_chunk_storage':'TerrainChunk', 'fixtures':count, 'sources_sha256':tested, 'fixtures_sha256':fixtures,
'rust_output_sha256':lab.digest(build/'rust.txt', 'sha256'), 'references':references,
'scope':'Actual native Entity.collide executes initial collision and step-up decisions over BlockCollisions, registered block shapes and resident ProtoChunk sections. Rust combines owned/fallible step resolution with registry-bound TerrainChunk scanning. All registered states are used as obstacles, plus step heights, falling/grounded motion, zero and underflow motion, partial blocks, fluids, dynamic blocks, ceilings, chunk boundaries and query failures. Entity collider lists and world-border proximity/shape are controlled inputs; query order and reuse, shape collection and resulting displacement are compared. Contexts are deliberately supplied empty/position/placement snapshots in both worlds. This does not establish entity broad-phase selection, actual world-border proximity, travel/gravity/velocity or grounded side effects, experimental minecarts or a playable game.'}
'scope':'Actual native Entity.collide executes initial collision and step-up decisions over BlockCollisions, registered block shapes and resident ProtoChunk sections. Rust combines owned/fallible step resolution with registry-bound TerrainChunk scanning. All registered states are used as obstacles, plus step heights, falling/grounded motion, zero and underflow motion, partial blocks including exact falling-block-sized boxes over slabs, stairs, snow, fences, iron bars, soul sand and farmland, fluids, dynamic blocks, ceilings, chunk boundaries and query failures. Entity collider lists and world-border proximity/shape are controlled inputs; query order and reuse, shape collection and resulting displacement are compared. Contexts are deliberately supplied empty/position/placement snapshots in both worlds. This does not establish entity broad-phase selection, actual world-border proximity, travel/gravity/velocity or grounded side effects, experimental minecarts or a playable game.'}
lab.write_json(report_path, report);print(f'Scoped world movement parity passed: {report_path}', flush=True)