Initial mid-run reset support

Author: thecodewarrior

README.md

@@ -60,7 +60,9 @@ The `.lss` files can be imported directly into LiveSplit One and the correspondi
 # Route JSON
 Routes are configured using a JSON file and use "events" generated by SwiftSplit. They consist of a reset event and a 
 list of route events. SwiftSplit expects route events in a specific order and triggers splits on those events. The reset
-event can trigger at any point during the route and will reset the run. 
+event can trigger at any point during the route and will reset the run. If the next event in the route is itself the 
+reset event, that will take priority and the run won't be reset. This can be used to implement returning to map into
+your route.
 
 Here's an example for Old Site Any%:
 ```json

SwiftSplit/CelesteScanner.swift

@@ -279,7 +279,7 @@ struct AutoSplitterData: Equatable {
     }
 }
 
-enum ChapterMode {
+enum ChapterMode : Equatable {
     case Normal
     case BSide
     case CSide
@@ -353,5 +353,22 @@ class AutoSplitterInfo {
         self.fileCassettes = Int(data.fileCassettes)
         self.fileHearts = Int(data.fileHearts)
     }
+    
+    func stableStateEquals(other: AutoSplitterInfo) -> Bool {
+        return self.chapter == other.chapter &&
+            self.mode == other.mode &&
+            self.level == other.level &&
+            self.timerActive == other.timerActive &&
+            self.chapterStarted == other.chapterStarted &&
+            self.chapterComplete == other.chapterComplete &&
+//            self.chapterTime == other.chapterTime &&
+            self.chapterStrawberries == other.chapterStrawberries &&
+            self.chapterCassette == other.chapterCassette &&
+            self.chapterHeart == other.chapterHeart &&
+//            self.fileTime == other.fileTime &&
+            self.fileStrawberries == other.fileStrawberries &&
+            self.fileCassettes == other.fileCassettes &&
+            self.fileHearts == other.fileHearts
+    }
 
 }

SwiftSplit/CelesteSplitter.swift

@@ -11,18 +11,38 @@ import Foundation
 enum SplitterError: Error {
     case noHeader
 }
+
+struct Event {
+    var variants: Set<String>
+    
+    init() {
+        self.variants = Set()
+    }
+    
+    mutating func add(variant: String) {
+        self.variants.insert(variant)
+    }
+}
+
+extension Event : ExpressibleByArrayLiteral {
+    init(arrayLiteral elements: String...) {
+        self.init()
+        for element in elements {
+            self.add(variant: element)
+        }
+    }
+    
+    typealias ArrayLiteralElement = String
+}
+
 /**
  Handles sending split commands based on state changes
  */
 class CelesteSplitter {
     let scanner: CelesteScanner
     let server: LiveSplitServer
     var autoSplitterInfo: AutoSplitterInfo = AutoSplitterInfo()
-    var routeConfig = RouteConfig(
-        useFileTime: false,
-        reset: "",
-        route: []
-    )
+    var routeConfig = RouteConfig()
 
     init(pid: pid_t, server: LiveSplitServer) throws {
         self.scanner = try CelesteScanner(pid: pid)
@@ -35,19 +55,20 @@ class CelesteSplitter {
     }
 
     private var gameTimeRunning = false
-    private(set) var routeIndex = 0
+    private(set) var nextEventIndex = 0
 
     func reset() {
         server.reset()
-        routeIndex = 0
+        nextEventIndex = 0
     }
 
-    func update() throws -> [String] {
+    func update() throws -> [Event] {
         guard let info = try scanner.getInfo() else {
             autoSplitterInfo = AutoSplitterInfo()
             return []
         }
         let events = getEvents(from: autoSplitterInfo, to: info)
+//        logStateChange(from: autoSplitterInfo, to: info)
         autoSplitterInfo = info
 
         let time = routeConfig.useFileTime ? autoSplitterInfo.fileTime : autoSplitterInfo.chapterTime
@@ -65,106 +86,170 @@ class CelesteSplitter {
         return events
     }
 
-    func getEvents(from old: AutoSplitterInfo, to new: AutoSplitterInfo) -> [String] {
-        var events: [String] = []
+    var lastStateTime = DispatchTime.now()
+
+    func logStateChange(from old: AutoSplitterInfo, to new: AutoSplitterInfo) {
+        if !old.stableStateEquals(other: new) {
+            let currentTime = DispatchTime.now()
+            let delta = Double(currentTime.uptimeNanoseconds - lastStateTime.uptimeNanoseconds) / 1_000_000_000
+            print(
+                "[\(delta)] " +
+                    "chapter: \(new.chapter), mode: \(new.mode), level: \(new.level), timerActive: \(new.timerActive), " +
+                    "chapterStarted: \(new.chapterStarted), chapterComplete: \(new.chapterComplete), chapterTime: \(new.chapterTime), " +
+                    "chapterStrawberries: \(new.chapterStrawberries), chapterCassette: \(new.chapterCassette), chapterHeart: \(new.chapterHeart), fileTime: \(new.fileTime), " +
+                "fileStrawberries: \(new.fileStrawberries), fileCassettes: \(new.fileCassettes), fileHearts: \(new.fileHearts)"
+            )
+            lastStateTime = currentTime
+        }
+    }
+    
+    func getEvents(from old: AutoSplitterInfo, to new: AutoSplitterInfo) -> [Event] {
+        var events: [Event] = []
 
         // if we don't check `new.chapterComplete`, the summit credits trigger the autosplitter
         if new.chapterStarted && !old.chapterStarted && !new.chapterComplete {
-            events.append("start chapter \(new.chapter)")
+            var event: Event = ["start chapter", "start chapter \(new.chapter)"]
             switch new.mode {
-            case .Normal: events.append("start a-side \(new.chapter)")
-            case .BSide: events.append("start b-side \(new.chapter)")
-            case .CSide: events.append("start c-side \(new.chapter)")
+            case .Normal: event.add(variant: "start a-side \(new.chapter)")
+            case .BSide: event.add(variant: "start b-side \(new.chapter)")
+            case .CSide: event.add(variant: "start c-side \(new.chapter)")
             default: break
             }
+            events.append(event)
         }
         if !new.chapterStarted && old.chapterStarted && !old.chapterComplete {
-            events.append("reset chapter")
-            events.append("reset chapter \(old.chapter)")
+            var event: Event = ["return to map", "reset chapter", "reset chapter \(old.chapter)"]
             switch new.mode {
-            case .Normal: events.append("reset a-side \(old.chapter)")
-            case .BSide: events.append("reset b-side \(old.chapter)")
-            case .CSide: events.append("reset c-side \(old.chapter)")
+            case .Normal: event.add(variant: "reset a-side \(old.chapter)")
+            case .BSide: event.add(variant: "reset b-side \(old.chapter)")
+            case .CSide: event.add(variant: "reset c-side \(old.chapter)")
             default: break
             }
+            events.append(event)
         }
         if new.chapterComplete && !old.chapterComplete {
-            events.append("complete chapter \(old.chapter)")
+            var event: Event = ["complete chapter", "complete chapter \(old.chapter)"]
             switch new.mode {
-            case .Normal: events.append("complete a-side \(old.chapter)")
-            case .BSide: events.append("complete b-side \(old.chapter)")
-            case .CSide: events.append("complete c-side \(old.chapter)")
+            case .Normal: event.add(variant: "complete a-side \(old.chapter)")
+            case .BSide: event.add(variant: "complete b-side \(old.chapter)")
+            case .CSide: event.add(variant: "complete c-side \(old.chapter)")
             default: break
             }
+            events.append(event)
         }
 
         if new.level != old.level && old.level != "" && new.level != "" {
-            events.append("\(old.level) > \(new.level)")
+            events.append(["\(old.level) > \(new.level)"])
         }
         if new.chapterCassette && !old.chapterCassette {
-            events.append("cassette")
-            events.append("chapter \(new.chapter) cassette")
-            events.append("\(new.fileCassettes) total cassettes")
+            events.append(["cassette", "chapter \(new.chapter) cassette", "\(new.fileCassettes) total cassettes"])
         }
         if new.chapterHeart && !old.chapterHeart {
-            events.append("heart")
-            events.append("chapter \(new.chapter) heart")
-            events.append("\(new.fileHearts) total hearts")
+            events.append(["heart", "chapter \(new.chapter) heart", "\(new.fileHearts) total hearts"])
         }
         if new.chapterStrawberries > old.chapterStrawberries {
-            events.append("strawberry")
-            events.append("\(new.chapterStrawberries) chapter strawberries")
-            events.append("\(new.fileStrawberries) file strawberries")
+            events.append(["strawberry", "\(new.chapterStrawberries) chapter strawberries", "\(new.fileStrawberries) file strawberries"])
         }
         return events
     }
 
-    func processEvents(_ events: [String]) {
-        for event in events {
-            print("Event: `\(event)`")
-            if event == routeConfig.reset {
-                server.reset()
-                routeIndex = 0
-            } else if routeIndex < routeConfig.route.count {
-                let nextEvent = routeConfig.route[routeIndex]
-                if event == nextEvent || "!\(event)" == nextEvent {
-                    if routeIndex == 0 {
+    func processEvents(_ events: [Event]) {
+        if events.count == 0 {
+            return
+        }
+        var events = events
+        // go through the route, gobbling up events as they match
+        route: for routeEvent in routeConfig.route[nextEventIndex...] {
+            for i in events.indices {
+                if routeEvent.matches(event: events[i]) {
+                    print("Matched against: `\(routeEvent.event)`")
+                    events.remove(at: i)
+                    
+                    if nextEventIndex == 0 {
                         server.reset()
                         server.start()
                         gameTimeRunning = true
-                    } else if !nextEvent.starts(with: "!") {
+                    } else if !routeEvent.silent {
                         server.split()
                     }
-                    routeIndex += 1
-                    if routeIndex == routeConfig.route.count {
-                        routeIndex = 0
-                    }
+                    
+                    nextEventIndex += 1
+                    continue route
                 }
             }
+            break
+        }
+        
+        if events.contains(where: { routeConfig.reset.matches(event: $0) }) {
+            server.reset()
+            nextEventIndex = 0
         }
     }
 }
 
 struct RouteConfig {
     let useFileTime: Bool
-    let reset: String
-    let route: [String]
+    let reset: RouteEvent
+    let route: [RouteEvent]
 }
 
 extension RouteConfig {
     init?(json: [String: Any]) {
         guard let useFileTime = json["useFileTime"] as? Bool,
             let reset = json["reset"] as? String,
+            let resetEvent = RouteEvent(from: reset),
             let route = json["route"] as? [String]
             else {
                 return nil
         }
+        let routeEvents = route.compactMap({ RouteEvent(from: $0) })
+        if(routeEvents.count != route.count) {
+            return nil
+        }
         self.useFileTime = useFileTime
-        self.reset = reset.components(separatedBy: " ##")[0]
-        self.route = route.map { $0.components(separatedBy: " ##")[0] }
+        self.reset = resetEvent
+        self.route = routeEvents
     }
 
     init() {
-        self.init(useFileTime: false, reset: "", route: [])
+        self.init(useFileTime: false, reset: RouteEvent(silent: false, event: ""), route: [])
+    }
+}
+
+class RouteEvent {
+    var silent: Bool
+    var event: String
+
+    init?(from jsonString: String) {
+        guard let match = RouteEvent.pattern.firstMatch(in: jsonString, options: [], range: NSRange(jsonString.startIndex..<jsonString.endIndex, in: jsonString)) else {
+            return nil
+        }
+        silent = match.range(at: 1).location != NSNotFound
+        if let eventRange = Range(match.range(at: 2), in: jsonString) {
+            event = String(jsonString[eventRange]).lowercased(with: nil)
+        } else {
+            return nil
+        }
+    }
+    
+    init(silent: Bool, event: String) {
+        self.silent = silent
+        self.event = event
+    }
+
+    func matches(event: Event) -> Bool {
+        return event.variants.contains(self.event)
+    }
+    
+    private static let pattern = try! NSRegularExpression(
+        pattern: #"^(!)?\s*(.*?)\s*(##.*)?$"#
+    )
+}
+
+extension RouteEvent : CustomStringConvertible {
+    var description: String {
+        (silent ? "!" : "") + event
     }
+    
+    
 }

SwiftSplit/ViewController.swift

@@ -71,7 +71,7 @@ class ViewController: NSViewController, RouteBoxDelegate {
 
         do {
             let events = try splitter.update()
-            eventStream = (eventStream + events.map { "\"\($0)\"" }).suffix(eventStreamLength)
+            eventStream = (eventStream + events.flatMap { $0.variants }).suffix(eventStreamLength)
         } catch {
             self.splitter = nil
             eventStream = Array(repeating: "", count: eventStreamLength)
@@ -215,8 +215,8 @@ class ViewController: NSViewController, RouteBoxDelegate {
 
         gameTimeLabel.stringValue = timeString
 
-        nextEventLabel.stringValue = splitter.routeIndex < routeConfig.route.count ?
-            "\"\(routeConfig.route[splitter.routeIndex])\" (\(splitter.routeIndex + 1)/\(routeConfig.route.count))"
+        nextEventLabel.stringValue = splitter.nextEventIndex < routeConfig.route.count ?
+            "\"\(routeConfig.route[splitter.nextEventIndex])\" (\(splitter.nextEventIndex + 1)/\(routeConfig.route.count))"
             : "<none>"
     }