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

@@ -22,10 +22,12 @@ mod handshake;
 mod world;
 mod player;
 
+pub use handshake::ConnectionRejectionReason;
 use handshake::{
   set_client_join_state_to_connected,
   say_hello,
-  check_server_hello_response
+  check_server_hello_response,
+  check_server_fuck_off_response,
 };
 use world::{
   inject_network_responses_into_manager_queue,
@@ -129,6 +131,7 @@ pub fn update_networking() -> Workload {
     ).into_sequential_workload().run_if(if_just_connected),
     (
       check_server_hello_response,
+      check_server_fuck_off_response,
       handle_disconnect,
     ).into_sequential_workload().run_if(is_join_state::<{ClientJoinState::Connected as u8}>),
     (

kubi/src/networking/handshake.rs

@@ -1,4 +1,4 @@
-use shipyard::{UniqueViewMut, View, IntoIter, AllStoragesViewMut};
+use shipyard::{AllStoragesView, AllStoragesViewMut, IntoIter, Unique, UniqueView, UniqueViewMut, View};
 use uflow::{client::Event as ClientEvent, SendMode};
 use kubi_shared::networking::{
   messages::{ClientToServerMessage, ServerToClientMessage, ServerToClientMessageType},
@@ -8,6 +8,11 @@ use kubi_shared::networking::{
 use crate::player::{spawn_local_player_multiplayer, spawn_remote_player_multiplayer};
 use super::{UdpClient, NetworkEvent};
 
+#[derive(Unique)]
+pub struct ConnectionRejectionReason {
+  pub reason: String,
+}
+
 pub fn set_client_join_state_to_connected(
   mut join_state: UniqueViewMut<ClientJoinState>
 ) {
@@ -74,3 +79,33 @@ pub fn check_server_hello_response(
 
   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,7 +1,9 @@
-use shipyard::{NonSendSync, UniqueView, Unique, AllStoragesView};
+use std::{io::{BufReader, Read}, path::Path};
+use hui::text::FontHandle;
+use shipyard::{AllStoragesView, NonSendSync, Unique, UniqueView, UniqueViewMut};
 use glium::{texture::{SrgbTexture2dArray, MipmapsOption}, Program};
 use kubi_shared::block::BlockTexture;
-use crate::{rendering::Renderer, filesystem::AssetManager};
+use crate::{filesystem::AssetManager, hui_integration::UiState, rendering::Renderer};
 
 mod texture;
 mod shaders;
@@ -48,9 +50,14 @@ pub struct ChunkShaderPrefab(pub Program);
 #[repr(transparent)]
 pub struct ColoredShaderPrefab(pub Program);
 
+#[derive(Unique)]
+#[repr(transparent)]
+pub struct UiFontPrefab(pub FontHandle);
+
 pub fn load_prefabs(
   storages: AllStoragesView,
   renderer: NonSendSync<UniqueView<Renderer>>,
+  mut ui: NonSendSync<UniqueViewMut<UiState>>,
   assman: UniqueView<AssetManager>
 ) {
   log::info!("Loading textures...");
@@ -63,6 +70,15 @@ pub fn load_prefabs(
     )
   ));
 
+  log::info!("Loading the UI stuff...");
+  {
+    let asset_handle = assman.open_asset(Path::new("fonts/Crisp.ttf")).unwrap();
+    let mut font_data = vec![];
+    BufReader::new(asset_handle).read_to_end(&mut font_data).unwrap();
+    let font_handle = ui.hui.add_font_from_bytes(&font_data);
+    storages.add_unique(UiFontPrefab(font_handle));
+  }
+
   log::info!("Compiling shaders...");
   storages.add_unique_non_send_sync(ChunkShaderPrefab(
     include_shader_prefab!(

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()
+}