Excessive

        }

        private static ReactionScannerService? s_instance;

        public static ReactionScannerService Instance => s_instance ??= new ReactionScannerService();

        // Current Status

        public bool IsCaptured { get; private set; }

        public PaintColor RecordedColor {

            get => _recordedColor;

            private set => _recordedColor.Set(value);

        private int _pixelMultiplier = 1;

        private bool _firstRun   = true;

        private int _lastSwatchX = -1;

        private int _lastSwatchY = -1;

        public void RefreshFromSettings()

        {

            SettingsService.Get(SettingKey.PixelMultiplier, out _pixelMultiplier, Constants.DefaultPixelMultiplier);

            SettingsService.Get(SettingKey.ScreenX, out _screenX, Constants.DefaultScreenX);

            SettingsService.Get(SettingKey.ScreenY, out _screenY, Constants.DefaultScreenY);

        private void UpdateSwatchSizes()

        {

        }

        public void CancelScan()

            if (!PixelColor.IsDark(pixels.ColorAt(x, y))) return false;

            // 2.) grab the swatch color 2 down from top border

            // Scan the column from 2 below the top to 3 above the bottom to ensure the color matches

            for (int i = 2; i < (_swatchHeight-3); ++i)

        {

            bool result = true;

            int swatchSolidRightX = swatchSolidLeftX + swatchSolidWidth - 1;

            int swatchSolidBottomY = swatchSolidTopY + swatchSolidHeight - 1;

                return false;

            }

            // scan down the right and left sides

            {

                result &= pixels.DoesPixelMatch(swatchSolidLeftX, swatchSolidTopY + yOff, ColorMatcher.IsMatch);

                if (!result)

            }

            if (!result)

            {

                return false;

            }

            {

                result &= pixels.DoesPixelMatch(swatchSolidLeftX + xOff, swatchSolidTopY, ColorMatcher.IsMatch);

                if (!result)

            }

            if (!result)

            {

                return false;

            }

            // test the left edge for dark pixels -- the bottom-most pixel is bright now

            int i = 0;

            {

                result &= pixels.DoesPixelMatch(x, y + i, PixelColor.IsDark);

            }

            if (!result)

            {

                return false;

            }

            bool borderError = false;

            {

                bool isBorder = pixels.DoesPixelMatch(x + i, y, PixelColor.IsDark);

                result &= isBorder;

                    borderError = true;

                }

                // The row just above is shaded, so check 2 above

                if (y > 1)

                {

                }

                else

                {

                }

                if (y < pixels.Height)

                {

                }

                else

                {

                }

            }

            {

                {

                }

            }

        private bool TestPosition(int x, int y, Pixels pixels, ref PaintColor reactedColor)

        {

            // Check 4 corners of solid area and left/right solid bar areas

            if (foundSwatch)

            {

                WriteLog(LogVerbosity.Normal, "Found probable swatch at {0},{1} - checking border slices", x, y);

                int borderXOffset = 0;

                {

                    foundSwatch &= IsPossibleSwatchSlice(pixels, x + borderXOffset, y);

                    if (!foundSwatch)

                }

            }

            // WE FOUND THE SWATCH!

            // Now we know where the color bars are.

            int redPixelCount = pixels.LengthOfColorAt(x, y + _redBarSpacing, PixelColor.IsRed);

            int greenPixelCount = pixels.LengthOfColorAt(x, y + _greenBarSpacing, PixelColor.IsGreen);

            int bluePixelCount = pixels.LengthOfColorAt(x, y + _blueBarSpacing, PixelColor.IsBlue);

            WriteLog(LogVerbosity.Low, "Found the color swatch at {0}, {1}. Color={2} Red={3}px Green={4}px Blue={5}px", x, y, reactedColor, redPixelCount, greenPixelCount, bluePixelCount);

            return true;

        }

                g.CopyFromScreen(_screenX, _screenY, 0, 0, _targetBitmap.Size, CopyPixelOperation.SourceCopy);

            }

            Pixels pixels = new(_targetBitmap, _pixelMultiplier);

            SettingsService.Get("Log.Verbosity", out var verbosityIdx, 1);

            _logVerbosity = (LogVerbosity)verbosityIdx;

            SettingsService.Get("ScanArea.Min.X", out var startX, 0);

            SettingsService.Get("ScanArea.Min.Y", out var startY, 0);

            startX = Math.Max(2, Math.Min(startX, _targetBitmap.Width - 2));

            startY = Math.Max(2, Math.Min(startY, _targetBitmap.Height - 2));

            endY = Math.Min(_targetBitmap.Height - 2, Math.Max(2, endY)) - (_blueBarSpacing + 10); // + patchTestSize;

            int xSpan = endX - startX;

            int ySpan = endY - startY;

                    Color patchColor = pixels.ColorAt(roughX, roughY);

                    WriteLog(LogVerbosity.Excessive, "Found a solid patch of {2},{3},{4} at {0}, {1}", roughX, roughY, patchColor.R, patchColor.G, patchColor.B);

                    {

                        {

                            WriteLog(LogVerbosity.Excessive, "Searching for potential swatch at {0},{1} after found square at {2},{3}", x, y, roughX, roughY);

            return new Reaction(r, g, b);

        }

        public static Reaction CalculateReaction(PaintColor expectedColor, PaintColor reactedColor)

        {

            // A 2-reagent reaction.

{

    public static class SettingKey

    {

        public const string PixelMultiplier = "pixelmultiplier";

        public const string ScreenIndex     = "screenindex";

        public const string ScreenX         = "screenx";

{

    public static class Constants

    {

        public static int DefaultPixelMultiplier = 1;

        public static int DefaultScreenWidth = 1920;

        public static int DefaultScreenHeight = 1080;

            }

        }

    }

}

{

    public class PixelColor

    {

        public static bool IsMatch(Color colorA, Color colorB)

        {

            return (color.R < 0x47) && (color.G < 0x47) && (color.B < 0x47);

        }

        {

        }

        public static bool IsRed(Color color)

        {

        }

        public static bool IsGreen(Color color)

        {

        }

        public static bool IsBlue(Color color)

        {

        }

    }

            TestView.SaveReaction.Subscribe(_ => OnSaveReaction());

            TestView.ClearReaction.Subscribe(_ => OnClearReaction());

        }

        private ReactionTest GetSelectedReactionTest()

            return (itemIndex >= list.Count) ? Constants.StubReactionTest : list[itemIndex];

        }

        private void OnSaveReaction()

        {

            ReactionTest test = TestView.ReactionTest;

            }

        }

        private static void InsertTestIntoList(ReactionTest test, IList<ReactionTest> list)

        {

            int i;

            ShowScreenSettingsDialog = new Interaction<ScreenSettingsViewModel, Unit>();

            SaveReaction = ReactiveCommand.Create(() => ReactionTest.SaveReaction());

            ClearReaction = ReactiveCommand.Create(() => ReactionTest.ClearReaction());

        }

        private void UpdateDerivedState()

            try

            {

                await ReactionTest.StartScan();

            }

            catch (OperationCanceledException)

            {

            await ShowInfoBox("Clipped Reactions", "The Pigment Lab is only capable of displaying color channel values in the 0-255 range. However, sometimes, your reactions will push one or more channels outside of that range. When that happens, the value will be clamped either to 0 or 255. In this case, we say that the reaction was \"Clipped.\"\n\nThis is nothing to panic about, though. We solve this issue by using a third (buffer) reagent to offset the extreme value, so that it falls within measurable range, similar to how we test Catalyst+Catalyst reactions. Desert Paint Codex will automatically do the math for this, but it does move clipped reactions towards the end of your test list, because you'll want any reactions between the buffer reagent and your two test reagents already known, prior to running your buffered test.");

        }

        public Interaction<ScreenSettingsViewModel, Unit> ShowScreenSettingsDialog { get; }

        public ReactiveCommand<Unit, Unit> ClearReaction { get; }

        public ReactiveCommand<Unit, Unit> SaveReaction { get; }

    }

}



