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();
-    sections.push(Tag::Compound(section));
+    let sections = vec![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,8 +13,9 @@ 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(dim) = world.overworld_mut() {
+            if let Some(ref mut world) = self.world
+                && let Some(dim) = world.overworld_mut()
+            {
                 let inv = op.inverse();
                 if let Err(e) = inv.apply(dim) {
                     self.status_message = format!("Undo error: {:?}", e);
@@ -25,7 +26,6 @@ impl TerrafierApp {
                 self.status_message = "Undo".to_string();
                 return;
             }
-            }
             self.undo_stack.push_back(op);
             self.status_message = "Undo error: world has no overworld".to_string();
         } else {
@@ -35,8 +35,9 @@ 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(dim) = world.overworld_mut() {
+            if let Some(ref mut world) = self.world
+                && let Some(dim) = world.overworld_mut()
+            {
                 if let Err(e) = op.apply(dim) {
                     self.status_message = format!("Redo error: {:?}", e);
                     self.redo_stack.push(op);
@@ -46,7 +47,6 @@ impl TerrafierApp {
                 self.status_message = "Redo".to_string();
                 return;
             }
-            }
             self.redo_stack.push(op);
             self.status_message = "Redo error: world has no overworld".to_string();
         } else {

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
-                    .heightmap
-                    .as_slice()
-                    .try_into()
-                    .unwrap_or_else(|_| [0; 16384]),
-                &tile
-                    .terrain
-                    .as_slice()
-                    .try_into()
-                    .unwrap_or_else(|_| [0; 16384]),
+                &tile.heightmap.as_slice().try_into().unwrap_or([0; 16384]),
+                &tile.terrain.as_slice().try_into().unwrap_or([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,9 +151,10 @@ pub fn render(ui: &mut egui::Ui, app: &mut crate::app::TerrafierApp) {
                 };
 
                 for li in 0..6 {
-                    if app.layer_visible[li] {
-                        if let Some(val) = layer_value(tile, idx, li) {
-                            if let Some(over) = layer_overlay(li, val) {
+                    if app.layer_visible[li]
+                        && let Some(val) = layer_value(tile, idx, li)
+                        && let Some(over) = layer_overlay(li, val)
+                    {
                         let alpha = if val > 0.0 {
                             (val * 0.6 + 0.2).min(0.8)
                         } else {
@@ -163,8 +163,6 @@ pub fn render(ui: &mut egui::Ui, app: &mut crate::app::TerrafierApp) {
                         (r, g, b) = blend_overlay((r, g, b), over, alpha);
                     }
                 }
-                    }
-                }
 
                 let di = (pz + ly) * grid_w + (px + lx);
                 img_data[di * 4] = r;