Added terminal sample.

Author: RUBIUS\chebanovdd

.idea/.idea.Match3/.idea/.name

@@ -0,0 +1,63 @@
+using Match3.App;
+using Match3.App.Interfaces;
+using Match3.Template;
+using Match3.Template.Interfaces;
+using Match3.Template.SequenceDetectors;
+using Microsoft.Extensions.DependencyInjection;
+using Terminal.Match3.FillStrategies;
+using Terminal.Match3.Interfaces;
+using Terminal.Match3.TileGroupDetectors;
+
+namespace Terminal.Match3
+{
+    public static class DependencyInjection
+    {
+        public static void AddInfrastructure(this IServiceCollection services)
+        {
+            var gameBoardRenderer = new TerminalGameBoardRenderer();
+            services.AddSingleton<IGameBoardRenderer>(gameBoardRenderer);
+            services.AddSingleton<ITerminalGameBoardRenderer>(gameBoardRenderer);
+
+            var gameConfig = GetGameConfig(gameBoardRenderer);
+            services.AddSingleton<GameConfig<ITerminalGridSlot>>(gameConfig);
+
+            var itemGenerator = new TerminalItemGenerator();
+            services.AddSingleton<IItemGenerator>(itemGenerator);
+            services.AddSingleton<IItemsPool<ITerminalItem>>(itemGenerator);
+
+            services.AddSingleton<TerminalGame>();
+            services.AddSingleton<ITerminalInputSystem, TerminalInputSystem>();
+            services.AddSingleton<IBoardFillStrategy<ITerminalGridSlot>, SimpleFillStrategy>();
+        }
+
+        private static GameConfig<ITerminalGridSlot> GetGameConfig(TerminalGameBoardRenderer gameBoardRenderer)
+        {
+            return new GameConfig<ITerminalGridSlot>
+            {
+                GameBoardDataProvider = gameBoardRenderer,
+                LevelGoalsProvider = new LevelGoalsProvider(),
+                ItemSwapper = new TerminalItemSwapper(gameBoardRenderer),
+                GameBoardSolver = GetGameBoardSolver(),
+                SolvedSequencesConsumers = GetSolvedSequencesConsumers(gameBoardRenderer)
+            };
+        }
+
+        private static IGameBoardSolver<ITerminalGridSlot> GetGameBoardSolver()
+        {
+            return new GameBoardSolver<ITerminalGridSlot>(new ISequenceDetector<ITerminalGridSlot>[]
+            {
+                new VerticalLineDetector<ITerminalGridSlot>(),
+                new HorizontalLineDetector<ITerminalGridSlot>()
+            });
+        }
+
+        private static ISolvedSequencesConsumer<ITerminalGridSlot>[] GetSolvedSequencesConsumers(
+            ITerminalGameBoardRenderer gameBoardRenderer)
+        {
+            return new ISolvedSequencesConsumer<ITerminalGridSlot>[]
+            {
+                new TileGroupDetector(gameBoardRenderer)
+            };
+        }
+    }
+}

.idea/.idea.Match3/.idea/vcs.xml

@@ -0,0 +1,9 @@
+namespace Terminal.Match3.Enums
+{
+    public enum TileGroup
+    {
+        Unavailable = 0,
+        Available = 1,
+        Locked = 2
+    }
+}

samples/Terminal.Match3/DependencyInjection.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using Match3.Template.Extensions;
+using Match3.Template.Interfaces;
+
+namespace Terminal.Match3.Extensions
+{
+    public static class AppModeExtensions
+    {
+        public static TaskAwaiter GetAwaiter(this IGameMode gameMode)
+        {
+            var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            void OnFinished(object sender, EventArgs eventArgs)
+            {
+                gameMode.Finished -= OnFinished;
+                gameMode.Deactivate();
+
+                tcs.SetResult();
+            }
+
+            gameMode.Finished += OnFinished;
+            gameMode.Activate();
+
+            return tcs.Task.GetAwaiter();
+        }
+    }
+}

samples/Terminal.Match3/Enums/TileGroup.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Text;
+using Microsoft.Extensions.Hosting;
+
+namespace Terminal.Match3.Extensions
+{
+    public static class ConsoleOptionsExtensions
+    {
+        public static void SetCursorVisible(this ConsoleLifetimeOptions _, bool isVisible)
+        {
+            Console.CursorVisible = isVisible;
+        }
+
+        public static void SetOutputEncoding(this ConsoleLifetimeOptions _, Encoding encoding)
+        {
+            Console.OutputEncoding = encoding;
+        }
+
+        public static void SuppressStatusMessages(this ConsoleLifetimeOptions options)
+        {
+            options.SuppressStatusMessages = true;
+        }
+    }
+}

samples/Terminal.Match3/Extensions/AppModeExtensions.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using Match3.App;
+using Match3.Core.Interfaces;
+
+namespace Terminal.Match3.Extensions
+{
+    public static class ItemsSequenceExtensions
+    {
+        public static IEnumerable<TGridSlot> GetUniqueGridSlots<TGridSlot>(
+            this IEnumerable<ItemSequence<TGridSlot>> sequences, bool onlyMovable = false) where TGridSlot : IGridSlot
+        {
+            var solvedGridSlots = new HashSet<TGridSlot>();
+
+            foreach (var sequence in sequences)
+            {
+                foreach (var solvedGridSlot in sequence.SolvedGridSlots)
+                {
+                    if (onlyMovable && solvedGridSlot.IsMovable == false)
+                    {
+                        continue;
+                    }
+
+                    if (solvedGridSlots.Add(solvedGridSlot) == false)
+                    {
+                        continue;
+                    }
+
+                    yield return solvedGridSlot;
+                }
+            }
+
+            solvedGridSlots.Clear();
+        }
+    }
+}

samples/Terminal.Match3/Extensions/ConsoleOptionsExtensions.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Cysharp.Threading.Tasks;
+using Match3.App;
+using Terminal.Match3.Interfaces;
+
+namespace Terminal.Match3.FillStrategies.Jobs
+{
+    public class ItemsShowJob : Job
+    {
+        private const char Stage1 = '✵';
+        private const char Stage2 = '❄';
+        private const int StagesDelay = 150;
+        private const ConsoleColor StageColor = ConsoleColor.DarkGray;
+
+        private readonly char[] _icons;
+        private readonly ConsoleColor[] _colors;
+        private readonly IReadOnlyList<ITerminalItem> _items;
+        private readonly ITerminalGameBoardRenderer _terminalGameBoardRenderer;
+
+        public ItemsShowJob(ITerminalGameBoardRenderer terminalGameBoardRenderer,
+            IReadOnlyList<ITerminalItem> items) : base(0)
+        {
+            _terminalGameBoardRenderer = terminalGameBoardRenderer;
+
+            _items = items;
+            _icons = new char[items.Count];
+            _colors = new ConsoleColor[items.Count];
+        }
+
+        public override async UniTask ExecuteAsync(CancellationToken cancellationToken = default)
+        {
+            StoreData();
+
+            await SetIcon(Stage1, StageColor, cancellationToken);
+            await SetIcon(Stage2, StageColor, cancellationToken);
+
+            RestoreData();
+            RedrawGameBoard();
+        }
+
+        private void StoreData()
+        {
+            for (var i = 0; i < _items.Count; i++)
+            {
+                _icons[i] = _items[i].Icon;
+                _colors[i] = _items[i].Color;
+            }
+        }
+
+        private async UniTask SetIcon(char icon, ConsoleColor color, CancellationToken cancellationToken = default)
+        {
+            foreach (var item in _items)
+            {
+                item.Icon = icon;
+                item.Color = color;
+            }
+
+            RedrawGameBoard();
+            await Task.Delay(StagesDelay, cancellationToken);
+        }
+
+        private void RestoreData()
+        {
+            for (var i = 0; i < _items.Count; i++)
+            {
+                _items[i].Icon = _icons[i];
+                _items[i].Color = _colors[i];
+            }
+        }
+
+        private void RedrawGameBoard()
+        {
+            _terminalGameBoardRenderer.RedrawGameBoard();
+        }
+    }
+}

samples/Terminal.Match3/Extensions/ItemsSequenceExtensions.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using Match3.App;
+using Match3.App.Interfaces;
+using Match3.Template.Interfaces;
+using Terminal.Match3.FillStrategies.Jobs;
+using Terminal.Match3.Interfaces;
+using Terminal.Match3.Extensions;
+
+namespace Terminal.Match3.FillStrategies
+{
+    public class SimpleFillStrategy : IBoardFillStrategy<ITerminalGridSlot>
+    {
+        private readonly TerminalItem _notAvailableItem;
+        private readonly IItemsPool<ITerminalItem> _itemsPool;
+        private readonly ITerminalGameBoardRenderer _gameBoardRenderer;
+
+        public SimpleFillStrategy(ITerminalGameBoardRenderer terminalGameBoardRenderer,
+            IItemsPool<ITerminalItem> itemsPool)
+        {
+            _itemsPool = itemsPool;
+            _notAvailableItem = new TerminalItem(' ', ConsoleColor.DarkGray);
+            _gameBoardRenderer = terminalGameBoardRenderer;
+        }
+
+        public string Name => "Simple Fill Strategy";
+
+        public IEnumerable<IJob> GetFillJobs(IGameBoard<ITerminalGridSlot> gameBoard)
+        {
+            var itemsToShow = new List<ITerminalItem>();
+
+            for (var rowIndex = 0; rowIndex < gameBoard.RowCount; rowIndex++)
+            {
+                for (var columnIndex = 0; columnIndex < gameBoard.ColumnCount; columnIndex++)
+                {
+                    var gridSlot = gameBoard[rowIndex, columnIndex];
+                    ITerminalItem item;
+
+                    if (gridSlot.CanSetItem)
+                    {
+                        item = _itemsPool.GetItem();
+                        itemsToShow.Add(item);
+                    }
+                    else
+                    {
+                        item = _notAvailableItem;
+                    }
+
+                    gridSlot.SetItem(item);
+                }
+            }
+
+            return new[] { new ItemsShowJob(_gameBoardRenderer, itemsToShow) };
+        }
+
+        public IEnumerable<IJob> GetSolveJobs(IGameBoard<ITerminalGridSlot> gameBoard,
+            IEnumerable<ItemSequence<ITerminalGridSlot>> sequences)
+        {
+            var itemsToShow = new List<ITerminalItem>();
+
+            foreach (var solvedGridSlot in sequences.GetUniqueGridSlots(true))
+            {
+                var newItem = _itemsPool.GetItem();
+                var currentItem = solvedGridSlot.Item;
+
+                solvedGridSlot.SetItem(newItem);
+                itemsToShow.Add(newItem);
+
+                _itemsPool.ReturnItem(currentItem);
+            }
+
+            return new Job[]
+            {
+                new ItemsShowJob(_gameBoardRenderer, itemsToShow)
+            };
+        }
+    }
+}