Add mlog binary

Author: object-Object

.cargo/config.toml

@@ -2,4 +2,5 @@
 rustflags = ["-C", "target-cpu=native"]
 
 [alias]
+mlog = "run --release --features mlog --bin mlog --"
 mlogv32 = "run --release --features mlogv32 --bin mlogv32 --"

Cargo.lock

@@ -3,6 +3,10 @@ name = "mindustry-rs"
 version = "0.1.0"
 edition = "2024"
 
+[[bin]]
+name = "mlog"
+required-features = ["mlog"]
+
 [[bin]]
 name = "mlogv32"
 required-features = ["mlogv32"]
@@ -12,6 +16,7 @@ base64 = "0.22.1"
 binrw = "0.15.0"
 cesu8 = "1.1.0"
 csv = "1.3.1"
+enum_dispatch = "0.3.13"
 flate2 = { version = "1.1.2", features = ["zlib-rs"], default-features = false }
 indexmap = "2.10.0"
 itertools = "0.14.0"
@@ -35,7 +40,7 @@ clap = { version = "4.5.42", features = ["derive"], optional = true }
 crossterm = { version = "0.29.0", optional = true }
 cursive = { version = "0.21.1", optional = true }
 indicatif = { version = "0.18.0", optional = true }
-enum_dispatch = "0.3.13"
+clap-stdin = { version = "0.6.0", optional = true }
 
 [build-dependencies]
 lalrpop = "0.22.2"
@@ -44,8 +49,12 @@ lalrpop = "0.22.2"
 pretty_assertions = "1.4.1"
 
 [features]
-mlogv32 = [
+mlog = [
     "dep:clap",
+    "dep:clap-stdin",
+]
+mlogv32 = [
+    "mlog",
     "dep:crossterm",
     "dep:cursive",
     "dep:indicatif",

Cargo.toml

@@ -0,0 +1,142 @@
+use std::{error::Error, time::Instant};
+
+use clap::Parser;
+use clap_stdin::FileOrStdin;
+use mindustry_rs::{
+    logic::vm::{
+        Building, BuildingData, HYPER_PROCESSOR, LOGIC_PROCESSOR, LogicVMBuilder, MEMORY_BANK,
+        MEMORY_CELL, MESSAGE, MICRO_PROCESSOR, WORLD_PROCESSOR,
+    },
+    types::{Object, Point2, ProcessorConfig, ProcessorLinkConfig},
+};
+use strum_macros::EnumString;
+use widestring::U16String;
+
+#[derive(Parser)]
+#[command(version)]
+struct Cli {
+    /// Mlog code to load and run
+    code: FileOrStdin,
+
+    /// Processor type to use (micro, logic, hyper, world)
+    #[arg(long, short, default_value_t = ProcessorType::World)]
+    processor: ProcessorType,
+
+    /// Simulated time delta (0.5 = 120 fps, 1 = 60 fps, 2 = 30 fps)
+    #[arg(long, default_value_t = 1.0, value_parser = time_delta_parser)]
+    delta: f64,
+
+    /// Maximum number of ticks to run the simulation for
+    #[arg(long)]
+    max_ticks: Option<u32>,
+}
+
+fn time_delta_parser(s: &str) -> Result<f64, String> {
+    match s.parse() {
+        Ok(value) if value > 0. && value <= 6. => Ok(value),
+        Ok(_) => Err(format!("{s} is not in range (0, 6]")),
+        Err(_) => Err(format!("{s} is not a valid number")),
+    }
+}
+
+#[allow(clippy::enum_variant_names)]
+#[derive(Debug, Clone, Copy, EnumString, strum_macros::Display)]
+#[strum(serialize_all = "lowercase")]
+enum ProcessorType {
+    Micro,
+    Logic,
+    Hyper,
+    World,
+}
+
+impl ProcessorType {
+    fn name(&self) -> &str {
+        match self {
+            Self::Micro => MICRO_PROCESSOR,
+            Self::Logic => LOGIC_PROCESSOR,
+            Self::Hyper => HYPER_PROCESSOR,
+            Self::World => WORLD_PROCESSOR,
+        }
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli = Cli::parse();
+
+    let mut builder = LogicVMBuilder::new();
+    builder.add_buildings([
+        Building::from_processor_config(
+            cli.processor.name(),
+            Point2::new(0, 0),
+            &ProcessorConfig {
+                code: cli.code.contents()?,
+                links: vec![
+                    ProcessorLinkConfig::unnamed(3, 0),
+                    ProcessorLinkConfig::unnamed(4, 0),
+                    ProcessorLinkConfig::unnamed(5, 0),
+                ],
+            },
+            &builder,
+        )?,
+        Building::from_config(MESSAGE, Point2::new(3, 0), &Object::Null, &builder)?,
+        Building::from_config(MEMORY_CELL, Point2::new(4, 0), &Object::Null, &builder)?,
+        Building::from_config(MEMORY_BANK, Point2::new(5, 0), &Object::Null, &builder)?,
+    ]);
+    let vm = builder.build()?;
+
+    let processor = vm.building((0, 0).into()).unwrap();
+    assert_eq!(processor.block.name.as_str(), cli.processor.name());
+
+    let message = vm.building((3, 0).into()).unwrap();
+    assert_eq!(message.block.name.as_str(), MESSAGE);
+
+    let start = Instant::now();
+    let mut ticks = 0u32;
+    let mut prev_message = U16String::new();
+
+    let all_stopped = loop {
+        vm.do_tick_with_delta(start.elapsed(), cli.delta);
+        ticks += 1;
+
+        if let BuildingData::Message(message) = &*message.data.borrow()
+            && !message.is_empty()
+            && *message != prev_message
+        {
+            println!("{}", message.display());
+            prev_message = message.clone();
+        }
+
+        if vm.running_processors() == 0 {
+            break true;
+        }
+
+        if let Some(max_ticks) = cli.max_ticks
+            && ticks >= max_ticks
+        {
+            break false;
+        }
+    };
+
+    if let BuildingData::Processor(processor) = &*processor.data.borrow()
+        && !processor.state.printbuffer.is_empty()
+    {
+        println!("{}", processor.state.printbuffer.display());
+    }
+
+    if all_stopped {
+        println!("--------\nAll processors stopped, halting.");
+    } else {
+        println!("--------\nTick limit reached, halting.");
+    }
+
+    let time = start.elapsed();
+    println!("Runtime: {time:?}");
+    println!("Ticks completed: {ticks}");
+    println!("Average time per tick: {:?}", time / ticks);
+    println!(
+        "Average ticks per second: {:.1}",
+        (ticks as f64) / time.as_secs_f64()
+    );
+
+    Ok(())
+}

src/bin/mlog.rs

@@ -61,11 +61,17 @@ impl LogicVM {
     /// Run the simulation until all processors halt, or until a number of ticks are finished.
     /// Returns true if all processors halted, or false if the tick limit was reached.
     pub fn run(&self, max_ticks: Option<usize>) -> bool {
+        self.run_with_delta(max_ticks, 1.0)
+    }
+
+    /// Run the simulation until all processors halt, or until a number of ticks are finished.
+    /// Returns true if all processors halted, or false if the tick limit was reached.
+    pub fn run_with_delta(&self, max_ticks: Option<usize>, delta: f64) -> bool {
         let start = Instant::now();
         let mut tick = 0;
 
         loop {
-            self.do_tick(start.elapsed());
+            self.do_tick_with_delta(start.elapsed(), delta);
 
             if self.running_processors.get() == 0 {
                 // all processors finished, return true