public static void Single([NotNull] ICompetitionRunVisualizer visualizer, [NotNull] VisualizationChange change) { Guard.NotNull(visualizer, nameof(visualizer)); Guard.NotNull(change, nameof(change)); using (var collector = new VisualizationUpdateCollector(visualizer)) { collector.Include(change); } }
public void RequestAbort() { Log.Debug("Entering RequestAbort."); ExecuteExclusiveIfStateIn(AllStates, () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { GoOffline(collector); } }); }
private void HandlePlaySoundA() { ExecuteExclusiveIfStateIn( StatesInRange(CompetitionClassState.SetupCompleted, CompetitionClassState.RunCompleted), () => { if (modelSnapshot.Alerts.CustomItemA.Sound.EffectivePath != null) { using (var collector = new VisualizationUpdateCollector(visualizer)) { collector.Include(new PlaySound(modelSnapshot.Alerts.CustomItemA.Sound.EffectivePath)); } } }); }
private void HandleMuteSound() { ExecuteExclusiveIfStateIn( StatesInRange(CompetitionClassState.SetupCompleted, CompetitionClassState.RunCompleted), () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { collector.Include(PlaySound.Mute); } }); }
private void HandleChangeFaults(bool isIncrement) { ExecuteExclusiveIfStateIn( StatesInRange(CompetitionClassState.ReadyToStart, CompetitionClassState.FinishPassed), () => { if ((isIncrement && runData.FaultCount <= CompetitionRunResult.MaxFaultValue - CompetitionRunResult.FaultStepSize) || (!isIncrement && runData.FaultCount > 0)) { int stepSize = isIncrement ? CompetitionRunResult.FaultStepSize : -CompetitionRunResult.FaultStepSize; int faultCount = runData.FaultCount + stepSize; runData.FaultCount = faultCount; } using (var collector = new VisualizationUpdateCollector(visualizer)) { runData.HideExistingRunResultIfAny(collector); collector.Include(new FaultCountUpdate(runData.FaultCount)); } }); }
private void HandleResetRun() { ExecuteExclusiveIfStateIn( StatesInRange(CompetitionClassState.ReadyToStart, CompetitionClassState.FinishPassed), () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { ClearCurrentRunOrShowExistingRun(collector); } }); }
private void HandleReady() { ExecuteExclusiveIfStateIn( StatesInRange(CompetitionClassState.SetupCompleted, CompetitionClassState.RunCompleted), () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { switch (classState) { case CompetitionClassState.SetupCompleted: PrepareForRun(collector, true); break; case CompetitionClassState.ReadyToStart: StartClockSynchronization(collector); break; case CompetitionClassState.RunCompleted: PrepareForRun(collector, false); break; default: if (runData.EliminationTracker.IsEliminated || classState == CompetitionClassState.FinishPassed) { CompleteActiveRun(collector); } break; } } }); }
private void ClockSynchronizationMonitorOnSyncCompleted([CanBeNull] object sender, [NotNull] ClockSynchronizationCompletedEventArgs e) { ExecuteExclusiveIfStateIn(CompetitionClassState.WaitingForSync, () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { if (e.Result == ClockSynchronizationResult.Succeeded) { collector.Include(new ClockSynchronizationUpdate(ClockSynchronizationMode.Normal)); if (modelSnapshot.Alerts.ReadyToStart.Sound.EffectivePath != null) { collector.Include(new PlaySound(modelSnapshot.Alerts.ReadyToStart.Sound.EffectivePath)); } ClearCurrentRunOrShowExistingRun(collector); } else { GoOffline(collector); } } }); }
private void HandlePassStart([NotNull] RecordedTime passageTime) { ExecuteExclusiveIfStateIn(CompetitionClassState.ReadyToStart, () => { runData.Timings = new CompetitionRunTimings(passageTime); SetState(CompetitionClassState.StartPassed); runData.EliminationTracker.StartMonitorCourseTime(modelSnapshot.ClassInfo.MaximumCourseTime); using (var collector = new VisualizationUpdateCollector(visualizer)) { runData.HideExistingRunResultIfAny(collector); collector.Include(new StartPrimaryTimer()); } }); }
private void HandlePassFinish([NotNull] RecordedTime passageTime) { ExecuteExclusiveIfStateIn( StatesInRange(CompetitionClassState.StartPassed, CompetitionClassState.Intermediate3Passed), () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { CompetitionRunTimings timingsNotNull = AssertRunDataTimingsNotNull(); runData.Timings = timingsNotNull.ChangeFinishTime(passageTime); SetState(CompetitionClassState.FinishPassed); TimeSpanWithAccuracy elapsed = passageTime.ElapsedSince(runData.Timings.StartTime); Log.Info($"Passed Finish at {elapsed}."); runData.EliminationTracker.StopMonitorCourseTime(); collector.Include(PrimaryTimeStopAndSet.FromTimeSpanWithAccuracy(elapsed)); } }); }
public void CompleteCompetitorSelection(bool isCurrentCompetitor, [CanBeNull] int? competitorNumber) { Log.Debug( $"Entering CompleteCompetitorSelection with number {competitorNumber} for {CurrentOrNext(isCurrentCompetitor)} competitor."); ICollection<CompetitionClassState> statesAllowed = isCurrentCompetitor ? StatesInRange(CompetitionClassState.SetupCompleted, CompetitionClassState.FinishPassed) : StatesInRange(CompetitionClassState.SetupCompleted, CompetitionClassState.RunCompleted); ExecuteExclusiveIfStateIn(statesAllowed, () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { if (competitorNumber != null) { if (isCurrentCompetitor) { if (modelSnapshot.Results.Any(r => r.Competitor.Number == competitorNumber.Value)) { currentCompetitorNumber = competitorNumber.Value; if (nextCompetitorNumberTyped == null || nextCompetitorNumberTyped.Value == currentCompetitorNumber.Value) { nextCompetitorNumberTyped = null; nextCompetitorNumberGenerated = modelSnapshot.GetBestNextCompetitorNumberOrNull(currentCompetitorNumber); UpdateNextCompetitorVisualization(collector); } } UpdateCurrentCompetitorVisualization(collector); if (classState == CompetitionClassState.ReadyToStart) { ClearCurrentRunOrShowExistingRun(collector); } } else if ( modelSnapshot.Results.Any( r => r.Competitor.Number == competitorNumber.Value && (currentCompetitorNumber == null || r.Competitor.Number != currentCompetitorNumber.Value))) { nextCompetitorNumberTyped = competitorNumber.Value; } UpdateNextCompetitorVisualization(collector); } collector.Include(VisualizationChangeFactory.CompetitorNumberBlinkOff(isCurrentCompetitor)); } }); }
public void StartClass([NotNull] CompetitionClassRequirements requirements) { Guard.NotNull(requirements, nameof(requirements)); Log.Debug("Entering StartClass."); ExecuteExclusiveIfStateIn(CompetitionClassState.Offline, () => { modelSnapshot = CacheManager.DefaultInstance.ActiveModel; currentCompetitorNumber = modelSnapshot.GetBestStartingCompetitorNumber(); nextCompetitorNumberTyped = null; nextCompetitorNumberGenerated = modelSnapshot.GetBestNextCompetitorNumberOrNull(currentCompetitorNumber); classRequirements = requirements; runData.Reset(false); SetState(CompetitionClassState.SetupCompleted); using (var collector = new VisualizationUpdateCollector(visualizer)) { collector.Include(VisualizationChangeFactory.ClearAll()); collector.Include(new ClassInfoUpdate(modelSnapshot.ClassInfo)); UpdateCurrentCompetitorVisualization(collector); UpdateNextCompetitorVisualization(collector); CompetitionRunResult previousCompetitorOrNull = modelSnapshot.GetLastCompletedOrNull(); collector.Include(new PreviousCompetitorRunUpdate(previousCompetitorOrNull)); IReadOnlyCollection<CompetitionRunResult> rankings = modelSnapshot.FilterCompletedAndSortedAscendingByPlacement().Results; collector.Include(new RankingsUpdate(rankings)); } }); }
public string TryUpdateRunResult([NotNull] CompetitionRunResult originalRunVersion, [NotNull] CompetitionRunResult newRunVersion) { Guard.NotNull(originalRunVersion, nameof(originalRunVersion)); Guard.NotNull(newRunVersion, nameof(newRunVersion)); string result = null; ExecuteExclusiveIfStateIn(AllStates, () => { // Assumptions: // 1] When class is started, underlying cache can never be changed from the outside. // 2] When no run active (state Offline), we are not in control of underlying cache // (so snapshot field should not be read because it is likely outdated). CompetitionClassModel activeModelVersion = classState == CompetitionClassState.Offline ? CacheManager.DefaultInstance.ActiveModel : modelSnapshot; CompetitionRunResult activeRunVersion = activeModelVersion.GetRunResultOrNull(originalRunVersion.Competitor.Number); if (activeRunVersion == null) { result = "Competitor not found"; return; } if (!CompetitionRunResult.AreEquivalent(activeRunVersion, originalRunVersion)) { result = "Competitor changed in-between"; return; } if (classState != CompetitionClassState.Offline && currentCompetitorNumber == newRunVersion.Competitor.Number) { result = "Competitor is running"; return; } CompetitionClassModel newSnapshot = activeModelVersion.ChangeRunResult(newRunVersion).RecalculatePlacements(); modelSnapshot = CacheManager.DefaultInstance.ReplaceModel(newSnapshot, activeModelVersion); AutoExportRunResults(); if (classState != CompetitionClassState.Offline) { using (var collector = new VisualizationUpdateCollector(visualizer)) { IReadOnlyCollection<CompetitionRunResult> rankings = modelSnapshot.FilterCompletedAndSortedAscendingByPlacement().Results; collector.Include(new RankingsUpdate(rankings)); if (newRunVersion.Competitor.Number == modelSnapshot.LastCompletedCompetitorNumber) { CompetitionRunResult previousCompetitorOrNull = modelSnapshot.GetLastCompletedOrNull(); collector.Include(new PreviousCompetitorRunUpdate(previousCompetitorOrNull)); } } } }); return result; }
private void EliminationTrackerOnRefusalCountChanged([CanBeNull] object sender, [NotNull] EventArgs<int> e) { ExecuteExclusiveIfStateIn(AllStates, () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { runData.HideExistingRunResultIfAny(collector); collector.Include(new RefusalCountUpdate(e.Argument)); } }); }
private void EliminationTrackerOnEliminationChanged([CanBeNull] object sender, [NotNull] EliminationEventArgs e) { ExecuteExclusiveIfStateIn(AllStates, () => { using (var collector = new VisualizationUpdateCollector(visualizer)) { runData.HideExistingRunResultIfAny(collector); collector.Include(new EliminationUpdate(e.IsEliminated)); if (e.IsEliminated) { if (modelSnapshot.Alerts.Eliminated.Picture.EffectiveItem != null) { collector.Include(new StartAnimation(modelSnapshot.Alerts.Eliminated.Picture.EffectiveItem)); } if (modelSnapshot.Alerts.Eliminated.Sound.EffectivePath != null) { collector.Include(new PlaySound(modelSnapshot.Alerts.Eliminated.Sound.EffectivePath)); } } } }); }