diff --git a/kubi/src/init.rs b/kubi/src/init.rs index e6fa838..06484c3 100644 --- a/kubi/src/init.rs +++ b/kubi/src/init.rs @@ -12,18 +12,20 @@ pub fn initialize_from_args( // If an address is provided, we're in multiplayer mode (the first argument is the address) // Otherwise, we're in singleplayer mode and working with local stuff let args: Vec = env::args().collect(); - if args.len() > 1 { - // Parse the address and switch the state to connecting - let address = args[1].parse::().expect("invalid address"); - all_storages.add_unique(GameType::Muliplayer); - all_storages.add_unique(ServerAddress(address)); - all_storages.borrow::>().unwrap().0 = Some(GameState::Connecting); - } else { + if args.get(1) == Some(&"play".into()) { // Open the local save file let save_file = open_local_save_file(Path::new("./world.kubi")).expect("failed to open save file"); all_storages.add_unique(IOThreadManager::new(save_file)); // Switch the state and kick off the world loading all_storages.add_unique(GameType::Singleplayer); all_storages.borrow::>().unwrap().0 = Some(GameState::LoadingWorld); + } else if args.len() > 1 { + // Parse the address and switch the state to connecting + let address = args[1].parse::().expect("invalid address"); + all_storages.add_unique(GameType::Muliplayer); + all_storages.add_unique(ServerAddress(address)); + all_storages.borrow::>().unwrap().0 = Some(GameState::Connecting); + } else { + all_storages.borrow::>().unwrap().0 = Some(GameState::MainMenu); } } diff --git a/kubi/src/lib.rs b/kubi/src/lib.rs index b94e8ef..986886e 100644 --- a/kubi/src/lib.rs +++ b/kubi/src/lib.rs @@ -16,6 +16,7 @@ use shipyard::{ WorkloadModificator, SystemModificator }; +use ui::main_menu::update_main_menu; use winit::{ event_loop::{EventLoop, ControlFlow}, event::{Event, WindowEvent} @@ -35,6 +36,7 @@ pub(crate) use ui::{ crosshair_ui, settings_ui, shutdown_screen, + main_menu, }; pub(crate) mod rendering; pub(crate) mod world; @@ -77,10 +79,11 @@ use block_placement::update_block_placement; use delta_time::{DeltaTime, init_delta_time}; use cursor_lock::{debug_toggle_lock, insert_lock_state, lock_cursor_now, update_cursor_lock_state}; use control_flow::{exit_on_esc, insert_control_flow_unique, RequestExit}; -use state::{init_state, is_connecting, is_ingame, is_ingame_or_loading, is_loading, is_shutting_down, update_state}; +use state::{init_state, is_connecting, is_ingame, is_ingame_or_loading, is_ingame_or_loading_or_connecting_or_shutting_down, is_loading, is_main_menu, is_shutting_down, update_state}; use networking::{update_networking, update_networking_late, is_multiplayer, disconnect_on_exit, is_singleplayer}; use init::initialize_from_args; use hui_integration::{kubi_ui_begin, /*kubi_ui_draw,*/ kubi_ui_end, kubi_ui_init}; +use main_menu::render_main_menu_ui; use loading_screen::update_loading_screen; use shutdown_screen::update_shutdown_screen; use connecting_screen::update_connecting_screen; @@ -109,7 +112,7 @@ fn startup() -> Workload { insert_lock_state, init_state, initialize_from_args, - lock_cursor_now, + // lock_cursor_now, init_input, insert_control_flow_unique, init_delta_time, @@ -126,13 +129,18 @@ fn update() -> Workload { update_cursor_lock_state, process_inputs, kubi_ui_begin, + ( + update_main_menu + ).into_sequential_workload().run_if(is_main_menu), ( init_game_world.run_if_missing_unique::(), ( spawn_player.run_if_storage_empty::(), ).into_sequential_workload().run_if(is_singleplayer), ).into_sequential_workload().run_if(is_ingame_or_loading), - update_networking().run_if(is_multiplayer), + ( + update_networking + ).into_sequential_workload().run_if(is_multiplayer).run_if(is_ingame_or_loading_or_connecting_or_shutting_down), ( update_connecting_screen, ).into_sequential_workload().run_if(is_connecting), @@ -158,7 +166,9 @@ fn update() -> Workload { ( update_shutdown_screen, ).into_sequential_workload().run_if(is_shutting_down), - update_networking_late.run_if(is_multiplayer), + ( + update_networking_late + ).into_sequential_workload().run_if(is_multiplayer).run_if(is_ingame_or_loading_or_connecting_or_shutting_down), compute_cameras, kubi_ui_end, exit_on_esc, diff --git a/kubi/src/networking.rs b/kubi/src/networking.rs index ab9d18b..812bd65 100644 --- a/kubi/src/networking.rs +++ b/kubi/src/networking.rs @@ -11,9 +11,9 @@ use kubi_shared::networking::{ }; use crate::{ events::EventComponent, + fixed_timestamp::FixedTimestamp, + state::{is_ingame_or_loading, is_ingame_or_loading_or_connecting_or_shutting_down}, world::tasks::ChunkTaskManager, - state::is_ingame_or_loading, - fixed_timestamp::FixedTimestamp }; mod handshake; @@ -185,13 +185,15 @@ fn is_join_state( } pub fn is_multiplayer( - game_type: UniqueView + game_type: Option> ) -> bool { + let Some(game_type) = game_type else { return false }; *game_type == GameType::Muliplayer } pub fn is_singleplayer( - game_type: UniqueView + game_type: Option> ) -> bool { + let Some(game_type) = game_type else { return false }; *game_type == GameType::Singleplayer } diff --git a/kubi/src/state.rs b/kubi/src/state.rs index 0c2a294..fd9c0aa 100644 --- a/kubi/src/state.rs +++ b/kubi/src/state.rs @@ -5,6 +5,7 @@ use std::mem::take; pub enum GameState { #[default] Initial, + MainMenu, Connecting, LoadingWorld, InGame, @@ -34,6 +35,12 @@ pub fn is_changing_state( state.0.is_some() } +pub fn is_main_menu( + state: UniqueView +) -> bool { + *state == GameState::MainMenu +} + pub fn is_connecting( state: UniqueView ) -> bool { @@ -64,6 +71,12 @@ pub fn is_ingame_or_loading( matches!(*state, GameState::InGame | GameState::LoadingWorld) } +pub fn is_ingame_or_loading_or_connecting_or_shutting_down( + state: UniqueView +) -> bool { + matches!(*state, GameState::InGame | GameState::LoadingWorld | GameState::Connecting) +} + pub fn is_ingame_or_shutting_down( state: UniqueView ) -> bool { diff --git a/kubi/src/ui.rs b/kubi/src/ui.rs index 7a2c58b..7472f80 100644 --- a/kubi/src/ui.rs +++ b/kubi/src/ui.rs @@ -1,3 +1,4 @@ +pub(crate) mod main_menu; pub(crate) mod loading_screen; pub(crate) mod connecting_screen; pub(crate) mod shutdown_screen; diff --git a/kubi/src/ui/main_menu.rs b/kubi/src/ui/main_menu.rs new file mode 100644 index 0000000..483511a --- /dev/null +++ b/kubi/src/ui/main_menu.rs @@ -0,0 +1,149 @@ +use std::path::Path; + +use glam::vec4; +use hui::{ + element::{ + container::Container, + interactable::ElementInteractableExt, + text::Text, + UiElementExt + }, + layout::Alignment, + rect::Corners, + signal::Signal, + rect_frame, + size, +}; +use kubi_shared::data::{io_thread::IOThreadManager, open_local_save_file}; +use shipyard::{AllStoragesView, AllStoragesViewMut, IntoWorkload, NonSendSync, Unique, UniqueView, UniqueViewMut, Workload}; +use crate::{ + control_flow::RequestExit, + hui_integration::UiState, networking::GameType, rendering::Renderer, state::{GameState, NextState}}; + +#[derive(Clone, Copy)] +enum MainMenuPage { + TopMenu, + // ListWorlds { + // list: Vec, + // }, +} + +#[derive(Unique)] +struct MainMenuState { + page: MainMenuPage, +} + +#[derive(Signal, Clone, Copy)] +enum MainMenuSignal { + GotoPage(MainMenuPage), + Play, + Quit, + // CreatePlayWorld { + // name: String, + // }, + // PlayWorld { + // path: PathBuf, + // }, +} + +pub fn main_menu_leave( + storages: AllStoragesView, +) { + if storages.remove_unique::().is_err() { + log::warn!("what the fuck? shouldn't matter tho") + } +} + +pub fn render_main_menu_ui( + mut hui: NonSendSync>, + ren: UniqueView, +) { + Container::default() + .with_size(size!(100%, 100%)) + .with_padding(30.) + .with_gap(20.) + .with_background(Corners::top_bottom( + vec4(0.0, 0.0, 0.0, 0.85), + vec4(0.0, 0.0, 0.0, 0.0)) + ) + .with_children(|ui| { + Container::default() + .with_size(size!(100%, auto)) + .with_align(Alignment::Center) + .with_children(|ui| { + Text::new("Kubi") + .with_text_size(120) + .add_child(ui); + }) + .add_child(ui); + Container::default() + .with_size(size!(100%, 100%=)) + .with_align(Alignment::Center) + .with_children(|ui| { + Container::default() + .with_align((Alignment::Center, Alignment::Begin)) + .with_padding(20.) + .with_gap(10.) + .with_background(rect_frame! { + color: (0.1, 0.1, 0.1), + corner_radius: 10., + }) + .with_children(|ui| { + for (button_text, button_signal) in [ + ("Play", MainMenuSignal::Play), + ("Quit", MainMenuSignal::Quit), + ] { + Container::default() + .with_size(size!(300, 50)) + .with_align(Alignment::Center) + .with_background(rect_frame! { + color: (0.2, 0.2, 0.2), + corner_radius: 3., + }) + .with_children(|ui| { + Text::new(button_text) + .with_text_size(24) + .add_child(ui); + }) + .on_click(move || button_signal) + .add_child(ui) + } + }) + .add_child(ui); + }) + .add_child(ui); + }) + .add_root(&mut hui.hui, ren.size_vec2()); +} + +fn main_menu_process_signals( + storages: AllStoragesViewMut, +) { + let mut hui = storages.borrow::>>().unwrap(); + let mut quit = storages.borrow::>().unwrap(); + hui.hui.process_signals(|signal| { + match signal { + MainMenuSignal::Play => { + log::info!("play button pressed"); + // Open the local save file + let save_file = open_local_save_file(Path::new("./world.kubi")).expect("failed to open save file"); + storages.add_unique(IOThreadManager::new(save_file)); + // Switch the state and kick off the world loading + storages.add_unique(GameType::Singleplayer); + storages.borrow::>().unwrap().0 = Some(GameState::LoadingWorld); + } + MainMenuSignal::Quit => { + log::info!("quit button pressed"); + quit.0 = true; + } + _ => {} + } + }); +} + +pub fn update_main_menu() -> Workload { + ( + render_main_menu_ui, + main_menu_process_signals, + ).into_sequential_workload() +} \ No newline at end of file