private void UpdateAutosplitter() { var previousLatestSavePath = latestSavePath; latestSavePath = FindLatestSavePath(); if (latestSavePath != previousLatestSavePath) { if (timer.CurrentState.CurrentPhase == TimerPhase.Running) { ResetWools(); timer.Reset(true); } watcher?.Dispose(); watcher = new FileSystemWatcher { Path = latestSavePath, NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.Size | NotifyFilters.Attributes, Filter = "*.*" }; watcher.Renamed += NewLevelDat; watcher.Created += SessionLock; watcher.Changed += SessionLock; watcher.EnableRaisingEvents = true; CheckExistingSessionLock(); } if (timer.CurrentState.CurrentPhase == TimerPhase.NotRunning) { ResetWools(); } }
private void _state_OnStart(object sender, EventArgs e) { if (!_usb2snes.Connected()) { if (!this.connect()) { _model.Reset(); return; } } if (_game == null) { if (!this.readConfig()) { _model.Reset(); return; } } _error = false; _splits = _game.categories.Where(c => c.name.ToLower() == _state.Run.CategoryName.ToLower()).First()?.splits; if (_splits == null) { MessageBox.Show("There are no splits for the current category in the split config file, check that the run category is correctly set and exists in the config file."); } }
void gameMemory_OnPlayerGainedControl(object sender, PlayerControlChangedEventArgs e) { if (!this.Settings.AutoStartEndResetEnabled) { return; } _timer.Reset(); // make sure to reset for games that start from a quicksave (Aperture Tag) _timer.Start(); _sessionTicksOffset += e.TicksOffset; }
public override void Update(IInvalidator invalidator, LiveSplitState state, float width, float height, LayoutMode mode) { if (!gameMemory.ProcessHook()) { return; } if (logic.ShouldStart()) { logic.ResetLogic(); if (liveSplitState.CurrentPhase == TimerPhase.Running) { timerModel.Reset(); } timerModel.Start(); } if (liveSplitState.CurrentPhase == TimerPhase.Running) { if (logic.ShouldSplit(liveSplitState.CurrentSplitIndex, liveSplitState.Run.Count)) { timerModel.Split(); } } }
private void handleStandingOnArea(Checkpoint checkpoint, int checkpointIndex, LiveSplitState state, bool playingTransition, int mapId) { switch (checkpoint.CheckpointType) { case CheckpointType.StartingArea: if (_wasPlayingTransition && !playingTransition) { Log.Info( $"Resetting timer because {checkpoint.Name} is a starting area and a transition was playing."); _timer.Reset(); } break; case CheckpointType.Checkpoint: Log.Info($"Splitting because player is on {checkpoint.Name}"); _lastCheckpoint[mapId] = checkpointIndex; _timer.Split(); break; case CheckpointType.Boss: if (playingTransition) { Log.Info($"Splitting because player is on boss {checkpoint.Name} and a transition happened"); var currentSplit = state.CurrentSplit; _timer.Split(); currentSplit.SplitTime = new Time(currentSplit.SplitTime.RealTime?.Subtract( TimeSpan.FromMilliseconds(checkpoint.TimeSubtract))); } break; } }
void gameMemory_OnReset(object sender, EventArgs e) { if (Settings.AutoReset) { _timer.Reset(); } }
void gameMemory_OnFirstLevelLoading(object sender, EventArgs e) { if (this.Settings.AutoReset) { _timer.Reset(); } }
//Reset timer on music selection screen void gameMemory_OnMusicSelect(object sender, EventArgs e) { if (this.Settings.AutoReset) { _timer.Reset(); } }
public override void Update(IInvalidator invalidator, LiveSplitState state, float width, float height, LayoutMode mode) { state.IsGameTimePaused = true; bool start = false; lock (eventsLock) { foreach (var ev in events) { if (ev is GameEndEvent) { if (state.CurrentPhase == TimerPhase.Running && settings.ShouldSplitOnGameEnd()) { state.SetGameTime(ev.Time); model.Split(); } } else if (ev is MapChangeEvent) { var e = (MapChangeEvent)ev; if (visitedMaps.Add(e.Map) && settings.ShouldSplitOn(e.Map)) { state.SetGameTime(e.Time); model.Split(); } } else if (ev is TimerResetEvent) { if (settings.IsAutoResetEnabled()) { state.SetGameTime(ev.Time); model.Reset(); } } else if (ev is TimerStartEvent) { if (settings.IsAutoStartEnabled()) { state.SetGameTime(ev.Time); start = true; } } } events.Clear(); } if (start) { model.Start(); } TimeSpan curTime; lock (currentTimeLock) { curTime = currentTime; } state.SetGameTime(curTime); }
void gameMemory_OnFirstLevelLoading(object sender, EventArgs e) { if ((_state.CurrentPhase == TimerPhase.Running || _state.CurrentPhase == TimerPhase.Ended) && this.Settings.AutoReset) { Trace.WriteLine(String.Format("[NoLoads] Reset - {0}", _gameMemory.frameCounter)); _timer.Reset(); } }
// This is executed repeatedly as long as the game is connected and initialized. private void DoUpdate(LiveSplitState state) { OldState = State.RefreshValues(_game); if (!(RunMethod(_methods.update, state) ?? true)) { // If Update explicitly returns false, don't run anything else return; } // Call the start segment if the splits are not running, but ensure that the segment is called at least once. if (state.CurrentPhase == TimerPhase.NotRunning || !startMethodCalledFromUpdate) { if (RunMethod(_methods.start, state) ?? false) { if (_settings.GetBasicSettingValue("start") && state.CurrentPhase == TimerPhase.NotRunning) { _timer.Start(); } } startMethodCalledFromUpdate = true; } if (state.CurrentPhase == TimerPhase.Running || state.CurrentPhase == TimerPhase.Paused) { if (_uses_game_time && !state.IsGameTimeInitialized) { _timer.InitializeGameTime(); } var is_paused = RunMethod(_methods.isLoading, state); if (is_paused != null) { state.IsGameTimePaused = is_paused; } var game_time = RunMethod(_methods.gameTime, state); if (game_time != null) { state.SetGameTime(game_time); } if (RunMethod(_methods.reset, state) ?? false) { if (_settings.GetBasicSettingValue("reset")) { _timer.Reset(); } } else if (RunMethod(_methods.split, state) ?? false) { if (_settings.GetBasicSettingValue("split")) { _timer.Split(); } } } }
private void UpdateAutosplitter() { var previousLatestSavePath = latestSavePath; latestSavePath = FindLatestSavePath(); var levelDat = new NbtFile(Path.Combine(latestSavePath, "level.dat")); if (levelDat.RootTag.First()["DataVersion"].IntValue < 1122) { timer.Reset(); Properties.Settings.Default.AutosplitterEnabled = false; Properties.Settings.Default.Save(); MessageBox.Show("Autosplitting is not supported for versions under 1.12 and has been disabled", ComponentName, MessageBoxButtons.OK, MessageBoxIcon.Error); return; } var previousWorldTime = worldTime; worldTime = levelDat.RootTag.First()["Time"].LongValue; // We don't have a previous time to compare with yet, skip if (previousWorldTime == -1) { return; } if (timer.CurrentState.CurrentPhase != TimerPhase.NotRunning && worldTime == 0) { timer.Reset(); } if (timer.CurrentState.CurrentPhase == TimerPhase.NotRunning && worldTime > 0 && previousWorldTime != worldTime && latestSavePath == previousLatestSavePath) { timer.Start(); } if (timer.CurrentState.CurrentPhase == TimerPhase.Running && previousWorldTime != worldTime && latestSavePath == previousLatestSavePath && levelDat.RootTag.First()["Player"]["seenCredits"].ByteValue == 1) { timer.Split(); } }
// This is executed repeatedly as long as the game is connected and initialized. private void DoUpdate(LiveSplit.UI.Components.LiveSplitState state) { OldState = State.RefreshValues(_game); if (!(RunMethod(_methods.update, state) ?? true)) { // If Update explicitly returns false, don't run anything else return; } if (state.CurrentPhase == TimerPhase.Running || state.CurrentPhase == TimerPhase.Paused) { if (_uses_game_time && !state.IsGameTimeInitialized) { _timer.InitializeGameTime(); } var is_paused = RunMethod(_methods.isLoading, state); if (is_paused != null) { state.IsGameTimePaused = is_paused; } var game_time = RunMethod(_methods.gameTime, state); if (game_time != null) { state.SetGameTime(game_time); } if (RunMethod(_methods.reset, state) ?? false) { if (_settings.GetBasicSettingValue("reset")) { _timer.Reset(); } } else if (RunMethod(_methods.split, state) ?? false) { if (_settings.GetBasicSettingValue("split")) { _timer.Split(); } } } if (state.CurrentPhase == TimerPhase.NotRunning) { if (RunMethod(_methods.start, state) ?? false) { if (_settings.GetBasicSettingValue("start")) { _timer.Start(); } } } }
public void On_Start() { if (_state.CurrentPhase != TimerPhase.NotRunning && _settings.AutoReset) { _timer.Reset(); } if (_state.CurrentPhase == TimerPhase.NotRunning && _settings.AutoStart) { _timer.Start(); } _state.IsGameTimePaused = true; _starting = true; }
void gameMemory_OnPlayerGainedControl(object sender, PlayerControlChangedEventArgs e) { if (Settings.ResetMapTransitions.Value) { _splitOperations.Clear(); _splitCount = 0; } if (!this.Settings.AutoStartEnabled.Value) { return; } if (_timer.CurrentState.CurrentPhase == TimerPhase.Running) { if (Settings.SplitInstead.Value) { gameMemory_ManualSplit(sender, e); return; } else if (!Settings.AutoResetEnabled.Value) { return; } } _timer.Reset(); // make sure to reset for games that start from a quicksave (Aperture Tag) _timer.Start(); if (Settings.RTAStartOffset.Value) { _timer.CurrentState.AdjustedStartTime -= TimeSpan.FromSeconds(Math.Abs(e.TicksOffset) * _intervalPerTick); } _sessionTicksOffset += e.TicksOffset; _tickOffset = e.TicksOffset; }
void gameMemory_OnStartSaveLoad(object sender, EventArgs e) { Stopwatch s = Stopwatch.StartNew(); if (this.Settings.AutoReset) { UpdateBearCartPB(true); _timer.Reset(); } if (this.Settings.AutoStart) { StartTimer(s.Elapsed); } }
private void _gameMemory_OnFirstLevelLoaded(object sender, EventArgs e) { if (_state.CurrentPhase == TimerPhase.NotRunning) { if (this.Settings.AutoReset) { Debug.WriteLine($"Restting"); _timer.Reset(); } } if (this.Settings.AutoStart) { Debug.WriteLine($"strating timer"); _timer.Start(); } }
/// <summary> /// Reset and start the timer /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnNewGame(object sender, StateEventArgs e) { if (gameData.IsRandomized) { e.State.Run.Clear(); // LiveSplit pretends its in Timer-only mode if there is only one segment (Triforce), which means new segments won't be added e.State.Run.AddSegment(START); e.State.Run.AddSegment(TRIFORCE, icon: icons[TRIFORCE]); } timer.Reset(); timer.Start(); e.State.IsGameTimePaused = true; }
public void Update() { _oldMemoryState = _currentMemoryState; _currentMemoryState = Memory.GetState(); switch (_state.CurrentPhase) { case TimerPhase.NotRunning: if (ShouldStart()) { _startingMemoryState = _currentMemoryState; // Temporarily adjust the start offset for real-time accuracy. var userOffset = _state.Run.Offset; _state.Run.Offset = DateTime.Now - _firstLoadStartTime + TimeSpan.FromSeconds(StartOffset[AutosplitterSettings.StartCondition]); _model.Start(); _state.Run.Offset = userOffset; _state.SetGameTime(TimeSpan.FromSeconds(StartOffset[AutosplitterSettings.StartCondition])); } break; case TimerPhase.Running: // Pause timer when loading _state.IsGameTimePaused = _currentMemoryState.IsLoading; if (DateTime.Now > _timeUntilNextSplit && ShouldSplit()) { _model.Split(); } else if (ShouldReset()) { _model.Reset(); } break; } }
void do_reset(object sender, EventArgs e) { _tm.Reset(); }
public void Update(IInvalidator invalidator, LiveSplitState state, float width, float height, LayoutMode mode) { if (Game == null || Game.HasExited) { Game = null; var process = Process.GetProcessesByName("SuperMeatBoy").FirstOrDefault(); if (process != null) { Game = process; } OldTitleScreenShowing = false; } if (Model == null) { Model = new TimerModel() { CurrentState = state }; state.OnStart += state_OnStart; } if (Game != null) { float time; TimeSpan levelTime = OldLevelTime ?? TimeSpan.Zero; bool isInALevel; IsInALevel.Deref <bool>(Game, out isInALevel); if (isInALevel) { try { LevelTimer.Deref <float>(Game, out time); levelTime = TimeSpan.FromSeconds(time); } catch { } } //AliveTimer.Deref<float>(Game, out time); //var aliveTime = TimeSpan.FromSeconds(time); //int deathCounter; //DeathCounter.Deref<int>(Game, out deathCounter); int levelID; LevelID.Deref <int>(Game, out levelID); int chapterID; ChapterID.Deref <int>(Game, out chapterID); int levelType; LevelType.Deref <int>(Game, out levelType); int chapterSelectID; ChapterSelectID.Deref <int>(Game, out chapterSelectID); bool creditsPlaying; CreditsPlaying.Deref <bool>(Game, out creditsPlaying); bool isAtLevelSelect; IsAtLevelSelect.Deref <bool>(Game, out isAtLevelSelect); bool isNotAtLevelEnd; IsNotAtLevelEnd.Deref <bool>(Game, out isNotAtLevelEnd); if (!WasAtLevelEnd && !isNotAtLevelEnd) { WasAtLevelEnd = true; FinishedLevelTime = levelTime; } bool titleScreenShowing; bool couldFetch = TitleScreenShowing.Deref <bool>(Game, out titleScreenShowing); if (!couldFetch) { titleScreenShowing = true; } //bool isTimeRunning = OldLevelTime != levelTime; if (OldLevelTime != null)// && OldLevelTime != null) { if (state.CurrentPhase == TimerPhase.NotRunning && !titleScreenShowing && OldTitleScreenShowing) { Model.Start(); } else if (state.CurrentPhase == TimerPhase.Running) { if (chapterID == 6 && levelID == 99) { if (creditsPlaying && !OldCreditsPlaying) { Model.Split(); //The End } } else { if ((levelType != 0 && levelType != 10) || chapterID == 7) { if (((levelType <= 1) ? (levelID == 20) : true) && !isInALevel && (levelID == 20 && state.CurrentSplitIndex == state.Run.Count - 1 ? WasInALevel //Split earlier for Cotton Alley if it's the last split : (!isAtLevelSelect && WasAtLevelSelect))) { Model.Split(); //Dark World or Cotton Alley } } else if (!creditsPlaying && OldCreditsPlaying) { Model.Split(); //Chapter Splits } } if (titleScreenShowing && !creditsPlaying) { Model.Reset(); } } if (OldLevelTime > levelTime) { //OldDeathCounter = deathCounter; GameTime += (WasAtLevelEnd ? FinishedLevelTime : OldLevelTime ?? TimeSpan.Zero); WasAtLevelEnd = false; } } #if GAME_TIME state.IsLoading = true; var currentGameTime = GameTime + (WasAtLevelEnd ? FinishedLevelTime : levelTime); state.SetGameTime(currentGameTime < TimeSpan.Zero ? TimeSpan.Zero : currentGameTime); #endif //WasTimeRunning = isTimeRunning; //OldLevelTime = levelTime; OldLevelTime = levelTime; OldLevelID = levelID; OldChapterSelectID = chapterSelectID; OldCreditsPlaying = creditsPlaying; WasAtLevelSelect = isAtLevelSelect; WasInALevel = isInALevel; OldTitleScreenShowing = titleScreenShowing; } }
public void Update(IInvalidator invalidator, LiveSplitState state, float width, float height, LayoutMode mode) { if (Game == null || Game.HasExited) { Game = null; var process = Process.GetProcessesByName("GrooveCity").FirstOrDefault(); if (process != null) { Game = process; } } if (!state.Run.CustomComparisons.Contains("Game Time")) { state.Run.CustomComparisons.Add("Game Time"); } if (Model == null) { Model = new TimerModel() { CurrentState = state }; state.OnStart += state_OnStart; } if (Game != null) { float time; //LevelTimer.Deref<float>(Game, out time); //var levelTime = TimeSpan.FromSeconds(time); AliveTimer.Deref <float>(Game, out time); var aliveTime = TimeSpan.FromSeconds(time); //int deathCounter; //DeathCounter.Deref<int>(Game, out deathCounter); int levelID; LevelID.Deref <int>(Game, out levelID); //bool isTimeRunning = OldLevelTime != levelTime; if (OldAliveTime != null)// && OldLevelTime != null) { if (levelID != OldLevelID && levelID >= 6 && levelID <= 22 && levelID != 7 && levelID != 8 && levelID != 18) { if (state.CurrentPhase == TimerPhase.NotRunning && levelID == 6) { Model.Start(); } else if (state.CurrentPhase == TimerPhase.Running) { Model.Split(); } } if (levelID == 4 && state.CurrentPhase == TimerPhase.Running) { Model.Reset(); } if (OldAliveTime > aliveTime) { //OldDeathCounter = deathCounter; GameTime += OldAliveTime ?? TimeSpan.Zero; } } state.IsLoading = true; state.CurrentGameTime = GameTime + aliveTime; //WasTimeRunning = isTimeRunning; //OldLevelTime = levelTime; OldAliveTime = aliveTime; OldLevelID = levelID; } }
void gameMemory_OnReset(object sender, EventArgs e) { _timer.Reset(); }