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, 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
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 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
151/// Number of seconds a player must wait before they can change their battle
152/// mode after each change.
153///
154/// TODO: Discuss time
155const BATTLE_MODE_COOLDOWN: f64 = 60.0 * 5.0;
156
157/// SpawnPoint corresponds to the default location that players are positioned
158/// at if they have no waypoint. Players *should* always have a waypoint, so
159/// this should basically never be used in practice.
160#[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
167// This is the minimum chunk range that is kept loaded around each player
168// server-side. This is independent of the client's view distance and exists to
169// avoid exploits such as small view distance chunk reloading and also to keep
170// various mechanics working fluidly (i.e: not unloading nearby entities).
171pub const MIN_VD: u32 = 6;
172
173// Tick count used for throttling network updates
174// Note this doesn't account for dt (so update rate changes with tick rate)
175#[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// Start of Tick, used for metrics
191#[derive(Copy, Clone)]
192pub struct TickStart(Instant);
193
194/// Store of BattleMode cooldowns for players while they go offline
195#[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
214/// Keeps the IPs of recently logged off clients in memory, only used
215/// for IP bans if the target is no longer online.
216pub 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    /// Create a new `Server`
260    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        // Run pending DB migrations (if any)
276        debug!("Running DB migrations...");
277        persistence::run_migrations(&database_settings);
278
279        report_stage(ServerInitStage::DbVacuum);
280        // Vacuum database
281        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(&registry).unwrap();
288        let job_metrics = metrics::JobMetrics::new(&registry).unwrap();
289        let network_request_metrics = metrics::NetworkRequestMetrics::new(&registry).unwrap();
290        let player_metrics = metrics::PlayerMetrics::new(&registry).unwrap();
291        let ecs_system_metrics = EcsSystemMetrics::new(&registry).unwrap();
292        let tick_metrics = TickMetrics::new(&registry).unwrap();
293        let physics_metrics = PhysicsMetrics::new(&registry).unwrap();
294        let server_event_metrics = metrics::ServerEventMetrics::new(&registry).unwrap();
295        let query_server_metrics = metrics::QueryServerMetrics::new(&registry).unwrap();
296
297        let battlemode_buffer = BattleModeBuffer::default();
298
299        let pools = State::pools(GameMode::Server);
300
301        // Load plugins before generating the world.
302        #[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                    // Load default map from assets.
315                    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        // System schedulers to control execution of systems
460        state
461            .ecs_mut()
462            .insert(sys::PersistenceScheduler::every(Duration::from_secs(10)));
463
464        // Region map (spatial structure for entity synchronization)
465        state.ecs_mut().insert(RegionMap::new());
466
467        // Server-only components
468        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        // Load banned words list
480        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        // Init automod
485        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            // NOTE: all of these `.map(|e| e as [type])` calls should compile into no-ops,
495            // but are needed to be explicit about casting (and to make the compiler stop
496            // complaining)
497
498            // Search for town defined by spawn_town server setting. If this fails, or is
499            // None, set spawn to the nearest town to the centre of the world
500            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        // Set the spawn point we calculated above
515        state.ecs_mut().insert(spawn_point);
516
517        // Insert a default AABB for the world
518        // TODO: prevent this from being deleted
519        {
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        // Insert the world into the ECS (todo: Maybe not an Arc?)
540        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        // Set starting time for the server.
546        state.ecs_mut().write_resource::<TimeOfDay>().0 = settings.world.start_time;
547
548        // Register trackers
549        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, &registry);
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        // Init rtsim, loading it from disk if possible
667        #[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    /// Get a reference to the server's settings
726    pub fn settings(&self) -> impl Deref<Target = Settings> + '_ {
727        self.state.ecs().fetch::<Settings>()
728    }
729
730    /// Get a mutable reference to the server's settings
731    pub fn settings_mut(&self) -> impl DerefMut<Target = Settings> + '_ {
732        self.state.ecs().fetch_mut::<Settings>()
733    }
734
735    /// Get a mutable reference to the server's editable settings
736    pub fn editable_settings_mut(&self) -> impl DerefMut<Target = EditableSettings> + '_ {
737        self.state.ecs().fetch_mut::<EditableSettings>()
738    }
739
740    /// Get a reference to the server's editable settings
741    pub fn editable_settings(&self) -> impl Deref<Target = EditableSettings> + '_ {
742        self.state.ecs().fetch::<EditableSettings>()
743    }
744
745    /// Get path to the directory that the server info into
746    pub fn data_dir(&self) -> impl Deref<Target = DataDir> + '_ {
747        self.state.ecs().fetch::<DataDir>()
748    }
749
750    /// Get a reference to the server's game state.
751    pub fn state(&self) -> &State { &self.state }
752
753    /// Get a mutable reference to the server's game state.
754    pub fn state_mut(&mut self) -> &mut State { &mut self.state }
755
756    /// Get a reference to the server's world.
757    pub fn world(&self) -> &World { &self.world }
758
759    /// Get a reference to the Metrics Registry
760    pub fn metrics_registry(&self) -> &Arc<Registry> { &self.metrics_registry }
761
762    /// Get a reference to the Chat Cache
763    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    /// Execute a single server tick, handle input and update the game state by
784    /// the given duration.
785    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        // Update calendar events as time changes
790        // TODO: If a lot of calendar events get added, this might become expensive.
791        // Maybe don't do this every tick?
792        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        // This tick function is the centre of the Veloren universe. Most server-side
801        // things are managed from here, and as such it's important that it
802        // stays organised. Please consult the core developers before making
803        // significant changes to this code. Here is the approximate order of
804        // things. Please update it as this code changes.
805        //
806        // 1) Collect input from the frontend, apply input effects to the state of the
807        //    game
808        // 2) Go through any events (timer-driven or otherwise) that need handling and
809        //    apply them to the state of the game
810        // 3) Go through all incoming client network communications, apply them to the
811        //    game state
812        // 4) Perform a single LocalState tick (i.e: update the world and entities in
813        //    the world)
814        // 5) Go through the terrain update queue and apply all changes to the terrain
815        // 6) Send relevant state updates to all clients
816        // 7) Check for persistence updates related to character data, and message the
817        //    relevant entities
818        // 8) Update Metrics with current data
819        // 9) Finish the tick, passing control of the main thread back to the frontend
820
821        // 1) Build up a list of events for this frame, to be passed to the frontend.
822        let mut frontend_events = Vec::new();
823
824        // 2)
825
826        let before_new_connections = Instant::now();
827
828        // 3) Handle inputs from clients
829        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            // When a resource block updates, inform rtsim
835            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        // 4) Tick the server's LocalState.
848        // 5) Fetch any generated `TerrainChunk`s and insert them into the terrain.
849        // in sys/terrain.rs
850        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        // Process any pending request to disconnect all clients, the disconnections
863        // will be processed once handle_events() is called below
864        let disconnect_type = self.disconnect_all_clients_if_requested();
865
866        // Handle entity links (such as mounting)
867        self.state.maintain_links();
868
869        // Handle game events
870        frontend_events.append(&mut self.handle_events());
871
872        let before_update_terrain_and_regions = Instant::now();
873
874        // Apply terrain changes and update the region map after processing server
875        // events so that changes made by server events will be immediately
876        // visible to client synchronization systems, minimizing the latency of
877        // `ServerEvent` mediated effects
878        self.update_region_map();
879        // NOTE: apply_terrain_changes sends the *new* value since it is not being
880        // synchronized during the tick.
881        self.state.apply_terrain_changes(on_block_update);
882
883        let before_sync = Instant::now();
884
885        // 6) Synchronise clients with the new state of the world.
886        sys::run_sync_systems(self.state.ecs_mut());
887
888        let before_world_tick = Instant::now();
889
890        // Tick the world
891        self.world.tick(dt);
892
893        let before_entity_cleanup = Instant::now();
894
895        // In the event of a request to disconnect all players without persistence, we
896        // must run the terrain system a second time after the messages to
897        // perform client disconnections have been processed. This ensures that any
898        // items on the ground are deleted.
899        if let Some(DisconnectType::WithoutPersistence) = disconnect_type {
900            run_now::<terrain::Sys>(self.state.ecs_mut());
901        }
902
903        // Hook rtsim chunk unloads
904        #[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        // Prevent anchor entity chains which are not currently supported due to:
914        // * potential cycles?
915        // * unloading a chain could occur across an unbounded number of ticks with the
916        //   current implementation.
917        // * in particular, we want to be able to unload all entities in a
918        //   limited number of ticks when a database error occurs and kicks all
919        //   players (not quiet sure on exact time frame, since it already
920        //   takes a tick after unloading all chunks for entities to despawn?),
921        //   see this thread and the discussion linked from there:
922        //   https://gitlab.com/veloren/veloren/-/merge_requests/2668#note_634913847
923        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            // We allow Anchor::Entity(_) -> Anchor::Chunk(_) connections, since they can't chain further.
934            //
935            // NOTE: The entity with `Anchor::Entity` will unload one tick after the entity with `Anchor::Chunk`.
936            .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        // Remove NPCs that are outside the view distances of all players
955        // This is done by removing NPCs in unloaded chunks
956        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                            // Check if both this chunk and the NPCs `home_chunk` is unloaded. If
987                            // so, we delete them. We check for
988                            // `home_chunk` in order to avoid duplicating
989                            // the entity under some circumstances.
990                            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        // Actually perform entity deletion
1013        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        // 7 Persistence updates
1031        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        // Get character-related database responses and notify the requesting client
1039        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                                    // TODO: Does this need to be a server event? E.g. we could
1121                                    // just handle it here.
1122                                    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                                    // We failed to load data for the character from the DB. Notify
1130                                    // the client to push the state back to character selection,
1131                                    // with the error to display
1132                                    self.notify_client(
1133                                        response.target_entity,
1134                                        ServerGeneral::CharacterDataLoadResult(Err(
1135                                            error.to_string()
1136                                        )),
1137                                    );
1138
1139                                    // Clean up the entity data on the server
1140                                    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            // Check for new chunks; cancel and regenerate all chunks if the asset has been
1155            // reloaded. Note that all of these assignments are no-ops, so the
1156            // only work we do here on the fast path is perform a relaxed read on an atomic.
1157            // boolean.
1158            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                // Cancel all pending chunks.
1173                chunk_generator.cancel_all();
1174
1175                if client.is_empty() {
1176                    // No clients, so just clear all terrain.
1177                    terrain.clear();
1178                } else {
1179                    // There's at least one client, so regenerate all chunks.
1180                    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        // 8) Update Metrics
1201        run_now::<sys::metrics::Sys>(self.state.ecs());
1202
1203        {
1204            // Report timing info
1205            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        // 9) Finish the tick, pass control back to the frontend.
1236
1237        Ok(frontend_events)
1238    }
1239
1240    /// Clean up the server after a tick.
1241    pub fn cleanup(&mut self) {
1242        // Cleanup the local state
1243        self.state.cleanup();
1244
1245        // Maintain persisted terrain
1246        #[cfg(feature = "persistent_world")]
1247        self.state
1248            .ecs()
1249            .try_fetch_mut::<TerrainPersistence>()
1250            .map(|mut t| t.maintain());
1251    }
1252
1253    // Run RegionMap tick to update entity region occupancy
1254    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    /// Disconnects all clients if requested by either an admin command or
1281    /// due to a persistence transaction failure and returns the processed
1282    /// DisconnectionType
1283    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    /// Handle new client connections.
1332    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            // can fail, e.g. due to timeout or network prob.
1335            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        // Find the command object and run its handler.
1382        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    /// NOTE: Do *not* allow this to be called from any command that doesn't go
1470    /// through the CLI!
1471    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            // Add admin component if the player is ingame; if they are not, we can ignore
1494            // the write failure.
1495            self.state
1496                .write_component_ignore_entity_dead(entity, comp::Admin(role));
1497        };
1498    }
1499
1500    /// NOTE: Do *not* allow this to be called from any command that doesn't go
1501    /// through the CLI!
1502    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            // Remove admin component if the player is ingame
1523            self.state
1524                .ecs()
1525                .write_storage::<comp::Admin>()
1526                .remove(entity);
1527        };
1528    }
1529
1530    /// Useful for testing without a client
1531    /// view_distance: distance in chunks that are persisted, this acts like the
1532    /// player view distance so it is actually a bit farther due to a buffer
1533    /// zone
1534    #[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        // NOTE: origin is in the corner of the map
1539        // TODO: extend this function to have picking a random position or specifying a
1540        // position as options
1541        //let mut rng = rand::rng();
1542        // // Pick a random position but not to close to the edge
1543        // let rand_pos = world_dims_blocks.map(|e| e as i32).map(|e| e / 2 +
1544        // rng.random_range(-e/2..e/2 + 1));
1545        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    /// Used by benchmarking code.
1552    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    /// Sets the SQL log mode at runtime
1561    pub fn set_sql_log_mode(&mut self, sql_log_mode: SqlLogMode) {
1562        // Unwrap is safe here because we only perform a variable assignment with the
1563        // RwLock taken meaning that no panic can occur that would cause the
1564        // RwLock to become poisoned. This justification also means that calling
1565        // unwrap() on the associated read() calls for this RwLock is also safe
1566        // as long as no code that can panic is introduced here.
1567        let mut database_settings = self.database_settings.write().unwrap();
1568        database_settings.sql_log_mode = sql_log_mode;
1569        // Drop the RwLockWriteGuard to avoid performing unnecessary actions (logging)
1570        // with the lock taken.
1571        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    /// Sends the given client a message with their current battle mode and
1581    /// whether they can change it.
1582    ///
1583    /// This function expects the `EcsEntity` to represent a player, otherwise
1584    /// it will log an error.
1585    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(&notice);
1623            }
1624        }
1625
1626        self.notify_client(
1627            client,
1628            ServerGeneral::server_msg(ChatType::CommandInfo, Content::Plain(msg)),
1629        );
1630    }
1631
1632    /// Sets the battle mode for the given client or informs them if they are
1633    /// not allowed to change it.
1634    ///
1635    /// This function expects the `EcsEntity` to represent a player, otherwise
1636    /// it will log an error.
1637    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                // empirical
1682                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/// If successful returns the Some(uuid) of the added admin
1822///
1823/// NOTE: Do *not* allow this to be called from any command that doesn't go
1824/// through the CLI!
1825#[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/// If successful returns the Some(uuid) of the removed admin
1871///
1872/// NOTE: Do *not* allow this to be called from any command that doesn't go
1873/// through the CLI!
1874#[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}