private void RunOnReset(object sender, TimerPhase e) => RunMethod(_methods.onReset, (LiveSplitState)sender);
private void State_OnReset(object sender, TimerPhase value) { Debug.WriteLine($"Reset"); resetSplitStates(); }
private void OnReset(object sender, TimerPhase value) { updateSplitImage(settings.resetImage); }
void state_OnReset(object sender, TimerPhase e) { ScrollOffset = 0; }
protected void OnReset(object sender, TimerPhase value) { Recalculate(); }
public void OnReset(object sender, TimerPhase e) { currentSplit = 0; lastLevelComplete = 0; state = 0; levelTimes = 0; lastYP2 = 0; startFrameCount = 0; lastMenu = MenuScreen.MainMenu; Model.CurrentState.IsGameTimePaused = true; WriteLog("---------Reset----------------------------------"); }
protected void OnReset(object sender, TimerPhase value) { updateText(); }
private void DoUpdate(LiveSplitState state, DeltaOutput d) { var updateState = RunMethod(Methods.update, state, d); // If Update explicitly returns false, don't run anything else if (updateState is bool && updateState == false) { return; } var offsetTime = TimeStamp.CurrentDateTime.Time - d.History[d.FrameIndex].FrameEnd; // Enable regardless to keep track of offseting for now. if (!state.IsGameTimeInitialized) { Timer.InitializeGameTime(); } if (state.CurrentPhase == TimerPhase.Running || state.CurrentPhase == TimerPhase.Paused) { if (UsesGameTime) { if (UsesIsLoading) { var isPausedState = RunMethod(Methods.isLoading, state, d); if (isPausedState is bool) { var prevPauseState = state.IsGameTimePaused; state.IsGameTimePaused = isPausedState; if (prevPauseState != isPausedState) { if (isPausedState) { state.GameTimePauseTime -= offsetTime; } else { state.GameTimePauseTime += offsetTime; } } } } if (UsesGameTime) { var gameTimeState = RunMethod(Methods.gameTime, state, d); if (gameTimeState is TimeSpan) { state.SetGameTime(gameTimeState); } } } if (Settings.GetBasicSettingValue("reset")) { var resetState = RunMethod(Methods.reset, state, d); if (resetState is bool && resetState == true) { Timer.Reset(); } } if (Settings.GetBasicSettingValue("split")) { var splitState = RunMethod(Methods.split, state, d); if (splitState is bool && splitState == true) { splitState = TimeSpan.Zero; } if (splitState is TimeSpan) { AdjustGameTime(state, splitState.Negate()); if (!UsesCustomGameTime) { AdjustGameTime(state, offsetTime.Negate()); } Timer.Split(); if (state.CurrentPhase != TimerPhase.Ended) { AdjustGameTime(state, splitState); if (!UsesCustomGameTime) { AdjustGameTime(state, offsetTime); } } else { LastSplitOffset = splitState; if (!UsesCustomGameTime) { LastSplitOffset += offsetTime; } } } } // @TODO: Add undo and skip; } else if (state.CurrentPhase == TimerPhase.NotRunning && Settings.GetBasicSettingValue("start")) { var startState = RunMethod(Methods.start, state, d); if ((startState is bool && startState == true) || startState is TimeSpan) { Timer.Start(); if (!state.IsGameTimeInitialized) { Timer.InitializeGameTime(); } LastSplitOffset = TimeSpan.Zero; TimeSpan startOffset = (startState is TimeSpan) ? startState : TimeSpan.Zero; AdjustGameTime(state, startOffset); if (!UsesCustomGameTime) { AdjustGameTime(state, offsetTime); } } } PreviousPhase = state.CurrentPhase; }
void state_OnReset(object sender, TimerPhase e) { UpdateHistoryValue((LiveSplitState)sender); }
void state_OnReset(object sender, TimerPhase t) { this.EngineHook.Unload(); }
void Model_OnReset(object sender, TimerPhase e) { if (RaceState == RaceState.RaceStarted) QuitRace(); }
void state_OnReset(object sender, TimerPhase t) { _deaths = 0; }
public void OnReset(object sender, TimerPhase e) { // Reset the autosplitter state whenever LiveSplit is reset LogWriter.WriteLine("[LiveSplit] Reset."); process.StandardInput.WriteLine("reset"); }
void state_OnReset(object sender, TimerPhase e) { UpdateSumOfBestValue((LiveSplitState)sender); }
// Reset the odds calculations void state_OnReset(object sender, TimerPhase e) { CalculateOdds(); }
void CurrentState_OnReset(object sender, TimerPhase e) { RegenerateComparisons(); this.InvokeIfRequired(() => { if (InTimerOnlyMode) { var timerOnlyRun = new StandardRunFactory().Create(ComparisonGeneratorsFactory); timerOnlyRun.Offset = CurrentState.Run.Offset; SetRun(timerOnlyRun); } resetMenuItem.Enabled = false; pauseMenuItem.Enabled = false; undoSplitMenuItem.Enabled = false; skipSplitMenuItem.Enabled = false; splitMenuItem.Enabled = true; splitMenuItem.Text = "Start"; }); }
public void OnReset(object sender, TimerPhase e) { currentSplit = -1; lastHasPointer = mem.HasPointer(); WriteLog("---------Reset----------------------------------"); }
public void OnReset(object sender, TimerPhase e) { currentSplit = 0; WriteLog("---------Reset----------------------------------"); }
private void UpdatePb(object sender, TimerPhase e) { PersonalBest = GetPbFromState(CurrentState); }
void state_OnReset(object sender, TimerPhase t) { _count = 0; }
public void UpdatePresence(LiveSplitState state) { DeltaFormatter.Accuracy = Settings.Accuracy; DeltaFormatter.DropDecimals = Settings.DropDecimals; string GlobalComparison = Settings.Comparison; if (GlobalComparison == "Current Comparison") { GlobalComparison = state.CurrentComparison; } TimerPhase RunState = state.CurrentPhase; string CategoryName = state.Run.CategoryName; string DetailedCategoryName = state.Run.GetExtendedCategoryName(); string GameName = state.Run.GameName; string ShortGameName = state.Run.GameName.GetAbbreviations().Last(); TimeSpan?delta = TimeSpan.Zero; if (RunState == TimerPhase.NotRunning && Settings.NRClearActivity) { activityManager.ClearActivity((res) => { if (res != Result.Ok) { throw new ResultException(res); } }); return; } string RunningImage = "gray_square"; string SplitName = ""; if (RunState == TimerPhase.Running || RunState == TimerPhase.Paused) { SplitName = state.CurrentSplit.Name; // Want to do more with this, maybe more advanced formatting. For now, simple removal. if (Settings.SubSplitCount && SplitName.Length > 0) { int bracket1 = SplitName.IndexOf("{"); int bracket2 = SplitName.IndexOf("}"); if (SplitName.Substring(0, 1) == "-") { SplitName = SplitName.Substring(1); } if ((bracket1 != -1 && bracket2 != -1) && SplitName.Length > bracket2) { SplitName = SplitName.Substring(bracket2 + 1); } } } if (RunState != TimerPhase.NotRunning) { var timestring = ""; if (state.CurrentSplitIndex > 0) { GetDelta(GlobalComparison); } if (RunState != TimerPhase.Paused && timestring.Length > 0) { RunningImage = timestring.Substring(0, 1) == "+" ? "red_square" : "green_square"; } } long StartTime = 0; if (Settings.DisplayElapsedTimeType == ElapsedTimeType.DisplayAttemptDuration || Settings.DisplayElapsedTimeType == ElapsedTimeType.DisplayADwOffset) { DateTime sTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); StartTime = (long)(state.AttemptStarted - sTime).TotalSeconds; if (Settings.DisplayElapsedTimeType == ElapsedTimeType.DisplayADwOffset) { StartTime -= (long)state.Run.Offset.TotalSeconds; } } else if (Settings.DisplayElapsedTimeType == ElapsedTimeType.DisplayGameTime) { StartTime = DateTime.UtcNow.Ticks - (long)state.CurrentTime[state.CurrentTimingMethod].Value.TotalSeconds; } var activity = new Activity { Details = CheckText("Details"), State = CheckText("State"), Assets = { LargeImage = "livesplit_icon", LargeText = CheckText("largeImage") } }; if (Settings.Comparison != NoneComparisonGenerator.ComparisonName) { activity.Assets.SmallText = CheckText("smallImage"); activity.Assets.SmallImage = RunningImage; } if (RunState == TimerPhase.Running && (int)Settings.DisplayElapsedTimeType >= 1) { activity.Timestamps.Start = StartTime; } activityManager.UpdateActivity(activity, (res) => { if (res != Result.Ok) { throw new ResultException(res); } }); string CheckText(string item) { string text = GetText(item); if (text == "%inherit") { text = GetText(item, true); if (text.Contains("%delta") || text.Contains("%split")) { if (RunState == TimerPhase.NotRunning) { return("Not Running"); } else if (RunState == TimerPhase.Ended) { return("Ended. Final Time: " + TimeFormatter.Format(state.CurrentTime[state.CurrentTimingMethod])); } else if (RunState == TimerPhase.Paused) { return("Paused"); } else { text = FindDelta(text); text = text.Replace("%split", SplitName); } } } else { text = FindDelta(text); text = text.Replace("%split", SplitName); } text = text.Replace("%game_short", ShortGameName); text = text.Replace("%game", GameName); text = text.Replace("%category_detailed", DetailedCategoryName); text = text.Replace("%category", CategoryName); text = text.Replace("%attempts", state.Run.AttemptCount.ToString()); text = text.Replace("%comparison", GlobalComparison); text = text.Replace("%time", TimeFormatter.Format(state.CurrentTime[state.CurrentTimingMethod])); return(text); } string GetText(string item, bool GetRunning = false) { if (RunState == TimerPhase.Running || GetRunning) { if (item == "Details") { return(Settings.Details); } else if (item == "State") { return(Settings.State); } else if (item == "largeImage") { return(Settings.largeImageKey); } else { return(Settings.smallImageKey); } } else if (RunState == TimerPhase.NotRunning) { if (item == "Details") { return(Settings.NRDetails); } else if (item == "State") { return(Settings.NRState); } else if (item == "largeImage") { return(Settings.NRlargeImageKey); } else { return(Settings.NRsmallImageKey); } } else if (RunState == TimerPhase.Ended) { if (item == "Details") { return(Settings.EDetails); } else if (item == "State") { return(Settings.EState); } else if (item == "largeImage") { return(Settings.ElargeImageKey); } else { return(Settings.EsmallImageKey); } } else { if (item == "Details") { return(Settings.PDetails); } else if (item == "State") { return(Settings.PState); } else if (item == "largeImage") { return(Settings.PlargeImageKey); } else { return(Settings.PsmallImageKey); } } } string GetDelta(string Comparison) { int SplitIndex = (RunState == TimerPhase.Ended ? state.CurrentSplitIndex - 1 : state.CurrentSplitIndex); delta = LiveSplitStateHelper.GetLastDelta(state, SplitIndex, Comparison, state.CurrentTimingMethod); return(DeltaFormatter.Format(delta)); } string FindDelta(string SearchText) { if (SearchText.IndexOf("%delta_") != -1) { SearchText = SearchText.Replace("%delta_cur", GetDelta(state.CurrentComparison)); foreach (KeyValuePair <string, string> deltaCheck in ComparisonDict) { SearchText = SearchText.Replace(deltaCheck.Key, GetDelta(deltaCheck.Value)); } } SearchText = SearchText.Replace("%delta", GetDelta(GlobalComparison)); return(SearchText); } }
private void DoReset(object sender, TimerPhase value) { LiveSplitState state = (LiveSplitState)sender; CurrentNote = new Note("", ComponentName); }
public void OnReset(object sender, TimerPhase e) { currentSplit = 0; startOfBomb = DateTime.MinValue; endOfBomb = DateTime.MinValue; bestTimeRTA = 0; bestTime = 0; }
public void OnReset(object sender, TimerPhase e) { LogWriter.WriteLine("[LiveSplit] Reset."); oriState.Reset(); oriState.oriTriggers.timerRunning = (Model.CurrentState.CurrentPhase == TimerPhase.Running); }
void state_OnReset(object sender, TimerPhase t) { MapTimesForm.Instance.Reset(); _waitingForDelay = false; }
void CurrentState_OnReset(object sender, TimerPhase e) { RegenerateComparisons(); Action x = () => { if (InTimerOnlyMode) { var offset = CurrentState.Run.Offset; TimerOnlyRun = new StandardRunFactory().Create(ComparisonGeneratorsFactory); TimerOnlyRun.Offset = offset; var run = TimerOnlyRun; SetRun(run); } resetMenuItem.Enabled = false; pauseMenuItem.Enabled = false; undoSplitMenuItem.Enabled = false; skipSplitMenuItem.Enabled = false; splitMenuItem.Enabled = true; splitMenuItem.Text = "Start"; }; if (InvokeRequired) Invoke(x); else x(); }
private void OnReset(object sender, TimerPhase timerPhase) { timer.CurrentState.Run.Offset = TimeSpan.Zero; }
public void OnSplitReset(object sender, TimerPhase timerPhase) { //SharedDataManager.Parse SendTargetData(); }
private void State_OnReset(object sender, TimerPhase value) { this.resetIndexesLatch = false; this.model.Reset(); }
void state_OnReset(object sender, TimerPhase e) { GameTimeForm.Close(); PreviousLocation = GameTimeForm.Location; }
void state_OnReset(object sender, TimerPhase e) { InvokeIfNeeded(() => { lock (VLC) { VLC.playlist.stop(); if (activated) Control.Visible = false; } }); }
void State_OnReset(object sender, TimerPhase e) { UpdateBearCartPB(); }
// Making the phase nullable makes testing easier. public void Refresh(TimerPhase?nullablePhase = null) { // In theory, the first IGT frame of a run should have a time value of about 32 milliseconds (i.e. one // frame at 30 fps). In practice, though, the first non-zero time value tends to be a bit bigger than that. // This threshold is arbitrary, but is meant to be big enough to cover that variation in start time, but // small enough that later loads into a file don't autostart the timer. const int TimerAutostartThreshold = 150; if (!Hook()) { return; } // This will only be true while testing (through a console program). if (nullablePhase == null) { return; } if (waitingOnFirstLoad) { if (!memory.IsPlayerLoaded()) { return; } InitializeItems(); UpdateRunState(); waitingOnFirstLoad = false; } TimerPhase phase = nullablePhase.Value; // Someone might want to disable timer autostart if using real time and starting their timer from the main // menu (or some other reason). if (phase == TimerPhase.NotRunning && masterControl.StartTimerAutomatically) { int time = memory.GetGameTimeInMilliseconds(); // The timer should autostart on a new game, but not every time you load into a file. Note that // if someone resets their timer manually immediately as the run begins, the timer may // autostart again if game time is still less than the threshold value. This is fixable, but // likely not worth the effort. if (run.GameTime == 0 && time > 0 && time < TimerAutostartThreshold) { timer.Start(); } } // Quitout splits (below) are detected using game time (specifically, when IGT is reset back to zero). As // such, the current IGT value needs to be stored here before it's reset while updating game time. int previousGameTime = run.GameTime; int newGameTime = memory.GetGameTimeInMilliseconds(); // The timer is intentionally updated before an autosplit occurs (to ensure the split time is as accurate // as possible). if (masterControl.UseGameTime) { UpdateGameTime(newGameTime); } else { // Game time must be tracked even if "Use game time" is disabled (in order to accomodate quitout // splits). run.GameTime = newGameTime; } // This is called each tick regardless of whether the current split is an item split (to ensure that the // inventory state is accurate by the time an item split crops up). if (itemsEnabled) { memory.RefreshItems(); } // This check is intentionally done relatively far down in the function. The reason is that an ended timer // can be undone, and if that happens, I'd like all splits to continue working properly. Specifically, that // means that items and IGT (if applicable) are tracked even when the timer has ended. if (phase == TimerPhase.Ended) { return; } Split split = splitCollection.CurrentSplit; // It's possible for the current split to be null if no splits were configured at all. if (split == null || split.Type == SplitTypes.Manual || !split.IsFinished) { return; } // This condition covers all split types with warping as an option. if (preparedForWarp) { if (isBonfireWarpSplitActive) { int[] leaveValues = { (int)AnimationFlags.BonfireLeave1, (int)AnimationFlags.BonfireLeave2, (int)AnimationFlags.BonfireLeave3 }; int animation = memory.GetForcedAnimation(); // Without this check, the player could rest at a target bonfire (without warping), then warp from // another bonfire and have the tool incorrectly split. if (leaveValues.Contains(animation)) { preparedForWarp = false; return; } } else if (isItemWarpSplitActive && !IsTargetItemSatisfied()) { preparedForWarp = false; return; } if (CheckWarp()) { timer.Split(); } return; } // Similar to warping, this covers all splits with quitouts as a timing option (and Quitout splits // themselves, of course). if (waitingOnQuitout) { // Game time is reset to zero on the title screen, but not on regular loading screens. if (newGameTime == 0 && previousGameTime > 0) { if (splitCollection.CurrentSplit.Type == SplitTypes.Quitout) { run.Data++; // Quitout splits track quitout count. If that target hasn't yet been satisfied, the function // can just return immediately (which leaves the waitingOnQuitout variable intact). if (run.Data < run.Target) { return; } } // On quitout splits, the actual split occurs on the loading screen following a reload // (specifically when the player is loaded). This is done to account for any potential IGT drift // between quitout and reload. In theory, this drift shouldn't exist, but it seems to happen anyway // in practice. waitingOnUnload = true; waitingOnQuitout = false; } return; } if (waitingOnUnload) { // When the load screen appears following a quitout, the player isn't unloaded instantly. if (!memory.IsPlayerLoaded()) { waitingOnUnload = false; waitingOnReload = true; } return; } if (waitingOnReload) { // By the time this point in the code is reached, the player must already be unloaded (due to quitting // to the title screen). if (memory.IsPlayerLoaded()) { waitingOnReload = false; timer.Split(); } return; } if (splitFunctions[split.Type](split.Data)) { timer.Split(); } }
public void OnReset(object sender, TimerPhase e) { currentSplit = -1; Model.CurrentState.IsGameTimePaused = true; WriteLog("---------Reset----------------------------------"); }
private void State_OnReset(object sender, TimerPhase e) { if (e != TimerPhase.Ended) PlaySound(Settings.Reset, Settings.ResetVolume); }
public void OnBaseReset(object sender, TimerPhase timerPhase) { OnReset?.Invoke(sender, timerPhase); }
void state_OnReset(object sender, TimerPhase t) { }
public void OnReset(object sender, TimerPhase e) { currentSplit = 0; Model.CurrentState.IsGameTimePaused = true; WriteLog("---------Reset----------------------------------"); }