veloren_server/
lib.rs

1#![deny(unsafe_code)]
2#![expect(
3    clippy::option_map_unit_fn,
4    clippy::needless_pass_by_ref_mut // until we find a better way for specs
5)]
6#![deny(clippy::clone_on_ref_ptr)]
7#![feature(box_patterns, let_chains, option_zip, const_type_name)]
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
40// Reexports
41pub 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 censor::Censor;
66#[cfg(not(feature = "worldgen"))]
67use common::grid::Grid;
68#[cfg(feature = "worldgen")]
69use common::terrain::TerrainChunkSize;
70use common::{
71    assets::AssetExt,
72    calendar::Calendar,
73    character::{CharacterId, CharacterItem},
74    cmd::ServerChatCommand,
75    comp,
76    event::{
77        ClientDisconnectEvent, ClientDisconnectWithoutPersistenceEvent, EventBus, ExitIngameEvent,
78        UpdateCharacterDataEvent,
79    },
80    link::Is,
81    mounting::{Volume, VolumeRider},
82    region::RegionMap,
83    resources::{BattleMode, GameMode, Time, TimeOfDay},
84    rtsim::RtSimEntity,
85    shared_server_config::ServerConstants,
86    slowjob::SlowJobPool,
87    terrain::TerrainChunk,
88    util::GIT_DATE_TIMESTAMP,
89    vol::RectRasterableVol,
90};
91use common_base::prof_span;
92use common_ecs::run_now;
93use common_net::{
94    msg::{ClientType, DisconnectReason, ServerGeneral, ServerInfo, ServerMsg},
95    sync::WorldSyncExt,
96};
97use common_state::{AreasContainer, BlockDiff, BuildArea, State};
98use common_systems::add_local_systems;
99use metrics::{EcsSystemMetrics, PhysicsMetrics, TickMetrics};
100use network::{ListenAddr, Network, Pid};
101use persistence::{
102    character_loader::{CharacterLoader, CharacterUpdaterMessage},
103    character_updater::CharacterUpdater,
104};
105use prometheus::Registry;
106use rustls::pki_types::{CertificateDer, PrivateKeyDer};
107use specs::{
108    Builder, Entity as EcsEntity, Entity, Join, LendJoin, WorldExt, shred::SendDispatcher,
109};
110use std::{
111    ops::{Deref, DerefMut},
112    sync::{Arc, Mutex},
113    time::{Duration, Instant},
114};
115#[cfg(not(feature = "worldgen"))]
116use test_world::{IndexOwned, World};
117use tokio::runtime::Runtime;
118use tracing::{debug, error, info, trace, warn};
119use vek::*;
120use veloren_query_server::server::QueryServer;
121pub use world::{WorldGenerateStage, civ::WorldCivStage, sim::WorldSimStage};
122
123use crate::{
124    persistence::{DatabaseSettings, SqlLogMode},
125    sys::terrain,
126};
127use hashbrown::HashMap;
128use std::sync::RwLock;
129
130use crate::settings::Protocol;
131
132#[cfg(feature = "plugins")]
133use {
134    common::uid::IdMaps,
135    common_state::plugin::{PluginMgr, memory_manager::EcsWorld},
136};
137
138use crate::{chat::ChatCache, persistence::character_loader::CharacterScreenResponseKind};
139use common::comp::Anchor;
140#[cfg(feature = "worldgen")]
141pub use world::{
142    IndexOwned, World,
143    sim::{DEFAULT_WORLD_MAP, DEFAULT_WORLD_SEED, FileOpts, GenOpts, WorldOpts},
144};
145
146/// SpawnPoint corresponds to the default location that players are positioned
147/// at if they have no waypoint. Players *should* always have a waypoint, so
148/// this should basically never be used in practice.
149#[derive(Copy, Clone)]
150pub struct SpawnPoint(pub Vec3<f32>);
151
152impl Default for SpawnPoint {
153    fn default() -> Self { Self(Vec3::new(0.0, 0.0, 256.0)) }
154}
155
156// This is the minimum chunk range that is kept loaded around each player
157// server-side. This is independent of the client's view distance and exists to
158// avoid exploits such as small view distance chunk reloading and also to keep
159// various mechanics working fluidly (i.e: not unloading nearby entities).
160pub const MIN_VD: u32 = 6;
161
162// Tick count used for throttling network updates
163// Note this doesn't account for dt (so update rate changes with tick rate)
164#[derive(Copy, Clone, Default)]
165pub struct Tick(u64);
166
167#[derive(Clone)]
168pub struct HwStats {
169    hardware_threads: u32,
170    rayon_threads: u32,
171}
172
173#[derive(Clone, Copy, PartialEq)]
174enum DisconnectType {
175    WithPersistence,
176    WithoutPersistence,
177}
178
179// Start of Tick, used for metrics
180#[derive(Copy, Clone)]
181pub struct TickStart(Instant);
182
183/// Store of BattleMode cooldowns for players while they go offline
184#[derive(Clone, Default, Debug)]
185pub struct BattleModeBuffer {
186    map: HashMap<CharacterId, (BattleMode, Time)>,
187}
188
189impl BattleModeBuffer {
190    pub fn push(&mut self, char_id: CharacterId, save: (BattleMode, Time)) {
191        self.map.insert(char_id, save);
192    }
193
194    pub fn get(&self, char_id: &CharacterId) -> Option<&(BattleMode, Time)> {
195        self.map.get(char_id)
196    }
197
198    pub fn pop(&mut self, char_id: &CharacterId) -> Option<(BattleMode, Time)> {
199        self.map.remove(char_id)
200    }
201}
202
203pub struct ChunkRequest {
204    entity: EcsEntity,
205    key: Vec2<i32>,
206}
207
208#[derive(Debug)]
209pub enum ServerInitStage {
210    DbMigrations,
211    DbVacuum,
212    WorldGen(WorldGenerateStage),
213    StartingSystems,
214}
215
216pub struct Server {
217    state: State,
218    world: Arc<World>,
219    index: IndexOwned,
220
221    connection_handler: ConnectionHandler,
222
223    runtime: Arc<Runtime>,
224
225    metrics_registry: Arc<Registry>,
226    chat_cache: ChatCache,
227    database_settings: Arc<RwLock<DatabaseSettings>>,
228    disconnect_all_clients_requested: bool,
229
230    event_dispatcher: SendDispatcher<'static>,
231}
232
233impl Server {
234    /// Create a new `Server`
235    pub fn new(
236        settings: Settings,
237        editable_settings: EditableSettings,
238        database_settings: DatabaseSettings,
239        data_dir: &std::path::Path,
240        report_stage: &(dyn Fn(ServerInitStage) + Send + Sync),
241        runtime: Arc<Runtime>,
242    ) -> Result<Self, Error> {
243        prof_span!("Server::new");
244        info!("Server data dir is: {}", data_dir.display());
245        if settings.auth_server_address.is_none() {
246            info!("Authentication is disabled");
247        }
248
249        report_stage(ServerInitStage::DbMigrations);
250        // Run pending DB migrations (if any)
251        debug!("Running DB migrations...");
252        persistence::run_migrations(&database_settings);
253
254        report_stage(ServerInitStage::DbVacuum);
255        // Vacuum database
256        debug!("Vacuuming database...");
257        persistence::vacuum_database(&database_settings);
258
259        let database_settings = Arc::new(RwLock::new(database_settings));
260
261        let registry = Arc::new(Registry::new());
262        let chunk_gen_metrics = metrics::ChunkGenMetrics::new(&registry).unwrap();
263        let job_metrics = metrics::JobMetrics::new(&registry).unwrap();
264        let network_request_metrics = metrics::NetworkRequestMetrics::new(&registry).unwrap();
265        let player_metrics = metrics::PlayerMetrics::new(&registry).unwrap();
266        let ecs_system_metrics = EcsSystemMetrics::new(&registry).unwrap();
267        let tick_metrics = TickMetrics::new(&registry).unwrap();
268        let physics_metrics = PhysicsMetrics::new(&registry).unwrap();
269        let server_event_metrics = metrics::ServerEventMetrics::new(&registry).unwrap();
270        let query_server_metrics = metrics::QueryServerMetrics::new(&registry).unwrap();
271
272        let battlemode_buffer = BattleModeBuffer::default();
273
274        let pools = State::pools(GameMode::Server);
275
276        // Load plugins before generating the world.
277        #[cfg(feature = "plugins")]
278        let plugin_mgr = PluginMgr::from_asset_or_default();
279
280        debug!("Generating world, seed: {}", settings.world_seed);
281        #[cfg(feature = "worldgen")]
282        let (world, index) = World::generate(
283            settings.world_seed,
284            WorldOpts {
285                seed_elements: true,
286                world_file: if let Some(ref opts) = settings.map_file {
287                    opts.clone()
288                } else {
289                    // Load default map from assets.
290                    FileOpts::LoadAsset(DEFAULT_WORLD_MAP.into())
291                },
292                calendar: Some(settings.calendar_mode.calendar_now()),
293            },
294            &pools,
295            &|stage| {
296                report_stage(ServerInitStage::WorldGen(stage));
297            },
298        );
299        #[cfg(not(feature = "worldgen"))]
300        let (world, index) = World::generate(settings.world_seed);
301
302        #[cfg(feature = "worldgen")]
303        let map = world.get_map_data(index.as_index_ref(), &pools);
304        #[cfg(not(feature = "worldgen"))]
305        let map = common_net::msg::WorldMapMsg {
306            dimensions_lg: Vec2::zero(),
307            max_height: 1.0,
308            rgba: Grid::new(Vec2::new(1, 1), 1),
309            horizons: [(vec![0], vec![0]), (vec![0], vec![0])],
310            alt: Grid::new(Vec2::new(1, 1), 1),
311            sites: Vec::new(),
312            possible_starting_sites: Vec::new(),
313            pois: Vec::new(),
314            default_chunk: Arc::new(world.generate_oob_chunk()),
315        };
316
317        #[cfg(feature = "worldgen")]
318        let map_size_lg = world.sim().map_size_lg();
319        #[cfg(not(feature = "worldgen"))]
320        let map_size_lg = world.map_size_lg();
321
322        let lod = lod::Lod::from_world(&world, index.as_index_ref(), &pools);
323
324        report_stage(ServerInitStage::StartingSystems);
325
326        let mut state = State::server(
327            Arc::clone(&pools),
328            map_size_lg,
329            Arc::clone(&map.default_chunk),
330            |dispatcher_builder| {
331                add_local_systems(dispatcher_builder);
332                sys::msg::add_server_systems(dispatcher_builder);
333                sys::add_server_systems(dispatcher_builder);
334                #[cfg(feature = "worldgen")]
335                {
336                    rtsim::add_server_systems(dispatcher_builder);
337                    weather::add_server_systems(dispatcher_builder);
338                }
339            },
340            #[cfg(feature = "plugins")]
341            plugin_mgr,
342        );
343        events::register_event_busses(state.ecs_mut());
344        state.ecs_mut().insert(battlemode_buffer);
345        state.ecs_mut().insert(settings.clone());
346        state.ecs_mut().insert(editable_settings);
347        state.ecs_mut().insert(DataDir {
348            path: data_dir.to_owned(),
349        });
350
351        state.ecs_mut().insert(Vec::<ChunkRequest>::new());
352        state
353            .ecs_mut()
354            .insert(EventBus::<chunk_serialize::ChunkSendEntry>::default());
355        state.ecs_mut().insert(Locations::default());
356        state.ecs_mut().insert(LoginProvider::new(
357            settings.auth_server_address.clone(),
358            Arc::clone(&runtime),
359        ));
360        state.ecs_mut().insert(HwStats {
361            hardware_threads: num_cpus::get() as u32,
362            rayon_threads: num_cpus::get() as u32,
363        });
364        state.ecs_mut().insert(ServerConstants {
365            day_cycle_coefficient: settings.day_cycle_coefficient(),
366        });
367        state.ecs_mut().insert(Tick(0));
368        state.ecs_mut().insert(TickStart(Instant::now()));
369        state.ecs_mut().insert(job_metrics);
370        state.ecs_mut().insert(network_request_metrics);
371        state.ecs_mut().insert(player_metrics);
372        state.ecs_mut().insert(ecs_system_metrics);
373        state.ecs_mut().insert(tick_metrics);
374        state.ecs_mut().insert(physics_metrics);
375        state.ecs_mut().insert(server_event_metrics);
376        state.ecs_mut().insert(query_server_metrics);
377        if settings.experimental_terrain_persistence {
378            #[cfg(feature = "persistent_world")]
379            {
380                warn!(
381                    "Experimental terrain persistence support is enabled. This feature may break, \
382                     be disabled, or otherwise change under your feet at *any time*. \
383                     Additionally, it is expected to be replaced in the future *without* \
384                     migration or warning. You have been warned."
385                );
386                state
387                    .ecs_mut()
388                    .insert(TerrainPersistence::new(data_dir.to_owned()));
389            }
390            #[cfg(not(feature = "persistent_world"))]
391            error!(
392                "Experimental terrain persistence support was requested, but the server was not \
393                 compiled with the feature. Terrain modifications will *not* be persisted."
394            );
395        }
396        {
397            let pool = state.ecs_mut().write_resource::<SlowJobPool>();
398            pool.configure("CHUNK_DROP", |_n| 1);
399            pool.configure("CHUNK_GENERATOR", |n| n / 2 + n / 4);
400            pool.configure("CHUNK_SERIALIZER", |n| n / 2);
401            pool.configure("RTSIM_SAVE", |_| 1);
402            pool.configure("WEATHER", |_| 1);
403        }
404        state
405            .ecs_mut()
406            .insert(ChunkGenerator::new(chunk_gen_metrics));
407        {
408            let (sender, receiver) =
409                crossbeam_channel::bounded::<chunk_serialize::SerializedChunk>(10_000);
410            state.ecs_mut().insert(sender);
411            state.ecs_mut().insert(receiver);
412        }
413
414        state.ecs_mut().insert(CharacterUpdater::new(
415            Arc::<RwLock<DatabaseSettings>>::clone(&database_settings),
416        )?);
417
418        let ability_map = comp::item::tool::AbilityMap::<comp::AbilityItem>::load_expect_cloned(
419            "common.abilities.ability_set_manifest",
420        );
421        state.ecs_mut().insert(ability_map);
422
423        let msm = comp::inventory::item::MaterialStatManifest::load().cloned();
424        state.ecs_mut().insert(msm);
425
426        let rbm = common::recipe::RecipeBookManifest::load().cloned();
427        state.ecs_mut().insert(rbm);
428
429        state.ecs_mut().insert(CharacterLoader::new(
430            Arc::<RwLock<DatabaseSettings>>::clone(&database_settings),
431        )?);
432
433        // System schedulers to control execution of systems
434        state
435            .ecs_mut()
436            .insert(sys::PersistenceScheduler::every(Duration::from_secs(10)));
437
438        // Region map (spatial structure for entity synchronization)
439        state.ecs_mut().insert(RegionMap::new());
440
441        // Server-only components
442        state.ecs_mut().register::<RegionSubscription>();
443        state.ecs_mut().register::<Client>();
444        state.ecs_mut().register::<comp::Presence>();
445        state.ecs_mut().register::<wiring::WiringElement>();
446        state.ecs_mut().register::<wiring::Circuit>();
447        state.ecs_mut().register::<Anchor>();
448        state.ecs_mut().register::<comp::Pet>();
449        state.ecs_mut().register::<login_provider::PendingLogin>();
450        state.ecs_mut().register::<RepositionOnChunkLoad>();
451        state.ecs_mut().register::<RtSimEntity>();
452
453        // Load banned words list
454        let banned_words = settings.moderation.load_banned_words(data_dir);
455        let censor = Arc::new(Censor::Custom(banned_words.into_iter().collect()));
456        state.ecs_mut().insert(Arc::clone(&censor));
457
458        // Init automod
459        state
460            .ecs_mut()
461            .insert(AutoMod::new(&settings.moderation, censor));
462
463        state.ecs_mut().insert(map);
464
465        #[cfg(feature = "worldgen")]
466        let spawn_point = SpawnPoint({
467            use world::civ::SiteKind;
468
469            let index = index.as_index_ref();
470            // NOTE: all of these `.map(|e| e as [type])` calls should compile into no-ops,
471            // but are needed to be explicit about casting (and to make the compiler stop
472            // complaining)
473
474            // Search for town defined by spawn_town server setting. If this fails, or is
475            // None, set spawn to the nearest town to the centre of the world
476            let center_chunk = world.sim().map_size_lg().chunks().map(i32::from) / 2;
477            let spawn_chunk = world
478                .civs()
479                .sites()
480                .filter(|site| matches!(site.kind, SiteKind::Settlement | SiteKind::Refactor))
481                .map(|site| site.center)
482                .min_by_key(|site_pos| site_pos.distance_squared(center_chunk))
483                .unwrap_or(center_chunk);
484
485            world.find_accessible_pos(index, TerrainChunkSize::center_wpos(spawn_chunk), false)
486        });
487        #[cfg(not(feature = "worldgen"))]
488        let spawn_point = SpawnPoint::default();
489
490        // Set the spawn point we calculated above
491        state.ecs_mut().insert(spawn_point);
492
493        // Insert a default AABB for the world
494        // TODO: prevent this from being deleted
495        {
496            #[cfg(feature = "worldgen")]
497            let size = world.sim().get_size();
498            #[cfg(not(feature = "worldgen"))]
499            let size = world.map_size_lg().chunks().map(u32::from);
500
501            let world_size = size.map(|e| e as i32) * TerrainChunk::RECT_SIZE.map(|e| e as i32);
502            let world_aabb = Aabb {
503                min: Vec3::new(0, 0, -32768),
504                max: Vec3::new(world_size.x, world_size.y, 32767),
505            }
506            .made_valid();
507
508            state
509                .ecs()
510                .write_resource::<AreasContainer<BuildArea>>()
511                .insert("world".to_string(), world_aabb)
512                .expect("The initial insert should always work.");
513        }
514
515        // Insert the world into the ECS (todo: Maybe not an Arc?)
516        let world = Arc::new(world);
517        state.ecs_mut().insert(Arc::clone(&world));
518        state.ecs_mut().insert(lod);
519        state.ecs_mut().insert(index.clone());
520
521        // Set starting time for the server.
522        state.ecs_mut().write_resource::<TimeOfDay>().0 = settings.world.start_time;
523
524        // Register trackers
525        sys::sentinel::UpdateTrackers::register(state.ecs_mut());
526
527        state.ecs_mut().insert(DeletedEntities::default());
528
529        let network = Network::new_with_registry(Pid::new(), &runtime, &registry);
530        let (chat_cache, chat_tracker) = ChatCache::new(Duration::from_secs(60), &runtime);
531        state.ecs_mut().insert(chat_tracker);
532
533        let mut printed_quic_warning = false;
534        for protocol in &settings.gameserver_protocols {
535            match protocol {
536                Protocol::Tcp { address } => {
537                    runtime.block_on(network.listen(ListenAddr::Tcp(*address)))?;
538                },
539                Protocol::Quic {
540                    address,
541                    cert_file_path,
542                    key_file_path,
543                } => {
544                    use rustls_pemfile::Item;
545                    use std::fs;
546
547                    match || -> Result<_, Box<dyn std::error::Error>> {
548                        let key = fs::read(key_file_path)?;
549                        let key = if key_file_path.extension().is_some_and(|x| x == "der") {
550                            PrivateKeyDer::try_from(key).map_err(|_| "No valid pem key in file")?
551                        } else {
552                            debug!("convert pem key to der");
553                            rustls_pemfile::read_all(&mut key.as_slice())
554                                .find_map(|item| match item {
555                                    Ok(Item::Pkcs1Key(v)) => Some(PrivateKeyDer::Pkcs1(v)),
556                                    Ok(Item::Pkcs8Key(v)) => Some(PrivateKeyDer::Pkcs8(v)),
557                                    Ok(Item::Sec1Key(v)) => Some(PrivateKeyDer::Sec1(v)),
558                                    Ok(Item::Crl(_)) => None,
559                                    Ok(Item::Csr(_)) => None,
560                                    Ok(Item::X509Certificate(_)) => None,
561                                    Ok(_) => None,
562                                    Err(e) => {
563                                        tracing::warn!(?e, "error while reading key_file");
564                                        None
565                                    },
566                                })
567                                .ok_or("No valid pem key in file")?
568                        };
569                        let cert_chain = fs::read(cert_file_path)?;
570                        let cert_chain = if cert_file_path.extension().is_some_and(|x| x == "der") {
571                            vec![CertificateDer::from(cert_chain)]
572                        } else {
573                            debug!("convert pem cert to der");
574                            rustls_pemfile::certs(&mut cert_chain.as_slice())
575                                .filter_map(|item| match item {
576                                    Ok(cert) => Some(cert),
577                                    Err(e) => {
578                                        tracing::warn!(?e, "error while reading cert_file");
579                                        None
580                                    },
581                                })
582                                .collect()
583                        };
584                        let server_config = quinn::ServerConfig::with_single_cert(cert_chain, key)?;
585                        Ok(server_config)
586                    }() {
587                        Ok(server_config) => {
588                            runtime.block_on(
589                                network.listen(ListenAddr::Quic(*address, server_config.clone())),
590                            )?;
591
592                            if !printed_quic_warning {
593                                warn!(
594                                    "QUIC is enabled. This is experimental and not recommended in \
595                                     production"
596                                );
597                                printed_quic_warning = true;
598                            }
599                        },
600                        Err(e) => {
601                            error!(
602                                ?e,
603                                "Failed to load the TLS certificate, running without QUIC {}",
604                                *address
605                            );
606                        },
607                    }
608                },
609            }
610        }
611
612        if let Some(addr) = settings.query_address {
613            use veloren_query_server::proto::ServerInfo;
614
615            const QUERY_SERVER_RATELIMIT: u16 = 120;
616
617            let (query_server_info_tx, query_server_info_rx) =
618                tokio::sync::watch::channel(ServerInfo {
619                    git_hash: *sys::server_info::GIT_HASH,
620                    git_timestamp: *GIT_DATE_TIMESTAMP,
621                    players_count: 0,
622                    player_cap: settings.max_players,
623                    battlemode: settings.gameplay.battle_mode.into(),
624                });
625            let mut query_server =
626                QueryServer::new(addr, query_server_info_rx, QUERY_SERVER_RATELIMIT);
627            let query_server_metrics =
628                Arc::new(Mutex::new(veloren_query_server::server::Metrics::default()));
629            let query_server_metrics2 = Arc::clone(&query_server_metrics);
630            runtime.spawn(async move {
631                let err = query_server.run(query_server_metrics2).await.err();
632                error!(?err, "Query server stopped unexpectedly");
633            });
634            state.ecs_mut().insert(query_server_info_tx);
635            state.ecs_mut().insert(query_server_metrics);
636        }
637
638        runtime.block_on(network.listen(ListenAddr::Mpsc(14004)))?;
639
640        let connection_handler = ConnectionHandler::new(network, &runtime);
641
642        // Init rtsim, loading it from disk if possible
643        #[cfg(feature = "worldgen")]
644        {
645            match rtsim::RtSim::new(
646                &settings.world,
647                index.as_index_ref(),
648                &world,
649                data_dir.to_owned(),
650            ) {
651                Ok(rtsim) => {
652                    state.ecs_mut().insert(rtsim.state().data().time_of_day);
653                    state.ecs_mut().insert(rtsim);
654                },
655                Err(err) => {
656                    error!("Failed to load rtsim: {}", err);
657                    return Err(Error::RtsimError(err));
658                },
659            }
660            weather::init(&mut state);
661        }
662
663        let this = Self {
664            state,
665            world,
666            index,
667            connection_handler,
668            runtime,
669
670            metrics_registry: registry,
671            chat_cache,
672            database_settings,
673            disconnect_all_clients_requested: false,
674
675            event_dispatcher: Self::create_event_dispatcher(pools),
676        };
677
678        debug!(?settings, "created veloren server with");
679
680        let git_hash = *common::util::GIT_HASH;
681        let git_date = common::util::GIT_DATE.clone();
682        let git_time = *common::util::GIT_TIME;
683        let version = common::util::DISPLAY_VERSION_LONG.clone();
684        info!(?version, "Server version");
685        debug!(?git_hash, ?git_date, ?git_time, "detailed Server version");
686
687        Ok(this)
688    }
689
690    pub fn get_server_info(&self) -> ServerInfo {
691        let settings = self.state.ecs().fetch::<Settings>();
692
693        ServerInfo {
694            name: settings.server_name.clone(),
695            git_hash: common::util::GIT_HASH.to_string(),
696            git_date: common::util::GIT_DATE.to_string(),
697            auth_provider: settings.auth_server_address.clone(),
698        }
699    }
700
701    /// Get a reference to the server's settings
702    pub fn settings(&self) -> impl Deref<Target = Settings> + '_ {
703        self.state.ecs().fetch::<Settings>()
704    }
705
706    /// Get a mutable reference to the server's settings
707    pub fn settings_mut(&self) -> impl DerefMut<Target = Settings> + '_ {
708        self.state.ecs().fetch_mut::<Settings>()
709    }
710
711    /// Get a mutable reference to the server's editable settings
712    pub fn editable_settings_mut(&self) -> impl DerefMut<Target = EditableSettings> + '_ {
713        self.state.ecs().fetch_mut::<EditableSettings>()
714    }
715
716    /// Get a reference to the server's editable settings
717    pub fn editable_settings(&self) -> impl Deref<Target = EditableSettings> + '_ {
718        self.state.ecs().fetch::<EditableSettings>()
719    }
720
721    /// Get path to the directory that the server info into
722    pub fn data_dir(&self) -> impl Deref<Target = DataDir> + '_ {
723        self.state.ecs().fetch::<DataDir>()
724    }
725
726    /// Get a reference to the server's game state.
727    pub fn state(&self) -> &State { &self.state }
728
729    /// Get a mutable reference to the server's game state.
730    pub fn state_mut(&mut self) -> &mut State { &mut self.state }
731
732    /// Get a reference to the server's world.
733    pub fn world(&self) -> &World { &self.world }
734
735    /// Get a reference to the Metrics Registry
736    pub fn metrics_registry(&self) -> &Arc<Registry> { &self.metrics_registry }
737
738    /// Get a reference to the Chat Cache
739    pub fn chat_cache(&self) -> &ChatCache { &self.chat_cache }
740
741    fn parse_locations(&self, character_list_data: &mut [CharacterItem]) {
742        character_list_data.iter_mut().for_each(|c| {
743            let name = c
744                .location
745                .as_ref()
746                .and_then(|s| {
747                    persistence::parse_waypoint(s)
748                        .ok()
749                        .and_then(|(waypoint, _)| waypoint.map(|w| w.get_pos()))
750                })
751                .and_then(|wpos| {
752                    self.world
753                        .get_location_name(self.index.as_index_ref(), wpos.xy().as_::<i32>())
754                });
755            c.location = name;
756        });
757    }
758
759    /// Execute a single server tick, handle input and update the game state by
760    /// the given duration.
761    pub fn tick(&mut self, _input: Input, dt: Duration) -> Result<Vec<Event>, Error> {
762        self.state.ecs().write_resource::<Tick>().0 += 1;
763        self.state.ecs().write_resource::<TickStart>().0 = Instant::now();
764
765        // Update calendar events as time changes
766        // TODO: If a lot of calendar events get added, this might become expensive.
767        // Maybe don't do this every tick?
768        let new_calendar = self
769            .state
770            .ecs()
771            .read_resource::<Settings>()
772            .calendar_mode
773            .calendar_now();
774        *self.state.ecs_mut().write_resource::<Calendar>() = new_calendar;
775
776        // This tick function is the centre of the Veloren universe. Most server-side
777        // things are managed from here, and as such it's important that it
778        // stays organised. Please consult the core developers before making
779        // significant changes to this code. Here is the approximate order of
780        // things. Please update it as this code changes.
781        //
782        // 1) Collect input from the frontend, apply input effects to the state of the
783        //    game
784        // 2) Go through any events (timer-driven or otherwise) that need handling and
785        //    apply them to the state of the game
786        // 3) Go through all incoming client network communications, apply them to the
787        //    game state
788        // 4) Perform a single LocalState tick (i.e: update the world and entities in
789        //    the world)
790        // 5) Go through the terrain update queue and apply all changes to the terrain
791        // 6) Send relevant state updates to all clients
792        // 7) Check for persistence updates related to character data, and message the
793        //    relevant entities
794        // 8) Update Metrics with current data
795        // 9) Finish the tick, passing control of the main thread back to the frontend
796
797        // 1) Build up a list of events for this frame, to be passed to the frontend.
798        let mut frontend_events = Vec::new();
799
800        // 2)
801
802        let before_new_connections = Instant::now();
803
804        // 3) Handle inputs from clients
805        self.handle_new_connections(&mut frontend_events);
806
807        let before_state_tick = Instant::now();
808
809        fn on_block_update(ecs: &specs::World, changes: Vec<BlockDiff>) {
810            // When a resource block updates, inform rtsim
811            if changes
812                .iter()
813                .any(|c| c.old.get_rtsim_resource() != c.new.get_rtsim_resource())
814            {
815                ecs.write_resource::<rtsim::RtSim>().hook_block_update(
816                    &ecs.read_resource::<Arc<world::World>>(),
817                    ecs.read_resource::<world::IndexOwned>().as_index_ref(),
818                    changes,
819                );
820            }
821        }
822
823        // 4) Tick the server's LocalState.
824        // 5) Fetch any generated `TerrainChunk`s and insert them into the terrain.
825        // in sys/terrain.rs
826        let mut state_tick_metrics = Default::default();
827        let server_constants = (*self.state.ecs().read_resource::<ServerConstants>()).clone();
828        self.state.tick(
829            dt,
830            false,
831            Some(&mut state_tick_metrics),
832            &server_constants,
833            on_block_update,
834        );
835
836        let before_handle_events = Instant::now();
837
838        // Process any pending request to disconnect all clients, the disconnections
839        // will be processed once handle_events() is called below
840        let disconnect_type = self.disconnect_all_clients_if_requested();
841
842        // Handle entity links (such as mounting)
843        self.state.maintain_links();
844
845        // Handle game events
846        frontend_events.append(&mut self.handle_events());
847
848        let before_update_terrain_and_regions = Instant::now();
849
850        // Apply terrain changes and update the region map after processing server
851        // events so that changes made by server events will be immediately
852        // visible to client synchronization systems, minimizing the latency of
853        // `ServerEvent` mediated effects
854        self.update_region_map();
855        // NOTE: apply_terrain_changes sends the *new* value since it is not being
856        // synchronized during the tick.
857        self.state.apply_terrain_changes(on_block_update);
858
859        let before_sync = Instant::now();
860
861        // 6) Synchronise clients with the new state of the world.
862        sys::run_sync_systems(self.state.ecs_mut());
863
864        let before_world_tick = Instant::now();
865
866        // Tick the world
867        self.world.tick(dt);
868
869        let before_entity_cleanup = Instant::now();
870
871        // In the event of a request to disconnect all players without persistence, we
872        // must run the terrain system a second time after the messages to
873        // perform client disconnections have been processed. This ensures that any
874        // items on the ground are deleted.
875        if let Some(DisconnectType::WithoutPersistence) = disconnect_type {
876            run_now::<terrain::Sys>(self.state.ecs_mut());
877        }
878
879        // Hook rtsim chunk unloads
880        #[cfg(feature = "worldgen")]
881        {
882            let mut rtsim = self.state.ecs().write_resource::<rtsim::RtSim>();
883            for chunk in &self.state.terrain_changes().removed_chunks {
884                rtsim.hook_unload_chunk(*chunk);
885            }
886        }
887
888        // Prevent anchor entity chains which are not currently supported due to:
889        // * potential cycles?
890        // * unloading a chain could occur across an unbounded number of ticks with the
891        //   current implementation.
892        // * in particular, we want to be able to unload all entities in a
893        //   limited number of ticks when a database error occurs and kicks all
894        //   players (not quiet sure on exact time frame, since it already
895        //   takes a tick after unloading all chunks for entities to despawn?),
896        //   see this thread and the discussion linked from there:
897        //   https://gitlab.com/veloren/veloren/-/merge_requests/2668#note_634913847
898        let anchors = self.state.ecs().read_storage::<Anchor>();
899        let anchored_anchor_entities: Vec<Entity> = (
900            &self.state.ecs().entities(),
901            &self.state.ecs().read_storage::<Anchor>(),
902        )
903            .join()
904            .filter_map(|(_, anchor)| match anchor {
905                Anchor::Entity(anchor_entity) => Some(*anchor_entity),
906                _ => None,
907            })
908            // We allow Anchor::Entity(_) -> Anchor::Chunk(_) connections, since they can't chain further.
909            //
910            // NOTE: The entity with `Anchor::Entity` will unload one tick after the entity with `Anchor::Chunk`.
911            .filter(|anchor_entity| match anchors.get(*anchor_entity) {
912                Some(Anchor::Entity(_)) => true,
913                Some(Anchor::Chunk(_)) | None => false
914            })
915            .collect();
916        drop(anchors);
917
918        for entity in anchored_anchor_entities {
919            if cfg!(debug_assertions) {
920                panic!("Entity anchor chain detected");
921            }
922            error!(
923                "Detected an anchor entity that itself has an anchor entity - anchor chains are \
924                 not currently supported. The entity's Anchor component has been deleted"
925            );
926            self.state.delete_component::<Anchor>(entity);
927        }
928
929        // Remove NPCs that are outside the view distances of all players
930        // This is done by removing NPCs in unloaded chunks
931        let to_delete = {
932            let terrain = self.state.terrain();
933            (
934                &self.state.ecs().entities(),
935                &self.state.ecs().read_storage::<comp::Pos>(),
936                !&self.state.ecs().read_storage::<comp::Presence>(),
937                self.state.ecs().read_storage::<Anchor>().maybe(),
938                self.state.ecs().read_storage::<Is<VolumeRider>>().maybe(),
939            )
940                .join()
941                .filter(|(_, pos, _, anchor, is_volume_rider)| {
942                    let pos = is_volume_rider
943                        .and_then(|is_volume_rider| match is_volume_rider.pos.kind {
944                            Volume::Terrain => None,
945                            Volume::Entity(e) => {
946                                let e = self.state.ecs().entity_from_uid(e)?;
947                                let pos = self
948                                    .state
949                                    .ecs()
950                                    .read_storage::<comp::Pos>()
951                                    .get(e)
952                                    .copied()?;
953
954                                Some(pos.0)
955                            },
956                        })
957                        .unwrap_or(pos.0);
958                    let chunk_key = terrain.pos_key(pos.map(|e| e.floor() as i32));
959                    match anchor {
960                        Some(Anchor::Chunk(hc)) => {
961                            // Check if both this chunk and the NPCs `home_chunk` is unloaded. If
962                            // so, we delete them. We check for
963                            // `home_chunk` in order to avoid duplicating
964                            // the entity under some circumstances.
965                            terrain.get_key_real(chunk_key).is_none()
966                                && terrain.get_key_real(*hc).is_none()
967                        },
968                        Some(Anchor::Entity(entity)) => !self.state.ecs().is_alive(*entity),
969                        None => terrain.get_key_real(chunk_key).is_none(),
970                    }
971                })
972                .map(|(entity, _, _, _, _)| entity)
973                .collect::<Vec<_>>()
974        };
975
976        #[cfg(feature = "worldgen")]
977        {
978            let mut rtsim = self.state.ecs().write_resource::<rtsim::RtSim>();
979            let rtsim_entities = self.state.ecs().read_storage();
980            for entity in &to_delete {
981                if let Some(rtsim_entity) = rtsim_entities.get(*entity) {
982                    rtsim.hook_rtsim_entity_unload(*rtsim_entity);
983                }
984            }
985        }
986
987        // Actually perform entity deletion
988        for entity in to_delete {
989            if let Err(e) = self.state.delete_entity_recorded(entity) {
990                error!(?e, "Failed to delete agent outside the terrain");
991            }
992        }
993
994        if let Some(DisconnectType::WithoutPersistence) = disconnect_type {
995            info!(
996                "Disconnection of all players without persistence complete, signalling to \
997                 persistence thread that character updates may continue to be processed"
998            );
999            self.state
1000                .ecs()
1001                .fetch_mut::<CharacterUpdater>()
1002                .disconnected_success();
1003        }
1004
1005        // 7 Persistence updates
1006        let before_persistence_updates = Instant::now();
1007
1008        let character_loader = self.state.ecs().read_resource::<CharacterLoader>();
1009
1010        let mut character_updater = self.state.ecs().write_resource::<CharacterUpdater>();
1011        let updater_messages: Vec<CharacterUpdaterMessage> = character_updater.messages().collect();
1012
1013        // Get character-related database responses and notify the requesting client
1014        character_loader
1015            .messages()
1016            .chain(updater_messages)
1017            .for_each(|message| match message {
1018                CharacterUpdaterMessage::DatabaseBatchCompletion(batch_id) => {
1019                    character_updater.process_batch_completion(batch_id);
1020                },
1021                CharacterUpdaterMessage::CharacterScreenResponse(response) => {
1022                    match response.response_kind {
1023                        CharacterScreenResponseKind::CharacterList(result) => match result {
1024                            Ok(mut character_list_data) => {
1025                                self.parse_locations(&mut character_list_data);
1026                                self.notify_client(
1027                                    response.target_entity,
1028                                    ServerGeneral::CharacterListUpdate(character_list_data),
1029                                )
1030                            },
1031                            Err(error) => self.notify_client(
1032                                response.target_entity,
1033                                ServerGeneral::CharacterActionError(error.to_string()),
1034                            ),
1035                        },
1036                        CharacterScreenResponseKind::CharacterCreation(result) => match result {
1037                            Ok((character_id, mut list)) => {
1038                                self.parse_locations(&mut list);
1039                                self.notify_client(
1040                                    response.target_entity,
1041                                    ServerGeneral::CharacterListUpdate(list),
1042                                );
1043                                self.notify_client(
1044                                    response.target_entity,
1045                                    ServerGeneral::CharacterCreated(character_id),
1046                                );
1047                            },
1048                            Err(error) => self.notify_client(
1049                                response.target_entity,
1050                                ServerGeneral::CharacterActionError(error.to_string()),
1051                            ),
1052                        },
1053                        CharacterScreenResponseKind::CharacterEdit(result) => match result {
1054                            Ok((character_id, mut list)) => {
1055                                self.parse_locations(&mut list);
1056                                self.notify_client(
1057                                    response.target_entity,
1058                                    ServerGeneral::CharacterListUpdate(list),
1059                                );
1060                                self.notify_client(
1061                                    response.target_entity,
1062                                    ServerGeneral::CharacterEdited(character_id),
1063                                );
1064                            },
1065                            Err(error) => self.notify_client(
1066                                response.target_entity,
1067                                ServerGeneral::CharacterActionError(error.to_string()),
1068                            ),
1069                        },
1070                        CharacterScreenResponseKind::CharacterData(result) => {
1071                            match *result {
1072                                Ok((character_data, skill_set_persistence_load_error)) => {
1073                                    let PersistedComponents {
1074                                        body,
1075                                        hardcore,
1076                                        stats,
1077                                        skill_set,
1078                                        inventory,
1079                                        waypoint,
1080                                        pets,
1081                                        active_abilities,
1082                                        map_marker,
1083                                    } = character_data;
1084                                    let character_data = (
1085                                        body,
1086                                        hardcore,
1087                                        stats,
1088                                        skill_set,
1089                                        inventory,
1090                                        waypoint,
1091                                        pets,
1092                                        active_abilities,
1093                                        map_marker,
1094                                    );
1095                                    // TODO: Does this need to be a server event? E.g. we could
1096                                    // just handle it here.
1097                                    self.state.emit_event_now(UpdateCharacterDataEvent {
1098                                        entity: response.target_entity,
1099                                        components: character_data,
1100                                        metadata: skill_set_persistence_load_error,
1101                                    })
1102                                },
1103                                Err(error) => {
1104                                    // We failed to load data for the character from the DB. Notify
1105                                    // the client to push the state back to character selection,
1106                                    // with the error to display
1107                                    self.notify_client(
1108                                        response.target_entity,
1109                                        ServerGeneral::CharacterDataLoadResult(Err(
1110                                            error.to_string()
1111                                        )),
1112                                    );
1113
1114                                    // Clean up the entity data on the server
1115                                    self.state.emit_event_now(ExitIngameEvent {
1116                                        entity: response.target_entity,
1117                                    })
1118                                },
1119                            }
1120                        },
1121                    }
1122                },
1123            });
1124
1125        drop(character_loader);
1126        drop(character_updater);
1127
1128        {
1129            // Check for new chunks; cancel and regenerate all chunks if the asset has been
1130            // reloaded. Note that all of these assignments are no-ops, so the
1131            // only work we do here on the fast path is perform a relaxed read on an atomic.
1132            // boolean.
1133            let index = &mut self.index;
1134            let world = &mut self.world;
1135            let ecs = self.state.ecs_mut();
1136            let slow_jobs = ecs.write_resource::<SlowJobPool>();
1137
1138            index.reload_if_changed(|index| {
1139                let mut chunk_generator = ecs.write_resource::<ChunkGenerator>();
1140                let client = ecs.read_storage::<Client>();
1141                let mut terrain = ecs.write_resource::<common::terrain::TerrainGrid>();
1142                #[cfg(feature = "worldgen")]
1143                let rtsim = ecs.read_resource::<rtsim::RtSim>();
1144                #[cfg(not(feature = "worldgen"))]
1145                let rtsim = ();
1146
1147                // Cancel all pending chunks.
1148                chunk_generator.cancel_all();
1149
1150                if client.is_empty() {
1151                    // No clients, so just clear all terrain.
1152                    terrain.clear();
1153                } else {
1154                    // There's at least one client, so regenerate all chunks.
1155                    terrain.iter().for_each(|(pos, _)| {
1156                        chunk_generator.generate_chunk(
1157                            None,
1158                            pos,
1159                            &slow_jobs,
1160                            Arc::clone(world),
1161                            &rtsim,
1162                            index.clone(),
1163                            (
1164                                *ecs.read_resource::<TimeOfDay>(),
1165                                (*ecs.read_resource::<Calendar>()).clone(),
1166                            ),
1167                        );
1168                    });
1169                }
1170            });
1171        }
1172
1173        let end_of_server_tick = Instant::now();
1174
1175        // 8) Update Metrics
1176        run_now::<sys::metrics::Sys>(self.state.ecs());
1177
1178        {
1179            // Report timing info
1180            let tick_metrics = self.state.ecs().read_resource::<TickMetrics>();
1181
1182            let tt = &tick_metrics.tick_time;
1183            tt.with_label_values(&["new connections"])
1184                .set((before_state_tick - before_new_connections).as_nanos() as i64);
1185            tt.with_label_values(&["handle server events"])
1186                .set((before_update_terrain_and_regions - before_handle_events).as_nanos() as i64);
1187            tt.with_label_values(&["update terrain and region map"])
1188                .set((before_sync - before_update_terrain_and_regions).as_nanos() as i64);
1189            tt.with_label_values(&["state"])
1190                .set((before_handle_events - before_state_tick).as_nanos() as i64);
1191            tt.with_label_values(&["world tick"])
1192                .set((before_entity_cleanup - before_world_tick).as_nanos() as i64);
1193            tt.with_label_values(&["entity cleanup"])
1194                .set((before_persistence_updates - before_entity_cleanup).as_nanos() as i64);
1195            tt.with_label_values(&["persistence_updates"])
1196                .set((end_of_server_tick - before_persistence_updates).as_nanos() as i64);
1197            for (label, duration) in state_tick_metrics.timings {
1198                tick_metrics
1199                    .state_tick_time
1200                    .with_label_values(&[label])
1201                    .set(duration.as_nanos() as i64);
1202            }
1203            tick_metrics.tick_time_hist.observe(
1204                end_of_server_tick
1205                    .duration_since(before_state_tick)
1206                    .as_secs_f64(),
1207            );
1208        }
1209
1210        // 9) Finish the tick, pass control back to the frontend.
1211
1212        Ok(frontend_events)
1213    }
1214
1215    /// Clean up the server after a tick.
1216    pub fn cleanup(&mut self) {
1217        // Cleanup the local state
1218        self.state.cleanup();
1219
1220        // Maintain persisted terrain
1221        #[cfg(feature = "persistent_world")]
1222        self.state
1223            .ecs()
1224            .try_fetch_mut::<TerrainPersistence>()
1225            .map(|mut t| t.maintain());
1226    }
1227
1228    // Run RegionMap tick to update entity region occupancy
1229    fn update_region_map(&mut self) {
1230        prof_span!("Server::update_region_map");
1231        let ecs = self.state().ecs();
1232        ecs.write_resource::<RegionMap>().tick(
1233            ecs.read_storage::<comp::Pos>(),
1234            ecs.read_storage::<comp::Vel>(),
1235            ecs.read_storage::<comp::Presence>(),
1236            ecs.entities(),
1237        );
1238    }
1239
1240    fn initialize_client(&mut self, client: connection_handler::IncomingClient) -> Entity {
1241        let entity = self
1242            .state
1243            .ecs_mut()
1244            .create_entity_synced()
1245            .with(client)
1246            .build();
1247        self.state
1248            .ecs()
1249            .read_resource::<metrics::PlayerMetrics>()
1250            .clients_connected
1251            .inc();
1252        entity
1253    }
1254
1255    /// Disconnects all clients if requested by either an admin command or
1256    /// due to a persistence transaction failure and returns the processed
1257    /// DisconnectionType
1258    fn disconnect_all_clients_if_requested(&mut self) -> Option<DisconnectType> {
1259        let mut character_updater = self.state.ecs().fetch_mut::<CharacterUpdater>();
1260
1261        let disconnect_type = self.get_disconnect_all_clients_requested(&mut character_updater);
1262        if let Some(disconnect_type) = disconnect_type {
1263            let with_persistence = disconnect_type == DisconnectType::WithPersistence;
1264            let clients = self.state.ecs().read_storage::<Client>();
1265            let entities = self.state.ecs().entities();
1266
1267            info!(
1268                "Disconnecting all clients ({} persistence) as requested",
1269                if with_persistence { "with" } else { "without" }
1270            );
1271            for (_, entity) in (&clients, &entities).join() {
1272                info!("Emitting client disconnect event for entity: {:?}", entity);
1273                if with_persistence {
1274                    self.state.emit_event_now(ClientDisconnectEvent(
1275                        entity,
1276                        comp::DisconnectReason::Kicked,
1277                    ))
1278                } else {
1279                    self.state
1280                        .emit_event_now(ClientDisconnectWithoutPersistenceEvent(entity))
1281                };
1282            }
1283
1284            self.disconnect_all_clients_requested = false;
1285        }
1286
1287        disconnect_type
1288    }
1289
1290    fn get_disconnect_all_clients_requested(
1291        &self,
1292        character_updater: &mut CharacterUpdater,
1293    ) -> Option<DisconnectType> {
1294        let without_persistence_requested = character_updater.disconnect_all_clients_requested();
1295        let with_persistence_requested = self.disconnect_all_clients_requested;
1296
1297        if without_persistence_requested {
1298            return Some(DisconnectType::WithoutPersistence);
1299        };
1300        if with_persistence_requested {
1301            return Some(DisconnectType::WithPersistence);
1302        };
1303        None
1304    }
1305
1306    /// Handle new client connections.
1307    fn handle_new_connections(&mut self, frontend_events: &mut Vec<Event>) {
1308        while let Ok(sender) = self.connection_handler.info_requester_receiver.try_recv() {
1309            // can fail, e.g. due to timeout or network prob.
1310            trace!("sending info to connection_handler");
1311            let _ = sender.send(connection_handler::ServerInfoPacket {
1312                info: self.get_server_info(),
1313                time: self.state.get_time(),
1314            });
1315        }
1316
1317        while let Ok(incoming) = self.connection_handler.client_receiver.try_recv() {
1318            let entity = self.initialize_client(incoming);
1319            frontend_events.push(Event::ClientConnected { entity });
1320        }
1321    }
1322
1323    pub fn notify_client<S>(&self, entity: EcsEntity, msg: S)
1324    where
1325        S: Into<ServerMsg>,
1326    {
1327        if let Some(client) = self.state.ecs().read_storage::<Client>().get(entity) {
1328            client.send_fallible(msg);
1329        }
1330    }
1331
1332    pub fn notify_players(&mut self, msg: ServerGeneral) { self.state.notify_players(msg); }
1333
1334    pub fn generate_chunk(&mut self, entity: EcsEntity, key: Vec2<i32>) {
1335        let ecs = self.state.ecs();
1336        let slow_jobs = ecs.read_resource::<SlowJobPool>();
1337        #[cfg(feature = "worldgen")]
1338        let rtsim = ecs.read_resource::<rtsim::RtSim>();
1339        #[cfg(not(feature = "worldgen"))]
1340        let rtsim = ();
1341        ecs.write_resource::<ChunkGenerator>().generate_chunk(
1342            Some(entity),
1343            key,
1344            &slow_jobs,
1345            Arc::clone(&self.world),
1346            &rtsim,
1347            self.index.clone(),
1348            (
1349                *ecs.read_resource::<TimeOfDay>(),
1350                (*ecs.read_resource::<Calendar>()).clone(),
1351            ),
1352        );
1353    }
1354
1355    fn process_command(&mut self, entity: EcsEntity, name: String, args: Vec<String>) {
1356        // Find the command object and run its handler.
1357        if let Ok(command) = name.parse::<ServerChatCommand>() {
1358            command.execute(self, entity, args);
1359        } else {
1360            #[cfg(feature = "plugins")]
1361            {
1362                let mut plugin_manager = self.state.ecs().write_resource::<PluginMgr>();
1363                let ecs_world = EcsWorld {
1364                    entities: &self.state.ecs().entities(),
1365                    health: self.state.ecs().read_component().into(),
1366                    uid: self.state.ecs().read_component().into(),
1367                    id_maps: &self.state.ecs().read_resource::<IdMaps>().into(),
1368                    player: self.state.ecs().read_component().into(),
1369                };
1370                let uid = if let Some(uid) = ecs_world.uid.get(entity).copied() {
1371                    uid
1372                } else {
1373                    self.notify_client(
1374                        entity,
1375                        ServerGeneral::server_msg(
1376                            comp::ChatType::CommandError,
1377                            common::comp::Content::Plain(
1378                                "Can't get player UUID (player may be disconnected?)".to_string(),
1379                            ),
1380                        ),
1381                    );
1382                    return;
1383                };
1384                match plugin_manager.command_event(&ecs_world, &name, args.as_slice(), uid) {
1385                    Err(common_state::plugin::CommandResults::UnknownCommand) => self
1386                        .notify_client(
1387                            entity,
1388                            ServerGeneral::server_msg(
1389                                comp::ChatType::CommandError,
1390                                common::comp::Content::Plain(format!(
1391                                    "Unknown command '/{name}'.\nType '/help' for available \
1392                                     commands",
1393                                )),
1394                            ),
1395                        ),
1396                    Ok(value) => {
1397                        self.notify_client(
1398                            entity,
1399                            ServerGeneral::server_msg(
1400                                comp::ChatType::CommandInfo,
1401                                common::comp::Content::Plain(value.join("\n")),
1402                            ),
1403                        );
1404                    },
1405                    Err(common_state::plugin::CommandResults::PluginError(err)) => {
1406                        self.notify_client(
1407                            entity,
1408                            ServerGeneral::server_msg(
1409                                comp::ChatType::CommandError,
1410                                common::comp::Content::Plain(format!(
1411                                    "Error occurred while executing command '/{name}'.\n{err}"
1412                                )),
1413                            ),
1414                        );
1415                    },
1416                    Err(common_state::plugin::CommandResults::HostError(err)) => {
1417                        error!(?err, ?name, ?args, "Can't execute command");
1418                        self.notify_client(
1419                            entity,
1420                            ServerGeneral::server_msg(
1421                                comp::ChatType::CommandError,
1422                                common::comp::Content::Plain(format!(
1423                                    "Internal error {err:?} while executing '/{name}'.\nContact \
1424                                     the server administrator",
1425                                )),
1426                            ),
1427                        );
1428                    },
1429                }
1430            }
1431        }
1432    }
1433
1434    fn entity_admin_role(&self, entity: EcsEntity) -> Option<comp::AdminRole> {
1435        self.state
1436            .read_component_copied::<comp::Admin>(entity)
1437            .map(|admin| admin.0)
1438    }
1439
1440    pub fn number_of_players(&self) -> i64 {
1441        self.state.ecs().read_storage::<Client>().join().count() as i64
1442    }
1443
1444    /// NOTE: Do *not* allow this to be called from any command that doesn't go
1445    /// through the CLI!
1446    pub fn add_admin(&mut self, username: &str, role: comp::AdminRole) {
1447        let mut editable_settings = self.editable_settings_mut();
1448        let login_provider = self.state.ecs().fetch::<LoginProvider>();
1449        let data_dir = self.data_dir();
1450        if let Some(entity) = add_admin(
1451            username,
1452            role,
1453            &login_provider,
1454            &mut editable_settings,
1455            &data_dir.path,
1456        )
1457        .and_then(|uuid| {
1458            let state = &self.state;
1459            (
1460                &state.ecs().entities(),
1461                &state.read_storage::<comp::Player>(),
1462            )
1463                .join()
1464                .find(|(_, player)| player.uuid() == uuid)
1465                .map(|(e, _)| e)
1466        }) {
1467            drop((data_dir, login_provider, editable_settings));
1468            // Add admin component if the player is ingame; if they are not, we can ignore
1469            // the write failure.
1470            self.state
1471                .write_component_ignore_entity_dead(entity, comp::Admin(role));
1472        };
1473    }
1474
1475    /// NOTE: Do *not* allow this to be called from any command that doesn't go
1476    /// through the CLI!
1477    pub fn remove_admin(&self, username: &str) {
1478        let mut editable_settings = self.editable_settings_mut();
1479        let login_provider = self.state.ecs().fetch::<LoginProvider>();
1480        let data_dir = self.data_dir();
1481        if let Some(entity) = remove_admin(
1482            username,
1483            &login_provider,
1484            &mut editable_settings,
1485            &data_dir.path,
1486        )
1487        .and_then(|uuid| {
1488            let state = &self.state;
1489            (
1490                &state.ecs().entities(),
1491                &state.read_storage::<comp::Player>(),
1492            )
1493                .join()
1494                .find(|(_, player)| player.uuid() == uuid)
1495                .map(|(e, _)| e)
1496        }) {
1497            // Remove admin component if the player is ingame
1498            self.state
1499                .ecs()
1500                .write_storage::<comp::Admin>()
1501                .remove(entity);
1502        };
1503    }
1504
1505    /// Useful for testing without a client
1506    /// view_distance: distance in chunks that are persisted, this acts like the
1507    /// player view distance so it is actually a bit farther due to a buffer
1508    /// zone
1509    #[cfg(feature = "worldgen")]
1510    pub fn create_centered_persister(&mut self, view_distance: u32) {
1511        let world_dims_chunks = self.world.sim().get_size();
1512        let world_dims_blocks = TerrainChunkSize::blocks(world_dims_chunks);
1513        // NOTE: origin is in the corner of the map
1514        // TODO: extend this function to have picking a random position or specifying a
1515        // position as options
1516        //let mut rng = rand::thread_rng();
1517        // // Pick a random position but not to close to the edge
1518        // let rand_pos = world_dims_blocks.map(|e| e as i32).map(|e| e / 2 +
1519        // rng.gen_range(-e/2..e/2 + 1));
1520        let pos = comp::Pos(Vec3::from(world_dims_blocks.map(|e| e as f32 / 2.0)));
1521        self.state
1522            .create_persister(pos, view_distance, &self.world, &self.index)
1523            .build();
1524    }
1525
1526    /// Used by benchmarking code.
1527    pub fn chunks_pending(&mut self) -> bool {
1528        self.state_mut()
1529            .mut_resource::<ChunkGenerator>()
1530            .pending_chunks()
1531            .next()
1532            .is_some()
1533    }
1534
1535    /// Sets the SQL log mode at runtime
1536    pub fn set_sql_log_mode(&mut self, sql_log_mode: SqlLogMode) {
1537        // Unwrap is safe here because we only perform a variable assignment with the
1538        // RwLock taken meaning that no panic can occur that would cause the
1539        // RwLock to become poisoned. This justification also means that calling
1540        // unwrap() on the associated read() calls for this RwLock is also safe
1541        // as long as no code that can panic is introduced here.
1542        let mut database_settings = self.database_settings.write().unwrap();
1543        database_settings.sql_log_mode = sql_log_mode;
1544        // Drop the RwLockWriteGuard to avoid performing unnecessary actions (logging)
1545        // with the lock taken.
1546        drop(database_settings);
1547        info!("SQL log mode changed to {:?}", sql_log_mode);
1548    }
1549
1550    pub fn disconnect_all_clients(&mut self) {
1551        info!("Disconnecting all clients due to local console command");
1552        self.disconnect_all_clients_requested = true;
1553    }
1554}
1555
1556impl Drop for Server {
1557    fn drop(&mut self) {
1558        self.state
1559            .notify_players(ServerGeneral::Disconnect(DisconnectReason::Shutdown));
1560
1561        #[cfg(feature = "persistent_world")]
1562        self.state
1563            .ecs()
1564            .try_fetch_mut::<TerrainPersistence>()
1565            .map(|mut terrain_persistence| {
1566                info!("Unloading terrain persistence...");
1567                terrain_persistence.unload_all()
1568            });
1569
1570        #[cfg(feature = "worldgen")]
1571        {
1572            debug!("Saving rtsim state...");
1573            self.state.ecs().write_resource::<rtsim::RtSim>().save(true);
1574        }
1575    }
1576}
1577
1578#[must_use]
1579pub fn handle_edit<T, S: settings::EditableSetting>(
1580    data: T,
1581    result: Option<(String, Result<(), settings::SettingError<S>>)>,
1582) -> Option<T> {
1583    use crate::settings::SettingError;
1584    let (info, result) = result?;
1585    match result {
1586        Ok(()) => {
1587            info!("{}", info);
1588            Some(data)
1589        },
1590        Err(SettingError::Io(err)) => {
1591            warn!(
1592                ?err,
1593                "Failed to write settings file to disk, but succeeded in memory (success message: \
1594                 {})",
1595                info,
1596            );
1597            Some(data)
1598        },
1599        Err(SettingError::Integrity(err)) => {
1600            error!(?err, "Encountered an error while validating the request",);
1601            None
1602        },
1603    }
1604}
1605
1606/// If successful returns the Some(uuid) of the added admin
1607///
1608/// NOTE: Do *not* allow this to be called from any command that doesn't go
1609/// through the CLI!
1610#[must_use]
1611pub fn add_admin(
1612    username: &str,
1613    role: comp::AdminRole,
1614    login_provider: &LoginProvider,
1615    editable_settings: &mut EditableSettings,
1616    data_dir: &std::path::Path,
1617) -> Option<common::uuid::Uuid> {
1618    use crate::settings::EditableSetting;
1619    let role_ = role.into();
1620    match login_provider.username_to_uuid(username) {
1621        Ok(uuid) => handle_edit(
1622            uuid,
1623            editable_settings.admins.edit(data_dir, |admins| {
1624                match admins.insert(uuid, settings::AdminRecord {
1625                    username_when_admined: Some(username.into()),
1626                    date: chrono::Utc::now(),
1627                    role: role_,
1628                }) {
1629                    None => Some(format!(
1630                        "Successfully added {} ({}) as {:?}!",
1631                        username, uuid, role
1632                    )),
1633                    Some(old_admin) if old_admin.role == role_ => {
1634                        info!("{} ({}) already has role: {:?}!", username, uuid, role);
1635                        None
1636                    },
1637                    Some(old_admin) => Some(format!(
1638                        "{} ({}) role changed from {:?} to {:?}!",
1639                        username, uuid, old_admin.role, role
1640                    )),
1641                }
1642            }),
1643        ),
1644        Err(err) => {
1645            error!(
1646                ?err,
1647                "Could not find uuid for this name; either the user does not exist or there was \
1648                 an error communicating with the auth server."
1649            );
1650            None
1651        },
1652    }
1653}
1654
1655/// If successful returns the Some(uuid) of the removed admin
1656///
1657/// NOTE: Do *not* allow this to be called from any command that doesn't go
1658/// through the CLI!
1659#[must_use]
1660pub fn remove_admin(
1661    username: &str,
1662    login_provider: &LoginProvider,
1663    editable_settings: &mut EditableSettings,
1664    data_dir: &std::path::Path,
1665) -> Option<common::uuid::Uuid> {
1666    use crate::settings::EditableSetting;
1667    match login_provider.username_to_uuid(username) {
1668        Ok(uuid) => handle_edit(
1669            uuid,
1670            editable_settings.admins.edit(data_dir, |admins| {
1671                if let Some(admin) = admins.remove(&uuid) {
1672                    Some(format!(
1673                        "Successfully removed {} ({}) with role {:?} from the admins list",
1674                        username, uuid, admin.role,
1675                    ))
1676                } else {
1677                    info!("{} ({}) is not an admin!", username, uuid);
1678                    None
1679                }
1680            }),
1681        ),
1682        Err(err) => {
1683            error!(
1684                ?err,
1685                "Could not find uuid for this name; either the user does not exist or there was \
1686                 an error communicating with the auth server."
1687            );
1688            None
1689        },
1690    }
1691}