Run rust fmt

src/main.rs

@@ -1,14 +1,14 @@
+use colored::Colorize;
+use flate2::write::GzEncoder;
+use flate2::Compression;
 use std::fs::{self, File};
 use std::io::prelude::*;
 use std::net::{SocketAddr, TcpListener, TcpStream};
-use std::thread::sleep;
-use std::time::{Duration, UNIX_EPOCH};
-use std::time::SystemTime;
-use std::thread;
 use std::sync::{Arc, Mutex};
-use flate2::Compression;
+use std::thread;
-use flate2::write::GzEncoder;
+use std::thread::sleep;
-use colored::Colorize;
+use std::time::SystemTime;
+use std::time::{Duration, UNIX_EPOCH};
 // #[macro_use]
 // extern crate lazy_static;
 
@@ -25,12 +25,13 @@ impl Default for Player {
             yaw: 0,
             pitch: 0,
             operator: false,
-                outgoing_data: Vec::new()
+            outgoing_data: Vec::new(),
         }
     }
 }
 
-struct Player { // Struct `Player` is never constructed `#[warn(fuck_you)]` on by default
+struct Player {
+    // Struct `Player` is never constructed `#[warn(fuck_you)]` on by default
     pub id: u8,
     pub username: String,
     pub verification_key: [u8; 64],
@@ -41,25 +42,25 @@ struct Player { // Struct `Player` is never constructed `#[warn(fuck_you)]` on b
     pub yaw: u8,
     pub pitch: u8,
     pub operator: bool,
-    pub outgoing_data: Vec<u8>
+    pub outgoing_data: Vec<u8>,
 }
 
 enum SpecialPlayers {
-    SelfPlayer = 0xFF
+    SelfPlayer = 0xFF,
 }
 
 #[derive(Copy, Clone, PartialEq)]
 enum PlayerStatus {
     Disconnected,
     ConnectedSelf,
-    Connected
+    Connected,
 }
 
 struct World {
     pub size_x: i16,
     pub size_y: i16,
     pub size_z: i16,
-    pub data: Vec<u8>
+    pub data: Vec<u8>,
 }
 
 fn build_world(size_x: i16, size_y: i16, size_z: i16) -> Vec<u8> {
@@ -95,7 +96,12 @@ const SIZE_Z: i16 = 64;
 //     };
 // }
 
-fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Arc<Mutex<[Player; 255]>>, world_arc_clone: Arc<Mutex<World>>) {
+fn handle_client(
+    mut stream: TcpStream,
+    client_number: u8,
+    players_arc_clone: Arc<Mutex<[Player; 255]>>,
+    world_arc_clone: Arc<Mutex<World>>,
+) {
     thread::spawn(move || {
         let mut player_statuses = [PlayerStatus::Disconnected; 255];
         let mut immediate_join = [false; 255];
@@ -128,7 +134,9 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
 
                     if payload_buffer[0] != 7 {
                         // Shit pant
-                        let _ = &mut stream.write(&client_disconnect("Something went wrong (CODE: PACKET_SKIPPED)"));
+                        let _ = &mut stream.write(&client_disconnect(
+                            "Something went wrong (CODE: PACKET_SKIPPED)",
+                        ));
                         println!("this client is wiggidy wack yo!");
                         break;
                     }
@@ -184,19 +192,22 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
                                     players[i].position_y,
                                     players[i].position_z,
                                     players[i].yaw,
-                                    players[i].pitch
+                                    players[i].pitch,
                                 ));
                             }
                         }
                     }
-                },
+                }
                 0x05 => {
                     let mut payload_buffer = [0; 8]; // Short (2) + Short (2) + Short (2) + Byte (1) + Byte (1)
                     let _ = stream.read(&mut payload_buffer);
 
-                    let position_x = ((payload_buffer[0] as i16) << (8 as i16)) + payload_buffer[1] as i16;
+                    let position_x =
-                    let position_y = ((payload_buffer[2] as i16) << (8 as i16)) + payload_buffer[3] as i16;
+                        ((payload_buffer[0] as i16) << (8 as i16)) + payload_buffer[1] as i16;
-                    let position_z = ((payload_buffer[4] as i16) << (8 as i16)) + payload_buffer[5] as i16;
+                    let position_y =
+                        ((payload_buffer[2] as i16) << (8 as i16)) + payload_buffer[3] as i16;
+                    let position_z =
+                        ((payload_buffer[4] as i16) << (8 as i16)) + payload_buffer[5] as i16;
 
                     let mode = payload_buffer[6];
                     let mut block_type = payload_buffer[7];
@@ -204,9 +215,14 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
                         let mut world_dat = world_arc_clone.lock().unwrap();
 
                         // Sanity check (Stop losers from losing)
-                        if position_x > world_dat.size_x || position_y > world_dat.size_y || position_z > world_dat.size_z {
+                        if position_x > world_dat.size_x
+                            || position_y > world_dat.size_y
+                            || position_z > world_dat.size_z
+                        {
                             // Fuck you!
-                            let _ = &mut stream.write(&client_disconnect("Block position was not within world bounds, naughty boy"));
+                            let _ = &mut stream.write(&client_disconnect(
+                                "Block position was not within world bounds, naughty boy",
+                            ));
                             break;
                         }
 
@@ -214,7 +230,11 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
                             block_type = 0x00; // Air
                         }
 
-                        let world_offset: u32 = position_x as u32 + (position_z as u32 * world_dat.size_x as u32) + (position_y as u32 * world_dat.size_x as u32 * world_dat.size_z as u32);
+                        let world_offset: u32 = position_x as u32
+                            + (position_z as u32 * world_dat.size_x as u32)
+                            + (position_y as u32
+                                * world_dat.size_x as u32
+                                * world_dat.size_z as u32);
                         world_dat.data[world_offset as usize] = block_type;
                     }
 
