コード例 #1
0
        public AreaViewWindow(int width, int height, Action <string> showMessageCallback) : base(Config.Instance.Get <int>("MapWidth"), Config.Instance.Get <int>("MapHeight"))
        {
            this.showMessageCallback    = showMessageCallback;
            this.TextSurface.RenderArea = new Rectangle(0, 0, width, height);

            var player       = new Player();
            var playerEntity = this.CreateGameObject("Player", player);

            this.CreateGameObject("StairsDown", '>', Color.White);

            SadConsole.Engine.ActiveConsole = this;
            // Keyboard setup
            SadConsole.Engine.Keyboard.RepeatDelay        = 0.07f;
            SadConsole.Engine.Keyboard.InitialRepeatDelay = 0.1f;

            this.GenerateAndDisplayMap();

            var currentFieldOfView = new RogueSharp.FieldOfView(this.currentMap.GetIMap());
            var fovTiles           = currentFieldOfView.ComputeFov(playerEntity.Position.X, playerEntity.Position.Y, Config.Instance.Get <int>("PlayerLightRadius"), true);

            this.MarkCurrentFovAsVisible(fovTiles);

            var creatures = this.objects.Where(s => s.Data is Monster || s.Data is Player).Select(e => e.Data as IHasAgility);

            this.turnCalculator = new TurnCalculator(creatures);
        }
コード例 #2
0
        public void TestExtraTurnForBlackBug()
        {
            var sut   = new TurnCalculator();
            var board = new MatrixBoard();
            {
                board.IsTurnOfBlackPlayer = true;

                board.TryConsumeNamedCellByWhitePlayer("E4");
                board.TryConsumeNamedCellByWhitePlayer("E5");

                board.TryConsumeNamedCellByBlackPlayer("C5");
                board.TryConsumeNamedCellByBlackPlayer("D5");
                board.TryConsumeNamedCellByBlackPlayer("D4");
                board.TryConsumeNamedCellByBlackPlayer("E6");
            }


            var result = sut.GetValidTurnsForBoard(board);

            Assert.IsNotNull(result);
            Assert.AreEqual(5, result.Count());

            string strTurnPositions      = BoardCoordinatesConverter.PrintTurnPositions(result);
            string expectedTurnPositions = "E3; F3; F4; F5; F6";

            Assert.AreEqual(expectedTurnPositions, strTurnPositions);
        }
コード例 #3
0
        public void Run_Turn_Calculation()
        {
            /// Initialise
            var log     = new EmptyLog();
            var locator = new InMemoryLocator();

            locator.AddResolver(typeof(IRepository <Stockpile>), () => new InMemoryRepository <Stockpile>());
            var bus = new InMemoryBus(locator, log);

            Bus.SetBus(bus);
            Bus.RegisterHandler <AddStockpileCommandHandler>();

            /// Start testing
            var calculator = new TurnCalculator();

            var map  = new Map(8, 8);
            var game = new Game(map.GetAggregateKey());

            var stockpileRepository = new InMemoryRepository <Stockpile>();

            Bus.Send(new AddStockpileCommand(game, Resource.Collection.Iron));
            Bus.Send(new AddStockpileCommand(game, Resource.Collection.Stone));
            Bus.Send(new AddStockpileCommand(game, Resource.Collection.Wood));

            calculator.Calculate(game);
        }
コード例 #4
0
        public void TestTurnsResultIsNullForEmptyBoard()
        {
            var board = new MatrixBoard();
            var sut   = new TurnCalculator();

            var turns = sut.GetValidTurnsForBoard(board);

            Assert.IsNull(turns);
        }
コード例 #5
0
        public void SetUp()
        {
            this._initialBoard = new MatrixBoard();
            {
                this._initialBoard.TryConsumeNamedCellByBlackPlayer("D4");
                this._initialBoard.TryConsumeNamedCellByBlackPlayer("E5");

                this._initialBoard.TryConsumeNamedCellByWhitePlayer("E4");
                this._initialBoard.TryConsumeNamedCellByWhitePlayer("D5");

                this._initialBoard.IsTurnOfBlackPlayer = true;
            }

            this._sut = new TurnCalculator();
        }
コード例 #6
0
        public void TestNoFlipsIfBoardEndReached()
        {
            var sut   = new TurnCalculator();
            var board = new MatrixBoard();
            {
                board.IsTurnOfBlackPlayer = false;
                board.TryConsumeNamedCellByBlackPlayer("A1");
                board.TryConsumeNamedCellByBlackPlayer("H1");
                board.TryConsumeNamedCellByBlackPlayer("A8");
                board.TryConsumeNamedCellByBlackPlayer("H8");
                board.TryConsumeNamedCellByBlackPlayer("A4");
                board.TryConsumeNamedCellByBlackPlayer("H4");
                board.TryConsumeNamedCellByBlackPlayer("D1");
                board.TryConsumeNamedCellByBlackPlayer("D8");


                // Diagonal
                board.TryConsumeNamedCellByBlackPlayer("B2");
                board.TryConsumeNamedCellByBlackPlayer("C3");
                board.TryConsumeNamedCellByBlackPlayer("E5");
                board.TryConsumeNamedCellByBlackPlayer("F6");
                board.TryConsumeNamedCellByBlackPlayer("G7");

                // Horizontal
                board.TryConsumeNamedCellByBlackPlayer("B4");
                board.TryConsumeNamedCellByBlackPlayer("C4");
                board.TryConsumeNamedCellByBlackPlayer("E4");
                board.TryConsumeNamedCellByBlackPlayer("F4");
                board.TryConsumeNamedCellByBlackPlayer("G4");

                // Vertical
                board.TryConsumeNamedCellByBlackPlayer("D2");
                board.TryConsumeNamedCellByBlackPlayer("D3");
                board.TryConsumeNamedCellByBlackPlayer("D5");
                board.TryConsumeNamedCellByBlackPlayer("D6");
                board.TryConsumeNamedCellByBlackPlayer("D7");
            }


            var result = sut.GetValidTurnsForBoard(board);

            Assert.IsNull(result);
        }
