Beispiel #1
0
        void huStep(object sender, EventArgs e)
        {
            Grid.GridCell cell = (Grid.GridCell)sender;

            if (!gameBoard[cell.i, cell.j].isFree())
            {
                return;
            }

            if (gameMode == GameMode.career || gameMode == GameMode.certainLevel)
            {
                lastHuMove = new Move(cell.i, cell.j);
                gameBoard.SetStep(cell.i, cell.j, huPlayer);
                ai.RemoveMove(cell.i, cell.j);

                grid[lastAIMove.i, lastAIMove.j].button.BackColor = Color.Transparent;

                cancelMoveMenuItem.Enabled = canceledMoves < Settings.Default.maxCancelMoves;
            }
            else
            {
                gameBoard.SetStep(cell.i, cell.j, player);
            }

            Game(gameMode);
        }
Beispiel #2
0
        void InitGame(GameMode mode)
        {
            gameBoard = new Board(Settings.Default.BoardHeight, Settings.Default.BoardWidth, player1, player2);
            grid.Reset();

            resetProgressMenuItem.Visible = (mode == GameMode.career);
            cancelMoveMenuItem.Visible    = (mode == GameMode.career || mode == GameMode.certainLevel);
            cancelMoveMenuItem.Enabled    = false;
            progressLabel.Visible         = (mode == GameMode.career);
            levelLabel.Visible            = (mode == GameMode.career || mode == GameMode.certainLevel);
            complexityLabel.Visible       = (mode == GameMode.career || mode == GameMode.certainLevel);
            winsPerLevelLabel.Visible     = (mode == GameMode.career);
            lossPerLevelLabel.Visible     = (mode == GameMode.career);

            selectLevelBox.SelectedIndexChanged -= selectLevelBox_SelectedIndexChanged;
            selectLevelBox.SelectedIndex         = Settings.Default.lastSelectedLevel - 1;
            selectLevelBox.SelectedIndexChanged += selectLevelBox_SelectedIndexChanged;

            careerModeMenuItem.Enabled         = mode != GameMode.career;
            certainLevelModeMenuItem.Enabled   = mode != GameMode.certainLevel;
            friendToFriendModeMenuItem.Enabled = mode != GameMode.friendWithFriend;

            if (mode == GameMode.career || mode == GameMode.certainLevel)
            {
                ai = new GomokuAI(Settings.Default.BoardHeight, Settings.Default.BoardWidth, isUserFirst);

                huPlayer = isUserFirst ? player1 : player2;
                aiPlayer = isUserFirst ? player2 : player1;

                if (!isUserFirst)
                {
                    gameBoard.SetStep(Settings.Default.BoardHeight / 2, Settings.Default.BoardWidth / 2, aiPlayer);
                }

                if (mode == GameMode.career)
                {
                    complexity = minComplexity + (Settings.Default.level - 1) * complexityStep;
                }
                else
                {
                    level      = Settings.Default.lastSelectedLevel;
                    complexity = minComplexity + (level - 1) * complexityStep;
                }
                playerPicture.Image = huPlayer.image;
            }
            else
            {
                player = isUserFirst ? player1 : player2;

                playerPicture.Image = player.image;
            }

            isUserFirst = !isUserFirst;

            showInfo(mode);

            gameBoard.Draw(grid);
        }
Beispiel #3
0
        public Move MakeMove(ref Board board, Player player, Player huPlayer, Player aiPlayer, double probably)
        {
            CalcWeights(board, huPlayer, aiPlayer, probably);

            int index = 0;

            for (int i = 1; i < availableMoves.Count; i++)
            {
                if (availableMoves[i].importance > availableMoves[index].importance)
                {
                    index = i;
                }
            }

            Move move;

            if (availableMoves[index].importance == 0)
            {
                move = availableMoves[rnd.Next(availableMoves.Count)];
            }
            else
            {
                int importance = availableMoves[index].importance;

                List <Move> maxImportantMoves = new List <Move>();

                for (int i = 0; i < availableMoves.Count; i++)
                {
                    if (availableMoves[i].importance == importance)
                    {
                        maxImportantMoves.Add(availableMoves[i]);
                    }
                }

                move = maxImportantMoves[rnd.Next(maxImportantMoves.Count)];
            }

            RemoveMove(move.i, move.j);

            board.SetStep(move.i, move.j, player);

            return(move);
        }