C Como melhorar meu jogo de cartas?

[Luis Vilo]

Bom dia!

Eu tô criando um jogo de cartas (usuario vs PC) e preciso de ajuda. O jogo é o seguinte: Há um baralho com 4 naipes diferentes. Cada grupo de naipe tem 7 cartas (de 1 a 7) e 3 cartas diferentes (valete, cavaleiro e rei). Ou seja, o baralho tem no total 40 cartas. O objetivo é conseguir fazer 7,5 pontos (parece o clássico jogo do blackjack). As 7 primeiras cartas de cada naipe valem o valor que tem a propria carta e as 3 "diferentes" valem 0.5 cada. Daí o programa pergunta pro usuario se quer carta ou quer passar a vez pro PC. Ganha quem fizer os 7,5 pontos ou quem chega mais proximo dessa pontuação, mas sem ultrapassar. Se ultrapassar, perdeu.

 

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

int main()
{
   srand( time(NULL) );
   int chave, carta;
   float pontos;

   printf("Aperte 1 para comecar a jogar ou 0 para passar!\t");
   scanf("%d", &chave);

   printf("\n");

   while(chave==1){
   carta = rand()%10+1;
   if(carta==8 || carta==9 || carta==10){
                                         pontos = 0.5;
                                         }
                                         else{
                                              pontos = carta;
                                              }

   printf("Tua pontuacao e': %0.1f \n", pontos);

   printf("Quer outra carta? (Aperte 1 para sim)\t");
   scanf("%d", &chave);

   while(chave==1){
                   carta = rand()%10+1;
                   if(carta==8 || carta==9 || carta==10){
                                                         pontos = pontos + 0.5;
                                                         }
                                                         else{
                                                              pontos = pontos + carta;
                                                              }
                   printf("\n");

                   printf("Tua pontuacao e': %0.1f \n", pontos);

                   if(pontos>7.5){
                                     printf("PERDEU! Tua pontuacao supera o limite!\n");
                                     system("pause");
                                     return 0;
                                     }

                   printf("Quer outra carta? (Aperte 1 para sim)\t");
                   scanf("%d", &chave);

                   printf("\n");
                   }

   int cartapc;
   float pontos_pc;

   cartapc = rand()%10+1;
   if(cartapc==8 || cartapc==9 || cartapc==10){
                                               pontos_pc = 0.5;
                                               }
                                               else{
                                                    pontos_pc = cartapc;
                                                    }
   printf("A pontuacao do pc e': %0.1f \n", pontos_pc);

   if(pontos_pc==pontos){
                              printf("O pc venceu! \n");
                              }
   else{
        if(pontos_pc>7.5){
                            printf("você venceu! A pontuacao do pc supera o limite! \n");
                            }
   else{
        if(pontos_pc>pontos){
                                  printf("O pc venceu! \n");
                                  }
        }
        }

   while(pontos_pc<pontos){
                                cartapc = rand()%10+1;
                                if(cartapc==8 || cartapc==9 || cartapc==10){
                                                                            pontos_pc = pontos_pc + 0.5;
                                                                            }
                                                                            else{
                                                                                 pontos_pc = pontos_pc + cartapc;
                                                                                 }
                                printf("A pontuacao do pc e': %0.1f \n", pontos_pc);

                                if(pontos_pc==pontos){
                                                           printf("O pc venceu! \n");
                                                           }
                                else{
                                     if(pontos_pc>7.5){
                                                         printf("você venceu! A pontuacao do pc supera o limite \n");
                                                         }
                                else{
                                     if(pontos_pc>pontos){
                                                               printf("O pc venceu! \n");
                                                               }
                          }
                          }
                     }

                     printf("\n");

                     printf("Quer jogar outra vez? (Aperte 0 para sim)\t");
                     scanf("%d", &chave);

                     printf("\n");
                     }


  system("pause");
  return 0;
}

 

Eu fiz isso, mas meu propósito mesmo é o seguinte: Eu peço carta, daí o PC joga. Quando o PC joga, eu peço carta. E assim sucessivamente até alguém ganhar ou perder. Ou seja, que seja alternado. Eu só consegui fazer do jeito que tá o codigo aí, em que eu jogo tudo primeiro e depois o PC, sem alternar. E eu não quero isso. Alguém pode me ajudar? 

Eu também gostaria de saber se há algum jeito de fazer com que um número não seja sorteado mais de 4 vezes (por causa dos 4 naipes)? Porque do jeito que eu fiz aí, um numero pode ser sorteado infinitas vezes...

 

Grato!

[AdrianoSiqueira]

Para alternar entre os jogadores, use uma variável que servirá de switch:

int vez = 0;

// ...

vez = (vez == 0) ? 1 : 0;

// ...

 

Para evitar cartas repetidas, crie uma estrutura que represente uma carta:

