C Jogo de poker 5 cartas em C

Ricardo José · 19 de julho de 2022

Boa tarde galera, fiz esse jogo de poker porém não sei como fazer de modo que cartas não se repitam, algo como, jogador 1 tem seis de paus, jogador 2 também ter seis de paus. Segue um link que direciona para um c online(mais fácil visualização) assim como código.

https://www.onlinegdb.com/z9ju6i1Hd

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

// As cartas são feitas simplesmente de um naipe e um valor
struct Card{
int face;
int suit;
};

// Cada mão é apenas um conjunto de cinco cartas
struct Hand{
struct Card cards[5];
};

// O baralho só vai conter as cartas que já geramos.
// Ele também tem que saber quantas cartas foram dis

tribuídas para que não
// tem que iterar através de um monte de objetos de cartão em branco.
struct Deck{
struct Card dealtCards[52];
int numCardsDealt;
};

// Estou tornando essas variáveis globais para que não tenhamos que lidar com
// gerenciamento de ponteiros para objetos locais.
struct Hand hand1, hand2;
struct Deck deck;

// Esses arrays conterão todas as strings para simplificar a impressão.
static const char *faceStrings[] = {
"Dois","Três","Quatro","Cinco","Seis","Sete","Oito","Nove",
"Dez","Valete","Dama","Rei","As"};
static const char *suitStrings[] = {
"Copas","Paus","Ouros","Spadilha"};
static const char *rankStrings[] = {
"Carta maior","Um par","Dois pares","Three of a Kind","Straight",
"Flush","Full House","Four of a Kind","Straight Flush"};

// Precisamos de funções para gerar mãos, imprimir mãos e determinar
// qual mão ganhou.
void generateHands();
struct Card dealCard();
void printHands();
void analyzeHands();

int main(){
// primeira coisa, precisamos inicializar nosso deck
deck.numCardsDealt=0;

// Semeie nosso gerador aleatório
srand(time(NULL));

// Em seguida, gere cartões
generateHands();

// Imprima-os
printHands();

// E encontrar o vencedor
analyzeHands();

// Deixar o programa saber que foi feito e sem problemas
return 0;
}

void generateHands(){
int i;// Variável de contador

// FAzer as duas mãos em um loop para tornar o código mais simples.
// Isso seria como o dealer alternando dando cartas para um
// jogador ou outro.
for(i=0; i<5; i++){
hand1.cards[i] = dealCard();
hand2.cards[i] = dealCard();
}
}

struct Card dealCard(){
int i;// Variável de contador
int isUnique;// Esta variável acompanha se existem outras cartas correspondentes
struct Card cardToDeal;// Cartas vamos devolver
while(1){// Loop infinito, vamos parar quando pegarmos o cartão
cardToDeal.face = rand()%13;
cardToDeal.suit = rand()%4;
isUnique = 1;
// Verificar de 0 até a última carta que negociamos
for(i=0; i<deck.numCardsDealt; i++){
if(deck.dealtCards[i].face == cardToDeal.face && deck.dealtCards[i].suit == cardToDeal.suit)
isUnique = 0;
}
// Se cardToDeal não tiver sido distribuído
if(isUnique){
deck.numCardsDealt++;
deck.dealtCards[deck.numCardsDealt] = cardToDeal;
return cardToDeal;
}
}
}

// As matrizes de strings que declarei na linha 40 correspondem aos índices
// do valor da face ou do naipe das cartas
void printHands(){
int i;// Variável de contador
printf("Jogador um tem:\n");
for(i=0; i<5; i++)
printf("%s de %s\n", faceStrings[hand1.cards[i].face], suitStrings[hand1.cards[i].suit]);
printf("\nPlayer dois tem:\n");
for(i=0; i<5; i++)
printf("%s de %s\n", faceStrings[hand2.cards[i].face], suitStrings[hand2.cards[i].suit]);
}

void analyzeHands(){
int i,j;// Variável de contador
// Vou tentar usar um sistema semelhante ao do documento
// Contagens de cada rosto e terno.
int hand1FaceCounts[13];
int hand1SuitCounts[4];
int hand2FaceCounts[13];
int hand2SuitCounts[4];

// Inicializar esses arrays para zero.
// Vou usar a função memset.
//memset = preenche uma quantidade de uma determinada área da memória com um dado valor
memset(hand1FaceCounts,0,sizeof(hand1FaceCounts));
memset(hand1SuitCounts,0,sizeof(hand1SuitCounts));
memset(hand2FaceCounts,0,sizeof(hand2FaceCounts));
memset(hand2SuitCounts,0,sizeof(hand2SuitCounts));

// Agora pegar os numeros
for(i=0; i<5; i++){
hand1FaceCounts[hand1.cards[i].face]++;
hand1SuitCounts[hand1.cards[i].suit]++;
hand2FaceCounts[hand2.cards[i].face]++;
hand2SuitCounts[hand2.cards[i].suit]++;
}

// Acompanhamento com o que cada mão tem.
// Abreviando hand1 em h1 e assim por diante.
int h1Rank=0, h1Consec=0, h1Straight=0, h1Flush=0, h1Four=0, h1Three=0, h1Pairs=0;
int h2Rank=0, h2Consec=0, h2Straight=0, h2Flush=0, h2Four=0, h2Three=0, h2Pairs=0;

// checar flush – 5 cartas do mesmo naipe
   for(i=0; i<5; i++){
if(hand1SuitCounts[i]==5)
h1Flush=1;
if(hand2SuitCounts[i]==5)
h2Flush=1;
   }

   // checar para straight 5,6,7,8,9
   // localizar primeira carta
   i = 0;
   while (hand1FaceCounts[i] == 0)
       i++;
   // contar as faces não nulas consecutivas
   for (; i < 3 && hand1FaceCounts[i]; i++)
       h1Consec++;
   if (h1Consec == 5)
       h1Straight = 1;

// checar straight 5,6,7,8,9
   // localize o primeiro cartão
   i = 0;
   while (hand2FaceCounts[i] == 0)
       i++;
   // contar as faces não nulas consecutivas
   for (; i < 3 && hand2FaceCounts[i]; i++)
       h2Consec++;
   if (h2Consec == 5)
       h2Straight = 1;

   /* checar 4-of-a-kind, 3-of-a-kind, e pares */
   for (i = 0; i < 14; i++) {
       if (hand1FaceCounts[i] == 4)
           h1Four = 1;
       if (hand1FaceCounts[i] == 3)
           h1Three = 1;
       if (hand1FaceCounts[i] == 2)
           h1Pairs++;
   }
   for (i = 0; i < 14; i++) {
       if (hand2FaceCounts[i] == 4)
           h2Four = 1;
       if (hand2FaceCounts[i] == 3)
           h2Three = 1;
       if (hand2FaceCounts[i] == 2)
           h2Pairs++;
   }

   // Ranking mão 1
   if (h1Straight && h1Flush)
       h1Rank=8;
   else if (h1Four)
       h1Rank=7;
   else if (h1Three && h1Pairs == 1)
       h1Rank=6;
   else if (h1Flush)
       h1Rank=5;
   else if (h1Straight)
       h1Rank=4;
   else if (h1Three)
       h1Rank=3;
   else if (h1Pairs == 2)
       h1Rank=2;
   else if (h1Pairs == 1)
       h1Rank=1;
   else
       h1Rank=0;

// Ranking mão 2
if (h2Straight && h2Flush)
       h2Rank=8;
   else if (h2Four)
       h2Rank=7;
   else if (h2Three && h2Pairs == 1)
       h2Rank=6;
   else if (h2Flush)
       h2Rank=5;
   else if (h2Straight)
       h2Rank=4;
   else if (h2Three)
       h2Rank=3;
   else if (h2Pairs == 2)
       h2Rank=2;
   else if (h2Pairs == 1)
       h2Rank=1;
   else
       h2Rank=0;

// Mostrar o que cada jogador tem.
printf("\nJogador um tem a seguinte combinacao %s.\n",rankStrings[h1Rank]);
printf("Jogador dois tem a seguinte combinacao %s.\n",rankStrings[h2Rank]);

// Determinar vencedor

if(h1Rank>h2Rank)
printf("Jogador um vence essa rodada!!!\n");
else if(h2Rank>h1Rank)
printf("Jogador dois vence essa rodada!!!\n");
else
printf("Empate!!!\n");
}

arfneto · 19 de julho de 2022

21 minutos atrás, Ricardo José disse:

Segue um link que direciona para um c online(mais fácil visualização)

Porque seria mais fácil ir para outro site a acessar um compilador online?

Mais fácil seria você usar o botão CODE como explicado no primeiro post desse forum

Veja:

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

//  As cartas são feitas simplesmente de um naipe e um valor
struct Card
{
    int face;
    int suit;
};

//  Cada mão é apenas um conjunto de cinco cartas
struct Hand
{
    struct Card cards[5];
};

//  O baralho só vai conter as cartas que já geramos.
//  Ele também tem que saber quantas cartas foram
//  distribuídas para que não
//  tem que iterar através de um monte de objetos de
//  cartão em branco.
struct Deck
{
    struct Card dealtCards[52];
    int         numCardsDealt;
};

//  Estou tornando essas variáveis globais para que não
//  tenhamos que lidar com gerenciamento de ponteiros para
//  objetos locais.
struct Hand hand1, hand2;
struct Deck deck;

//  Esses arrays conterão todas as strings para simplificar
//  a impressão.
static const char* faceStrings[] = {
    "Dois", "Três", "Quatro", "Cinco", "Seis",
    "Sete", "Oito", "Nove",   "Dez",   "Valete",
    "Dama", "Rei",  "As"};
static const char* suitStrings[] = {
    "Copas", "Paus", "Ouros", "Spadilha"};
static const char* rankStrings[] = {
    "Carta maior",     "Um par",         "Dois pares",
    "Three of a Kind", "Straight",       "Flush",
    "Full House",      "Four of a Kind", "Straight Flush"};

//  Precisamos de funções para gerar mãos, imprimir mãos e
//  determinar qual mão ganhou.
void        generateHands();
struct Card dealCard();
void        printHands();
void        analyzeHands();

int main()
{
    //  primeira coisa, precisamos inicializar nosso deck
    deck.numCardsDealt = 0;

    //  Semeie nosso gerador aleatório
    srand(time(NULL));

    //  Em seguida, gere cartões
    generateHands();

    //  Imprima-os
    printHands();

    //  E encontrar o vencedor
    analyzeHands();

    //  Deixar o programa saber que foi feito e sem
    //  problemas
    return 0;
}

void generateHands()
{
    int i;  // Variável de contador

    //  FAzer as duas mãos em um loop para tornar o código
    //  mais simples. Isso seria como o dealer alternando
    //  dando cartas para um jogador ou outro.
    for (i = 0; i < 5; i++)
    {
        hand1.cards[i] = dealCard();
        hand2.cards[i] = dealCard();
    }
}

struct Card dealCard()
{
    int i;         // Variável de contador
    int isUnique;  // Esta variável acompanha se existem
                   // outras cartas correspondentes
    struct Card cardToDeal;  // Cartas vamos devolver
    while (1)
    {  // Loop infinito, vamos parar quando pegarmos o
       // cartão
        cardToDeal.face = rand() % 13;
        cardToDeal.suit = rand() % 4;
        isUnique        = 1;
        // Verificar de 0 até a última carta que negociamos
        for (i = 0; i < deck.numCardsDealt; i++)
        {
            if (deck.dealtCards[i].face ==
                    cardToDeal.face &&
                deck.dealtCards[i].suit == cardToDeal.suit)
                isUnique = 0;
        }
        // Se cardToDeal não tiver sido distribuído
        if (isUnique)
        {
            deck.numCardsDealt++;
            deck.dealtCards[deck.numCardsDealt] =
                cardToDeal;
            return cardToDeal;
        }
    }
}

//  As matrizes de strings que declarei na linha 40
//  correspondem aos índices do valor da face ou do naipe
//  das cartas
void printHands()
{
    int i;  // Variável de contador
    printf("Jogador um tem:\n");
    for (i = 0; i < 5; i++)
        printf(
            "%s de %s\n", faceStrings[hand1.cards[i].face],
            suitStrings[hand1.cards[i].suit]);
    printf("\nPlayer dois tem:\n");
    for (i = 0; i < 5; i++)
        printf(
            "%s de %s\n", faceStrings[hand2.cards[i].face],
            suitStrings[hand2.cards[i].suit]);
}

void analyzeHands()
{
    int i, j;  // Variável de contador
    // Vou tentar usar um sistema semelhante ao do documento
    // Contagens de cada rosto e terno.
    int hand1FaceCounts[13];
    int hand1SuitCounts[4];
    int hand2FaceCounts[13];
    int hand2SuitCounts[4];

    // Inicializar esses arrays para zero.
    // Vou usar a função memset.
    // memset = preenche uma quantidade de uma determinada
    // área da memória com um dado valor
    memset(hand1FaceCounts, 0, sizeof(hand1FaceCounts));
    memset(hand1SuitCounts, 0, sizeof(hand1SuitCounts));
    memset(hand2FaceCounts, 0, sizeof(hand2FaceCounts));
    memset(hand2SuitCounts, 0, sizeof(hand2SuitCounts));

    // Agora pegar os numeros
    for (i = 0; i < 5; i++)
    {
        hand1FaceCounts[hand1.cards[i].face]++;
        hand1SuitCounts[hand1.cards[i].suit]++;
        hand2FaceCounts[hand2.cards[i].face]++;
        hand2SuitCounts[hand2.cards[i].suit]++;
    }

    // Acompanhamento com o que cada mão tem.
    // Abreviando hand1 em h1 e assim por diante.
    int h1Rank = 0, h1Consec = 0, h1Straight = 0,
        h1Flush = 0, h1Four = 0, h1Three = 0, h1Pairs = 0;
    int h2Rank = 0, h2Consec = 0, h2Straight = 0,
        h2Flush = 0, h2Four = 0, h2Three = 0, h2Pairs = 0;

    // checar flush – 5 cartas do mesmo naipe
    for (i = 0; i < 5; i++)
    {
        if (hand1SuitCounts[i] == 5) h1Flush = 1;
        if (hand2SuitCounts[i] == 5) h2Flush = 1;
    }

    // checar para straight  5,6,7,8,9
    // localizar primeira carta
    i = 0;
    while (hand1FaceCounts[i] == 0) i++;
    // contar as faces não nulas consecutivas
    for (; i < 3 && hand1FaceCounts[i]; i++) h1Consec++;
    if (h1Consec == 5) h1Straight = 1;

    // checar straight  5,6,7,8,9
    // localize o primeiro cartão
    i = 0;
    while (hand2FaceCounts[i] == 0) i++;
    // contar as faces não nulas consecutivas
    for (; i < 3 && hand2FaceCounts[i]; i++) h2Consec++;
    if (h2Consec == 5) h2Straight = 1;

    /* checar 4-of-a-kind, 3-of-a-kind, e pares */
    for (i = 0; i < 14; i++)
    {
        if (hand1FaceCounts[i] == 4) h1Four = 1;
        if (hand1FaceCounts[i] == 3) h1Three = 1;
        if (hand1FaceCounts[i] == 2) h1Pairs++;
    }
    for (i = 0; i < 14; i++)
    {
        if (hand2FaceCounts[i] == 4) h2Four = 1;
        if (hand2FaceCounts[i] == 3) h2Three = 1;
        if (hand2FaceCounts[i] == 2) h2Pairs++;
    }

    // Ranking mão 1
    if (h1Straight && h1Flush)
        h1Rank = 8;
    else if (h1Four)
        h1Rank = 7;
    else if (h1Three && h1Pairs == 1)
        h1Rank = 6;
    else if (h1Flush)
        h1Rank = 5;
    else if (h1Straight)
        h1Rank = 4;
    else if (h1Three)
        h1Rank = 3;
    else if (h1Pairs == 2)
        h1Rank = 2;
    else if (h1Pairs == 1)
        h1Rank = 1;
    else
        h1Rank = 0;

    // Ranking mão 2
    if (h2Straight && h2Flush)
        h2Rank = 8;
    else if (h2Four)
        h2Rank = 7;
    else if (h2Three && h2Pairs == 1)
        h2Rank = 6;
    else if (h2Flush)
        h2Rank = 5;
    else if (h2Straight)
        h2Rank = 4;
    else if (h2Three)
        h2Rank = 3;
    else if (h2Pairs == 2)
        h2Rank = 2;
    else if (h2Pairs == 1)
        h2Rank = 1;
    else
        h2Rank = 0;

    // Mostrar o que cada jogador tem.
    printf(
        "\nJogador um tem a seguinte combinacao %s.\n",
        rankStrings[h1Rank]);
    printf(
        "Jogador dois tem a seguinte combinacao %s.\n",
        rankStrings[h2Rank]);

    // Determinar vencedor

    if (h1Rank > h2Rank)
        printf("Jogador um vence essa rodada!!!\n");
    else if (h2Rank > h1Rank)
        printf("Jogador dois vence essa rodada!!!\n");
    else
        printf("Empate!!!\n");
}

