fmt

client/src/lib.rs

@@ -14,13 +14,13 @@ use common::{
     state::State,
     terrain::chonk::ChonkMetrics,
 };
+use log::info;
 use std::{
     collections::HashMap,
     net::SocketAddr,
     time::{Duration, Instant},
 };
 use threadpool::ThreadPool;
-use log::info;
 use vek::*;
 
 const SERVER_TIMEOUT: Duration = Duration::from_secs(20);
@@ -313,7 +313,8 @@ impl Client {
 
         // Output debug metrics
         if DEBUG_METRICS && self.tick % 600 == 0 {
-            let metrics = self.state
+            let metrics = self
+                .state
                 .terrain()
                 .iter()
                 .fold(ChonkMetrics::default(), |a, (_, c)| a + c.get_metrics());

common/src/terrain/chonk.rs

@@ -4,10 +4,7 @@ use crate::{
     volumes::chunk::{Chunk, ChunkErr},
 };
 use serde_derive::{Deserialize, Serialize};
-use std::{
+use std::{collections::HashMap, ops::Add};
-    ops::Add,
-    collections::HashMap,
-};
 use vek::*;
 
 #[derive(Debug)]
@@ -49,17 +46,29 @@ impl Chonk {
     pub fn get_metrics(&self) -> ChonkMetrics {
         ChonkMetrics {
             chonks: 1,
-            homogeneous: self.sub_chunks
+            homogeneous: self
+                .sub_chunks
                 .iter()
-                .filter(|s| match s { SubChunk::Homogeneous(_) => true, _ => false })
+                .filter(|s| match s {
+                    SubChunk::Homogeneous(_) => true,
+                    _ => false,
+                })
                 .count(),
-            hash: self.sub_chunks
+            hash: self
+                .sub_chunks
                 .iter()
-                .filter(|s| match s { SubChunk::Hash(_, _) => true, _ => false })
+                .filter(|s| match s {
+                    SubChunk::Hash(_, _) => true,
+                    _ => false,
+                })
                 .count(),
-            heterogeneous: self.sub_chunks
+            heterogeneous: self
+                .sub_chunks
                 .iter()
-                .filter(|s| match s { SubChunk::Heterogeneous(_) => true, _ => false })
+                .filter(|s| match s {
+                    SubChunk::Heterogeneous(_) => true,
+                    _ => false,
+                })
                 .count(),
         }
     }
@@ -124,8 +133,8 @@ impl WriteVol for Chonk {
             self.sub_chunks.push(SubChunk::Homogeneous(self.above));
         }
 
-        let rpos = pos
+        let rpos =
-            - Vec3::unit_z() * (self.z_offset + sub_chunk_idx as i32 * SUB_CHUNK_HEIGHT as i32);
+            pos - Vec3::unit_z() * (self.z_offset + sub_chunk_idx as i32 * SUB_CHUNK_HEIGHT as i32);
 
         match &mut self.sub_chunks[sub_chunk_idx] {
             // Can't fail
@@ -136,23 +145,25 @@ impl WriteVol for Chonk {
 
                 self.sub_chunks[sub_chunk_idx] = SubChunk::Hash(*cblock, map);
                 Ok(())
-            },
+            }
             SubChunk::Hash(cblock, map) if block == *cblock => Ok(()),
             SubChunk::Hash(cblock, map) if map.len() < 4096 => {
                 map.insert(rpos.map(|e| e as u8), block);
                 Ok(())
-            },
+            }
             SubChunk::Hash(cblock, map) => {
                 let mut new_chunk = Chunk::filled(*cblock, ());
                 new_chunk.set(rpos, block).unwrap(); // Can't fail (I hope)
 
                 for (map_pos, map_block) in map {
-                    new_chunk.set(map_pos.map(|e| e as i32), *map_block).unwrap(); // Can't fail (I hope!)
+                    new_chunk
+                        .set(map_pos.map(|e| e as i32), *map_block)
+                        .unwrap(); // Can't fail (I hope!)
                 }
 
                 self.sub_chunks[sub_chunk_idx] = SubChunk::Heterogeneous(new_chunk);
                 Ok(())
-            },
+            }
 
             /*
             SubChunk::Homogeneous(cblock) => {

world/src/lib.rs

@@ -49,7 +49,8 @@ impl World {
 
         let warp_nz = BasicMulti::new().set_octaves(3).set_seed(self.sim.seed + 0);
 
-        let base_z = match self.sim
+        let base_z = match self
+            .sim
             .get(chunk_pos.map(|e| e as u32))
             .map(|chunk| chunk.get_base_z())
         {