Jump to content
Fórum Script Brasil
  • 0

Jogo Paciência - Linguagem C


juniorfv
 Share

Question

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 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;
}

 

Link to comment
Share on other sites

1 answer to this question

Recommended Posts

  • 0

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.

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.

 Share



  • Forum Statistics

    • Total Topics
      149.6k
    • Total Posts
      646.1k
×
×
  • Create New...