handle fuck off request

assets/fonts/roboto/LICENSE.txt

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

kubi/src/connecting_screen.rs

@@ -1,12 +0,0 @@
-use kubi_shared::networking::state::ClientJoinState;
-use shipyard::{UniqueViewMut, UniqueView};
-use crate::state::{NextState, GameState};
-
-pub fn switch_to_loading_if_connected(
-  mut next_state: UniqueViewMut<NextState>,
-  client_state: UniqueView<ClientJoinState>,
-) { 
-  if *client_state == ClientJoinState::Joined {
-    next_state.0 = Some(GameState::LoadingWorld);
-  }
-}

kubi/src/hui_integration.rs

@@ -1,12 +1,12 @@
 use hui::UiInstance;
 use hui_glium::GliumUiRenderer;
 use shipyard::{AllStoragesView, Unique, UniqueView, NonSendSync, UniqueViewMut};
-use crate::rendering::{Renderer, RenderTarget, WindowSize};
+use crate::rendering::{RenderTarget, Renderer, WindowSize};
 
 #[derive(Unique)]
 pub struct UiState {
   pub hui: UiInstance,
-  pub renderer: GliumUiRenderer,
+  pub renderer: GliumUiRenderer
 }
 
 pub fn kubi_ui_init(
@@ -15,7 +15,7 @@ pub fn kubi_ui_init(
   let renderer = storages.borrow::<NonSendSync<UniqueView<Renderer>>>().unwrap();
   storages.add_unique_non_send_sync(UiState {
     hui: UiInstance::new(),
-    renderer: GliumUiRenderer::new(&renderer.display)
+    renderer: GliumUiRenderer::new(&renderer.display),
   });
 }
 
@@ -29,7 +29,7 @@ pub fn kubi_ui_end(
   mut ui: NonSendSync<UniqueViewMut<UiState>>
 ) {
   let ui: &mut UiState = &mut ui;
-  let UiState { hui, renderer } = ui;
+  let UiState { hui, renderer, .. } = ui;
   hui.end();
   renderer.update(hui);
 }

kubi/src/lib.rs

@@ -13,7 +13,13 @@ use winit::{
 use glam::vec3;
 use std::time::Instant;
 
-pub use kubi_shared::transform;
+pub(crate) use kubi_shared::transform;
+
+mod ui {
+  pub(crate) mod loading_screen;
+  pub(crate) mod connecting_screen;
+}
+pub(crate) use ui::{loading_screen, connecting_screen};
 
 pub(crate) mod rendering;
 pub(crate) mod world;
@@ -33,8 +39,6 @@ pub(crate) mod hui_integration;
 pub(crate) mod networking;
 pub(crate) mod init;
 pub(crate) mod color;
-pub(crate) mod loading_screen;
-pub(crate) mod connecting_screen;
 pub(crate) mod fixed_timestamp;
 pub(crate) mod filesystem;
 pub(crate) mod client_physics;
@@ -77,9 +81,9 @@ use control_flow::{exit_on_esc, insert_control_flow_unique, RequestExit};
 use state::{is_ingame, is_ingame_or_loading, is_loading, init_state, update_state, is_connecting};
 use networking::{update_networking, update_networking_late, is_multiplayer, disconnect_on_exit, is_singleplayer};
 use init::initialize_from_args;
-use hui_integration::{kubi_ui_init, kubi_ui_begin, kubi_ui_end, kubi_ui_draw};
+use hui_integration::{kubi_ui_begin, kubi_ui_draw, kubi_ui_end, kubi_ui_init};
 use loading_screen::update_loading_screen;
-use connecting_screen::switch_to_loading_if_connected;
+use connecting_screen::update_connecting_screen;
 use fixed_timestamp::init_fixed_timestamp_storage;
 use filesystem::AssetManager;
 use client_physics::{init_client_physics, update_client_physics_late};
@@ -124,7 +128,7 @@ fn update() -> Workload {
     ).into_sequential_workload().run_if(is_ingame_or_loading),
     update_networking().run_if(is_multiplayer),
     (
-      switch_to_loading_if_connected
+      update_connecting_screen,
     ).into_sequential_workload().run_if(is_connecting),
     (
       update_loading_screen,

kubi/src/loading_screen.rs

@@ -1,101 +0,0 @@
-use hui::{
-  element::{container::Container, progress_bar::ProgressBar, text::Text},
-  layout::{Alignment, UiDirection, UiSize},
-  rectangle::{Corners, Sides}
-};
-use shipyard::{UniqueView, UniqueViewMut, Workload, NonSendSync, IntoWorkload};
-use winit::keyboard::KeyCode;
-use crate::{
-  world::ChunkStorage,
-  state::{GameState, NextState},
-  rendering::WindowSize,
-  input::RawKbmInputState,
-  hui_integration::UiState,
-};
-
-fn render_loading_ui(
-  mut ui: NonSendSync<UniqueViewMut<UiState>>,
-  world: UniqueView<ChunkStorage>,
-  size: UniqueView<WindowSize>
-) {
-  let loaded = world.chunks.iter().fold(0, |acc, (&_, chunk)| {
-    acc + chunk.desired_state.matches_current(chunk.current_state) as usize
-  });
-  let total = world.chunks.len();
-  let value = loaded as f32 / total as f32;
-  let percentage = value * 100.;
-  ui.hui.add(
-    Container {
-      size: (UiSize::Fraction(1.), UiSize::Fraction(1.)),
-      background: (0.1, 0.1, 0.1, 1. - (value - 0.75).max(0.)).into(),
-      align: Alignment::Center.into(),
-      elements: vec![
-        Box::new(Container {
-          padding: Sides::all(10.),
-          gap: 10.,
-          background: (0.2, 0.2, 0.2).into(),
-          corner_radius: Corners::all(8.),
-          elements: vec![
-            Box::new(Text {
-              text: "Loading...".into(),
-              ..Default::default()
-            }),
-            Box::new(ProgressBar {
-              value,
-              size: (UiSize::Static(400.), UiSize::Auto),
-              corner_radius: Corners::all(2.),
-              ..Default::default()
-            }),
-            Box::new(Container {
-              size: (UiSize::Static(400.), UiSize::Auto),
-              align: (Alignment::End, Alignment::Begin).into(),
-              direction: UiDirection::Horizontal,
-              elements: vec![
-                Box::new(Text {
-                  text: format!("{loaded}/{total} ({percentage:.1}%)").into(),
-                  ..Default::default()
-                })
-              ],
-              ..Default::default()
-            })
-          ],
-          ..Default::default()
-        })
-      ],
-      ..Default::default()
-    },
-    size.0.as_vec2()
-  );
-}
-
-fn switch_to_ingame_if_loaded(
-  world: UniqueView<ChunkStorage>,
-  mut state: UniqueViewMut<NextState>
-) {
-  if world.chunks.is_empty() {
-    return
-  }
-  if world.chunks.iter().all(|(_, chunk)| {
-    chunk.desired_state.matches_current(chunk.current_state)
-  }) {
-    log::info!("Finished loading chunks");
-    state.0 = Some(GameState::InGame);
-  }
-}
-
-fn override_loading(
-  kbm_state: UniqueView<RawKbmInputState>,
-  mut state: UniqueViewMut<NextState>
-) {
-  if kbm_state.keyboard_state.contains(KeyCode::KeyF as u32) {
-    state.0 = Some(GameState::InGame);
-  }
-}
-
-pub fn update_loading_screen() -> Workload {
-  (
-    render_loading_ui,
-    override_loading,
-    switch_to_ingame_if_loaded,
-  ).into_sequential_workload()
-}

kubi/src/networking.rs

@@ -1,198 +1,201 @@
-use shipyard::{Unique, AllStoragesView, UniqueView, UniqueViewMut, Workload, IntoWorkload, EntitiesViewMut, Component, ViewMut, SystemModificator, View, IntoIter, WorkloadModificator};
+use shipyard::{Unique, AllStoragesView, UniqueView, UniqueViewMut, Workload, IntoWorkload, EntitiesViewMut, Component, ViewMut, SystemModificator, View, IntoIter, WorkloadModificator};
-use winit::event_loop::ControlFlow;
+use winit::event_loop::ControlFlow;
-use std::net::SocketAddr;
+use std::net::SocketAddr;
-use uflow::{
+use uflow::{
-  client::{Client, Config as ClientConfig, Event as ClientEvent}, 
+  client::{Client, Config as ClientConfig, Event as ClientEvent}, 
-  EndpointConfig
+  EndpointConfig
-};
+};
-use kubi_shared::networking::{
+use kubi_shared::networking::{
-  messages::ServerToClientMessage,
+  messages::ServerToClientMessage,
-  state::ClientJoinState, 
+  state::ClientJoinState, 
-  client::ClientIdMap,
+  client::ClientIdMap,
-};
+};
-use crate::{
+use crate::{
-  events::EventComponent, 
+  events::EventComponent, 
-  control_flow::RequestExit,
+  control_flow::RequestExit,
-  world::tasks::ChunkTaskManager, 
+  world::tasks::ChunkTaskManager, 
-  state::is_ingame_or_loading, 
+  state::is_ingame_or_loading, 
-  fixed_timestamp::FixedTimestamp
+  fixed_timestamp::FixedTimestamp
-};
+};
-
+
-mod handshake;
+mod handshake;
-mod world;
+mod world;
-mod player;
+mod player;
-
+
-use handshake::{
+pub use handshake::ConnectionRejectionReason;
-  set_client_join_state_to_connected,
+use handshake::{
-  say_hello,
+  set_client_join_state_to_connected,
-  check_server_hello_response
+  say_hello,
-};
+  check_server_hello_response,
-use world::{
+  check_server_fuck_off_response,
-  inject_network_responses_into_manager_queue,
+};
-  send_block_place_events,
+use world::{
-  recv_block_place_events,
+  inject_network_responses_into_manager_queue,
-};
+  send_block_place_events,
-use player::{
+  recv_block_place_events,
-  init_client_map,
+};
-  send_player_movement_events,
+use player::{
-  receive_player_movement_events, 
+  init_client_map,
-  receive_player_connect_events
+  send_player_movement_events,
-};
+  receive_player_movement_events, 
-
+  receive_player_connect_events
-const NET_TICKRATE: u16 = 33;
+};
-
+
-#[derive(Unique, Clone, Copy, PartialEq, Eq)]
+const NET_TICKRATE: u16 = 33;
-pub enum GameType {
+
-  Singleplayer,
+#[derive(Unique, Clone, Copy, PartialEq, Eq)]
-  Muliplayer
+pub enum GameType {
-}
+  Singleplayer,
-
+  Muliplayer
-#[derive(Unique, Clone, Copy, PartialEq, Eq)]
+}
-pub struct ServerAddress(pub SocketAddr);
+
-
+#[derive(Unique, Clone, Copy, PartialEq, Eq)]
-#[derive(Unique)]
+pub struct ServerAddress(pub SocketAddr);
-pub struct UdpClient(pub Client);
+
-
+#[derive(Unique)]
-#[derive(Component)]
+pub struct UdpClient(pub Client);
-pub struct NetworkEvent(pub ClientEvent);
+
-
+#[derive(Component)]
-impl NetworkEvent {
+pub struct NetworkEvent(pub ClientEvent);
-  ///Checks if postcard-encoded message has a type
+
-  pub fn is_message_of_type<const T: u8>(&self) -> bool {
+impl NetworkEvent {
-    let ClientEvent::Receive(data) = &self.0 else { return false };
+  ///Checks if postcard-encoded message has a type
-    if data.len() == 0 { return false }
+  pub fn is_message_of_type<const T: u8>(&self) -> bool {
-    data[0] == T
+    let ClientEvent::Receive(data) = &self.0 else { return false };
-  }
+    if data.len() == 0 { return false }
-}
+    data[0] == T
-
+  }
-#[derive(Component)]
+}
-pub struct NetworkMessageEvent(pub ServerToClientMessage);
+
-
+#[derive(Component)]
-fn connect_client(
+pub struct NetworkMessageEvent(pub ServerToClientMessage);
-  storages: AllStoragesView
+
-) {
+fn connect_client(
-  log::info!("Creating client");
+  storages: AllStoragesView
-  let address = storages.borrow::<UniqueView<ServerAddress>>().unwrap();
+) {
-  let client = Client::connect(address.0, ClientConfig {
+  log::info!("Creating client");
-    endpoint_config: EndpointConfig {
+  let address = storages.borrow::<UniqueView<ServerAddress>>().unwrap();
-      active_timeout_ms: 10000,
+  let client = Client::connect(address.0, ClientConfig {
-      keepalive: true,
+    endpoint_config: EndpointConfig {
-      keepalive_interval_ms: 5000,
+      active_timeout_ms: 10000,
-      ..Default::default()
+      keepalive: true,
-    },
+      keepalive_interval_ms: 5000,
-  }).expect("Client connection failed");
+      ..Default::default()
-  storages.add_unique(UdpClient(client));
+    },
-  storages.add_unique(ClientJoinState::Disconnected);
+  }).expect("Client connection failed");
-}
+  storages.add_unique(UdpClient(client));
-
+  storages.add_unique(ClientJoinState::Disconnected);
-fn poll_client(
+}
-  mut client: UniqueViewMut<UdpClient>,
+
-  mut entities: EntitiesViewMut,
+fn poll_client(
-  mut events: ViewMut<EventComponent>,
+  mut client: UniqueViewMut<UdpClient>,
-  mut network_events: ViewMut<NetworkEvent>,
+  mut entities: EntitiesViewMut,
-) {
+  mut events: ViewMut<EventComponent>,
-  entities.bulk_add_entity((
+  mut network_events: ViewMut<NetworkEvent>,
-    &mut events,
+) {
-    &mut network_events,
+  entities.bulk_add_entity((
-  ), client.0.step().map(|event| {
+    &mut events,
-    (EventComponent, NetworkEvent(event))
+    &mut network_events,
-  }));
+  ), client.0.step().map(|event| {
-}
+    (EventComponent, NetworkEvent(event))
-
+  }));
-fn flush_client(
+}
-  mut client: UniqueViewMut<UdpClient>,
+
-) {
+fn flush_client(
-  client.0.flush();
+  mut client: UniqueViewMut<UdpClient>,
-}
+) {
-
+  client.0.flush();
-fn handle_disconnect(
+}
-  network_events: View<NetworkEvent>,
+
-  mut join_state: UniqueViewMut<ClientJoinState>
+fn handle_disconnect(
-) {
+  network_events: View<NetworkEvent>,
-  for event in network_events.iter() {
+  mut join_state: UniqueViewMut<ClientJoinState>
-    if matches!(event.0, ClientEvent::Disconnect) {
+) {
-      log::warn!("Disconnected from server");
+  for event in network_events.iter() {
-      *join_state = ClientJoinState::Disconnected;
+    if matches!(event.0, ClientEvent::Disconnect) {
-      return;
+      log::warn!("Disconnected from server");
-    }
+      *join_state = ClientJoinState::Disconnected;
-  }
+      return;
-}
+    }
-
+  }
-pub fn update_networking() -> Workload {
+}
-  (
+
-    init_client_map.run_if_missing_unique::<ClientIdMap>(),
+pub fn update_networking() -> Workload {
-    connect_client.run_if_missing_unique::<UdpClient>(),
+  (
-    poll_client.into_workload().make_fixed(NET_TICKRATE, 0),
+    init_client_map.run_if_missing_unique::<ClientIdMap>(),
-    (
+    connect_client.run_if_missing_unique::<UdpClient>(),
-      set_client_join_state_to_connected,
+    poll_client.into_workload().make_fixed(NET_TICKRATE, 0),
-      say_hello,
+    (
-    ).into_sequential_workload().run_if(if_just_connected),
+      set_client_join_state_to_connected,
-    (
+      say_hello,
-      check_server_hello_response,
+    ).into_sequential_workload().run_if(if_just_connected),
-      handle_disconnect,
+    (
-    ).into_sequential_workload().run_if(is_join_state::<{ClientJoinState::Connected as u8}>),
+      check_server_hello_response,
-    (
+      check_server_fuck_off_response,
-      (
+      handle_disconnect,
-        receive_player_connect_events,
+    ).into_sequential_workload().run_if(is_join_state::<{ClientJoinState::Connected as u8}>),
-      ).into_workload(),
+    (
-      (
+      (
-        recv_block_place_events,
+        receive_player_connect_events,
-        receive_player_movement_events,
+      ).into_workload(),
-      ).into_workload()
+      (
-    ).into_sequential_workload().run_if(is_join_state::<{ClientJoinState::Joined as u8}>).run_if(is_ingame_or_loading),
+        recv_block_place_events,
-    inject_network_responses_into_manager_queue.run_if(is_ingame_or_loading).skip_if_missing_unique::<ChunkTaskManager>(),
+        receive_player_movement_events,
-  ).into_sequential_workload()
+      ).into_workload()
-}
+    ).into_sequential_workload().run_if(is_join_state::<{ClientJoinState::Joined as u8}>).run_if(is_ingame_or_loading),
-
+    inject_network_responses_into_manager_queue.run_if(is_ingame_or_loading).skip_if_missing_unique::<ChunkTaskManager>(),
-pub fn update_networking_late() -> Workload {
+  ).into_sequential_workload()
-  (
+}
-    (
+
-      send_block_place_events,
+pub fn update_networking_late() -> Workload {
-      send_player_movement_events,
+  (
-    ).into_workload().run_if(is_join_state::<{ClientJoinState::Joined as u8}>),
+    (
-    flush_client.into_workload().make_fixed(NET_TICKRATE, 1)
+      send_block_place_events,
-  ).into_sequential_workload()
+      send_player_movement_events,
-}
+    ).into_workload().run_if(is_join_state::<{ClientJoinState::Joined as u8}>),
-
+    flush_client.into_workload().make_fixed(NET_TICKRATE, 1)
-pub fn disconnect_on_exit(
+  ).into_sequential_workload()
-  exit: UniqueView<RequestExit>,
+}
-  mut client: UniqueViewMut<UdpClient>,
+
-) {
+pub fn disconnect_on_exit(
-  //TODO check if this works
+  exit: UniqueView<RequestExit>,
-  if exit.0 {
+  mut client: UniqueViewMut<UdpClient>,
-    if client.0.is_active() {
+) {
-      client.0.flush();
+  //TODO check if this works
-      client.0.disconnect();
+  if exit.0 {
-      while client.0.is_active() { client.0.step().for_each(|_|()); }
+    if client.0.is_active() {
-      log::info!("Client disconnected");
+      client.0.flush();
-    } else {
+      client.0.disconnect();
-      log::info!("Client inactive")
+      while client.0.is_active() { client.0.step().for_each(|_|()); }
-    }
+      log::info!("Client disconnected");
-  }
+    } else {
-}
+      log::info!("Client inactive")
-
+    }
-// conditions
+  }
-
+}
-fn if_just_connected(
+
-  network_events: View<NetworkEvent>,
+// conditions
-) -> bool {
+
-  network_events.iter().any(|event| matches!(&event.0, ClientEvent::Connect))
+fn if_just_connected(
-}
+  network_events: View<NetworkEvent>,
-
+) -> bool {
-fn is_join_state<const STATE: u8>(
+  network_events.iter().any(|event| matches!(&event.0, ClientEvent::Connect))
-  join_state: UniqueView<ClientJoinState>
+}
-) -> bool {
+
-  (*join_state as u8) == STATE
+fn is_join_state<const STATE: u8>(
-}
+  join_state: UniqueView<ClientJoinState>
-
+) -> bool {
-pub fn is_multiplayer(
+  (*join_state as u8) == STATE
-  game_type: UniqueView<GameType>
+}
-) -> bool {
+
-  *game_type == GameType::Muliplayer
+pub fn is_multiplayer(
-}
+  game_type: UniqueView<GameType>
-
+) -> bool {
-pub fn is_singleplayer(
+  *game_type == GameType::Muliplayer
-  game_type: UniqueView<GameType>
+}
-) -> bool {
+
-  *game_type == GameType::Singleplayer
+pub fn is_singleplayer(
-}
+  game_type: UniqueView<GameType>
+) -> bool {
+  *game_type == GameType::Singleplayer
+}

kubi/src/networking/handshake.rs

@@ -1,76 +1,111 @@
-use shipyard::{UniqueViewMut, View, IntoIter, AllStoragesViewMut};
+use shipyard::{AllStoragesView, AllStoragesViewMut, IntoIter, Unique, UniqueView, UniqueViewMut, View};
-use uflow::{client::Event as ClientEvent, SendMode};
+use uflow::{client::Event as ClientEvent, SendMode};
-use kubi_shared::networking::{
+use kubi_shared::networking::{
-  messages::{ClientToServerMessage, ServerToClientMessage, ServerToClientMessageType},
+  messages::{ClientToServerMessage, ServerToClientMessage, ServerToClientMessageType},
-  state::ClientJoinState,
+  state::ClientJoinState,
-  channels::Channel,
+  channels::Channel,
-};
+};
-use crate::player::{spawn_local_player_multiplayer, spawn_remote_player_multiplayer};
+use crate::player::{spawn_local_player_multiplayer, spawn_remote_player_multiplayer};
-use super::{UdpClient, NetworkEvent};
+use super::{UdpClient, NetworkEvent};
-
+
-pub fn set_client_join_state_to_connected(
+#[derive(Unique)]
-  mut join_state: UniqueViewMut<ClientJoinState>
+pub struct ConnectionRejectionReason {
-) {
+  pub reason: String,
-  log::info!("Setting ClientJoinState");
+}
-  *join_state = ClientJoinState::Connected;
+
-}
+pub fn set_client_join_state_to_connected(
-
+  mut join_state: UniqueViewMut<ClientJoinState>
-pub fn say_hello(
+) {
-  mut client: UniqueViewMut<UdpClient>,
+  log::info!("Setting ClientJoinState");
-) {
+  *join_state = ClientJoinState::Connected;
-  let username = "XxX-FishFucker-69420-XxX".into(); 
+}
-  let password = None;
+
-  log::info!("Authenticating");
+pub fn say_hello(
-  client.0.send(
+  mut client: UniqueViewMut<UdpClient>,
-    postcard::to_allocvec(
+) {
-      &ClientToServerMessage::ClientHello { username, password }
+  let username = "XxX-FishFucker-69420-XxX".into(); 
-    ).unwrap().into_boxed_slice(),
+  let password = None;
-    Channel::Auth as usize,
+  log::info!("Authenticating");
-    SendMode::Reliable
+  client.0.send(
-  );
+    postcard::to_allocvec(
-}
+      &ClientToServerMessage::ClientHello { username, password }
-
+    ).unwrap().into_boxed_slice(),
-pub fn check_server_hello_response(
+    Channel::Auth as usize,
-  mut storages: AllStoragesViewMut,
+    SendMode::Reliable
-) {
+  );
-  //Check if we got the message and extract the init data from it
+}
-  let Some(init) = storages.borrow::<View<NetworkEvent>>().unwrap().iter().find_map(|event| {
+
-    let ClientEvent::Receive(data) = &event.0 else {
+pub fn check_server_hello_response(
-      return None
+  mut storages: AllStoragesViewMut,
-    };
+) {
-    if !event.is_message_of_type::<{ServerToClientMessageType::ServerHello as u8}>() {
+  //Check if we got the message and extract the init data from it
-      return None
+  let Some(init) = storages.borrow::<View<NetworkEvent>>().unwrap().iter().find_map(|event| {
-    }
+    let ClientEvent::Receive(data) = &event.0 else {
-    let Ok(parsed_message) = postcard::from_bytes(data) else {
+      return None
-      log::error!("Malformed message");
+    };
-      return None
+    if !event.is_message_of_type::<{ServerToClientMessageType::ServerHello as u8}>() {
-    };
+      return None
-    let ServerToClientMessage::ServerHello { init } = parsed_message else {
+    }
-      unreachable!()
+    let Ok(parsed_message) = postcard::from_bytes(data) else {
-    };
+      log::error!("Malformed message");
-    Some(init)
+      return None
-  }) else { return };
+    };
-
+    let ServerToClientMessage::ServerHello { init } = parsed_message else {
-  //  struct ClientInitData {
+      unreachable!()
-  //    client_id: ClientId,
+    };
-  //    username: String,
+    Some(init)
-  //    position: Vec3,
+  }) else { return };
-  //    velocity: Vec3,
+
-  //    direction: Quat,
+  //  struct ClientInitData {
-  //    health: Health,
+  //    client_id: ClientId,
-  //  }
+  //    username: String,
-  
+  //    position: Vec3,
-  //Add components to main player
+  //    velocity: Vec3,
-  spawn_local_player_multiplayer(&mut storages, init.user);
+  //    direction: Quat,
-
+  //    health: Health,
-  //Init players
+  //  }
-  for init_data in init.users {
+  
-    spawn_remote_player_multiplayer(&mut storages, init_data);
+  //Add components to main player
-  }
+  spawn_local_player_multiplayer(&mut storages, init.user);
-
+
-  // Set state to connected
+  //Init players
-  let mut join_state = storages.borrow::<UniqueViewMut<ClientJoinState>>().unwrap();
+  for init_data in init.users {
-  *join_state = ClientJoinState::Joined;
+    spawn_remote_player_multiplayer(&mut storages, init_data);
-
+  }
-  log::info!("Joined the server!");
+
-}
+  // Set state to connected
+  let mut join_state = storages.borrow::<UniqueViewMut<ClientJoinState>>().unwrap();
+  *join_state = ClientJoinState::Joined;
+
+  log::info!("Joined the server!");
+}
+
+pub fn check_server_fuck_off_response(
+  storages: AllStoragesView,
+) {
+  //Check if we got the message and extract the init data from it
+  let Some(reason) = storages.borrow::<View<NetworkEvent>>().unwrap().iter().find_map(|event| {
+    let ClientEvent::Receive(data) = &event.0 else {
+      return None
+    };
+    if !event.is_message_of_type::<{ServerToClientMessageType::ServerFuckOff as u8}>() {
+      return None
+    }
+    let Ok(parsed_message) = postcard::from_bytes(data) else {
+      log::error!("Malformed message");
+      return None
+    };
+    let ServerToClientMessage::ServerFuckOff { reason } = parsed_message else {
+      unreachable!()
+    };
+    Some(reason)
+  }) else { return };
+
+  let mut client = storages.borrow::<UniqueViewMut<UdpClient>>().unwrap();
+  client.0.disconnect_now();
+
+  let mut join_state = storages.borrow::<UniqueViewMut<ClientJoinState>>().unwrap();
+  *join_state = ClientJoinState::Disconnected;
+
+  storages.add_unique(ConnectionRejectionReason { reason });
+}

kubi/src/prefabs.rs

@@ -1,87 +1,103 @@
-use shipyard::{NonSendSync, UniqueView, Unique, AllStoragesView};
+use std::{io::{BufReader, Read}, path::Path};
-use glium::{texture::{SrgbTexture2dArray, MipmapsOption}, Program};
+use hui::text::FontHandle;
-use kubi_shared::block::BlockTexture;
+use shipyard::{AllStoragesView, NonSendSync, Unique, UniqueView, UniqueViewMut};
-use crate::{rendering::Renderer, filesystem::AssetManager};
+use glium::{texture::{SrgbTexture2dArray, MipmapsOption}, Program};
-
+use kubi_shared::block::BlockTexture;
-mod texture;
+use crate::{filesystem::AssetManager, hui_integration::UiState, rendering::Renderer};
-mod shaders;
+
-
+mod texture;
-use texture::load_texture2darray_prefab;
+mod shaders;
-use shaders::include_shader_prefab;
+
-
+use texture::load_texture2darray_prefab;
-pub trait AssetPaths {
+use shaders::include_shader_prefab;
-  fn file_name(self) -> &'static str;
+
-}
+pub trait AssetPaths {
-
+  fn file_name(self) -> &'static str;
-impl AssetPaths for BlockTexture {
+}
-  fn file_name(self) -> &'static str {
+
-    match self {
+impl AssetPaths for BlockTexture {
-      Self::Stone         => "stone.png",
+  fn file_name(self) -> &'static str {
-      Self::Dirt          => "dirt.png",
+    match self {
-      Self::GrassTop      => "grass_top.png",
+      Self::Stone         => "stone.png",
-      Self::GrassSide     => "grass_side.png",
+      Self::Dirt          => "dirt.png",
-      Self::Sand          => "sand.png",
+      Self::GrassTop      => "grass_top.png",
-      Self::Bedrock       => "bedrock.png",
+      Self::GrassSide     => "grass_side.png",
-      Self::Wood          => "wood.png",
+      Self::Sand          => "sand.png",
-      Self::WoodTop       => "wood_top.png",
+      Self::Bedrock       => "bedrock.png",
-      Self::Leaf          => "leaf.png",
+      Self::Wood          => "wood.png",
-      Self::Torch         => "torch.png",
+      Self::WoodTop       => "wood_top.png",
-      Self::TallGrass     => "tall_grass.png",
+      Self::Leaf          => "leaf.png",
-      Self::Snow          => "snow.png",
+      Self::Torch         => "torch.png",
-      Self::GrassSideSnow => "grass_side_snow.png",
+      Self::TallGrass     => "tall_grass.png",
-      Self::Cobblestone   => "cobblestone.png",
+      Self::Snow          => "snow.png",
-      Self::Planks        => "planks.png",
+      Self::GrassSideSnow => "grass_side_snow.png",
-      Self::WaterSolid    => "solid_water.png",
+      Self::Cobblestone   => "cobblestone.png",
-    }
+      Self::Planks        => "planks.png",
-  }
+      Self::WaterSolid    => "solid_water.png",
-}
+    }
-
+  }
-#[derive(Unique)]
+}
-#[repr(transparent)]
+
-pub struct BlockTexturesPrefab(pub SrgbTexture2dArray);
+#[derive(Unique)]
-
+#[repr(transparent)]
-#[derive(Unique)]
+pub struct BlockTexturesPrefab(pub SrgbTexture2dArray);
-#[repr(transparent)]
+
-pub struct ChunkShaderPrefab(pub Program);
+#[derive(Unique)]
-
+#[repr(transparent)]
-#[derive(Unique)]
+pub struct ChunkShaderPrefab(pub Program);
-#[repr(transparent)]
+
-pub struct ColoredShaderPrefab(pub Program);
+#[derive(Unique)]
-
+#[repr(transparent)]
-pub fn load_prefabs(
+pub struct ColoredShaderPrefab(pub Program);
-  storages: AllStoragesView,
+
-  renderer: NonSendSync<UniqueView<Renderer>>,
+#[derive(Unique)]
-  assman: UniqueView<AssetManager>
+#[repr(transparent)]
-) {
+pub struct UiFontPrefab(pub FontHandle);
-  log::info!("Loading textures...");
+
-  storages.add_unique_non_send_sync(BlockTexturesPrefab(
+pub fn load_prefabs(
-    load_texture2darray_prefab::<BlockTexture, _>(
+  storages: AllStoragesView,
-      &assman,
+  renderer: NonSendSync<UniqueView<Renderer>>,
-      "blocks".into(),
+  mut ui: NonSendSync<UniqueViewMut<UiState>>,
-      &renderer.display,
+  assman: UniqueView<AssetManager>
-      MipmapsOption::AutoGeneratedMipmaps
+) {
-    )
+  log::info!("Loading textures...");
-  ));
+  storages.add_unique_non_send_sync(BlockTexturesPrefab(
-
+    load_texture2darray_prefab::<BlockTexture, _>(
-  log::info!("Compiling shaders...");
+      &assman,
-  storages.add_unique_non_send_sync(ChunkShaderPrefab(
+      "blocks".into(),
-    include_shader_prefab!(
+      &renderer.display,
-      "world",
+      MipmapsOption::AutoGeneratedMipmaps
-      "../shaders/world.vert",
+    )
-      "../shaders/world.frag",
+  ));
-      &renderer.display
+
-    )
+  log::info!("Loading the UI stuff...");
-  ));
+  {
-  storages.add_unique_non_send_sync(ColoredShaderPrefab(
+    let asset_handle = assman.open_asset(Path::new("fonts/Crisp.ttf")).unwrap();
-    include_shader_prefab!(
+    let mut font_data = vec![];
-      "colored",
+    BufReader::new(asset_handle).read_to_end(&mut font_data).unwrap();
-      "../shaders/colored.vert",
+    let font_handle = ui.hui.add_font_from_bytes(&font_data);
-      "../shaders/colored.frag",
+    storages.add_unique(UiFontPrefab(font_handle));
-      &renderer.display
+  }
-    )
+
-  ));
+  log::info!("Compiling shaders...");
-
+  storages.add_unique_non_send_sync(ChunkShaderPrefab(
-  log::info!("releasing shader compiler");
+    include_shader_prefab!(
-
+      "world",
-  renderer.display.release_shader_compiler();
+      "../shaders/world.vert",
-}
+      "../shaders/world.frag",
+      &renderer.display
+    )
+  ));
+  storages.add_unique_non_send_sync(ColoredShaderPrefab(
+    include_shader_prefab!(
+      "colored",
+      "../shaders/colored.vert",
+      "../shaders/colored.frag",
+      &renderer.display
+    )
+  ));
+
+  log::info!("releasing shader compiler");
+
+  renderer.display.release_shader_compiler();
+}

kubi/src/state.rs

@@ -1,58 +1,58 @@
-use shipyard::{Unique, UniqueView, UniqueViewMut, AllStoragesView};
+use shipyard::{Unique, UniqueView, UniqueViewMut, AllStoragesView};
-use std::mem::take;
+use std::mem::take;
-
+
-#[derive(Unique, PartialEq, Eq, Default, Clone, Copy)]
+#[derive(Unique, PartialEq, Eq, Default, Clone, Copy)]
-pub enum GameState {
+pub enum GameState {
-  #[default]
+  #[default]
-  Initial,
+  Initial,
-  Connecting,
+  Connecting,
-  LoadingWorld,
+  LoadingWorld,
-  InGame
+  InGame
-}
+}
-
+
-#[derive(Unique, PartialEq, Eq, Default, Clone, Copy)]
+#[derive(Unique, PartialEq, Eq, Default, Clone, Copy)]
-pub struct NextState(pub Option<GameState>);
+pub struct NextState(pub Option<GameState>);
-
+
-pub fn init_state(
+pub fn init_state(
-  all_storages: AllStoragesView,
+  all_storages: AllStoragesView,
-) {
+) {
-  all_storages.add_unique(GameState::default());
+  all_storages.add_unique(GameState::default());
-  all_storages.add_unique(NextState::default());
+  all_storages.add_unique(NextState::default());
-}
+}
-
+
-pub fn update_state(
+pub fn update_state(
-  mut state: UniqueViewMut<GameState>,
+  mut state: UniqueViewMut<GameState>,
-  mut next: UniqueViewMut<NextState>,
+  mut next: UniqueViewMut<NextState>,
-) {
+) {
-  *state = take(&mut next.0).unwrap_or(*state);
+  *state = take(&mut next.0).unwrap_or(*state);
-}
+}
-
+
-pub fn is_changing_state(
+pub fn is_changing_state(
-  state: UniqueView<NextState>
+  state: UniqueView<NextState>
-) -> bool {
+) -> bool {
-  state.0.is_some()
+  state.0.is_some()
-}
+}
-
+
-pub fn is_connecting(
+pub fn is_connecting(
-  state: UniqueView<GameState>
+  state: UniqueView<GameState>
-) -> bool {
+) -> bool {
-  *state == GameState::Connecting
+  *state == GameState::Connecting
-}
+}
-
+
-pub fn is_ingame(
+pub fn is_ingame(
-  state: UniqueView<GameState>
+  state: UniqueView<GameState>
-) -> bool {
+) -> bool {
-  *state == GameState::InGame
+  *state == GameState::InGame
-}
+}
-
+
-pub fn is_loading(
+pub fn is_loading(
-  state: UniqueView<GameState>
+  state: UniqueView<GameState>
-) -> bool {
+) -> bool {
-  matches!(*state, GameState::LoadingWorld)
+  matches!(*state, GameState::LoadingWorld)
-}
+}
-
+
-pub fn is_ingame_or_loading(
+pub fn is_ingame_or_loading(
-  state: UniqueView<GameState>
+  state: UniqueView<GameState>
-) -> bool {
+) -> bool {
-  matches!(*state, GameState::InGame | GameState::LoadingWorld)
+  matches!(*state, GameState::InGame | GameState::LoadingWorld)
-}
+}

kubi/src/ui/connecting_screen.rs

@@ -0,0 +1,52 @@
+use hui::element::text::Text;
+use kubi_shared::networking::state::ClientJoinState;
+use shipyard::{IntoWorkload, NonSendSync, UniqueView, UniqueViewMut, Workload};
+use crate::{
+  hui_integration::UiState,
+  loading_screen::loading_screen_base,
+  networking::{ConnectionRejectionReason, ServerAddress},
+  prefabs::UiFontPrefab,
+  rendering::WindowSize,
+  state::{GameState, NextState}
+};
+
+fn render_connecting_ui(
+  addr: UniqueView<ServerAddress>,
+  rejection: Option<UniqueView<ConnectionRejectionReason>>,
+  join_state: UniqueView<ClientJoinState>,
+  mut ui: NonSendSync<UniqueViewMut<UiState>>,
+  font: UniqueView<UiFontPrefab>,
+  size: UniqueView<WindowSize>,
+) {
+  ui.hui.add(
+    loading_screen_base(vec![
+      Box::new(Text {
+        text: match (rejection, *join_state) {
+          (Some(err), _) => format!("Connection rejected by {}\n\n{}", addr.0, err.reason).into(),
+          (_, ClientJoinState::Disconnected) => format!("Lost connection to {}", addr.0).into(),
+          _ => format!("Connecting to {}...", addr.0).into(),
+        },
+        font: font.0,
+        text_size: 16,
+        ..Default::default()
+      }),
+    ], 1.),
+    size.0.as_vec2(),
+  );
+}
+
+fn switch_to_loading_if_connected(
+  mut next_state: UniqueViewMut<NextState>,
+  client_state: UniqueView<ClientJoinState>,
+) {
+  if *client_state == ClientJoinState::Joined {
+    next_state.0 = Some(GameState::LoadingWorld);
+  }
+}
+
+pub fn update_connecting_screen() -> Workload {
+  (
+    render_connecting_ui,
+    switch_to_loading_if_connected,
+  ).into_workload()
+}

kubi/src/ui/loading_screen.rs

@@ -0,0 +1,115 @@
+use hui::{
+  element::{container::Container, progress_bar::ProgressBar, text::Text, UiElement},
+  layout::{Alignment, UiDirection, UiSize},
+  rectangle::{Corners, Sides},
+};
+use shipyard::{UniqueView, UniqueViewMut, Workload, NonSendSync, IntoWorkload};
+use winit::keyboard::KeyCode;
+use crate::{
+  hui_integration::UiState, input::RawKbmInputState, networking::ServerAddress, prefabs::UiFontPrefab, rendering::WindowSize, state::{GameState, NextState}, world::ChunkStorage
+};
+
+pub fn loading_screen_base(elements: Vec<Box<dyn UiElement>>, bg_alpha: f32) -> Container {
+  Container {
+    size: (UiSize::Fraction(1.), UiSize::Fraction(1.)),
+    background: (0.1, 0.1, 0.1, bg_alpha).into(),
+    align: Alignment::Center.into(),
+    elements: vec![
+      Box::new(Container {
+        padding: Sides::all(10.),
+        gap: 5.,
+        background: (0.2, 0.2, 0.2).into(),
+        corner_radius: Corners::all(8.),
+        elements,
+        ..Default::default()
+      })
+    ],
+    ..Default::default()
+  }
+}
+
+fn render_loading_ui(
+  addr: Option<UniqueView<ServerAddress>>,
+  world: UniqueView<ChunkStorage>,
+  mut ui: NonSendSync<UniqueViewMut<UiState>>,
+  font: UniqueView<UiFontPrefab>,
+  size: UniqueView<WindowSize>
+) {
+  let loaded = world.chunks.iter().fold(0, |acc, (&_, chunk)| {
+    acc + chunk.desired_state.matches_current(chunk.current_state) as usize
+  });
+  let total = world.chunks.len();
+  let value = loaded as f32 / total as f32;
+  let percentage = value * 100.;
+
+  ui.hui.add(loading_screen_base(vec![
+    Box::new(Text {
+      text: match addr {
+        Some(addr) => format!("Connected to {}\nDownloading world data...", addr.0).into(),
+        _ => "Loading...".into(),
+      },
+      font: font.0,
+      text_size: 16,
+      ..Default::default()
+    }),
+    Box::new(ProgressBar {
+      value,
+      size: (UiSize::Static(400.), UiSize::Auto),
+      corner_radius: Corners::all(2.),
+      ..Default::default()
+    }),
+    Box::new(Container {
+      size: (UiSize::Static(400.), UiSize::Auto),
+      align: (Alignment::End, Alignment::Begin).into(),
+      direction: UiDirection::Horizontal,
+      elements: vec![
+        Box::new(Text {
+          text: format!("{loaded}/{total} ({percentage:.1}%)").into(),
+          font: font.0,
+          text_size: 16,
+          ..Default::default()
+        })
+      ],
+      ..Default::default()
+    }),
+    // Box::new(Text {
+    //   text: "--------------------------------------------------\nTip: You can press F to skip this loading screen".into(),
+    //   font: font_handle,
+    //   text_size: 16,
+    //   color: (0.5, 0.5, 0.5, 1.).into(),
+    //   ..Default::default()
+    // })
+  ], 1. - (value - 0.75).max(0.)), size.0.as_vec2());
+}
+
+fn switch_to_ingame_if_loaded(
+  world: UniqueView<ChunkStorage>,
+  mut state: UniqueViewMut<NextState>
+) {
+  if world.chunks.is_empty() {
+    return
+  }
+  if world.chunks.iter().all(|(_, chunk)| {
+    chunk.desired_state.matches_current(chunk.current_state)
+  }) {
+    log::info!("Finished loading chunks");
+    state.0 = Some(GameState::InGame);
+  }
+}
+
+fn override_loading(
+  kbm_state: UniqueView<RawKbmInputState>,
+  mut state: UniqueViewMut<NextState>
+) {
+  if kbm_state.keyboard_state.contains(KeyCode::KeyF as u32) {
+    state.0 = Some(GameState::InGame);
+  }
+}
+
+pub fn update_loading_screen() -> Workload {
+  (
+    render_loading_ui,
+    override_loading,
+    switch_to_ingame_if_loaded,
+  ).into_sequential_workload()
+}