コード例 #7
0
        public void TestReverseDiagonalFlips()
        {
            var sut   = new TurnCalculator();
            var board = new MatrixBoard();
            {
                board.IsTurnOfBlackPlayer = false;

                board.TryConsumeNamedCellByWhitePlayer("A8");
                board.TryConsumeNamedCellByWhitePlayer("H1");

                board.TryConsumeNamedCellByBlackPlayer("B7");
                board.TryConsumeNamedCellByBlackPlayer("C6");
                board.TryConsumeNamedCellByBlackPlayer("D5");
                board.TryConsumeNamedCellByBlackPlayer("E4");
                board.TryConsumeNamedCellByBlackPlayer("G2");
            }

            var result = sut.GetValidTurnsForBoard(board);

            Assert.IsNotNull(result);
            Assert.AreEqual(1, result.Count());

            IReversiTurn turn        = result.First();
            string       strPosition = BoardCoordinatesConverter.CoordinatesToCellName(turn.Position);

            Assert.AreEqual("F3", strPosition);

            Assert.AreEqual(5, turn.PositionsOfFlippedItems.Count());

            var sortedFlips =
                turn.PositionsOfFlippedItems.OrderBy(c =>
            {
                return(BoardCoordinatesConverter.CoordinatesToCellName(c));
            });
            string strSortedFlips = BoardCoordinatesConverter.PrintCoordinates(sortedFlips);
            string expectedFlips  = "B7; C6; D5; E4; G2";

            Assert.AreEqual(expectedFlips, strSortedFlips);
        }
コード例 #8
0
        public void TurnCalculatorReturnsTurnsFairly()
        {
            var player  = new Creature(7, "Player");
            var monster = new Creature(5, "Monster");

            // Manually worked this out
            var expected = new Creature[] { player, monster, player, monster, player, player, monster };

            var actual         = new List <Creature>();
            var turnCalculator = new TurnCalculator(new Creature[] { player, monster });

            while (actual.Count < expected.Length)
            {
                actual.Add(turnCalculator.NextTurn() as Creature);
            }

            for (int i = 0; i < expected.Length; i++)
            {
                var e = expected[i];
                var a = actual[i];
                Assert.That(a, Is.EqualTo(e), $"On turn {i + 1}, expected {e.Name} but got {a.Name}");
            }
        }
コード例 #9
0
 public void TearDown()
 {
     this._initialBoard = null;
     this._sut          = null;
 }
コード例 #10
0
        public void TestMultipleDirections()
        {
            var sut   = new TurnCalculator();
            var board = new MatrixBoard();
            {
                board.IsTurnOfBlackPlayer = false;
                board.TryConsumeNamedCellByWhitePlayer("A1");
                board.TryConsumeNamedCellByWhitePlayer("H1");
                board.TryConsumeNamedCellByWhitePlayer("A8");
                board.TryConsumeNamedCellByWhitePlayer("H8");
                board.TryConsumeNamedCellByWhitePlayer("A4");
                board.TryConsumeNamedCellByWhitePlayer("H4");
                board.TryConsumeNamedCellByWhitePlayer("D1");
                board.TryConsumeNamedCellByWhitePlayer("D8");


                // Diagonal
                board.TryConsumeNamedCellByBlackPlayer("B2");
                board.TryConsumeNamedCellByBlackPlayer("C3");
                board.TryConsumeNamedCellByBlackPlayer("E5");
                board.TryConsumeNamedCellByBlackPlayer("F6");
                board.TryConsumeNamedCellByBlackPlayer("G7");

                // Horizontal
                board.TryConsumeNamedCellByBlackPlayer("B4");
                board.TryConsumeNamedCellByBlackPlayer("C4");
                board.TryConsumeNamedCellByBlackPlayer("E4");
                board.TryConsumeNamedCellByBlackPlayer("F4");
                board.TryConsumeNamedCellByBlackPlayer("G4");

                // Vertical
                board.TryConsumeNamedCellByBlackPlayer("D2");
                board.TryConsumeNamedCellByBlackPlayer("D3");
                board.TryConsumeNamedCellByBlackPlayer("D5");
                board.TryConsumeNamedCellByBlackPlayer("D6");
                board.TryConsumeNamedCellByBlackPlayer("D7");
            }


            var result = sut.GetValidTurnsForBoard(board);

            Assert.IsNotNull(result);
            Assert.AreEqual(1, result.Count());

            IReversiTurn turn        = result.First();
            string       strPosition = BoardCoordinatesConverter.CoordinatesToCellName(turn.Position);

            Assert.AreEqual("D4", strPosition);

            Assert.AreEqual(15, turn.PositionsOfFlippedItems.Count());

            var sortedFlips =
                turn.PositionsOfFlippedItems.OrderBy(c =>
            {
                return(BoardCoordinatesConverter.CoordinatesToCellName(c));
            });
            string strSortedFlips = BoardCoordinatesConverter.PrintCoordinates(sortedFlips);
            string expectedFlips  = "B2; B4; C3; C4; D2; D3; D5; D6; D7; E4; E5; F4; F6; G4; G7";

            Assert.AreEqual(expectedFlips, strSortedFlips);
        }