Jump to content
Fórum Script Brasil
  • 0

Dúvida - Elaborar Paciência em C++


Iago CF

Question

Boa noite, gostaria de pedir a ajuda de quem puder para me auxiliar no código, tenho um trabalho da faculdade para fazer, tenho que desenvolver paciência, porém estou com muita dificuldade, tenho o arquivo em pdf do que é para ser feito, mas não é nada além do que o jogo paciência, o que consegui até agora foi o seguinte:

#include <conio2.h>

#include <stdio.h>

#include <ctype.h>

struct carta
{
    int num;//1=A, 5=5, J=12...
    int naipe; //1=ouro, 2=espada, 3=espada, 4=ouro
    int cor; //2=preto, 1=vermelo
}

struct carta fazer_baralho() {
   int i;
   struct carta aux[52];

   for (i=0; i<13; i++) {
      aux[i].valor = i;
      aux[i].naipe = 1; // porque é ouro
      aux[i];cor = 1; // porque é vermelha
   }

   for (i=13; i<26; i++) {
      aux[i].valor = i-13;
      aux[i].naipe = 2; // porque é espada
      aux[i].cor = 2; // porque é preta
}
struct carta[] fazer_baralho() {
   int i;
   struct carta aux[52];

   for (i=0; i<13; i++) {
      aux[i].valor = i;
      aux[i].naipe = 1; // porque é ouro
      aux[i];cor = 1; // porque é vermelha
   }

   for (i=13; i<26; i++) {
      aux[i].valor = i-13;
      aux[i].naipe = 2; // porque é espada
      aux[i].cor = 2; // porque é preta
}

struct carta[] fazer_baralho() {
   int i;
   struct carta aux[52];

   for (i=0; i<13; i++) {
      aux[i].valor = i;
      aux[i].naipe = 3; // porque é copas
      aux[i];cor = 1; // porque é vermelha
   }

   for (i=13; i<26; i++) {
      aux[i].valor = i-13;
      aux[i].naipe = 4; // porque é paus
      aux[i].cor = 2; // porque é preta
}

Se alguém puder ajudar, ficarei grato.

Edited by Iago CF
Link to comment
Share on other sites

16 answers to this question

Recommended Posts

  • 0

Pedro, desculpa, mas como usa as tags?

Bom, são muitas dúvidas, estou completamente perdido, tenho que criar uma parte para embaralhar, distribuir em ordem aleatória (usando o rand), fazer todo o esquema do jogo paciência, estou completamente perdido nessa programação. As pilhas de cartas serão formadas por um vetor? Se sim ou se não, alguém pode me dar um exemplo?

Obrigado

Link to comment
Share on other sites

  • 0

Ok. Primeiro:

para usar as tags digite "

" seu código "

". (Sem as aspas).

E depois, vamos por partes. Para embaralhar, pode usar um for loop ou até mesmo o rand. Para distribuir a mesma coisa. As pilhas podem ser um vetor de C++ ou um vetor à moda antiga. Tenho que sair no momento, mas logo logo posso te ajudar mais. Depois te mando uma MSG por pm.

Link to comment
Share on other sites

  • 0

Olá!

Esse programa não é simples. Não sei qual sei conhecimento na linguagem e por isso vou considerar que você já tem um conhecimento razoável...

Antes de começar, Q usa as tags code da seguinte forma:

(code)

Código

(/code)

Apenas troque os parênteses por colchetes.

Sobre o programa: eu desenvolveria o código em dois arquivos independentes: baralho.c e paciencia.c.

Eles teriam os códigos referentes ao controle do baralho (definição de cartas, listas de cartas, etc) e a lógica do jogo em si.

Assim o baralho.c poderia até ser usado em outros jogos, ser usado tanto por programas gráficos como para console, entre outras vantagens.

O baralho seria uma lista de cartas e que conteria todas elas. O jogo teria uma lista para cada posição (as pilhas dos ases, as pilhas de cartas ordenadas, a pilha de descartes e a pilha das cartas ainda não sorteadas).

Depois que você tiver a lógica de controle do baralho funcionando com funções como adicionar e remover cartas de listas, embaralhar e etc, a lógica do jogo em si será apenas mover cartas ente as listas segundo as regras do jogo.

Você entendeu esse princípio?

Do que foi dito,o que você sabe fazer?

Abraços,

Marcelo Utikawa da Fonseca

Link to comment
Share on other sites

  • 0

Obrigado pelas respostas, entendi sim o que quis dizer Marcelo, o problema é colocar em prática. :(

Uso o devcpp, comandos de imprimir e ler printf e scanf, do resto acho que é normal, é que alguns usam o cin e cout, por isso disse qual eu uso, mas seguindo ao assunto, tenho até o dia 1º para fazer isso, e não sai do ponto em que postei, creio que tem muita coisa ainda pela frente, a lógica do jogo eu já aprendi, agora falta colocar em prática, se puder me ajudar, eu agradeço.

Link to comment
Share on other sites

  • 0

Ok... Eu perguntei pois achava que você tinha conhecimentos mais básicos mesmo! Mas ou o professor exagerou ou você não conseguiu acompanhar pois esse programa exige no mínimo um conhecimento intermediário na linguagem...

E desenvolver até o dia primeiro acho que você mesmo percebeu que é complicado!!!

Eu não gosto de passar código pronto pois acho que estou mais atrapalhando que ajudando pois você pede a oportunidade de aprender e não sente o gosto da conquista. Mas como já está em cima da hora vou ajudar no que for possível...

Primeiro vamos trabalhar apenas no baralho.c e depois a gente faz o jogo em si.

Pode usar ponteiros no projeto? Tem alguma restrição ou exigência?

Abraços,

Marcelo Utikawa da Fonseca

Link to comment
Share on other sites

  • 0

Oi de novo!

Desculpe mas não tenho muito tempo para ajudar mas o que conseguir vou passando. Tenho cerca de meia hora por dia apenas!

Por enquanto consegui fazer o baralho.h, baralho.c e paciencia.c

Ainda não faz muita coisa mas acho que dá para você entender o que precisa ser feito! Veja se consegue criar algo a partir do que foi feito.

Eu testei e compilei no Linux e por isso fiz um script para compilar os arquivos. Mas como usei apenas ANSI C deve funcionar em qualquer SO.

Seguem os arquivos:

baralho.h

#ifndef BARALHO_H_INCLUDED
#define BARALHO_H_INCLUDED

typedef enum { Diamond, Spade, Heart, Club } Suit;

typedef struct {
    int  iValue;
    Suit eSuit;
} Card;

typedef struct strCardList CardList;
struct strCardList {
    Card     *pCard;
    CardList *pNext;
};

Card * Card_Create       (int iValue, Suit eSuit);
void   Card_Free         (Card *pCard);
char * Card_GetSuitString(Card *pCard);

#endif // BARALHO_H_INCLUDED
baralho.c
#include <malloc.h>

#include "baralho.h"

Card * Card_Create(int iValue, Suit eSuit)
{
    Card *pNew = (Card *)malloc(sizeof(Card));

    if(pNew != NULL) {
        pNew->iValue = iValue;
        pNew->eSuit  = eSuit;
    }

    return pNew;
}

void Card_Free(Card *pCard)
{
    if(pCard != NULL) {
        free(pCard);
    }
}

char * Card_GetSuitString(Card *pCard)
{
    if(pCard != NULL) {
        switch(pCard->eSuit) {
            case Diamond: return "Ouros" ;
            case Spade  : return "Espadas";
            case Heart  : return "Copas" ;
            case Club   : return "Paus"  ;
        }
    }

    return "";
}
paciencia.c
#include <stdio.h>

#include "baralho.h"

int main(void)
{
    Card *pCard = Card_Create(3, Spade);

    if(pCard != NULL) {
        printf("Carta criada! Valor: %d, Naipe: %s\n", pCard->iValue, Card_GetSuitString(pCard));
    } else {
        printf("Erro ao criar carta!!!\n");
    }

    return 0;
}
compila.sh
#!/bin/sh

gcc -Wall -c -o baralho.o baralho.c
gcc -Wall    -o paciencia paciencia.c baralho.o
Ao rodar o programa é exibido na tela:
Carta criada! Valor: 3, Naipe: Espadas

Espero conseguir fazer um pouco por dia. Se você conseguir algo coloque também pois assim é mais provável de você ter algo para aprensentar até dia primeiro.

Abraços,

Marcelo Utikawa da Fonseca

Link to comment
Share on other sites

  • 0

Obrigado pela grande ajuda Marcelo, muito obrigado mesmo, porém, acho que algumas coisas que tem aí são diferente do que uso, vou passar um código de exemplo:

#include <conio2.h>
#include <ctype.h>
#include <string.h>
#include <stdio.h>

#define TF 20

struct TpPessoa
{
    char Nome[40], Fone[15];
    int d, m, a;
};


void Cadastra(TpPessoa Tab[TF], int &TL)
{
    char AuxFone[15];
    clrscr();
    printf ("** Cadastro de Pessoas **\n");
    printf ("Digite o telefone (xx)xxxx-xxxx: ");
    fflush(stdin);
    gets(AuxFone);
    while (TL<TF && strcmp(AuxFone, "")!=0)
    {
        strcpy(Tab[TL].Fone, AuxFone);
        printf ("Nome: ");
        gets(Tab[TL].Nome);
        printf ("Ano Nasc.: xx xx xxxx: ");
        scanf ("%d %d %d", &Tab[TL].d, &Tab[TL].m, &Tab[TL].a);
        TL++;
        printf ("\nTelefone: (xx)xxxx-xxxx: ");
        fflush(stdin);
        gets(AuxFone);
    }
}

int BuscaSentinela (int Vetor[TF], int TL, int Elemento)
{
    int i=0;
    Vetor[TL] = Elemento;
    while (Elemento!=Vetor[i])
        i++;
    if(i<TL)
        return i;
    else
        return -1;
}


int main (void)
{
    TpPessoa Pessoas[TF];
    int TL=0;
    Cadastra(Pessoas, TL);
    //InsercaoDireta(Pessoas, TL);
    ExibePessoas(Pessoas, TL);
    Ordem(Pessoas, TL);
    ExibePessoas(Pessoas, TL);
    Consulta(Pessoas, TL);
    Exclusao(Pessoas, TL);
    Alterar(Pessoas, TL);

    return 1;
}

Apenas um exemplo das bibliotecas que eu dos comandos como printf, scanf, nunca usei ifndef, typedef, e outras coisas, ontem tem -> seria o =?

Obrigado!

Link to comment
Share on other sites

  • 0

Boa tarde!

Eu estou usando poucas bibliotecas. Apenas a stdio.h (para o printf, você também usa) e a malloc.h (para alocar memória pois não estou usando vetores de tamanho fixo mas sim ponteiros com alocação dinâmica).

O typedef é apenas para criar um "apelido" para o nome do tipo, pode ser retirado. Além disso faz parte da linguagem, não é de nenhuma biblioteca.

O ifdef também é da linguagem e é usado apenas por causa do arquivo .h. Isso é praxe. Se você abrir qualquer arquivo .h verá que existe isso. Serve para que o arquivo .h não tenha o seu conteúdo incluído mais de uma vez. Em projetos maiores isso é indispensável mas nesse caso pode ser removido sem problema.

No seu caso, se o professor não deixa usar (o que não acredito, tente falar com ele), você pode retirar tudo isso, é bem simples.

Eu não vou retirar pois minha intenção é terminar esse programa e deixar como referência aqui na parte de tutoriais do fórum. Assim é melhor que ele seja feito conforme manda o figurino... :P

Agora estou no celular então não tenho como programar mas se você quiser posso tentar tirar suas dúvidas!

Edit: esqueci de responder! O -> é operador de referência.serve para acessar os membros de uma estrutura, classe, etc através de um ponteiro. É o mesmo que o operador ponto, que é utilizado para acessar membros de variáveis diretamente.exemplo:

struct coordenada {
    int x;
    int y;
};

struct  coordenada direto, *ponteiro;

direto.x = 10;
direto.y = 35;

ponteiro = &direto;

ponteiro->x = 10;
ponteiro->y = 35;

Abraços,

Marcelo Utikawa da Fonseca

Edited by Marcelo Utikawa da Fonseca
Link to comment
Share on other sites

  • 0

Olá!

Estou conseguindo fazer o programa mais rápido do que esperava! :)

Agora o baralho.c está quase pronto. Faltam apenas as funções para criar o baralho completo (que é apenas um loop chamando a função Card_Create) e a função para embaralhar.

Terminando é só fazer o jogo em si.

Seguem os códigos atualizados:

baralho.c

#include <malloc.h>

#include "baralho.h"

Card * Card_Create(int iValue, Suit eSuit)
{
    Card *pNew = (Card *)malloc(sizeof(Card));

    if(pNew != NULL) {
        pNew->iValue = iValue;
        pNew->eSuit  = eSuit;
    }

    return pNew;
}

void Card_Free(Card *pCard)
{
    if(pCard != NULL) {
        free(pCard);
    }
}

char * Card_GetSuitString(Card *pCard)
{
    if(pCard != NULL) {
        switch(pCard->eSuit) {
            case Diamond: return "Ouros" ;
            case Spade  : return "Espadas";
            case Heart  : return "Copas" ;
            case Club   : return "Paus"  ;
        }
    }

    return "";
}

void CardList_InsertCard(CardList **pList, Card *pCard)
{
    CardList *pNew, *pCurrent;
    if(pList == NULL || pCard == NULL) return;

    pNew = (CardList *)malloc(sizeof(CardList));
    pNew->pCard = pCard;
    pNew->pNext = NULL;

    if(*pList == NULL) {
        *pList = pNew;
    } else {
        pCurrent = *pList;

        while(pCurrent->pNext != NULL) {
            pCurrent = pCurrent->pNext;
        }

        pCurrent->pNext = pNew;
    }
}

void CardList_InsertCardList(CardList **pList, CardList *pNew)
{
    CardList *pCurrent;
    if(pList == NULL || pNew == NULL) return;

    if(*pList == NULL) {
        *pList = pNew;
    } else {
        pCurrent = *pList;

        while(pCurrent->pNext != NULL) {
            pCurrent = pCurrent->pNext;
        }

        pCurrent->pNext = pNew;
    }
}

CardList * CardList_GetSubset(CardList **pList, Card *pCard)
{
    CardList *pCurrent, *pPrevious = NULL;
    if(pList == NULL || *pList == NULL || pCard == NULL) return NULL;

    pCurrent = *pList;
    while(pCurrent != NULL) {
        if(pCurrent->pCard->iValue == pCard->iValue && pCurrent->pCard->eSuit == pCard->eSuit) {
            break; // Achou a carta!
        } else {
            pPrevious = pCurrent;
            pCurrent = pCurrent->pNext;
        }
    }

    if(pPrevious != NULL) {
        pPrevious->pNext = NULL;
    }

    // Se achou, pCurrent tera a posicao onde inicia a lista a partir de pCard, senao tera NULO.
    return pCurrent;
}

Card * CardList_GetCard(CardList **pList)
{
    CardList *pCurrent, *pPrevious = NULL;
    if(pList == NULL || *pList == NULL) return NULL;

    pCurrent = *pList;
    while(pCurrent->pNext != NULL) {
        pPrevious = pCurrent;
        pCurrent = pCurrent->pNext;
    }

    if(pPrevious != NULL) {
        pPrevious->pNext = NULL;
    }

    // Se achou, pCurrent tera a posicao onde inicia a lista a partir de pCard, senao tera NULO.
    return pCurrent->pCard;
}
baralho.h
#ifndef BARALHO_H_INCLUDED
#define BARALHO_H_INCLUDED

typedef enum { Diamond, Spade, Heart, Club } Suit;

typedef struct {
    int  iValue;
    Suit eSuit;
} Card;

typedef struct strCardList CardList;
struct strCardList {
    Card     *pCard;
    CardList *pNext;
};

// Funcoes referentes a Cartas
Card * Card_Create       (int iValue, Suit eSuit);
void   Card_Free         (Card *pCard);
char * Card_GetSuitString(Card *pCard);

// Funcoes referentes a Listas de Cartas
void       CardList_InsertCard    (CardList **pList, Card *pCard);
void       CardList_InsertCardList(CardList **pList, CardList *pNew);
CardList * CardList_GetSubset     (CardList **pList, Card *pCard);
Card     * CardList_GetCard       (CardList **pList);

#endif // BARALHO_H_INCLUDED
paciencia.c
#include <stdio.h>

#include "baralho.h"

void PrintCard(Card *pCard)
{
    printf("%d %s\n", pCard->iValue, Card_GetSuitString(pCard));
}

int main(void)
{
    Card *pCard = Card_Create(3, Spade);
    CardList *pList = NULL, *pSubset;

    if(pCard != NULL) {
        printf("Carta criada! Valor: ");
        PrintCard(pCard);
    } else {
        printf("Erro ao criar carta!!!\n");
        return 1;
    }

    CardList_InsertCard(&pList, Card_Create(1, Club   ));
    CardList_InsertCard(&pList, Card_Create(3, Club   ));
    CardList_InsertCard(&pList, Card_Create(8, Heart  ));
    CardList_InsertCard(&pList, Card_Create(9, Diamond));
    CardList_InsertCard(&pList, pCard);
    CardList_InsertCard(&pList, Card_Create(2, Heart  ));
    CardList_InsertCard(&pList, Card_Create(4, Spade  ));

    pSubset = CardList_GetSubset(&pList, pCard);
    pCard   = CardList_GetCard  (&pList);

    printf("Removida carta da lista principal: ");
    PrintCard(pCard);

    printf("Cartas na lista principal:\n");
    while(pList != NULL) {
        PrintCard(pList->pCard);
        pList = pList->pNext;
    }

    printf("Cartas na sublista:\n");
    while(pSubset != NULL) {
        PrintCard(pSubset->pCard);
        pSubset = pSubset->pNext;
    }

    return 0;
}

Abraços,

Marcelo Utikawa da Fonseca

Link to comment
Share on other sites