typedef struct {
    char nipe; // C - E - O - P
    int valor; // 1 .. 7
} Carta;

 

E crie um vetor com todas as cartas possíveis:

Carta cartas[40];

 

Para sortear uma carta, gere um número aleatório que esteja dentro dos limites de posição desse vetor (0 - 39 na primeira rodada. 0 - 38 na segunda e assim por diante). Depois crie um mecanismo para que cada carta sorteada seja retirada desse vetor.

 

Seria bom criar uma estrutura que represente o jogador (tanto pessoa, quanto o PC ).

typedef struct {
    char nome[256];
    double pontos;
} Jogador;

 

Execute o programa até que os pontos de algum jogador exceda o limite máximo.

[Lucca Rodrigues]

@Luis Vilo

39 minutos atrás, Luis Vilo disse:

Eu peço carta, daí o PC joga. Quando o PC joga, eu peço carta.

É só fazer um loop com isso: você joga, depois o computador joga.

Dessa forma, o jogador não pode negar pegar outra carta, porque daí seria muito fácil simplesmente negar até o computador passar dos 7.5 pontos.

Parece um jogo de pura sorte... Eu fiz um jogo do 7.5 há um tempo, nele eram sorteadas cartas de início para o jogador e para o computador, e assim, o jogador teria que pensar se vale a pena puxar outra carta para ultrapassar o computador, considerando sua pontuação atual.

Considerando que o jogador e o computador têm variáveis que representam a pontuação e a carta sorteada, você pode criar uma estrutura como o @AdrianoSiqueira disse.

Outra coisa é a pontuação: o jogador não sabe que carta foi sorteada, porque tudo o que aparece é a pontuação final, e tem um jeito bem simples de imprimir uma carta:

printf(" _______ \n");
printf("|%c      |\n",cartas[indice]);
printf("|       |\n");
printf("|       |\n");
printf("|       |\n");
printf("|      %c|\n",cartas[indice]);
printf(" ------- ");

/* EX:
 _______ 
|6      |
|       |
|       |
|       |
|      6|
 ------- 
*/

[AdrianoSiqueira]

Se quiser, pode se inspirar nessa ideia. Esse código funciona de forma automatizada, mas com algumas pequenas modificações pode atender a sua necessidade.

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

#define MAX_CARTA 40
#define MAX_JOGADOR 2

typedef struct {
    char nipe;
    double valor;
} Carta;

typedef struct {
    char nome[256];
    double ponto;
} Jogador;


void imprimirCartas(Carta *cartas);

void imprimirJogadores(Jogador *jogadores);

int remover(Carta *cartas, int tamanho, int posicao);

int sortearCarta(int quantidade);


int main() {
    srandom(time(NULL));

    /*
     * [ C ] - Copa
     * [ E ] - Espada
     * [ O ] - Ouro
     * [ P ] - Paus
     */
    Carta cartas[MAX_CARTA] = {
            (Carta) {'C', 0.5},
            (Carta) {'C', 0.5},
            (Carta) {'C', 0.5},
            (Carta) {'C', 1},
            (Carta) {'C', 2},
            (Carta) {'C', 3},
            (Carta) {'C', 4},
            (Carta) {'C', 5},
            (Carta) {'C', 6},
            (Carta) {'C', 7},
            (Carta) {'E', 0.5},
            (Carta) {'E', 0.5},
            (Carta) {'E', 0.5},
            (Carta) {'E', 1},
            (Carta) {'E', 2},
            (Carta) {'E', 3},
            (Carta) {'E', 4},
            (Carta) {'E', 5},
            (Carta) {'E', 6},
            (Carta) {'E', 7},
            (Carta) {'O', 0.5},
            (Carta) {'O', 0.5},
            (Carta) {'O', 0.5},
            (Carta) {'O', 1},
            (Carta) {'O', 2},
            (Carta) {'O', 3},
            (Carta) {'O', 4},
            (Carta) {'O', 5},
            (Carta) {'O', 6},
            (Carta) {'O', 7},
            (Carta) {'P', 0.5},
            (Carta) {'P', 0.5},
            (Carta) {'P', 0.5},
            (Carta) {'P', 1},
            (Carta) {'P', 2},
            (Carta) {'P', 3},
            (Carta) {'P', 4},
            (Carta) {'P', 5},
            (Carta) {'P', 6},
            (Carta) {'P', 7}
    };

    Jogador jogadores[MAX_JOGADOR] = {
            (Jogador) {"Computador", 0.0},
            (Jogador) {"Jogador", 0.0}
    };

    double pontoDerrota = 7.5;

    int quantidade = MAX_CARTA;
    int vez = 0;
    int carta = 0;

    while (jogadores[0].ponto <= pontoDerrota && jogadores[1].ponto <= pontoDerrota) {
        printf("Vez do %s: ", jogadores[vez].nome);
        carta = sortearCarta(quantidade);

        jogadores[vez].ponto += cartas[carta].valor;
        quantidade = remover(cartas, quantidade, carta);

        vez = (vez == 0) ? 1 : 0;
    }

    imprimirCartas(cartas);
    imprimirJogadores(jogadores);
    return EXIT_SUCCESS;
}


