435 lines
17 KiB
Rust
435 lines
17 KiB
Rust
//! A server's levels, one per dimension (`MinecraftServer.levels`).
|
|
//!
|
|
//! The game's tick code reads one level: the one in place, held in `Game`'s
|
|
//! own fields (the world, its streaming and save, block ticks, entities).
|
|
//! A server (the dedicated server and single player's server thread) keeps
|
|
//! the other dimensions' levels here and ticks each one that has players by
|
|
//! swapping it into place (`enter_level`), the way `as_guest` swaps a player
|
|
//! in, so the tick code runs unchanged, one level at a time. The in-frame
|
|
//! game holds one level, which follows its player (`enter_dimension`).
|
|
//!
|
|
//! Shared by every level, as vanilla's derived levels share the
|
|
//! Overworld's level data: the game time, the day time and the weather, the
|
|
//! game rules, the scoreboard, the maps and the entities waiting to arrive
|
|
//! through a portal.
|
|
|
|
use super::{
|
|
Dim, ExperienceOrb, FallingBlock, Game, ItemEntity, Mob, boats, commands,
|
|
creaking::CreakingState, dragon, fireworks, lan::LanHost, lightning, machines, minecarts,
|
|
ominous_item_spawner, persist, raids::Raiding, sculk::SculkState, tnt, trident,
|
|
};
|
|
use horizon_client::{
|
|
Result, block_entity_anim::BlockEntityAnims, random_tick_sections::RandomTickSections,
|
|
save::SaveDir, streaming::Streaming, tick_chunk_membership::TickChunkMembership,
|
|
ticket_levels::ChunkTickets, world::World,
|
|
};
|
|
use horizon_world::level::{LevelEvent, Ticks};
|
|
use std::{
|
|
collections::HashMap,
|
|
sync::Arc,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
/// Server ticks a level other than the Overworld stays loaded with no player
|
|
/// in it, before it is saved and closed (vanilla unloads a level's chunks
|
|
/// once no ticket holds them; the Overworld stays loaded).
|
|
const IDLE_TICKS: u32 = 300;
|
|
|
|
/// A level that is not in place: every per-level field of `Game`.
|
|
pub(super) struct Parked {
|
|
world: World,
|
|
streaming: Streaming,
|
|
save: Arc<SaveDir>,
|
|
block_ticks: Ticks,
|
|
tick_chunks: TickChunkMembership,
|
|
tickets: ChunkTickets,
|
|
random_tick_sections: RandomTickSections,
|
|
level_events: Vec<LevelEvent>,
|
|
falling: Vec<FallingBlock>,
|
|
paintings: Vec<horizon_client::entities::Painting>,
|
|
item_frames: Vec<horizon_client::entities::ItemFrame>,
|
|
armor_stands: Vec<horizon_client::entities::ArmorStand>,
|
|
others: Vec<commands::OtherEntity>,
|
|
boats: Vec<boats::Boat>,
|
|
carts: Vec<minecarts::Minecart>,
|
|
jukebox_sounds: HashMap<(i32, i32, i32), u64>,
|
|
bolts: Vec<lightning::Bolt>,
|
|
crystals: Vec<dragon::Crystal>,
|
|
dragon: Option<dragon::Dragon>,
|
|
dragon_fireballs: Vec<dragon::DragonFireball>,
|
|
breath_clouds: Vec<dragon::Breath>,
|
|
tridents: Vec<trident::ThrownTrident>,
|
|
rockets: Vec<fireworks::Rocket>,
|
|
ominous_spawners: Vec<ominous_item_spawner::OminousItemSpawner>,
|
|
tnts: Vec<tnt::PrimedTnt>,
|
|
hoppers: HashMap<(i32, i32, i32), machines::HopperState>,
|
|
mobs: Vec<Mob>,
|
|
projectiles: Vec<horizon_client::projectiles::Projectile>,
|
|
dropped: Vec<ItemEntity>,
|
|
orbs: Vec<ExperienceOrb>,
|
|
persist: persist::EntityMemory,
|
|
lectern_pulses: Vec<((i32, i32, i32), i32)>,
|
|
lid_openers: HashMap<(i32, i32, i32), i32>,
|
|
lan_events: Vec<(i32, [i32; 3], i32, Option<u32>)>,
|
|
lan_block_events: Vec<([i32; 3], i32, i32, u32)>,
|
|
lan_entity_events: Vec<(i32, i8, [f64; 3])>,
|
|
/// Only the per-level parts of these are used (`swap_level`).
|
|
anims: BlockEntityAnims,
|
|
raiding: Raiding,
|
|
sculk: SculkState,
|
|
creaking: CreakingState,
|
|
/// Server ticks since a player was last in the level.
|
|
idle: u32,
|
|
}
|
|
|
|
/// Which passes of the server tick the level in place runs: the first
|
|
/// reads the network (`Hub::poll`), the last ends the tick for every player
|
|
/// (`Hub::end_tick`). A tick with one level is both.
|
|
#[derive(Clone, Copy)]
|
|
pub(super) struct Pass {
|
|
pub first: bool,
|
|
pub last: bool,
|
|
}
|
|
|
|
impl Default for Pass {
|
|
fn default() -> Self {
|
|
Self {
|
|
first: true,
|
|
last: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The levels not in place, by dimension.
|
|
#[derive(Default)]
|
|
pub(super) struct Levels {
|
|
parked: HashMap<Dim, Parked>,
|
|
}
|
|
|
|
impl Game<'_> {
|
|
/// A new level for `dim`, opened from the save (`MinecraftServer.createLevels`).
|
|
fn open_level(&self, dim: Dim) -> Result<Parked> {
|
|
let (streaming, save) =
|
|
self.make_streaming(&self.world_root.clone(), dim, self.level.seed)?;
|
|
let mut world = World::new(self.res.facts().air, self.level.seed);
|
|
world.fast_lava = dim == Dim::Nether;
|
|
Ok(Parked {
|
|
world,
|
|
streaming,
|
|
save,
|
|
block_ticks: Ticks::new(self.level.seed as i32),
|
|
tick_chunks: Default::default(),
|
|
tickets: Default::default(),
|
|
random_tick_sections: Default::default(),
|
|
level_events: Vec::new(),
|
|
falling: Vec::new(),
|
|
paintings: Vec::new(),
|
|
item_frames: Vec::new(),
|
|
armor_stands: Vec::new(),
|
|
others: Vec::new(),
|
|
boats: Vec::new(),
|
|
carts: Vec::new(),
|
|
jukebox_sounds: HashMap::new(),
|
|
bolts: Vec::new(),
|
|
crystals: Vec::new(),
|
|
dragon: None,
|
|
dragon_fireballs: Vec::new(),
|
|
breath_clouds: Vec::new(),
|
|
tridents: Vec::new(),
|
|
rockets: Vec::new(),
|
|
ominous_spawners: Vec::new(),
|
|
tnts: Vec::new(),
|
|
hoppers: HashMap::new(),
|
|
mobs: Vec::new(),
|
|
projectiles: Vec::new(),
|
|
dropped: Vec::new(),
|
|
orbs: Vec::new(),
|
|
persist: Default::default(),
|
|
lectern_pulses: Vec::new(),
|
|
lid_openers: HashMap::new(),
|
|
lan_events: Vec::new(),
|
|
lan_block_events: Vec::new(),
|
|
lan_entity_events: Vec::new(),
|
|
anims: Default::default(),
|
|
raiding: Default::default(),
|
|
sculk: Default::default(),
|
|
creaking: Default::default(),
|
|
idle: 0,
|
|
})
|
|
}
|
|
|
|
/// Exchange the level in place with `p`.
|
|
fn swap_level(&mut self, p: &mut Parked) {
|
|
use std::mem::swap;
|
|
swap(&mut self.world, &mut p.world);
|
|
swap(&mut self.streaming, &mut p.streaming);
|
|
swap(&mut self.save, &mut p.save);
|
|
swap(&mut self.block_ticks, &mut p.block_ticks);
|
|
swap(&mut self.tick_chunks, &mut p.tick_chunks);
|
|
swap(&mut self.tickets, &mut p.tickets);
|
|
swap(&mut self.random_tick_sections, &mut p.random_tick_sections);
|
|
swap(&mut self.level_events, &mut p.level_events);
|
|
swap(&mut self.falling, &mut p.falling);
|
|
swap(&mut self.paintings, &mut p.paintings);
|
|
swap(&mut self.item_frames, &mut p.item_frames);
|
|
swap(&mut self.armor_stands, &mut p.armor_stands);
|
|
swap(&mut self.others, &mut p.others);
|
|
swap(&mut self.boats, &mut p.boats);
|
|
swap(&mut self.carts, &mut p.carts);
|
|
swap(&mut self.jukebox_sounds, &mut p.jukebox_sounds);
|
|
swap(&mut self.bolts, &mut p.bolts);
|
|
swap(&mut self.crystals, &mut p.crystals);
|
|
swap(&mut self.dragon, &mut p.dragon);
|
|
swap(&mut self.dragon_fireballs, &mut p.dragon_fireballs);
|
|
swap(&mut self.breath_clouds, &mut p.breath_clouds);
|
|
swap(&mut self.tridents, &mut p.tridents);
|
|
swap(&mut self.rockets, &mut p.rockets);
|
|
swap(&mut self.ominous_spawners, &mut p.ominous_spawners);
|
|
swap(&mut self.tnts, &mut p.tnts);
|
|
swap(&mut self.hoppers, &mut p.hoppers);
|
|
swap(&mut self.mobs, &mut p.mobs);
|
|
swap(&mut self.creatures.projectiles, &mut p.projectiles);
|
|
swap(&mut self.dropped, &mut p.dropped);
|
|
swap(&mut self.orbs, &mut p.orbs);
|
|
swap(&mut self.persist, &mut p.persist);
|
|
swap(&mut self.lectern_pulses, &mut p.lectern_pulses);
|
|
swap(&mut self.lid_openers, &mut p.lid_openers);
|
|
swap(&mut self.lan_events, &mut p.lan_events);
|
|
swap(&mut self.lan_block_events, &mut p.lan_block_events);
|
|
swap(&mut self.lan_entity_events, &mut p.lan_entity_events);
|
|
let (a, b) = (&mut self.be_anims, &mut p.anims);
|
|
swap(&mut a.chests, &mut b.chests);
|
|
swap(&mut a.books, &mut b.books);
|
|
swap(&mut a.shulkers, &mut b.shulkers);
|
|
swap(&mut a.bells, &mut b.bells);
|
|
swap(&mut a.conduits, &mut b.conduits);
|
|
swap(&mut a.skulls, &mut b.skulls);
|
|
swap(&mut a.pots, &mut b.pots);
|
|
swap(&mut a.gateways, &mut b.gateways);
|
|
swap(&mut a.gateway_servers, &mut b.gateway_servers);
|
|
self.raiding.swap_level(&mut p.raiding);
|
|
self.sculk.swap_level(&mut p.sculk);
|
|
self.creaking.swap_level(&mut p.creaking);
|
|
// What only the client draws starts over.
|
|
self.particles.clear();
|
|
self.pickups.clear();
|
|
}
|
|
|
|
/// Put `target`'s level in place, opening it first if it is not loaded.
|
|
/// The level that was in place is kept with the others; the shared
|
|
/// clock and weather go with the swap. `host` is the hub when the caller
|
|
/// holds it (`self.lan` is taken during the network tick).
|
|
pub(super) fn enter_level(&mut self, host: Option<&mut LanHost>, target: Dim) -> Result<()> {
|
|
// The in-frame game keeps its one level (`enter_dimension`).
|
|
if self.options.execution_role.is_client() {
|
|
return Ok(());
|
|
}
|
|
if target != self.dim {
|
|
let (mut p, opened) = match self.levels.parked.remove(&target) {
|
|
Some(p) => (p, false),
|
|
None => (self.open_level(target)?, true),
|
|
};
|
|
p.world.game_time = self.world.game_time;
|
|
p.world.day_time = self.world.day_time;
|
|
p.world.weather = self.world.weather;
|
|
// The game rules and the difficulty are the server's, not a
|
|
// level's: natural regeneration holds in every dimension.
|
|
p.world.health_rules = self.world.health_rules;
|
|
// The sculk tables' watched blocks are built once per game.
|
|
p.world.watched = std::mem::take(&mut self.world.watched);
|
|
self.swap_level(&mut p);
|
|
p.idle = 0;
|
|
let left = std::mem::replace(&mut self.dim, target);
|
|
self.levels.parked.insert(left, p);
|
|
if opened {
|
|
// The new streaming's radius and meshing options.
|
|
self.apply_settings();
|
|
}
|
|
}
|
|
let host = match host {
|
|
Some(h) => Some(h),
|
|
None => self.lan.as_mut(),
|
|
};
|
|
if let Some(h) = host {
|
|
h.hub.set_dimension(target.id());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Put `dim`'s level in place for a command whose source is there
|
|
/// (`execute in`, `execute at` a player in another level), opening it if
|
|
/// nobody is in it; returns the level to put back afterwards. Only a
|
|
/// server holds other levels.
|
|
pub(super) fn enter_command_level(&mut self, dim: Dim) -> Option<Dim> {
|
|
if self.options.execution_role.is_client() || dim == self.dim {
|
|
return None;
|
|
}
|
|
let back = self.dim;
|
|
match self.enter_level(None, dim) {
|
|
Ok(()) => Some(back),
|
|
Err(e) => {
|
|
log::error!("could not open {}: {e}", dim.id());
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
/// One server tick (`MinecraftServer.tickServer`): each level with
|
|
/// players in turn (`tickChildren`), its chunks streamed and loaded and
|
|
/// its world ticked. The first pass reads the network and runs the
|
|
/// tick's shared parts (the clock, the weather, functions, the autosave);
|
|
/// the next ones only their level. While `paused`, only the connections
|
|
/// run.
|
|
pub(super) fn tick_server(&mut self, paused: bool) -> Result<()> {
|
|
let dims = self.levels_to_tick();
|
|
let n = dims.len();
|
|
let mut result = Ok(());
|
|
for (k, dim) in dims.into_iter().enumerate() {
|
|
if let Err(e) = self.enter_level(None, dim) {
|
|
result = Err(e);
|
|
break;
|
|
}
|
|
self.level_pass = Pass {
|
|
first: k == 0,
|
|
last: k + 1 == n,
|
|
};
|
|
self.update_dedicated_streaming();
|
|
self.update_world();
|
|
result = if paused {
|
|
self.tick_lan(true);
|
|
Ok(())
|
|
} else if k == 0 {
|
|
self.tick()
|
|
} else {
|
|
let running = self.clock.world_runs();
|
|
if running {
|
|
self.tick_weather_effects();
|
|
}
|
|
self.tick_world(running)
|
|
};
|
|
if result.is_err() {
|
|
break;
|
|
}
|
|
}
|
|
self.level_pass = Pass::default();
|
|
result?;
|
|
self.close_idle_levels()
|
|
}
|
|
|
|
/// `tick_server` as a server thread runs it. With `HORIZON_SPIKES=MS`, a
|
|
/// tick longer than MS is logged with its thread CPU time and spans.
|
|
pub(super) fn tick_server_timed(&mut self, paused: bool) -> Result<()> {
|
|
let Some(threshold) = self.options.spikes else {
|
|
return self.tick_server(paused);
|
|
};
|
|
let (started, cpu) = (Instant::now(), horizon_client::spans::thread_cpu());
|
|
let result = self.tick_server(paused);
|
|
let wall = started.elapsed().as_secs_f32() * 1000.0;
|
|
// Taken every tick: nothing else takes this thread's spans.
|
|
let spans = horizon_client::spans::take();
|
|
if wall > threshold {
|
|
let cpu = horizon_client::spans::thread_cpu()
|
|
.zip(cpu)
|
|
.map_or_else(String::new, |(end, start)| {
|
|
format!(", cpu {:.1} ms", (end - start).as_secs_f32() * 1000.0)
|
|
});
|
|
log::info!(
|
|
"Horizon: slow tick {wall:.1} ms{cpu} ({} mobs): {}",
|
|
self.mobs.len(),
|
|
horizon_client::spans::describe(&spans)
|
|
);
|
|
}
|
|
result
|
|
}
|
|
|
|
/// The end of `MinecraftServer.runServer`'s loop for a server thread: a
|
|
/// finished `/tick sprint` reports to the operators as the server, then
|
|
/// the next tick starts one tick length after this one, or straight away
|
|
/// while the sprint runs (`checkShouldSprintThisTick`).
|
|
pub(super) fn wait_for_next_server_tick(&mut self, next: &mut Instant, paused: bool) {
|
|
if let Some(report) = self.clock.take_sprint_report() {
|
|
// ServerTickRateManager.finishTickSprint: the server's sendSuccess.
|
|
self.console_broadcast = Some(true);
|
|
self.sprint_report(&report);
|
|
self.console_broadcast = None;
|
|
if let Some(mut host) = self.lan.take() {
|
|
self.send_admin_feedback(&mut host, None);
|
|
self.lan = Some(host);
|
|
}
|
|
self.admin_feedback.clear();
|
|
}
|
|
let now = Instant::now();
|
|
if !paused && self.clock.sprinting() {
|
|
*next = now;
|
|
return;
|
|
}
|
|
*next += self.clock.tick_duration();
|
|
if *next > now {
|
|
std::thread::sleep(*next - now);
|
|
} else if now - *next > Duration::from_secs(2) {
|
|
*next = now;
|
|
}
|
|
}
|
|
|
|
/// The levels this server tick runs, in `MinecraftServer.levels` order
|
|
/// (the Overworld, the Nether, the End): every level with a player in
|
|
/// it, or the Overworld while nobody is online.
|
|
pub(super) fn levels_to_tick(&self) -> Vec<Dim> {
|
|
let guests = self
|
|
.lan
|
|
.as_ref()
|
|
.map_or(&[][..], |h| h.hub.guests.as_slice());
|
|
let mut dims: Vec<Dim> = [Dim::Overworld, Dim::Nether, Dim::End]
|
|
.into_iter()
|
|
.filter(|d| guests.iter().any(|g| g.dimension == d.id()))
|
|
.collect();
|
|
if dims.is_empty() {
|
|
dims.push(Dim::Overworld);
|
|
}
|
|
dims
|
|
}
|
|
|
|
/// Count the parked levels' empty ticks, and save and close the ones
|
|
/// (other than the Overworld) nobody has been in for a while.
|
|
pub(super) fn close_idle_levels(&mut self) -> Result<()> {
|
|
let occupied = self.levels_to_tick();
|
|
let mut closing = Vec::new();
|
|
for (dim, p) in &mut self.levels.parked {
|
|
if occupied.contains(dim) {
|
|
p.idle = 0;
|
|
continue;
|
|
}
|
|
p.idle += 1;
|
|
if *dim != Dim::Overworld && p.idle >= IDLE_TICKS {
|
|
closing.push(*dim);
|
|
}
|
|
}
|
|
if closing.is_empty() {
|
|
return Ok(());
|
|
}
|
|
let back = self.dim;
|
|
for dim in closing {
|
|
self.enter_level(None, dim)?;
|
|
self.save_level(true)?;
|
|
self.enter_level(None, back)?;
|
|
self.levels.parked.remove(&dim);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Save every parked level (`MinecraftServer.saveAllChunks`); the level
|
|
/// in place is the caller's to save.
|
|
pub(super) fn save_parked_levels(&mut self, wait: bool) -> Result<()> {
|
|
if self.levels.parked.is_empty() {
|
|
return Ok(());
|
|
}
|
|
let back = self.dim;
|
|
let dims: Vec<Dim> = self.levels.parked.keys().copied().collect();
|
|
for dim in dims {
|
|
self.enter_level(None, dim)?;
|
|
self.save_level(wait)?;
|
|
}
|
|
self.enter_level(None, back)
|
|
}
|
|
}
|