public void FallActionsFallPiece2x2()
        {
            var board = builder.FromTypeGrid(new int[, ] {
                { 0, 1, 2, 0 },
                { 1, 0, 0, 2 },
                { 1, 1, 1, 2 },
                { 0, 1, 1, 2 }
            });
            var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));

            var moves = new PotentialMove[] {
                new PotentialMove(c10, Orientation.Top),
                new PotentialMove(c01, Orientation.Right),
                new PotentialMove(c21, Orientation.Left),
            };

            foreach (var move in moves)
            {
                var simulator = MoveSimulator.FromPotentialMove(board, move, game.NextPieceIfPlaying(move));
                simulator.Simulate();
                Assert.IsTrue(simulator.IsMovePossible());
                var actions     = simulator.GetMove().consequences;
                var fallActions = actions.Where(IsFallAction);
                foreach (var action in fallActions)
                {
                    Assert.AreEqual(2, (action as FallAction).rows);
                }
            }
        }
        public void NewPieceHasExpectedCoords()
        {
            var board = builder.FromTypeGrid(new int[, ] {
                { 0, 1, 2, 0 },
                { 1, 0, 0, 2 },
                { 1, 1, 1, 2 },
                { 0, 1, 1, 2 }
            });
            var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));

            var moves = new PlayLogic(board).AvailableMoves();

            foreach (var move in moves)
            {
                var simulator = MoveSimulator.FromPotentialMove(board, move, game.NextPieceIfPlaying(move));
                simulator.Simulate();
                var coord          = simulator.moveCoord;
                var piece          = simulator.oldPiece;
                var actions        = simulator.GetMove().consequences;
                var newPieceAction = actions.First(IsNewPieceAction) as NewPieceAction;
                Assert.AreEqual(new Coord {
                    col = coord.col, row = board.Size - piece.size
                }, newPieceAction.coord);
            }
        }
        public void CanPlayDoublePieceFromPotentialMove()
        {
            var board = builder.FromTypeGrid("0101 1101 1100 1110");

            foreach (var coord in Coord.SquareRange(c00, 2))
            {
                var simulator = MoveSimulator.FromPotentialMove(board, new PotentialMove(coord, board.Orientation), piece_t0_s2);
                simulator.Simulate();
                Assert.Pass();
            }
        }
        public void CanSimulateRotatedMove()
        {
            var board = builder.FromTypeGrid(new int[, ] {
                { 0, 1, 2, 0 },
                { 1, 0, 0, 2 },
                { 1, 1, 1, 2 },
                { 0, 1, 1, 2 }
            });
            var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));

            var move      = new PotentialMove(c03, Orientation.Right);
            var simulator = MoveSimulator.FromPotentialMove(board, move, game.NextPieceIfPlaying(move));

            simulator.Simulate();
            Assert.IsTrue(simulator.IsMovePossible());
        }
        public void CanAlwaysSimulateAvailableMovesRnd()
        {
            for (int i = 0; i < 10; i++)
            {
                var board = generator.GenerateRandom(8, 3);
                var game  = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));

                var logic = new PlayLogic(board);
                var moves = logic.AvailableMoves();
                foreach (var move in moves)
                {
                    var simulator = MoveSimulator.FromPotentialMove(board, move, game.NextPieceIfPlaying(move));
                    simulator.Simulate();
                    Assert.IsTrue(simulator.IsMovePossible());
                }
            }
        }
        public void NewPieceHasExpectedSize()
        {
            var board = builder.FromTypeGrid(new int[, ] {
                { 0, 1, 2, 0 },
                { 2, 1, 0, 2 },
                { 1, 2, 1, 1 },
                { 0, 1, 1, 1 }
            });

            var game  = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));
            var logic = new PlayLogic(board);

            foreach (var move in logic.AvailableMoves())
            {
                var simulator = MoveSimulator.FromPotentialMove(board, move, game.NextPieceIfPlaying(move));
                simulator.Simulate();
                var actions        = simulator.GetMove().consequences;
                var newPieceAction = actions.First(IsNewPieceAction) as NewPieceAction;
                Assert.AreEqual(simulator.oldPiece.size, newPieceAction.newPiece.size);
            }
        }
        public void FallActionsFallPieceSizeRnd()
        {
            for (int i = 0; i < 50; i++)
            {
                var board = generator.GenerateRandom(4, 3);
                var game  = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));

                var logic = new PlayLogic(board);
                foreach (var potentialMove in logic.AvailableMoves())
                {
                    var simulator = MoveSimulator.FromPotentialMove(board, potentialMove, game.NextPieceIfPlaying(potentialMove));
                    simulator.Simulate();
                    var move        = simulator.GetMove();
                    var fallActions = move.consequences.Where(IsFallAction);
                    foreach (var action in fallActions)
                    {
                        var orientatedCoord = board.TransportCoord(potentialMove.coord, potentialMove.orientation);
                        var removedPiece    = board.Get(orientatedCoord);
                        Assert.AreEqual(removedPiece.size, (action as FallAction).rows,
                                        "Fall Action:\n" + action + ",\nboard:\n" + board + "\nmove:\n" + potentialMove);
                    }
                }
            }
        }