void imprimirCartas(Carta *cartas) {
    printf(">> Cartas \n");
    printf("-------------------------------------------------- \n");

    for (int i = 0; i < MAX_CARTA; ++i) {
        printf("{%c, %.1f} ", cartas[i].nipe, cartas[i].valor);

        if ((i + 1) % 10 == 0) {
            printf("\n");
        }
    }

    printf("-------------------------------------------------- \n");
}

void imprimirJogadores(Jogador *jogadores) {
    printf(">> Jogadores \n");
    printf("-------------------------------------------------- \n");

    for (int i = 0; i < MAX_JOGADOR; ++i) {
        printf("{%s, %.1f} \n", jogadores[i].nome, jogadores[i].ponto);
    }

    printf("-------------------------------------------------- \n");
}

int remover(Carta *cartas, int tamanho, int posicao) {
    if (posicao > tamanho) {
        fprintf(stderr, "[ E ]: Posicao invalida. \n");
        return tamanho;
    }

    for (int i = posicao; i < MAX_CARTA - 1; ++i) {
        cartas[i] = cartas[i + 1];
    }

    cartas[MAX_CARTA - 1] = (Carta) {' ', 0.0};
    return tamanho - 1;
}

int sortearCarta(int quantidade) {
    return (int) random() % quantidade;
}

 

[Luis Vilo]

@AdrianoSiqueira vou dar uma olhado nisso aí que você fez! Obgd pela ajuda!

[KXSY]

Uma outra ideia seria assim, mas essa usa um baralho francês.

Spoiler

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

/* Quantidade de naipes */
#define Q_NAIPES 4

/* Quantidade de cartas por naipe */
#define Q_CARTAS_NAIPE 13

/* Valores de cada naipe */
enum naipes_cartas{COPAS, ESPADAS, OUROS, PAUS};

struct carta_valores
{
    unsigned short valor;
    enum naipes_cartas naipe;
};

void
iniciaBaralhoFrances(struct carta_valores *baralho);

void
mostraCarta(struct carta_valores *carta);

void
embaralhaBaralhoFrances(struct carta_valores *baralho);

int main(void)
{
    struct carta_valores baralho[Q_NAIPES*Q_CARTAS_NAIPE];
    int indice;
    /* inicia o baralho */
    iniciaBaralhoFrances(baralho);
    /* Embaralha as cartas */
    embaralhaBaralhoFrances(baralho);
    /* Mostra o baralho */
    for (indice = 0; indice < Q_NAIPES*Q_CARTAS_NAIPE; indice++)
        mostraCarta(&baralho[indice]);

    getchar();      /* Pausa o programa */
    return(0);
}

void
iniciaBaralhoFrances(struct carta_valores *baralho)
{
    int indice = 0;
    for (int cont1 = 0; cont1 < Q_NAIPES; cont1++) {
        for (int cont2 = 0; cont2 < Q_CARTAS_NAIPE; cont2++) {
            baralho[indice].naipe = cont1;
            baralho[indice].valor = cont2+1;
            indice++;
        }
    }
}

void
mostraCarta(struct carta_valores *carta)
{
    printf("\n\n_____");
    if (carta->valor > 1 && carta->valor <= 10) {
        if (carta->valor == 10) {
            printf("\n|%hu |", carta->valor);    
        } else {
            printf("\n|%hu  |", carta->valor);
        }
    } else {
        switch (carta->valor) {
            case 1:
                printf("\n|A  |");
                break;

            case 11:
                printf("\n|V  |");
                break;

            case 12:
                printf("\n|D  |");
                break;

            case 13:
                printf("\n|R  |");
                break;
        }
    }

    printf("\n|   |");

    switch (carta->naipe) {
        case COPAS:
            printf("\n|__C|");
            break;

        case ESPADAS:
            printf("\n|__E|");
            break;

        case OUROS:
            printf("\n|__O|");
            break;

        case PAUS:
            printf("\n|__P|");
            break;
    }
}

void
trocaCarta(struct carta_valores *dest, struct carta_valores *font)
{
    struct carta_valores tmp = *dest;
    *dest = *font;
    *font = tmp;
}

void
embaralhaBaralhoFrances(struct carta_valores *baralho)
{
    /* Inicia o gerador de numeros aleatorios */
    srand(clock());
    for (int inidice = 0; inidice < Q_NAIPES*Q_CARTAS_NAIPE; inidice++)
        trocaCarta(&baralho[inidice], &baralho[rand()%(Q_NAIPES*Q_CARTAS_NAIPE)]);
}