mutable status stuff

Author: SubAt0m1c

server/src/network/client.rs

@@ -10,13 +10,13 @@ use crate::network::protocol::login::serverbound::LoginStart;
 use crate::network::protocol::play::serverbound::Play;
 use crate::network::protocol::status::clientbound::{StatusPong, StatusResponse};
 use crate::network::protocol::status::serverbound::StatusPing;
+use crate::network::status::StatusBytes;
 use crate::player::player::{ClientId, GameProfile};
 use crate::GameProfileProperty;
 use anyhow::bail;
 use bytes::{Buf, Bytes, BytesMut};
 use fstr::FString;
 use std::collections::HashMap;
-use std::sync::Arc;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
 use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
@@ -40,8 +40,7 @@ pub async fn handle_client(
     mut rx: UnboundedReceiver<ClientHandlerMessage>,
     main_tx: UnboundedSender<MainThreadMessage>,
     network_tx: UnboundedSender<NetworkThreadMessage>,
-    // probably needs to be made mutable?, so it can update the player count, etc
-    status: Arc<String>
+    status: StatusBytes
 ) {
     let mut client = Client {
         id: client_id,
@@ -62,7 +61,7 @@ pub async fn handle_client(
                             &mut client,
                             &tx,
                             &main_tx,
-                            status.as_ref()
+                            &status
                         ).await {
                             eprintln!("client {client_id:?} errored: {err}");
                             break;
@@ -89,7 +88,9 @@ pub async fn handle_client(
         }
     }
 
-    let _ = network_tx.send(NetworkThreadMessage::ConnectionClosed { client_id });
+    if client.connection_state == ConnectionState::Play {
+        let _ = network_tx.send(NetworkThreadMessage::ConnectionClosed { client_id });
+    }
     println!("handle client for {client_id:?} closed.");
 }
 
@@ -98,7 +99,7 @@ async fn read_packets(
     client: &mut Client,
     client_tx: &UnboundedSender<ClientHandlerMessage>,
     main_tx: &UnboundedSender<MainThreadMessage>,
-    status: &String
+    status: &StatusBytes
 ) -> anyhow::Result<()> {
     while let Some(mut buffer) = try_read_packet_slice(buffer) {
         match client.connection_state {
@@ -158,14 +159,14 @@ fn handle_handshake(buffer: &mut impl Buf, client: &mut Client) -> anyhow::Resul
 fn handle_status(
     buffer: &mut impl Buf,
     client_tx: &UnboundedSender<ClientHandlerMessage>,
-    status: &String
+    status: &StatusBytes
 ) -> anyhow::Result<()> {
     let packet_id = *VarInt::read(buffer)?;
     let mut packet_buffer = PacketBuffer::new();
     match packet_id {
         0x00 => {
             packet_buffer.write_packet(&StatusResponse {
-                status,
+                status: status.get_str(),
             });
         }
         0x01 => {
@@ -215,6 +216,8 @@ fn handle_login(
                 ),
             };
 
+            client.connection_state = ConnectionState::Play;
+            
             packet_buffer.write_packet(&LoginSuccess {
                 uuid: uuid.hyphenated().to_string(),
                 name: game_profile.username.clone(),
@@ -225,7 +228,6 @@ fn handle_login(
                 client_id: client.id,
                 profile: game_profile,
             })?;
-            client.connection_state = ConnectionState::Play;
         }
         _ => bail!("Unknown packet id during login")
     }

server/src/network/internal_packets.rs

@@ -1,8 +1,13 @@
 use crate::network::protocol::play::serverbound::Play;
+use crate::network::status::StatusUpdate;
 use crate::player::player::{ClientId, GameProfile};
 use bytes::Bytes;
 
 pub enum NetworkThreadMessage {
+    UpdateStatus {
+        update: StatusUpdate
+    },
+    
     SendPackets {
         client_id: ClientId,
         buffer: Bytes,

server/src/network/mod.rs

@@ -4,4 +4,5 @@ pub mod network;
 pub mod connection_state;
 pub mod internal_packets;
 pub mod protocol;
-pub mod binary;
+pub mod binary;
+pub mod status;

server/src/network/network.rs

@@ -1,4 +1,5 @@
 use crate::network::client::handle_client;
+use crate::network::status::Status;
 use core::panic;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -15,7 +16,7 @@ type ClientMap = HashMap<ClientId, UnboundedSender<ClientHandlerMessage>>;
 
 pub fn start_network(
     ip: &'static str,
-    status: Arc<String> // should probably be mutable
+    status: Status,
 ) -> (Sender<NetworkThreadMessage>, Receiver<MainThreadMessage>) {
     let (network_tx, network_rx) = unbounded_channel::<NetworkThreadMessage>();
     let (main_tx, main_rx) = unbounded_channel::<MainThreadMessage>();
@@ -25,7 +26,7 @@ pub fn start_network(
 
 async fn run_network_thread(
     ip: &'static str,
-    status: Arc<String>,
+    mut status: Status,
     mut network_rx: Receiver<NetworkThreadMessage>,
     network_tx: Sender<NetworkThreadMessage>,
     main_tx: Sender<MainThreadMessage>,
@@ -57,7 +58,7 @@ async fn run_network_thread(
                     client_rx,
                     main_tx.clone(),
                     network_tx.clone(),
-                    status.clone()
+                    status.get()
                 ));
             }
 
@@ -66,6 +67,7 @@ async fn run_network_thread(
                 // we can just discard main thread -> network thread messages with a disconnected client_id
                 // as the main thread either already has or will be be informed shortly of this issue
                 match msg { 
+                    NetworkThreadMessage::UpdateStatus { update } => status.set(update),
                     NetworkThreadMessage::SendPackets { client_id, buffer } => {
                         if let Some(client_tx) = clients.get(&client_id) {
                             if let Err(e) = client_tx.send(ClientHandlerMessage::Send(buffer)) {
@@ -84,9 +86,7 @@ async fn run_network_thread(
                         }
                     }
 
-                    NetworkThreadMessage::ConnectionClosed { client_id } => {
-                        disconnect_client(client_id, &main_tx, &mut clients)
-                    }
+                    NetworkThreadMessage::ConnectionClosed { client_id } => disconnect_client(client_id, &main_tx, &mut clients),
                 }
             }
         }

server/src/network/status.rs

@@ -0,0 +1,62 @@
+use bytes::Bytes;
+use crate::types::chat_component::ChatComponent;
+
+#[derive(Debug, Clone)]
+pub struct StatusBytes(Bytes);
+impl StatusBytes {
+    #[inline(always)]
+    pub fn get_str(&self) -> &str {
+        // SAFETY: These should always be constructed from a String.
+        unsafe { str::from_utf8_unchecked(&self.0) }
+    }
+}
+
+pub struct Status {
+    players: u32,
+    max_players: u32,
+    
+    info: ChatComponent,
+    icon: &'static str,
+    
+    cached: Option<StatusBytes>,
+}
+
+impl Status {
+    pub fn new(players: u32, max_players: u32, info: ChatComponent, icon: &'static str) -> Self {
+        Self { players, max_players, info, icon, cached: None, }
+    }
+    
+    pub fn set(&mut self, update: StatusUpdate) {
+        match update {
+            StatusUpdate::Players(count) => self.players = count,
+            StatusUpdate::MaxPlayers(count) => self.max_players = count,
+            StatusUpdate::Info(component) => self.info = component,
+            StatusUpdate::Icon(icon_data) => self.icon = icon_data,
+        }
+        self.cached = None;
+    }
+    
+    pub fn get(&mut self) -> StatusBytes {
+        self.cached.get_or_insert_with(|| {
+            StatusBytes(Bytes::from(format!(r#"{{
+                "version": {{
+                    "name": "1.8.9",
+                    "protocol": 47
+                }},
+                "players": {{
+                    "max": {},
+                    "online": {}
+                }},
+                "description": {},
+                "favicon": "data:image/png;base64,{}"
+            }}"#, self.max_players, self.players, self.info.serialize(), self.icon)))
+        }).clone()
+    }
+}
+
+pub enum StatusUpdate {
+    Players(u32),
+    MaxPlayers(u32),
+    Info(ChatComponent),
+    Icon(&'static str),
+}

server/src/world/chunk/chunk.rs

@@ -8,7 +8,7 @@ use std::collections::HashSet;
 
 pub struct ChunkSection {
     solid_block_amount: u16,
-    data: [u16; 4096],
+    data: Box<[u16; 4096]>,
 }
 pub struct Chunk {
     pub chunk_sections: [Option<ChunkSection>; 16],
@@ -52,7 +52,7 @@ impl Chunk {
         if self.chunk_sections[section_index].is_none() {
             self.chunk_sections[section_index] = Some(ChunkSection {
                 solid_block_amount: 0,
-                data: [0; 4096],
+                data: Box::new([0; 4096]),
             })
         }
         if let Some(section) = &mut self.chunk_sections[section_index] {
@@ -92,7 +92,7 @@ impl Chunk {
                 if section.solid_block_amount == 0 {
                     continue
                 }
-                for block in section.data {
+                for block in section.data.iter() {
                     data[offset] = (block & 0xFF) as u8;
                     data[offset + 1] = ((block >> 8) & 0xFF) as u8;
                     offset += 2;

src/assets/assets.rs

@@ -15,7 +15,7 @@ pub struct Assets {
     pub dungeon_seeds: Vec<&'static str>,
     pub door_data: HashMap<DoorType, Vec<Vec<Blocks>>>,
     pub room_data: DeterministicHashMap<usize, RoomData>,
-    pub icon_data: String,
+    pub icon_data: &'static str,
 }
 
 impl Assets {

src/assets/load_asset.rs

@@ -107,10 +107,10 @@ impl LoadAsset for DungeonStorageAssets {
 
 impl LoadAsset for FaviconAssets {
     const SUBPATH: &'static str = "favicon.png";
-    type Output = String;
+    type Output = &'static str;
 
     async fn load_asset(path: &Path) -> anyhow::Result<Self::Output> {
         let bytes = fs::read(path.join(Self::SUBPATH)).await?;
-        Ok(general_purpose::STANDARD.encode(&bytes))
+        Ok(Box::leak(general_purpose::STANDARD.encode(&bytes).into_boxed_str()))
     }
 }

src/main.rs

@@ -10,9 +10,10 @@ use server::entity::entity_metadata::{EntityMetadata, EntityVariant};
 use server::inventory::menu::OpenContainer;
 use server::network::internal_packets::NetworkThreadMessage;
 use server::network::network::start_network;
+use server::network::status::Status;
+use server::types::chat_component::{ChatComponent, MCColors};
 use server::utils::seeded_rng::{seeded_rng, SeededRng};
 use server::world::world::World;
-use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::mpsc::error::TryRecvError;
 use tokio::sync::mpsc::UnboundedSender as Sender;
@@ -80,34 +81,13 @@ async fn main() -> anyhow::Result<()> {
     // ^^^ for rooms/doors this is really pointless, because there is no reason to customize them, especially once finalised
     // I can understand it for favicon tho
 
-    let (tx, mut rx) = start_network("127.0.0.1:4972", Arc::new(
-        r#"{
-            "version": {
-                "name": "1.8.9",
-                "protocol": 47
-            },
-            "players": {
-                "max": 1,
-                "online": 0
-            },
-            "description": {
-                "text": "RustClear",
-                "color": "gold",
-                "extra": [
-                    {
-                        "text": " version ",
-                        "color": "gray"
-                    },
-                    {
-                        "text": "{version}",
-                        "color": "green"
-                    }
-                ]
-            },
-            "favicon": "data:image/png;base64,<data>"
-        }"#.into()
-    ));
-
+    let text = ChatComponent::new("RustClear").color(MCColors::Gold)
+        .append(ChatComponent::new(" version ").color(MCColors::Gray))
+        .append(ChatComponent::new(env!("CARGO_PKG_VERSION")).color(MCColors::Green));
+    
+    let status = Status::new(1, 0, text, get_assets().icon_data);
+    let (tx, mut rx) = start_network("127.0.0.1:4972", status);
+    
     let mut tick_interval = tokio::time::interval(Duration::from_millis(50));
     let mut world = initialize_world(tx)?;
     spawn_mort(&mut world);