using Avalonia.Platform;

using DesertPaintCodex.Models;

using DesertPaintCodex.Services;

using ReactiveUI;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Reactive;

using Avalonia;

using Avalonia.Controls.ApplicationLifetimes;

{

    public class ScreenSettingsViewModel : ViewModelBase

    {

        public ObservableCollection<ScreenMetrics> Screens { get; } = new();

        private int _pixeMultiplier;

        public int PixelMultiplier { get => _pixeMultiplier; private set => this.RaiseAndSetIfChanged(ref _pixeMultiplier, value); }

            if (Application.Current.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)

            {

                IScreenImpl screen = desktop.MainWindow.PlatformImpl.Screen;

                IReadOnlyList<Screen> screens = screen.AllScreens;

                for (int i = 0; i < screens.Count; i++)

                    Screens.Add(new ScreenMetrics(screens[i].Bounds, screens[i].Primary));

                }

                SettingsService.Get(SettingKey.PixelMultiplier, out _pixeMultiplier, Constants.DefaultPixelMultiplier);

                SettingsService.Get(SettingKey.ScreenIndex,     out _screenIndex, 0);

                _screenIndex = System.Math.Min(_screenIndex, screens.Count - 1); // In case the user has fewer screens than last time.

                Save = ReactiveCommand.Create(() => {

                    SettingsService.Set(SettingKey.PixelMultiplier, _pixeMultiplier);

                    SettingsService.Set(SettingKey.ScreenIndex,     _screenIndex);

                    SettingsService.Set(SettingKey.ScreenX,         screens[_screenIndex].Bounds.X);

            else

            {

                // Placeholder stuff.

                Screens.Add(new ScreenMetrics(new Avalonia.PixelRect(0, 0, 1920, 1080), true));

                Screens.Add(new ScreenMetrics(new Avalonia.PixelRect(1920, 0, 1920, 1080), false));

                PixelMultiplier       = 1;

                ScreenIndex           = 0;

using System.Reactive;

using ReactiveUI;

using System.Collections.Generic;

using System.Diagnostics;

using DesertPaintCodex.Services;

namespace DesertPaintCodex.ViewModels

{

    public class SelectProfileViewModel : ViewModelBase

    {

        private string? _selectedItem;

        public string? SelectedItem { get => _selectedItem; set => this.RaiseAndSetIfChanged(ref _selectedItem, value); }

        public SelectProfileViewModel()

        {

            var okEnabled = this.WhenAnyValue(

                x => x.SelectedItem,

        private void ShowSelectProfile()

        {

                _selectProfileVM = new SelectProfileViewModel();

                _selectProfileVM.NewProfile.Subscribe(_ => ShowCreateProfile());

                Observable.Merge(_selectProfileVM.Ok, _selectProfileVM.Cancel)

                    .Take(1)

                    .InvokeCommand(FinishWelcome);

            ProfileActivity = _selectProfileVM;

        }

        private void ShowCreateProfile()

        {

                _createProfileVM = new CreateProfileViewModel();

                Observable.Merge(_createProfileVM.Ok, _createProfileVM.Cancel).Subscribe(_ => ShowSelectProfile());

            ProfileActivity = _createProfileVM;

        }

    <DockPanel Classes="Activity">

        <TabControl DockPanel.Dock="Left" Width="318" Classes="ListFilter" SelectedIndex="{Binding SelectedList}">

            <TabItem Header="Pending Tests">

            </TabItem>

            <TabItem Header="Completed Tests">

            </TabItem>

        </TabControl>

using Avalonia.ReactiveUI;

using DesertPaintCodex.ViewModels;

{

    public class ExperimentLogView : ReactiveUserControl<ExperimentLogViewModel>

    {

        public ExperimentLogView()

        {

            InitializeComponent();

        }

        private void InitializeComponent()

        {

            AvaloniaXamlLoader.Load(this);

        }

    }

}

    <Button DockPanel.Dock="Bottom" Command="{Binding Save}">Ok</Button>

    <Grid DockPanel.Dock="Bottom" ColumnDefinitions="*,12,80,12,24" RowDefinitions="Auto,30,Auto" Margin="0, 0, 0, 30">

      <TextBlock VerticalAlignment="Center" TextWrapping="Wrap" TextAlignment="Right" Grid.Row="2" Grid.Column="0">

        Screen pixels to game pixels:

      </TextBlock>

        <ToolTip.Tip>

          <StackPanel Margin="5" Spacing="20" Orientation="Vertical">

            <TextBlock Classes="BlockHeader">Screen Pixels to Game Pixels</TextBlock>

          </StackPanel>

        </ToolTip.Tip>

    <ListBox Items="{Binding Screens}" SelectedIndex="{Binding ScreenIndex, Mode=TwoWay}" Margin="0,4,0,20">

      <ListBox.ItemTemplate>