a declaração de memset fica em memory.h

26 minutos atrás, Ricardo José disse:

como fazer de modo que cartas não se repitam, algo como, jogador 1 tem seis de paus, jogador 2 também ter seis de paus

Escreva em torno dos dados.

Alguns vão dizer que isso é um algoritmo mas pense no simples e trivial

Você tem o deck com 52 cartas. E começa a dsitribuir. Se tirar do deck a carta que distribuiu ela não pode sair de novo. Então faça isso no programa.

Embaralhe um vetor de cartas. E distribua. Com o deck embaralhado é só ir dando as caras e por construção elas não vão repetirm certo?

Eu já postei uns programas assim aqui nesse forum.

Ricardo José · 19 de julho de 2022

3 horas atrás, arfneto disse:

Porque seria mais fácil ir para outro site a acessar um compilador online?

Mais fácil seria você usar o botão CODE como explicado no primeiro post desse forum

Veja:

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

//  As cartas são feitas simplesmente de um naipe e um valor
struct Card
{
    int face;
    int suit;
};

//  Cada mão é apenas um conjunto de cinco cartas
struct Hand
{
    struct Card cards[5];
};

//  O baralho só vai conter as cartas que já geramos.
//  Ele também tem que saber quantas cartas foram
//  distribuídas para que não
//  tem que iterar através de um monte de objetos de
//  cartão em branco.
struct Deck
{
    struct Card dealtCards[52];
    int         numCardsDealt;
};

//  Estou tornando essas variáveis globais para que não
//  tenhamos que lidar com gerenciamento de ponteiros para
//  objetos locais.
struct Hand hand1, hand2;
struct Deck deck;

//  Esses arrays conterão todas as strings para simplificar
//  a impressão.
static const char* faceStrings[] = {
    "Dois", "Três", "Quatro", "Cinco", "Seis",
    "Sete", "Oito", "Nove",   "Dez",   "Valete",
    "Dama", "Rei",  "As"};
static const char* suitStrings[] = {
    "Copas", "Paus", "Ouros", "Spadilha"};
static const char* rankStrings[] = {
    "Carta maior",     "Um par",         "Dois pares",
    "Three of a Kind", "Straight",       "Flush",
    "Full House",      "Four of a Kind", "Straight Flush"};

//  Precisamos de funções para gerar mãos, imprimir mãos e
//  determinar qual mão ganhou.
void        generateHands();
struct Card dealCard();
void        printHands();
void        analyzeHands();

int main()
{
    //  primeira coisa, precisamos inicializar nosso deck
    deck.numCardsDealt = 0;

    //  Semeie nosso gerador aleatório
    srand(time(NULL));

    //  Em seguida, gere cartões
    generateHands();

    //  Imprima-os
    printHands();

    //  E encontrar o vencedor
    analyzeHands();

    //  Deixar o programa saber que foi feito e sem
    //  problemas
    return 0;
}

void generateHands()
{
    int i;  // Variável de contador

    //  FAzer as duas mãos em um loop para tornar o código
    //  mais simples. Isso seria como o dealer alternando
    //  dando cartas para um jogador ou outro.
    for (i = 0; i < 5; i++)
    {
        hand1.cards[i] = dealCard();
        hand2.cards[i] = dealCard();
    }
}

struct Card dealCard()
{
    int i;         // Variável de contador
    int isUnique;  // Esta variável acompanha se existem
                   // outras cartas correspondentes
    struct Card cardToDeal;  // Cartas vamos devolver
    while (1)
    {  // Loop infinito, vamos parar quando pegarmos o
       // cartão
        cardToDeal.face = rand() % 13;
        cardToDeal.suit = rand() % 4;
        isUnique        = 1;
        // Verificar de 0 até a última carta que negociamos
        for (i = 0; i < deck.numCardsDealt; i++)
        {
            if (deck.dealtCards[i].face ==
                    cardToDeal.face &&
                deck.dealtCards[i].suit == cardToDeal.suit)
                isUnique = 0;
        }
        // Se cardToDeal não tiver sido distribuído
        if (isUnique)
        {
            deck.numCardsDealt++;
            deck.dealtCards[deck.numCardsDealt] =
                cardToDeal;
            return cardToDeal;
        }
    }
}

//  As matrizes de strings que declarei na linha 40
//  correspondem aos índices do valor da face ou do naipe
//  das cartas
void printHands()
{
    int i;  // Variável de contador
    printf("Jogador um tem:\n");
    for (i = 0; i < 5; i++)
        printf(
            "%s de %s\n", faceStrings[hand1.cards[i].face],
            suitStrings[hand1.cards[i].suit]);
    printf("\nPlayer dois tem:\n");
    for (i = 0; i < 5; i++)
        printf(
            "%s de %s\n", faceStrings[hand2.cards[i].face],
            suitStrings[hand2.cards[i].suit]);
}

