Merge pull request #884 from AlexKnauth/segment-splitted-3

Add timer_current_split_index and timer_segment_splitted

Author: CryZe

crates/livesplit-auto-splitting/README.md

@@ -99,6 +99,18 @@ impl MemoryRangeFlags {
 unsafe extern "C" {
     /// Gets the state that the timer currently is in.
     pub safe fn timer_get_state() -> TimerState;
+    /// Accesses the index of the split the attempt is currently on.
+    /// If there's no attempt in progress, `-1` is returned instead.
+    /// This returns an index that is equal to the amount of segments
+    /// when the attempt is finished, but has not been reset.
+    /// So you need to be careful when using this value for indexing.
+    /// Same index does not imply same split on undo and then split.
+    pub safe fn timer_current_split_index() -> i64;
+    /// Whether the segment at `idx` was splitted this attempt.
+    /// Returns `1` if the segment was splitted, or `0` if skipped.
+    /// If `idx` is greater than or equal to the current split index,
+    /// `-1` is returned instead.
+    pub safe fn timer_segment_splitted(idx: u64) -> i32;
 
     /// Starts the timer.
     pub safe fn timer_start();

crates/livesplit-auto-splitting/src/lib.rs

@@ -99,6 +99,18 @@
 //! unsafe extern "C" {
 //!     /// Gets the state that the timer currently is in.
 //!     pub safe fn timer_get_state() -> TimerState;
+//!     /// Accesses the index of the split the attempt is currently on.
+//!     /// If there's no attempt in progress, `-1` is returned instead.
+//!     /// This returns an index that is equal to the amount of segments
+//!     /// when the attempt is finished, but has not been reset.
+//!     /// So you need to be careful when using this value for indexing.
+//!     /// Same index does not imply same split on undo and then split.
+//!     pub safe fn timer_current_split_index() -> i64;
+//!     /// Whether the segment at `idx` was splitted this attempt.
+//!     /// Returns `1` if the segment was splitted, or `0` if skipped.
+//!     /// If `idx` is greater than or equal to the current split index,
+//!     /// `-1` is returned instead.
+//!     pub safe fn timer_segment_splitted(idx: u64) -> i32;
 //!
 //!     /// Starts the timer.
 //!     pub safe fn timer_start();

crates/livesplit-auto-splitting/src/runtime/api/timer.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use wasmtime::{Caller, Linker};
 
-use crate::{runtime::Context, CreationError, Timer};
+use crate::{CreationError, Timer, runtime::Context};
 
 use super::{get_str, memory_and_context};
 
@@ -14,6 +14,32 @@ pub fn bind<T: Timer>(linker: &mut Linker<Context<T>>) -> Result<(), CreationErr
             source,
             name: "timer_get_state",
         })?
+        .func_wrap("env", "timer_current_split_index", {
+            |caller: Caller<'_, Context<T>>| {
+                caller
+                    .data()
+                    .timer
+                    .current_split_index()
+                    .map_or(-1, |i| i as i64)
+            }
+        })
+        .map_err(|source| CreationError::LinkFunction {
+            source,
+            name: "timer_current_split_index",
+        })?
+        .func_wrap("env", "timer_segment_splitted", {
+            |caller: Caller<'_, Context<T>>, index: u64| {
+                Ok(caller
+                    .data()
+                    .timer
+                    .segment_splitted(index as usize)
+                    .map_or(-1, |b| b as i32))
+            }
+        })
+        .map_err(|source| CreationError::LinkFunction {
+            source,
+            name: "timer_segment_splitted",
+        })?
         .func_wrap(
             "env",
             "timer_start",

crates/livesplit-auto-splitting/src/timer.rs

@@ -35,6 +35,19 @@ pub enum LogLevel {
 pub trait Timer: Send {
     /// Returns the current state of the timer.
     fn state(&self) -> TimerState;
+    /// Accesses the index of the split the attempt is currently on.
+    /// If there's no attempt in progress, `None` is returned instead.
+    /// This returns an index that is equal to the amount of segments
+    /// when the attempt is finished, but has not been reset.
+    /// So you need to be careful when using this value for indexing.
+    /// Same index does not imply same split on undo and then split.
+    fn current_split_index(&self) -> Option<usize>;
+    /// Whether the segment at `idx` was splitted this attempt.
+    /// Returns `Some(true)` if the segment was splitted,
+    /// or `Some(false)` if skipped.
+    /// If `idx` is greater than or equal to the current split index,
+    /// `None` is returned instead.
+    fn segment_splitted(&self, idx: usize) -> Option<bool>;
     /// Starts the timer.
     fn start(&mut self);
     /// Splits the current segment.

crates/livesplit-auto-splitting/tests/sandboxing.rs

@@ -14,6 +14,12 @@ impl Timer for DummyTimer {
     fn state(&self) -> TimerState {
         TimerState::NotRunning
     }
+    fn current_split_index(&self) -> Option<usize> {
+        None
+    }
+    fn segment_splitted(&self, _idx: usize) -> Option<bool> {
+        None
+    }
     fn start(&mut self) {}
     fn split(&mut self) {}
     fn skip_split(&mut self) {}

src/auto_splitting/mod.rs

@@ -99,6 +99,18 @@
 //! unsafe extern "C" {
 //!     /// Gets the state that the timer currently is in.
 //!     pub safe fn timer_get_state() -> TimerState;
+//!     /// Accesses the index of the split the attempt is currently on.
+//!     /// If there's no attempt in progress, `-1` is returned instead.
+//!     /// This returns an index that is equal to the amount of segments
+//!     /// when the attempt is finished, but has not been reset.
+//!     /// So you need to be careful when using this value for indexing.
+//!     /// Same index does not imply same split on undo and then split.
+//!     pub safe fn timer_current_split_index() -> i64;
+//!     /// Whether the segment at `idx` was splitted this attempt.
+//!     /// Returns `1` if the segment was splitted, or `0` if skipped.
+//!     /// If `idx` is greater than or equal to the current split index,
+//!     /// `-1` is returned instead.
+//!     pub safe fn timer_segment_splitted(idx: u64) -> i32;
 //!
 //!     /// Starts the timer.
 //!     pub safe fn timer_start();
@@ -787,6 +799,25 @@ impl<E: event::CommandSink + TimerQuery + Send> AutoSplitTimer for Timer<E> {
         }
     }
 
+    fn current_split_index(&self) -> Option<usize> {
+        self.0.get_timer().current_split_index()
+    }
+
+    fn segment_splitted(&self, idx: usize) -> Option<bool> {
+        let t = self.0.get_timer();
+        if !(idx < t.current_split_index()?) {
+            return None;
+        }
+        Some(
+            t.run()
+                .segments()
+                .get(idx)?
+                .split_time()
+                .real_time
+                .is_some(),
+        )
+    }
+
     fn start(&mut self) {
         drop(self.0.start());
     }