コード例 #1
0
        public Tuple <int, int> ChooseWhichStone(bool blackIsPlaying, Board.PlaceOnBoardIs[,] board)
        {
            int counter = 0;

            Tuple <int, int, int, int>[] almostMill = AlmostMill(blackIsPlaying, board);
            Tuple <int, int>             tupleOfIndexes;
            short index;

            for (int i = 0; i < 60; i++)
            {
                if (almostMill[i] == null)
                {
                    break;
                }
                else
                {
                    counter++;
                }
            }

            if (counter > 0)
            {
                int num = random.Next(0, counter - 1);
                index = (short)random.Next(0, 1);
                if (index == 0)
                {
                    return(tupleOfIndexes = new Tuple <int, int>(almostMill[num].Item1, almostMill[num].Item2));
                }
                else
                {
                    return(tupleOfIndexes = new Tuple <int, int>(almostMill[num].Item3, almostMill[num].Item4));
                }
            }
            else
            {
                while (true)
                {
                    index          = (short)random.Next(0, 23);
                    tupleOfIndexes = Linking.GetIndexesOnBoard(index);
                    if (!blackIsPlaying)
                    {
                        if (board[tupleOfIndexes.Item1, tupleOfIndexes.Item2] == Board.PlaceOnBoardIs.blackOccupied)
                        {
                            return(tupleOfIndexes);
                        }
                    }
                    else
                    {
                        if (board[tupleOfIndexes.Item1, tupleOfIndexes.Item2] == Board.PlaceOnBoardIs.whiteOccupied)
                        {
                            return(tupleOfIndexes);
                        }
                    }
                }
            }
        }
コード例 #2
0
        private Tuple <int, int, int, int>[] AlmostMill(bool blackIsPlaying, Board.PlaceOnBoardIs[,] board)
        {
            Tuple <int, int, int, int>[] almostMill        = new Tuple <int, int, int, int> [60];
            Tuple <int, int>[]           OccupiedPositions = new Tuple <int, int> [4];
            Tuple <int, int>             tupleOfIndexes;
            int helper = 0;

            if (blackIsPlaying)
            {
                for (short i = 0; i < 24; i++)
                {
                    tupleOfIndexes = Linking.GetIndexesOnBoard(i);
                    if (board[tupleOfIndexes.Item1, tupleOfIndexes.Item2] == Board.PlaceOnBoardIs.whiteOccupied)
                    {
                        OccupiedPositions = GetOccupiedPositions(tupleOfIndexes.Item1, tupleOfIndexes.Item2,
                                                                 Board.PlaceOnBoardIs.whiteOccupied, board);
                        for (int j = 0; j < 4; j++)
                        {
                            if (OccupiedPositions[j].Item1 != -1)
                            {
                                almostMill[helper] = new Tuple <int, int, int, int>(tupleOfIndexes.Item1, tupleOfIndexes.Item2,
                                                                                    OccupiedPositions[j].Item1, OccupiedPositions[j].Item2);
                                helper++;
                            }
                        }
                    }
                }
            }
            else
            {
                for (short i = 0; i < 24; i++)
                {
                    tupleOfIndexes = Linking.GetIndexesOnBoard(i);
                    if (board[tupleOfIndexes.Item1, tupleOfIndexes.Item2] == Board.PlaceOnBoardIs.blackOccupied)
                    {
                        OccupiedPositions = GetOccupiedPositions(tupleOfIndexes.Item1, tupleOfIndexes.Item2,
                                                                 Board.PlaceOnBoardIs.blackOccupied, board);
                        for (int j = 0; j < 4; j++)
                        {
                            if (OccupiedPositions[j].Item1 != -1)
                            {
                                almostMill[helper] = new Tuple <int, int, int, int>(tupleOfIndexes.Item1, tupleOfIndexes.Item2,
                                                                                    OccupiedPositions[j].Item1, OccupiedPositions[j].Item2);
                                helper++;
                            }
                        }
                    }
                }
            }
            return(almostMill);
        }