C 两名玩家之间的扑克游戏结果

我正试图在游戏中对我的玩家进行排名，并决定胜利者。您可以阅读下面的代码，因为我认为我已经很好地记录了整个逻辑

我现在需要做的是确定哪位玩家获胜，因为有两位玩家。我已经列出了洗牌、交易和确定手牌类型的功能

    //
//  main.c
//  Created by gixx88 on 7/22/15.
//  Copyright (c) 2015 gixx88. All rights reserved.
//

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#define SUITS 4
#define FACES 13
#define CARDS 52

#define HAND 5
#define PLAYERS 2

//prototypes for shuffle and deal
void shuffle( size_t wDeck[][FACES] ); //shuffling modifies wDeck
void deal( size_t wDeck[][FACES], const char *wFace[],
          const char *wSuit[] ); //dealing doesn't modify the arrays
void dealHand(size_t wHands[][HAND], size_t wDeck[][FACES]);

//prototypes for determing suit and face
size_t determineSuit(size_t wCard);
size_t determineFace(size_t wCard);


//prototypes for determing poker hand
unsigned int findAPair(size_t wHand[HAND]);
unsigned int findTwoPairs(size_t wHand[HAND]);
unsigned int findThreeOfAKind(size_t wHand[HAND]);
unsigned int findFourOfAKind(size_t wHand[HAND]);
unsigned int findFlush(size_t wHand[HAND]);
unsigned int findFullHouse(size_t wHand[HAND]);
unsigned int findStraightFlush(size_t wHand[HAND]);
unsigned int findStraight (size_t wHand[HAND]);

//prototypes for determing player outcomes
unsigned int determingPlayerHand(size_t wHand[HAND]);
void playerRank( size_t wHands[PLAYERS][HAND]);



int main(void) {

   //initialize suit array
    const char *suit[SUITS] = {"Hearts", "Diamonds", "Clubs", "Spades" };

    //initilize face array
    const char *face[ FACES ] = { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven",
        "Eight", "Nine", "Ten", "Jack", "Queen", "King" };

    //initilize deck array
    size_t deck[ SUITS ][FACES] = {{0}};

    size_t hands[PLAYERS][HAND] = {{0}};

    srand(time(NULL));  //random seed generator

    shuffle(deck); //shuffle the deck
    dealHand(hands, deck);

    playerRank(hands);



} //end main

//determine suit
size_t determineSuit(size_t wCard){
    return wCard / SUITS;
} // end determine suit

//determine face
size_t determineFace(size_t wCard){
    return wCard % FACES;
}//end determine face

//if four of a kind

//shuffle cards in deck
void shuffle( size_t wDeck[][FACES] ){
    size_t row; //row number
    size_t column; //column number
    size_t card; //counter

    for (card = 0; card <= CARDS; ++card){

        //choose a random location until unoccupied slot found
        do {
            row = rand() % SUITS;
            column = rand() % FACES;
        } //end do
        while (wDeck[row][column] != 0); //end do while

        //place card number in chosen slot of deck
        wDeck[row][column] = card;
    }// end for
} //end shuffle function

//deal cards in deck
void deal( size_t wDeck[][FACES], const char *wFace[],
          const char *wSuit[] ){
    size_t card; //card counter
    size_t row; //row counter
    size_t column; //column counter

    //deal each of the cards
    for (card = 0; card <= CARDS; ++card){
        //loop through rows of wDeck
        for (row = 0; row < SUITS; ++row){
            //loop through columns in wDeck for current row
            for(column = 0; column < FACES; ++column){
                //if slot contians current card, display card
                if (wDeck[row][column] == card){
                    printf("%5s of %-8s%c", wFace[column], wSuit[row],
                           card % 2 == 0 ? '\n' : '\t'); //two column format
                } //end if
            } //end column for
        } //end row for
    } //end card for
} //end function deal

void dealHand(size_t wHands[][HAND], size_t wDeck[][FACES]){

    size_t cards;
    size_t players;
    unsigned int current;
    unsigned int current_suit;
    unsigned int current_face;

    for (cards = 0; cards <= HAND; cards ++){

        for (players = 0; players < PLAYERS; players++){
            current = cards * PLAYERS + players;
            current_suit = current / SUITS;
            current_face = current % FACES;
            wHands[players][cards] = wDeck[current_suit][current_face];
        } // end players for
    } // end cards for

} // end deal hand