  • 0

Obrigado Marcelo, vou dando uma estudada no código e mudar algumas coisas, porque terei que explicá-lo, mas creio que não será problema, consigo entender o programa pronto, mas o problema é começar a fazer a lógica dele.

Tenho que salvar os que estão em H também, porque uso apenas cpp, e é possível colocar tudo em um único código? Por exemplo:

void Baralho
{
....
}
int main()
{
baralho(...);
}

Edited by Iago CF
Link to comment
Share on other sites

  • 0

Boa tarde!

Sim, é possível mesclar tudo em um único arquivo. Basta pegar o conteúdo dos arquivos baralho.h, baralho.c e paciencia.c, nessa ordem, e criar um novo arquivo.

Porém usar mais de um arquivo é normal. Imagine um windows desenvolvido em um único arquivo! Qualquer programa um pouco maior terá vários arquivos. E qualquer ide suporta isso! :)

Abraços,

Marcelo Utikawa da Fonseca

Link to comment
Share on other sites

  • 0

Mais uma atualização...

Agora toda a lógica do baralho está pronta. Só falta o jogo em si, que é o que estou trabalhando agora.

Tire suas dúvidas!

baralho.c

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

#include "baralho.h"

Card * Card_Create(int iValue, Suit eSuit)
{
    Card *pNew = (Card *)malloc(sizeof(Card));

    if(pNew != NULL) {
        pNew->iValue = iValue;
        pNew->eSuit  = eSuit;
    }

    return pNew;
}

void Card_Free(Card *pCard)
{
    if(pCard != NULL) {
        free(pCard);
    }
}

int Card_GetValue(Card *pCard)
{
    int iValue;

    if(pCard != NULL) {
        for(iValue = 0; iValue < CARD_VALUE_K; iValue++) {
            if(pCard->iValue == (1<<iValue)) {
                return iValue+1;
            }
        }
    }

    return CARD_VALUE_INVALID;
}

char * Card_GetSuitString(Card *pCard)
{
    if(pCard != NULL) {
        switch(pCard->eSuit) {
            case Diamond: return "Ouros" ;
            case Spade  : return "Espadas";
            case Heart  : return "Copas" ;
            case Club   : return "Paus"  ;
        }
    }

    return "";
}

CardList * CardList_GetPosition(CardList **pList, CardList **pRetPrevious, int iPosition)
{
    CardList *pCurrent, *pPrevious = NULL;
    if(pList == NULL || *pList == NULL) return NULL;

    pCurrent = *pList;

    while(pCurrent != NULL) {
        if(iPosition < 0 && pCurrent->pNext == NULL) break; // Encontrou ultimo item
        if(iPosition-- == 0) break; // Encontrou item procurado

        pPrevious = pCurrent;
        pCurrent = pCurrent->pNext;
    }

    if(pRetPrevious != NULL) {
        if(pCurrent != NULL) {
            *pRetPrevious = pPrevious;
        } else {
            *pRetPrevious = NULL;
        }
    }

    return pCurrent;
}

int CardList_GetSize(CardList **pList)
{
    int iSize = 0;
    CardList *pCurrent;

    if(pList != NULL && *pList != NULL) {
        pCurrent = *pList;
        while(pCurrent != NULL) {
            iSize++;
            pCurrent = pCurrent->pNext;
        }
    }

    return iSize;
}

void CardList_InsertCardList(CardList **pList, CardList *pNew)
{
    CardList *pCurrent;
    if(pList == NULL || pNew == NULL) return;

    if(*pList == NULL) {
        *pList = pNew;
    } else {
        pCurrent = CardList_GetPosition(pList, NULL, -1);
        pCurrent->pNext = pNew;
    }
}

void CardList_InsertCard(CardList **pList, Card *pCard)
{
    CardList *pNew;
    if(pList == NULL || pCard == NULL) return;

    pNew = (CardList *)malloc(sizeof(CardList));
    pNew->pCard = pCard;
    pNew->pNext = NULL;

    CardList_InsertCardList(pList, pNew);
}

CardList * CardList_GetSubset(CardList **pList, Card *pCard)
{
    CardList *pCurrent, *pPrevious = NULL;
    if(pList == NULL || *pList == NULL || pCard == NULL) return NULL;

    pCurrent = *pList;
    while(pCurrent != NULL) {
        if(pCurrent->pCard->iValue == pCard->iValue && pCurrent->pCard->eSuit == pCard->eSuit) {
            break; // Achou a carta!
        } else {
            pPrevious = pCurrent;
            pCurrent = pCurrent->pNext;
        }
    }

    if(pPrevious != NULL) {
        pPrevious->pNext = NULL;
    }

    // Se achou, pCurrent tera a posicao onde inicia a lista a partir de pCard, senao tera NULO.
    return pCurrent;
}

Card * CardList_GetCard(CardList **pList)
{
    CardList *pCurrent, *pPrevious = NULL;
    if(pList == NULL || *pList == NULL) return NULL;

    pCurrent = CardList_GetPosition(pList, &pPrevious, -1);

    if(pPrevious != NULL) {
        pPrevious->pNext = NULL;
    } else { // Lista vazia, carrega NULO
        *pList = NULL;
    }

    // Se achou, pCurrent tera a posicao onde inicia a lista a partir de pCard, senao tera NULO.
    return pCurrent->pCard;
}

void CardList_CreateDeck(CardList **pList, unsigned int uDeckMask)
{
    int iValue;
    if(pList == NULL) return;

    for(iValue=0; (1<<iValue) <= CARD_VALUE_K; iValue++) {
        if(uDeckMask & (1<<iValue)) {
            CardList_InsertCard(pList, Card_Create(1<<iValue, Diamond));
            CardList_InsertCard(pList, Card_Create(1<<iValue, Spade  ));
            CardList_InsertCard(pList, Card_Create(1<<iValue, Heart  ));
            CardList_InsertCard(pList, Card_Create(1<<iValue, Club   ));
        }
    }
}

void CardList_Shuffle(CardList **pList, int iCount)
{
    int iSize;
    CardList *pPrevious, *pStart, *pEnd;

    if(pList == NULL || *pList == NULL) return;

    iSize = CardList_GetSize(pList);
    if(iCount <= 0) {
        iCount = 4*iSize;
    }

    srand(time(NULL));
    while(iCount--) {
        // Carrega posicao inicial aleatoriamente
        pStart = CardList_GetPosition(pList, &pPrevious, rand()%iSize);
        if(pPrevious == NULL) {
            *pList           = pStart->pNext;
        } else {
            pPrevious->pNext = pStart->pNext;
        }

        // Carrega posicao final aleatoriamente
        pEnd = CardList_GetPosition(pList, NULL, rand()%(iSize-1));
        pStart->pNext = pEnd->pNext;
        pEnd  ->pNext = pStart;
    }
}

void CardList_Free(CardList **pList)
{
    CardList *pCurrent;
    if(pList == NULL || *pList == NULL) return;

    while(*pList != NULL) {
        pCurrent = *pList;
        *pList   = pCurrent->pNext;

        Card_Free(pCurrent->pCard);
        free(pCurrent);
    }
}
baralho.h
#ifndef BARALHO_H_INCLUDED
#define BARALHO_H_INCLUDED

#define CARD_VALUE_INVALID 0x0000
#define CARD_VALUE_ACE     0x0001
#define CARD_VALUE_2       0x0002
#define CARD_VALUE_3       0x0004
#define CARD_VALUE_4       0x0008
#define CARD_VALUE_5       0x0010
#define CARD_VALUE_6       0x0020
#define CARD_VALUE_7       0x0040
#define CARD_VALUE_8       0x0080
#define CARD_VALUE_9       0x0100
#define CARD_VALUE_10      0x0200
#define CARD_VALUE_J       0x0400
#define CARD_VALUE_Q       0x0800
#define CARD_VALUE_K       0x1000

#define DECK_TYPE_FULL  (CARD_VALUE_ACE | CARD_VALUE_2 | CARD_VALUE_3 | CARD_VALUE_4 | CARD_VALUE_5  | \
                         CARD_VALUE_6   | CARD_VALUE_7 | CARD_VALUE_8 | CARD_VALUE_9 | CARD_VALUE_10 | \
                         CARD_VALUE_J   | CARD_VALUE_Q | CARD_VALUE_K)

#define DECK_TYPE_TRUCO (CARD_VALUE_ACE | CARD_VALUE_2 | CARD_VALUE_3 | CARD_VALUE_4 | CARD_VALUE_5 | \
                         CARD_VALUE_6   | CARD_VALUE_7 | CARD_VALUE_J | CARD_VALUE_Q | CARD_VALUE_K)

