1pub(crate) mod client_init;
2mod ui;
3
4use super::{char_selection::CharSelectionState, dummy_scene::Scene, server_info::ServerInfoState};
5#[cfg(feature = "singleplayer")]
6use crate::singleplayer::SingleplayerState;
7use crate::{
8 Direction, GlobalState, PlayState, PlayStateResult, hud,
9 render::{Drawer, GlobalsBindGroup},
10 session::SessionState,
11 settings::Settings,
12 window::Event,
13};
14use chrono::{DateTime, Local, Utc};
15use client::{
16 Client, ClientInitStage, ServerInfo,
17 addr::ConnectionArgs,
18 error::{InitProtocolError, NetworkConnectError, NetworkError},
19};
20use client_init::{ClientInit, Error as InitError, Msg as InitMsg};
21use common::{comp, event::UpdateCharacterMetadata};
22use common_base::span;
23use common_net::msg::ClientType;
24#[cfg(feature = "plugins")]
25use common_state::plugin::PluginMgr;
26use i18n::{LocalizationGuard, LocalizationHandle, fluent_args};
27#[cfg(feature = "singleplayer")]
28use server::ServerInitStage;
29#[cfg(any(feature = "singleplayer", feature = "plugins"))]
30use specs::WorldExt;
31use std::{cell::RefCell, path::Path, rc::Rc, sync::Arc};
32use tokio::runtime;
33use tracing::error;
34use ui::{Event as MainMenuEvent, MainMenuUi};
35
36pub use ui::rand_bg_image_spec;
37
38#[derive(Debug)]
39pub enum DetailedInitializationStage {
40 #[cfg(feature = "singleplayer")]
41 Singleplayer,
42 #[cfg(feature = "singleplayer")]
43 SingleplayerServer(ServerInitStage),
44 StartingMultiplayer,
45 Client(ClientInitStage),
46 CreatingRenderPipeline(usize, usize),
47}
48
49enum InitState {
50 None,
51 Client(ClientInit),
53 Pipeline(Box<Client>, hud::MessageBacklog),
55}
56
57impl InitState {
58 fn client(&self) -> Option<&ClientInit> {
59 if let Self::Client(client_init) = &self {
60 Some(client_init)
61 } else {
62 None
63 }
64 }
65}
66
67pub struct MainMenuState {
68 main_menu_ui: MainMenuUi,
69 init: InitState,
70 scene: Scene,
71}
72
73impl MainMenuState {
74 pub fn new(global_state: &mut GlobalState) -> Self {
76 Self {
77 main_menu_ui: MainMenuUi::new(global_state),
78 init: InitState::None,
79 scene: Scene::new(global_state.window.renderer_mut()),
80 }
81 }
82}
83
84impl PlayState for MainMenuState {
85 fn enter(&mut self, global_state: &mut GlobalState, _: Direction) {
86 if global_state.settings.audio.output.is_enabled() && global_state.audio.music_enabled() {
88 global_state.audio.play_title_music();
89 }
90
91 #[cfg(feature = "singleplayer")]
93 {
94 global_state.singleplayer = SingleplayerState::None;
95 }
96
97 self.main_menu_ui
99 .update_language(global_state.i18n, &global_state.settings);
100 self.main_menu_ui
102 .set_scale_mode(global_state.settings.interface.ui_scale);
103
104 #[cfg(feature = "discord")]
105 global_state.discord.enter_main_menu();
106 }
107
108 fn tick(&mut self, global_state: &mut GlobalState, events: Vec<Event>) -> PlayStateResult {
109 span!(_guard, "tick", "<MainMenuState as PlayState>::tick");
110
111 let localized_strings = &global_state.i18n.read();
113
114 #[cfg(feature = "singleplayer")]
116 {
117 if let Some(singleplayer) = global_state.singleplayer.as_running() {
118 if let Ok(stage_update) = singleplayer.init_stage_receiver.try_recv() {
119 self.main_menu_ui.update_stage(
120 DetailedInitializationStage::SingleplayerServer(stage_update),
121 );
122 }
123
124 match singleplayer.receiver.try_recv() {
125 Ok(Ok(())) => {
126 attempt_login(
128 &mut global_state.info_message,
129 "singleplayer".to_owned(),
130 "".to_owned(),
131 ConnectionArgs::Mpsc(14004),
132 &mut self.init,
133 &global_state.tokio_runtime,
134 global_state.settings.language.send_to_server.then_some(
135 global_state.settings.language.selected_language.clone(),
136 ),
137 &global_state.i18n,
138 &global_state.config_dir,
139 global_state.args.client_type.0,
140 );
141 },
142 Ok(Err(e)) => {
143 error!(?e, "Could not start server");
144 global_state.singleplayer = SingleplayerState::None;
145 self.init = InitState::None;
146 self.main_menu_ui.cancel_connection();
147 let server_err = match e {
148 server::Error::NetworkErr(e) => localized_strings
149 .get_msg_ctx("main-servers-network_error", &i18n::fluent_args! {
150 "raw_error" => e.to_string()
151 })
152 .into_owned(),
153 server::Error::ParticipantErr(e) => localized_strings
154 .get_msg_ctx(
155 "main-servers-participant_error",
156 &i18n::fluent_args! {
157 "raw_error" => e.to_string()
158 },
159 )
160 .into_owned(),
161 server::Error::StreamErr(e) => localized_strings
162 .get_msg_ctx("main-servers-stream_error", &i18n::fluent_args! {
163 "raw_error" => e.to_string()
164 })
165 .into_owned(),
166 server::Error::DatabaseErr(e) => localized_strings
167 .get_msg_ctx("main-servers-database_error", &i18n::fluent_args! {
168 "raw_error" => e.to_string()
169 })
170 .into_owned(),
171 server::Error::PersistenceErr(e) => localized_strings
172 .get_msg_ctx(
173 "main-servers-persistence_error",
174 &i18n::fluent_args! {
175 "raw_error" => e.to_string()
176 },
177 )
178 .into_owned(),
179 server::Error::RtsimError(e) => localized_strings
180 .get_msg_ctx("main-servers-rtsim_error", &i18n::fluent_args! {
181 "raw_error" => e.to_string(),
182 })
183 .into_owned(),
184 server::Error::Other(e) => localized_strings
185 .get_msg_ctx("main-servers-other_error", &i18n::fluent_args! {
186 "raw_error" => e,
187 })
188 .into_owned(),
189 };
190 global_state.info_message = Some(
191 localized_strings
192 .get_msg_ctx(
193 "main-servers-singleplayer_error",
194 &i18n::fluent_args! {
195 "sp_error" => server_err
196 },
197 )
198 .into_owned(),
199 );
200 },
201 Err(_) => (),
202 }
203 }
204 }
205 for event in events {
207 if self.main_menu_ui.handle_event(event.clone()) {
209 continue;
210 }
211
212 match event {
213 Event::Close => return PlayStateResult::Shutdown,
214 _ => {},
216 }
217 }
218
219 if let Some(client_stage_update) = self.init.client().and_then(|init| init.stage_update()) {
220 self.main_menu_ui
221 .update_stage(DetailedInitializationStage::Client(client_stage_update));
222 }
223
224 match self.init.client().and_then(|init| init.poll()) {
226 Some(InitMsg::Done(Ok(mut client))) => {
227 #[cfg(feature = "plugins")]
229 for path in client.take_local_plugins().drain(..) {
230 if let Err(e) = client
231 .state_mut()
232 .ecs_mut()
233 .write_resource::<PluginMgr>()
234 .load_server_plugin(path)
235 {
236 tracing::error!(?e, "load local plugin");
237 }
238 }
239 crate::ecs::init(client.state_mut().ecs_mut());
241 self.init = InitState::Pipeline(Box::new(client), hud::MessageBacklog::default());
242 },
243 Some(InitMsg::Done(Err(e))) => {
244 self.init = InitState::None;
245 error!(?e, "Client Init failed raw error");
246 let e = get_client_init_msg_error(e, &global_state.i18n);
247 error!(?e, "Client Init failed");
250 global_state.info_message = Some(
251 localized_strings
252 .get_msg_ctx("main-login-client_init_failed", &i18n::fluent_args! {
253 "init_fail_reason" => e
254 })
255 .into_owned(),
256 );
257 },
258 Some(InitMsg::IsAuthTrusted(auth_server)) => {
259 if global_state
260 .settings
261 .networking
262 .trusted_auth_servers
263 .contains(&auth_server)
264 {
265 self.init.client().unwrap().auth_trust(auth_server, true);
267 } else {
268 self.main_menu_ui.auth_trust_prompt(auth_server);
270 }
271 },
272 None => {},
273 }
274
275 if let InitState::Pipeline(client, _) = &mut self.init {
277 match client.tick(comp::ControllerInputs::default(), global_state.clock.dt()) {
278 Ok(events) => {
279 for event in events {
280 match event {
281 client::Event::SetViewDistance(_vd) => {},
282 client::Event::Disconnect => {
283 global_state.info_message = Some(
284 localized_strings
285 .get_msg("main-login-server_shut_down")
286 .into_owned(),
287 );
288 self.init = InitState::None;
289 },
290 client::Event::Chat(m) => {
291 if let InitState::Pipeline(client, message_backlog) = &mut self.init
292 {
293 message_backlog.new_message(client, &global_state.profile, m)
294 }
295 },
296 #[cfg_attr(not(feature = "plugins"), expect(unused_variables))]
297 client::Event::PluginDataReceived(data) => {
298 #[cfg(feature = "plugins")]
299 {
300 tracing::info!("plugin data {}", data.len());
301 if let InitState::Pipeline(client, _) = &mut self.init {
302 let hash = client
303 .state()
304 .ecs()
305 .write_resource::<PluginMgr>()
306 .cache_server_plugin(&global_state.config_dir, data);
307 match hash {
308 Ok(hash) => {
309 if client.plugin_received(hash) == 0 {
310 client.load_character_list();
313 }
314 },
315 Err(e) => tracing::error!(?e, "cache_server_plugin"),
316 }
317 }
318 }
319 },
320 _ => {},
321 }
322 }
323 },
324 Err(err) => {
325 error!(?err, "[main menu] Failed to tick the client");
326 global_state.info_message =
327 Some(get_client_msg_error(err, None, &global_state.i18n.read()));
328 self.init = InitState::None;
329 },
330 }
331 }
332
333 if let InitState::Pipeline(..) = &self.init {
335 if let Some((done, total)) = &global_state.window.renderer().pipeline_creation_status()
336 {
337 self.main_menu_ui.update_stage(
338 DetailedInitializationStage::CreatingRenderPipeline(*done, *total),
339 );
340 } else {
342 if let InitState::Pipeline(mut client, message_backlog) =
344 core::mem::replace(&mut self.init, InitState::None)
345 {
346 self.main_menu_ui.connected();
347
348 if client.client_type().can_spectate()
351 && !client.client_type().can_enter_character()
352 {
353 client.request_spectate(global_state.settings.graphics.view_distances());
354
355 return PlayStateResult::Push(Box::new(SessionState::new(
356 global_state,
357 UpdateCharacterMetadata::default(),
358 Rc::new(RefCell::new(*client)),
359 Rc::new(RefCell::new(message_backlog)),
360 )));
361 }
362
363 let server_info = client.server_info().clone();
364 let server_description = client.server_description().clone();
365
366 let char_select = CharSelectionState::new(
367 global_state,
368 Rc::new(RefCell::new(*client)),
369 Rc::new(RefCell::new(message_backlog)),
370 );
371
372 let new_state = ServerInfoState::try_from_server_info(
373 global_state,
374 self.main_menu_ui.bg_img_spec(),
375 char_select,
376 server_info,
377 server_description,
378 false,
379 )
380 .map(|s| Box::new(s) as _)
381 .unwrap_or_else(|s| Box::new(s) as _);
382
383 return PlayStateResult::Push(new_state);
384 }
385 }
386 }
387
388 for event in self
390 .main_menu_ui
391 .maintain(global_state, global_state.clock.dt())
392 {
393 match event {
394 MainMenuEvent::LoginAttempt {
395 username,
396 password,
397 server_address,
398 } => {
399 let net_settings = &mut global_state.settings.networking;
400 let use_srv = net_settings.use_srv;
401 let use_quic = net_settings.use_quic;
402 let validate_tls = net_settings.validate_tls;
403 net_settings.username.clone_from(&username);
404 net_settings.default_server.clone_from(&server_address);
405 if !server_address.is_empty() && !net_settings.servers.contains(&server_address)
406 {
407 net_settings.servers.push(server_address.clone());
408 }
409 global_state
410 .settings
411 .save_to_file_warn(&global_state.config_dir);
412
413 let connection_args = if use_srv {
414 ConnectionArgs::Srv {
415 hostname: server_address,
416 prefer_ipv6: false,
417 validate_tls,
418 use_quic,
419 }
420 } else if use_quic {
421 ConnectionArgs::Quic {
422 hostname: server_address,
423 prefer_ipv6: false,
424 validate_tls,
425 }
426 } else {
427 ConnectionArgs::Tcp {
428 hostname: server_address,
429 prefer_ipv6: false,
430 }
431 };
432 attempt_login(
433 &mut global_state.info_message,
434 username,
435 password,
436 connection_args,
437 &mut self.init,
438 &global_state.tokio_runtime,
439 global_state
440 .settings
441 .language
442 .send_to_server
443 .then_some(global_state.settings.language.selected_language.clone()),
444 &global_state.i18n,
445 &global_state.config_dir,
446 global_state.args.client_type.0,
447 );
448 },
449 MainMenuEvent::CancelLoginAttempt => {
450 #[cfg(feature = "singleplayer")]
454 {
455 global_state.singleplayer = SingleplayerState::None;
456 }
457 self.init = InitState::None;
458 self.main_menu_ui.cancel_connection();
459 },
460 MainMenuEvent::ChangeLanguage(new_language) => {
461 global_state.settings.language.selected_language =
462 new_language.language_identifier;
463 global_state.i18n = LocalizationHandle::load_expect(
464 &global_state.settings.language.selected_language,
465 );
466 global_state
467 .i18n
468 .set_english_fallback(global_state.settings.language.use_english_fallback);
469 self.main_menu_ui
470 .update_language(global_state.i18n, &global_state.settings);
471 },
472 #[cfg(feature = "singleplayer")]
473 MainMenuEvent::StartSingleplayer => {
474 global_state.singleplayer.run(&global_state.tokio_runtime);
475 },
476 #[cfg(feature = "singleplayer")]
477 MainMenuEvent::InitSingleplayer => {
478 global_state.singleplayer = SingleplayerState::init();
479 },
480 #[cfg(feature = "singleplayer")]
481 MainMenuEvent::SinglePlayerChange(change) => {
482 if let SingleplayerState::Init(ref mut init) = global_state.singleplayer {
483 match change {
484 ui::WorldsChange::SetActive(world) => init.current = world,
485 ui::WorldsChange::Delete(world) => init.remove(world),
486 ui::WorldsChange::Regenerate(world) => init.delete_map_file(world),
487 ui::WorldsChange::AddNew => init.new_world(),
488 ui::WorldsChange::CurrentWorldChange(change) => {
489 if let Some(world) = init.current.map(|i| &mut init.worlds[i]) {
490 change.apply(world);
491 init.save_current_meta();
492 }
493 },
494 }
495 }
496 },
497 MainMenuEvent::Quit => return PlayStateResult::Shutdown,
498 MainMenuEvent::AuthServerTrust(auth_server, trust) => {
503 if trust {
504 global_state
505 .settings
506 .networking
507 .trusted_auth_servers
508 .insert(auth_server.clone());
509 global_state
510 .settings
511 .save_to_file_warn(&global_state.config_dir);
512 }
513 self.init
514 .client()
515 .map(|init| init.auth_trust(auth_server, trust));
516 },
517 MainMenuEvent::DeleteServer { server_index } => {
518 let net_settings = &mut global_state.settings.networking;
519 net_settings.servers.remove(server_index);
520
521 global_state
522 .settings
523 .save_to_file_warn(&global_state.config_dir);
524 },
525 }
526 }
527
528 if let Some(info) = global_state.info_message.take() {
529 self.main_menu_ui.show_info(info);
530 }
531
532 PlayStateResult::Continue
533 }
534
535 fn name(&self) -> &'static str { "Title" }
536
537 fn capped_fps(&self) -> bool { true }
538
539 fn globals_bind_group(&self) -> &GlobalsBindGroup { self.scene.global_bind_group() }
540
541 fn render(&self, drawer: &mut Drawer<'_>, _: &Settings) {
542 let mut third_pass = drawer.third_pass();
544 if let Some(mut ui_drawer) = third_pass.draw_ui() {
545 self.main_menu_ui.render(&mut ui_drawer);
546 };
547 }
548
549 fn egui_enabled(&self) -> bool { false }
550}
551
552pub(crate) fn get_client_msg_error(
553 error: client::Error,
554 mismatched_server_info: Option<ServerInfo>,
555 localization: &LocalizationGuard,
556) -> String {
557 let net_error = |error: String, mismatched_server_info: Option<ServerInfo>| -> String {
561 if let Some(server_info) =
562 mismatched_server_info.filter(|info| info.git_hash != *common::util::GIT_HASH)
563 {
564 format!(
565 "{} {}: {} ({}) {}: {} ({})",
566 localization.get_msg("main-login-network_wrong_version"),
567 localization.get_msg("main-login-client_version"),
568 &*common::util::GIT_HASH,
569 &*common::util::GIT_DATE,
570 localization.get_msg("main-login-server_version"),
571 server_info.git_hash,
572 server_info.git_date,
573 )
574 } else {
575 format!(
576 "{}: {}",
577 localization.get_msg("main-login-network_error"),
578 error
579 )
580 }
581 };
582
583 use client::Error;
584 match error {
585 Error::SpecsErr(e) => {
586 format!(
587 "{}: {}",
588 localization.get_msg("main-login-internal_error"),
589 e
590 )
591 },
592 Error::AuthErr(e) => format!(
593 "{}: {}",
594 localization.get_msg("main-login-authentication_error"),
595 e
596 ),
597 Error::Kicked(reason) => localization
598 .get_msg_ctx("main-login-kicked", &fluent_args! {
599 "reason" => reason,
600 })
601 .into(),
602 Error::TooManyPlayers => localization.get_msg("main-login-server_full").into(),
603 Error::AuthServerNotTrusted => localization
604 .get_msg("main-login-untrusted_auth_server")
605 .into(),
606 Error::ServerTimeout => localization.get_msg("main-login-timeout").into(),
607 Error::ServerShutdown => localization.get_msg("main-login-server_shut_down").into(),
608 Error::NotOnWhitelist => localization.get_msg("main-login-not_on_whitelist").into(),
609 Error::Banned(ban_info) => if let Some(end_time) = ban_info
610 .until
611 .and_then(|timestamp| DateTime::<Utc>::from_timestamp(timestamp, 0))
612 {
613 let end_date = end_time.with_timezone(&Local);
614 let end_date_str = end_date.format("%Y-%m-%d %H:%M").to_string();
615
616 localization.get_msg_ctx("main-login-banned_until", &fluent_args! {
617 "reason" => ban_info.reason,
618 "end_date" => end_date_str,
619 })
620 } else {
621 localization.get_msg_ctx("main-login-banned", &fluent_args! {
622 "reason" => ban_info.reason
623 })
624 }
625 .into(),
626 Error::InvalidCharacter => localization.get_msg("main-login-invalid_character").into(),
627 Error::NetworkErr(NetworkError::ConnectFailed(NetworkConnectError::Handshake(
628 InitProtocolError::WrongVersion(_),
629 ))) => net_error(
630 localization
631 .get_msg("main-login-network_wrong_version")
632 .into_owned(),
633 mismatched_server_info,
634 ),
635 Error::NetworkErr(e) => net_error(e.to_string(), mismatched_server_info),
636 Error::ParticipantErr(e) => net_error(e.to_string(), mismatched_server_info),
637 Error::StreamErr(e) => net_error(e.to_string(), mismatched_server_info),
638 Error::HostnameLookupFailed(e) => {
639 format!(
640 "{}: {}",
641 localization.get_msg("main-login-server_not_found"),
642 e
643 )
644 },
645 Error::Other(e) => {
646 format!("{}: {}", localization.get_msg("common-error"), e)
647 },
648 Error::AuthClientError(e) => match e {
649 client::AuthClientError::RequestError(e) => format!(
651 "{}: {}",
652 localization.get_msg("main-login-failed_sending_request"),
653 e
654 ),
655 client::AuthClientError::ResponseError(e) => format!(
656 "{}: {}",
657 localization.get_msg("main-login-failed_sending_request"),
658 e
659 ),
660 client::AuthClientError::CertificateLoad(e) => format!(
661 "{}: {}",
662 localization.get_msg("main-login-failed_sending_request"),
663 e
664 ),
665 client::AuthClientError::JsonError(e) => format!(
666 "{}: {}",
667 localization.get_msg("main-login-failed_sending_request"),
668 e
669 ),
670 client::AuthClientError::InsecureSchema => localization
671 .get_msg("main-login-insecure_auth_scheme")
672 .into(),
673 client::AuthClientError::ServerError(_, e) => String::from_utf8_lossy(&e).into(),
674 },
675 Error::AuthServerUrlInvalid(e) => {
676 format!(
677 "{}: https://{}",
678 localization.get_msg("main-login-failed_auth_server_url_invalid"),
679 e
680 )
681 },
682 }
683}
684
685fn get_client_init_msg_error(
686 error: client_init::Error,
687 localized_strings: &LocalizationHandle,
688) -> String {
689 let localization = localized_strings.read();
690
691 match error {
692 InitError::ClientError {
693 error,
694 mismatched_server_info,
695 } => get_client_msg_error(error, mismatched_server_info, &localization),
696 InitError::ClientCrashed => localization.get_msg("main-login-client_crashed").into(),
697 InitError::ServerNotFound => localization.get_msg("main-login-server_not_found").into(),
698 }
699}
700
701fn attempt_login(
702 info_message: &mut Option<String>,
703 username: String,
704 password: String,
705 connection_args: ConnectionArgs,
706 init: &mut InitState,
707 runtime: &Arc<runtime::Runtime>,
708 locale: Option<String>,
709 localized_strings: &LocalizationHandle,
710 config_dir: &Path,
711 client_type: ClientType,
712) {
713 let localization = localized_strings.read();
714 if let Err(err) = comp::Player::alias_validate(&username) {
715 match err {
716 comp::AliasError::ForbiddenCharacters => {
717 *info_message = Some(
718 localization
719 .get_msg("main-login-username_bad_characters")
720 .into_owned(),
721 );
722 },
723 comp::AliasError::TooLong => {
724 *info_message = Some(
725 localization
726 .get_msg_ctx("main-login-username_too_long", &i18n::fluent_args! {
727 "max_len" => comp::MAX_ALIAS_LEN
728 })
729 .into_owned(),
730 );
731 },
732 }
733 return;
734 }
735
736 if let InitState::None = init {
738 *init = InitState::Client(ClientInit::new(
739 connection_args,
740 username,
741 password,
742 Arc::clone(runtime),
743 locale,
744 config_dir,
745 client_type,
746 ));
747 }
748}