[RS] formatted source code with 'cargo fmt'

Author: TrifanBogdan24

method-rs/src/.gitignore method-rs/.gitignoremethod-rs/src/.gitignore renamed to method-rs/.gitignore

@@ -2,12 +2,7 @@ use std::fs::{self, File};
 use std::io::{BufRead, BufReader, Write};
 use std::path::Path;
 
-pub fn print_chunk(
-    chunk: &Vec<Vec<Vec<u8>>>,
-    width: usize,
-    height: usize,
-    depth: usize
-) {
+pub fn print_chunk(chunk: &Vec<Vec<Vec<u8>>>, width: usize, height: usize, depth: usize) {
     for x in 0..width {
         for y in (0..height).rev() {
             for z in 0..depth {
@@ -18,11 +13,9 @@ pub fn print_chunk(
     }
 }
 
-
 pub fn fread_chunk(file_in: &str) -> (Vec<Vec<Vec<u8>>>, usize, usize, usize) {
     // Read the whole file as a string
-    let input = fs::read_to_string(file_in)
-        .expect("Failed to read params file");
+    let input = fs::read_to_string(file_in).expect("Failed to read params file");
 
     let mut lines = input.lines();
 
@@ -77,53 +70,58 @@ pub fn fread_chunk(file_in: &str) -> (Vec<Vec<Vec<u8>>>, usize, usize, usize) {
     (chunk, width, height, depth)
 }
 
-
 pub fn fread_block_coordinates(file_params: &str) -> (isize, isize, isize, u8) {
     let file = File::open(file_params).unwrap();
     let mut reader = BufReader::new(file);
 
     let mut line = String::new();
-    reader.read_line(&mut line).unwrap(); 
+    reader.read_line(&mut line).unwrap();
 
     // Split line by whitespace
     let mut parts = line.trim().split_whitespace();
 
-    let x: isize = parts.next().expect("Missing x")
-        .parse().expect("Invalid x");
-    let y: isize = parts.next().expect("Missing y")
-        .parse().expect("Invalid y");
-    let z: isize = parts.next().expect("Missing z")
-        .parse().expect("Invalid z");
+    let x: isize = parts.next().expect("Missing x").parse().expect("Invalid x");
+    let y: isize = parts.next().expect("Missing y").parse().expect("Invalid y");
+    let z: isize = parts.next().expect("Missing z").parse().expect("Invalid z");
 
-    let block: u8 = parts.next().expect("Missing block")
-        .parse().expect("Invalid block");
+    let block: u8 = parts
+        .next()
+        .expect("Missing block")
+        .parse()
+        .expect("Invalid block");
 
     (x, y, z, block)
 }
 
-
 pub fn fread_chunk_sizes(file_params: &str) -> (usize, usize, usize) {
     let file = File::open(file_params).unwrap();
     let mut reader = BufReader::new(file);
 
     let mut line = String::new();
-    reader.read_line(&mut line).unwrap(); 
+    reader.read_line(&mut line).unwrap();
 
     // Split line by whitespace
     let mut parts = line.trim().split_whitespace();
 
-    let width: usize = parts.next().expect("Missing width")
-        .parse().expect("Invalid width");
-    let height: usize = parts.next().expect("Missing height")
-        .parse().expect("Invalid height");
-    let depth: usize = parts.next().expect("Missing depth")
-        .parse().expect("Invalid depth");
-
+    let width: usize = parts
+        .next()
+        .expect("Missing width")
+        .parse()
+        .expect("Invalid width");
+    let height: usize = parts
+        .next()
+        .expect("Missing height")
+        .parse()
+        .expect("Invalid height");
+    let depth: usize = parts
+        .next()
+        .expect("Missing depth")
+        .parse()
+        .expect("Invalid depth");
 
     (width, height, depth)
 }
 
-
 fn create_file_out(file_out: &str) -> File {
     let path = Path::new(file_out);
 
@@ -135,16 +133,15 @@ fn create_file_out(file_out: &str) -> File {
         ));
     }
 
-    File::create(path)
-        .expect(&format!("[ERROR] cannot create {:?} output file", file_out))
+    File::create(path).expect(&format!("[ERROR] cannot create {:?} output file", file_out))
 }
 
 pub fn fwrite_chunk(
     file_out: &str,
     chunk: &Vec<Vec<Vec<u8>>>,
     width: usize,
     height: usize,
-    depth: usize
+    depth: usize,
 ) {
     let mut file: File = create_file_out(file_out);
     writeln!(file, "{}", width).expect("Failed to write width");
@@ -162,16 +159,12 @@ pub fn fwrite_chunk(
     }
 }
 
-pub fn fwrite_encode(
-    file_out: &str,
-    code: &[u8]
-) {
+pub fn fwrite_encode(file_out: &str, code: &[u8]) {
     let mut file: File = create_file_out(file_out);
-    file.write(&code).expect(&format!("Cannot write bytes in {}", file_out));
+    file.write(&code)
+        .expect(&format!("Cannot write bytes in {}", file_out));
 }
 
-
 pub fn fread_code(file_in: &str) -> Vec<u8> {
-    return fs::read(file_in)
-        .expect(&format!("[ERROR] cannot read {:?} file", file_in));
-}
+    return fs::read(file_in).expect(&format!("[ERROR] cannot read {:?} file", file_in));
+}

method-rs/coding_style.txt

@@ -1,9 +1,9 @@
 pub mod libchunk {
     pub mod chunk;
+    pub mod chunk_compress;
     pub mod chunk_gen;
     pub mod chunk_process;
     pub mod chunk_transform;
-    pub mod chunk_compress;
 }
 
 pub mod chunk_io;

method-rs/src/chunk_io.rs

@@ -1,11 +1,10 @@
 use crate::libchunk::chunk::BLOCK_AIR;
 use crate::libchunk::chunk::*;
 
-
 #[derive(Default)]
 struct Run {
     num_occurrences: usize,
-    block: u8
+    block: u8,
 }
 
 const B0: usize = 0;
@@ -16,17 +15,9 @@ const B11: usize = 11;
 const IDX_BIT_B1: usize = 7;
 const IDX_BIT_B0: usize = 6;
 
-
 const MAX_NUM_OCCURRENCES: usize = 4095;
 
-
-
-fn flatten(
-    chunk: &Vec<Vec<Vec<u8>>>,
-    width: usize,
-    height: usize,
-    depth: usize,
-) -> Vec<u8> {
+fn flatten(chunk: &Vec<Vec<Vec<u8>>>, width: usize, height: usize, depth: usize) -> Vec<u8> {
     let mut array: Vec<u8> = vec![0; width * height * depth];
 
     for y in 0..height {
@@ -54,37 +45,45 @@ fn get_runs(flat_chunk: &[u8]) -> Vec<Run> {
 
     while idx < flat_chunk.len() {
         if last_block != flat_chunk[idx] {
-            runs.push(Run{num_occurrences: num_occurrences, block: last_block});
+            runs.push(Run {
+                num_occurrences: num_occurrences,
+                block: last_block,
+            });
             last_block = flat_chunk[idx];
             num_occurrences = 1;
         } else {
             num_occurrences += 1;
         }
 
         if num_occurrences == MAX_NUM_OCCURRENCES {
-            runs.push(Run{num_occurrences: MAX_NUM_OCCURRENCES, block: last_block});
+            runs.push(Run {
+                num_occurrences: MAX_NUM_OCCURRENCES,
+                block: last_block,
+            });
             num_occurrences = 0;
         }
 
         idx += 1;
     }
 
     if num_occurrences > 0 {
-        runs.push(Run{num_occurrences: num_occurrences, block: last_block});
-    } 
+        runs.push(Run {
+            num_occurrences: num_occurrences,
+            block: last_block,
+        });
+    }
 
     runs
 }
 
-
 fn encode_run(bytes: &mut Vec<u8>, run: &Run) {
     let mut byte = 0u8;
 
     match run.block {
         BLOCK_GRASS => byte |= 1 << IDX_BIT_B0,
         BLOCK_WOOD => byte |= 1 << IDX_BIT_B1,
         BLOCK_STONE => byte |= (1 << IDX_BIT_B0) | (1 << IDX_BIT_B1),
-        _ => ()
+        _ => (),
     }
 
     if run.num_occurrences < (1 << B5) {
@@ -97,7 +96,7 @@ fn encode_run(bytes: &mut Vec<u8>, run: &Run) {
         bytes.push(byte);
     } else {
         // bb10nnnn nnnnnnnn
-        
+
         byte |= 1 << B5;
 
         // Primul octet:
@@ -119,7 +118,6 @@ fn encode_run(bytes: &mut Vec<u8>, run: &Run) {
     }
 }
 
-
 pub fn chunk_encode(
     chunk: &Vec<Vec<Vec<u8>>>,
     width: usize,
@@ -147,14 +145,16 @@ pub fn chunk_decode(
     let mut idx: usize = 0;
 
     while idx < code.len() {
-        let block: u8 = match (code[idx] & (1 << IDX_BIT_B1) > 0, code[idx] & (1 << IDX_BIT_B0) > 0)  {
+        let block: u8 = match (
+            code[idx] & (1 << IDX_BIT_B1) > 0,
+            code[idx] & (1 << IDX_BIT_B0) > 0,
+        ) {
             (true, true) => BLOCK_STONE,  // b1b0 = 11
             (true, false) => BLOCK_WOOD,  // b1b0 = 10
             (false, true) => BLOCK_GRASS, // b1b0 = 01
-            _ => BLOCK_AIR                // b1b0 = 00
+            _ => BLOCK_AIR,               // b1b0 = 00
         };
 
-
         let mut num_occurrences = 0usize;
 
         if code[idx] & (1 << B5) == 0 {

method-rs/src/lib.rs

@@ -1,37 +1,42 @@
-use std::cmp::{min, max};
-
-pub fn is_inside(
-    width: usize, height: usize, depth: usize,
-    x: isize, y: isize, z: isize
-) -> bool {
-    0 <= x && x < (width as isize)
-    && 0 <= y && y < (height as isize)
-    && 0 <= z && z < (depth as isize)
-
+use std::cmp::{max, min};
+
+pub fn is_inside(width: usize, height: usize, depth: usize, x: isize, y: isize, z: isize) -> bool {
+    0 <= x
+        && x < (width as isize)
+        && 0 <= y
+        && y < (height as isize)
+        && 0 <= z
+        && z < (depth as isize)
 }
 
-
 pub fn chunk_place_block(
     chunk: &mut Vec<Vec<Vec<u8>>>,
-    width: usize, height: usize, depth: usize,
-    x: isize, y: isize, z: isize,
-    block: u8
+    width: usize,
+    height: usize,
+    depth: usize,
+    x: isize,
+    y: isize,
+    z: isize,
+    block: u8,
 ) {
     if !is_inside(width, height, depth, x, y, z) {
         return;
     }
     chunk[x as usize][y as usize][z as usize] = block;
 }
 
-
-
-
 pub fn chunk_fill_cuboid(
     chunk: &mut Vec<Vec<Vec<u8>>>,
-    width: usize, height: usize, depth: usize,
-    x0: isize, y0: isize, z0: isize,
-    x1: isize, y1: isize, z1: isize,
-    block: u8
+    width: usize,
+    height: usize,
+    depth: usize,
+    x0: isize,
+    y0: isize,
+    z0: isize,
+    x1: isize,
+    y1: isize,
+    z1: isize,
+    block: u8,
 ) {
     let min_x = max(min(x0, x1), 0isize);
     let min_y = max(min(y0, y1), 0isize);
@@ -44,31 +49,26 @@ pub fn chunk_fill_cuboid(
     for x in min_x..=max_x {
         for y in min_y..=max_y {
             for z in min_z..=max_z {
-                chunk_place_block(
-                    chunk, width, height, depth, 
-                    x, y, z, block);
+                chunk_place_block(chunk, width, height, depth, x, y, z, block);
             }
-        } 
+        }
     }
 }
 
-
-fn euclidian_dist(
-    x0: isize, y0: isize, z0: isize,
-    x1: isize, y1: isize, z1: isize
-) -> f32 {
-    (
-        (x0 - x1).pow(2) as f32
-        + (y0 - y1).pow(2) as f32
-        + (z0 - z1).pow(2) as f32
-    ).sqrt()
+fn euclidian_dist(x0: isize, y0: isize, z0: isize, x1: isize, y1: isize, z1: isize) -> f32 {
+    ((x0 - x1).pow(2) as f32 + (y0 - y1).pow(2) as f32 + (z0 - z1).pow(2) as f32).sqrt()
 }
 
 pub fn chunk_fill_sphere(
     chunk: &mut Vec<Vec<Vec<u8>>>,
-    width: usize, height: usize, depth: usize,
-    x: isize, y: isize, z: isize,
-    radius: f32, block: u8
+    width: usize,
+    height: usize,
+    depth: usize,
+    x: isize,
+    y: isize,
+    z: isize,
+    radius: f32,
+    block: u8,
 ) {
     let r = radius.ceil().abs() as isize;