Jogo Paciência - Linguagem C

[juniorfv]

Meu código para um programa de paciência está apresentando os seguintes erros:

C:\Users\Pc\Documents\CS350B\teste.cpp    In function 'Informacao* novaInformacao(int, int)':
47    35    C:\Users\Pc\Documents\CS350B\teste.cpp    [Error] invalid conversion from 'void*' to 'Informacao*' [-fpermissive]
C:\Users\Pc\Documents\CS350B\teste.cpp    In function 'void inicializaPaciencia()':
421    40    C:\Users\Pc\Documents\CS350B\teste.cpp    [Error] invalid conversion from 'void*' to 'Informacao**' [-fpermissive]

 

alguém poderia me ajudar? Segue o Codigo do programa:

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

 

/* Pilha, marca o comeco e o fim da pilha num vetor */
typedef struct {
   int comeco;
   int ocultas;      /* marcas as cartas ocultas, ajuda na hora de ver o comeco e o fim das cartas não ocultas */
   int fim;
   /* algumas flags para as pilhas, ajudam na hora de ficar fazendo procura de jogadas */
   int podeEntrar;   /* diz se existe algum monte na pilha de jogo pode ou não entrar nessa pilha */
   int podeSair;     /* diz se esse monte pode entrar ou não em alguma pilha de jogo ou pilha final */
} Pilha;

 

/* minha definicao de carta:
 * um inteiro, entre 0 e 51
 * para saber o simbola da carta c (valor) basta pegar (c%13 + 1)
 * onde 1 representa A, 2 = 2 ... 10 = 10 , 11 = J, 12 = Q, 13 = K
 * para saber o naipe da carta c basta pegar c/13 
 * onde 0 = ouro, 1 = espada, 2 = copas, 3 = paus
 * 
 * Vantagens dessa organizacao:
 * 
 * Saber se as cartas a e b são da mesma cor
 *    (a/13)%2 == (b/13)%2
 *
 * Saber se a carta a pode ser colocada em acima da carta b, na pilha de jogo
 *  ser um simbolo a menos e   cor diferente 
 *    (a%13 == (b%13 -1)) && (a/13)%2 != (b/13)%2
 */

/* Carta é um inteiro, apenas a posicao do meu vetor onde está suas informacoes */
typedef int Carta;

/* estrutura que contem informacao sobre a carta */
typedef struct {
   int valor;      /* valor da carta, descrito acima                                        */
   int virada;     /* se 1, a carta ta virada, se 0 a carta não pode ser vista pelo jogador */
   Pilha *pilha;   /* ponteiro para a pilha que a carta pertence                            */
} Informacao;

Informacao *novaInformacao(int valor, int virada) {
   Informacao *i = malloc(sizeof*i);
   i->valor = valor;
   i->virada = virada;
   i->pilha = NULL;
   return i;
}

Informacao **baralho;
/* um vetor de ponteiros para Informacao é o meu baralho */

/* para facilitar algumas coisas no programa,
 * vou deixar as estruturas de pilhas e o vetor 
 * como variaveis globais */

Pilha pilhaJogo[7];

/* Como não é permitido tirar cartas da pilha de saida,
 * para deixar mais rapido, vou deixa-los todos numa unica pilha
 * e guardar apenas quem foi o ultimo colocado de cada naipe */
Pilha pilhaSaida;    

int podeSaida[4];   /* diz se o cara da saida pode receber cartas */
int ultimoSaida[4]; /* diz a ultima carta da saida                */

/* Para quem já jogou paciencia, 
 * é intuitivo que as pilhas de estoque e de descarte
 * são as que ficam maiores durante o jogo.
 * Como o espaco para todas as pilhas é apenas de 60, tudo junto
 * faz sentido querer alterar as pilhas de estoque e de descarta a 
 * menor quantidade de vezes possiveis, então vou colocalas nas pontas
 * ou seja, a pilha de descarte vai sempre terminar no 0
 * e a pilha de estoque no 59.
 * Olhando de outra menira, se a pilha de descarte termina em n, 
 * e a pilha de estoque termina em m
 * eu vou organizar as outras pilhas entre n+1 e m-1
 */