//PRINT THE CARD
void printCard(unsigned int wCard, const char wFaces[FACES], const char wSuit[SUITS]){
    //find suit and face
    size_t suit;
    size_t face;

    suit = determineSuit(wCard);
    face = determineFace(wCard);

    printf("%s or %s", wFaces[face], wSuit[suit]);


} //end print card

//******************************
//BEGIN HAND TYPE DETERMINATION
//******************************


//find A PAIR
unsigned int findAPair(size_t wHand[HAND]){

    size_t countOfFaces[FACES] = { 0 };
    unsigned int foundAPair = 1;
    size_t card;


    for (card = 0; card < HAND; card++)
    {

        size_t face = determineFace(wHand[card]);

        countOfFaces[face]++;

        if (countOfFaces[face] == 3)
        {

            return 1;
        }
        else if (countOfFaces[face] == 2)
        {

            if (foundAPair)
            {

                return 1;
            }

            foundAPair = 0;
        }
    }
    return foundAPair;

} // end find a pair


//find TWO PAIRS
unsigned int findTwoPairs(size_t wHand[HAND]){

    size_t countOfFaces[FACES] = { 0 };

    unsigned int numberOfPairs = 0;

    size_t card;
    for (card = 0; card < HAND; card++){

        size_t face =  determineFace(wHand[card]);
        countOfFaces[face]++;

        if (countOfFaces[face] == 3)
        {

            return 1;
        }
        else if (countOfFaces[face] == 2)
        {

            numberOfPairs++;
        }
    }
    return numberOfPairs == 2;

} //end find two pairs


//find THREE OF A KIND
unsigned int findThreeOfAKind(size_t wHand[HAND]){

    size_t countOfFaces[FACES] = {0};
    size_t card;
    unsigned int foundThree = 1;

    for (card = 0; card < HAND; card++){
        size_t face = determineFace(wHand[card]);
        countOfFaces[face]++;

        if (countOfFaces[face] == 3){
            foundThree =  0;
        } //end if

        else if (countOfFaces[face] == 4){
            return 1;
        } //end else if

        else if (countOfFaces[face] == 2 && foundThree){
            return 1;
        } //end else if
    } //end card for loop

    return 1;

} //end find three of a kind



//find FOUR OF A KIND
unsigned int findFourOfAKind(size_t wHand[HAND]){

    size_t countOfFaces[FACES] = {0};
    size_t card;

    for (card = 0; card < HAND; card++){
        size_t face = determineFace(wHand[card]);
        countOfFaces[face]++;

        if (countOfFaces[face] == 4){
            return 0;
        } //end if
    } //end card for loop

    return 1;

} //end for of a kind

unsigned int findStraight (size_t wHand[HAND]){
    size_t card;

    size_t lowFace;
    size_t highFace;

    size_t firstSuit;
    unsigned int foundSecondSuit = 1;

    for (card = 0; card < HAND; card++)
    {
        size_t suit = determineSuit(wHand[card]);
        size_t face = determineFace(wHand[card]);

        // first card
        if (card == 0)
        {
            lowFace = face;
            highFace = face;

            firstSuit = suit;
        }
        // all other cards
        // check for two equal faces first
        else if (face == lowFace || face == highFace)
        {

            return 1;
        }
        // update low and high face, if necessary
        else
        {

            if (suit != firstSuit)
            {

                foundSecondSuit = 0;
            }

            // an Ace can only go low if the low face is at most a Five
            if (face == 0 && lowFace > HAND - 1)
            {

                face = 13;
            }
            if (face < lowFace)
            {

                lowFace = face;
            }

            if (face > highFace)
            {

                highFace = face;
            }

            if ((highFace - lowFace + 1) != HAND)
            {

                return 1;
            }
        }
    }

    return foundSecondSuit;
}