typedef enum { Diamond, Spade, Heart, Club } Suit;

typedef struct {
    int  iValue;
    Suit eSuit;
} Card;

typedef struct strCardList CardList;
struct strCardList {
    Card     *pCard;
    CardList *pNext;
};

// Funcoes referentes a Cartas
Card * Card_Create       (int iValue, Suit eSuit);
void   Card_Free         (Card *pCard);
char * Card_GetSuitString(Card *pCard);
int    Card_GetValue     (Card *pCard);

// Funcoes referentes a Listas de Cartas
CardList * CardList_GetPosition   (CardList **pList, CardList **pRetPrevious, int iPosition);
int        CardList_GetSize       (CardList **pList);
void       CardList_InsertCardList(CardList **pList, CardList *pNew);
void       CardList_InsertCard    (CardList **pList, Card *pCard);
CardList * CardList_GetSubset     (CardList **pList, Card *pCard);
Card     * CardList_GetCard       (CardList **pList);
void       CardList_CreateDeck    (CardList **pList, unsigned int uDeckMask);
void       CardList_Shuffle       (CardList **pList, int iCount);
void       CardList_Free          (CardList **pList);

#endif // BARALHO_H_INCLUDED
paciencia.c
#include <stdio.h>
#include <malloc.h>
#include <string.h>

