Fix all clippy warnings: collapsible_if, for_kv_map, vec_init_then_push, let_and_return, manual_div_ceil, useless_conversion, needless_borrows, manual_is_multiple_of, new_without_default, unnecessary_lazy_evaluations

core/src/io/minecraft/export/writer.rs

@@ -21,6 +21,7 @@ fn dim_region_path(output_path: &Path, dim_name: &str) -> std::path::PathBuf {
     }
 }
 
+#[allow(clippy::type_complexity)]
 fn write_dimension(
     dim: &crate::model::dimension::Dimension,
     output_path: &Path,

core/tests/golden_test.rs

@@ -63,8 +63,7 @@ fn make_chunk_nbt_gzip(cx: i32, cz: i32) -> Vec<u8> {
     biomes.insert("palette".into(), Tag::List(biome_palette));
     section.insert("biomes".into(), Tag::Compound(biomes));
 
-    let mut sections = Vec::new();
+    let sections = vec![Tag::Compound(section)];
-    sections.push(Tag::Compound(section));
     chunk.insert("sections".into(), Tag::List(sections));
 
     to_gzip_bytes(&Tag::Compound(chunk)).unwrap()
@@ -133,7 +132,7 @@ fn test_golden_mca_roundtrip() {
     std::fs::create_dir_all(world_path.join("region")).unwrap();
 
     // Write level.dat
-    std::fs::write(world_path.join("level.dat"), &make_level_dat()).unwrap();
+    std::fs::write(world_path.join("level.dat"), make_level_dat()).unwrap();
 
     // Build and write region r.0.0.mca
     let chunk_gzip = make_chunk_nbt_gzip(0, 0);

crates/scripting/src/lib.rs

@@ -52,7 +52,7 @@ fn generate_heightmap_flat_fn(
     let flat = FlatHeightMap {
         height: height as i16,
     };
-    for (_, tile) in &mut dim.tiles {
+    for tile in dim.tiles.values_mut() {
         flat.generate(tile, world.seed);
     }
     Ok(())
@@ -77,7 +77,7 @@ fn generate_heightmap_noise_fn(
         scale_x: 1.0,
         scale_z: 1.0,
     };
-    for (_, tile) in &mut dim.tiles {
+    for tile in dim.tiles.values_mut() {
         noise.generate(tile, seed as u64);
     }
     Ok(())
@@ -117,12 +117,18 @@ fn generate_layers_fn(world: &mut World, dim_name: &str) -> Result<(), Box<EvalA
         .iter_mut()
         .find(|d| d.name == dim_name)
         .ok_or_else(|| format!("Dimension '{}' not found", dim_name))?;
-    for (_, tile) in &mut dim.tiles {
+    for tile in dim.tiles.values_mut() {
         generate_all_layers(tile, world.seed);
     }
     Ok(())
 }
 
+impl Default for ScriptEngine {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ScriptEngine {
     pub fn new() -> Self {
         let mut engine = Engine::new();

crates/scripting/tests/integration_test.rs

@@ -32,7 +32,7 @@ fn test_generate_flat_heightmap() {
         .unwrap();
     let loaded: World = terrafier_core::io::load_binary(Path::new("/tmp/test_flat.tfw")).unwrap();
     if let Some(dim) = loaded.dimensions.first() {
-        for (_, tile) in &dim.tiles {
+        for tile in dim.tiles.values() {
             for z in 0..128 {
                 for x in 0..128 {
                     assert_eq!(tile.get_height(x, z), 64);

crates/wasm-host/src/host.rs

@@ -107,7 +107,7 @@ fn host_alloc_buffers(mut caller: Caller<'_, WorldContext>) -> i32 {
     };
     let needed_bytes = TOTAL_BUFFER;
     let current_size = mem.data_size(&caller);
-    let pages_needed = (needed_bytes + current_size + 65535) / 65536 - current_size / 65536;
+    let pages_needed = (needed_bytes + current_size).div_ceil(65536) - current_size / 65536;
     if mem.grow(&mut caller, pages_needed as u64).is_err() {
         return -1;
     }

crates/wasm-host/src/plugin.rs

@@ -98,7 +98,7 @@ impl WasmTileSourcePlugin {
         tile_z: i32,
     ) -> Result<(Store<WorldContext>, Instance), WasmHostError> {
         let mut linker = Linker::new(&self.engine);
-        register_host_functions(&mut linker).map_err(|e| WasmHostError::LoadError(e.into()))?;
+        register_host_functions(&mut linker).map_err(WasmHostError::LoadError)?;
 
         let ctx = WorldContext {
             tile: tile.clone(),

gui/src/app/ops.rs

@@ -13,18 +13,18 @@ impl TerrafierApp {
 
     pub fn undo(&mut self) {
         if let Some(op) = self.undo_stack.pop_back() {
-            if let Some(ref mut world) = self.world {
+            if let Some(ref mut world) = self.world
-                if let Some(dim) = world.overworld_mut() {
+                && let Some(dim) = world.overworld_mut()
-                    let inv = op.inverse();
+            {
-                    if let Err(e) = inv.apply(dim) {
+                let inv = op.inverse();
-                        self.status_message = format!("Undo error: {:?}", e);
+                if let Err(e) = inv.apply(dim) {
-                        self.undo_stack.push_back(op);
+                    self.status_message = format!("Undo error: {:?}", e);
-                        return;
+                    self.undo_stack.push_back(op);
-                    }
-                    self.redo_stack.push(op);
-                    self.status_message = "Undo".to_string();
                     return;
                 }
+                self.redo_stack.push(op);
+                self.status_message = "Undo".to_string();
+                return;
             }
             self.undo_stack.push_back(op);
             self.status_message = "Undo error: world has no overworld".to_string();
@@ -35,17 +35,17 @@ impl TerrafierApp {
 
     pub fn redo(&mut self) {
         if let Some(op) = self.redo_stack.pop() {
-            if let Some(ref mut world) = self.world {
+            if let Some(ref mut world) = self.world
-                if let Some(dim) = world.overworld_mut() {
+                && let Some(dim) = world.overworld_mut()
-                    if let Err(e) = op.apply(dim) {
+            {
-                        self.status_message = format!("Redo error: {:?}", e);
+                if let Err(e) = op.apply(dim) {
-                        self.redo_stack.push(op);
+                    self.status_message = format!("Redo error: {:?}", e);
-                        return;
+                    self.redo_stack.push(op);
-                    }
-                    self.undo_stack.push_back(op);
-                    self.status_message = "Redo".to_string();
                     return;
                 }
+                self.undo_stack.push_back(op);
+                self.status_message = "Redo".to_string();
+                return;
             }
             self.redo_stack.push(op);
             self.status_message = "Redo error: world has no overworld".to_string();

gui/src/app/update.rs

@@ -71,16 +71,8 @@ impl eframe::App for TerrafierApp {
             && let Some(tile) = world.dimensions[0].tiles.values().next()
         {
             renderer.render(
-                &tile
+                &tile.heightmap.as_slice().try_into().unwrap_or([0; 16384]),
-                    .heightmap
+                &tile.terrain.as_slice().try_into().unwrap_or([0; 16384]),
-                    .as_slice()
-                    .try_into()
-                    .unwrap_or_else(|_| [0; 16384]),
-                &tile
-                    .terrain
-                    .as_slice()
-                    .try_into()
-                    .unwrap_or_else(|_| [0; 16384]),
                 self.show_heightmap,
             );
 

gui/src/view/cpu.rs

@@ -24,7 +24,7 @@ fn layer_value(
 ) -> Option<f32> {
     let layer_id = LAYER_IDS[layer_idx];
     let buf = tile.layer_data.get(&layer_id)?;
-    let val = match buf {
+    match buf {
         LayerBuffer::Bit(data) => {
             let word = data.get(idx / 64)?;
             Some(if (word >> (idx % 64)) & 1 != 0 {
@@ -35,7 +35,7 @@ fn layer_value(
         }
         LayerBuffer::Nibble(data) => {
             let byte = *data.get(idx / 2)?;
-            let nib = if idx % 2 == 0 {
+            let nib = if idx.is_multiple_of(2) {
                 byte & 0x0F
             } else {
                 (byte >> 4) & 0x0F
@@ -47,8 +47,7 @@ fn layer_value(
             Some(v / 255.0)
         }
         LayerBuffer::Int(_) => None,
-    };
+    }
-    val
 }
 
 fn layer_overlay(layer_idx: usize, value: f32) -> Option<(u8, u8, u8)> {
@@ -152,17 +151,16 @@ pub fn render(ui: &mut egui::Ui, app: &mut crate::app::TerrafierApp) {
                 };
 
                 for li in 0..6 {
-                    if app.layer_visible[li] {
+                    if app.layer_visible[li]
-                        if let Some(val) = layer_value(tile, idx, li) {
+                        && let Some(val) = layer_value(tile, idx, li)
-                            if let Some(over) = layer_overlay(li, val) {
+                        && let Some(over) = layer_overlay(li, val)
-                                let alpha = if val > 0.0 {
+                    {
-                                    (val * 0.6 + 0.2).min(0.8)
+                        let alpha = if val > 0.0 {
-                                } else {
+                            (val * 0.6 + 0.2).min(0.8)
-                                    0.0
+                        } else {
-                                };
+                            0.0
-                                (r, g, b) = blend_overlay((r, g, b), over, alpha);
+                        };
-                            }
+                        (r, g, b) = blend_overlay((r, g, b), over, alpha);
-                        }
                     }
                 }