Пример #1
0
        public int TestPairKind(Player playerTemp, int rnd)
        {
            int s = 0;
            // create temp hand
            Card[] tempHand = new Card[7];
            for (int c = 0; c < 7; c++)
            {
                if (c < 2)
                    tempHand[c] = playerTemp.playerHand[c];
                else
                    tempHand[c] = Dealer.dealerHand[c-2];
            }

            for (int x = 0; x < rnd + 4; x++)
            {
                for (int y = x + 1; y < rnd + 3; y++)
                {
                    if (tempHand[x].rank == tempHand[y].rank)
                    {
                        s++;
                    }
                }

            }

            return s;
        }
Пример #2
0
        // create the AI players
        public void CreateAIPlayers(int r)
        {
            // choose name for AI players
            for (int i = 0; i < 4; i++)
            {
                Player playerTemp = new Player(" ");
                AIplayer[i] = playerTemp;

                string nameTemp = "";
                int next = 0;

                while (next == 0)
                {
                    int namePick = random1.Next(r, 60);

                    if (playerNames[namePick] != "x")
                    {
                        nameTemp = playerNames[namePick];
                        //Player playerTemp = new Player(nameTemp);
                        AIplayer[i].name = nameTemp;
                        playerNames[namePick] = "x";
                        next = 1;
                    } // end if
                    else
                    {
                        continue;
                    }
                } // end while
            } // for
        }