#include "baralho.h"

#define GAME_SLOT_NUM 7

#define GAME_SLOT_CLOSED 0
#define GAME_SLOT_OPEN   1

typedef struct {
    Card     *pCard;
    CardList *pDeck, *pWaste, *pFoundation[4], *pSlots[GAME_SLOT_NUM][2];
} GameState;

void PrintCard(Card *pCard)
{
    char  szCardString[6];
    char *szCard[] = { "??", " A", " 2", " 3", " 4", " 5", " 6", " 7", " 8", " 9", "10", " J", " Q", " K" }, cSuit = '?';

    if(pCard != NULL) {
        switch(pCard->eSuit) {
            case Diamond: cSuit = 'o'; break;
            case Spade  : cSuit = 's'; break;
            case Heart  : cSuit = 'c'; break;
            case Club   : cSuit = 'p'; break;
        }

        sprintf(szCardString, "|%s%c|", szCard[Card_GetValue(pCard)], cSuit);
    } else {
        strcpy(szCardString, "|   |");
    }

    printf("%s", szCardString);
}

void Game_PrintBoard(GameState **pGame)
{
    int iCount;
    Card *pCard;

    if(pGame == NULL || *pGame == NULL) return;

    printf("Tamanho do baralho: %d\n", CardList_GetSize(&((*pGame)->pDeck)));

    printf("|###| ");
    PrintCard((*pGame)->pCard);
    printf("       ");

    for(iCount=0; iCount<4; iCount++) {
        pCard = NULL;
        if((*pGame)->pFoundation[iCount] != NULL) {
            pCard = (*pGame)->pFoundation[iCount]->pCard;
        }

        PrintCard(pCard);
        printf(" ");
    }

    printf("\n| + | | * |       |(a)| |(b)| |(c)| |(d)|\n\n");

    for(iCount = 0; iCount < GAME_SLOT_NUM; iCount++) {
    }

    printf("\n");
}

GameState * Game_Create(void)
{
    GameState *pGame;
    int iCount, iSlot;

    pGame = (GameState *)malloc(sizeof(GameState));
    if(pGame == NULL) return NULL;

    memset(pGame, 0, sizeof(GameState));

    CardList_CreateDeck(&(pGame->pDeck), DECK_TYPE_FULL);
    CardList_Shuffle   (&(pGame->pDeck), 0);

    for(iSlot = 0; iSlot < GAME_SLOT_NUM; iSlot++) {
        for(iCount = iSlot; iCount > 0; iCount--) {
            pGame->pCard = CardList_GetCard(&(pGame->pDeck));
            CardList_InsertCard(&(pGame->pSlots[iSlot][GAME_SLOT_CLOSED]), pGame->pCard);
        }
    }

    pGame->pCard = CardList_GetCard(&(pGame->pDeck));

    return pGame;
}

int main(void)
{
    GameState *pGame = Game_Create();

    Game_PrintBoard(&pGame);

    return 0;
}

Abraços,

Marcelo Utikawa da Fonseca

Link to comment
Share on other sites

  • 0

Boa tarde!

Depois de muito trabalho eu terminei o jogo! B)

Ainda falta dar a mensagem que terminou o jogo e não permitir mover a carta do baralho para os slots mas já funciona!

Segue o código:

baralho.h

#ifndef BARALHO_H_INCLUDED
#define BARALHO_H_INCLUDED

#define CARD_VALUE_INVALID 0x0000
#define CARD_VALUE_ACE     0x0001
#define CARD_VALUE_2       0x0002
#define CARD_VALUE_3       0x0004
#define CARD_VALUE_4       0x0008
#define CARD_VALUE_5       0x0010
#define CARD_VALUE_6       0x0020
#define CARD_VALUE_7       0x0040
#define CARD_VALUE_8       0x0080
#define CARD_VALUE_9       0x0100
#define CARD_VALUE_10      0x0200
#define CARD_VALUE_J       0x0400
#define CARD_VALUE_Q       0x0800
#define CARD_VALUE_K       0x1000

#define DECK_TYPE_FULL  (CARD_VALUE_ACE | CARD_VALUE_2 | CARD_VALUE_3 | CARD_VALUE_4 | CARD_VALUE_5  | \
                         CARD_VALUE_6   | CARD_VALUE_7 | CARD_VALUE_8 | CARD_VALUE_9 | CARD_VALUE_10 | \
                         CARD_VALUE_J   | CARD_VALUE_Q | CARD_VALUE_K)

#define DECK_TYPE_TRUCO (CARD_VALUE_ACE | CARD_VALUE_2 | CARD_VALUE_3 | CARD_VALUE_4 | CARD_VALUE_5 | \
                         CARD_VALUE_6   | CARD_VALUE_7 | CARD_VALUE_J | CARD_VALUE_Q | CARD_VALUE_K)

typedef enum { Diamond, Spade, Heart, Club } Suit;

typedef struct {
    int  iValue;
    Suit eSuit;
} Card;

typedef struct strCardList CardList;
struct strCardList {
    Card     *pCard;
    CardList *pNext;
};

// Funcoes referentes a Cartas
Card * Card_Create       (int iValue, Suit eSuit);
void   Card_Free         (Card *pCard);
char * Card_GetSuitString(Card *pCard);
int    Card_IsBlack      (Card *pCard);
int    Card_GetValue     (Card *pCard);