Pilha estoqueDescarte;  /* estoque e descarta */

/* assinaturas de algumas funcoes uteis */

/* responde se pode mover uma carta, para uma pilha */
int podeMoverCarta(Carta carta, Pilha b);

/* responde se pode mover a pilha a, para a pilha b */
int podeMoverPilha(Pilha a, Pilha b);

/* procura no no Topo de uma pilha de jogo a carta de valor dado */
int procuraTopo(int valor, Pilha pilha); 

/* responde se a carta pode ser colocada no topo ou não */
int podeSair(int valor);

/* coloca a ultima carta de uma Pilha de Jogo numa das pilhas finais */
void mudaFinal(Pilha *pilha);

/* coloca uma pilha na outra */
void movePilha(Pilha *a, Pilha *b);

/* coloca uma carta em uma determinada posicao do baralho */
void moveCarta(Informacao *carta, int posicao, int meio);

/* move da pilha de descarta para a pilha de Saida */
void moveSairDescarte();

/* pega uma carta da pilha de estoque e coloca na pilha de descarte */
void pescaGrimorio();

/* imprime o jogo */
void imprimeJogo();

/* imprime a pilha de Estoque e de Descarte */
void imprimeEstoqueDescarta();

/* inicializa o jogo */
void inicializaPaciencia();

/* imprime uma pilha */
void imprimePilha(Pilha pilha);

/* imprime uma pilha de saida */
void imprimeSaida(int pilha);

/* imprime uma carta */
void imprimeCarta(int valor, int virada);

 

/* responde se pode mover uma carta, para uma pilha */
int podeMoverCarta(Carta carta, Pilha b) {
   Carta topoB = b.fim - 1;
   int va = baralho[carta]->valor, vb ;
   /* se for um reis */
   if(baralho[carta]->valor%13 == 12) {      
      /* se b estiver vazio pode mover um Reis */
      if(b.comeco == b.fim)
     return 1;
      return 0;
   }

   /* se b estiver vazia não pode */
   if(b.comeco == b.fim)
      return 0;
   vb = baralho[topoB]->valor;

   /* verifica se a carta pode ir em b */
   if(va%13 == (vb%13-1) && (va/13)%2 != (vb/13)%2)
      return 1;
   return 0;
}

/* responde se pode mover a pilha a, para a pilha b */
int podeMoverPilha(Pilha a, Pilha b) {
   Carta comecoA  = a.comeco + a.ocultas; /* comeco de A despresando as cartas ocultas */
   
   /* se a pilha a estiver vazia, ela não pode ser movida pra lugar nenhum */
   if(a.comeco == a.fim)
      return 0;

   /* se for um reis */
   if(baralho[comecoA]->valor%13 == 12 && a.comeco == comecoA) {
      /* não faz sentido removar o Reis de A e deixar o A vazio */
      return 0;
   }
   return podeMoverCarta(comecoA, b);
}

/* procura no no Topo de uma pilha de jogo a carta de valor dado */
int procuraTopo(int valor, Pilha pilha) {
   Carta topo = pilha.fim - 1;
   /* se a pilha estiver vazia, a carta não está nela */   
   if(pilha.comeco == pilha.fim)
      return 0;
   
   return baralho[topo]->valor == valor;   
}

/* responde se a carta pode ser colocada no topo ou não */
int podeSair(int valor) {
   int naipe = valor/13;   
   if(ultimoSaida[naipe] == valor%13)
      return 1;
   return 0;
}

/* coloca a ultima carta de uma Pilha de Jogo numa das pilhas finais */
void mudaFinal(Pilha *pilha) {
   Carta topo = pilha->fim -1;
   baralho[topo]->pilha = &pilhaSaida;
   pilha->fim--;
   
   ultimoSaida[(baralho[topo]->valor)/13]++;
   if(ultimoSaida[(baralho[topo]->valor)/13] != 13)
      podeSaida[(baralho[topo]->valor)/13] = 1; /* como mudei o topo da pilha, eu digo que agora alguém pode entrar */
   else
      podeSaida[(baralho[topo]->valor)/13] = 0; /* se chegou um reis, não pode entrar mais aqui */

   /* se não tem mais cartas mostradas na pilha e ainda tem cartas na pilha*/
   if(pilha->fim == (pilha->comeco + pilha->ocultas) && pilha->fim != pilha->comeco) {      
      pilha->ocultas--;
      topo = pilha->fim -1;
      baralho[topo]->virada = 1;     
   }   
}