void analyzeHands()
{
    int i, j;  // Variável de contador
    // Vou tentar usar um sistema semelhante ao do documento
    // Contagens de cada rosto e terno.
    int hand1FaceCounts[13];
    int hand1SuitCounts[4];
    int hand2FaceCounts[13];
    int hand2SuitCounts[4];

    // Inicializar esses arrays para zero.
    // Vou usar a função memset.
    // memset = preenche uma quantidade de uma determinada
    // área da memória com um dado valor
    memset(hand1FaceCounts, 0, sizeof(hand1FaceCounts));
    memset(hand1SuitCounts, 0, sizeof(hand1SuitCounts));
    memset(hand2FaceCounts, 0, sizeof(hand2FaceCounts));
    memset(hand2SuitCounts, 0, sizeof(hand2SuitCounts));

    // Agora pegar os numeros
    for (i = 0; i < 5; i++)
    {
        hand1FaceCounts[hand1.cards[i].face]++;
        hand1SuitCounts[hand1.cards[i].suit]++;
        hand2FaceCounts[hand2.cards[i].face]++;
        hand2SuitCounts[hand2.cards[i].suit]++;
    }

    // Acompanhamento com o que cada mão tem.
    // Abreviando hand1 em h1 e assim por diante.
    int h1Rank = 0, h1Consec = 0, h1Straight = 0,
        h1Flush = 0, h1Four = 0, h1Three = 0, h1Pairs = 0;
    int h2Rank = 0, h2Consec = 0, h2Straight = 0,
        h2Flush = 0, h2Four = 0, h2Three = 0, h2Pairs = 0;

    // checar flush – 5 cartas do mesmo naipe
    for (i = 0; i < 5; i++)
    {
        if (hand1SuitCounts[i] == 5) h1Flush = 1;
        if (hand2SuitCounts[i] == 5) h2Flush = 1;
    }

    // checar para straight  5,6,7,8,9
    // localizar primeira carta
    i = 0;
    while (hand1FaceCounts[i] == 0) i++;
    // contar as faces não nulas consecutivas
    for (; i < 3 && hand1FaceCounts[i]; i++) h1Consec++;
    if (h1Consec == 5) h1Straight = 1;

    // checar straight  5,6,7,8,9
    // localize o primeiro cartão
    i = 0;
    while (hand2FaceCounts[i] == 0) i++;
    // contar as faces não nulas consecutivas
    for (; i < 3 && hand2FaceCounts[i]; i++) h2Consec++;
    if (h2Consec == 5) h2Straight = 1;

    /* checar 4-of-a-kind, 3-of-a-kind, e pares */
    for (i = 0; i < 14; i++)
    {
        if (hand1FaceCounts[i] == 4) h1Four = 1;
        if (hand1FaceCounts[i] == 3) h1Three = 1;
        if (hand1FaceCounts[i] == 2) h1Pairs++;
    }
    for (i = 0; i < 14; i++)
    {
        if (hand2FaceCounts[i] == 4) h2Four = 1;
        if (hand2FaceCounts[i] == 3) h2Three = 1;
        if (hand2FaceCounts[i] == 2) h2Pairs++;
    }

    // Ranking mão 1
    if (h1Straight && h1Flush)
        h1Rank = 8;
    else if (h1Four)
        h1Rank = 7;
    else if (h1Three && h1Pairs == 1)
        h1Rank = 6;
    else if (h1Flush)
        h1Rank = 5;
    else if (h1Straight)
        h1Rank = 4;
    else if (h1Three)
        h1Rank = 3;
    else if (h1Pairs == 2)
        h1Rank = 2;
    else if (h1Pairs == 1)
        h1Rank = 1;
    else
        h1Rank = 0;

    // Ranking mão 2
    if (h2Straight && h2Flush)
        h2Rank = 8;
    else if (h2Four)
        h2Rank = 7;
    else if (h2Three && h2Pairs == 1)
        h2Rank = 6;
    else if (h2Flush)
        h2Rank = 5;
    else if (h2Straight)
        h2Rank = 4;
    else if (h2Three)
        h2Rank = 3;
    else if (h2Pairs == 2)
        h2Rank = 2;
    else if (h2Pairs == 1)
        h2Rank = 1;
    else
        h2Rank = 0;

    // Mostrar o que cada jogador tem.
    printf(
        "\nJogador um tem a seguinte combinacao %s.\n",
        rankStrings[h1Rank]);
    printf(
        "Jogador dois tem a seguinte combinacao %s.\n",
        rankStrings[h2Rank]);

    // Determinar vencedor

    if (h1Rank > h2Rank)
        printf("Jogador um vence essa rodada!!!\n");
    else if (h2Rank > h1Rank)
        printf("Jogador dois vence essa rodada!!!\n");
    else
        printf("Empate!!!\n");
}

a declaração de memset fica em memory.h

Escreva em torno dos dados.

Alguns vão dizer que isso é um algoritmo mas pense no simples e trivial

Você tem o deck com 52 cartas. E começa a dsitribuir. Se tirar do deck a carta que distribuiu ela não pode sair de novo. Então faça isso no programa.

Embaralhe um vetor de cartas. E distribua. Com o deck embaralhado é só ir dando as caras e por construção elas não vão repetirm certo?

Eu já postei uns programas assim aqui nesse forum.

Desculpa ingorância kkkkkkk. Entendi um pouco do que tu disse, tu faria como? É um projeto de primeiro periodo de TI,e estou enrolado nessa parte. Infelizmente todos pegaram coisas mais simples porém a bomba do poker ficou comigo e infelizmente ainda sou leigo . Se tiver como mandar link desses programas seus também, obrigado desde já!

arfneto · 19 de julho de 2022

54 minutos atrás, Ricardo José disse:

Entendi um pouco do que tu disse, tu faria como?

? Leu essa parte:

4 horas atrás, arfneto disse:

Você tem o deck com 52 cartas. E começa a dsitribuir. Se tirar do deck a carta que distribuiu ela não pode sair de novo. Então faça isso no programa.

Embaralhe um vetor de cartas. E distribua. Com o deck embaralhado é só ir dando as caras e por construção elas não vão repetir

Exatamente assim. Passo a passo.

Eu não achei nos meus registros por enquanto. Vou ver. Mas como eu disse você pode pesquisar aqui no forum no meu conteúdo.

Seu programa parece muito complicado.

kgin · 19 de julho de 2022

@Ricardo José Eu dei uma recortada no que eu tinha aqui, mas vê se ajuda.

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

#define Q_CARTAS 13

const char *NOMES_CARTAS[] = {
    "As",
    "Valete",
    "Dama",
    "Rei"
};

const char *NOMES_NAIPES[] = {
    "Paus",
    "Ouros",
    "Copas",
    "Espadas"
};