//find FLUSH
unsigned int findFlush(size_t wHand[HAND]){

    size_t card;
    size_t firstSuit = 5;
    for (card = 0; card < HAND; card++){
        size_t suit = determineSuit(wHand[card]);
        //determing if all cards are the same suit
        if (card == 0){
            firstSuit = suit;
        } //end if
        else if (suit != firstSuit){
            return 1;
        } //end else if
    } //end card for loop

    return 0;

} //end find flush



//find FULL HOUSE
unsigned int findFullHouse(size_t wHand[HAND]){
    if (findAPair(wHand) && findThreeOfAKind(wHand)){
        return 0;
    } //end if

    return 1;
} //end full house


//find STRAIGHT FLUSH
unsigned int findStraightFlush(size_t wHand[HAND]){

    size_t lowFace;
    size_t highFace;
    size_t card;
    size_t firstSuit;

    for (card = 0; card < HAND; card++){
        size_t suit = determineSuit(wHand[card]);
        size_t face = determineFace(wHand[card]);
        //determing if all cards are the same suit
        if (card == 0){
            firstSuit = suit;
            lowFace = face;
            highFace = face;
        } //end if
        else if (suit != firstSuit || face == lowFace || face == highFace){
            return 1;
        } //end else if

        //determination for ace being high or low, which depends on hand
        else
        {
            // an Ace can only go low if the low face is at most a Five
            if (face == 0 && lowFace > HAND - 1)
            {

                face = 13;
            }
            if (face < lowFace)
            {

                lowFace = face;
            }

            if (face > highFace)
            {

                highFace = face;
            }

            if ((highFace - lowFace + 1) != HAND)
            {

                return 1;
            }
        }
    }

    return 0;

} //end straight flush

//****************************
//DETERMINING PLAYER OUTCOMES
//****************************

//determing PLAYER HAND
unsigned int determingPlayerHand(size_t wHand[HAND]){

    if (findStraightFlush(wHand) == 0){
        return 8;
    } //end if

    else if (findFourOfAKind(wHand) == 0){
        return 7;
    } //end else if

    else if (findFullHouse(wHand) == 0){
        return 6;
    } //end else if

    else if (findFlush(wHand) == 0){
        return 5;
    } //end else if

    else if (findStraight(wHand) == 0){
        return 4;
    } //end else if

    else if (findThreeOfAKind(wHand) == 0){
        return 3;
    } //end else if

    else if (findTwoPairs(wHand) == 0){
        return 2;
    } //end else if

    else if (findAPair(wHand) == 0){
        return 1;
    }


    return 0;

} //end determing player hand



//determing PLAYER RANK
void playerRank( size_t wHands[PLAYERS][HAND]){


    unsigned int player1 = determingPlayerHand(wHands);
    unsigned int player2 = determingPlayerHand(wHands);

    if (player1 > player2){
        printf("%s", "Player 1 Wins!");
    }//end if

    else if (player2 > player1){
        printf("%s", "Player 2 Wins!");
    }

} //end player rank

