{

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

                    foundSwatch &= IsPossibleSwatchSlice(pixels, x + swatchWidth - 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);

                reactedColor.Red = (byte)Math.Round((float)redPixelCount * 255f / (float)colorBarWidth);

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

                reactedColor.Green = (byte)Math.Round((float)greenPixelCount * 255f / (float)colorBarWidth);

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

                reactedColor.Blue = (byte)Math.Round((float)bluePixelCount * 255f / (float)colorBarWidth);

                WriteLog("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;

            }

            return false;

        }

        unsafe public bool CaptureReaction(byte* pixBytes, int screenshotWidth, int screenshotHeight, int stride)

        {

            PaintColor reactedColor = new PaintColor();

            int redPixelStart = 0;

            ScreenWidth = screenshotWidth;

            ScreenHeight = screenshotHeight;

            IsCaptured = false;

            _recordedColor.Clear();

            Pixels pixels = new Pixels

            {

                pixBytes = pixBytes,

                width = screenshotWidth,

                height = screenshotHeight,

                stride = stride,

                pixelMultiplier = pixelMultiplier

            };

            IsCaptured = false;

            if (!firstRun)

            {

                // If this is not the first run, let's check the last location, to see if the UI is still there.

                if (TestPosition(lastSwatchX, lastSwatchY, pixels, ref reactedColor, ref redPixelStart))

                {

                    IsCaptured = true;

                    RedBarX = (redPixelStart % stride) / 3;

                    RedBarY = redPixelStart / stride;

                    RecordedColor = reactedColor;

                    return true;

                }

                else

                {

                    firstRun = true;

                }

            }

            int startX;

            int endX;

            int startY;

            int endY;

            DesertPaintLab.AppSettings.Get("ScanOffsetX", out startX);

            DesertPaintLab.AppSettings.Get("ScanOffsetY", out startY);

            DesertPaintLab.AppSettings.Get("ScanLimitX", out endX);

            DesertPaintLab.AppSettings.Get("ScanLimitY", out endY);

            if (endX == 0) endX = screenshotWidth;

            if (endY == 0) endY = screenshotHeight;

            int patchTestSize = (swatchHeight / 2) - 1;

            PixelColor patchColor = new PixelColor();

            for (int roughX = startX; roughX < endX - colorBarWidth - patchTestSize; roughX += patchTestSize)

            {

                for (int roughY = startY; roughY < (endY - (blueBarSpacing + 10) - patchTestSize  /*53*/); roughY += patchTestSize)

                {

                    OnCaptureProgress?.Invoke(roughX, roughY);

                    if (!pixels.IsSolidPatchAt(roughX, roughY, patchTestSize, patchTestSize)) continue;

                    pixels.ColorAt(roughX, roughY, ref patchColor);

                    for (X = roughX - patchTestSize; X < roughX; ++X)

                    {

                        for (Y = roughY - patchTestSize; Y < roughY; ++Y)

                        {

                            if (TestPosition(X, Y, pixels, ref reactedColor, ref redPixelStart))

                            {

                                RedBarX = (redPixelStart % stride) / 3;

                                RedBarY = redPixelStart / stride;

                                RecordedColor = reactedColor;

                                lastSwatchX = X;

                                lastSwatchY = Y;

                                firstRun = false;

                                IsCaptured = true;

                                return true;

                            }

                        }

                    }

                }

            }

            return false;

        }

        public bool RecordReaction(PlayerProfile profile, PaintColor expectedColor, PaintColor reactedColor, Reagent[] reagents)

        {

            bool saved = false;

            int r, g, b;

            if (reagents[2] != null)

            {

                // A 3-reagent reaction.

                Reaction reaction1 = profile.FindReaction(reagents[0], reagents[1]);

                Reaction reaction2 = profile.FindReaction(reagents[0], reagents[2]);

                Reaction reaction3 = profile.FindReaction(reagents[1], reagents[2]);

                r = reactedColor.Red - expectedColor.Red;

                g = reactedColor.Green - expectedColor.Green;

                b = reactedColor.Blue - expectedColor.Blue;

                if (reaction2 == null)

                {

                    r = r - reaction1.Red - reaction3.Red;

                    g = g - reaction1.Green - reaction3.Green;

                    b = b - reaction1.Blue - reaction3.Blue;

                    Reaction reaction = new Reaction(r, g, b);

                    profile.SetReaction(reagents[0], reagents[2], reaction);

                    profile.Save();

                    saved = true;

                    OnReactionRecorded?.Invoke(reagents[0], reagents[2], reaction);

                }

                else if (reaction3 == null)

                {

                    r = r - reaction1.Red - reaction2.Red;

                    g = g - reaction1.Green - reaction2.Green;

                    b = b - reaction1.Blue - reaction2.Blue;

                    Reaction reaction = new Reaction(r, g, b);

                    profile.SetReaction(reagents[1], reagents[2], reaction);

                    profile.Save();

                    saved = true;

                    OnReactionRecorded?.Invoke(reagents[1], reagents[2], reaction);

                }

            }

            else if ((reagents[0] != null) && (reagents[1] != null))

            {

                // A 2-reagent reaction.

                r = reactedColor.Red - expectedColor.Red;

                g = reactedColor.Green - expectedColor.Green;

                b = reactedColor.Blue - expectedColor.Blue;

                Reaction reaction = new Reaction(r, g, b);

                profile.SetReaction(reagents[0], reagents[1], reaction);

                profile.Save();

                saved = true;

                OnReactionRecorded?.Invoke(reagents[0], reagents[1], reaction);

            }

            return saved;

        }

    }

}