enum valores_naipes
{
    PAUS = 0,
    OUROS,
    COPAS,
    ESPADAS,
    Q_NAIPES
};

struct carta
{
    unsigned char valor;
    enum valores_naipes naipe;
};

/* Inicia um baralho françes de 52 cartas */
void
inicia_baralho_frances(struct carta *baralho)
{
    unsigned char valor_carta;
    enum valores_naipes valor_naipe;
    unsigned short int contador = 0;
    for (valor_naipe = 0; valor_naipe < Q_NAIPES; valor_naipe++) {
        for (valor_carta = 0; valor_carta < Q_CARTAS; valor_carta++) {
            baralho[contador].valor = valor_carta+1;
            baralho[contador].naipe = valor_naipe;
            contador++;
        }
    }
}

void
embaralha_baralho(struct carta *baralho)
{
    unsigned short int
        contador, indice;
    struct carta tmp = {0};
    srand(time(NULL));
    for (contador = 0; contador < Q_CARTAS*Q_NAIPES; contador++) {
        indice = rand()%(Q_NAIPES*Q_CARTAS);
        tmp = baralho[contador];
        baralho[contador] = baralho[indice];
        baralho[indice] = tmp;
    }
}

void
mostra_carta(struct carta atual)
{
    switch (atual.valor) {
        case 1:
            printf("|%c |", *NOMES_CARTAS[0]);
            break;
        case 11:
            printf("|%c |", *NOMES_CARTAS[1]);
            break;
        case 12:
            printf("|%c |", *NOMES_CARTAS[2]);
            break;
        case 13:
            printf("|%c |", *NOMES_CARTAS[3]);
            break;
        default:
            if (atual.valor < 10)
                printf("|%hhu |", atual.valor);
            else
                printf("|%hhu|", atual.valor);
    }
    printf("\n");
    printf("|_%c|\n", *NOMES_NAIPES[atual.naipe]);
}

void
pausa_msg(char *msg)
{
    char buff[100];
    if (msg != NULL) {
        printf("\t%s\n", msg);
    }
    fgets(buff, 100, stdin);
}

int main(void)
{
    int contador;
    struct carta baralho[Q_CARTAS*Q_NAIPES] = {0};
    inicia_baralho_frances(baralho);
    printf("Baralho organizado!\n");
    for (contador = 0; contador < Q_NAIPES*Q_CARTAS; contador++) {
        static int n_cartas = 1;
        mostra_carta(baralho[contador]);
        if (n_cartas >= 13) {
            pausa_msg("Pressione enter para mostrar mais 13 cartas");
            n_cartas = 1;
        } else {
            n_cartas++;
        }
    }
    embaralha_baralho(baralho);
    printf("Baralho embaralhado!\n");
    for (contador = 0; contador < Q_NAIPES*Q_CARTAS; contador++) {
        static int n_cartas = 1;
        mostra_carta(baralho[contador]);
        if (n_cartas >= 13) {
            pausa_msg("Pressione enter para mostrar mais 13 cartas");
            n_cartas = 1;
        } else {
            n_cartas++;
        }
    }
    return(0);
}

Versão online!

Ricardo José · 19 de julho de 2022

@kgin Gostei do modo como tu pensou sobre embaralhar, verei como introdusir em meu codigo de alguma forma, no caso seria na parte de Dealer.@arfneto Desculpa complicação no codigo, deveria ser mais simples mas ainda sou bem burro, me dê um desconto, quando perguntei eu entendi sua ideia só queria saber como tu colocaria. Mas entendi sim seu passo a passo. Triste não tive muito tempo pensar nesse trabalho, foi me dado menos de 1 semana e sem contar que tenho outras matérias, não existe só programação dai vim pedir ajuda pessoal aqui que são muito bons.

arfneto · 19 de julho de 2022

@Ricardo José eu vou achar um exemplo e te mostro depois. E vou ler teu programa depois.

Não tive tempo hoje

kgin · 19 de julho de 2022

25 minutos atrás, Ricardo José disse:

@kgin Gostei do modo como tu pensou sobre embaralhar, verei como introdusir em meu codigo de alguma forma, no caso seria na parte de Dealer.

Dessa maneira que eu implementei você só precisaria salvar a posição que a carta está.

Um vetor ou uma lista ligada já resolveria para servir de mão do jogador, bastando só ir incrementando uma variável para contar as cartas restantes no baralho.

arfneto · 20 de julho de 2022

De volta ao programa

Seu programa foi bem construído, eu acho. Tem uma indecisão sobre usar inglês ou português nos nomes, tem um folclórico naipe "Spadilha", mas dos problemas comuns vistos nos programas aqui tem poucos. Tem uns comentários com acentos que podem sair errado na tela ou na impressora. E deve declarar as variáveis de controle do loop DENTRO do loop.

Claro que o que estou escrevendo é opinião pessoal. Mas é um forum afinal. Ignore livremente

Mas tem um problema aqui:

void generateHands();
struct Card dealCard();
void printHands();
void analyzeHands();

e o outro lado dele está aqui:

//  Estou tornando essas variáveis globais para que não
//  tenhamos que lidar com gerenciamento de ponteiros para
//  objetos locais.
struct Hand hand1, hand2;
struct Deck deck;

Nunca faça isso. Não use nada global. Isso sempre cai na sua cabeça; É um desastre de manutenção, não tem um mínimo de flexibilidade e torna suas funções quase inúteis porque operam sempre sobre os mesmos dados. E é proibido em toda parte, escolas e empresas.

Escreva em torno dos dados.

O poker de 5 cartas é o mais simples de implementar porque não tem as cartas na mesa nem as fases de cada rodada como o Stud ou Texas Holden.