int procuraVazio() {
   int i;
   for(i=0;i<60;i++)
      if(baralho==NULL)
     break;
   return i;       
}
/* coloca uma pilha na outra */
void movePilha(Pilha *a, Pilha *b) {
   Pilha auxiliar;
   int i, vazio;
   auxiliar.fim = a->fim;
   auxiliar.comeco = a->comeco + a->ocultas;
   
   a->fim = a->comeco + a->ocultas;
   if(a->ocultas) {
      baralho[a->comeco + a->ocultas]->virada = 1;
      a->ocultas--;
   }
   
   for(i=auxiliar.comeco;i<auxiliar.fim;i++) {
      baralho->pilha = &auxiliar;
   }
   for(i=auxiliar.fim-1;i>=auxiliar.comeco;i--) {
      Informacao *carta = baralho;
      baralho = NULL;
      carta->pilha = b;
      
      /* caso b seja vazio */
      if(b->fim == b->comeco) {
     vazio = procuraVazio();
     b->fim = vazio + 1;
     b->comeco = vazio;
     b->ocultas = 0;
     baralho[vazio] = carta;
     continue;
      }
      
      moveCarta(carta, b->fim, 1);      
   }
   b->podeEntrar = a->podeEntrar;
   b->podeSair = a->podeSair || b->podeSair;
   a->podeEntrar = 1;
   a->podeSair = 1;
}

/* coloca uma carta em uma determinada posicao do baralho */
void moveCarta(Informacao *carta, int posicao, int meio) {
   Informacao *proxima;
  
   
   int mesmaPilha, proximaPosicao = posicao + 1;  

   if(posicao == estoqueDescarte.comeco) {
      moveCarta(carta, estoqueDescarte.fim, meio);
      return;
   }

   if(carta->pilha==&pilhaSaida) {
      posicao = procuraVazio();
      baralho[posicao] = carta;
      return;
   }
   
   carta->pilha->fim = posicao+1;

   /* lugar vago */
   if(baralho[posicao]==NULL) {
      baralho[posicao]=carta;
      return;
   } else {
      mesmaPilha = baralho[posicao]->pilha == carta->pilha;
      proxima = baralho[posicao];
      imprimeCarta(proxima->valor, 1);
      if(!mesmaPilha) {     
     proxima->pilha->comeco = proximaPosicao;
      }

      baralho[posicao] = carta;
      moveCarta(proxima, proximaPosicao, mesmaPilha);
   }

}
/* move da pilha de descarta para a pilha de Saida */
void moveSairDescarte() {
   int valor = baralho[estoqueDescarte.fim -1]->valor;
   baralho[estoqueDescarte.fim -1]->pilha = &pilhaSaida;
   ultimoSaida[valor/13]+=1;
   podeSaida[valor/13]=1;

   estoqueDescarte.fim--;
}

/* pega uma carta da pilha de estoque e coloca na pilha de descarte */
void pescaGrimorio() {
   Informacao *carta = baralho[estoqueDescarte.fim];

   /* ver se tem carta pra pescar */
   if(estoqueDescarte.comeco == 59)
      return;

   baralho[estoqueDescarte.fim] = baralho[estoqueDescarte.comeco + 1];
   baralho[estoqueDescarte.fim]->virada = 1;
   baralho[estoqueDescarte.comeco + 1] = NULL;
   if(carta!=NULL) {
      if(baralho[estoqueDescarte.comeco-1]==NULL || baralho[estoqueDescarte.comeco-1]->pilha != carta->pilha) {    
     carta->pilha->comeco = estoqueDescarte.fim +1;
      }
      imprimeCarta(carta->valor, 1);
     
      moveCarta(carta, estoqueDescarte.fim + 1, 1);
   } 
   estoqueDescarte.fim++;
   estoqueDescarte.comeco++;
}

