assets/fonts/roboto/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 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

@@ -0,0 +1,12 @@
+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::{RenderTarget, Renderer, WindowSize};
+use crate::rendering::{Renderer, RenderTarget, 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,13 +13,7 @@ use winit::{
 use glam::vec3;
 use std::time::Instant;
 
-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 use kubi_shared::transform;
 
 pub(crate) mod rendering;
 pub(crate) mod world;
@@ -39,6 +33,8 @@ 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;
@@ -81,9 +77,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_begin, kubi_ui_draw, kubi_ui_end, kubi_ui_init};
+use hui_integration::{kubi_ui_init, kubi_ui_begin, kubi_ui_end, kubi_ui_draw};
 use loading_screen::update_loading_screen;
-use connecting_screen::update_connecting_screen;
+use connecting_screen::switch_to_loading_if_connected;
 use fixed_timestamp::init_fixed_timestamp_storage;
 use filesystem::AssetManager;
 use client_physics::{init_client_physics, update_client_physics_late};
@@ -128,7 +124,7 @@ fn update() -> Workload {
     ).into_sequential_workload().run_if(is_ingame_or_loading),
     update_networking().run_if(is_multiplayer),
     (
-      update_connecting_screen,
+      switch_to_loading_if_connected
     ).into_sequential_workload().run_if(is_connecting),
     (
       update_loading_screen,

kubi/src/loading_screen.rs

@@ -0,0 +1,101 @@
+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,12 +22,10 @@ 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_fuck_off_response,
+  check_server_hello_response
 };
 use world::{
   inject_network_responses_into_manager_queue,
@@ -131,7 +129,6 @@ 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::{AllStoragesView, AllStoragesViewMut, IntoIter, Unique, UniqueView, UniqueViewMut, View};
+use shipyard::{UniqueViewMut, View, IntoIter, AllStoragesViewMut};
 use uflow::{client::Event as ClientEvent, SendMode};
 use kubi_shared::networking::{
   messages::{ClientToServerMessage, ServerToClientMessage, ServerToClientMessageType},
@@ -8,11 +8,6 @@ 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>
 ) {
@@ -79,33 +74,3 @@ 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,9 +1,7 @@
-use std::{io::{BufReader, Read}, path::Path};
-use hui::text::FontHandle;
-use shipyard::{AllStoragesView, NonSendSync, Unique, UniqueView, UniqueViewMut};
+use shipyard::{NonSendSync, UniqueView, Unique, AllStoragesView};
 use glium::{texture::{SrgbTexture2dArray, MipmapsOption}, Program};
 use kubi_shared::block::BlockTexture;
-use crate::{filesystem::AssetManager, hui_integration::UiState, rendering::Renderer};
+use crate::{rendering::Renderer, filesystem::AssetManager};
 
 mod texture;
 mod shaders;
@@ -50,14 +48,9 @@ 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...");
@@ -70,15 +63,6 @@ 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

@@ -1,52 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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()
-}