@@ -228,10 +248,12 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
                     let mut players = players_arc_clone.lock().unwrap();
                     for i in 0..players.len() {
                         if players[i].id != 255 && players[i].id != client_number {
-                            players[i].outgoing_data.extend_from_slice(&update_block_bytes);
+                            players[i]
+                                .outgoing_data
+                                .extend_from_slice(&update_block_bytes);
+                        }
                     }
                 }
-                },
                 0x08 => {
                     let mut payload_buffer = [0; 9]; // SByte + FShort (2B) + FShort + FShort +
                                                      // Byte + Byte
@@ -244,14 +266,17 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
                     {
                         let mut players = players_arc_clone.lock().unwrap();
                         let current_player = &mut players[client_number as usize];
-                        current_player.position_x = ((payload_buffer[1] as i16) << (8 as i16)) + payload_buffer[2] as i16;
+                        current_player.position_x =
-                        current_player.position_y = ((payload_buffer[3] as i16) << (8 as i16)) + payload_buffer[4] as i16;
+                            ((payload_buffer[1] as i16) << (8 as i16)) + payload_buffer[2] as i16;
-                        current_player.position_z = ((payload_buffer[5] as i16) << (8 as i16)) + payload_buffer[6] as i16;
+                        current_player.position_y =
+                            ((payload_buffer[3] as i16) << (8 as i16)) + payload_buffer[4] as i16;
+                        current_player.position_z =
+                            ((payload_buffer[5] as i16) << (8 as i16)) + payload_buffer[6] as i16;
 
                         current_player.yaw = payload_buffer[7];
                         current_player.pitch = payload_buffer[8];
                     }
-                },
+                }
                 0x0D => {
                     let mut payload_buffer = [0; 65]; // Byte + String
                     let _ = stream.read(&mut payload_buffer);
@@ -270,13 +295,21 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
                     for i in 0..players.len() {
                         if players[i].id != 255 && players[i].id != client_number {
                             let sender: u8 = players[client_number as usize].id;
-                            players[i].outgoing_data.extend_from_slice(&send_chat_message(sender, String::from_iter(message)));
+                            players[i]
+                                .outgoing_data
+                                .extend_from_slice(&send_chat_message(
+                                    sender,
+                                    String::from_iter(message),
+                                ));
                         }
                     }
 
-                    let _ = &mut stream.write(&send_chat_message(SpecialPlayers::SelfPlayer as u8, String::from_iter(message)));
+                    let _ = &mut stream.write(&send_chat_message(
+                        SpecialPlayers::SelfPlayer as u8,
+                        String::from_iter(message),
+                    ));
                     println!("{}", String::from_iter(message));
-                },
+                }
                 _ => println!("Packet {} not implemented!", buffer[0]),
             }
             let is_kill = &mut stream.write(&ping()); // Ping that MF
@@ -302,15 +335,21 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
                                 players[i].position_y,
                                 players[i].position_z,
                                 players[i].yaw,
-                            players[i].pitch
+                                players[i].pitch,
                             ));
                             player_statuses[i] = PlayerStatus::Connected;