//
//main.c
//由gixx88于2015年7月22日创建。
//版权所有（c）2015 gixx88。版权所有。
//
#包括
#包括
#包括
#包括
#定义诉讼4
#定义面13
#定义卡52
#定义手5
#定义玩家2
//洗牌和交易的原型
无效洗牌（大小为[FACES]）//洗牌会修改wDeck
无效交易（大小为[FACES]，常量字符*wFace[]，
常量字符*wSuit[]//处理不会修改数组
void dealHand（大小为[HAND]，大小为[FACES]）；
//确定衣服和脸的原型
尺寸确定电路（尺寸卡）；
尺寸确定（尺寸卡）；
//确定扑克手的原型
无符号整数findAPair（大小和[手]）；
无符号整数findTwoPairs（size_t wHand[HAND]）；
unsigned int findThreeOfAKind（size_t wHand[HAND]）；
无符号整数findFourOfAKind（size_t wHand[HAND]）；
无符号整数findFlush（size_t wHand[HAND]）；
未签字的内部findFullHouse（尺寸和[手]）；
无符号整数findStraightFlush（大小和[手]）；
无符号整数findStraight（size_t wHand[HAND]）；
//确定玩家结果的原型
不带符号的int determingPlayerHand（size_t wHand[HAND]）；
void playternak（大小[玩家][手]）；
内部主（空）{
//初始化套装数组
const char*套装[套装]={“红心”、“钻石”、“梅花”、“黑桃”}；
//初始化面数组
const char*face[FACES]={“Ace”、“平分”、“三”、“四”、“五”、“六”、“七”，
“八”、“九”、“十”、“杰克”、“女王”、“国王”}；
//初始化甲板阵列
大小甲板[套装][面]={{0}；
大小手[玩家][手]={{0}；
srand（time（NULL））；//随机种子生成器
洗牌（牌）；//洗牌
手（手，甲板）；
游侠（手）；
}//末端总管
//确定诉讼
尺寸确定电路（尺寸卡）{
退回西卡/西服；
}//结束诉讼
//确定面孔
尺寸确定（尺寸卡）{
返回wCard%FACES；
}//端面
//如果是四个一类的
//在牌组中洗牌
无效洗牌（大小\u t wDeck[][面]）{
大小\u t行；//行数
size\u t column；//列号
大小\u t卡；//计数器
用于（卡片=0；卡片手-1）
{
面=13；
}
如果（面<低面）
{
低脸=脸；
}
如果（面>高面）
{
正面=正面；
}
如果（（高面-低面+1）！=手）
{
返回1；
}
}
}
返回0；
}//端部直齐
//****************************
//决定玩家结果
//****************************
//确定玩家手牌
无符号整数determingPlayerHand（大小\u t wHand[手]）{
如果（findStraightFlush（wHand）==0）{
返回8；
}//如果结束，则结束
else if（findFourOfAKind（wHand）==0）{
返回7；
}//如果需要，则结束
else if（findFullHouse（wHand）==0）{
返回6；
}//如果需要，则结束
else if（findFlush（wHand）==0）{
返回5；
}//如果需要，则结束
else if（findStraight（wHand）==0）{
返回4；
}//如果需要，则结束
else if（findThreeOfAKind（wHand）==0）{
返回3；
}//如果需要，则结束
else if（findTwoPairs（wHand）==0）{
返回2；
}//如果需要，则结束
else if（findAPair（wHand）==0）{
返回1；
}
返回0；
}//结束确定玩家手
//确定运动员等级
无效游侠（大小[玩家][手]）{
unsigned int player1=determingPlayerHand（wHands）；
unsigned int player2=determingPlayerHand（wHands）；
如果（播放器1>播放器2）{
printf（“%s”，“玩家1获胜！”）；
}//如果结束
else if（player2>player1）{
printf（“%s”，“玩家2获胜！”）；
}
}//最终玩家等级

我很不愿意把这篇文章发出去，但很遗憾，我必须在明天之前完成这篇文章，而且我已经连续写了12个小时了。我关心的是，我将扑克手类型函数设置为只获取二维数组的一维。有没有一种方法可以有效地为我拥有的球员建立一个排名系统

下面是我在别处给自己做的一些笔记，可能也很有用：determingPlayer只取二维数组的一个下标。我需要玩跑腿游戏来获取两个下标。我如何才能做到这一点，使我的排名将适当地返回给每个球员？我认为排名返回值应该可以。我最初认为它是真是假，1或0，但后来意识到这不够具体

如果我需要更清楚或更相关，请让我知道我可以提供哪些其他信息

在M Oehm的评论之后，我想更新这篇文章，以反映一些我意识到会有用的其他信息

---

我正在解决的问题的部分参数要求某些事情保持现状。如果我可以选择改变它们，我想也有更好的方法。然而，牌组的现状、洗牌算法和交易算法都是根据问题的具体情况构建的。至于手部评估他们应该做什么，到目前为止，他们是这样做的，我写这篇文章是基于这样一个想法，ace需要在某个点上走高，这就是为什么它如此复杂的一部分。带有[玩家][手牌]的二维数组的目的是使其能够按照交替顺序从牌组顶部向每个玩家发放牌，就像在现实生活中一样

当你选择如何表现你的牌组和手时，你的开始很糟糕

您将这些卡表示为整数

rank = card % 13;
suit = card / 13;

int deck[52];