ATITD-Tools/Desert-Paint-Codex Changeset

Changeset - d7b40cfbe0f3

Parent rev.

Child rev.

[Not reviewed]

R_T10_1.2 default

0 2 0

Tess Snider (Malkyne) - 4 years ago 2021-07-21 09:24:41
this@malkyne.org

Analyzing a Mixture should no longer cause the Pending Tests lists to
scroll down a little, for no reason.

2 files changed with 24 insertions and 13 deletions:

Models/ReactionTest.cs

ViewModels/ExperimentLogViewModel.cs

0 comments (0 inline, 0 general)

Models/ReactionTest.cs

➞

Show inline comments

@@ ... / @@ -31,275 +31,276 @@ namespace DesertPaintCodex.Models @@
             set
+            {
                 if (_bufferReagent == value) return;
                 _bufferReagent = value;
                 _recipe.Clear();
                 if (_bufferReagent == null)
+                {
                     _recipe.AddReagent(Reagent1.Name);
                     _recipe.AddReagent(Reagent2.Name);
+                }
                 else
+                {
                     _recipe.AddReagent(_bufferReagent.Name);
                     _recipe.AddReagent(Reagent1.Name);
                     _recipe.AddReagent(Reagent2.Name);
+                }
                 NotifyPropertyChanged(nameof(BufferReagent));
                 NotifyPropertyChanged(nameof(CanScan));
                 UpdateHypotheticalColor();
+            }
+        }
         private ClipType _clipType;
         public ClipType Clipped {
             get => _clipType;
             set
+            {
                 _clipType = value;
                 NotifyPropertyChanged(nameof(Clipped));
+            }
+        }
         public bool IsAllCatalysts { get; }
         private Reaction? _reaction;
         public Reaction? Reaction { get => _reaction; set { _reaction = value; NotifyPropertyChanged(nameof(Reaction)); } }
         private Reaction? _badReaction;
         public Reaction? BadReaction { get => _badReaction; set { _badReaction = value; NotifyPropertyChanged(nameof(BadReaction)); } }
         private int _scanProgress;
         public int ScanProgress { get => _scanProgress; set { _scanProgress = value; NotifyPropertyChanged(nameof(ScanProgress)); } }
         private TestState _state;
         public TestState State
+        {
             get => _state;
             set
+            {
                 _state = value;
                 NotifyPropertyChanged(nameof(State));
                 NotifyPropertyChanged(nameof(Requires3Way));
                 NotifyPropertyChanged(nameof(CanScan));
                 NotifyPropertyChanged(nameof(IsScanning));
                 NotifyPropertyChanged(nameof(HasResults));
                 NotifyPropertyChanged(nameof(HasReaction));
                 NotifyPropertyChanged(nameof(CanClear));
                 NotifyPropertyChanged(nameof(CanSave));
                 NotifyPropertyChanged(nameof(NoLab));
                 NotifyPropertyChanged(nameof(CanPickBuffer));
+            }
+        }
         public bool Requires3Way =>
             (State == TestState.ClippedResult) || IsAllCatalysts;
         public bool CanScan => (State is TestState.Untested or TestState.LabNotFound) || ((State == TestState.ClippedResult) && (BufferReagent != null));
         public bool IsScanning => State == TestState.Scanning;
         public bool HasResults => (ObservedColor != null) && (State is TestState.ClippedResult or TestState.GoodResult or TestState.LabNotFound);
         public bool HasReaction => State is TestState.ClippedResult or TestState.GoodResult or TestState.Saved;
         public bool CanClear => State is TestState.ClippedResult or TestState.GoodResult or TestState.Saved;
         public bool CanSave => State == TestState.GoodResult;
         public bool NoLab => State == TestState.LabNotFound;
         public bool CanPickBuffer => (State == TestState.ClippedResult) || IsAllCatalysts;
         private PaintColor? _hypotheticalColor;
         public PaintColor? HypotheticalColor { get => _hypotheticalColor; set { _hypotheticalColor = value; NotifyPropertyChanged(nameof(HypotheticalColor)); } }
         private PaintColor? _observedColor;
         public PaintColor? ObservedColor { get => _observedColor; set { _observedColor = value; NotifyPropertyChanged(nameof(ObservedColor)); } }
         private readonly PaintRecipe _recipe = new();
         public bool IsStub { get; }
         public ReactionTest(Reagent reagent1, Reagent reagent2, Reaction? reaction, ClipType clipType, bool isStub = false)