-                        let _ = stream.write(&send_chat_message(players[i].id, format!("{} has joined the game!", &players[i].username)));
+                            let _ = stream.write(&send_chat_message(
+                                players[i].id,
+                                format!("{} has joined the game!", &players[i].username),
+                            ));
                         }
                     } else {
                         if player_statuses[i] == PlayerStatus::Connected {
                             let _ = stream.write(&despawn_player(i.try_into().unwrap()));
-                        let _ = stream.write(&send_chat_message(i.try_into().unwrap(), format!("{} has left the game!", &players[i].username)));
+                            let _ = stream.write(&send_chat_message(
+                                i.try_into().unwrap(),
+                                format!("{} has left the game!", &players[i].username),
+                            ));
                             player_statuses[i] = PlayerStatus::Disconnected;
                         }
                     }
@@ -321,7 +360,7 @@ fn handle_client(mut stream: TcpStream, client_number: u8, players_arc_clone: Ar
                             players[i].position_y,
                             players[i].position_z,
                             players[i].yaw,
-                        players[i].pitch
+                            players[i].pitch,
                         ));
                     }
                 }
@@ -383,9 +422,15 @@ fn client_disconnect(text: &str) -> Vec<u8> {
 fn server_identification(is_op: bool) -> Vec<u8> {
     let mut ret_val: Vec<u8> = vec![];
     ret_val.push(0x00);
-    let start = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+    let start = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
     ret_val.push(0x07);
-    let end = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+    let end = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
     println!("Single stream write: {}ns", end - start);
 
     let server_name = "Erm... what the sigma?";
@@ -424,7 +469,15 @@ fn finalize_level(world_arc_clone: &Arc<Mutex<World>>) -> Vec<u8> {
     return ret_val;
 }
 
-fn spawn_player(player_id: u8, name: &String, pos_x: i16, pos_y: i16, pos_z: i16, yaw: u8, pitch: u8) -> Vec<u8> {
+fn spawn_player(
+    player_id: u8,
+    name: &String,
+    pos_x: i16,
+    pos_y: i16,
+    pos_z: i16,
+    yaw: u8,
+    pitch: u8,
+) -> Vec<u8> {
     let mut ret_val: Vec<u8> = vec![];
     ret_val.push(0x07);
 
@@ -466,7 +519,14 @@ fn send_chat_message(source_id: u8, message: String) -> Vec<u8> {
 //    Ok(())
 //}
 
-fn set_position_and_orientation(player_id: u8, pos_x: i16, pos_y: i16, pos_z: i16, yaw: u8, pitch: u8) -> Vec<u8> {
+fn set_position_and_orientation(
+    player_id: u8,
+    pos_x: i16,
+    pos_y: i16,
+    pos_z: i16,
+    yaw: u8,
+    pitch: u8,
+) -> Vec<u8> {
     let mut ret_val: Vec<u8> = vec![];
     ret_val.push(0x08);
 
@@ -531,7 +591,9 @@ fn send_level_data(world_arc_clone: &Arc<Mutex<World>>) -> Vec<u8> {
     if remaining_chunk_size > 0 {
         ret_val.push(0x03);
 
-        ret_val.append(&mut stream_write_short(remaining_chunk_size.try_into().unwrap()));
+        ret_val.append(&mut stream_write_short(
+            remaining_chunk_size.try_into().unwrap(),
+        ));
 
         let mut remaining_data_buffer = [0u8; 1024];
         for i in 0..remaining_chunk_size {
@@ -542,7 +604,10 @@ fn send_level_data(world_arc_clone: &Arc<Mutex<World>>) -> Vec<u8> {
         ret_val.push(100);
     }
 
-    println!("World transmission size: {}KiB", ret_val.len() as f32 / 1024.0);
+    println!(
+        "World transmission size: {}KiB",
+        ret_val.len() as f32 / 1024.0
+    );
     return ret_val;
 }
 
@@ -565,7 +630,12 @@ fn save_world(world_arc_clone: Arc<Mutex<World>>) -> std::io::Result<()> {
 
 fn load_world() -> World {
     if fs::metadata("world.wrld").is_ok() {
-        let mut world: World = World {size_x: 0, size_y: 0, size_z: 0, data: Vec::new()};
+        let mut world: World = World {
+            size_x: 0,
+            size_y: 0,
+            size_z: 0,
+            data: Vec::new(),
+        };
         let world_data_raw = fs::read("world.wrld").unwrap();
         if world_data_raw.len() < 6 {
             println!("INVALID WORLD!");
@@ -575,8 +645,14 @@ fn load_world() -> World {
         world.size_y = ((world_data_raw[2] as i16) << 8) + (world_data_raw[3] as i16);
         world.size_z = ((world_data_raw[4] as i16) << 8) + (world_data_raw[5] as i16);
 
-        if world_data_raw.len() != (world.size_x as i32 * world.size_y as i32 * world.size_z as i32 + 6 as i32) as usize {
+        if world_data_raw.len()
-            println!("Expected more bytes in world contents: {} (expected) != {} (actual)", world.size_x * world.size_y * world.size_z + 6, world_data_raw.len());
+            != (world.size_x as i32 * world.size_y as i32 * world.size_z as i32 + 6 as i32) as usize
+        {
+            println!(
+                "Expected more bytes in world contents: {} (expected) != {} (actual)",
+                world.size_x * world.size_y * world.size_z + 6,
+                world_data_raw.len()
+            );
             std::process::exit(1);
         }
 
@@ -584,11 +660,20 @@ fn load_world() -> World {
 
         return world;
     } else {
-        return World {size_x: SIZE_X, size_y: SIZE_Y, size_z: SIZE_Z, data: build_world(SIZE_X, SIZE_Y, SIZE_Z)};
+        return World {
+            size_x: SIZE_X,
+            size_y: SIZE_Y,
+            size_z: SIZE_Z,
+            data: build_world(SIZE_X, SIZE_Y, SIZE_Z),
+        };
     }
 }
 
-fn bomb_server_details(stream: &mut TcpStream, current_player: &Player, world_arc_clone: &Arc<Mutex<World>>) {
+fn bomb_server_details(
+    stream: &mut TcpStream,
+    current_player: &Player,
+    world_arc_clone: &Arc<Mutex<World>>,
+) {
     let mut compound_data: Vec<u8> = vec![];
     println!("Server IDENT");
     compound_data.append(&mut server_identification(current_player.operator));
@@ -603,7 +688,15 @@ fn bomb_server_details(stream: &mut TcpStream, current_player: &Player, world_ar
     compound_data.append(&mut finalize_level(&world_arc_clone));
 
     println!("Spawning player");
-    compound_data.append(&mut spawn_player(SpecialPlayers::SelfPlayer as u8, &current_player.username, 32, 17, 32, 0, 0));
+    compound_data.append(&mut spawn_player(
+        SpecialPlayers::SelfPlayer as u8,
+        &current_player.username,
+        32,
+        17,
+        32,
+        0,
+        0,
+    ));
 
     let _ = stream.write(&compound_data);
 }
@@ -617,16 +710,41 @@ fn _create_player_info_window(client_number: u8, players_arc_clone: Arc<Mutex<[P
                 let current_player = &mut players[client_number as usize];
 
                 if current_player.id == 255 && thread_alive == true {
-                    println!("[{}{}] {} has disconnected!", "THREAD: ".cyan(), client_number, current_player.username);
+                    println!(
+                        "[{}{}] {} has disconnected!",
+                        "THREAD: ".cyan(),
+                        client_number,
+                        current_player.username
+                    );
                     break;
                 } else {
                     thread_alive = true;
                 }
 
-                println!("[{}{}] id:    {}", "THREAD: ".cyan(), client_number, current_player.id);
+                println!(
-                println!("[{}{}] pos_x: {}", "THREAD: ".cyan(), client_number, current_player.position_x >> 5);
+                    "[{}{}] id:    {}",
-                println!("[{}{}] pos_y: {}", "THREAD: ".cyan(), client_number, current_player.position_y >> 5);
+                    "THREAD: ".cyan(),
-                println!("[{}{}] pos_z: {}", "THREAD: ".cyan(), client_number, current_player.position_z >> 5);
+                    client_number,
+                    current_player.id
+                );
+                println!(
+                    "[{}{}] pos_x: {}",
+                    "THREAD: ".cyan(),
+                    client_number,
+                    current_player.position_x >> 5
+                );
+                println!(
+                    "[{}{}] pos_y: {}",
+                    "THREAD: ".cyan(),
+                    client_number,
+                    current_player.position_y >> 5
+                );
+                println!(
+                    "[{}{}] pos_z: {}",
+                    "THREAD: ".cyan(),
+                    client_number,
+                    current_player.position_z >> 5
+                );
             }
             sleep(Duration::from_millis(200));
         }
@@ -650,7 +768,8 @@ fn main() -> std::io::Result<()> {
     ctrlc::set_handler(move || {
         let _ = save_world(world_arc_clone_main_thread.clone()); // Fortnite save the world
         std::process::exit(0);
-    }).expect("Error handling control C, save on exit will not work");
+    })
+    .expect("Error handling control C, save on exit will not work");
 
     for stream in listener.incoming() {
         let players_arc_clone = Arc::clone(&players_arc);

wrld.hexpat

@@ -0,0 +1,12 @@
+#pragma endian big
+
+struct Header {
+    u16 size_x ;
+    u16 size_y;
+    u16 size_z;
+    u8 blocks[size_x*size_y*size_z];
+};
+
+
+
+Header Data @ 0x00;