Пример #1
0
        public value GenerateMove( opponent op, ref int bestRow, ref int bestColumn, value alpha, value beta)
        {
            value state, results;
                slotState owner;
                opponent opposite;
                int notNeeded=0;

              //  ttt_count++;
                // See if we have a win
                if ((state = evaluate()) != value.unclear ) {
                  //  depth++;
                    return state;
                }

                // Get the opposite player for the recursive call
                if (op == opponent.X) {
                    owner = slotState.ownedByX ;  opposite = opponent.O; state = alpha;
                }
                else {
                    owner = slotState.ownedByO; opposite = opponent.X; state = beta;
                }

                int x, y;

                for (x=0; x < NumOfRows;x++) {
                    for (y=0; y < NumOfCols; y++) {
                        if (gameBoardSlots[x,y] == slotState.ownedByNull) {
                            SetBoardPositionToOwner(x, y, owner);
                            results = GenerateMove(opposite, ref notNeeded, ref notNeeded, alpha, beta);
                            SetBoardPositionToOwner(x, y, slotState.ownedByNull);

                            if ((op == opponent.X && results > state)||
                                (op == opponent.O && results < state)) {

                                if (op == opponent.X) {
                                    alpha = state = results;
                                }
                                else {
                                    beta = state = results;
                                }

                                bestRow = x; bestColumn = y;

                                if (alpha >= beta) {
                                    return state;
                                }
                            }
                        }
                    }
                }

                return state;
        }
Пример #2
0
        value evaluateHelper(opponent p)
        {
            int x, y;
                int threeInARow, threeInACol;
                slotState s;

                if (p == opponent.X)
                    s = slotState.ownedByX;
                else
                    s = slotState.ownedByO;

                // See if there is a win in the rows
                for (x = 0; x < NumOfRows; x++) {
                    threeInARow = 0; threeInACol = 0;
                    for (y = 0; y < NumOfCols; y++) {

                        if (gameBoardSlots[x, y] == s) {
                            ++threeInARow;
                        }

                        if (gameBoardSlots[y, x] == s) {
                            ++threeInACol;
                        }
                    }

                    // Do we have a winner?
                    if (threeInARow == NumOfRows || threeInACol == NumOfCols) {
                        return value.winner;
                    }
                }

                // Now check the diagonals
                // (0,0, 1,1, 2,2) or (0,2 1,1 2,0)
                if (gameBoardSlots[1,1] == s) {
                    if ((gameBoardSlots[0,0] == s && gameBoardSlots[2,2] == s) ||
                        (gameBoardSlots[0,2] == s && gameBoardSlots[2,0] == s)) {
                        return value.winner;
                    }
                }

                return value.unclear;
        }
        override public void MyTurn()
        {
            turnCount++;
            int[] playerList = banker.getPlayerList(this);
            int   myMoney    = banker.balanceInquiry(this);
            //if (banker.inJail(this) && turnCount > STAY_IN_JAIL)
            //{
            //    bail = true;
            //}

            List <opponent> opponents = new List <opponent>();

            foreach (int p in playerList)
            {
                opponent t = new opponent();
                t.tilesOwned = banker.getPlayerPropertyInfo(p);
                t.funds      = banker.playerMoneyLookup(p);

                opponents.Add(t);
            }

            List <Game_Tile_Safe> myProperties = banker.getPropertiesOwned(this);
            int assetsAtThisTile = banker.checkCurrentTilesAssets(this);
            int position         = banker.getCurrentTile(this).index;
            int assetPrices      = banker.getCurrentTile(this).assetPrice;

            //try to mortgage first if money is below the reserve threshold

            if (myMoney < MORTGAGE_RESERVE)
            {
                int[] preferredMortgage = PropertyHelper.prefferedMortgage();
                if (preferredMortgage.Length > 0)
                {
                    banker.mortgageProperty(this, preferredMortgage[0]);
                    PropertyHelper.mortgage(preferredMortgage[0]);
                    myMoney = banker.balanceInquiry(this);
                    //Console.WriteLine(myMoney);
                }
            }
            else //unmortgage a property if we're above the threshold
            {
                int[] mortgagedProperties = PropertyHelper.mortgagedProperties();
                for (int i = 0; i < mortgagedProperties.Length; i++)
                {
                    int index   = mortgagedProperties[i];
                    int UMPrice = banker.getPropertyInfo(index).price + (int)((double)banker.getPropertyInfo(index).price * 0.1);
                    if (myMoney + MORTGAGE_RESERVE > UMPrice)
                    {
                        banker.unmortageProperty(this, index);
                        PropertyHelper.unMortgage(index);
                        myMoney = banker.balanceInquiry(this);
                    }
                }
            }

            //then try to buy

            if (banker.canBuy(this) && myMoney > BUY_RESERVE)
            {
                banker.buyProperty(this);
                PropertyHelper.buyProperty(position);
                myMoney = banker.balanceInquiry(this);
            }

            //then attempt to develop if we have monopoly(s)

            int[] canDevelop = PropertyHelper.canDevelop();
            foreach (int p in canDevelop)
            {
                int pos   = p;
                int price = banker.getPropertyInfo(p).assetPrice;
                if ((myMoney + ASSET_RESERVE) > price)
                {
                    if (PropertyHelper.buyAsset(pos, 1))
                    {
                    }

                    else
                    {
                        continue;
                    }

                    if (banker.buyAssets(this, banker.getPropertyInfo(pos)))
                    {  /*Console.WriteLine(banker.getPropertyInfo(pos).name);*/
                    }
                }
            }
        }