/* imprime o jogo */
void imprimeJogo() {
   int i;
   printf("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\n");
   imprimeEstoqueDescarta();
   printf("\nPilhas de Jogo\n");
   for(i=0;i<7;i++) {
      printf("%d : ",i+1);
      imprimePilha(pilhaJogo);
   }
   printf("\nPilhas de Saida\n");
   for(i=0;i<4;i++) {
      imprimeSaida(i);      
   }  
   printf("--\n");
}

/* imprime a pilha de Estoque e de Descarte */
void imprimeEstoqueDescarta() {
   int i;
   printf("Pilha de Estoque\n");
   for(i=59;i>estoqueDescarte.comeco;i--) {
      imprimeCarta(baralho->valor, baralho->virada);
      printf(" ");
   }
   printf("\n\n");
   printf("Pilha de Descarte\n");
   for(i=0;i<estoqueDescarte.fim;i++) {
      imprimeCarta(baralho->valor, baralho->virada);
      printf(" ");
   }
   printf("\n\n");
} 

/* imprime uma pilha */
void imprimePilha(Pilha pilha) {
   int i;
   for(i=pilha.comeco;i<pilha.fim;i++) {
      imprimeCarta(baralho->valor, baralho->virada);
      printf(" ");
   }
   printf("\n");
}

/* imprime uma pilha de saida */
void imprimeSaida(int pilha) {
   int i;
   for(i=0;i<ultimoSaida[pilha];i++) {
      imprimeCarta(pilha*13 + i, 1);
      printf(" ");
   }      
   printf("\n");
}

/* imprime uma carta */

   char getNaipe(int valor) {
      if(valor/13 == 0)
     return 'O';
      if(valor/13 == 1)
     return 'E';
      if(valor/13 == 2)
     return 'C';
      return 'P';
   }
void imprimeCarta(int valor, int virada) {
   printf("[%2d%c %c]",valor%13+1, getNaipe(valor), virada ? ' ' : 'X');
}

void atualizaPilha(int pi, int pf, int pilha) {
   for(;pi<=pf;pi++) {
      baralho[pi]->pilha = &pilhaJogo[pilha];
   }
}
/* inicializa o jogo */
void inicializaPaciencia() {
   int cartas[52], i, pos, aux;

   for(i=0;i<52;i++) /* incializando */
      cartas = i;

   /* embaralhando */
   for(i=0;i<51;i++) {
      pos = i + rand()%(52 - i);
      aux = cartas;
      cartas = cartas[pos];
      cartas[pos] = aux;
   }

   baralho = malloc(60*(sizeof*baralho));

   for(i=1;i<=52;i++) {
      baralho[60 - i] = novaInformacao(cartas[i-1], 0);      
   }
   for(;i<=60;i++)
      baralho[60 - i] = NULL;

   pos = 35;

   for(i=0;i<7;i++) { /* incializando pilhas de jogo */
      pilhaJogo.comeco  = pos - i;
      pilhaJogo.fim     = pos + 1;
      pilhaJogo.ocultas = i;
      pilhaJogo.podeSair = 1;
      pilhaJogo.podeEntrar = 1;
      atualizaPilha(pos - i, pos, i);
      baralho[pilhaJogo.comeco + pilhaJogo.ocultas]->virada = 1;
      pos-=(i+1);
   }   

   estoqueDescarte.comeco = 35;
   estoqueDescarte.fim = 0;

   for(i=0;i<4;i++) {
      podeSaida = 1;
      ultimoSaida = 0;
   }

}