Do lado das cartas tudo o que existe é o deck e um grupo de jogadores. Numa rodada o deck é embaralhado e as cartas são distribuídas uma a uma. Então o que são os dados no programa? O deck com as cartas e as mãos de cada jogador. Dois vetores.

Uma outra parte do programa eventualmente controlaria o dinheiro, uma outra parte a interface, mas assim é.

Embaralhando o deck

12 horas atrás, Ricardo José disse:

fazer de modo que cartas não se repitam, algo como, jogador 1 tem seis de paus, jogador 2 também ter seis de paus

Pois é: se você tem essa dúvida é porque não está vendo os dados do modo natural. Uma carta já distribuída não pode se repetir. Ela não está mais no deck. Se não escreveu assim não escreveu em torno dos dados e isso vai custar caro. Em resumo o erro em geral é sortear as cartas pelo valor delas e não pela posição.

Imagine uma criança fazendo isso com as cartas: ela tem a pilha de cartas e escolhe uma. O seis de paus. E põe numa pilha a parte: esse será o deck embaralhado. Restam 51 cartas. A criança pega outra: a dama de copas. Põe na pilha, que agora tem duas cartas. Na mesa tem 50 espalhadas, com a face para baixo. E continua. Num certo momento vão restar 2 cartas na mesa e 50 na pilha. A criança escolhe uma e põe na pilha. Pega a última carta e põe na pilha. E aí está o deck embaralhado pela criança.

Programe essa criança; Notou que a criança fez apenas 51 sorteios para embaralhar 52 cartas? Entende que é o número mínimo de sorteios? Seu método pode fazer milhares de chamadas e milhares de testes até terminar. Eu postei aqui um programa com os tempos e chamadas uma vez mas não sei mesmo quando foi e não achei. Mas não importa.

Muita gente vai dizer que esse é o algoritmo de Fisher-Yates. Eu por exemplo escrevi isso pela primeira vez quando eu tinha uns 13 anos (e era exatamente para um jogo de poker ) e não pensei em dar meu nome nem em procurar em livros: era o que eu fazia com as cartas então deveria dar certo. Com todo o respeito ao Fisher e ao Yates não é justo se apropriar da ideia das crianças.

É como procurar um autor para o Selection Sort.

Apenas distribua de fato as cartas e as coisas seguem do modo natural, como no jogo.

EXEMPLO:

Considere o exemplo com essas 6 peças do clássico dominó:

1/1 2/2 3/3 4/4 5/5 6/6

.

É claro que para um programa não faz diferença se são 52 ou 6 ou meio milhão de items. Pode fazer aí uma analogia com o naipe e o valor. Ao embaralhar é claro que não faz diferença a ordem em que estão as cartas. Então o simples: coloque em ordem crescente ou decrescente. Então vamos considerar a ordem crescente.

Sorteia um dos 6: 4/4 e troca com o primeiro

4/4        2/2 3/3 1/1 5/5 6/6

Restam 5. Sorteia um dos 5: 3/3 e troca com o segundo

4/4 3/3        2/2 1/1 5/5 6/6

Restam 4. Sorteia um dos 4: 1/1 e troca com o terceiro

4/4 3/3 1/1        2/2 5/5 6/6

Restam 3: sorteia um dos 3: 5/5 e troca com o quarto

4/4 3/3 1/1 5/5        2/2 6/6

Restam 2: sorteia um dos 2: 2/2 e troca com o quinto

4/4 3/3 1/1 5/5 2/2        6/6

Só resta 1 então acabou e o vetor está embaralhado, 6 peças com 5 sorteios

Como seria em C?

Seria igualzinho. Veja a função abaixo, que foi a que eu postei no forum:

int*        sorteados(unsigned N, int menor, int maior)
{
    unsigned cjto = maior - menor + 1;
    if (cjto < 2) return NULL; // tem que ter um par ao menos
    if (N == 0) return NULL; // bobagem, mas...
    if (N > cjto) N = cjto; // por sanidade :) 
    int* v = (int*)malloc(cjto * sizeof(int)); // cria o vetor
    if (v == NULL) return NULL; // deu pau
    // numera as bolinhas
    for (unsigned i = 0, valor = menor; i < cjto; i += 1) *(v + i) = valor++;
    // as "bolinhas" estão em ordem: faz os sorteios
    for (unsigned i = 1; i < cjto; i += 1)
    {
        int outra = i + rand() % (cjto - i); // uma das outras
        int temp = *(v + i - 1); // a primeira bolinha
        *(v + i - 1) = *(v + outra); // troca pela outra
        *(v + outra) = temp;
    };  // for()
    return v;
};

Ela retorna um vetor de tamanho N, A julgar pelos meus comentários era algo relacionado a loteria. Mas são só números.

Essa função é mais conveniente. Serve para a loteria, para os dados, para o poker ou para qualquer coisa.

Considere uma hipotética função

int show_h(int* v, unsigned N, const char* tit)

que mostra uma mão com N cartas no vetor V. E tit é um título opcional. Isso é outra conveniência.

É claro que se pode usar uma mão de 52 cartas para ver o baralho todo.
É claro que qualquer convenção serve para associar naipe e face. E ela pode estar só dentro dessa função por enquanto.
E se pode imaginar as cartas vindo na ordem, de 2 a A ; E os naipes paus, copas, espadas e ouros como no popular truco.

Então esse programa

int main(void)
{
    srand(220720);
    int  N    = 52;
    int* deck = sorteados(N,0,51);
    show_h(deck,N,"=== [teste com um deck completo] ===");
    free(deck);
    return 0;
}

Embaralha um deck e mostra uma "mão" com as cartas todas só pra testar...

Uma versão de show_h