+        {
             Reagent1 = reagent1;
             Reagent2 = reagent2;
             IsAllCatalysts = reagent1.IsCatalyst && reagent2.IsCatalyst;
             Clipped = clipType;
             Reaction = reaction;
             State = (reaction != null) ? TestState.Saved :
                 (clipType == ClipType.None) ? TestState.Untested : TestState.ClippedResult;
             _recipe.AddReagent(reagent1.Name);
             _recipe.AddReagent(reagent2.Name);
             IsStub = isStub;
             UpdateHypotheticalColor();
+        }
         #region Actions
         public async Task StartScan()
+        {
             Clipped = ClipType.None;
             ScanProgress = 0;
             Reaction = null;
             BadReaction = null;
             State = TestState.Scanning;
             bool foundLab = await ReactionScannerService.Instance.CaptureReactionAsync(this);
             if (foundLab)
+            {
                 ObservedColor = ReactionScannerService.Instance.RecordedColor;
                 if (_observedColor != null)
+                {
                     Clipped = _observedColor.Red switch
+                        {
 => ClipType.RedLow,
 => ClipType.RedHigh,
                             _   => ClipType.None
+                        }
                         | _observedColor.Green switch
+                        {
 => ClipType.GreenLow,
 => ClipType.GreenHigh,
                             _   => ClipType.None
+                        }
                         | _observedColor.Blue switch
+                        {
 => ClipType.BlueLow,
 => ClipType.BlueHigh,
                             _   => ClipType.None
                         };
                     if (Clipped == ClipType.None)
+                    {
                         State = TestState.GoodResult;
                         Reaction = CalculateReaction();
+                    }
                     else
+                    {
                         State = TestState.ClippedResult;
                         BadReaction = CalculateReaction();
+                    }
                     PlayerProfile? profile = ProfileManager.CurrentProfile;
                     profile?.SetPairClipStatus(Reagent1, Reagent2, Clipped);
+                }
+            }
             else
+            {
                 Debug.WriteLine("ERROR: Lab UI not found.");
                 State = TestState.LabNotFound;
+            }
+        }
         public void CancelScan()
+        {
             ReactionScannerService.Instance.CancelScan();
             State = TestState.Untested;
+        }
         public void MarkInert()
+        {
             Reaction = new Reaction(0, 0, 0);
             State = TestState.GoodResult;
+        }
         public void ClearReaction()
+        {
             PlayerProfile? profile = ProfileManager.CurrentProfile;
             if (profile == null) return;
             profile.Reactions.Remove(Reagent1, Reagent2);
             profile.SetPairClipStatus(Reagent1, Reagent2, ClipType.None);
             if (State == TestState.Saved)
+            {
                 profile.Save();
+            }
             Reaction = null;
             BadReaction = null;
             Clipped = ClipType.None;
             State = TestState.Untested;
+        }
         public void SaveReaction()
+        {
             PlayerProfile? profile = ProfileManager.CurrentProfile;
             if (profile == null) return;
             profile.Reactions.Set(Reagent1, Reagent2, Reaction);
             profile.Save();
             State = TestState.Saved;
+        }
         #endregion
         #region Internals
         private Reaction? CalculateReaction()