/* funcao que joga o paciencia */
void jogar() { 
   int i,j, houveMovimento; 
   /* a variavel houveMovimento serve para garantir que só faco uma jogada a cada iteracao do meu laco */
   while(1) {

      if(estoqueDescarte.fim == 0) 
     pescaGrimorio();

      imprimeJogo();
      houveMovimento = 0;

      /* passo 1, verifico se algum monte final quer carta */
      for(i=0;i<4 && !houveMovimento ;i++) {
     /* se a quer receber carta */
     if(podeSaida == 1) {
        for(j=0;j<7;j++) { /* procuro na pilha de jogo */
           if(procuraTopo(i*13 + ultimoSaida,pilhaJogo[j])) {
          printf("Colocar carta da pilha %d para pilha final\n",j+1);
          mudaFinal(&pilhaJogo[j]); /* coloca o topo de j em i */
          houveMovimento = 1;
          break;
           }
        }
        if(!houveMovimento)
           podeSaida = 0; /* se ninguém quis entrar em Saida i, eu anoto isso */
     }        
      }

      if(houveMovimento)
     continue;

      /* passo 2 do jogo, procuro alguma pilha que pode ser movida para outra */
      for(i=0;i<7 && !houveMovimento ;i++) {     
     if(pilhaJogo.podeSair) {
        /* se pode sair então procuro algum monte pra ele ir */
        for(j=0;j<7;j++) {
           if(j!=i && podeMoverPilha(pilhaJogo, pilhaJogo[j]) ) {
          printf("Colocar pilha %d na pilha %d\n", i+1, j+1);
          movePilha(&pilhaJogo, &pilhaJogo[j]);
          houveMovimento = 1;
          break;
           }
        }        
        if(!houveMovimento && podeSair( baralho[pilhaJogo.comeco + pilhaJogo.ocultas]->valor) )
        {
           mudaFinal(&pilhaJogo);
           houveMovimento = 1;
           break;
        }
        if(!houveMovimento)
           pilhaJogo.podeSair = 0; /* se ninguém aceitou essa pilha eu anoto isso */
     }
     if(pilhaJogo.podeEntrar && !houveMovimento) {
        /* se pode entrar então procuro alguém pra vir */
        for(j=0;j<7;j++) {
           if(j!=i && podeMoverPilha(pilhaJogo, pilhaJogo) ) {
          printf("Movendo da pilha %d pra pilha %d\n", j,i);
          movePilha(&pilhaJogo[j], &pilhaJogo);
          houveMovimento = 1;
          break;
           }
        }
        if(!houveMovimento)
           pilhaJogo.podeEntrar = 0; /* se ninguém entrou na minha pilha eu anoto isso tambem */
     }
      }

      if(houveMovimento)
     continue;

      /* passo 3, verificar se a pilha de descarta pode ir pra algum lugar */
      if(estoqueDescarte.fim != 0) { /* se a pilha de descarte não esta vazia */
     imprimeCarta(baralho[estoqueDescarte.fim-1]->valor, 1);
     if(podeSair( baralho[estoqueDescarte.fim-1]->valor )) {
        printf("Colocar carta da pilha de descarta na pilha de saida\n");
        moveSairDescarte();
        houveMovimento = 1;
     }
     if(!houveMovimento) {
        for(i=0;i<7;i++) {
           if(podeMoverCarta(estoqueDescarte.fim -1, pilhaJogo)) {          
          Informacao *carta;
          printf("Carta da pilha de descarte para a pilha de jogo Numero %d\n", i+1);
          carta = baralho[estoqueDescarte.fim -1];
          baralho[estoqueDescarte.fim -1]= NULL;
          carta->pilha = &pilhaJogo;
          /* se tiver vazia */
          if(carta->pilha->comeco == carta->pilha->fim) {
             int vazio = procuraVazio();
             carta->pilha->comeco = vazio;
             carta->pilha->fim = vazio +1;
             moveCarta(carta, vazio, 1);

          } else {
             moveCarta(carta, carta->pilha->fim, 1);
          }
          estoqueDescarte.fim--;
          houveMovimento = 1;
          break;
           }
        }
     }
      }
      if(houveMovimento == 1)
     continue;

      if(estoqueDescarte.comeco == 59)
     break;

      printf("pescando uma carta\n");
      pescaGrimorio();

   }
}
/* main pra compilar */

int main() {
   int semente = 1133229541;
   srand(semente);
   inicializaPaciencia();
   jogar();
   return 0;
}

 

[juniorfv]

Os erros estão na utilização do malloc, em dois locais distintos:

Informacao *novaInformacao(int valor, int virada) {
   Informacao *i = malloc(sizeof*i);
   i->valor = valor;
   i->virada = virada;
   i->pilha = NULL;
   return i;
}

 

E

 

 baralho = malloc(60*(sizeof*baralho));

 

Não sei oquê  fazer para rodar o programa.