Esempio n. 1
0
        private ITile createBoard(PrizeLevels prizes)
        {
            BoardGeneration bg = new BoardGeneration();
            int boardSize = 26;
            int initialReachable = 18;

            return bg.GenerateBoard(boardSize, initialReachable, 1, 6, 3, 2, prizes, 1, 2);
        }
Esempio n. 2
0
        public void personalGenBoardTest()
        {
            BoardGeneration bg = new BoardGeneration();
            int boardSize = 26;
            int initialReachable = 20;
            PrizeLevels prizes = new PrizeLevels();
            PrizeLevel A1 = new PrizeLevel();
            A1.numCollections = 3;
            A1.prizeLevel = 1;
            A1.isBonusGame = true;
            prizes.addPrizeLevel(A1);

            PrizeLevel A2 = new PrizeLevel();
            A2.numCollections = 3;
            A2.prizeLevel = 2;
            prizes.addPrizeLevel(A2);

            PrizeLevel A3 = new PrizeLevel();
            A3.numCollections = 3;
            A3.prizeLevel = 3;
            A3.isInstantWin = true;
            prizes.addPrizeLevel(A3);

            PrizeLevel A4 = new PrizeLevel();
            A4.numCollections = 3;
            A4.prizeLevel = 4;
            prizes.addPrizeLevel(A4);

            int numberOfExpectedCollection = 12;
            int numberOfExpectedMoveBack = 3;
            int numberOfExpectedMoveForward = 2;
            ITile firstTile = bg.GenerateBoard(boardSize, initialReachable, 2, 6, numberOfExpectedMoveBack, numberOfExpectedMoveForward, prizes, 1, 2);

            int numberOfCollection = 0;
            int numberOfMoveBack = 0;
            int numberOfMoveForward = 0;
            int numberOfextraGames = 0;
            int numberOfTiles = 0;
            ITile currentTile = firstTile;
            while (currentTile != null)
            {
                if (currentTile.Type == TileTypes.collection)
                {
                    numberOfCollection++;
                }
                else if (currentTile.Type == TileTypes.moveForward)
                {
                    numberOfMoveForward++;
                }
                else if (currentTile.Type == TileTypes.moveBack)
                {
                    numberOfMoveBack++;
                }
                else if (currentTile.Type == TileTypes.extraGame)
                {
                    numberOfextraGames++;
                }
                numberOfTiles++;
                currentTile = currentTile.Child;
            }
            string board = bg.ToString();
            Assert.IsTrue(numberOfCollection == numberOfExpectedCollection, "Number Of Collection Tiles not correct");
            Assert.IsTrue(numberOfMoveBack == numberOfExpectedMoveBack, "Number Of MoveBack Tiles not correct");
            Assert.IsTrue(numberOfMoveForward == numberOfExpectedMoveForward, "Number Of MoveForward Tiles not correct");
            Assert.IsTrue(boardSize == numberOfTiles, "Number Of Tiles not correct");
            if (board == "")
            {

            }
        }
        /// <summary>
        /// The thread to run to create the board file.
        /// </summary>
        private void ProcessThread(DoWorkEventArgs e)
        {
            //open save dialog
            string filename = OpenSaveWindow();

            if ( !string.IsNullOrEmpty( filename ))
            {
                _processCanceled = false;

                int minMove = 0;
                int maxMove = 0;
                if (MainWindowModel.Instance.GameSetupModel.DiceSelected)
                {
                    minMove = MainWindowModel.Instance.GameSetupModel.NumDice;
                    maxMove = MainWindowModel.Instance.GameSetupModel.NumDice * 6;
                }
                else
                {
                    minMove = 1;
                    maxMove = MainWindowModel.Instance.GameSetupModel.SpinnerMaxValue;
                }

                Collection_Game_Tool.Services.Tiles.ITile boardFirstTile =
                    new BoardGeneration(e).GenerateBoard(
                        MainWindowModel.Instance.GameSetupModel.BoardSize,
                        MainWindowModel.Instance.GameSetupModel.InitialReachableSpaces,
                        minMove,
                        maxMove,
                        MainWindowModel.Instance.GameSetupModel.NumMoveBackwardTiles,
                        MainWindowModel.Instance.GameSetupModel.NumMoveForwardTiles,
                        MainWindowModel.Instance.PrizeLevelsModel,
                        MainWindowModel.Instance.GameSetupModel.MoveForwardLength,
                        MainWindowModel.Instance.GameSetupModel.MoveBackwardLength
                    );
                if (e != null && e.Cancel) return;

                List<Collection_Game_Tool.Services.Tiles.ITile> boards = new List<Collection_Game_Tool.Services.Tiles.ITile>();
                boards.Add(boardFirstTile);
                if (e != null && e.Cancel) return;

                GamePlayGeneration generator = new GamePlayGeneration(boards);

                StringBuilder formattedPlays = new StringBuilder();
                foreach (Collection_Game_Tool.Services.Tiles.ITile board in boards)
                {
                    if (e != null && e.Cancel) return;
                    formattedPlays.Append(generator.GetFormattedGameplay(boards));
                }

                if (e != null && e.Cancel) return;
                // write to file
                File.WriteAllText(filename, formattedPlays.ToString());
            }
            else
            {
                _processCanceled = true;
            }
        }