// Funcoes referentes a Listas de Cartas
CardList * CardList_GetPosition   (CardList **pList, CardList **pRetPrevious, int iPosition);
int        CardList_GetSize       (CardList **pList);
void       CardList_InsertCardList(CardList **pList, CardList *pNew);
void       CardList_InsertCard    (CardList **pList, Card *pCard);
CardList * CardList_GetSubset     (CardList **pList, Card *pCard);
Card     * CardList_GetCard       (CardList **pList);
void       CardList_CreateDeck    (CardList **pList, unsigned int uDeckMask);
void       CardList_Shuffle       (CardList **pList, int iCount);
void       CardList_Free          (CardList **pList);

#endif // BARALHO_H_INCLUDED
baralho.c
#include <time.h>
#include <stdlib.h>
#include <malloc.h>

#include "baralho.h"

Card * Card_Create(int iValue, Suit eSuit)
{
    Card *pNew = (Card *)malloc(sizeof(Card));

    if(pNew != NULL) {
        pNew->iValue = iValue;
        pNew->eSuit  = eSuit;
    }

    return pNew;
}

void Card_Free(Card *pCard)
{
    if(pCard != NULL) {
        free(pCard);
    }
}

int Card_GetValue(Card *pCard)
{
    int iValue;

    if(pCard != NULL) {
        for(iValue = 0; iValue < CARD_VALUE_K; iValue++) {
            if(pCard->iValue == (1<<iValue)) {
                return iValue+1;
            }
        }
    }

    return CARD_VALUE_INVALID;
}

char * Card_GetSuitString(Card *pCard)
{
    if(pCard != NULL) {
        switch(pCard->eSuit) {
            case Diamond: return "Ouros" ;
            case Spade  : return "Espadas";
            case Heart  : return "Copas" ;
            case Club   : return "Paus"  ;
        }
    }

    return "";
}

int Card_IsBlack(Card *pCard)
{
    if(pCard != NULL && (pCard->eSuit == Spade || pCard->eSuit == Club)) return 1;

    return 0;
}

CardList * CardList_GetPosition(CardList **pList, CardList **pRetPrevious, int iPosition)
{
    CardList *pCurrent, *pPrevious = NULL;
    if(pList == NULL || *pList == NULL) return NULL;

    pCurrent = *pList;

    while(pCurrent != NULL) {
        if(iPosition < 0 && pCurrent->pNext == NULL) break; // Encontrou ultimo item
        if(iPosition-- == 0) break; // Encontrou item procurado

        pPrevious = pCurrent;
        pCurrent = pCurrent->pNext;
    }

    if(pRetPrevious != NULL) {
        if(pCurrent != NULL) {
            *pRetPrevious = pPrevious;
        } else {
            *pRetPrevious = NULL;
        }
    }

    return pCurrent;
}

int CardList_GetSize(CardList **pList)
{
    int iSize = 0;
    CardList *pCurrent;

    if(pList != NULL && *pList != NULL) {
        pCurrent = *pList;
        while(pCurrent != NULL) {
            iSize++;
            pCurrent = pCurrent->pNext;
        }
    }

    return iSize;
}

void CardList_InsertCardList(CardList **pList, CardList *pNew)
{
    CardList *pCurrent;
    if(pList == NULL || pNew == NULL) return;

    if(*pList == NULL) {
        *pList = pNew;
    } else {
        pCurrent = CardList_GetPosition(pList, NULL, -1);
        pCurrent->pNext = pNew;
    }
}

void CardList_InsertCard(CardList **pList, Card *pCard)
{
    CardList *pNew;
    if(pList == NULL || pCard == NULL) return;

    pNew = (CardList *)malloc(sizeof(CardList));
    pNew->pCard = pCard;
    pNew->pNext = NULL;

    CardList_InsertCardList(pList, pNew);
}

CardList * CardList_GetSubset(CardList **pList, Card *pCard)
{
    CardList *pCurrent, *pPrevious = NULL;
    if(pList == NULL || *pList == NULL || pCard == NULL) return NULL;

    pCurrent = *pList;
    while(pCurrent != NULL) {
        if(pCurrent->pCard->iValue == pCard->iValue && pCurrent->pCard->eSuit == pCard->eSuit) {
            break; // Achou a carta!
        } else {
            pPrevious = pCurrent;
            pCurrent = pCurrent->pNext;
        }
    }

    if(pPrevious != NULL) {
        pPrevious->pNext = NULL;
    } else if(pCurrent != NULL) {
        *pList = NULL;
    }

    // Se achou, pCurrent tera a posicao onde inicia a lista a partir de pCard, senao tera NULO.
    return pCurrent;
}

Card * CardList_GetCard(CardList **pList)
{
    Card     *pCard = NULL;
    CardList *pCurrent, *pPrevious = NULL;
    if(pList == NULL || *pList == NULL) return NULL;

    pCurrent = CardList_GetPosition(pList, &pPrevious, -1);

    if(pPrevious != NULL) {
        pPrevious->pNext = NULL;
    } else { // Lista vazia, carrega NULO
        *pList = NULL;
    }

    // Se achou, pCurrent tera a posicao onde inicia a lista a partir de pCard, senao tera NULO.
    if(pCurrent != NULL) {
        pCard = pCurrent->pCard;
        free(pCurrent);
    }

    return pCard;
}

void CardList_CreateDeck(CardList **pList, unsigned int uDeckMask)
{
    int iValue;
    if(pList == NULL) return;

    for(iValue=0; (1<<iValue) <= CARD_VALUE_K; iValue++) {
        if(uDeckMask & (1<<iValue)) {
            CardList_InsertCard(pList, Card_Create(1<<iValue, Diamond));
            CardList_InsertCard(pList, Card_Create(1<<iValue, Spade  ));
            CardList_InsertCard(pList, Card_Create(1<<iValue, Heart  ));
            CardList_InsertCard(pList, Card_Create(1<<iValue, Club   ));
        }
    }
}

void CardList_Shuffle(CardList **pList, int iCount)
{
    int iSize;
    CardList *pPrevious, *pStart, *pEnd;

    if(pList == NULL || *pList == NULL) return;

    iSize = CardList_GetSize(pList);
    if(iCount <= 0) {
        iCount = 4*iSize;
    }

    srand(time(NULL));
    while(iCount--) {
        // Carrega posicao inicial aleatoriamente
        pStart = CardList_GetPosition(pList, &pPrevious, rand()%iSize);
        if(pPrevious == NULL) {
            *pList           = pStart->pNext;
        } else {
            pPrevious->pNext = pStart->pNext;
        }

        // Carrega posicao final aleatoriamente
        pEnd = CardList_GetPosition(pList, NULL, rand()%(iSize-1));
        pStart->pNext = pEnd->pNext;
        pEnd  ->pNext = pStart;
    }
}

