Skip to content

Instantly share code, notes, and snippets.

@alaisgomes

alaisgomes/gist:988d07d50dcfa4beaa53

Created January 14, 2011 21:37
Show Gist options
  • Save alaisgomes/988d07d50dcfa4beaa53 to your computer and use it in GitHub Desktop.
Save alaisgomes/988d07d50dcfa4beaa53 to your computer and use it in GitHub Desktop.
Download ZIP
Jogo de Dominó FINAL - certo e completo.
Raw
gistfile1.c
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
/*FUNCAO 1: PARA DISTRIBUIR PECAS PARA OS JOGADORES
descricao: com um vetor auxiliar, randomiza as pedras do jogo e depois as distribui entre os jogadores
*/
void Distribuir (int *player1, int *player2) {
int i, j, k, aux, a;
int vetor_random[10];
srand (time (NULL) );
aux=0;
a=0;
i=0;
for (i=0;i<10;i++) {
vetor_random[i]=i;
}
for (i=0;i<10;i++) {
a = rand()%10;
aux = vetor_random[a];
vetor_random[a]= vetor_random[i];
vetor_random[i]=aux;
}
j=0;
k=0;
for (i=0;i<10;i++) {
if (i<5) {
player1[j] = vetor_random[i];
j++;
} else {
player2[k]=vetor_random[i];
k++;
}
}
}
/*FUNCAO 2: CONTAR A QUANTIDADE DE PEDRAS QUE UM JOGADOR TEM
descricao: procura no vetor estado_pedras quais as pedras que pertencem ao jogador em questao que estao em sua mao e as conta
*/
int ContarPecasJogador (int *player, int *estado_pedra) {
int qtd_pecas, i, k, achou;
qtd_pecas=0;
for (k=0;k<5;k++) {
i=0;
achou=0;
while ((i<10)&&(achou==0)) {
if ((estado_pedra[i]==0)&&(i==player[k])) {
qtd_pecas++;
achou=1;
}
i++;
}
}
return(qtd_pecas);
}
/*FUNCAO EXTRA: INDICA QUAIS AS PEDRAS DO JOGADOR
descricao: Funcao feita para facilitar a identificacao das pedras que o jogador tem na mao (deixando-as em ordem), facilitando as funcoes que precisam mexer com tais pedras
*/
void IdentificarPedrasJogador (int *vetor_pedras, int *player, int *estado_pedra,int *lado_A, int*lado_B) {
int i, k, j, achou, qtd_pedras;
int total_pecas = ContarPecasJogador(player, estado_pedra);
k=0;
qtd_pedras=0;
j=0;
while ((k<5)&&(qtd_pedras<total_pecas)) {
i=0;
achou=0;
while ((i<10)&&(achou==0)) {
if ( (estado_pedra[i]==0) && (i==player[k]) ) {
vetor_pedras[j]=k;
achou=1;
qtd_pedras++;
j++;
}
i++;
}
k++;
}
}
/*FUNCAO 3: IMPRIMIR AS PECAS QUE O JOGADOR TEM ATUALMENTE NA TELA
descricao: funcao que chama a funcao de contar pecas para poder saber quantas pecas imprimir na tela e as imprime
*/
void ImprimirPecas (int *player, int*estado_pedra, int *lado_A, int *lado_B) {
int qtd_pedras = ContarPecasJogador(player, estado_pedra);
int vetor_pedras[5];
int i, j, cont;
int x, y, z, n;
char mat[9][41], numero_pedras[40];
IdentificarPedrasJogador(vetor_pedras, player, estado_pedra, lado_A, lado_B);
printf("\n");
for (i=0; i<9; i++) {
for (j=0; j<40; j++) {
mat[i][j]=' ';
}
mat[i][j]='\0';
}
/*O x e o y tem o papel controlar as colunas que ficarao em branco:
*todas as colunas que obedecem a equacao 7*x + y (sao incrementados juntos) serao a separacao;
*antes e depois dessas colunas em branco, serao acrescentados as BORDAS '|' das pedras;
*pontilhados sao preenchidos nas linhas multiplas de 4 (0 4 e 8)
*/
for (i=0;i<9;i++){
x=1;
y=0;
z=0;
for (j=0;j<=7*qtd_pedras+(qtd_pedras-1);j++){
if (((i%4)==0)&&(j!=7*x+y)) {
if (z == 7) {
z=0;
} else {
mat[i][j]='-';
z++;
}
y++;
x++;
} else if (j==0) {
mat [i][j]='|';
} else if ((j==x*7+y)&&(i!=z*4)) {
if(j+1<7*qtd_pedras+(qtd_pedras-1)) {
mat[i][j+1]='|';
}
mat[i][j-1]='|';
x++;
y++;
z++;
}
}
}
/*os loops analizam os lados para preencher com asteriscos adequados
*/
cont=0;
n=0;
while (cont<qtd_pedras) {
n=0;
for (i=0;i<qtd_pedras;i++) {
if (lado_A[player[vetor_pedras[i]]]==1) {
mat[2][3+8*n]='*';
} else if (lado_A[player[vetor_pedras[i]]]==2) {
mat[1][1+8*n]='*';
mat[3][5+8*n]='*';
} else if (lado_A[player[vetor_pedras[i]]]==3) {
mat[1][1+8*n]='*';
mat[2][3+8*n]='*';
mat[3][5+8*n]='*';
}
n++;
}
n=0;
for (i=0;i<qtd_pedras;i++) {
if (lado_B[player[vetor_pedras[i]]]==1) {
mat[6][3+8*n]='*';
} else if (lado_B[player[vetor_pedras[i]]]==2) {
mat[5][1+8*n]='*';
mat[7][5+8*n]='*';
} else if (lado_B[player[vetor_pedras[i]]]==3) {
mat[5][1+8*n]='*';
mat[6][3+8*n]='*';
mat[7][5+8*n]='*';
}
n++;
}
cont++;
}
/*Numeros em baixo da matriz
*/
for (i=0;i<39;i++) {
numero_pedras[i]=' ';
}
numero_pedras[7*qtd_pedras+(qtd_pedras-1)]='\0';
n=0;
for (i=0;i<qtd_pedras;i++) {
numero_pedras[3+8*n]=(vetor_pedras[i]+1) + '0';
numero_pedras[2+8*n]='(';
numero_pedras[4+8*n]=')';
n++;
}
/*Imprimir
*/
for (i=0;i<9;i++){
for (j=0;j<7*qtd_pedras+(qtd_pedras-1);j++){
printf ("%c", mat[i][j]);
}
printf ("\n");
}
for (i=0;i<7*qtd_pedras+(qtd_pedras-1); i++) {
printf ("%c", numero_pedras[i]);
}
printf ("\n");
}
/*FUNCAO 4: ACHAR QUAIS TIPOS DE PONTAS DISPONIVEIS
descricao: indicar quais sao as pontas da mesa atualmente, ou seja, se as pontas sao PELADO, AS, TERNA OU DUQUE
*/
void IndicarPontas (int *mesa_indices, int *mesa_inicio, int *mesa_fim) {
int ponta_inicio, ponta_fim;
ponta_inicio=0;
ponta_fim=18;
while (mesa_indices[ponta_inicio]==-1) {
ponta_inicio++;
}
while(mesa_indices[ponta_fim]==-1) {
ponta_fim=ponta_fim-1;
}
*mesa_inicio=mesa_indices[ponta_inicio];
*mesa_fim = mesa_indices[ponta_fim];
}
/*FUNCAO 5: VERIFICAR SE EXISTE ALGUMA PEDRA COM O JOGADOR QUE POSSA SER JOGADA
descricao: procurar entre as pecas que o jogador possui, se existe alguma que possa ser jogada na mesa
a funcao faz isso analisando as pontas do jogo e se ha compatibilidade entre o lado disponivel delas e alguma pedra do jogador
*/
int VerificarJogadaPlayer (int *player,int *estado_pedras, int mesa_inicio, int mesa_fim, int *lado_A, int *lado_B) {
int vetor_pedras[5];
int i;
int total_pecas = ContarPecasJogador(player, estado_pedras);
int existe_jogada;
IdentificarPedrasJogador (vetor_pedras, player, estado_pedras, lado_A, lado_B);
existe_jogada = 0;
for (i=0;i<total_pecas;i++) {
if (estado_pedras[mesa_inicio]==1) {
if ((lado_A[player[vetor_pedras[i]]] == lado_B[mesa_inicio]) || (lado_B[player[vetor_pedras[i]]] == lado_B[mesa_inicio])) {
existe_jogada = 1;
}
} else if (estado_pedras[mesa_inicio]==2){
if ((lado_A[player[vetor_pedras[i]]] == lado_A[mesa_inicio]) || (lado_B[player[vetor_pedras[i]]] == lado_A[mesa_inicio])) {
existe_jogada = 1;
}
}
if (estado_pedras[mesa_fim]==1) {
if ((lado_A[player[vetor_pedras[i]]] == lado_B[mesa_fim]) || (lado_B[player[vetor_pedras[i]]] == lado_B[mesa_fim])) {
existe_jogada = 1;
}
} else if (estado_pedras[mesa_fim]==2){
if ((lado_A[player[vetor_pedras[i]]] == lado_A[mesa_fim]) || (lado_B[player[vetor_pedras[i]]] == lado_A[mesa_fim])) {
existe_jogada = 1;
}
}
}
return (existe_jogada);
}
/*FUNCAO 6:VER SE O JOGO CONTINUA OU NAO
descricao: chama as funcoes para contar as pedras dos jogadores (ver se alguem nao tem mais pedras) e para ver ser nenhum dos dois conseguem mais jogar (sem pedras que encaixam na mesa) para dar fim no jogo ou nao
*/
int VerificarFimJogo (int *player1, int *player2, int *estado_pedras, int mesa_inicio, int mesa_fim, int *lado_A, int *lado_B) {
int total_player1 = ContarPecasJogador (player1, estado_pedras);
int total_player2 = ContarPecasJogador (player2, estado_pedras);
int jogo_termina;
int perdervez_player1 = VerificarJogadaPlayer (player1, estado_pedras, mesa_inicio, mesa_fim, lado_A, lado_B);
int perdervez_player2 = VerificarJogadaPlayer (player2, estado_pedras, mesa_inicio, mesa_fim, lado_A, lado_B);
if ( (total_player1==0) || (total_player2==0) || ((perdervez_player1==0)&&(perdervez_player2==0)) ) {
jogo_termina = 1;
} else
jogo_termina = 0;
return(jogo_termina);
}
/*FUNCAO 7: FAZER O TURNO DO JOGO - ATUALIZAR A MESA E SEU INICIO/ FIM; MUDAR O ESTADO DAS PEDRAS
descricao: funciona partindo do ponto de que na main ja foram feito os testes que eu jogador tem uma pedra para jogar
ela retorna um iteiro porque retornara o numero da pedra que o jogador escolheu (para escrever o nome depois)*/
int AtualizarTurno (int *player, int *estado_pedras, int *mesa_inicio, int *mesa_fim, int *mesa_indices, int *lado_A, int *lado_B) {
int i, escolha_pedra, escolha_lado, escolha_ponta;
char prosseguir;
printf ("\nDigite o numero da pedra que deseja jogar: ");
scanf ("%d", &escolha_pedra);
printf ("Digite 1 para encaixar o lado de cima, ou 2 para encaixar o lado de baixo: ");
scanf ("%d", &escolha_lado);
printf ("Digite 1 para jogar na ponta de cima ou 2 para jogar na ponta de baixo: ");
scanf ("%d", &escolha_ponta);
/*Testes de consistencia para ver se o jogador escolheu uma pedra que se encaixe em uma das pontas da mesa
*/
if (escolha_ponta==1) {
if (estado_pedras[*mesa_inicio]==1) {
if (escolha_lado==1) {
while ((lado_A[player[escolha_pedra-1]])!= (lado_B[*mesa_inicio])) {
printf ("Digite o numero da pedra que deseja jogar (pedra imcpativel): ");
scanf ("%d", &escolha_pedra);
}
} else {
while (lado_B[player[escolha_pedra-1]]!=lado_B[*mesa_inicio]) {
printf ("Digite o numero da pedra que deseja jogar(pedra imcpativel): ");
scanf ("%d", &escolha_pedra);
}
}
} else if (estado_pedras[*mesa_inicio]==2) {
if(escolha_lado==1) {
while (lado_A[player[escolha_pedra-1]] != lado_A[*mesa_inicio]) {
printf ("Digite o numero da pedra que deseja jogar(pedra imcpativel): ");
scanf ("%d", &escolha_pedra);
}
} else {
while (lado_B[player[escolha_pedra-1]] != lado_A[*mesa_inicio]) {
printf ("Digite o numero da pedra que deseja jogar(pedra imcpativel): ");
scanf ("%d", &escolha_pedra);
}
}
}
} else if (escolha_ponta==2) {
if (estado_pedras[*mesa_fim]==1) {
if (escolha_lado==1) {
while ((lado_A[player[escolha_pedra-1]])!= (lado_B[*mesa_fim])) {
printf ("Digite o numero da pedra que deseja jogar(pedra imcpativel): ");
scanf ("%d", &escolha_pedra);
}
} else {
while (lado_B[player[escolha_pedra-1]]!=lado_B[*mesa_fim]) {
printf ("Digite o numero da pedra que deseja jogar(pedra imcpativel): ");
scanf ("%d", &escolha_pedra);
}
}
} else if (estado_pedras[*mesa_fim]==2) {
if(escolha_lado==1) {
while (lado_A[player[escolha_pedra-1]] != lado_A[*mesa_fim]) {
printf ("Digite o numero da pedra que deseja jogar(pedra imcpativel): ");
scanf ("%d", &escolha_pedra);
}
} else {
while (lado_B[player[escolha_pedra-1]] != lado_A[*mesa_fim]) {
printf ("Digite o numero da pedra que deseja jogar(pedra imcpativel): ");
scanf ("%d", &escolha_pedra);
}
}
}
}
/*Teste para caso o jogador opte por NAO continuar, para repetir o ate ele desejar continuar
*/
printf ("Deseja continuar? (S/N)\n");
getchar();
scanf ("%c", &prosseguir);
while ((prosseguir!='s')&&(prosseguir!='S')) {
printf ("Digite o numero da pedra que deseja jogar: ");
scanf ("%d", &escolha_pedra);
printf ("Digite 1 para encaixar o lado de cima, ou 2 para encaixar o lado de baixo: ");
scanf ("%d", &escolha_lado);
printf ("Digite 1 para jogar na ponta de cima ou 2 para jogar na ponta de baixo: ");
scanf ("%d", &escolha_ponta);
printf ("Deseja continuar? (S/N)\n");
scanf ("%c", &prosseguir);
}
/*Atualizar o estado das pedras apos encaixadas (de acordo com o lado) e atualizar a mesa_indices
*/
if (escolha_ponta==1) {
i=0;
while (mesa_indices[i]==-1) {
i++;
}
mesa_indices[i-1]=player[escolha_pedra-1];
if (escolha_lado==1) {
estado_pedras[player[escolha_pedra-1]]=1;
} else {
estado_pedras[player[escolha_pedra-1]]=2;
}
} else {
i=18;
while (mesa_indices[i]==-1) {
i--;
}
mesa_indices[i+1]=player[escolha_pedra-1];
if (escolha_lado==1) {
estado_pedras[player[escolha_pedra-1]]=1;
} else {
estado_pedras[player[escolha_pedra-1]]=2;
}
}
IndicarPontas(mesa_indices, mesa_inicio, mesa_fim);
return(player[escolha_pedra-1]);
}
/* FUNCAO 8: ATUALIZAR A MATRIZ DA MESA DO JOGO
descricao: essa funcao atualizara a matriz da MESA de acordo com as pedras jogadas (de acordo com a mesa_indices)
*/
void AtualizarMesa (int *mesa_indices, int *lado_A, int *lado_B, int *estado_pedras, char mesa[][125]) {
/*os indices abaixo servem para a manipulacao das linhas e colunas;
algumas linhas e colunas seguem um pedrao de characteres e, por isso, obedecem uma equacao matematica para indices
*/
int i, j, z, n, y, x, m, k;
int contador, qtd_cima, qtd_baixo, h;
int vetor_cima[10], vetor_baixo[10];
k=0;
m=0;
qtd_cima=0;
qtd_baixo=0;
for(i=0;i<19;i++) {
if ((i<9)&&(mesa_indices[i]!=-1)) {
qtd_cima++;
vetor_cima[k]=mesa_indices[i];
k++;
} else if ((i>9)&&(mesa_indices[i]!=-1)) {
qtd_baixo++;
vetor_baixo[m]=mesa_indices[i];
m++;
}
}
for (i=0;i<19;i++) {
for (j=0;j<124;j++) {
mesa[i][j]=' ';
}
}
/*so colocar o PELADO PELADO (sempre vai estar na mesa na primeira vez)
*/
for (i=5;i<14;i++) {
for (j=0;j<7;j++) {
if((i==5)||(i==9)||(i==13)) {
mesa[i][j]='-';
}else {
if ((j==0)||(j==6)) {
mesa[i][j]='|';
}
}
}
}
/*Para desenhar as pedras acima na mesa
*/
if (qtd_cima>0) {
for (i=0;i<5;i++) {
n=1;
y=0;
x=1;
z=0;
for (j=0;j<=14*qtd_cima-1;j++) {
if (((i % 4) == 0)&&(j!=14*n-1)) {
if (z == 13) {
z=0;
} else {
mesa[i][j]='-';
z++;
}
n++;
} else if (j==0) {
mesa[i][j]='|';
} else if (j==14*x-1) {
mesa[i][j-1]='|';
if (j+1<14*qtd_cima-1) {
mesa[i][j+1]='|';
}
mesa[i][j]=' ';
x++;
} else if (j==14*y+6) {
mesa[i][j]='|';
y++;
}
}
}
contador=0;
while (contador<=14*qtd_cima-1) {
n=0;
i=qtd_cima-1;
h=0;
while (i>=0) {
if ((n % 2)==0) {
if (estado_pedras[vetor_cima[i]]==1) {
if (lado_A[vetor_cima[i]]==1) {
mesa[2][3+6*n+h]='*';
} else if (lado_A[vetor_cima[i]]==2) {
mesa[1][1+6*n+h]='*';
mesa[3][5+6*n+h]='*';
} else if (lado_A[vetor_cima[i]]==3) {
mesa[1][1+6*n+h]='*';
mesa[2][3+6*n+h]='*';
mesa[3][5+6*n+h]='*';
}
} else if(estado_pedras[vetor_cima[i]]==2) {
if (lado_B[vetor_cima[i]]==1) {
mesa[2][3+6*n+h]='*';
} else if (lado_B[vetor_cima[i]]==2) {
mesa[1][1+6*n+h]='*';
mesa[3][5+6*n+h]='*';
} else if (lado_B[vetor_cima[i]]==3) {
mesa[1][1+6*n+h]='*';
mesa[2][3+6*n+h]='*';
mesa[3][5+6*n+h]='*';
}
}
} else {
if (estado_pedras[vetor_cima[i]]==1) {
if (lado_B[vetor_cima[i]]==1) {
mesa[2][3+6*n+h]='*';
} else if (lado_B[vetor_cima[i]]==2) {
mesa[1][1+6*n+h]='*';
mesa[3][5+6*n+h]='*';
} else if (lado_B[vetor_cima[i]]==3) {
mesa[1][1+6*n+h]='*';
mesa[2][3+6*n+h]='*';
mesa[3][5+6*n+h]='*';
}
} else {
if (lado_A[vetor_cima[i]]==1) {
mesa[2][3+6*n+h]='*';
} else if (lado_A[vetor_cima[i]]==2) {
mesa[1][1+6*n+h]='*';
mesa[3][5+6*n+h]='*';
} else if (lado_A[vetor_cima[i]]==3) {
mesa[1][1+6*n+h]='*';
mesa[2][3+6*n+h]='*';
mesa[3][5+6*n+h]='*';
}
}
i--;
h++;
h++;
}
n++;
}
contador++;
}
}
/*Para desenhar as pedras abaixo na mesa
*/
if (qtd_baixo>0) {
for (i=14;i<19;i++) {
n=1;
y=0;
x=1;
z=0;
for (j=0;j<=14*qtd_baixo-1;j++) {
if (((i==14)&&(j!=14*n-1))||((i==18)&&(j!=14*n-1))) {
if (z == 13) {
z=0;
} else {
mesa[i][j]='-';
z++;
}
n++;
} else if (j==0) {
mesa[i][j]='|';
} else if (j==14*x-1) {
mesa[i][j-1]='|';
if (j+1<14*qtd_baixo-1) {
mesa[i][j+1]='|';
}
mesa[i][j]=' ';
x++;
} else if (j==14*y+6) {
mesa[i][j]='|';
y++;
}
}
}
contador=0;
while (contador<=14*qtd_baixo-1) {
n=0;
i=0;
h=0;
while (i<qtd_baixo) {
if ((n % 2)==0) {
if (estado_pedras[vetor_baixo[i]]==1) {
if (lado_A[vetor_baixo[i]]==1) {
mesa[16][3+6*n+h]='*';
} else if (lado_A[vetor_baixo[i]]==2) {
mesa[15][1+6*n+h]='*';
mesa[17][5+6*n+h]='*';
} else if (lado_A[vetor_baixo[i]]==3) {
mesa[15][1+6*n+h]='*';
mesa[16][3+6*n+h]='*';
mesa[17][5+6*n+h]='*';
}
} else if(estado_pedras[vetor_baixo[i]]==2) {
if (lado_B[vetor_baixo[i]]==1) {
mesa[16][3+6*n+h]='*';
} else if (lado_B[vetor_baixo[i]]==2) {
mesa[15][1+6*n+h]='*';
mesa[17][5+6*n+h]='*';
} else if (lado_B[vetor_baixo[i]]==3) {
mesa[15][1+6*n+h]='*';
mesa[16][3+6*n+h]='*';
mesa[17][5+6*n+h]='*';
}
}
} else {
if (estado_pedras[vetor_baixo[i]]==1) {
if (lado_B[vetor_baixo[i]]==1) {
mesa[16][3+6*n+h]='*';
} else if (lado_B[vetor_baixo[i]]==2) {
mesa[15][1+6*n+h]='*';
mesa[17][5+6*n+h]='*';
} else if (lado_B[vetor_baixo[i]]==3) {
mesa[15][1+6*n+h]='*';
mesa[16][3+6*n+h]='*';
mesa[17][5+6*n+h]='*';
}
} else {
if (lado_A[vetor_baixo[i]]==1) {
mesa[16][3+6*n+h]='*';
} else if (lado_A[vetor_baixo[i]]==2) {
mesa[15][1+6*n+h]='*';
mesa[17][5+6*n+h]='*';
} else if (lado_A[vetor_baixo[i]]==3) {
mesa[15][1+6*n+h]='*';
mesa[16][3+6*n+h]='*';
mesa[17][5+6*n+h]='*';
}
}
i++;
h++;
h++;
}
n++;
}
contador++;
}
}
}
/*FUNCAO 9: QUANDO CAHAMDA, IMPRIME A MESA DO JOGO
*/
void ImprimirMesa (char mesa[][125]) {
int i, j;
for (i=0;i<19;i++) {
for (j=0;j<125;j++) {
printf ("%c", mesa[i][j]);
}
printf ("\n");
}
}
/*FUNCAO 10: INDICAR QUAL A PEDRA QUE O JOGADOR JOGOU
descricao: essa funcao atualiza a STRING nome_pedra para que, logo apos que o jogador jogar uma pedra, aparecera na tela o nome da pedra que ele jogou
*/
void NomePedra (int numero_pedra, char *nome_pedra, int *lado_A, int *lado_B) {
int i, n, k;
char duque[6], terna[6], as[3], pelado[7];
pelado[0]='P';
pelado[1]='E';
pelado[2]='L';
pelado[3]='A';
pelado[4]='D';
pelado[5]='O';
pelado[6]='\0';
as[0]='A';
as[1]='S';
as[3]='\0';
terna[0]='T';
terna[1]='E';
terna[2]='R';
terna[3]='N';
terna[4]='A';
terna[5]='\0';
duque[0]='D';
duque[1]='U';
duque[2]='Q';
duque[3]='U';
duque[4]='E';
duque[5]='\0';
k=0;
if (lado_A[numero_pedra]==0) {
for (i=0;i<strlen(pelado); i++) {
nome_pedra[k]=pelado[i];
k++;
}
} else if (lado_A[numero_pedra]==1) {
for (i=0;i<strlen(as); i++) {
nome_pedra[k]=as[i];
k++;
}
} else if (lado_A[numero_pedra]==2) {
for (i=0;i<strlen(duque); i++) {
nome_pedra[k]=duque[i];
k++;
}
} else if (lado_A[numero_pedra]==3) {
for (i=0;i<strlen(terna); i++) {
nome_pedra[k]=terna[i];
k++;
}
}
nome_pedra[k]=' ';
nome_pedra[k+1]='E';
nome_pedra[k+2]=' ';
n=k+3;
if (lado_B[numero_pedra]==0) {
for (i=0;i<strlen(pelado); i++) {
nome_pedra[n]=pelado[i];
n++;
}
} else if (lado_B[numero_pedra]==1) {
for (i=0;i<strlen(as); i++) {
nome_pedra[n]=as[i];
n++;
}
} else if (lado_B[numero_pedra]==2) {
for (i=0;i<strlen(duque); i++) {
nome_pedra[n]=duque[i];
n++;
}
} else if (lado_B[numero_pedra]==3) {
for (i=0;i<strlen(terna); i++) {
nome_pedra[n]=terna[i];
n++;
}
}
nome_pedra[n]='\0';
}
int main () {
/*obs:
player1 = pedras do jogador 1;
player2 = pedras do jogador 2;
mesa_inicio = parte de cima da mesa;
mesa_fim = parte de baixo;
*/
int estado_pedras[10], i, j;
int player1[5];
int player2[5];
int lado_A[10], lado_B[10];
int mesa_indices[19];
int mesa_inicio, mesa_fim;
int turno_da_vez, pecas_1, pecas_2, aux, FimJogo, numero_pedra;
char mesa[19][125], nome_pedra[30];
/*Definindo o lado A e o lado B das pedras
*/
aux=0;
for (i=0;i<10;i++) {
if (i<4) {
lado_B[i]=aux;
aux++;
} else if (i<7) {
lado_B[i]=aux-3;
aux++;
} else if (i<9) {
lado_B[i]=aux-5;
aux++;
} else
lado_B[i]=aux-6;
}
for (i=0;i<10;i++) {
if (i<4) {
lado_A[i]=0;
} else if (i<7) {
lado_A[i]=1;
} else if (i<9) {
lado_A[i]=2;
} else
lado_A[i]=3;
}
/*Todas os estados pedras iniciam com 0 (fora da mesa
*/
for (i=0;i<10;i++) {
estado_pedras[i]=0;
}
/*Iniciando os indices da mesa com -1 todos para indicar que nao existe nada na mesa, e no decorrer do jogo, sera atualizada
*/
for (i=0;i<19;i++) {
mesa_indices[i]=-1;
}
printf ("-----------------------------------------------------------------------\n");
printf (" JOGO DO DOMINO \n");
printf ("-----------------------------------------------------------------------\n");
Distribuir (player1, player2);
mesa_indices[9]=0;
mesa_inicio=0;
mesa_fim=0;
numero_pedra=0;
for (i=0;i<19;i++) {
for (j=0;j<124;j++) {
mesa[i][j]=' ';
}
mesa[i][j]='\0';
}
for (i=0;i<30;i++) {
nome_pedra[i]=' ';
}
/*Verificar quem saiu com pelado pelado. É um loop a parte dos turnos normais por ser um turno pre-definido.
*/
for (i=0;i<5;i++) {
if(player1[i]==0) {
turno_da_vez=1;
printf ("\nO JOGADOR 1 SAIU COM PELADO PELADO, PORTANTO, ELE COMECA. \n");
ImprimirPecas(player1, estado_pedras, lado_A, lado_B);
printf ("\nTecle ENTER para continuar...\n");
getchar();
AtualizarMesa (mesa_indices, lado_A, lado_B, estado_pedras, mesa);
ImprimirMesa(mesa);
NomePedra (numero_pedra, nome_pedra, lado_A, lado_B);
printf("\n O jogador %d jogou a pedra %s \n", turno_da_vez, nome_pedra);
estado_pedras[0]=1;
turno_da_vez=2;
if (VerificarJogadaPlayer(player2, estado_pedras, mesa_inicio, mesa_fim, lado_A, lado_B)==1) {
turno_da_vez=2;
} else {
ImprimirPecas(player1, estado_pedras, lado_A, lado_B);
printf ("\nJOGADOR %d PASSOU A VEZ!\n", turno_da_vez);
turno_da_vez=1;
}
} else {
if (player2[i]==0) {
turno_da_vez=2;
printf ("\nO JOGADOR 2 SAIU COM PELADO PELADO, PORTANTO, ELE COMECA. \n");
ImprimirPecas(player2, estado_pedras, lado_A, lado_B);
printf ("\nTecle ENTER para continuar...\n");
getchar();
AtualizarMesa (mesa_indices, lado_A, lado_B, estado_pedras, mesa);
ImprimirMesa(mesa);
NomePedra (numero_pedra, nome_pedra, lado_A, lado_B);
printf("\n O jogador %d jogou a pedra %s \n", turno_da_vez, nome_pedra);
estado_pedras[0]=1;
turno_da_vez=1;
if (VerificarJogadaPlayer(player1, estado_pedras, mesa_inicio, mesa_fim, lado_A, lado_B)==1) {
turno_da_vez =1;
} else {
ImprimirPecas(player1, estado_pedras, lado_A, lado_B);
printf ("\nJOGADOR %d PASSOU A VEZ!\n", turno_da_vez);
turno_da_vez=2;
}
}
}
}
FimJogo=0;
/*Loop dos turnos:
roda enquanto o jogo nao acaba (de acordo com o que a funcao de verificar fim do jogo retorna);
quanto o turno da vez esta com o jogador 1, as atualizacoes sao todas feitas em prol do jogador um e a reciproca eh verdadeira para o jogador 2*/
while (FimJogo == 0) {
for (i=0;i<30;i++) {
nome_pedra[i]=' ';
}
printf ("\nVEZ DE JOGADOR %d JOGAR.\n", turno_da_vez);
printf ("\nTecle ENTER para continuar...\n");
getchar();
if (turno_da_vez==1) {
ImprimirPecas(player1, estado_pedras, lado_A, lado_B);
if (VerificarJogadaPlayer(player1, estado_pedras, mesa_inicio, mesa_fim, lado_A, lado_B)==1) {
numero_pedra=AtualizarTurno(player1, estado_pedras, &mesa_inicio, &mesa_fim, mesa_indices,lado_A, lado_B);
AtualizarMesa (mesa_indices, lado_A, lado_B, estado_pedras, mesa);
ImprimirMesa(mesa);
NomePedra (numero_pedra, nome_pedra, lado_A, lado_B);
printf("\n O jogador %d jogou a pedra %s \n", turno_da_vez, nome_pedra);
} else {
printf ("\nJogador %d passou a vez!\n", turno_da_vez);
}
turno_da_vez=2;
} else {
if (turno_da_vez==2) {
ImprimirPecas(player2, estado_pedras, lado_A, lado_B);
if (VerificarJogadaPlayer(player2, estado_pedras, mesa_inicio, mesa_fim, lado_A, lado_B)==1) {
numero_pedra=AtualizarTurno(player2, estado_pedras, &mesa_inicio, &mesa_fim, mesa_indices,lado_A, lado_B);
AtualizarMesa (mesa_indices, lado_A, lado_B, estado_pedras, mesa);
ImprimirMesa(mesa);
NomePedra (numero_pedra, nome_pedra, lado_A, lado_B);
printf("\n O jogador %d jogou a pedra %s \n", turno_da_vez, nome_pedra);
} else {
printf ("\nJogador %d passou a vez!\n", turno_da_vez);
}
turno_da_vez=1;
}
}
IndicarPontas (mesa_indices, &mesa_inicio, &mesa_fim);
FimJogo = VerificarFimJogo(player1, player2, estado_pedras, mesa_inicio, mesa_fim, lado_A, lado_B);
}
/*Ver se alguem ganhou, ou se deu empate, apos sair do loop do jogo
*/
pecas_1=ContarPecasJogador (player1, estado_pedras);
pecas_2=ContarPecasJogador (player2, estado_pedras);
if (pecas_1 == 0) {
printf ("\n");
printf ("O JOGADOR 1 VENCEU O JOGO!\n");
printf ("\n");
printf ("O JOGADOR 2 FICOU COM %d PEDRA(S)\n", pecas_2);
} else if (pecas_2 == 0) {
printf ("\n");
printf ("O JOGADOR 2 VENCEU O JOGO!\n");
printf ("\n");
printf ("O JOGADOR 1 FICOU COM %d PEDRA(S)\n", pecas_1);
} else {
printf ("\n");
printf ("NENHUM DOS DOIS PODEM MAIS JOGAR....\n");
printf ("<enter>....\n");
getchar();
if (pecas_1> pecas_2) {
printf ("JOGADOR 2 VENCEU COM MENOS PEDRAS (%d pedra(s)) \n", pecas_2);
printf ("JOGADOR 1 TERMINOU O JOGO COM %d PEDRAS \n", pecas_1);
} else if (pecas_1<pecas_2) {
printf ("JOGADOR 1 VENCEU COM MENOS PEDRAS (%d pedra(s)) \n", pecas_1);
printf ("JOGADOR 2 TERMINOU O JOGO COM %d PEDRAS \n", pecas_2);
} else
printf ("EMPATE!\n");
}
printf ("Aperte ENTER para sair...\n");
getchar();
return(0);
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment