feat: update command line usage

Author: Quozul

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "minecraft_world_optimizer"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 
 [dependencies]

Cargo.toml

@@ -36,13 +36,13 @@ The Minecraft World Optimizer has only been successfully tested on 1.20.6 and 1.
 
 The Minecraft World Optimizer as successfully been tested on the following worlds:
 
-- **Server World:** Backed-up world of my survival server with over 13.9 million generated chunks.
+- **Server Worlds:** Backed-up world of my survival server with over 17.9 million generated chunks.
 - **New World:** New amplified world pre-generated using Chunky with a square radius of 1024.
 
-| World        | Before Optimization                      | After Optimization                     | Size Reduction |
-|--------------|------------------------------------------|----------------------------------------|----------------|
-| Server World | 105,681,020 Kilobytes <br/> 24,381 Files | 16,145,728 Kilobytes <br/> 6,961 Files | **84.7%**      |
-| New World    | 235,204 Kilobytes <br/> 36 Files         | 2,440 Kilobytes <br/> 4 Files          | **98.9%**      |
+| World         | Before Optimization                      | After Optimization                     | Size Reduction |
+|---------------|------------------------------------------|----------------------------------------|----------------|
+| Server Worlds | 134,079,252 Kilobytes <br/> 29,861 Files | 27,220,248 Kilobytes <br/> 9,734 Files | **79.7%**      |
+| New World     | 235,204 Kilobytes <br/> 36 Files         | 2,440 Kilobytes <br/> 4 Files          | **98.9%**      |
 
 ## Getting Started
 
@@ -72,25 +72,33 @@ cargo install --git https://github.com/Quozul/minecraft_world_optimizer.git
 ## Usage
 
 ```shell
-minecraft_world_optimizer [WORLD_PATH]...
+# View up-to-date usage of the command:
+❯ minecraft_world_optimizer --help
+❯ minecraft_world_optimizer <MODE> <WORLD_PATHS>...
 ```
 
-Replace <WORLD_PATH> with the path to your Minecraft world folder containing region files.
+Replace mode with one of the following:
+
+- `check`: the program will only check for chunks and region files that can be deleted without actually deleting any
+  data. This mode is around two times faster than the write mode as it does not perform any file system operations.
+- `write`: the program will delete unused chunks and region files.
+
+Replace <WORLD_PATHS> with the path to your Minecraft world folder containing region files.
 It will detect the 3 vanilla dimensions and optimise them. Note that this has not been tested on modded worlds with
 multiple dimensions.
 
 Example:
 
 ```shell
-minecraft_world_optimizer ~/.minecraft/saves/MyWorld
+❯ minecraft_world_optimizer check ~/.minecraft/saves/MyWorld
 ```
 
-It can also be used to optimize a server's worlds as dimensions are split in multiple worlds:
+It can also be used to optimize server worlds as dimensions are split in multiple worlds:
 
 ```shell
-minecraft_world_optimizer /path/to/server/world*
+❯ minecraft_world_optimizer check /path/to/server/world*
 # Or if your shell does not support wildcard:
-minecraft_world_optimizer /path/to/server/world /path/to/server/world_nether /path/to/server/world_the_end
+❯ minecraft_world_optimizer check /path/to/server/world /path/to/server/world_nether /path/to/server/world_the_end
 ```
 
 ## Contributing

README.md

@@ -1,18 +1,30 @@
-use clap::Parser;
+use clap::{Parser, ValueEnum};
 use std::path::PathBuf;
 
 #[derive(Parser)]
 #[command(
     name = "minecraft_world_optimizer",
     version = "1.0",
-    about = "Optimizing Minecraft region files by deleting unused chunks.",
+    about = "Optimizing Minecraft worlds by deleting unused region files and chunks.",
     long_about = None,
 )]
 pub struct Cli {
-    /// Path to your Minecraft Worlds containing `level.dat` file.
-    pub world_path: Vec<PathBuf>,
+    /// What mode to run the program in
+    #[arg(value_enum, required = true)]
+    pub mode: Mode,
 
-    /// Optimizes the world, if not set, will only count regions and chunks to be deleted.
-    #[arg(short, long)]
-    pub write: bool,
+    /// Path to your Minecraft Worlds containing `level.dat` file
+    #[arg(required = true)]
+    pub world_paths: Vec<PathBuf>,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
+pub enum Mode {
+    /// Only counts of region files and chunks that can be deleted without making any change to the world
+    Check,
+
+    /// Optimizes the world by deleting unused region files and chunks.
+    /// This is a destructive process, make sure to make a backup of your worlds before running.
+    /// Also make sure the world is not loaded by the game as this will corrupt the world.
+    Write,
 }

src/cli.rs

@@ -0,0 +1,3 @@
+mod optimize_result;
+pub mod read;
+pub mod write;

src/commands/mod.rs

@@ -0,0 +1,34 @@
+use std::fmt::Display;
+
+#[derive(Default, Clone)]
+pub struct OptimizeResult {
+    pub total_chunks: usize,
+    pub deleted_chunks: usize,
+    pub deleted_regions: usize,
+}
+
+impl Display for OptimizeResult {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "Optimization Result:\n\
+                   Total Chunks: {}\n\
+                   Deleted Chunks: {}\n\
+                   Deleted Regions: {}",
+            self.total_chunks, self.deleted_chunks, self.deleted_regions
+        )
+    }
+}
+
+pub fn reduce_optimize_results(results: &mut [OptimizeResult]) -> OptimizeResult {
+    results
+        .iter_mut()
+        .reduce(|acc, cur| {
+            acc.deleted_regions += cur.deleted_regions;
+            acc.total_chunks += cur.total_chunks;
+            acc.deleted_chunks += cur.deleted_chunks;
+            acc
+        })
+        .cloned()
+        .unwrap_or_default()
+}

src/commands/optimize_result.rs

@@ -0,0 +1,58 @@
+use crate::commands::optimize_result::{reduce_optimize_results, OptimizeResult};
+use crate::region_loader::region::Region;
+use crate::world::get_region_files::get_region_files;
+use indicatif::{ProgressBar, ProgressStyle};
+use rayon::iter::ParallelIterator;
+use rayon::prelude::IntoParallelRefIterator;
+use std::error::Error;
+use std::path::PathBuf;
+
+pub fn execute_read(world_paths: &Vec<PathBuf>) -> Result<(), Box<dyn Error>> {
+    let entries = get_region_files(world_paths)?;
+    let pb = ProgressBar::new(entries.len() as u64);
+    let style = ProgressStyle::with_template(
+        "{percent}% {bar} {pos}/{len} [{elapsed_precise}>{eta_precise}, {per_sec}]",
+    )
+    .unwrap();
+    pb.set_style(style);
+
+    let mut results = entries
+        .par_iter()
+        .map(|entry| {
+            let result = optimize_read(entry);
+            pb.inc(1);
+            result
+        })
+        .flatten()
+        .collect::<Vec<OptimizeResult>>();
+
+    let result = reduce_optimize_results(&mut results);
+    println!("{result}");
+
+    Ok(())
+}
+
+fn optimize_read(region_file_path: &PathBuf) -> std::io::Result<OptimizeResult> {
+    let mut result = OptimizeResult::default();
+
+    match Region::from_file_name(region_file_path) {
+        Ok(region) => {
+            let chunks = region.get_chunks();
+            result.total_chunks += chunks.len();
+
+            for chunk in chunks {
+                if chunk.should_delete() {
+                    result.deleted_chunks += 1;
+                }
+            }
+            if result.deleted_chunks >= result.total_chunks {
+                result.deleted_regions += 1;
+            }
+        }
+        Err(_) => {
+            result.deleted_regions += 1;
+        }
+    }
+
+    Ok(result)
+}

src/commands/read.rs

@@ -0,0 +1,70 @@
+use crate::commands::optimize_result::{reduce_optimize_results, OptimizeResult};
+use crate::region_loader::region::Region;
+use crate::world::get_region_files::get_region_files;
+use indicatif::{ProgressBar, ProgressStyle};
+use rayon::iter::ParallelIterator;
+use rayon::prelude::IntoParallelRefIterator;
+use std::error::Error;
+use std::path::PathBuf;
+
+pub fn execute_write(world_paths: &Vec<PathBuf>) -> Result<(), Box<dyn Error>> {
+    let entries = get_region_files(world_paths)?;
+    let pb = ProgressBar::new(entries.len() as u64);
+    let style = ProgressStyle::with_template(
+        "{percent}% {bar} {pos}/{len} [{elapsed_precise}>{eta_precise}, {per_sec}]",
+    )
+    .unwrap();
+    pb.set_style(style);
+
+    let mut results = entries
+        .par_iter()
+        .map(|entry| {
+            let result = optimize_write(entry);
+            pb.inc(1);
+            result
+        })
+        .flatten()
+        .collect::<Vec<OptimizeResult>>();
+
+    let result = reduce_optimize_results(&mut results);
+    println!("{result}");
+
+    Ok(())
+}
+
+fn optimize_write(region_file_path: &PathBuf) -> std::io::Result<OptimizeResult> {
+    let mut result = OptimizeResult::default();
+
+    match Region::from_file_name(region_file_path) {
+        Ok(mut region) => {
+            let chunks = region.get_chunks();
+            result.total_chunks += chunks.len();
+
+            let mut chunks_to_delete = Vec::new();
+            for chunk in chunks {
+                if chunk.should_delete() {
+                    chunks_to_delete.push(chunk.clone());
+                }
+            }
+            result.deleted_chunks += chunks_to_delete.len();
+
+            for chunk in &chunks_to_delete {
+                region.remove_chunk(chunk);
+            }
+
+            if region.is_empty() {
+                result.deleted_regions += 1;
+                std::fs::remove_file(region_file_path)?;
+            } else {
+                let bytes = region.to_bytes();
+                std::fs::write(region_file_path, bytes)?;
+            }
+        }
+        Err(_) => {
+            result.deleted_regions += 1;
+            std::fs::remove_file(region_file_path)?;
+        }
+    }
+
+    Ok(result)
+}

src/commands/write.rs

@@ -1,56 +1,23 @@
 mod cli;
+mod commands;
 mod nbt;
-mod optimizer;
 mod region_loader;
 mod world;
 
-use crate::cli::Cli;
-use crate::optimizer::{optimize_region_file, OptimizeResult};
-use crate::world::get_region_files::get_region_files;
-use crate::world::validate::validate_worlds;
+use crate::cli::{Cli, Mode};
+use crate::commands::read::execute_read;
+use crate::commands::write::execute_write;
 use clap::Parser;
-use indicatif::{ProgressBar, ProgressStyle};
-use rayon::prelude::*;
 
 fn main() {
     let cli = Cli::parse();
 
-    match validate_worlds(&cli.world_path) {
-        Err(err) => {
-            eprintln!("{err}");
-        }
-        Ok(_) => {
-            let entries = cli
-                .world_path
-                .iter()
-                .flat_map(|world| get_region_files(world))
-                .collect::<Vec<_>>();
+    let result = match cli.mode {
+        Mode::Write => execute_write(&cli.world_paths),
+        Mode::Check => execute_read(&cli.world_paths),
+    };
 
-            let pb = ProgressBar::new(entries.len() as u64);
-            let style = ProgressStyle::with_template(
-                "{percent}% {bar} {pos}/{len} [{elapsed_precise}>{eta_precise}, {per_sec}]",
-            )
-            .unwrap();
-            pb.set_style(style);
-
-            let mut results = entries
-                .par_iter()
-                .map(|entry| {
-                    let result = optimize_region_file(entry, cli.write);
-                    pb.inc(1);
-                    result
-                })
-                .flatten()
-                .collect::<Vec<OptimizeResult>>();
-
-            let result = results.iter_mut().reduce(|acc, cur| {
-                acc.deleted_regions += cur.deleted_regions;
-                acc.total_chunks += cur.total_chunks;
-                acc.deleted_chunks += cur.deleted_chunks;
-                acc
-            });
-
-            println!("{:?}", result);
-        }
+    if let Err(err) = result {
+        eprintln!("{err}");
     }
 }