Pesquisar na Comunidade

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