Merge remote-tracking branch 'origin/main' into pr800
This commit is contained in:
@@ -233,22 +233,32 @@ fn mouse(c: &Value, out: &mut impl Write) -> Result<()> {
|
||||
fn scroll(c: &Value, out: &mut impl Write) -> Result<()> {
|
||||
let mut handler = MouseLook::default();
|
||||
let mut slot = c["slot"].as_i64().unwrap() as i32;
|
||||
let spectator = c["spectator"].as_bool().unwrap_or(false);
|
||||
let mut speed = 0.05;
|
||||
// OptionInstance.set quantises the wheel sensitivity.
|
||||
let mut file = OptionsFile::default();
|
||||
file.set("mouseWheelSensitivity", V::Double(db(&c["sens"])));
|
||||
let sensitivity = file.double("mouseWheelSensitivity");
|
||||
writeln!(out, "scroll")?;
|
||||
for op in c["ops"].as_array().unwrap() {
|
||||
if let Some((wheel, _)) =
|
||||
if let Some((wheel, (_, y))) =
|
||||
handler.on_scroll(db(&op[0]), db(&op[1]), b(&c["discrete"]), sensitivity)
|
||||
{
|
||||
slot = horizon_client::mouse::ScrollWheelHandler::next_selection(
|
||||
f64::from(wheel),
|
||||
slot,
|
||||
9,
|
||||
);
|
||||
if spectator {
|
||||
speed = horizon_client::mouse::spectator_flying_speed(speed, y);
|
||||
} else {
|
||||
slot = horizon_client::mouse::ScrollWheelHandler::next_selection(
|
||||
f64::from(wheel),
|
||||
slot,
|
||||
9,
|
||||
);
|
||||
}
|
||||
}
|
||||
if spectator {
|
||||
writeln!(out, "{slot} {}", fb(speed))?;
|
||||
} else {
|
||||
writeln!(out, "{slot}")?;
|
||||
}
|
||||
writeln!(out, "{slot}")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1024,6 +1024,7 @@ fn main() -> horizon_client::Result<()> {
|
||||
collision: &collision,
|
||||
data: &data,
|
||||
player: player.clone(),
|
||||
nearest_player: player.as_ref().filter(|p| !p.spectator).map(|p| p.position),
|
||||
others: $snapshot,
|
||||
others_grid: $grid,
|
||||
daylight: (world.day_time.rem_euclid(24000)) < 12000,
|
||||
|
||||
@@ -510,6 +510,9 @@ impl EntityObstructionWorld for PlayerObstruction {
|
||||
}
|
||||
}
|
||||
impl LevelAccess for GameLevel<'_> {
|
||||
fn world_surface(&self, x: i32, z: i32) -> i32 {
|
||||
self.world.world_surface(x, z, |s| self.facts.is_air(s))
|
||||
}
|
||||
fn precipitation(&self, pos: BlockPos) -> Option<horizon_world::level::Precipitation> {
|
||||
self.behaviours.precipitation_info(self, pos)
|
||||
}
|
||||
@@ -2594,7 +2597,12 @@ impl Game<'_> {
|
||||
let mut dropped = Vec::new();
|
||||
let mut collision_error = None;
|
||||
let entity_drops = self.ui.rules.bool("entity_drops");
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
falling.retain_mut(|f| {
|
||||
if !ticking(f.position.x.floor() as i32, f.position.z.floor() as i32) {
|
||||
return true;
|
||||
}
|
||||
let original = f.clone();
|
||||
f.previous = f.position;
|
||||
f.age = f.age.wrapping_add(1);
|
||||
@@ -9925,15 +9933,25 @@ impl ApplicationHandler for Game<'_> {
|
||||
&& self.sleeping.is_none()
|
||||
&& self.player.is_some()
|
||||
&& !self.extras_scroll(d)
|
||||
&& let Some((wheel, _)) =
|
||||
&& let Some((wheel, (_, vertical_steps))) =
|
||||
self.mouse
|
||||
.on_scroll(raw_x, raw_y, discrete, wheel_sensitivity)
|
||||
{
|
||||
self.selected = horizon_client::mouse::ScrollWheelHandler::next_selection(
|
||||
f64::from(wheel),
|
||||
self.selected as i32,
|
||||
9,
|
||||
) as usize;
|
||||
if self.spectator() {
|
||||
if let Some(player) = &mut self.player {
|
||||
player.flying_speed = horizon_client::mouse::spectator_flying_speed(
|
||||
player.flying_speed,
|
||||
vertical_steps,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
self.selected =
|
||||
horizon_client::mouse::ScrollWheelHandler::next_selection(
|
||||
f64::from(wheel),
|
||||
self.selected as i32,
|
||||
9,
|
||||
) as usize;
|
||||
}
|
||||
}
|
||||
if self.screen == Screen::Chat && d != 0.0 {
|
||||
self.chat_scroll(d);
|
||||
|
||||
@@ -382,7 +382,12 @@ impl Game<'_> {
|
||||
subject: None,
|
||||
};
|
||||
let mut dead = Vec::new();
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
for (i, a) in self.armor_stands.iter_mut().enumerate() {
|
||||
if !ticking(a.position.x.floor() as i32, a.position.z.floor() as i32) {
|
||||
continue;
|
||||
}
|
||||
a.tick(&mut scene);
|
||||
if !a.environment_tick(&self.world, self.res.facts(), self.pack.assets.registry) {
|
||||
dead.push(i);
|
||||
|
||||
@@ -443,8 +443,13 @@ impl Game<'_> {
|
||||
}
|
||||
/// Every boat but the ridden one (which ticks with its rider).
|
||||
pub(super) fn tick_boats(&mut self) {
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
for i in 0..self.boats.len() {
|
||||
if Some(self.boats[i].id) == self.riding {
|
||||
let p = self.boats[i].position;
|
||||
if Some(self.boats[i].id) == self.riding
|
||||
|| !ticking(p.x.floor() as i32, p.z.floor() as i32)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let b = self.boats[i].clone();
|
||||
|
||||
@@ -4,7 +4,8 @@
|
||||
//! command as the player (Commands.performPrefixedCommand) and records every
|
||||
//! system message it produced, as styled spans, with the results reported to
|
||||
//! the player's `CommandResultCallback`; `tick` advances the game; `settle`
|
||||
//! waits until the terrain around the player is loaded.
|
||||
//! waits until the terrain and entities around the player are loaded;
|
||||
//! `portal` sends the player through the nether portal it stands in.
|
||||
use super::Game;
|
||||
use horizon_client::{Result, text::Text};
|
||||
use serde_json::{Value, json};
|
||||
@@ -40,6 +41,19 @@ pub(super) fn spans(text: &Text) -> Value {
|
||||
}
|
||||
|
||||
impl Game<'_> {
|
||||
/// The player's portal process finished in the nether portal it stands
|
||||
/// in (the oracle's player is not ticked, so neither is the wait).
|
||||
fn harness_portal(&mut self) -> Result<()> {
|
||||
let Some(p) = &self.player else {
|
||||
return Err("command harness: portal without a player".into());
|
||||
};
|
||||
let entry = horizon_core::position::BlockPos::containing(p.position);
|
||||
let block = self.world.block(entry.x, entry.y, entry.z);
|
||||
if &*self.res.facts().get(block).name != "minecraft:nether_portal" {
|
||||
return Err("command harness: the player is not in a nether portal".into());
|
||||
}
|
||||
self.player_through_nether_portal(entry)
|
||||
}
|
||||
/// Load terrain until the player stands in lit chunks.
|
||||
fn harness_settle(&mut self, deadline: Instant) -> Result<()> {
|
||||
loop {
|
||||
@@ -51,6 +65,10 @@ impl Game<'_> {
|
||||
(p.position.z.floor() as i32) >> 4,
|
||||
);
|
||||
if (-1..=1).all(|dz| (-1..=1).all(|dx| self.streaming.is_lit(cx + dx, cz + dz))) {
|
||||
// The oracle's settle also waits for the entities saved
|
||||
// in those chunks (areEntitiesActuallyLoadedAndTicking):
|
||||
// after a dimension change they come back from the save.
|
||||
self.spawn_loaded_entities();
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
@@ -130,6 +148,7 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
"settle" => self.harness_settle(deadline)?,
|
||||
"portal" => self.harness_portal()?,
|
||||
other => return Err(format!("command harness: unknown op {other}").into()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -666,13 +666,20 @@ impl Game<'_> {
|
||||
/// Spawn an entity from its compound (`EntityType.loadEntityRecursive`);
|
||||
/// returns what was created.
|
||||
pub(super) fn spawn_entity_from_nbt(&mut self, tag: Tag) -> Option<Target> {
|
||||
let before = self.next_entity;
|
||||
let key = {
|
||||
let p = entity_nbt::position(&tag)?;
|
||||
((p.x.floor() as i32) >> 4, (p.z.floor() as i32) >> 4)
|
||||
};
|
||||
// Only this stack spawns now: the entities of chunks that finished
|
||||
// loading wait for the level's entity tick, as in vanilla
|
||||
// (PersistentEntitySectionManager.processPendingLoads), and must not
|
||||
// take the ids counted as this stack's.
|
||||
let mut waiting = std::mem::take(&mut self.world.loaded_entities);
|
||||
let before = self.next_entity;
|
||||
self.world.loaded_entities.push((key, vec![tag]));
|
||||
self.spawn_loaded_entities();
|
||||
waiting.append(&mut self.world.loaded_entities);
|
||||
self.world.loaded_entities = waiting;
|
||||
if self.next_entity == before {
|
||||
return None;
|
||||
}
|
||||
|
||||
@@ -377,6 +377,7 @@ impl Game<'_> {
|
||||
}
|
||||
pub(super) fn mob_world_base<'s>(&'s self, others: &'s [Seen]) -> MobWorld<'s> {
|
||||
let (rain, thunder) = self.world.weather.levels(1.0);
|
||||
let player = self.player_view();
|
||||
MobWorld {
|
||||
world: &self.world,
|
||||
registry: self.pack.assets.registry,
|
||||
@@ -384,7 +385,8 @@ impl Game<'_> {
|
||||
movement: &self.motion.blocks,
|
||||
collision: self.collision,
|
||||
data: self.res.mob_data(),
|
||||
player: self.player_view(),
|
||||
nearest_player: player.as_ref().filter(|p| !p.spectator).map(|p| p.position),
|
||||
player,
|
||||
others,
|
||||
others_grid: None,
|
||||
daylight: self.dim != Dim::Nether && self.sky_darken() < 4,
|
||||
@@ -429,25 +431,6 @@ impl Game<'_> {
|
||||
};
|
||||
spawning::LocalDifficulty::new(base, self.world.day_time, inhabited, moon)
|
||||
}
|
||||
/// `ServerChunkCache.tickSpawningChunk`: chunks whose centre is within
|
||||
/// 128 blocks of the player gain inhabited time.
|
||||
fn tick_inhabited(&mut self) {
|
||||
let Some(p) = self.player.as_ref().map(|p| p.position) else {
|
||||
return;
|
||||
};
|
||||
let (pcx, pcz) = (p.x.floor() as i32 >> 4, p.z.floor() as i32 >> 4);
|
||||
for dx in -8..=8 {
|
||||
for dz in -8..=8 {
|
||||
let key = (pcx + dx, pcz + dz);
|
||||
let (cx, cz) = (f64::from(key.0 * 16 + 8), f64::from(key.1 * 16 + 8));
|
||||
if (cx - p.x).powi(2) + (cz - p.z).powi(2) < 128.0 * 128.0
|
||||
&& self.world.chunks.contains_key(&key)
|
||||
{
|
||||
*self.world.inhabited.entry(key).or_insert(0) += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Advance every mob one tick, then apply their events.
|
||||
pub(super) fn tick_creatures(&mut self) -> Result<()> {
|
||||
self.attack_ticks = self.attack_ticks.saturating_add(1);
|
||||
@@ -464,7 +447,6 @@ impl Game<'_> {
|
||||
}
|
||||
self.spawn_generation_creatures(key.0, key.1);
|
||||
}
|
||||
self.tick_inhabited();
|
||||
self.tick_leads();
|
||||
self.spawn_natural();
|
||||
// ServerChunkCache.tickChunks: the custom spawners tick only with spawn_mobs.
|
||||
@@ -505,6 +487,7 @@ impl Game<'_> {
|
||||
let ticking = self.entity_ticking_area();
|
||||
// With guests on, each mob sees its nearest player (game/lan_mobs.rs).
|
||||
let guests = self.lan_guest_views();
|
||||
let players = self.level_players();
|
||||
let mut bindings = match self.lan.as_mut() {
|
||||
Some(host) if !guests.is_empty() => std::mem::take(&mut host.mob_players),
|
||||
_ => Default::default(),
|
||||
@@ -523,6 +506,13 @@ impl Game<'_> {
|
||||
let mut w = self.mob_world_base(&snapshot);
|
||||
w.others_grid = Some(&grid);
|
||||
let m = &mut mobs[i];
|
||||
w.nearest_player = super::natural_spawning::nearest_player(
|
||||
&players,
|
||||
m.position.x,
|
||||
m.position.y,
|
||||
m.position.z,
|
||||
)
|
||||
.map(|p| p.position);
|
||||
let seen_guest = if guests.is_empty() {
|
||||
None
|
||||
} else {
|
||||
|
||||
@@ -282,8 +282,15 @@ impl Game<'_> {
|
||||
}
|
||||
/// BlockAttachedEntity.tick for frames.
|
||||
pub(super) fn tick_item_frames(&mut self) {
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
let mut i = 0;
|
||||
while i < self.item_frames.len() {
|
||||
let at = center(&self.item_frames[i]);
|
||||
if !ticking(at[0].floor() as i32, at[2].floor() as i32) {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
self.item_frames[i].check_interval += 1;
|
||||
if self.item_frames[i].check_interval >= 100 {
|
||||
self.item_frames[i].check_interval = 0;
|
||||
|
||||
@@ -24,14 +24,18 @@ pub(super) struct Bolt {
|
||||
converted: Vec<u32>,
|
||||
}
|
||||
impl Game<'_> {
|
||||
/// One `tickThunder` roll per loaded chunk.
|
||||
/// `ServerChunkCache.tickSpawningChunk`: one `tickThunder` roll per
|
||||
/// spawning chunk (within 128 blocks of a player) that is in entity
|
||||
/// ticking range.
|
||||
pub(super) fn tick_thunder(&mut self) {
|
||||
// isRaining (rain level > 0.2) and isThundering (> 0.9, sky light, no ceiling).
|
||||
let (rain, thunder) = self.world.weather.levels(1.0);
|
||||
if rain <= 0.2 || thunder <= 0.9 || self.dim != super::Dim::Overworld {
|
||||
return;
|
||||
}
|
||||
let chunks: Vec<(i32, i32)> = self.world.chunks.keys().copied().collect();
|
||||
let (_, mut chunks) = self.spawning_chunks(&self.level_players());
|
||||
let levels = self.tickets.levels();
|
||||
chunks.retain(|&(x, z)| levels.random_ticking(x, z));
|
||||
for (cx, cz) in chunks {
|
||||
if self.world.random.next_int_bound(100_000).unwrap_or(1) != 0 {
|
||||
continue;
|
||||
|
||||
@@ -23,10 +23,54 @@ use horizon_core::{
|
||||
use horizon_world::registry::BlockStateId;
|
||||
use std::collections::HashMap;
|
||||
|
||||
/// A player in the level in place, as spawning and despawning see it.
|
||||
pub(super) struct LevelPlayer {
|
||||
pub(super) position: Vec3,
|
||||
pub(super) bounds: Aabb,
|
||||
pub(super) alive: bool,
|
||||
pub(super) creative: bool,
|
||||
pub(super) spectator: bool,
|
||||
}
|
||||
impl LevelPlayer {
|
||||
fn distance_sqr(&self, x: f64, y: f64, z: f64) -> f64 {
|
||||
(self.position.x - x).powi(2)
|
||||
+ (self.position.y - y).powi(2)
|
||||
+ (self.position.z - z).powi(2)
|
||||
}
|
||||
}
|
||||
/// `ChunkMap.euclideanDistanceSquared` below 128 blocks
|
||||
/// (`playerIsCloseEnoughForSpawning`).
|
||||
fn close_enough_for_spawning(p: &LevelPlayer, (cx, cz): (i32, i32)) -> bool {
|
||||
let (x, z) = (
|
||||
f64::from(cx * 16 + 8) - p.position.x,
|
||||
f64::from(cz * 16 + 8) - p.position.z,
|
||||
);
|
||||
!p.spectator && x * x + z * z < 16384.0
|
||||
}
|
||||
/// `EntityGetter.getNearestPlayer(x, y, z, -1, false)`: the nearest
|
||||
/// non-spectator, alive or not.
|
||||
pub(super) fn nearest_player(
|
||||
players: &[LevelPlayer],
|
||||
x: f64,
|
||||
y: f64,
|
||||
z: f64,
|
||||
) -> Option<&LevelPlayer> {
|
||||
let mut best: Option<(&LevelPlayer, f64)> = None;
|
||||
for p in players.iter().filter(|p| !p.spectator) {
|
||||
let d = p.distance_sqr(x, y, z);
|
||||
if best.is_none_or(|(_, b)| d < b) {
|
||||
best = Some((p, d));
|
||||
}
|
||||
}
|
||||
best.map(|(p, _)| p)
|
||||
}
|
||||
|
||||
/// The game level as natural spawning reads it.
|
||||
pub(super) struct GameLevel<'g, 'a> {
|
||||
pub(super) game: &'g Game<'a>,
|
||||
pub(super) w: MobWorld<'g>,
|
||||
/// Every player in the level ([`Game::level_players`]).
|
||||
pub(super) players: Vec<LevelPlayer>,
|
||||
/// Boxes of the mobs this pass created, not yet in the game's list.
|
||||
pub(super) pending: std::cell::RefCell<Vec<Aabb>>,
|
||||
/// The types and boxes of what a spawner created this tick.
|
||||
@@ -84,8 +128,11 @@ impl SpawnLevel for GameLevel<'_, '_> {
|
||||
fn world_seed(&self) -> i64 {
|
||||
self.w.world_seed
|
||||
}
|
||||
/// `getNearestPlayer(x, y, z, distance, true)`, over every player.
|
||||
fn player_near(&self, x: f64, y: f64, z: f64, distance: f64) -> bool {
|
||||
self.w.player_near(x, y, z, distance)
|
||||
self.players.iter().any(|p| {
|
||||
p.alive && !p.creative && !p.spectator && p.distance_sqr(x, y, z) < distance * distance
|
||||
})
|
||||
}
|
||||
}
|
||||
impl NaturalLevel for GameLevel<'_, '_> {
|
||||
@@ -138,12 +185,7 @@ impl NaturalLevel for GameLevel<'_, '_> {
|
||||
StructureSpawns::shared(&self.game.options.resources)
|
||||
}
|
||||
fn nearest_player_distance_sqr(&self, x: f64, y: f64, z: f64) -> Option<f64> {
|
||||
let p = self.game.player.as_ref()?;
|
||||
if self.game.spectator() {
|
||||
return None;
|
||||
}
|
||||
let d = [p.position.x - x, p.position.y - y, p.position.z - z];
|
||||
Some(d[0] * d[0] + d[1] * d[1] + d[2] * d[2])
|
||||
nearest_player(&self.players, x, y, z).map(|p| p.distance_sqr(x, y, z))
|
||||
}
|
||||
fn respawn(&self) -> Option<[i32; 3]> {
|
||||
// The world spawn point lives in the overworld.
|
||||
@@ -184,9 +226,9 @@ impl NaturalLevel for GameLevel<'_, '_> {
|
||||
}
|
||||
fn unobstructed(&self, bounds: Aabb) -> bool {
|
||||
let player = self
|
||||
.game
|
||||
.player_view()
|
||||
.is_some_and(|p| p.alive && !p.spectator && p.bounds.intersects(bounds));
|
||||
.players
|
||||
.iter()
|
||||
.any(|p| p.alive && !p.spectator && p.bounds.intersects(bounds));
|
||||
!player
|
||||
&& !self.pending.borrow().iter().any(|b| b.intersects(bounds))
|
||||
&& !self
|
||||
@@ -221,17 +263,10 @@ impl NaturalLevel for GameLevel<'_, '_> {
|
||||
}
|
||||
}
|
||||
impl horizon_client::mobs::spawner::SpawnerLevel for GameLevel<'_, '_> {
|
||||
/// `Level.hasNearbyAlivePlayer`, over every player.
|
||||
fn alive_player_near(&self, x: f64, y: f64, z: f64, range: f64) -> bool {
|
||||
let Some(p) = self.game.player_view() else {
|
||||
return false;
|
||||
};
|
||||
if !p.alive || p.spectator {
|
||||
return false;
|
||||
}
|
||||
let at = self.game.player.as_ref().map(|p| p.position);
|
||||
at.is_some_and(|a| {
|
||||
let d = (a.x - x).powi(2) + (a.y - y).powi(2) + (a.z - z).powi(2);
|
||||
range < 0.0 || d < range * range
|
||||
self.players.iter().any(|p| {
|
||||
p.alive && !p.spectator && (range < 0.0 || p.distance_sqr(x, y, z) < range * range)
|
||||
})
|
||||
}
|
||||
fn spawner_blocks_work(&self) -> bool {
|
||||
@@ -261,6 +296,7 @@ impl<'a> Game<'a> {
|
||||
GameLevel {
|
||||
game: self,
|
||||
w: self.mob_world_base(&[]),
|
||||
players: self.level_players(),
|
||||
pending: Default::default(),
|
||||
pending_ids: Default::default(),
|
||||
}
|
||||
@@ -299,25 +335,82 @@ impl<'a> Game<'a> {
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Every player in the level in place: the local player, and the LAN
|
||||
/// guests or server players in it.
|
||||
pub(super) fn level_players(&self) -> Vec<LevelPlayer> {
|
||||
let mut players: Vec<LevelPlayer> = self.lan.as_ref().map_or_else(Vec::new, |h| {
|
||||
h.hub
|
||||
.guests
|
||||
.iter()
|
||||
.filter(|g| h.hub.here(g))
|
||||
.map(|g| LevelPlayer {
|
||||
position: Vec3::new(g.position[0], g.position[1], g.position[2]),
|
||||
bounds: super::lan_mobs::guest_bounds(g),
|
||||
alive: !g.dead,
|
||||
creative: g.creative(),
|
||||
spectator: g.spectator(),
|
||||
})
|
||||
.collect()
|
||||
});
|
||||
if let Some(p) = self.player_view() {
|
||||
players.insert(
|
||||
0,
|
||||
LevelPlayer {
|
||||
position: p.position,
|
||||
bounds: p.bounds,
|
||||
alive: p.alive,
|
||||
creative: p.creative,
|
||||
spectator: p.spectator,
|
||||
},
|
||||
);
|
||||
}
|
||||
players
|
||||
}
|
||||
/// `ChunkMap.collectSpawningChunks`: the natural spawn chunk tracker's
|
||||
/// chunks (within 8 chunks of a player, `getSpawnCandidateChunks`) that
|
||||
/// are ticking and within 128 blocks of a non-spectator. Also returns how
|
||||
/// many chunks the tracker holds (`getNaturalSpawnChunkCount`).
|
||||
pub(super) fn spawning_chunks(&self, players: &[LevelPlayer]) -> (i32, Vec<(i32, i32)>) {
|
||||
let mut candidates: Vec<(i32, i32)> = Vec::with_capacity(289 * players.len());
|
||||
let mut seen = horizon_client::fast_hash::FxHashSet::default();
|
||||
for p in players {
|
||||
let (pcx, pcz) = (
|
||||
p.position.x.floor() as i32 >> 4,
|
||||
p.position.z.floor() as i32 >> 4,
|
||||
);
|
||||
for dx in -8..=8 {
|
||||
for dz in -8..=8 {
|
||||
let key = (pcx + dx, pcz + dz);
|
||||
if seen.insert(key) {
|
||||
candidates.push(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let count = candidates.len() as i32;
|
||||
let levels = self.tickets.levels();
|
||||
candidates.retain(|&(cx, cz)| {
|
||||
levels.loaded_ticking(cx, cz)
|
||||
&& super::ticking_chunk(&self.world, cx, cz)
|
||||
&& players
|
||||
.iter()
|
||||
.any(|p| close_enough_for_spawning(p, (cx, cz)))
|
||||
});
|
||||
(count, candidates)
|
||||
}
|
||||
/// `ServerChunkCache.tickChunks`: the spawn state over the loaded mobs,
|
||||
/// the categories under their global caps (creatures every 400 ticks),
|
||||
/// then `spawnForChunk` in the shuffled chunks within 128 blocks of the
|
||||
/// player.
|
||||
/// then `tickSpawningChunk` in the shuffled spawning chunks of every
|
||||
/// player: inhabited time, then `spawnForChunk`.
|
||||
pub(super) fn spawn_natural(&mut self) {
|
||||
let Some(p) = self.player.as_ref().map(|p| p.position) else {
|
||||
let players = self.level_players();
|
||||
if players.is_empty() {
|
||||
return;
|
||||
};
|
||||
let (pcx, pcz) = (p.x.floor() as i32 >> 4, p.z.floor() as i32 >> 4);
|
||||
// ChunkMap.collectSpawningChunks: tracked chunks whose centre is
|
||||
// within 128 blocks of a non-spectator.
|
||||
let spectator = self.spectator();
|
||||
let mut chunks: Vec<(i32, i32)> = (-8..=8)
|
||||
.flat_map(|dx| (-8..=8).map(move |dz| (pcx + dx, pcz + dz)))
|
||||
.filter(|&(cx, cz)| {
|
||||
let (x, z) = (f64::from(cx * 16 + 8) - p.x, f64::from(cz * 16 + 8) - p.z);
|
||||
!spectator && x * x + z * z < 16384.0 && self.world.chunks.contains_key(&(cx, cz))
|
||||
})
|
||||
.collect();
|
||||
}
|
||||
let (spawnable, mut chunks) = self.spawning_chunks(&players);
|
||||
for &key in &chunks {
|
||||
*self.world.inhabited.entry(key).or_insert(0) += 1;
|
||||
}
|
||||
let spawn_mobs = self.ui.rules.bool("spawn_mobs");
|
||||
let spawn_enemies = self.ui.rules.bool("spawn_monsters");
|
||||
let mut random = std::mem::replace(&mut self.world.random, LegacyRandom::new(0));
|
||||
@@ -339,12 +432,14 @@ impl<'a> Game<'a> {
|
||||
persistent: m.persistent,
|
||||
})
|
||||
.collect();
|
||||
let players = vec![SpawnPlayer {
|
||||
position: [p.x, p.y, p.z],
|
||||
spectator,
|
||||
}];
|
||||
// A single player's natural spawn chunk tracker covers 17 x 17 chunks.
|
||||
let mut state = SpawnState::new(&level, 289, players, &counted, |cx, cz| {
|
||||
let players = players
|
||||
.iter()
|
||||
.map(|p| SpawnPlayer {
|
||||
position: [p.position.x, p.position.y, p.position.z],
|
||||
spectator: p.spectator,
|
||||
})
|
||||
.collect();
|
||||
let mut state = SpawnState::new(&level, spawnable, players, &counted, |cx, cz| {
|
||||
self.world.chunks.contains_key(&(cx, cz))
|
||||
});
|
||||
let categories = if spawn_mobs {
|
||||
|
||||
@@ -298,6 +298,12 @@ impl Game<'_> {
|
||||
else {
|
||||
return Ok(());
|
||||
};
|
||||
self.player_through_nether_portal(entry)
|
||||
}
|
||||
/// `Entity.handlePortal` once the player's portal process at `entry`
|
||||
/// finished: `NetherPortalBlock.getPortalDestination`, then
|
||||
/// `teleportToPortalDestination` (`isAllowedToEnterPortal`).
|
||||
pub(super) fn player_through_nether_portal(&mut self, entry: BlockPos) -> Result<()> {
|
||||
let Some(p) = self.player.as_ref() else {
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
@@ -232,8 +232,16 @@ impl Game<'_> {
|
||||
}
|
||||
/// BlockAttachedEntity.tick: check survival every 100 ticks.
|
||||
pub(super) fn tick_paintings(&mut self) {
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
let mut i = 0;
|
||||
while i < self.paintings.len() {
|
||||
let (lo, hi) = self.paintings[i].bounds();
|
||||
let centre = [0, 2].map(|k| ((lo[k] + hi[k]) / 2.0).floor() as i32);
|
||||
if !ticking(centre[0], centre[1]) {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
self.paintings[i].check_interval += 1;
|
||||
if self.paintings[i].check_interval >= 100 {
|
||||
self.paintings[i].check_interval = 0;
|
||||
|
||||
@@ -1805,7 +1805,12 @@ impl Game<'_> {
|
||||
}
|
||||
_ => {}
|
||||
},
|
||||
C::PlayerAbilities(p) => self.creative = p.flags & 8 != 0,
|
||||
C::PlayerAbilities(p) => {
|
||||
self.creative = p.flags & 8 != 0;
|
||||
if let Some(player) = &mut self.player {
|
||||
player.flying_speed = p.flying_speed;
|
||||
}
|
||||
}
|
||||
C::SetHeldSlot(p) => {
|
||||
self.selected = p.slot.clamp(0, 8) as usize;
|
||||
if let Some(r) = self.remote.as_mut() {
|
||||
|
||||
@@ -156,8 +156,14 @@ impl Game<'_> {
|
||||
pub(super) fn tick_tnt(&mut self) -> Result<()> {
|
||||
let mut count = self.tnts.len();
|
||||
let mut i = 0;
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
while i < count {
|
||||
let t = &mut self.tnts[i];
|
||||
if !ticking(t.position.x.floor() as i32, t.position.z.floor() as i32) {
|
||||
i += 1;
|
||||
continue;
|
||||
}
|
||||
t.tick(
|
||||
&self.world,
|
||||
self.collision,
|
||||
|
||||
@@ -6,7 +6,7 @@ use horizon_client::{
|
||||
mobs::{Species, leash::Holder, spawning, trader},
|
||||
save::{read_dat, write_dat},
|
||||
};
|
||||
use horizon_core::random::RandomSource;
|
||||
use horizon_core::{geometry::Vec3, random::RandomSource};
|
||||
use horizon_world::nbt::Tag;
|
||||
|
||||
const TICK_DELAY: i32 = 1200;
|
||||
@@ -83,10 +83,7 @@ impl Game<'_> {
|
||||
}
|
||||
/// `WanderingTraderSpawner.tick`.
|
||||
pub(super) fn tick_wandering_trader(&mut self) {
|
||||
if self.dim != Dim::Overworld
|
||||
|| self.player.is_none()
|
||||
|| !self.ui.rules.bool("spawn_wandering_traders")
|
||||
{
|
||||
if self.dim != Dim::Overworld || !self.ui.rules.bool("spawn_wandering_traders") {
|
||||
return;
|
||||
}
|
||||
self.load_trader_data();
|
||||
@@ -110,9 +107,23 @@ impl Game<'_> {
|
||||
}
|
||||
/// `WanderingTraderSpawner.spawn`.
|
||||
fn spawn_trader(&mut self) -> bool {
|
||||
let Some(p) = self.player.as_ref().map(|p| p.position) else {
|
||||
// ServerLevel.getRandomPlayer: one of the living players, drawn
|
||||
// from the level random.
|
||||
let alive: Vec<Vec3> = self
|
||||
.level_players()
|
||||
.into_iter()
|
||||
.filter(|p| p.alive)
|
||||
.map(|p| p.position)
|
||||
.collect();
|
||||
if alive.is_empty() {
|
||||
return true;
|
||||
};
|
||||
}
|
||||
let pick = self
|
||||
.world
|
||||
.random
|
||||
.next_int_bound(alive.len() as i32)
|
||||
.unwrap_or(0);
|
||||
let p = alive[pick as usize];
|
||||
if self.world.random.next_int_bound(10).unwrap_or(1) != 0 {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -273,7 +273,9 @@ impl Cull {
|
||||
}
|
||||
let mapped = r.buffer.slice(..r.slots.len() as u64 * 4);
|
||||
if let Ok(data) = mapped.get_mapped_range() {
|
||||
let results: &[u32] = bytemuck::cast_slice(&data);
|
||||
// The mapping isn't guaranteed to be 4-byte aligned (a Vega 11
|
||||
// on Windows panicked in cast_slice), so copy the words out.
|
||||
let results: Vec<u32> = bytemuck::pod_collect_to_vec(&data);
|
||||
let (mut hidden, mut indices) = (0, 0u64);
|
||||
for (&result, &n) in results.iter().zip(&r.indices) {
|
||||
if result != r.stamp {
|
||||
@@ -283,7 +285,7 @@ impl Cull {
|
||||
}
|
||||
let share = indices as f32 / r.total.max(1) as f32;
|
||||
self.hidden = ([hidden, results.len()], share);
|
||||
for (&slot, &result) in r.slots.iter().zip(results) {
|
||||
for (&slot, &result) in r.slots.iter().zip(&results) {
|
||||
let slot = slot as usize;
|
||||
if slot >= self.seen.len() {
|
||||
self.seen.resize(slot + 1, false);
|
||||
|
||||
@@ -147,7 +147,8 @@ impl GpuTimer {
|
||||
continue;
|
||||
}
|
||||
if let Ok(data) = slot.buffer.slice(..).get_mapped_range() {
|
||||
let stamps: &[u64] = bytemuck::cast_slice(&data);
|
||||
// Read unaligned: the mapping isn't guaranteed to be 8-byte aligned.
|
||||
let stamps: [u64; 2] = bytemuck::pod_read_unaligned(&data[..16]);
|
||||
let ticks = stamps[1].saturating_sub(stamps[0]);
|
||||
out.push((ticks as f64 * f64::from(self.period_ns) / 1e6) as f32);
|
||||
}
|
||||
|
||||
@@ -1412,6 +1412,9 @@ pub struct MobWorld<'a> {
|
||||
pub collision: &'a BlockCollisionRegistry<'a>,
|
||||
pub data: &'a MobData,
|
||||
pub player: Option<PlayerView>,
|
||||
/// `getNearestPlayer(mob, -1)`: where the nearest non-spectator of every
|
||||
/// player in the level stands, alive or not (the despawn distance).
|
||||
pub nearest_player: Option<Vec3>,
|
||||
pub others: &'a [Seen],
|
||||
/// `others` by position, when the caller keeps one (the mob ticks).
|
||||
pub others_grid: Option<&'a seen_grid::SeenGrid>,
|
||||
|
||||
@@ -1018,8 +1018,10 @@ pub fn despawn_check(m: &mut Mob, w: &MobWorld) -> bool {
|
||||
/// Mob.checkDespawn, before the tick (players are the only despawn
|
||||
/// reference). Returns false when the mob is discarded.
|
||||
fn check_despawn(m: &mut Mob, w: &MobWorld) -> bool {
|
||||
let Some(p) = &w.player else { return true };
|
||||
let d = m.distance_sqr(p.position);
|
||||
let Some(p) = w.nearest_player else {
|
||||
return true;
|
||||
};
|
||||
let d = m.distance_sqr(p);
|
||||
// requiresCustomPersistence: raiders in a raid, a tame nautilus, a sulfur
|
||||
// cube holding a block or let out of a bucket.
|
||||
let persistent = m.persistent
|
||||
|
||||
@@ -224,6 +224,8 @@ pub struct PlayerMotion {
|
||||
/// Spectator mode: no physics, always flying (`Player.tick`).
|
||||
pub spectator: bool,
|
||||
pub flying: bool,
|
||||
/// Client-side `Abilities.flyingSpeed`, adjusted by the spectator scroll wheel.
|
||||
pub flying_speed: f32,
|
||||
/// The jump key last tick (LocalPlayer.aiStep's wasJumping).
|
||||
pub was_jumping: bool,
|
||||
/// `LocalPlayer.autoJumpEnabled` (the Auto-Jump option) and
|
||||
@@ -387,6 +389,7 @@ impl PlayerMotion {
|
||||
invulnerable: false,
|
||||
spectator: false,
|
||||
flying: false,
|
||||
flying_speed: 0.05,
|
||||
was_jumping: false,
|
||||
auto_jump_enabled: false,
|
||||
auto_jump_time: 0,
|
||||
@@ -789,7 +792,7 @@ impl MotionWorld<'_, '_, '_> {
|
||||
// Vertical flight: jump up, shift down, three times the flying speed.
|
||||
let ya = i32::from(jumping) - i32::from(self.player.shift_key_down);
|
||||
if ya != 0 {
|
||||
self.player.velocity.y += f64::from(ya as f32 * 0.05 * 3.0);
|
||||
self.player.velocity.y += f64::from(ya as f32 * self.player.flying_speed * 3.0);
|
||||
}
|
||||
}
|
||||
self.dry_tick(TickInput::PreparedLocal {
|
||||
@@ -1863,8 +1866,8 @@ impl LivingAirWorld for MotionWorld<'_, '_, '_> {
|
||||
}
|
||||
fn flying_speed(&mut self) -> Result<f32> {
|
||||
if self.player.flying {
|
||||
// Abilities.flyingSpeed 0.05, doubled when sprinting.
|
||||
return Ok(if self.player.sprinting { 0.1 } else { 0.05 });
|
||||
// Player.getFlyingSpeed: abilities speed, doubled when sprinting.
|
||||
return Ok(self.player.flying_speed * if self.player.sprinting { 2.0 } else { 1.0 });
|
||||
}
|
||||
Ok(if self.player.sprinting {
|
||||
0.025999999
|
||||
@@ -2123,6 +2126,47 @@ mod tests {
|
||||
assert!(player.position.y < 84.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn spectator_scroll_speed_controls_horizontal_and_vertical_flight() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
|
||||
if !root.join("movement-properties.nbt").exists() {
|
||||
return;
|
||||
}
|
||||
let assets = Assets::load(&root).unwrap();
|
||||
let render = assets.reload(&root).unwrap();
|
||||
let binding = crate::collisions::load(&root, assets.registry).unwrap();
|
||||
let resources = MotionResources::load(&root, &assets).unwrap();
|
||||
let run = |steps| {
|
||||
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
|
||||
let start = Vec3::new(20.5, 12.0, 20.5);
|
||||
let mut player = PlayerMotion::new(&resources, start).unwrap();
|
||||
player.spectator = true;
|
||||
player.flying_speed = crate::mouse::spectator_flying_speed(player.flying_speed, steps);
|
||||
MotionWorld {
|
||||
entities: &[],
|
||||
player: &mut player,
|
||||
scene: &mut scene,
|
||||
assets: &assets,
|
||||
collision_binding: &binding,
|
||||
resources: &resources,
|
||||
}
|
||||
.controlled_simulation_tick(crate::sprint::Keys {
|
||||
forward: true,
|
||||
jump: true,
|
||||
..Default::default()
|
||||
})
|
||||
.unwrap();
|
||||
player.position.subtract(start)
|
||||
};
|
||||
let stopped = run(-100);
|
||||
assert_eq!(stopped, Vec3::ZERO);
|
||||
let normal = run(0);
|
||||
let fast = run(10);
|
||||
assert!(normal.y > 0.0 && normal.z > 0.0);
|
||||
assert!((fast.y - normal.y * 2.0).abs() < 1e-6);
|
||||
assert!((fast.z - normal.z * 2.0).abs() < 1e-6);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resident_spectator_flight_ignores_solid_and_climbable_blocks() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
|
||||
|
||||
@@ -80,6 +80,12 @@ impl ScrollWheelHandler {
|
||||
}
|
||||
}
|
||||
|
||||
/// `MouseHandler.onScroll` with the spectator menu closed. Only vertical whole
|
||||
/// wheel steps adjust `Abilities.flyingSpeed`; horizontal scrolling does not.
|
||||
pub fn spectator_flying_speed(speed: f32, vertical_steps: i32) -> f32 {
|
||||
(speed + vertical_steps as f32 * 0.005).clamp(0.0, 0.2)
|
||||
}
|
||||
|
||||
/// Entity rotation as `Entity.turn` keeps it.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct Rotation {
|
||||
|
||||
@@ -103,6 +103,13 @@ impl SamplerContext {
|
||||
self.scratch.push(buffer);
|
||||
result
|
||||
}
|
||||
/// Start an independent evaluation, retaining only temporary scratch buffers.
|
||||
/// Cached scalar/volume results and world bindings must not cross chunks or
|
||||
/// graphs, whose cache IDs can refer to different functions.
|
||||
pub fn reset(&mut self) {
|
||||
self.caches = self.caches.as_ref().map(|_| Vec::new());
|
||||
self.fields = WorldFields::default();
|
||||
}
|
||||
/// Release retained storage between worlds or after unusually large work.
|
||||
pub fn clear_scratch(&mut self) {
|
||||
self.scratch.clear();
|
||||
|
||||
@@ -755,3 +755,73 @@ fn spline_lazy_branch_failure_preserves_completed_output_and_returns_scratch() {
|
||||
assert_eq!(context.scratch.len(), 2);
|
||||
assert_eq!(sampler.sample_value(&mut context, [0; 3]), Ok(7.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_retains_scratch_but_discards_graph_caches_and_world_bindings() {
|
||||
let binding = Arc::new(ConstantSampler(17.0));
|
||||
let lifetime = Arc::downgrade(&binding);
|
||||
let mut context = SamplerContext::cached()
|
||||
.with_world_fields(WorldFields::default().with_field(WorldField::Beardifier, binding));
|
||||
let cached = CachingDensitySampler::new(
|
||||
0,
|
||||
Arc::new(ContextBoundSampler::new(WorldField::Beardifier)),
|
||||
)
|
||||
.unwrap();
|
||||
let volume = DensityVolume::new([2; 3], [0; 3], [1; 3]).unwrap();
|
||||
let mut output = [0.0; 8];
|
||||
cached
|
||||
.sample_volume(&mut context, &mut output, volume)
|
||||
.unwrap();
|
||||
assert_eq!(output, [17.0; 8]);
|
||||
assert_eq!(cached.sample_value(&mut context, [9; 3]), Ok(17.0));
|
||||
context
|
||||
.with_buffer(128, |_, buffer| {
|
||||
buffer.fill(99.0);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
let allocation = context.scratch[0].as_ptr();
|
||||
let capacity = context.scratch[0].capacity();
|
||||
context.reset();
|
||||
assert!(lifetime.upgrade().is_none());
|
||||
assert!(context.caches.as_ref().unwrap().is_empty());
|
||||
assert_eq!(context.scratch[0].as_ptr(), allocation);
|
||||
assert_eq!(context.scratch[0].capacity(), capacity);
|
||||
// Same coordinates and cache ID must resolve the new context's fallback.
|
||||
assert_eq!(cached.sample_value(&mut context, [9; 3]), Ok(0.0));
|
||||
cached
|
||||
.sample_volume(&mut context, &mut output, volume)
|
||||
.unwrap();
|
||||
assert_eq!(output, [0.0; 8]);
|
||||
// A different graph may reuse IDs without inheriting scalar/volume results.
|
||||
context.reset();
|
||||
let replacement = CachingDensitySampler::new(0, Arc::new(ConstantSampler(3.0))).unwrap();
|
||||
assert_eq!(replacement.sample_value(&mut context, [9; 3]), Ok(3.0));
|
||||
replacement
|
||||
.sample_volume(&mut context, &mut output, volume)
|
||||
.unwrap();
|
||||
assert_eq!(output, [3.0; 8]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_after_sampling_error_drops_blender_and_preserves_uncached_mode() {
|
||||
let blender = Arc::new(EmptyBlender);
|
||||
let lifetime = Arc::downgrade(&blender);
|
||||
let mut context =
|
||||
SamplerContext::default().with_world_fields(WorldFields::default().with_blender(blender));
|
||||
let result: Result<(), SampleError> = context.with_buffer(64, |_, buffer| {
|
||||
buffer.fill(42.0);
|
||||
Err(SampleError::RecursiveCache)
|
||||
});
|
||||
assert_eq!(result, Err(SampleError::RecursiveCache));
|
||||
let allocation = context.scratch[0].as_ptr();
|
||||
context.reset();
|
||||
assert!(lifetime.upgrade().is_none());
|
||||
assert!(context.caches.is_none());
|
||||
context
|
||||
.with_buffer(32, |_, buffer| {
|
||||
assert_eq!(buffer.as_ptr(), allocation);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
@@ -301,6 +301,12 @@ pub trait LevelAccess {
|
||||
fn max_y(&self) -> i32 {
|
||||
320
|
||||
}
|
||||
/// `getHeight(WORLD_SURFACE, x, z)`: one above the column's highest
|
||||
/// block that isn't air. Only air lies above it, so scans for the other
|
||||
/// heightmaps start there. The default, `max_y`, scans the whole column.
|
||||
fn world_surface(&self, _x: i32, _z: i32) -> i32 {
|
||||
self.max_y()
|
||||
}
|
||||
/// Vanilla `level.random` (a `LegacyRandomSource`).
|
||||
fn random(&mut self) -> &mut LegacyRandom;
|
||||
fn game_time(&self) -> i64;
|
||||
|
||||
@@ -40,14 +40,16 @@ impl Behaviours {
|
||||
BiomePrecipitation::Rain
|
||||
}
|
||||
}
|
||||
/// `getHeightmapPos(MOTION_BLOCKING, pos)`.
|
||||
/// `getHeightmapPos(MOTION_BLOCKING, pos)`, scanning down from the
|
||||
/// world surface (air neither blocks motion nor holds a fluid).
|
||||
pub fn motion_blocking_top<L: LevelAccess + ?Sized>(
|
||||
&self,
|
||||
level: &L,
|
||||
pos: BlockPos,
|
||||
) -> BlockPos {
|
||||
let blocks = self.tag("minecraft:blocks_motion_in_heightmap");
|
||||
for y in (level.min_y()..level.max_y()).rev() {
|
||||
let top = level.world_surface(pos.x, pos.z).min(level.max_y());
|
||||
for y in (level.min_y()..top).rev() {
|
||||
let state = level.block_state(BlockPos::new(pos.x, y, pos.z));
|
||||
let fluid = self.fluid(state).kind() != FluidKind::Empty;
|
||||
if fluid || blocks.is_some_and(|t| t.contains(self.block(state))) {
|
||||
|
||||
@@ -635,6 +635,7 @@ struct Pipeline<R: RandomSource> {
|
||||
picker: GlobalFluidPicker,
|
||||
zoom: BiomeZoom,
|
||||
biome_cache: BiomeCache,
|
||||
biome_work: ChunkWork,
|
||||
carver_cache: Mutex<HashMap<(i32, i32), BiomeId>>,
|
||||
pub(super) decoration: Option<super::generator_decoration::Decoration>,
|
||||
pub(super) structures: Option<super::generator_structures::StructureState>,
|
||||
@@ -643,6 +644,30 @@ struct Pipeline<R: RandomSource> {
|
||||
spawn_position: std::sync::OnceLock<[i32; 2]>,
|
||||
}
|
||||
const CACHE_LIMIT: usize = 16384;
|
||||
/// Coordinates only equal missing neighbour keys. Weak entries retain no
|
||||
/// computed values across eviction or explicit invalidation. Only one work
|
||||
/// lock may be held at a time; finish shared prerequisites before acquiring it.
|
||||
pub(super) struct ChunkWork(Mutex<HashMap<(i32, i32), std::sync::Weak<Mutex<()>>>>);
|
||||
impl ChunkWork {
|
||||
pub(super) fn new() -> Self {
|
||||
Self(Mutex::new(HashMap::new()))
|
||||
}
|
||||
pub(super) fn at(&self, key: (i32, i32)) -> Arc<Mutex<()>> {
|
||||
let mut work = self.0.lock().unwrap();
|
||||
if let Some(lock) = work.get(&key).and_then(std::sync::Weak::upgrade) {
|
||||
return lock;
|
||||
}
|
||||
if work.len() >= 4096 {
|
||||
// Keep every active builder/waiter on its original lock, including
|
||||
// when the result cache was cleared while it was in flight.
|
||||
work.retain(|_, lock| lock.strong_count() > 0);
|
||||
}
|
||||
let lock = Arc::new(Mutex::new(()));
|
||||
work.insert(key, Arc::downgrade(&lock));
|
||||
lock
|
||||
}
|
||||
}
|
||||
|
||||
type BiomeCache = Mutex<HashMap<(i32, i32), Arc<BiomeChunk<BiomeId>>>>;
|
||||
|
||||
fn state(registry: &BlockRegistry, raw: &Value) -> Result<BlockStateId, GeneratorError> {
|
||||
@@ -834,6 +859,7 @@ where
|
||||
extensions,
|
||||
picker,
|
||||
biome_cache: Mutex::new(HashMap::new()),
|
||||
biome_work: ChunkWork::new(),
|
||||
carver_cache: Mutex::new(HashMap::new()),
|
||||
decoration: None,
|
||||
structures: None,
|
||||
@@ -867,6 +893,11 @@ where
|
||||
worker: &mut WorkerState,
|
||||
pos: ChunkPos,
|
||||
) -> Result<Arc<BiomeChunk<BiomeId>>, GeneratorError> {
|
||||
if let Some(chunk) = self.biome_cache.lock().unwrap().get(&(pos.x, pos.z)) {
|
||||
return Ok(chunk.clone());
|
||||
}
|
||||
let work = self.biome_work.at((pos.x, pos.z));
|
||||
let _work = work.lock().unwrap();
|
||||
if let Some(chunk) = self.biome_cache.lock().unwrap().get(&(pos.x, pos.z)) {
|
||||
return Ok(chunk.clone());
|
||||
}
|
||||
@@ -906,7 +937,15 @@ where
|
||||
Ok(chunk)
|
||||
}
|
||||
fn carver_biome(&self, worker: &mut WorkerState, origin: ChunkPos) -> Result<BiomeId, String> {
|
||||
if let Some(id) = self.carver_cache.lock().unwrap().get(&(origin.x, origin.z)) {
|
||||
let key = (origin.x, origin.z);
|
||||
if let Some(id) = worker.carver_biomes.get(&key) {
|
||||
return Ok(*id);
|
||||
}
|
||||
if worker.carver_biomes.len() >= 4096 {
|
||||
worker.carver_biomes.clear();
|
||||
}
|
||||
if let Some(id) = self.carver_cache.lock().unwrap().get(&key) {
|
||||
worker.carver_biomes.insert(key, *id);
|
||||
return Ok(*id);
|
||||
}
|
||||
let mut resolver = self.source.resolver(
|
||||
@@ -926,13 +965,27 @@ where
|
||||
if cache.len() >= CACHE_LIMIT * 4 {
|
||||
cache.clear();
|
||||
}
|
||||
cache.insert((origin.x, origin.z), id);
|
||||
cache.insert(key, id);
|
||||
worker.carver_biomes.insert(key, id);
|
||||
Ok(id)
|
||||
}
|
||||
fn generate(
|
||||
&self,
|
||||
worker: &mut WorkerState,
|
||||
pos: ChunkPos,
|
||||
) -> Result<ProtoChunk, GeneratorError> {
|
||||
let mut context = std::mem::take(&mut worker.terrain_context);
|
||||
let result = self.generate_with_context(worker, pos, &mut context);
|
||||
// Release chunk-specific bindings and caches even after a sampling error.
|
||||
context.reset();
|
||||
worker.terrain_context = context;
|
||||
result
|
||||
}
|
||||
fn generate_with_context(
|
||||
&self,
|
||||
worker: &mut WorkerState,
|
||||
pos: ChunkPos,
|
||||
context: &mut SamplerContext,
|
||||
) -> Result<ProtoChunk, GeneratorError> {
|
||||
let data = &self.data;
|
||||
let (min, height, sea) = (
|
||||
@@ -985,13 +1038,12 @@ where
|
||||
),
|
||||
None => Vec::new(),
|
||||
};
|
||||
let mut context = SamplerContext::cached();
|
||||
if let Some(beard) = self
|
||||
.structures
|
||||
.as_ref()
|
||||
.and_then(|s| s.beardifier(&references, pos))
|
||||
{
|
||||
context = context.with_world_fields(
|
||||
*context = std::mem::take(context).with_world_fields(
|
||||
horizon_core::density::WorldFields::default().with_field(
|
||||
horizon_core::density::WorldField::Beardifier,
|
||||
Arc::new(beard),
|
||||
@@ -1016,7 +1068,7 @@ where
|
||||
.fork_positional(),
|
||||
RegistryAquiferBlockStates::new(data.registry).map_err(stage("aquifer"))?,
|
||||
volume,
|
||||
&mut context,
|
||||
context,
|
||||
)
|
||||
.map_err(stage("aquifer"))?,
|
||||
),
|
||||
@@ -1030,7 +1082,7 @@ where
|
||||
&mut chunk,
|
||||
volume,
|
||||
self.router.get(RouterField::FinalDensity).as_ref(),
|
||||
&mut context,
|
||||
context,
|
||||
aquifer.as_mut(),
|
||||
self.settings.default_block,
|
||||
)
|
||||
@@ -1051,7 +1103,7 @@ where
|
||||
possible: Some(possible),
|
||||
},
|
||||
preliminary_surface: self.preliminary.clone(),
|
||||
density_context: &mut context,
|
||||
density_context: context,
|
||||
write_min_y: min,
|
||||
write_max_y: min + height - 1,
|
||||
},
|
||||
@@ -1086,7 +1138,7 @@ where
|
||||
possible: None,
|
||||
},
|
||||
preliminary_surface: self.preliminary.clone(),
|
||||
density_context: &mut context,
|
||||
density_context: context,
|
||||
},
|
||||
aquifer.as_mut(),
|
||||
&data.carving_blocks,
|
||||
@@ -1391,8 +1443,12 @@ pub struct StageTimings {
|
||||
/// thread-local caches and never change results.
|
||||
pub(super) struct WorkerState {
|
||||
pub(super) temperatures: Vec<BiomeTemperature>,
|
||||
terrain_context: SamplerContext,
|
||||
biome_context: SamplerContext,
|
||||
carver_context: SamplerContext,
|
||||
/// Seed/dimension-bound lookups avoid the shared mutex for overlapping
|
||||
/// carver neighborhoods. Bounded independently of the shared cache.
|
||||
carver_biomes: HashMap<(i32, i32), BiomeId>,
|
||||
timings: StageTimings,
|
||||
heights: HashMap<(i32, i32, u8), i32>,
|
||||
/// Decorate with structure pieces only (for structure parity checks).
|
||||
@@ -1866,8 +1922,10 @@ impl OverworldGenerator {
|
||||
.iter()
|
||||
.map(|s| BiomeTemperature::new(*s))
|
||||
.collect(),
|
||||
terrain_context: SamplerContext::cached(),
|
||||
biome_context: SamplerContext::cached(),
|
||||
carver_context: SamplerContext::default(),
|
||||
carver_biomes: HashMap::new(),
|
||||
timings: StageTimings::default(),
|
||||
structures_only: false,
|
||||
heights: HashMap::new(),
|
||||
@@ -1947,6 +2005,57 @@ impl GeneratorWorker {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn local_carver_cache_is_worker_owned_and_eviction_preserves_terrain() {
|
||||
let root = std::env::var_os("HORIZON_RESOURCES")
|
||||
.map(std::path::PathBuf::from)
|
||||
.unwrap_or_else(|| {
|
||||
Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3")
|
||||
});
|
||||
if !root.join("worldgen/world_presets.json").exists() {
|
||||
eprintln!("skipping: no worldgen bundle at {}", root.display());
|
||||
return;
|
||||
}
|
||||
let registry = Box::leak(Box::new(
|
||||
crate::level::data::load_registry(&root).expect("registry"),
|
||||
));
|
||||
let data = GeneratorData::load(&root.join("worldgen"), registry).unwrap();
|
||||
let generator = OverworldGenerator::new(data.clone(), 12345).unwrap();
|
||||
let mut first = generator.worker();
|
||||
let mut second = generator.worker();
|
||||
let pos = ChunkPos::new(0, 0);
|
||||
let before = first.generate_proto(pos).unwrap();
|
||||
assert!(!first.state.carver_biomes.is_empty());
|
||||
assert!(second.state.carver_biomes.is_empty());
|
||||
second.generate_proto(pos).unwrap();
|
||||
assert_eq!(first.state.carver_biomes, second.state.carver_biomes);
|
||||
let expected = first.state.carver_biomes.clone();
|
||||
first.state.carver_biomes.clear();
|
||||
// Fill unrelated origins to force eviction on the next local miss.
|
||||
for x in 0..4096 {
|
||||
first.state.carver_biomes.insert((x, 100_000), BiomeId(0));
|
||||
}
|
||||
let after = first.generate_proto(pos).unwrap();
|
||||
assert_eq!(first.state.carver_biomes, expected);
|
||||
for y in -64..320 {
|
||||
for z in 0..16 {
|
||||
for x in 0..16 {
|
||||
assert_eq!(before.block(x, y, z), after.block(x, y, z));
|
||||
assert_eq!(before.biome_id_at(x, y, z), after.biome_id_at(x, y, z));
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(
|
||||
OverworldGenerator::new(data, -1)
|
||||
.unwrap()
|
||||
.worker()
|
||||
.state
|
||||
.carver_biomes
|
||||
.is_empty()
|
||||
);
|
||||
assert_eq!(second.state.carver_biomes, expected);
|
||||
}
|
||||
|
||||
/// Generators of one seed and dimension share their ring positions;
|
||||
/// another seed or generator gets its own, and old entries go.
|
||||
#[test]
|
||||
@@ -2013,4 +2122,121 @@ mod tests {
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn neighbour_work_cleanup_keeps_active_keys_and_releases_idle_keys() {
|
||||
let work = ChunkWork::new();
|
||||
let first = work.at((0, 0));
|
||||
let held = first.lock().unwrap();
|
||||
let same = work.at((0, 0));
|
||||
assert!(Arc::ptr_eq(&first, &same));
|
||||
assert!(!Arc::ptr_eq(&first, &work.at((1, 0))));
|
||||
// Sweep many expired weak entries while a builder and a prospective
|
||||
// waiter retain their key. Cleanup must not split their coordination.
|
||||
for x in 1..8192 {
|
||||
drop(work.at((x, 1)));
|
||||
}
|
||||
assert!(work.0.lock().unwrap().len() <= 4096);
|
||||
assert!(Arc::ptr_eq(&same, &work.at((0, 0))));
|
||||
let weak = Arc::downgrade(&first);
|
||||
drop(held);
|
||||
drop((first, same));
|
||||
assert!(weak.upgrade().is_none());
|
||||
let next = work.at((0, 0));
|
||||
assert_eq!(Arc::strong_count(&next), 1);
|
||||
}
|
||||
|
||||
/// Equal concurrent misses share one biome volume and the same mutable
|
||||
/// structure pieces. Exercise cold ring startup before work coordination,
|
||||
/// then cache eviction and explicit start invalidation with old Arcs alive.
|
||||
#[test]
|
||||
fn concurrent_neighbours_share_results_and_survive_invalidation() {
|
||||
let root = std::env::var_os("HORIZON_RESOURCES")
|
||||
.map(std::path::PathBuf::from)
|
||||
.unwrap_or_else(|| {
|
||||
Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3")
|
||||
});
|
||||
if !root.join("worldgen/world_presets.json").exists() {
|
||||
eprintln!("skipping: no worldgen bundle at {}", root.display());
|
||||
return;
|
||||
}
|
||||
let registry = Box::leak(Box::new(
|
||||
crate::level::data::load_registry(&root).expect("registry"),
|
||||
));
|
||||
let data = GeneratorData::load(&root.join("worldgen"), registry).expect("worldgen data");
|
||||
let preset: Value = serde_json::from_str(&data.world_presets["minecraft:normal"]).unwrap();
|
||||
let generator_json = &preset["dimensions"]["minecraft:overworld"]["generator"];
|
||||
let settings: Value =
|
||||
serde_json::from_str(&data.settings[generator_json["settings"].as_str().unwrap()])
|
||||
.unwrap();
|
||||
let pipeline = Arc::new(
|
||||
Pipeline::new(
|
||||
data,
|
||||
12345,
|
||||
XoroshiroRandom::new(12345),
|
||||
generator_json,
|
||||
&settings,
|
||||
true,
|
||||
Some((-64, 384)),
|
||||
)
|
||||
.expect("pipeline"),
|
||||
);
|
||||
let generator = OverworldGenerator {
|
||||
pipeline: pipeline.clone(),
|
||||
};
|
||||
let barrier = std::sync::Barrier::new(6);
|
||||
let pos = ChunkPos::new(11, -11); // ancient city for this seed
|
||||
let results = std::thread::scope(|scope| {
|
||||
let handles: Vec<_> = (0..6)
|
||||
.map(|_| {
|
||||
scope.spawn(|| {
|
||||
let mut worker = generator.worker();
|
||||
barrier.wait();
|
||||
let biomes = pipeline.biome_chunk(&mut worker.state, pos).unwrap();
|
||||
let starts = pipeline.structure_starts(&mut worker.state, pos);
|
||||
(biomes, starts)
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
handles
|
||||
.into_iter()
|
||||
.map(|h| h.join().unwrap())
|
||||
.collect::<Vec<_>>()
|
||||
});
|
||||
let (biomes, starts) = &results[0];
|
||||
assert!(!starts.is_empty(), "fixture must exercise shared pieces");
|
||||
for (b, s) in &results[1..] {
|
||||
assert!(Arc::ptr_eq(biomes, b));
|
||||
assert_eq!(starts.len(), s.len());
|
||||
for (first, other) in starts.iter().zip(s) {
|
||||
assert!(Arc::ptr_eq(first, other));
|
||||
}
|
||||
}
|
||||
// Force the existing whole-cache biome eviction threshold.
|
||||
{
|
||||
let mut cache = pipeline.biome_cache.lock().unwrap();
|
||||
cache.clear();
|
||||
for x in 0..CACHE_LIMIT as i32 {
|
||||
cache.insert((x, 10000), biomes.clone());
|
||||
}
|
||||
}
|
||||
let mut worker = generator.worker();
|
||||
let rebuilt = pipeline.biome_chunk(&mut worker.state, pos).unwrap();
|
||||
assert!(!Arc::ptr_eq(biomes, &rebuilt));
|
||||
assert_eq!(pipeline.biome_cache.lock().unwrap().len(), 1);
|
||||
for section in 0..24 {
|
||||
assert_eq!(biomes.section(section), rebuilt.section(section));
|
||||
}
|
||||
worker.forget_structure_starts();
|
||||
let fresh = worker.structure_starts(pos);
|
||||
assert_eq!(starts.len(), fresh.len());
|
||||
for (old, new) in starts.iter().zip(&fresh) {
|
||||
assert!(!Arc::ptr_eq(old, new));
|
||||
assert_eq!(old.name, new.name);
|
||||
assert_eq!(old.bounding_box, new.bounding_box);
|
||||
}
|
||||
let again = worker.structure_starts(pos);
|
||||
for (first, hit) in fresh.iter().zip(&again) {
|
||||
assert!(Arc::ptr_eq(first, hit));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
use super::{
|
||||
biome::BiomeId,
|
||||
block_feature::FeatureBlockBindings,
|
||||
generator::{GeneratorData, GeneratorError},
|
||||
generator::{ChunkWork, GeneratorData, GeneratorError},
|
||||
structure::{
|
||||
StructureResources,
|
||||
start::{
|
||||
@@ -31,6 +31,7 @@ pub(super) struct StructureState {
|
||||
/// Structure indices of each decoration step, in registry order.
|
||||
pub(super) by_step: Vec<Vec<usize>>,
|
||||
starts: StartCache,
|
||||
start_work: ChunkWork,
|
||||
/// Concentric ring positions, computed on first use and shared with
|
||||
/// later generators of the same seed and dimension.
|
||||
rings: Arc<OnceLock<Rings>>,
|
||||
@@ -215,6 +216,7 @@ impl StructureState {
|
||||
possible_sets,
|
||||
by_step,
|
||||
starts: StartCache::new(),
|
||||
start_work: ChunkWork::new(),
|
||||
rings,
|
||||
ring_work: OnceLock::new(),
|
||||
}))
|
||||
@@ -246,6 +248,8 @@ impl StructureState {
|
||||
/// Drop the cached starts, so that later chunks build fresh pieces (the
|
||||
/// pieces keep per-start placement state such as a shipwreck's height).
|
||||
pub(super) fn forget_starts(&self) {
|
||||
// As before, a build already in flight can publish after this clear.
|
||||
// Do not wait for work locks or retain initialized entries here.
|
||||
self.starts.clear();
|
||||
}
|
||||
/// The (cached) structure starts owned by a chunk.
|
||||
@@ -257,7 +261,14 @@ impl StructureState {
|
||||
if let Some(found) = self.starts.get((chunk.x, chunk.z)) {
|
||||
return found;
|
||||
}
|
||||
// Ring searches enlist other workers and wait for them: never hold a
|
||||
// chunk-work lock while helping, even when this chunk has no starts.
|
||||
let rings = self.rings(context);
|
||||
let work = self.start_work.at((chunk.x, chunk.z));
|
||||
let _work = work.lock().unwrap();
|
||||
if let Some(found) = self.starts.get((chunk.x, chunk.z)) {
|
||||
return found;
|
||||
}
|
||||
let starts: Starts = Arc::new(
|
||||
create_starts(
|
||||
&self.registry,
|
||||
|
||||
@@ -222,6 +222,7 @@ public final class VanillaCommandExecOracle {
|
||||
}
|
||||
}
|
||||
case "settle" -> settle();
|
||||
case "portal" -> portal();
|
||||
default -> throw new IllegalArgumentException(line);
|
||||
}
|
||||
}
|
||||
@@ -278,6 +279,23 @@ public final class VanillaCommandExecOracle {
|
||||
}
|
||||
|
||||
/** Force-load the chunks around the player (Horizon waits for its streamed terrain). */
|
||||
/**
|
||||
* Entity.handlePortal once the player's portal process finished in the
|
||||
* nether portal it stands in (the oracle does not tick the player).
|
||||
*/
|
||||
void portal() {
|
||||
ServerLevel level = player.level();
|
||||
net.minecraft.core.BlockPos entry = player.blockPosition();
|
||||
if (!level.getBlockState(entry).is(net.minecraft.world.level.block.Blocks.NETHER_PORTAL)) {
|
||||
throw new IllegalStateException("portal: the player is not in a nether portal");
|
||||
}
|
||||
var block = (net.minecraft.world.level.block.NetherPortalBlock) net.minecraft.world.level.block.Blocks.NETHER_PORTAL;
|
||||
var transition = block.getPortalDestination(level, player, entry);
|
||||
if (transition != null) {
|
||||
player.teleportToPortalDestination(level, transition);
|
||||
}
|
||||
}
|
||||
|
||||
void settle() {
|
||||
ServerLevel level = player.level();
|
||||
int cx = player.chunkPosition().x(), cz = player.chunkPosition().z();
|
||||
|
||||
@@ -118,13 +118,14 @@ public final class VanillaGameLoopOracle {
|
||||
|
||||
static final class StubPlayer extends LocalPlayer {
|
||||
boolean scoping;
|
||||
boolean spectator;
|
||||
|
||||
StubPlayer() {
|
||||
super(null, null, null, null, null, Input.EMPTY, false, null, null);
|
||||
}
|
||||
|
||||
@Override public boolean isScoping() { return scoping; }
|
||||
@Override public boolean isSpectator() { return false; }
|
||||
@Override public boolean isSpectator() { return spectator; }
|
||||
}
|
||||
|
||||
static Minecraft shell;
|
||||
@@ -327,6 +328,12 @@ public final class VanillaGameLoopOracle {
|
||||
StubPlayer player = make(StubPlayer.class);
|
||||
Inventory inventory = make(Inventory.class);
|
||||
inventory.setSelectedSlot(c.get("slot").getAsInt());
|
||||
player.spectator = c.has("spectator") && c.get("spectator").getAsBoolean();
|
||||
field(net.minecraft.world.entity.player.Player.class, "abilities").set(player, new net.minecraft.world.entity.player.Abilities());
|
||||
var hud = make(net.minecraft.client.gui.Hud.class);
|
||||
field(net.minecraft.client.gui.Hud.class, "spectatorGui").set(hud,
|
||||
make(net.minecraft.client.gui.components.spectator.SpectatorGui.class));
|
||||
field(Gui.class, "hud").set(mc.gui, hud);
|
||||
field(net.minecraft.world.entity.player.Player.class, "inventory").set(player, inventory);
|
||||
mc.player = player;
|
||||
options.discreteMouseScroll().set(c.get("discrete").getAsBoolean());
|
||||
@@ -336,7 +343,7 @@ public final class VanillaGameLoopOracle {
|
||||
for (var e : c.getAsJsonArray("ops")) {
|
||||
var op = e.getAsJsonArray();
|
||||
h.onScroll(1L, d(op.get(0)), d(op.get(1)));
|
||||
out.println(inventory.getSelectedSlot());
|
||||
out.println(inventory.getSelectedSlot() + (player.spectator ? " " + fb(player.getAbilities().getFlyingSpeed()) : ""));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,8 @@
|
||||
|
||||
Each group is a list of operations: `cmd` runs a command as the player and
|
||||
records its messages and results (`record: false` runs setup silently),
|
||||
`tick` advances the game and `settle` loads the terrain around the player.
|
||||
`tick` advances the game, `settle` loads the terrain and entities around the
|
||||
player and `portal` sends the player through the nether portal it stands in.
|
||||
Everything happens high above the terrain (y 200 and up, where both worlds
|
||||
are air) after the world's entities are removed, so the results do not
|
||||
depend on world generation.
|
||||
@@ -416,6 +417,27 @@ def execute():
|
||||
]
|
||||
|
||||
|
||||
def levels():
|
||||
"""A nether portal round trip: on the way back the Overworld's entities (the
|
||||
pig left by `entities`) are found and a summon names what it summoned."""
|
||||
return [
|
||||
*setup('/fill 2 231 12 5 236 12 minecraft:obsidian', '/fill 3 232 12 4 235 12 minecraft:nether_portal[axis=x]',
|
||||
'/tp @s 3.5 232 12.5 0 0'),
|
||||
{'op': 'portal'},
|
||||
{'op': 'settle'},
|
||||
cmd('/execute if dimension minecraft:the_nether run say through the portal'),
|
||||
{'op': 'portal'},
|
||||
{'op': 'settle'},
|
||||
cmd('/execute if dimension minecraft:overworld run say back through the portal'),
|
||||
cmd('/data get entity @s Pos'),
|
||||
cmd('/data get entity @s Rotation'),
|
||||
cmd('/execute if entity @e[type=minecraft:pig]'),
|
||||
cmd('/summon minecraft:armor_stand 4.5 210 4.5 {NoGravity:1b,Tags:["lv"],CustomName:"Back"}'),
|
||||
*setup('/kill @e[tag=lv]', '/fill 2 231 12 5 236 12 minecraft:air', '/tp @s 8.5 230 8.5 0 0'),
|
||||
{'op': 'settle'},
|
||||
]
|
||||
|
||||
|
||||
def items_and_loot():
|
||||
return [
|
||||
*setup('/clear @s', '/gamemode survival'),
|
||||
@@ -940,6 +962,7 @@ def groups():
|
||||
('entities', entities()),
|
||||
('scores, teams and bossbars', scores()),
|
||||
('execute', execute()),
|
||||
('levels', levels()),
|
||||
('items and loot', items_and_loot()),
|
||||
('world', world_misc()),
|
||||
('progression', progression()),
|
||||
|
||||
@@ -120,8 +120,15 @@ def scroll_cases(rng):
|
||||
x = rng.choice([0.0, 0.0, 0.0, 1.0, -1.0, 0.25, -0.25, 0.4, 2.0, 5.5, -7.0, rng.uniform(-3, 3)])
|
||||
y = rng.choice([0.0, 1.0, -1.0, 1.0, -1.0, 0.1, -0.3, 0.5, -0.5, 2.0, -3.0, 120.0, rng.uniform(-3, 3)])
|
||||
ops.append([dbits(x), dbits(y)])
|
||||
yield dict(t='scroll', discrete=rng.random() < 0.4, sens=dbits(rng.choice([1.0, 0.01, 10.0, 0.5, 2.0, 3.1622776601683795])),
|
||||
slot=rng.randrange(9), ops=ops)
|
||||
case = dict(t='scroll', discrete=rng.random() < 0.4, sens=dbits(rng.choice([1.0, 0.01, 10.0, 0.5, 2.0, 3.1622776601683795])),
|
||||
slot=rng.randrange(9), ops=ops)
|
||||
yield case
|
||||
yield dict(case, spectator=True)
|
||||
# Bounds, recovery from each bound, fractional accumulation, and horizontal-only input.
|
||||
yield dict(t='scroll', discrete=False, sens=dbits(1.0), slot=4, spectator=True,
|
||||
ops=[[dbits(x), dbits(y)] for x, y in
|
||||
[(0, 100), (0, -1), (0, -100), (0, 1), (0, .4), (0, .7),
|
||||
(0, -.4), (0, -.7), (5, 0), (-5, 0)]])
|
||||
|
||||
|
||||
def key_cases(rng):
|
||||
@@ -152,7 +159,7 @@ def main():
|
||||
'Window.calculateScale/setGuiScale and MouseHandler scaled positions, FramerateLimitTracker throttle reasons and '
|
||||
'limits (not the focus-lost exclusive-fullscreen branch, which reads SDL), MouseHandler.onMove/turnPlayer with '
|
||||
'sensitivity, cinematic smoothing, scoping and inversion, Entity.turn clamps, onScroll with ScrollWheelHandler '
|
||||
'accumulation, discrete scrolling and hotbar selection, and ToggleKeyMapping/KeyMapping down, click and '
|
||||
'accumulation, discrete scrolling, hotbar selection and spectator flight speed, and ToggleKeyMapping/KeyMapping down, click and '
|
||||
'screen-release state. The frame clock source (Blaze3D.getTime, System.nanoTime) is injected, so sleeping in '
|
||||
'FramerateLimiter and vsync present-mode selection are covered by Rust unit tests only.')
|
||||
harness.differential(
|
||||
|
||||
Reference in New Issue
Block a user