1#![deny(unsafe_code)]
2#![expect(
3 clippy::option_map_unit_fn,
4 clippy::needless_pass_by_ref_mut )]
6#![deny(clippy::clone_on_ref_ptr)]
7#![feature(box_patterns, option_zip, const_type_name, slice_partition_dedup)]
8
9pub mod automod;
10mod character_creator;
11pub mod chat;
12pub mod chunk_generator;
13mod chunk_serialize;
14pub mod client;
15pub mod cmd;
16pub mod connection_handler;
17mod data_dir;
18pub mod error;
19pub mod events;
20pub mod input;
21pub mod location;
22pub mod lod;
23pub mod login_provider;
24pub mod metrics;
25pub mod persistence;
26mod pet;
27pub mod presence;
28pub mod rtsim;
29pub mod settings;
30pub mod state_ext;
31pub mod sys;
32#[cfg(feature = "persistent_world")]
33pub mod terrain_persistence;
34#[cfg(not(feature = "worldgen"))] mod test_world;
35
36#[cfg(feature = "worldgen")] mod weather;
37
38pub mod wiring;
39
40pub use crate::{
42 data_dir::DEFAULT_DATA_DIR_NAME,
43 error::Error,
44 events::Event,
45 input::Input,
46 settings::{CalendarMode, EditableSettings, Settings},
47};
48
49#[cfg(feature = "persistent_world")]
50use crate::terrain_persistence::TerrainPersistence;
51use crate::{
52 automod::AutoMod,
53 chunk_generator::ChunkGenerator,
54 client::Client,
55 cmd::ChatCommandExt,
56 connection_handler::ConnectionHandler,
57 data_dir::DataDir,
58 location::Locations,
59 login_provider::LoginProvider,
60 persistence::PersistedComponents,
61 presence::{RegionSubscription, RepositionOnChunkLoad},
62 state_ext::StateExt,
63 sys::sentinel::DeletedEntities,
64};
65use authc::Uuid;
66use censor::Censor;
67#[cfg(not(feature = "worldgen"))]
68use common::grid::Grid;
69#[cfg(feature = "worldgen")]
70use common::terrain::CoordinateConversions;
71#[cfg(feature = "worldgen")]
72use common::terrain::TerrainChunkSize;
73use common::{
74 assets::AssetExt,
75 calendar::Calendar,
76 character::{CharacterId, CharacterItem},
77 cmd::ServerChatCommand,
78 comp::{self, ChatType, Content},
79 event::{
80 ClientDisconnectEvent, ClientDisconnectWithoutPersistenceEvent, EventBus, ExitIngameEvent,
81 UpdateCharacterDataEvent,
82 },
83 link::Is,
84 mounting::{Volume, VolumeRider},
85 region::RegionMap,
86 resources::{BattleMode, GameMode, Time, TimeOfDay},
87 rtsim::RtSimEntity,
88 shared_server_config::ServerConstants,
89 slowjob::SlowJobPool,
90 terrain::TerrainChunk,
91 uid::Uid,
92 util::GIT_DATE_TIMESTAMP,
93 vol::RectRasterableVol,
94};
95use common_base::prof_span;
96use common_ecs::run_now;
97use common_net::{
98 msg::{ClientType, DisconnectReason, PlayerListUpdate, ServerGeneral, ServerInfo, ServerMsg},
99 sync::WorldSyncExt,
100};
101use common_state::{AreasContainer, BlockDiff, BuildArea, State};
102use common_systems::add_local_systems;
103use metrics::{EcsSystemMetrics, PhysicsMetrics, TickMetrics};
104use network::{ListenAddr, Network, Pid};
105use persistence::{
106 character_loader::{CharacterLoader, CharacterUpdaterMessage},
107 character_updater::CharacterUpdater,
108};
109use prometheus::Registry;
110use rustls::pki_types::{CertificateDer, PrivateKeyDer};
111use settings::banlist::NormalizedIpAddr;
112use specs::{
113 Builder, Entity as EcsEntity, Entity, Join, LendJoin, WorldExt, shred::SendDispatcher,
114};
115use std::{
116 ops::{Deref, DerefMut},
117 sync::{Arc, Mutex},
118 time::{Duration, Instant},
119};
120#[cfg(not(feature = "worldgen"))]
121use test_world::{IndexOwned, World};
122use tokio::runtime::Runtime;
123use tracing::{debug, error, info, trace, warn};
124use vek::*;
125use veloren_query_server::server::QueryServer;
126pub use world::{WorldGenerateStage, civ::WorldCivStage, sim::WorldSimStage};
127
128use crate::{
129 persistence::{DatabaseSettings, SqlLogMode},
130 sys::terrain,
131};
132use hashbrown::HashMap;
133use std::sync::RwLock;
134
135use crate::settings::Protocol;
136
137#[cfg(feature = "plugins")]
138use {
139 common::uid::IdMaps,
140 common_state::plugin::{PluginMgr, memory_manager::EcsWorld},
141};
142
143use crate::{chat::ChatCache, persistence::character_loader::CharacterScreenResponseKind};
144use common::comp::Anchor;
145#[cfg(feature = "worldgen")]
146pub use world::{
147 IndexOwned, World,
148 sim::{DEFAULT_WORLD_MAP, DEFAULT_WORLD_SEED, FileOpts, GenOpts, WorldOpts},
149};
150
151const BATTLE_MODE_COOLDOWN: f64 = 60.0 * 5.0;
156
157#[derive(Copy, Clone)]
161pub struct SpawnPoint(pub Vec3<f32>);
162
163impl Default for SpawnPoint {
164 fn default() -> Self { Self(Vec3::new(0.0, 0.0, 256.0)) }
165}
166
167pub const MIN_VD: u32 = 6;
172
173#[derive(Copy, Clone, Default)]
176pub struct Tick(u64);
177
178#[derive(Clone)]
179pub struct HwStats {
180 hardware_threads: u32,
181 rayon_threads: u32,
182}
183
184#[derive(Clone, Copy, PartialEq)]
185enum DisconnectType {
186 WithPersistence,
187 WithoutPersistence,
188}
189
190#[derive(Copy, Clone)]
192pub struct TickStart(Instant);
193
194#[derive(Clone, Default, Debug)]
196pub struct BattleModeBuffer {
197 map: HashMap<CharacterId, (BattleMode, Time)>,
198}
199
200impl BattleModeBuffer {
201 pub fn push(&mut self, char_id: CharacterId, save: (BattleMode, Time)) {
202 self.map.insert(char_id, save);
203 }
204
205 pub fn get(&self, char_id: &CharacterId) -> Option<&(BattleMode, Time)> {
206 self.map.get(char_id)
207 }
208
209 pub fn pop(&mut self, char_id: &CharacterId) -> Option<(BattleMode, Time)> {
210 self.map.remove(char_id)
211 }
212}
213
214pub struct RecentClientIPs {
217 pub last_addrs: schnellru::LruMap<Uuid, NormalizedIpAddr>,
218}
219
220impl Default for RecentClientIPs {
221 fn default() -> Self {
222 Self {
223 last_addrs: schnellru::LruMap::new(schnellru::ByLength::new(1000)),
224 }
225 }
226}
227
228pub struct ChunkRequest {
229 entity: EcsEntity,
230 key: Vec2<i32>,
231}
232
233#[derive(Debug)]
234pub enum ServerInitStage {
235 DbMigrations,
236 DbVacuum,
237 WorldGen(WorldGenerateStage),
238 StartingSystems,
239}
240
241pub struct Server {
242 state: State,
243 world: Arc<World>,
244 index: IndexOwned,
245
246 connection_handler: ConnectionHandler,
247
248 runtime: Arc<Runtime>,
249
250 metrics_registry: Arc<Registry>,
251 chat_cache: ChatCache,
252 database_settings: Arc<RwLock<DatabaseSettings>>,
253 disconnect_all_clients_requested: bool,
254
255 event_dispatcher: SendDispatcher<'static>,
256}
257
258impl Server {
259 pub fn new(
261 settings: Settings,
262 editable_settings: EditableSettings,
263 database_settings: DatabaseSettings,
264 data_dir: &std::path::Path,
265 report_stage: &(dyn Fn(ServerInitStage) + Send + Sync),
266 runtime: Arc<Runtime>,
267 ) -> Result<Self, Error> {
268 prof_span!("Server::new");
269 info!("Server data dir is: {}", data_dir.display());
270 if settings.auth_server_address.is_none() {
271 info!("Authentication is disabled");
272 }
273
274 report_stage(ServerInitStage::DbMigrations);
275 debug!("Running DB migrations...");
277 persistence::run_migrations(&database_settings);
278
279 report_stage(ServerInitStage::DbVacuum);
280 debug!("Vacuuming database...");
282 persistence::vacuum_database(&database_settings);
283
284 let database_settings = Arc::new(RwLock::new(database_settings));
285
286 let registry = Arc::new(Registry::new());
287 let chunk_gen_metrics = metrics::ChunkGenMetrics::new(®istry).unwrap();
288 let job_metrics = metrics::JobMetrics::new(®istry).unwrap();
289 let network_request_metrics = metrics::NetworkRequestMetrics::new(®istry).unwrap();
290 let player_metrics = metrics::PlayerMetrics::new(®istry).unwrap();
291 let ecs_system_metrics = EcsSystemMetrics::new(®istry).unwrap();
292 let tick_metrics = TickMetrics::new(®istry).unwrap();
293 let physics_metrics = PhysicsMetrics::new(®istry).unwrap();
294 let server_event_metrics = metrics::ServerEventMetrics::new(®istry).unwrap();
295 let query_server_metrics = metrics::QueryServerMetrics::new(®istry).unwrap();
296
297 let battlemode_buffer = BattleModeBuffer::default();
298
299 let pools = State::pools(GameMode::Server);
300
301 #[cfg(feature = "plugins")]
303 let plugin_mgr = PluginMgr::from_asset_or_default();
304
305 debug!("Generating world, seed: {}", settings.world_seed);
306 #[cfg(feature = "worldgen")]
307 let (world, index) = World::generate(
308 settings.world_seed,
309 WorldOpts {
310 seed_elements: true,
311 world_file: if let Some(ref opts) = settings.map_file {
312 opts.clone()
313 } else {
314 FileOpts::LoadAsset(DEFAULT_WORLD_MAP.into())
316 },
317 calendar: Some(settings.calendar_mode.calendar_now()),
318 },
319 &pools,
320 &|stage| {
321 report_stage(ServerInitStage::WorldGen(stage));
322 },
323 );
324 #[cfg(not(feature = "worldgen"))]
325 let (world, index) = World::generate(settings.world_seed);
326
327 #[cfg(feature = "worldgen")]
328 let map = world.get_map_data(index.as_index_ref(), &pools);
329 #[cfg(not(feature = "worldgen"))]
330 let map = common_net::msg::WorldMapMsg {
331 dimensions_lg: Vec2::zero(),
332 max_height: 1.0,
333 rgba: Grid::new(Vec2::new(1, 1), 1),
334 horizons: [(vec![0], vec![0]), (vec![0], vec![0])],
335 alt: Grid::new(Vec2::new(1, 1), 1),
336 sites: Vec::new(),
337 possible_starting_sites: Vec::new(),
338 pois: Vec::new(),
339 default_chunk: Arc::new(world.generate_oob_chunk()),
340 };
341
342 #[cfg(feature = "worldgen")]
343 let map_size_lg = world.sim().map_size_lg();
344 #[cfg(not(feature = "worldgen"))]
345 let map_size_lg = world.map_size_lg();
346
347 let lod = lod::Lod::from_world(&world, index.as_index_ref(), &pools);
348
349 report_stage(ServerInitStage::StartingSystems);
350
351 let mut state = State::server(
352 Arc::clone(&pools),
353 map_size_lg,
354 Arc::clone(&map.default_chunk),
355 |dispatcher_builder| {
356 add_local_systems(dispatcher_builder);
357 sys::msg::add_server_systems(dispatcher_builder);
358 sys::add_server_systems(dispatcher_builder);
359 #[cfg(feature = "worldgen")]
360 {
361 rtsim::add_server_systems(dispatcher_builder);
362 weather::add_server_systems(dispatcher_builder);
363 }
364 },
365 #[cfg(feature = "plugins")]
366 plugin_mgr,
367 );
368 events::register_event_busses(state.ecs_mut());
369 state.ecs_mut().insert(battlemode_buffer);
370 state.ecs_mut().insert(RecentClientIPs::default());
371 state.ecs_mut().insert(settings.clone());
372 state.ecs_mut().insert(editable_settings);
373 state.ecs_mut().insert(DataDir {
374 path: data_dir.to_owned(),
375 });
376
377 state.ecs_mut().insert(Vec::<ChunkRequest>::new());
378 state
379 .ecs_mut()
380 .insert(EventBus::<chunk_serialize::ChunkSendEntry>::default());
381 state.ecs_mut().insert(Locations::default());
382 state.ecs_mut().insert(LoginProvider::new(
383 settings.auth_server_address.clone(),
384 Arc::clone(&runtime),
385 ));
386 state.ecs_mut().insert(HwStats {
387 hardware_threads: num_cpus::get() as u32,
388 rayon_threads: num_cpus::get() as u32,
389 });
390 state.ecs_mut().insert(ServerConstants {
391 day_cycle_coefficient: settings.day_cycle_coefficient(),
392 });
393 state.ecs_mut().insert(Tick(0));
394 state.ecs_mut().insert(TickStart(Instant::now()));
395 state.ecs_mut().insert(job_metrics);
396 state.ecs_mut().insert(network_request_metrics);
397 state.ecs_mut().insert(player_metrics);
398 state.ecs_mut().insert(ecs_system_metrics);
399 state.ecs_mut().insert(tick_metrics);
400 state.ecs_mut().insert(physics_metrics);
401 state.ecs_mut().insert(server_event_metrics);
402 state.ecs_mut().insert(query_server_metrics);
403 if settings.experimental_terrain_persistence {
404 #[cfg(feature = "persistent_world")]
405 {
406 warn!(
407 "Experimental terrain persistence support is enabled. This feature may break, \
408 be disabled, or otherwise change under your feet at *any time*. \
409 Additionally, it is expected to be replaced in the future *without* \
410 migration or warning. You have been warned."
411 );
412 state
413 .ecs_mut()
414 .insert(TerrainPersistence::new(data_dir.to_owned()));
415 }
416 #[cfg(not(feature = "persistent_world"))]
417 error!(
418 "Experimental terrain persistence support was requested, but the server was not \
419 compiled with the feature. Terrain modifications will *not* be persisted."
420 );
421 }
422 {
423 let pool = state.ecs_mut().write_resource::<SlowJobPool>();
424 pool.configure("CHUNK_DROP", |_n| 1);
425 pool.configure("CHUNK_GENERATOR", |n| n / 2 + n / 4);
426 pool.configure("CHUNK_SERIALIZER", |n| n / 2);
427 pool.configure("RTSIM_SAVE", |_| 1);
428 pool.configure("WEATHER", |_| 1);
429 }
430 state
431 .ecs_mut()
432 .insert(ChunkGenerator::new(chunk_gen_metrics));
433 {
434 let (sender, receiver) =
435 crossbeam_channel::bounded::<chunk_serialize::SerializedChunk>(10_000);
436 state.ecs_mut().insert(sender);
437 state.ecs_mut().insert(receiver);
438 }
439
440 state.ecs_mut().insert(CharacterUpdater::new(
441 Arc::<RwLock<DatabaseSettings>>::clone(&database_settings),
442 )?);
443
444 let ability_map = comp::item::tool::AbilityMap::<comp::AbilityItem>::load_expect_cloned(
445 "common.abilities.ability_set_manifest",
446 );
447 state.ecs_mut().insert(ability_map);
448
449 let msm = comp::inventory::item::MaterialStatManifest::load().cloned();
450 state.ecs_mut().insert(msm);
451
452 let rbm = common::recipe::RecipeBookManifest::load().cloned();
453 state.ecs_mut().insert(rbm);
454
455 state.ecs_mut().insert(CharacterLoader::new(
456 Arc::<RwLock<DatabaseSettings>>::clone(&database_settings),
457 )?);
458
459 state
461 .ecs_mut()
462 .insert(sys::PersistenceScheduler::every(Duration::from_secs(10)));
463
464 state.ecs_mut().insert(RegionMap::new());
466
467 state.ecs_mut().register::<RegionSubscription>();
469 state.ecs_mut().register::<Client>();
470 state.ecs_mut().register::<comp::Presence>();
471 state.ecs_mut().register::<wiring::WiringElement>();
472 state.ecs_mut().register::<wiring::Circuit>();
473 state.ecs_mut().register::<Anchor>();
474 state.ecs_mut().register::<comp::Pet>();
475 state.ecs_mut().register::<login_provider::PendingLogin>();
476 state.ecs_mut().register::<RepositionOnChunkLoad>();
477 state.ecs_mut().register::<RtSimEntity>();
478
479 let banned_words = settings.moderation.load_banned_words(data_dir);
481 let censor = Arc::new(Censor::Custom(banned_words.into_iter().collect()));
482 state.ecs_mut().insert(Arc::clone(&censor));
483
484 state
486 .ecs_mut()
487 .insert(AutoMod::new(&settings.moderation, censor));
488
489 state.ecs_mut().insert(map);
490
491 #[cfg(feature = "worldgen")]
492 let spawn_point = SpawnPoint({
493 let index = index.as_index_ref();
494 let center_chunk = world.sim().map_size_lg().chunks().map(i32::from) / 2;
501 let spawn_chunk = world
502 .civs()
503 .sites()
504 .filter(|site| site.is_settlement())
505 .map(|site| site.center)
506 .min_by_key(|site_pos| site_pos.distance_squared(center_chunk))
507 .unwrap_or(center_chunk);
508
509 world.find_accessible_pos(index, TerrainChunkSize::center_wpos(spawn_chunk), false)
510 });
511 #[cfg(not(feature = "worldgen"))]
512 let spawn_point = SpawnPoint::default();
513
514 state.ecs_mut().insert(spawn_point);
516
517 {
520 #[cfg(feature = "worldgen")]
521 let size = world.sim().get_size();
522 #[cfg(not(feature = "worldgen"))]
523 let size = world.map_size_lg().chunks().map(u32::from);
524
525 let world_size = size.map(|e| e as i32) * TerrainChunk::RECT_SIZE.map(|e| e as i32);
526 let world_aabb = Aabb {
527 min: Vec3::new(0, 0, -32768),
528 max: Vec3::new(world_size.x, world_size.y, 32767),
529 }
530 .made_valid();
531
532 state
533 .ecs()
534 .write_resource::<AreasContainer<BuildArea>>()
535 .insert("world".to_string(), world_aabb)
536 .expect("The initial insert should always work.");
537 }
538
539 let world = Arc::new(world);
541 state.ecs_mut().insert(Arc::clone(&world));
542 state.ecs_mut().insert(lod);
543 state.ecs_mut().insert(index.clone());
544
545 state.ecs_mut().write_resource::<TimeOfDay>().0 = settings.world.start_time;
547
548 sys::sentinel::UpdateTrackers::register(state.ecs_mut());
550
551 state.ecs_mut().insert(DeletedEntities::default());
552
553 let network = Network::new_with_registry(Pid::new(), &runtime, ®istry);
554 let (chat_cache, chat_tracker) = ChatCache::new(Duration::from_secs(60), &runtime);
555 state.ecs_mut().insert(chat_tracker);
556
557 let mut printed_quic_warning = false;
558 for protocol in &settings.gameserver_protocols {
559 match protocol {
560 Protocol::Tcp { address } => {
561 runtime.block_on(network.listen(ListenAddr::Tcp(*address)))?;
562 },
563 Protocol::Quic {
564 address,
565 cert_file_path,
566 key_file_path,
567 } => {
568 use rustls_pemfile::Item;
569 use std::fs;
570
571 match || -> Result<_, Box<dyn std::error::Error>> {
572 let key = fs::read(key_file_path)?;
573 let key = if key_file_path.extension().is_some_and(|x| x == "der") {
574 PrivateKeyDer::try_from(key).map_err(|_| "No valid pem key in file")?
575 } else {
576 debug!("convert pem key to der");
577 rustls_pemfile::read_all(&mut key.as_slice())
578 .find_map(|item| match item {
579 Ok(Item::Pkcs1Key(v)) => Some(PrivateKeyDer::Pkcs1(v)),
580 Ok(Item::Pkcs8Key(v)) => Some(PrivateKeyDer::Pkcs8(v)),
581 Ok(Item::Sec1Key(v)) => Some(PrivateKeyDer::Sec1(v)),
582 Ok(Item::Crl(_)) => None,
583 Ok(Item::Csr(_)) => None,
584 Ok(Item::X509Certificate(_)) => None,
585 Ok(_) => None,
586 Err(e) => {
587 tracing::warn!(?e, "error while reading key_file");
588 None
589 },
590 })
591 .ok_or("No valid pem key in file")?
592 };
593 let cert_chain = fs::read(cert_file_path)?;
594 let cert_chain = if cert_file_path.extension().is_some_and(|x| x == "der") {
595 vec![CertificateDer::from(cert_chain)]
596 } else {
597 debug!("convert pem cert to der");
598 rustls_pemfile::certs(&mut cert_chain.as_slice())
599 .filter_map(|item| match item {
600 Ok(cert) => Some(cert),
601 Err(e) => {
602 tracing::warn!(?e, "error while reading cert_file");
603 None
604 },
605 })
606 .collect()
607 };
608 let server_config = quinn::ServerConfig::with_single_cert(cert_chain, key)?;
609 Ok(server_config)
610 }() {
611 Ok(server_config) => {
612 runtime.block_on(
613 network.listen(ListenAddr::Quic(*address, server_config.clone())),
614 )?;
615
616 if !printed_quic_warning {
617 warn!(
618 "QUIC is enabled. This is experimental and not recommended in \
619 production"
620 );
621 printed_quic_warning = true;
622 }
623 },
624 Err(e) => {
625 error!(
626 ?e,
627 "Failed to load the TLS certificate, running without QUIC {}",
628 *address
629 );
630 },
631 }
632 },
633 }
634 }
635
636 if let Some(addr) = settings.query_address {
637 use veloren_query_server::proto::ServerInfo;
638
639 const QUERY_SERVER_RATELIMIT: u16 = 120;
640
641 let (query_server_info_tx, query_server_info_rx) =
642 tokio::sync::watch::channel(ServerInfo {
643 git_hash: *sys::server_info::GIT_HASH,
644 git_timestamp: *GIT_DATE_TIMESTAMP,
645 players_count: 0,
646 player_cap: settings.max_players,
647 battlemode: settings.gameplay.battle_mode.into(),
648 });
649 let mut query_server =
650 QueryServer::new(addr, query_server_info_rx, QUERY_SERVER_RATELIMIT);
651 let query_server_metrics =
652 Arc::new(Mutex::new(veloren_query_server::server::Metrics::default()));
653 let query_server_metrics2 = Arc::clone(&query_server_metrics);
654 runtime.spawn(async move {
655 let err = query_server.run(query_server_metrics2).await.err();
656 error!(?err, "Query server stopped unexpectedly");
657 });
658 state.ecs_mut().insert(query_server_info_tx);
659 state.ecs_mut().insert(query_server_metrics);
660 }
661
662 runtime.block_on(network.listen(ListenAddr::Mpsc(14004)))?;
663
664 let connection_handler = ConnectionHandler::new(network, &runtime);
665
666 #[cfg(feature = "worldgen")]
668 {
669 match rtsim::RtSim::new(
670 &settings.world,
671 index.as_index_ref(),
672 &world,
673 data_dir.to_owned(),
674 ) {
675 Ok(rtsim) => {
676 state.ecs_mut().insert(rtsim.state().data().time_of_day);
677 state.ecs_mut().insert(rtsim);
678 },
679 Err(err) => {
680 error!("Failed to load rtsim: {}", err);
681 return Err(Error::RtsimError(err));
682 },
683 }
684 weather::init(&mut state);
685 }
686
687 let this = Self {
688 state,
689 world,
690 index,
691 connection_handler,
692 runtime,
693
694 metrics_registry: registry,
695 chat_cache,
696 database_settings,
697 disconnect_all_clients_requested: false,
698
699 event_dispatcher: Self::create_event_dispatcher(pools),
700 };
701
702 debug!(?settings, "created veloren server with");
703
704 let git_hash = *common::util::GIT_HASH;
705 let git_date = common::util::GIT_DATE.clone();
706 let git_time = *common::util::GIT_TIME;
707 let version = common::util::DISPLAY_VERSION_LONG.clone();
708 info!(?version, "Server version");
709 debug!(?git_hash, ?git_date, ?git_time, "detailed Server version");
710
711 Ok(this)
712 }
713
714 pub fn get_server_info(&self) -> ServerInfo {
715 let settings = self.state.ecs().fetch::<Settings>();
716
717 ServerInfo {
718 name: settings.server_name.clone(),
719 git_hash: common::util::GIT_HASH.to_string(),
720 git_date: common::util::GIT_DATE.to_string(),
721 auth_provider: settings.auth_server_address.clone(),
722 }
723 }
724
725 pub fn settings(&self) -> impl Deref<Target = Settings> + '_ {
727 self.state.ecs().fetch::<Settings>()
728 }
729
730 pub fn settings_mut(&self) -> impl DerefMut<Target = Settings> + '_ {
732 self.state.ecs().fetch_mut::<Settings>()
733 }
734
735 pub fn editable_settings_mut(&self) -> impl DerefMut<Target = EditableSettings> + '_ {
737 self.state.ecs().fetch_mut::<EditableSettings>()
738 }
739
740 pub fn editable_settings(&self) -> impl Deref<Target = EditableSettings> + '_ {
742 self.state.ecs().fetch::<EditableSettings>()
743 }
744
745 pub fn data_dir(&self) -> impl Deref<Target = DataDir> + '_ {
747 self.state.ecs().fetch::<DataDir>()
748 }
749
750 pub fn state(&self) -> &State { &self.state }
752
753 pub fn state_mut(&mut self) -> &mut State { &mut self.state }
755
756 pub fn world(&self) -> &World { &self.world }
758
759 pub fn metrics_registry(&self) -> &Arc<Registry> { &self.metrics_registry }
761
762 pub fn chat_cache(&self) -> &ChatCache { &self.chat_cache }
764
765 fn parse_locations(&self, character_list_data: &mut [CharacterItem]) {
766 character_list_data.iter_mut().for_each(|c| {
767 let name = c
768 .location
769 .as_ref()
770 .and_then(|s| {
771 persistence::parse_waypoint(s)
772 .ok()
773 .and_then(|(waypoint, _)| waypoint.map(|w| w.get_pos()))
774 })
775 .and_then(|wpos| {
776 self.world
777 .get_location_name(self.index.as_index_ref(), wpos.xy().as_::<i32>())
778 });
779 c.location = name;
780 });
781 }
782
783 pub fn tick(&mut self, _input: Input, dt: Duration) -> Result<Vec<Event>, Error> {
786 self.state.ecs().write_resource::<Tick>().0 += 1;
787 self.state.ecs().write_resource::<TickStart>().0 = Instant::now();
788
789 let new_calendar = self
793 .state
794 .ecs()
795 .read_resource::<Settings>()
796 .calendar_mode
797 .calendar_now();
798 *self.state.ecs_mut().write_resource::<Calendar>() = new_calendar;
799
800 let mut frontend_events = Vec::new();
823
824 let before_new_connections = Instant::now();
827
828 self.handle_new_connections(&mut frontend_events);
830
831 let before_state_tick = Instant::now();
832
833 fn on_block_update(ecs: &specs::World, changes: Vec<BlockDiff>) {
834 if changes
836 .iter()
837 .any(|c| c.old.get_rtsim_resource() != c.new.get_rtsim_resource())
838 {
839 ecs.write_resource::<rtsim::RtSim>().hook_block_update(
840 &ecs.read_resource::<Arc<world::World>>(),
841 ecs.read_resource::<world::IndexOwned>().as_index_ref(),
842 changes,
843 );
844 }
845 }
846
847 let mut state_tick_metrics = Default::default();
851 let server_constants = (*self.state.ecs().read_resource::<ServerConstants>()).clone();
852 self.state.tick(
853 dt,
854 false,
855 Some(&mut state_tick_metrics),
856 &server_constants,
857 on_block_update,
858 );
859
860 let before_handle_events = Instant::now();
861
862 let disconnect_type = self.disconnect_all_clients_if_requested();
865
866 self.state.maintain_links();
868
869 frontend_events.append(&mut self.handle_events());
871
872 let before_update_terrain_and_regions = Instant::now();
873
874 self.update_region_map();
879 self.state.apply_terrain_changes(on_block_update);
882
883 let before_sync = Instant::now();
884
885 sys::run_sync_systems(self.state.ecs_mut());
887
888 let before_world_tick = Instant::now();
889
890 self.world.tick(dt);
892
893 let before_entity_cleanup = Instant::now();
894
895 if let Some(DisconnectType::WithoutPersistence) = disconnect_type {
900 run_now::<terrain::Sys>(self.state.ecs_mut());
901 }
902
903 #[cfg(feature = "worldgen")]
905 {
906 let mut rtsim = self.state.ecs().write_resource::<rtsim::RtSim>();
907 let world = self.state.ecs().read_resource::<Arc<World>>();
908 for chunk in &self.state.terrain_changes().removed_chunks {
909 rtsim.hook_unload_chunk(*chunk, &world);
910 }
911 }
912
913 let anchors = self.state.ecs().read_storage::<Anchor>();
924 let anchored_anchor_entities: Vec<Entity> = (
925 &self.state.ecs().entities(),
926 &self.state.ecs().read_storage::<Anchor>(),
927 )
928 .join()
929 .filter_map(|(_, anchor)| match anchor {
930 Anchor::Entity(anchor_entity) => Some(*anchor_entity),
931 _ => None,
932 })
933 .filter(|anchor_entity| match anchors.get(*anchor_entity) {
937 Some(Anchor::Entity(_)) => true,
938 Some(Anchor::Chunk(_)) | None => false
939 })
940 .collect();
941 drop(anchors);
942
943 for entity in anchored_anchor_entities {
944 if cfg!(debug_assertions) {
945 panic!("Entity anchor chain detected");
946 }
947 error!(
948 "Detected an anchor entity that itself has an anchor entity - anchor chains are \
949 not currently supported. The entity's Anchor component has been deleted"
950 );
951 self.state.delete_component::<Anchor>(entity);
952 }
953
954 let to_delete = {
957 let terrain = self.state.terrain();
958 (
959 &self.state.ecs().entities(),
960 &self.state.ecs().read_storage::<comp::Pos>(),
961 !&self.state.ecs().read_storage::<comp::Presence>(),
962 self.state.ecs().read_storage::<Anchor>().maybe(),
963 self.state.ecs().read_storage::<Is<VolumeRider>>().maybe(),
964 )
965 .join()
966 .filter(|(_, pos, _, anchor, is_volume_rider)| {
967 let pos = is_volume_rider
968 .and_then(|is_volume_rider| match is_volume_rider.pos.kind {
969 Volume::Terrain => None,
970 Volume::Entity(e) => {
971 let e = self.state.ecs().entity_from_uid(e)?;
972 let pos = self
973 .state
974 .ecs()
975 .read_storage::<comp::Pos>()
976 .get(e)
977 .copied()?;
978
979 Some(pos.0)
980 },
981 })
982 .unwrap_or(pos.0);
983 let chunk_key = terrain.pos_key(pos.map(|e| e.floor() as i32));
984 match anchor {
985 Some(Anchor::Chunk(hc)) => {
986 terrain.get_key_real(chunk_key).is_none()
991 && terrain.get_key_real(*hc).is_none()
992 },
993 Some(Anchor::Entity(entity)) => !self.state.ecs().is_alive(*entity),
994 None => terrain.get_key_real(chunk_key).is_none(),
995 }
996 })
997 .map(|(entity, _, _, _, _)| entity)
998 .collect::<Vec<_>>()
999 };
1000
1001 #[cfg(feature = "worldgen")]
1002 {
1003 let mut rtsim = self.state.ecs().write_resource::<rtsim::RtSim>();
1004 let rtsim_entities = self.state.ecs().read_storage();
1005 for entity in &to_delete {
1006 if let Some(rtsim_entity) = rtsim_entities.get(*entity) {
1007 rtsim.hook_rtsim_entity_unload(*rtsim_entity);
1008 }
1009 }
1010 }
1011
1012 for entity in to_delete {
1014 if let Err(e) = self.state.delete_entity_recorded(entity) {
1015 error!(?e, "Failed to delete agent outside the terrain");
1016 }
1017 }
1018
1019 if let Some(DisconnectType::WithoutPersistence) = disconnect_type {
1020 info!(
1021 "Disconnection of all players without persistence complete, signalling to \
1022 persistence thread that character updates may continue to be processed"
1023 );
1024 self.state
1025 .ecs()
1026 .fetch_mut::<CharacterUpdater>()
1027 .disconnected_success();
1028 }
1029
1030 let before_persistence_updates = Instant::now();
1032
1033 let character_loader = self.state.ecs().read_resource::<CharacterLoader>();
1034
1035 let mut character_updater = self.state.ecs().write_resource::<CharacterUpdater>();
1036 let updater_messages: Vec<CharacterUpdaterMessage> = character_updater.messages().collect();
1037
1038 character_loader
1040 .messages()
1041 .chain(updater_messages)
1042 .for_each(|message| match message {
1043 CharacterUpdaterMessage::DatabaseBatchCompletion(batch_id) => {
1044 character_updater.process_batch_completion(batch_id);
1045 },
1046 CharacterUpdaterMessage::CharacterScreenResponse(response) => {
1047 match response.response_kind {
1048 CharacterScreenResponseKind::CharacterList(result) => match result {
1049 Ok(mut character_list_data) => {
1050 self.parse_locations(&mut character_list_data);
1051 self.notify_client(
1052 response.target_entity,
1053 ServerGeneral::CharacterListUpdate(character_list_data),
1054 )
1055 },
1056 Err(error) => self.notify_client(
1057 response.target_entity,
1058 ServerGeneral::CharacterActionError(error.to_string()),
1059 ),
1060 },
1061 CharacterScreenResponseKind::CharacterCreation(result) => match result {
1062 Ok((character_id, mut list)) => {
1063 self.parse_locations(&mut list);
1064 self.notify_client(
1065 response.target_entity,
1066 ServerGeneral::CharacterListUpdate(list),
1067 );
1068 self.notify_client(
1069 response.target_entity,
1070 ServerGeneral::CharacterCreated(character_id),
1071 );
1072 },
1073 Err(error) => self.notify_client(
1074 response.target_entity,
1075 ServerGeneral::CharacterActionError(error.to_string()),
1076 ),
1077 },
1078 CharacterScreenResponseKind::CharacterEdit(result) => match result {
1079 Ok((character_id, mut list)) => {
1080 self.parse_locations(&mut list);
1081 self.notify_client(
1082 response.target_entity,
1083 ServerGeneral::CharacterListUpdate(list),
1084 );
1085 self.notify_client(
1086 response.target_entity,
1087 ServerGeneral::CharacterEdited(character_id),
1088 );
1089 },
1090 Err(error) => self.notify_client(
1091 response.target_entity,
1092 ServerGeneral::CharacterActionError(error.to_string()),
1093 ),
1094 },
1095 CharacterScreenResponseKind::CharacterData(result) => {
1096 match *result {
1097 Ok((character_data, skill_set_persistence_load_error)) => {
1098 let PersistedComponents {
1099 body,
1100 hardcore,
1101 stats,
1102 skill_set,
1103 inventory,
1104 waypoint,
1105 pets,
1106 active_abilities,
1107 map_marker,
1108 } = character_data;
1109 let character_data = (
1110 body,
1111 hardcore,
1112 stats,
1113 skill_set,
1114 inventory,
1115 waypoint,
1116 pets,
1117 active_abilities,
1118 map_marker,
1119 );
1120 self.state.emit_event_now(UpdateCharacterDataEvent {
1123 entity: response.target_entity,
1124 components: character_data,
1125 metadata: skill_set_persistence_load_error,
1126 })
1127 },
1128 Err(error) => {
1129 self.notify_client(
1133 response.target_entity,
1134 ServerGeneral::CharacterDataLoadResult(Err(
1135 error.to_string()
1136 )),
1137 );
1138
1139 self.state.emit_event_now(ExitIngameEvent {
1141 entity: response.target_entity,
1142 })
1143 },
1144 }
1145 },
1146 }
1147 },
1148 });
1149
1150 drop(character_loader);
1151 drop(character_updater);
1152
1153 {
1154 let index = &mut self.index;
1159 let world = &mut self.world;
1160 let ecs = self.state.ecs_mut();
1161 let slow_jobs = ecs.write_resource::<SlowJobPool>();
1162
1163 index.reload_if_changed(|index| {
1164 let mut chunk_generator = ecs.write_resource::<ChunkGenerator>();
1165 let client = ecs.read_storage::<Client>();
1166 let mut terrain = ecs.write_resource::<common::terrain::TerrainGrid>();
1167 #[cfg(feature = "worldgen")]
1168 let rtsim = ecs.read_resource::<rtsim::RtSim>();
1169 #[cfg(not(feature = "worldgen"))]
1170 let rtsim = ();
1171
1172 chunk_generator.cancel_all();
1174
1175 if client.is_empty() {
1176 terrain.clear();
1178 } else {
1179 terrain.iter().for_each(|(pos, _)| {
1181 chunk_generator.generate_chunk(
1182 None,
1183 pos,
1184 &slow_jobs,
1185 Arc::clone(world),
1186 &rtsim,
1187 index.clone(),
1188 (
1189 *ecs.read_resource::<TimeOfDay>(),
1190 (*ecs.read_resource::<Calendar>()).clone(),
1191 ),
1192 );
1193 });
1194 }
1195 });
1196 }
1197
1198 let end_of_server_tick = Instant::now();
1199
1200 run_now::<sys::metrics::Sys>(self.state.ecs());
1202
1203 {
1204 let tick_metrics = self.state.ecs().read_resource::<TickMetrics>();
1206
1207 let tt = &tick_metrics.tick_time;
1208 tt.with_label_values(&["new connections"])
1209 .set((before_state_tick - before_new_connections).as_nanos() as i64);
1210 tt.with_label_values(&["handle server events"])
1211 .set((before_update_terrain_and_regions - before_handle_events).as_nanos() as i64);
1212 tt.with_label_values(&["update terrain and region map"])
1213 .set((before_sync - before_update_terrain_and_regions).as_nanos() as i64);
1214 tt.with_label_values(&["state"])
1215 .set((before_handle_events - before_state_tick).as_nanos() as i64);
1216 tt.with_label_values(&["world tick"])
1217 .set((before_entity_cleanup - before_world_tick).as_nanos() as i64);
1218 tt.with_label_values(&["entity cleanup"])
1219 .set((before_persistence_updates - before_entity_cleanup).as_nanos() as i64);
1220 tt.with_label_values(&["persistence_updates"])
1221 .set((end_of_server_tick - before_persistence_updates).as_nanos() as i64);
1222 for (label, duration) in state_tick_metrics.timings {
1223 tick_metrics
1224 .state_tick_time
1225 .with_label_values(&[label])
1226 .set(duration.as_nanos() as i64);
1227 }
1228 tick_metrics.tick_time_hist.observe(
1229 end_of_server_tick
1230 .duration_since(before_state_tick)
1231 .as_secs_f64(),
1232 );
1233 }
1234
1235 Ok(frontend_events)
1238 }
1239
1240 pub fn cleanup(&mut self) {
1242 self.state.cleanup();
1244
1245 #[cfg(feature = "persistent_world")]
1247 self.state
1248 .ecs()
1249 .try_fetch_mut::<TerrainPersistence>()
1250 .map(|mut t| t.maintain());
1251 }
1252
1253 fn update_region_map(&mut self) {
1255 prof_span!("Server::update_region_map");
1256 let ecs = self.state().ecs();
1257 ecs.write_resource::<RegionMap>().tick(
1258 ecs.read_storage::<comp::Pos>(),
1259 ecs.read_storage::<comp::Vel>(),
1260 ecs.read_storage::<comp::Presence>(),
1261 ecs.entities(),
1262 );
1263 }
1264
1265 fn initialize_client(&mut self, client: connection_handler::IncomingClient) -> Entity {
1266 let entity = self
1267 .state
1268 .ecs_mut()
1269 .create_entity_synced()
1270 .with(client)
1271 .build();
1272 self.state
1273 .ecs()
1274 .read_resource::<metrics::PlayerMetrics>()
1275 .clients_connected
1276 .inc();
1277 entity
1278 }
1279
1280 fn disconnect_all_clients_if_requested(&mut self) -> Option<DisconnectType> {
1284 let mut character_updater = self.state.ecs().fetch_mut::<CharacterUpdater>();
1285
1286 let disconnect_type = self.get_disconnect_all_clients_requested(&mut character_updater);
1287 if let Some(disconnect_type) = disconnect_type {
1288 let with_persistence = disconnect_type == DisconnectType::WithPersistence;
1289 let clients = self.state.ecs().read_storage::<Client>();
1290 let entities = self.state.ecs().entities();
1291
1292 info!(
1293 "Disconnecting all clients ({} persistence) as requested",
1294 if with_persistence { "with" } else { "without" }
1295 );
1296 for (_, entity) in (&clients, &entities).join() {
1297 info!("Emitting client disconnect event for entity: {:?}", entity);
1298 if with_persistence {
1299 self.state.emit_event_now(ClientDisconnectEvent(
1300 entity,
1301 comp::DisconnectReason::Kicked,
1302 ))
1303 } else {
1304 self.state
1305 .emit_event_now(ClientDisconnectWithoutPersistenceEvent(entity))
1306 };
1307 }
1308
1309 self.disconnect_all_clients_requested = false;
1310 }
1311
1312 disconnect_type
1313 }
1314
1315 fn get_disconnect_all_clients_requested(
1316 &self,
1317 character_updater: &mut CharacterUpdater,
1318 ) -> Option<DisconnectType> {
1319 let without_persistence_requested = character_updater.disconnect_all_clients_requested();
1320 let with_persistence_requested = self.disconnect_all_clients_requested;
1321
1322 if without_persistence_requested {
1323 return Some(DisconnectType::WithoutPersistence);
1324 };
1325 if with_persistence_requested {
1326 return Some(DisconnectType::WithPersistence);
1327 };
1328 None
1329 }
1330
1331 fn handle_new_connections(&mut self, frontend_events: &mut Vec<Event>) {
1333 while let Ok(sender) = self.connection_handler.info_requester_receiver.try_recv() {
1334 trace!("sending info to connection_handler");
1336 let _ = sender.send(connection_handler::ServerInfoPacket {
1337 info: self.get_server_info(),
1338 time: self.state.get_time(),
1339 });
1340 }
1341
1342 while let Ok(incoming) = self.connection_handler.client_receiver.try_recv() {
1343 let entity = self.initialize_client(incoming);
1344 frontend_events.push(Event::ClientConnected { entity });
1345 }
1346 }
1347
1348 pub fn notify_client<S>(&self, entity: EcsEntity, msg: S)
1349 where
1350 S: Into<ServerMsg>,
1351 {
1352 if let Some(client) = self.state.ecs().read_storage::<Client>().get(entity) {
1353 client.send_fallible(msg);
1354 }
1355 }
1356
1357 pub fn notify_players(&mut self, msg: ServerGeneral) { self.state.notify_players(msg); }
1358
1359 pub fn generate_chunk(&mut self, entity: EcsEntity, key: Vec2<i32>) {
1360 let ecs = self.state.ecs();
1361 let slow_jobs = ecs.read_resource::<SlowJobPool>();
1362 #[cfg(feature = "worldgen")]
1363 let rtsim = ecs.read_resource::<rtsim::RtSim>();
1364 #[cfg(not(feature = "worldgen"))]
1365 let rtsim = ();
1366 ecs.write_resource::<ChunkGenerator>().generate_chunk(
1367 Some(entity),
1368 key,
1369 &slow_jobs,
1370 Arc::clone(&self.world),
1371 &rtsim,
1372 self.index.clone(),
1373 (
1374 *ecs.read_resource::<TimeOfDay>(),
1375 (*ecs.read_resource::<Calendar>()).clone(),
1376 ),
1377 );
1378 }
1379
1380 fn process_command(&mut self, entity: EcsEntity, name: String, args: Vec<String>) {
1381 if let Ok(command) = name.parse::<ServerChatCommand>() {
1383 command.execute(self, entity, args);
1384 } else {
1385 #[cfg(feature = "plugins")]
1386 {
1387 let mut plugin_manager = self.state.ecs().write_resource::<PluginMgr>();
1388 let ecs_world = EcsWorld {
1389 entities: &self.state.ecs().entities(),
1390 health: self.state.ecs().read_component().into(),
1391 uid: self.state.ecs().read_component().into(),
1392 id_maps: &self.state.ecs().read_resource::<IdMaps>().into(),
1393 player: self.state.ecs().read_component().into(),
1394 };
1395 let uid = if let Some(uid) = ecs_world.uid.get(entity).copied() {
1396 uid
1397 } else {
1398 self.notify_client(
1399 entity,
1400 ServerGeneral::server_msg(
1401 comp::ChatType::CommandError,
1402 common::comp::Content::Plain(
1403 "Can't get player UUID (player may be disconnected?)".to_string(),
1404 ),
1405 ),
1406 );
1407 return;
1408 };
1409 match plugin_manager.command_event(&ecs_world, &name, args.as_slice(), uid) {
1410 Err(common_state::plugin::CommandResults::UnknownCommand) => self
1411 .notify_client(
1412 entity,
1413 ServerGeneral::server_msg(
1414 comp::ChatType::CommandError,
1415 common::comp::Content::Plain(format!(
1416 "Unknown command '/{name}'.\nType '/help' for available \
1417 commands",
1418 )),
1419 ),
1420 ),
1421 Ok(value) => {
1422 self.notify_client(
1423 entity,
1424 ServerGeneral::server_msg(
1425 comp::ChatType::CommandInfo,
1426 common::comp::Content::Plain(value.join("\n")),
1427 ),
1428 );
1429 },
1430 Err(common_state::plugin::CommandResults::PluginError(err)) => {
1431 self.notify_client(
1432 entity,
1433 ServerGeneral::server_msg(
1434 comp::ChatType::CommandError,
1435 common::comp::Content::Plain(format!(
1436 "Error occurred while executing command '/{name}'.\n{err}"
1437 )),
1438 ),
1439 );
1440 },
1441 Err(common_state::plugin::CommandResults::HostError(err)) => {
1442 error!(?err, ?name, ?args, "Can't execute command");
1443 self.notify_client(
1444 entity,
1445 ServerGeneral::server_msg(
1446 comp::ChatType::CommandError,
1447 common::comp::Content::Plain(format!(
1448 "Internal error {err:?} while executing '/{name}'.\nContact \
1449 the server administrator",
1450 )),
1451 ),
1452 );
1453 },
1454 }
1455 }
1456 }
1457 }
1458
1459 fn entity_admin_role(&self, entity: EcsEntity) -> Option<comp::AdminRole> {
1460 self.state
1461 .read_component_copied::<comp::Admin>(entity)
1462 .map(|admin| admin.0)
1463 }
1464
1465 pub fn number_of_players(&self) -> i64 {
1466 self.state.ecs().read_storage::<Client>().join().count() as i64
1467 }
1468
1469 pub fn add_admin(&mut self, username: &str, role: comp::AdminRole) {
1472 let mut editable_settings = self.editable_settings_mut();
1473 let login_provider = self.state.ecs().fetch::<LoginProvider>();
1474 let data_dir = self.data_dir();
1475 if let Some(entity) = add_admin(
1476 username,
1477 role,
1478 &login_provider,
1479 &mut editable_settings,
1480 &data_dir.path,
1481 )
1482 .and_then(|uuid| {
1483 let state = &self.state;
1484 (
1485 &state.ecs().entities(),
1486 &state.read_storage::<comp::Player>(),
1487 )
1488 .join()
1489 .find(|(_, player)| player.uuid() == uuid)
1490 .map(|(e, _)| e)
1491 }) {
1492 drop((data_dir, login_provider, editable_settings));
1493 self.state
1496 .write_component_ignore_entity_dead(entity, comp::Admin(role));
1497 };
1498 }
1499
1500 pub fn remove_admin(&self, username: &str) {
1503 let mut editable_settings = self.editable_settings_mut();
1504 let login_provider = self.state.ecs().fetch::<LoginProvider>();
1505 let data_dir = self.data_dir();
1506 if let Some(entity) = remove_admin(
1507 username,
1508 &login_provider,
1509 &mut editable_settings,
1510 &data_dir.path,
1511 )
1512 .and_then(|uuid| {
1513 let state = &self.state;
1514 (
1515 &state.ecs().entities(),
1516 &state.read_storage::<comp::Player>(),
1517 )
1518 .join()
1519 .find(|(_, player)| player.uuid() == uuid)
1520 .map(|(e, _)| e)
1521 }) {
1522 self.state
1524 .ecs()
1525 .write_storage::<comp::Admin>()
1526 .remove(entity);
1527 };
1528 }
1529
1530 #[cfg(feature = "worldgen")]
1535 pub fn create_centered_persister(&mut self, view_distance: u32) {
1536 let world_dims_chunks = self.world.sim().get_size();
1537 let world_dims_blocks = TerrainChunkSize::blocks(world_dims_chunks);
1538 let pos = comp::Pos(Vec3::from(world_dims_blocks.map(|e| e as f32 / 2.0)));
1546 self.state
1547 .create_persister(pos, view_distance, &self.world, &self.index)
1548 .build();
1549 }
1550
1551 pub fn chunks_pending(&mut self) -> bool {
1553 self.state_mut()
1554 .mut_resource::<ChunkGenerator>()
1555 .pending_chunks()
1556 .next()
1557 .is_some()
1558 }
1559
1560 pub fn set_sql_log_mode(&mut self, sql_log_mode: SqlLogMode) {
1562 let mut database_settings = self.database_settings.write().unwrap();
1568 database_settings.sql_log_mode = sql_log_mode;
1569 drop(database_settings);
1572 info!("SQL log mode changed to {:?}", sql_log_mode);
1573 }
1574
1575 pub fn disconnect_all_clients(&mut self) {
1576 info!("Disconnecting all clients due to local console command");
1577 self.disconnect_all_clients_requested = true;
1578 }
1579
1580 pub fn get_battle_mode_for(&mut self, client: EcsEntity) {
1586 let ecs = self.state.ecs();
1587 let time = ecs.read_resource::<Time>();
1588 let settings = ecs.read_resource::<Settings>();
1589 let players = ecs.read_storage::<comp::Player>();
1590 let get_player_result = players.get(client).ok_or_else(|| {
1591 error!("Can't get player component for client.");
1592
1593 Content::Plain("Can't get player component for client.".to_string())
1594 });
1595 let player = match get_player_result {
1596 Ok(player) => player,
1597 Err(content) => {
1598 self.notify_client(
1599 client,
1600 ServerGeneral::server_msg(ChatType::CommandError, content),
1601 );
1602 return;
1603 },
1604 };
1605
1606 let mut msg = format!("Current battle mode: {:?}.", player.battle_mode);
1607
1608 if settings.gameplay.battle_mode.allow_choosing() {
1609 msg.push_str(" Possible to change.");
1610 } else {
1611 msg.push_str(" Global.");
1612 }
1613
1614 if let Some(change) = player.last_battlemode_change {
1615 let Time(time) = *time;
1616 let Time(change) = change;
1617 let elapsed = time - change;
1618 let next = BATTLE_MODE_COOLDOWN - elapsed;
1619
1620 if next > 0.0 {
1621 let notice = format!(" Next change will be available in: {:.0} seconds", next);
1622 msg.push_str(¬ice);
1623 }
1624 }
1625
1626 self.notify_client(
1627 client,
1628 ServerGeneral::server_msg(ChatType::CommandInfo, Content::Plain(msg)),
1629 );
1630 }
1631
1632 pub fn set_battle_mode_for(&mut self, client: EcsEntity, battle_mode: BattleMode) {
1638 let ecs = self.state.ecs();
1639 let time = ecs.read_resource::<Time>();
1640 let settings = ecs.read_resource::<Settings>();
1641
1642 if !settings.gameplay.battle_mode.allow_choosing() {
1643 self.notify_client(
1644 client,
1645 ServerGeneral::server_msg(
1646 ChatType::CommandInfo,
1647 Content::localized("command-disabled-by-settings"),
1648 ),
1649 );
1650
1651 return;
1652 }
1653
1654 #[cfg(feature = "worldgen")]
1655 let in_town = {
1656 let pos = if let Some(pos) = self
1657 .state
1658 .ecs()
1659 .read_storage::<comp::Pos>()
1660 .get(client)
1661 .copied()
1662 {
1663 pos
1664 } else {
1665 self.notify_client(
1666 client,
1667 ServerGeneral::server_msg(
1668 ChatType::CommandInfo,
1669 Content::localized_with_args("command-position-unavailable", [(
1670 "target", "target",
1671 )]),
1672 ),
1673 );
1674
1675 return;
1676 };
1677
1678 let wpos = pos.0.xy().map(|x| x as i32);
1679 let chunk_pos = wpos.wpos_to_cpos();
1680 self.world.civs().sites().any(|site| {
1681 const RADIUS: f32 = 9.0;
1683 let delta = site
1684 .center
1685 .map(|x| x as f32)
1686 .distance(chunk_pos.map(|x| x as f32));
1687 delta < RADIUS
1688 })
1689 };
1690
1691 #[cfg(not(feature = "worldgen"))]
1692 let in_town = true;
1693
1694 if !in_town {
1695 self.notify_client(
1696 client,
1697 ServerGeneral::server_msg(
1698 ChatType::CommandInfo,
1699 Content::localized("command-battlemode-intown"),
1700 ),
1701 );
1702
1703 return;
1704 }
1705
1706 let mut players = ecs.write_storage::<comp::Player>();
1707 let mut player = if let Some(info) = players.get_mut(client) {
1708 info
1709 } else {
1710 error!("Failed to get info for player.");
1711
1712 return;
1713 };
1714
1715 if let Some(Time(last_change)) = player.last_battlemode_change {
1716 let Time(time) = *time;
1717 let elapsed = time - last_change;
1718 if elapsed < BATTLE_MODE_COOLDOWN {
1719 let next = BATTLE_MODE_COOLDOWN - elapsed;
1720
1721 self.notify_client(
1722 client,
1723 ServerGeneral::server_msg(
1724 ChatType::CommandInfo,
1725 Content::Plain(format!(
1726 "Next change will be available in {next:.0} seconds."
1727 )),
1728 ),
1729 );
1730
1731 return;
1732 }
1733 }
1734
1735 if player.battle_mode == battle_mode {
1736 self.notify_client(
1737 client,
1738 ServerGeneral::server_msg(
1739 ChatType::CommandInfo,
1740 Content::localized("command-battlemode-same"),
1741 ),
1742 );
1743
1744 return;
1745 }
1746
1747 player.battle_mode = battle_mode;
1748 player.last_battlemode_change = Some(*time);
1749
1750 self.notify_client(
1751 client,
1752 ServerGeneral::server_msg(
1753 ChatType::CommandInfo,
1754 Content::localized_with_args("command-battlemode-updated", [(
1755 "battlemode",
1756 format!("{battle_mode:?}"),
1757 )]),
1758 ),
1759 );
1760
1761 drop(players);
1762
1763 let uid = ecs.read_storage::<Uid>().get(client).copied().unwrap();
1764
1765 self.state().notify_players(ServerGeneral::PlayerListUpdate(
1766 PlayerListUpdate::UpdateBattleMode(uid, battle_mode),
1767 ));
1768 }
1769}
1770
1771impl Drop for Server {
1772 fn drop(&mut self) {
1773 self.state
1774 .notify_players(ServerGeneral::Disconnect(DisconnectReason::Shutdown));
1775
1776 #[cfg(feature = "persistent_world")]
1777 self.state
1778 .ecs()
1779 .try_fetch_mut::<TerrainPersistence>()
1780 .map(|mut terrain_persistence| {
1781 info!("Unloading terrain persistence...");
1782 terrain_persistence.unload_all()
1783 });
1784
1785 #[cfg(feature = "worldgen")]
1786 {
1787 debug!("Saving rtsim state...");
1788 self.state.ecs().write_resource::<rtsim::RtSim>().save(true);
1789 }
1790 }
1791}
1792
1793#[must_use]
1794pub fn handle_edit<T, S: settings::EditableSetting>(
1795 data: T,
1796 result: Option<(String, Result<(), settings::SettingError<S>>)>,
1797) -> Option<T> {
1798 use crate::settings::SettingError;
1799 let (info, result) = result?;
1800 match result {
1801 Ok(()) => {
1802 info!("{}", info);
1803 Some(data)
1804 },
1805 Err(SettingError::Io(err)) => {
1806 warn!(
1807 ?err,
1808 "Failed to write settings file to disk, but succeeded in memory (success message: \
1809 {})",
1810 info,
1811 );
1812 Some(data)
1813 },
1814 Err(SettingError::Integrity(err)) => {
1815 error!(?err, "Encountered an error while validating the request",);
1816 None
1817 },
1818 }
1819}
1820
1821#[must_use]
1826pub fn add_admin(
1827 username: &str,
1828 role: comp::AdminRole,
1829 login_provider: &LoginProvider,
1830 editable_settings: &mut EditableSettings,
1831 data_dir: &std::path::Path,
1832) -> Option<common::uuid::Uuid> {
1833 use crate::settings::EditableSetting;
1834 let role_ = role.into();
1835 match login_provider.username_to_uuid(username) {
1836 Ok(uuid) => handle_edit(
1837 uuid,
1838 editable_settings.admins.edit(data_dir, |admins| {
1839 match admins.insert(uuid, settings::AdminRecord {
1840 username_when_admined: Some(username.into()),
1841 date: chrono::Utc::now(),
1842 role: role_,
1843 }) {
1844 None => Some(format!(
1845 "Successfully added {} ({}) as {:?}!",
1846 username, uuid, role
1847 )),
1848 Some(old_admin) if old_admin.role == role_ => {
1849 info!("{} ({}) already has role: {:?}!", username, uuid, role);
1850 None
1851 },
1852 Some(old_admin) => Some(format!(
1853 "{} ({}) role changed from {:?} to {:?}!",
1854 username, uuid, old_admin.role, role
1855 )),
1856 }
1857 }),
1858 ),
1859 Err(err) => {
1860 error!(
1861 ?err,
1862 "Could not find uuid for this name; either the user does not exist or there was \
1863 an error communicating with the auth server."
1864 );
1865 None
1866 },
1867 }
1868}
1869
1870#[must_use]
1875pub fn remove_admin(
1876 username: &str,
1877 login_provider: &LoginProvider,
1878 editable_settings: &mut EditableSettings,
1879 data_dir: &std::path::Path,
1880) -> Option<common::uuid::Uuid> {
1881 use crate::settings::EditableSetting;
1882 match login_provider.username_to_uuid(username) {
1883 Ok(uuid) => handle_edit(
1884 uuid,
1885 editable_settings.admins.edit(data_dir, |admins| {
1886 if let Some(admin) = admins.remove(&uuid) {
1887 Some(format!(
1888 "Successfully removed {} ({}) with role {:?} from the admins list",
1889 username, uuid, admin.role,
1890 ))
1891 } else {
1892 info!("{} ({}) is not an admin!", username, uuid);
1893 None
1894 }
1895 }),
1896 ),
1897 Err(err) => {
1898 error!(
1899 ?err,
1900 "Could not find uuid for this name; either the user does not exist or there was \
1901 an error communicating with the auth server."
1902 );
1903 None
1904 },
1905 }
1906}