void CardList_Free(CardList **pList)
{
    CardList *pCurrent;
    if(pList == NULL || *pList == NULL) return;

    while(*pList != NULL) {
        pCurrent = *pList;
        *pList   = pCurrent->pNext;

        Card_Free(pCurrent->pCard);
        free(pCurrent);
    }
}
paciencia.c
#include <stdio.h>
#include <malloc.h>
#include <string.h>

#include "baralho.h"

#define GAME_SLOT_NUM 7

#define GAME_SLOT_CLOSED 0
#define GAME_SLOT_OPEN   1

#define GAME_CMD_NONE     0
#define GAME_CMD_QUIT     1
#define GAME_CMD_CARD_NEW 2
#define GAME_CMD_MOVE     3

#define GAME_KEY_CARD_NEW  '+'
#define GAME_KEY_CARD_OPEN '*'
#define GAME_KEY_QUIT      'X'

#define CARD_STRING_CLOSED "|###|"
#define CARD_STRING_EMPTY  "|   |"
#define CARD_STRING_NONE   "     "

#define CARD_REF_INVALID    0
#define CARD_REF_OPEN       1
#define CARD_REF_FOUNDATION 2
#define CARD_REF_SLOT       3

typedef struct {
    Card     *pCard;
    CardList *pDeck, *pWaste, *pFoundation[4], *pSlots[GAME_SLOT_NUM][2];
} GameState;

typedef struct {
    int iRef;
    int iColumn;
    int iIndex;
} GameCardRef;

void PrintCard(Card *pCard)
{
    char  szCardString[6];
    char *szCard[] = { "??", " A", " 2", " 3", " 4", " 5", " 6", " 7", " 8", " 9", "10", " J", " Q", " K" }, cSuit = '?';

    if(pCard != NULL) {
        switch(pCard->eSuit) {
            case Diamond: cSuit = 'o'; break;
            case Spade  : cSuit = 's'; break;
            case Heart  : cSuit = 'c'; break;
            case Club   : cSuit = 'p'; break;
        }

        sprintf(szCardString, "|%s%c|", szCard[Card_GetValue(pCard)], cSuit);
    } else {
        strcpy(szCardString, CARD_STRING_EMPTY);
    }

    printf("%s", szCardString);
}

void Game_PrintBoard(GameState **pGame)
{
    Card     *pCard;
    CardList *pSlotList;
    int iCount, iSlotSize[GAME_SLOT_NUM], iSlot, iCardPrinted;

    if(pGame == NULL || *pGame == NULL) return;

    printf("\n\n");

    if(CardList_GetSize(&(*pGame)->pDeck) > 0) {
        printf("%s ", CARD_STRING_CLOSED);
    } else {
        printf("%s ", CARD_STRING_EMPTY );
    }

    PrintCard((*pGame)->pCard);
    printf(" %s ", CARD_STRING_NONE);

    for(iCount=0; iCount<4; iCount++) {
        pCard = NULL;
        if((*pGame)->pFoundation[iCount] != NULL) {
            pCard = CardList_GetPosition(&(*pGame)->pFoundation[iCount], NULL, -1)->pCard;
        }

        PrintCard(pCard);
        printf(" ");
    }

    printf("\n|(+)| |(*)|       |(a)| |(b)| |(c)| |(d)|\n\n");

    for(iSlot = 0; iSlot < GAME_SLOT_NUM; iSlot++) {
        printf("|(%d)| ", iSlot);
        iSlotSize[iSlot] = CardList_GetSize(&(*pGame)->pSlots[iSlot][GAME_SLOT_CLOSED]);
    }

    printf("\n");

    iCount = 0;
    do {
        iCardPrinted = 0;
        
        for(iSlot = 0; iSlot < GAME_SLOT_NUM; iSlot++) {
            if(iCount < iSlotSize[iSlot]) {
                iCardPrinted = 1;
                printf("%s ", CARD_STRING_CLOSED);
            } else {
                pSlotList = CardList_GetPosition(&(*pGame)->pSlots[iSlot][GAME_SLOT_OPEN], NULL, iCount - iSlotSize[iSlot]);
                if(pSlotList != NULL) {
                    iCardPrinted = 1;
                    PrintCard(pSlotList->pCard);
                    printf(" ");
                } else {
                    printf("%s ", CARD_STRING_NONE);
                }
            }
        }

        iCount++;
        printf("\n");
    } while(iCardPrinted);

    printf("\n");
}

GameState * Game_Create(void)
{
    GameState *pGame;
    int iCount, iSlot;

    pGame = (GameState *)malloc(sizeof(GameState));
    if(pGame == NULL) return NULL;

    memset(pGame, 0, sizeof(GameState));

    CardList_CreateDeck(&(pGame->pDeck), DECK_TYPE_FULL);
    CardList_Shuffle   (&(pGame->pDeck), 0);

    for(iSlot = 0; iSlot < GAME_SLOT_NUM; iSlot++) {
        pGame->pCard = CardList_GetCard(&(pGame->pDeck));
        CardList_InsertCard(&(pGame->pSlots[iSlot][GAME_SLOT_OPEN]), pGame->pCard);
        for(iCount = iSlot; iCount > 0; iCount--) {
            pGame->pCard = CardList_GetCard(&(pGame->pDeck));
            CardList_InsertCard(&(pGame->pSlots[iSlot][GAME_SLOT_CLOSED]), pGame->pCard);
        }
    }

    pGame->pCard = CardList_GetCard(&(pGame->pDeck));

    return pGame;
}

CardList ** Game_GetCardList(GameState *pGame, GameCardRef *pRef)
{
    if(pGame != NULL && pRef != NULL) {
        switch(pRef->iRef) {
            case CARD_REF_FOUNDATION:
                if(pRef->iColumn >= 0 && pRef->iColumn < 4)
                    return &pGame->pFoundation[pRef->iColumn];
                break;

            case CARD_REF_SLOT:
                if(pRef->iColumn >= 0 && pRef->iColumn < GAME_SLOT_NUM)
                    return &pGame->pSlots[pRef->iColumn][GAME_SLOT_OPEN];
                break;
        }
    }

    return NULL;
}

