public void Update(LiveSplitState state)
        {
            // Hopefully get our process from the memory, as well as initialize our MemoryDefinition for reading
            if (gameProcess == null || gameProcess.HasExited || versionDefinition == null)
            {
                if (!this.TryGetGameProcess(state))
                {
                    return;
                }
            }

            // No need to evaluate anything if not running
            if (state.CurrentPhase != TimerPhase.Running)
            {
                return;
            }

            versionDefinition.UpdateAll(gameProcess);

            if ((versionDefinition.isLoadingState?.Changed ?? false) ||
                (versionDefinition.isMainMenuState?.Changed ?? false) ||
                (versionDefinition.levelSplitsState?.Changed ?? false) ||
                initalUpdate)
            {
                bool bPauseTimer = false;
                Debug.WriteLine("State changed...");

                if (versionDefinition.isLoadingState != null)
                {
                    bool pauses = versionDefinition.isLoadingInfo.ShouldPauseOnValue(versionDefinition.isLoadingState.Current);
                    bPauseTimer |= pauses;

                    int currentValue = versionDefinition.isLoadingState.Current;
                    int wantedValue  = versionDefinition.isLoadingInfo.value;
                    Debug.WriteLine(string.Format(
                                        "Loading: 0x{0:X} {1} 0x{2:X}, should{3} pause",
                                        currentValue,
                                        currentValue == wantedValue ? "==" : "!=",
                                        wantedValue,
                                        pauses ? "" : "n't"
                                        ));
                }

                if (versionDefinition.isMainMenuState != null)
                {
                    bool pauses = versionDefinition.isMainMenuInfo.ShouldPauseOnValue(versionDefinition.isMainMenuState.Current);
                    bPauseTimer |= pauses;

                    int currentValue = versionDefinition.isMainMenuState.Current;
                    int wantedValue  = versionDefinition.isMainMenuInfo.value;
                    Debug.WriteLine(string.Format(
                                        "Main Menu: 0x{0:X} {1} 0x{2:X}, should{3} pause",
                                        currentValue,
                                        currentValue == wantedValue ? "==" : "!=",
                                        wantedValue,
                                        pauses ? "" : "n't"
                                        ));
                }

                if (versionDefinition.levelSplitsState != null)
                {
                    int currentLevel = versionDefinition.levelSplitsState.Current;
                    // lastLevel will not update to the main menu, so this might be different
                    int oldLevel = versionDefinition.levelSplitsState.Old;
                    int mainMenu = versionDefinition.levelSplitsInfo.value;

                    if (initalUpdate)
                    {
                        lastLevel = currentLevel;
                    }
                    else if (currentLevel != 0 && currentLevel != oldLevel) // Filter out invalid pointers and unchanged values
                    {
                        // If you switched to the main menu, add a sq
                        if (currentLevel == mainMenu)
                        {
                            CounterHandler.Increment(state);
                        }
                        // If you switched to a different level than the stored last level, split
                        else if (currentLevel != lastLevel && settings.AllowLevelSplits)
                        {
                            Debug.WriteLine($"Level changed from 0x{lastLevel:X} to 0x{currentLevel:X}");
                            timerModel.Split();
                            lastLevel = currentLevel;
                        }
                    }
                }

                state.IsGameTimePaused = bPauseTimer;

                if (initalUpdate)
                {
                    if (bPauseTimer && !state.IsGameTimeInitialized)
                    {
                        state.SetGameTime(TimeSpan.Zero);
                    }
                    state.IsGameTimeInitialized = true;
                }
                initalUpdate = false;
            }
        }
 public void OnTimerStart(object sender, EventArgs e)
 {
     initalUpdate = true;
     CounterHandler.Reset((LiveSplitState)sender);
 }