+        {
             if (ProfileManager.CurrentProfile == null) return null;
             if (HypotheticalColor == null) return null;
             if (ObservedColor == null) return null;
             if (BufferReagent != null)
+            {
                 return ReactionScannerService.Calculate3WayReaction(ProfileManager.CurrentProfile, HypotheticalColor,
                     ObservedColor, BufferReagent, Reagent1, Reagent2);
+            }
             return ReactionScannerService.CalculateReaction(HypotheticalColor, ObservedColor);
+        }
         private void UpdateHypotheticalColor()
+        {
             HypotheticalColor = null;
             HypotheticalColor = (IsAllCatalysts && (BufferReagent == null)) ? null : _recipe.BaseColor;
+        }
         #endregion
         #region Interface Implementations
         public event PropertyChangedEventHandler? PropertyChanged;
         [NotifyPropertyChangedInvocator]
         private void NotifyPropertyChanged([CallerMemberName] string? propertyName = null)
+        {
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
         public void Report(float value)
+        {
             ScanProgress = (int)Math.Round(value * 100);
+        }
         #endregion
         public int CompareTo(ReactionTest? other)
+        {
             if (other == null) return 1;
             if (Clipped == ClipType.None)
+            {
                 if (other.Clipped != ClipType.None) return -1;
+            }
             else if (other.Clipped == ClipType.None) return 1;
             if (IsAllCatalysts)
+            {
                 if (!other.IsAllCatalysts) return 1;
+            }
             else if (other.IsAllCatalysts) return -1;
             return string.CompareOrdinal(Reagent1.Name, other.Reagent1.Name) switch
+            {
                 < 0 => -1,
                 > 0 => 1,
                 _   => string.CompareOrdinal(Reagent2.Name, other.Reagent2.Name)
             };
+        }
+    }
+}

ViewModels/ExperimentLogViewModel.cs

➞

Show inline comments

 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using ReactiveUI;
 using DesertPaintCodex.Services;
 using DesertPaintCodex.Models;
 using DesertPaintCodex.Util;
 using DynamicData.Binding;
 namespace DesertPaintCodex.ViewModels