int Game_CanMove(Card *pFromCard, Card *pToCard, int iToRef)
{
    int iCanMove = 0, iFromIsBlack, iToIsBlack;

    if(pFromCard != NULL) {
        iFromIsBlack = Card_IsBlack(pFromCard);
        iToIsBlack   = Card_IsBlack(pToCard  );

        if(iToRef == CARD_REF_FOUNDATION) {
            if(pToCard == NULL && Card_GetValue(pFromCard) == CARD_VALUE_ACE) {
                iCanMove = 1;
            } else if(Card_GetValue(pFromCard) == Card_GetValue(pToCard)+1 &&
                    pFromCard->eSuit == pToCard->eSuit) {
                iCanMove = 1;
            }
        } else if(iToRef == CARD_REF_SLOT) {
            if(pToCard == NULL) {
                iCanMove = 1;
            } else if(Card_GetValue(pFromCard) == Card_GetValue(pToCard)-1 &&
                  iFromIsBlack != iToIsBlack) {
                iCanMove = 1;
            }
        }
    }

    return iCanMove;
}

void Game_ProcessCommand(GameState **pGame, int iCommand, GameCardRef *pFrom, GameCardRef *pTo)
{
    int iCount;
    Card      *pFromCard,  *pToCard;
    CardList **pFromList, **pToList;
    if(pGame == NULL || *pGame == NULL || pFrom == NULL) return;

    switch(iCommand) {
        case GAME_CMD_CARD_NEW:
            if(pFrom->iRef == CARD_REF_OPEN) {
                if((*pGame)->pCard != NULL) {
                    CardList_InsertCard(&(*pGame)->pWaste, (*pGame)->pCard);
                }

                if(CardList_GetSize(&(*pGame)->pDeck) == 0) {
                    for(iCount = CardList_GetSize(&(*pGame)->pWaste); iCount > 0; iCount--) {
                        CardList_InsertCard(&(*pGame)->pDeck, CardList_GetCard(&(*pGame)->pWaste));
                    }
                }

                (*pGame)->pCard = CardList_GetCard(&(*pGame)->pDeck);
            } else if(pFrom->iRef == CARD_REF_SLOT) {
                pFromList = Game_GetCardList(*pGame, pFrom);
                if(pFromList != NULL && *pFromList == NULL) {
                    pFromCard = CardList_GetCard(&(*pGame)->pSlots[pFrom->iColumn][GAME_SLOT_CLOSED]);
                    if(pFromCard != NULL)
                        CardList_InsertCard(pFromList, pFromCard);
                }
            }

            break;

        case GAME_CMD_MOVE:
            if(pTo == NULL || pTo->iRef == CARD_REF_OPEN) break;

            pToList = Game_GetCardList(*pGame, pTo);

            pFromCard = NULL;
            pToCard   = NULL;
            pFromList = NULL;

            if(pToList != NULL) {
                if(*pToList != NULL) {
                    pToCard = CardList_GetPosition(pToList, NULL, -1)->pCard;
                }

                if(pFrom->iRef == CARD_REF_OPEN) {
                    pFromCard = (*pGame)->pCard;
                } else {
                    pFromList = Game_GetCardList(*pGame, pFrom);

                    if(pFromList != NULL && *pFromList != NULL) {
                        if(*pToList != NULL) {
                            iCount = CardList_GetSize(pFromList);
                            while(iCount-- > 0) {
                                pFromCard = CardList_GetPosition(pFromList, NULL, iCount)->pCard;
                                if(Game_CanMove(pFromCard, pToCard, pTo->iRef))
                                    break;
                            }
                            if(iCount < 0) {
                                pFromCard = NULL;
                            }
                        } else {
                            pFromCard = CardList_GetPosition(pFromList, NULL, pTo->iRef == CARD_REF_SLOT ? 0 : -1)->pCard;
                            if(pTo->iRef == CARD_REF_SLOT && Card_GetValue(pFromCard) != 13) {
                                pFromCard = NULL;
                            }
                        }
                    }
                }
            }

            if(pFromCard != NULL && pToList != NULL && Game_CanMove(pFromCard, pToCard, pTo->iRef)) {
                if(pFromList != NULL) {
                    CardList_InsertCardList(pToList, CardList_GetSubset(pFromList, pFromCard));
                } else {
                    CardList_InsertCard(pToList, pFromCard);
                }

                if(pFrom->iRef == CARD_REF_OPEN) {
                    (*pGame)->pCard = CardList_GetCard(&(*pGame)->pWaste);
                    if((*pGame)->pCard == NULL) {
                        Game_ProcessCommand(pGame, GAME_CMD_CARD_NEW, NULL, NULL);
                    }
                }
            }
    }
}

void Game_GetRefFromKey(GameCardRef *pRef, char cKey)
{
    if(pRef == NULL) return;

    if(cKey >= '0' && cKey <= '9') { // Maximo: 10 slots
        cKey -= '0';
        if(cKey < GAME_SLOT_NUM) {
            pRef->iRef    = CARD_REF_SLOT;
            pRef->iColumn = cKey;
        }
    } else if(cKey >= 'a' && cKey <= 'd') {
        pRef->iRef    = CARD_REF_FOUNDATION;
        pRef->iColumn = cKey - 'a';
    } else if(cKey == GAME_KEY_CARD_OPEN) {
        pRef->iRef    = CARD_REF_OPEN;
        pRef->iColumn = 0;
    } else {
        pRef->iRef = CARD_REF_INVALID;
    }
}

int main(void)
{
    char        cKey;
    int         iCommand = GAME_CMD_QUIT;
    GameState   *pGame = Game_Create();
    GameCardRef tFrom, tTo;

    do {
        Game_PrintBoard(&pGame);

        printf("Digite o comando e pressione ENTER: ");
        cKey = getchar();

        iCommand = GAME_CMD_NONE;
        switch(cKey) {
            case GAME_KEY_CARD_NEW:
                iCommand = GAME_CMD_CARD_NEW;
                Game_GetRefFromKey(&tFrom, GAME_KEY_CARD_OPEN);
                break;

            case GAME_KEY_QUIT:
                iCommand = GAME_CMD_QUIT;
                break;

            case '\n':
            case '\r':
                break;

            default:
                Game_GetRefFromKey(&tFrom, cKey);
                if(tFrom.iRef != CARD_REF_INVALID) {
                    cKey = getchar();
                    if(cKey == '\n') {
                        if(tFrom.iRef == CARD_REF_SLOT)
                            iCommand = GAME_CMD_CARD_NEW;
                    } else {
                        Game_GetRefFromKey(&tTo, cKey);
                        if(tTo.iRef != CARD_REF_INVALID) {
                            iCommand = GAME_CMD_MOVE;
                        }
                    }
                }
                if(iCommand == GAME_CMD_NONE)
                    printf("\n\nComando invalido!\n\n");

                break;
        }

        Game_ProcessCommand(&pGame, iCommand, &tFrom, &tTo);

        while(cKey != '\n') {
            cKey = getchar();
        }
    } while(iCommand != GAME_CMD_QUIT);

    return 0;
}

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Answer this question...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.



  • Forum Statistics

    • Total Topics
      152k
    • Total Posts
      651.5k
×
×
  • Create New...