Add ability to change simulated ipt time delta

Author: object-Object

schematics/mlogv32.msch

@@ -49,6 +49,18 @@ struct Cli {
 
     #[arg(long, short)]
     verbose: bool,
+
+    /// 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,
+}
+
+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")),
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -459,7 +471,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         let now = Instant::now();
         let time = now - start;
         if !frozen {
-            vm.do_tick(time);
+            vm.do_tick_with_delta(time, cli.delta);
             ticks += 1;
         }
 

src/bin/mlogv32.rs

@@ -113,7 +113,7 @@ impl Building {
         let data = match name {
             MICRO_PROCESSOR => BuildingData::Processor(
                 ProcessorBuilder {
-                    ipt: 2,
+                    ipt: 2.,
                     privileged: false,
                     running_processors: Rc::clone(&builder.vm.running_processors),
                     time: Rc::clone(&builder.vm.time),
@@ -124,7 +124,7 @@ impl Building {
             ),
             LOGIC_PROCESSOR => BuildingData::Processor(
                 ProcessorBuilder {
-                    ipt: 8,
+                    ipt: 8.,
                     privileged: false,
                     running_processors: Rc::clone(&builder.vm.running_processors),
                     time: Rc::clone(&builder.vm.time),
@@ -135,7 +135,7 @@ impl Building {
             ),
             HYPER_PROCESSOR => BuildingData::Processor(
                 ProcessorBuilder {
-                    ipt: 25,
+                    ipt: 25.,
                     privileged: false,
                     running_processors: Rc::clone(&builder.vm.running_processors),
                     time: Rc::clone(&builder.vm.time),
@@ -146,7 +146,7 @@ impl Building {
             ),
             WORLD_PROCESSOR => BuildingData::Processor(
                 ProcessorBuilder {
-                    ipt: 8,
+                    ipt: 8.,
                     privileged: true,
                     running_processors: Rc::clone(&builder.vm.running_processors),
                     time: Rc::clone(&builder.vm.time),

src/logic/vm/buildings.rs

@@ -22,7 +22,7 @@ use crate::{
     },
 };
 
-const MAX_IPT: usize = 1000;
+const MAX_IPT: i32 = 1000;
 const EQUALITY_EPSILON: f64 = 0.000001;
 const PRINT_EPSILON: f64 = 0.00001;
 
@@ -1107,6 +1107,6 @@ pub(super) struct SetRate {
 
 impl SimpleInstructionTrait for SetRate {
     fn execute(&self, state: &mut ProcessorState, _: &HashMap<String, LVar>, _: &LogicVM) {
-        state.ipt = (self.value.get(state).num() as usize).clamp(1, MAX_IPT);
+        state.ipt = self.value.get(state).numi().clamp(1, MAX_IPT) as f64;
     }
 }

src/logic/vm/instructions.rs

@@ -82,10 +82,19 @@ impl LogicVM {
         }
     }
 
-    /// Execute one tick of the simulation.
+    /// Execute one tick of the simulation with a delta of `1.0`.
     ///
-    /// Note: `time` is the time elapsed since the *start* of the simulation.
+    /// `time` is the time elapsed since the *start* of the simulation.
     pub fn do_tick(&self, time: Duration) {
+        self.do_tick_with_delta(time, 1.0);
+    }
+
+    /// Execute one tick of the simulation.
+    ///
+    /// `time` is the time elapsed since the *start* of the simulation.
+    ///
+    /// `delta` is the simulated time delta, eg. `1.0` corresponds to 60 fps.
+    pub fn do_tick_with_delta(&self, time: Duration, delta: f64) {
         // never move time backwards
         let time = duration_millis_f64(time);
         self.time.set(time);
@@ -95,7 +104,7 @@ impl LogicVM {
                 .data
                 .borrow_mut()
                 .unwrap_processor_mut()
-                .do_tick(self, time);
+                .do_tick(self, time, delta);
         }
     }
 
@@ -1656,7 +1665,7 @@ mod tests {
         for ipt in [8, 1, 10, 1, 1000, 500, 1000, 5] {
             with_processor(&mut vm, (0, 0), |p| {
                 assert_eq!(
-                    p.state.ipt, ipt,
+                    p.state.ipt, ipt as f64,
                     "incorrect ipt at counter {}",
                     p.state.counter
                 );
@@ -1673,7 +1682,7 @@ mod tests {
         let mut vm = single_processor_vm(MICRO_PROCESSOR, "setrate 10; stop");
         run(&mut vm, 1, true);
         let processor = take_processor(&mut vm, (0, 0));
-        assert_eq!(processor.state.ipt, 2);
+        assert_eq!(processor.state.ipt, 2.0);
     }
 
     const CONDITION_TESTS: &[(&str, &str, &str, bool)] = &[

src/logic/vm/mod.rs

@@ -1,6 +1,5 @@
 use std::{
     cell::Cell,
-    cmp::min,
     collections::{HashMap, HashSet},
     io::Cursor,
     rc::Rc,
@@ -23,7 +22,7 @@ use crate::{
 };
 
 pub(super) const MAX_TEXT_BUFFER: usize = 400;
-const MAX_INSTRUCTION_SCALE: usize = 5;
+const MAX_INSTRUCTION_SCALE: f64 = 5.0;
 
 pub struct Processor {
     instructions: Vec<Instruction>,
@@ -144,19 +143,19 @@ impl Processor {
         Ok(())
     }
 
-    pub fn do_tick(&mut self, vm: &LogicVM, time: f64) {
+    pub fn do_tick(&mut self, vm: &LogicVM, time: f64, delta: f64) {
         if !self.state.enabled || self.state.wait_end_time > time {
             return;
         }
 
-        self.state.accumulator = min(
-            self.state.accumulator + self.state.ipt,
+        self.state.accumulator = f64::min(
+            self.state.accumulator + self.state.ipt * delta,
             MAX_INSTRUCTION_SCALE * self.state.ipt,
         );
 
-        while self.state.accumulator >= 1 {
+        while self.state.accumulator >= 1. {
             let res = self.step(vm);
-            self.state.accumulator -= 1;
+            self.state.accumulator -= 1.;
             if let InstructionResult::Yield = res {
                 break;
             }
@@ -213,8 +212,8 @@ pub struct ProcessorState {
     linked_positions: HashSet<Point2>,
 
     pub counter: usize,
-    accumulator: usize,
-    pub ipt: usize,
+    accumulator: f64,
+    pub ipt: f64,
 
     running_processors: Rc<Cell<usize>>,
     pub(super) time: Rc<Cell<f64>>,
@@ -302,7 +301,7 @@ pub(super) struct ProcessorLink {
 
 #[derive(Debug)]
 pub(super) struct ProcessorBuilder<'a> {
-    pub ipt: usize,
+    pub ipt: f64,
     pub privileged: bool,
     pub running_processors: Rc<Cell<usize>>,
     pub time: Rc<Cell<f64>>,
@@ -399,7 +398,7 @@ impl ProcessorBuilder<'_> {
                 links,
                 linked_positions: HashSet::new(),
                 counter: 0,
-                accumulator: 0,
+                accumulator: 0.,
                 ipt,
                 running_processors,
                 time,