int show_h(int* v, unsigned N, const char* tit)
{
    static const char* face[] = {
        "Dois", "Tres", "Quatro", "Cinco", "Seis",
        "Sete", "Oito", "Nove",   "Dez",   "Valete",
        "Dama", "Rei",  "As"};
    static const char* naipe[] = {
        "Paus", "Copas", "Espadas", "Ouros "};
    if (tit != NULL) printf("%s\n", tit);
    printf("mao com %d cartas:\n",N);
    for (unsigned i = 0; i < N; i += 1)
        printf(
            "%2d\t%8s de %s\n", v[i], face[v[i] % 13],
            naipe[v[i] / 13]);
    printf("\n");
    return 0;
}

Bem simples, eu acho. Note a conveniência do título: a mesma função vai mostrar as mãos de cada jogador.

E só precisa acrescentar um int ou um char dando a posição do deck para o Dealer. E claro que vai colocar isso JUNTO com o deck e passar como parâmetro para controlar o jogo.

TL;DR

o programa "todo" que está acima

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

int show_h(int*,unsigned,const char*);
int* sorteados(unsigned,int,int);

int main(void)
{
    srand(220720);
    int  N    = 52;
    int* deck = sorteados(N,0,51);
    show_h(deck,N,"=== [teste com um deck completo] ===");
    free(deck);
    return 0;
}

int show_h(int* v, unsigned N, const char* tit)
{
    static const char* face[] = {
        "Dois", "Tres", "Quatro", "Cinco", "Seis",
        "Sete", "Oito", "Nove",   "Dez",   "Valete",
        "Dama", "Rei",  "As"};
    static const char* naipe[] = {
        "Paus", "Copas", "Espadas", "Ouros "};
    if (tit != NULL) printf("%s\n", tit);
    printf("mao com %d cartas:\n",N);
    for (unsigned i = 0; i < N; i += 1)
        printf(
            "%2d\t%8s de %s\n", v[i], face[v[i] % 13],
            naipe[v[i] / 13]);
    printf("\n");
    return 0;
}

int* sorteados(unsigned N, int menor, int maior)
{
    unsigned cjto = maior - menor + 1;
    if (cjto < 2)
        return NULL;          // tem que ter um par ao menos
    if (N == 0) return NULL;  // bobagem, mas...
    if (N > cjto) N = cjto;   // por sanidade :)
    int* v =
        (int*)malloc(cjto * sizeof(int));  // cria o vetor
    if (v == NULL) return NULL;            // deu pau
    // numera as bolinhas
    for (unsigned i = 0, valor = menor; i < cjto; i += 1)
        *(v + i) = valor++;
    // as "bolinhas" estão em ordem: faz os sorteios
    for (unsigned i = 1; i < cjto; i += 1)
    {
        int outra =
            i + rand() % (cjto - i);  // uma das outras
        int temp     = *(v + i - 1);  // a primeira bolinha
        *(v + i - 1) = *(v + outra);  // troca pela outra
        *(v + outra) = temp;
    };  // for()
    return v;
};

E a saída

=== [teste com um deck completo] ===
mao com 52 cartas:
50           Rei de Ouros
47           Dez de Ouros
41        Quatro de Ouros
 8           Dez de Paus
25            As de Copas
 2        Quatro de Paus
13          Dois de Copas
12            As de Paus
51            As de Ouros
14          Tres de Copas
 4          Seis de Paus
32          Oito de Espadas
16         Cinco de Copas
28        Quatro de Espadas
49          Dama de Ouros
 0          Dois de Paus
20          Nove de Copas
45          Oito de Ouros
48        Valete de Ouros
30          Seis de Espadas
33          Nove de Espadas
18          Sete de Copas
42         Cinco de Ouros
24           Rei de Copas
29         Cinco de Espadas
 3         Cinco de Paus
 9        Valete de Paus
 6          Oito de Paus
43          Seis de Ouros
15        Quatro de Copas
44          Sete de Ouros
21           Dez de Copas
39          Dois de Ouros
 5          Sete de Paus
40          Tres de Ouros
 7          Nove de Paus
34           Dez de Espadas
27          Tres de Espadas
31          Sete de Espadas
19          Oito de Copas
10          Dama de Paus
38            As de Espadas
11           Rei de Paus
17          Seis de Copas
35        Valete de Espadas
23          Dama de Copas
 1          Tres de Paus
26          Dois de Espadas
46          Nove de Ouros
36          Dama de Espadas
22        Valete de Copas
37           Rei de Espadas

Juntei isso aqui porque achei que seria legal o forum ter um exemplo completo de uma função de shuffle --- embaralhamento --- com o ingênuo método das crianças, a.k.a. algortimo de fisher-yates

Ricardo José · 26 de julho de 2022

Obrigado pela ajuda, foi de suma importância para finalização do trabalho, infelizmente não tenho muitos a quem recorrer e vejo que o pessoal aqui tem grande experiência no ramo. Agora estou em outro dilema em outro jogo, esse do poker deu certo, obrigado novamente!

arfneto · 26 de julho de 2022

@Ricardo José Compare o programa que te mostrei com os outros exemplos e o programa original. Se não rodou esse programa rode em sua máquina e entenda. Em especial note o tamanho de main() e a noção de encapsulamento em sorteados() e show_h(). E o fato de que a mesma função pode gerar todo tipo de amostra, seja um deck, uma mão de poker, um jogo de dominó, uma fila de clientes ou um bingo.

PhilipJones · 4 de abril de 2023

Eu adoro o jogo de poker! É um jogo de estratégia fascinante que requer muita habilidade e inteligência. Tenho jogado poker há algum tempo e aprendi muito sobre como ler as mãos dos outros jogadores e fazer blefes estratégicos. Eu posso aconselhar onde você pode aprender mais sobre o pôquer-Apostas no Brasil. É incrível como cada jogo é diferente e apresenta novos desafios. Definitivamente, recomendo o poker para quem gosta de jogos de cartas e quer testar suas habilidades de estratégia.