+{
     public class ExperimentLogViewModel : ViewModelBase
+    {
         public ObservableCollection<ReactionTest> RemainingTests { get; } = new();
         public ObservableCollection<ReactionTest> CompletedTests { get; } = new();
         private int _selectedList = 0;
         public int SelectedList { get => _selectedList; private set => this.RaiseAndSetIfChanged(ref _selectedList, value); }
         private int _selectedRemainingTest = 0;
         public int SelectedRemainingTest { get => _selectedRemainingTest; private set => this.RaiseAndSetIfChanged(ref _selectedRemainingTest, value); }
         private int _selectedCompletedTest = 0;
         public int SelectedCompletedTest { get => _selectedCompletedTest; private set => this.RaiseAndSetIfChanged(ref _selectedCompletedTest, value); }
         private ReactionTestViewModel _testView;
         public ReactionTestViewModel TestView { get => _testView; private set => this.RaiseAndSetIfChanged(ref _testView, value); }
         private readonly List<ObservableCollection<ReactionTest>> _testLists = new();
         public ExperimentLogViewModel()
+        {
             PlayerProfile? profile = ProfileManager.CurrentProfile;
             Debug.Assert(profile != null);
             _testLists.Add(RemainingTests);
             _testLists.Add(CompletedTests);
             ReactionTestService.PopulateRemainingTests(RemainingTests);
             ReactionTestService.PopulateCompletedTests(CompletedTests);
             // If we have no remaining tests, switch to the completed list.
             _testView = new ReactionTestViewModel();
             if (RemainingTests.Count > 0)
+            {
                 SelectedList = 0;
                 _testView.ReactionTest = RemainingTests[0];
+            }
             else
+            {
                 SelectedList = 1;
                 _testView.ReactionTest = CompletedTests[0];
+            }
             this.WhenAnyPropertyChanged(nameof(SelectedList), nameof(SelectedRemainingTest), nameof(SelectedCompletedTest))
                 .Subscribe(_ => _testView.ReactionTest = GetSelectedReactionTest());
             _testView.ReactionTest = GetSelectedReactionTest();
             TestView.SaveReaction.Subscribe(_ => OnSaveReaction());
             TestView.ClearReaction.Subscribe(_ => OnClearReaction());
             TestView.FinalizeTestResults.Subscribe(_ => OnReactionResults());
+        }
         private ReactionTest GetSelectedReactionTest()
+        {
             int itemIndex = (SelectedList == 0) ? SelectedRemainingTest : SelectedCompletedTest;
             if (itemIndex < 0) return Constants.StubReactionTest;
             var list = _testLists[SelectedList];
             return (itemIndex >= list.Count) ? Constants.StubReactionTest : list[itemIndex];
+        }
         #region Command Handlers
         private void OnSaveReaction()
+        {
             ReactionTest test = TestView.ReactionTest;
             int oldPos = RemainingTests.IndexOf(test);
             // Move test to Completed Tests.
             InsertTestIntoList(test, CompletedTests);
             RemainingTests.RemoveAt(oldPos);
             // Select next Remaining Test.
             if (RemainingTests.Count == 0) return;
             SelectedRemainingTest = (oldPos == RemainingTests.Count) ? RemainingTests.Count - 1 : oldPos;
             // If we have just inserted our first completed test, select it.
             if (CompletedTests.Count == 1)
+            {
                  SelectedCompletedTest = 0;
+            }
+        }
         private void OnClearReaction()
+        {
             int oldPos = 0;
             ReactionTest test = TestView.ReactionTest;
             if (!CompletedTests.Contains(test)) return;
             if (RemainingTests.Contains(test))
+            {
                 SelectedRemainingTest = ResortTestInList(test, RemainingTests);
                 return;
+            }
-            int oldPos = CompletedTests.IndexOf(test);
             oldPos = CompletedTests.IndexOf(test);
             // Move test to Remaining Tests.
             InsertTestIntoList(test, RemainingTests);
             CompletedTests.RemoveAt(oldPos);
             // Select next Completed Test.
             if (CompletedTests.Count == 0) return;
             SelectedCompletedTest = (oldPos == CompletedTests.Count) ? CompletedTests.Count - 1 : oldPos;
             // If we have just inserted our first remaining test, select it.
             if (RemainingTests.Count == 1)
+            {
                 SelectedRemainingTest = 0;
+            }
+        }
         private void OnReactionResults()
+        {
             ReactionTest? test = null;
             int selectedTest = SelectedRemainingTest;
             if (selectedTest >= 0)
             int newPos = ResortTestInList(TestView.ReactionTest, RemainingTests);
             if (newPos != SelectedRemainingTest)
+            {
                 test = RemainingTests[selectedTest];
+            }
             ReactionTestService.PopulateRemainingTests(RemainingTests);
             if (test != null)
+            {
                 int newIndex = RemainingTests.IndexOf(test);
                 SelectedRemainingTest = newIndex;
                 SelectedRemainingTest = newPos;
+            }
+        }
         #endregion
         private static void InsertTestIntoList(ReactionTest test, IList<ReactionTest> list)
         private static int ResortTestInList(ReactionTest test, IList<ReactionTest> list)
+        {
             int oldPos = list.IndexOf(test);
             if (((oldPos > 0) || (test.CompareTo(list[oldPos - 1]) > 0))
                 && ((oldPos == list.Count - 1) || (test.CompareTo(list[oldPos + 1]) < 0))) return oldPos; // No need to move.
             list.RemoveAt(oldPos);
             return InsertTestIntoList(test, list);
+        }
         private static int InsertTestIntoList(ReactionTest test, IList<ReactionTest> list)
+        {
             int i;
             for (i = 0; i < list.Count; i++)
+            {
                 if (test.CompareTo(list[i]) < 0) break;
+            }
             list.Insert(i, test);
             return i;
+        }
+    }
+}

0 comments (0 inline, 0 general)