Пример #3
0
        public void DetermineHandWinner()
        {
            if (mainPlayer.betStatus == Player.betstats.fold)
                mainPlayer.winHandScore = 0;
            else
                ScorePlayerHand();

            int adjustScore = 0;
            // create some tempory players
            Player[] tempPlayers = new Player[5];

            for (int i = 0; i < 4; i++)
            {

                if (AIplayer[i].isBust)
                {
                    AIplayer[i].winHandScore = 0;
                }

                tempPlayers[i] = AIplayer[i].ShallowCopy();
            }

            tempPlayers[4] = mainPlayer.ShallowCopy();

            // score winning hands
            for (int k = 0; k < 5; k++)
            {

                if (tempPlayers[k].isBust)
                    continue;

                // set up temp hand
                Card[] tempHand = new Card[7];
                Card swapCard = new Card();

                for (int y = 0; y < 7; y++)
                {

                    if (y < 2)
                        tempHand[y] = tempPlayers[k].playerHand[y].ShallowCopy();
                    else
                        tempHand[y] = Dealer.dealerHand[y - 2].ShallowCopy();
                }

                for (int j = 0; j < 7; j++)
                {
                    tempPlayers[k].playerTempHand[j] = tempHand[j].ShallowCopy();
                }

                //sort tempHand
                for (int a = 0; a < 6; a++)
                {
                    for (int b = a + 1; b < 7; b++)
                    {
                        if (tempHand[a].cardValue > tempHand[b].cardValue)
                        {
                            swapCard = tempHand[b];
                            tempHand[b] = tempHand[a];
                            tempHand[a] = swapCard;

                        }
                    }
                }

                    if (tempPlayers[k].betStatus == Player.betstats.fold)
                    {
                        tempPlayers[k].winHandScore = 0;

                        continue;
                    }

                switch (tempPlayers[k].winHands)
                {
                    case Player.winHand.none:
                        tempPlayers[k].winHandScore = 0;
                        break;

                    case Player.winHand.pair:
                        tempPlayers[k].winHandScore = 100;
                        break;

                    case Player.winHand.twopair:
                        tempPlayers[k].winHandScore = 200;
                        break;

                    case Player.winHand.threekind:
                        tempPlayers[k].winHandScore = 300;
                        break;

                    case Player.winHand.straight:
                        tempPlayers[k].winHandScore = 400;
                        break;

                    case Player.winHand.flush:
                        tempPlayers[k].winHandScore = 500;
                        break;

                    case Player.winHand.fullhouse:
                        tempPlayers[k].winHandScore = 600;
                        break;

                    case Player.winHand.fourkind:
                        tempPlayers[k].winHandScore = 700;
                        break;

                    case Player.winHand.straightflush:
                        tempPlayers[k].winHandScore = 800;
                        break;

                    case Player.winHand.royalflush:
                        tempPlayers[k].winHandScore = 900;
                        break;
                }

                // adjust scores for high cards

                    for (int a = 0; a < 7; a++)
                    {
                        switch (tempHand[a].rank)
                        {
                            case Card.Rank.ace:
                                if (tempPlayers[k].aceLow)
                                {
                                    adjustScore = adjustScore + 1;
                                }
                                else
                                    adjustScore = adjustScore + 14;

                                break;

                            case Card.Rank.king:
                                adjustScore = adjustScore + 13;
                                break;

                            case Card.Rank.queen:
                                adjustScore = adjustScore + 12;
                                break;

                            case Card.Rank.jack:
                                adjustScore = adjustScore + 11;
                                break;

                            case Card.Rank.ten:
                                adjustScore = adjustScore + 10;
                                break;

                            case Card.Rank.nine:
                                adjustScore = adjustScore + 9;
                                break;

                            case Card.Rank.eight:
                                adjustScore = adjustScore + 8;
                                break;

                            case Card.Rank.seven:
                                adjustScore = adjustScore + 7;
                                break;

                            case Card.Rank.six:
                                adjustScore = adjustScore + 6;
                                break;

                            case Card.Rank.five:
                                adjustScore = adjustScore + 5;
                                break;

                            case Card.Rank.four:
                                adjustScore = adjustScore + 4;
                                break;

                            case Card.Rank.three:
                                adjustScore = adjustScore + 3;
                                break;

                            case Card.Rank.deuce:
                                adjustScore = adjustScore + 2;
                                break;
                        }
                     }

                    tempPlayers[k].winHandScore = tempPlayers[k].winHandScore + adjustScore;

            }

            Player swapPlayerTemp = new Player();

            // find hand winner

            for (int x = 0; x < 4; x++)
            {
                for (int y = x + 1; y < 5; y++)
                {
                    if (tempPlayers[x].winHandScore > tempPlayers[y].winHandScore)
                    {
                        swapPlayerTemp = tempPlayers[y];
                        tempPlayers[y] = tempPlayers[x];
                        tempPlayers[x] = swapPlayerTemp;
                    }
                }
            }

            // check for ties

            int winner = 1;
            int q = 4;

            /*
            for (int i = 4; i < 3; i--)
            {
                if (tempPlayers[i].winHandScore == tempPlayers[i - 1].winHandScore)
                    winner = winner + 1;
                else
                    break;
            }
             */

            if (tempPlayers[4].winHandScore != 0)
            {
                //set winner(s)
                if (tempPlayers[4].name == mainPlayer.name)
                {
                    mainPlayer.isHandWinner = true;
                }
                else
                {
                    for (int z = 0; z < 4; z++)
                    {
                        if (tempPlayers[4].name == AIplayer[z].name)
                            AIplayer[z].isHandWinner = true;
                    }
                }

                if (winner > 1)
                {
                    for (int n = 3; n < 2; n--)
                    {

                        if (tempPlayers[n].name == mainPlayer.name)
                            mainPlayer.isHandWinner = true;
                        else
                        {
                            for (int m = 0; m < 4; m++)
                            {
                                if (tempPlayers[n].name == AIplayer[m].name)
                                    AIplayer[m].isHandWinner = true;
                            }
                        }
                    }
                }

                tempPlayers[4].winnings = pot / winner;

                if (mainPlayer.isHandWinner)
                {
                    mainPlayer.winnings = tempPlayers[4].winnings;
                    mainPlayer.money = mainPlayer.money + mainPlayer.winnings;

                }
                else
                {

                    for (int t = 0; t < 4; t++)
                    {
                        if (AIplayer[t].isHandWinner)
                        {
                            AIplayer[t].winnings = tempPlayers[4].winnings;
                            AIplayer[t].money = AIplayer[t].money + AIplayer[t].winnings;

                        }

                        if (AIplayer[t].money <= 0)
                            AIplayer[t].isBust = true;
                    }
                }
            }

            // use for testing purposes
            /*
            if (!qualified)
            {
                makePlayerGoBust();
            }
             */

            pot = 0;

            winnerHand = tempPlayers[4].ShallowCopy();

            if (mainPlayer.money <= 0)
            {
                mainPlayer.isBust = true;
                EndGame();
                return;
            }

            winResults form2 = new winResults(this);
            form2.Show();

            return;
        }