Que tal desenvolver seu próprio jogo de damas para jogar com seus amigos utilizando apenas conceitos básicos da linguagem C de programação? Aproveite esse guia para se divertir criando e jogando esse jogo que com certeza irá lembrar seus tempos de criança!
Índice
- 1 Criando estrutura de dados para arquivo
- 2 Criando a função de jogabilidade
- 3 Laço jogo de dama parte 1 (Vez de cada jogador)
- 4 Laço jogo de dama parte 2 (Desenho do tabuleiro)
- 5 Laço jogo de dama parte 3 (Origem das peças)
- 6 Laço jogo de dama parte 4 (Destino das peças)
- 7 Laço jogo de dama parte 5 (Destino válido?)
- 8 Laço jogo de dama parte 6 – Condições para comer uma peça
- 8.1 Primeiro movimento – Direita ou esquerda
- 8.2 Substituindo a peça
- 8.3 Comendo para trás
- 9 Laço do jogo de dama parte 7 (Fim do laço)
- 10 Criando função para exibir vencedor
- 10.1 Quem tem mais peças?
- 10.2 Vamos comparar?
- 11 Função main – Criando as variaveis da matriz do tabuleiro
- 12 Preencher a matriz do tabuleiro com caracteres da tabela ASCII
- 13 Segundo laço jogo de damas parte 1 (Menu inicial + apresentaçao)
- 14 Segundo laço jodo de dama Parte 2 (switch case para a opção escolhida) e fim do laço
- 14.1 Case 1: iniciando o jogo
- 14.2 Case 2: Informações do jogo
- 14.3 Case 3: Saindo do jogo
Criando estrutura de dados para arquivo
Começaremos criando uma estrutura para armazenar os dados básicos do jogo, como nome do jogador, quem foi o ganhador, todas essas de tipo “char” e também criaremos variáveis de contadores do tipo “int” para armazenarmos os números de pontos de cada jogador, ou seja, quantas peças cada um “comeu”. É importante criarmos essas variáveis antes do código “main” do nosso programa para que facilite o seu acesso futuramente.
struct{
char game1[20], game2[20], ganhador[20];
int cont1, cont2, pont_max;
}dama;
Criando a função de jogabilidade
Criaremos agora uma função do tipo “void” que utilizará como parametro a matriz do tabuleiro, o jogador e seu oposto, ou seja, o jogador que estará jogando e seu oponente. As variáveis do tipo inteiro criadas abaixo serão utilizadas para: (i, j) = contadores, (c, l) = coluna e linha correspondente a escolha da peça que o jogador irá mover, (li, co) = coluna e linha para onde o jogador irá mover a peça selecionada.
void jogador1(char matriz[8][8],char jogador, int oposto)
{
int i,j,l,c,li,co,opcao=0;
Lembre-se que esse é apenas o primeiro passo dessa função. Nela irá conter todo o sistema de jogabilidade do jogo.
Laço jogo de dama parte 1 (Vez de cada jogador)
Iniciaremos esse laço fazendo a verificação de qual jogador está jogando (jogador 1 ou jogador 2). Feita a verificação, você irá imprimir na tela um texto informando de quem é a vez de jogar.
do
{
if(jogador==1)
printf("\n\n---------------- A VEZ E A DO JOGADOR PEÇA BRANCA ----------\n\n\n\n");
if(jogador==2)
printf("\n\n---------------- A VEZ E A DO JOGADOR PEÇA PRETA ------------\n\n\n\n");
Laço jogo de dama parte 2 (Desenho do tabuleiro)
Aqui iremos imprimir o tabuleiro na tela. Como começamos o processo pela função, iremos apenas imprimir o número correspondente as coordenadas das linhas e colunas utilizando de nossos contadores inicializados no começo da função. A variável “matriz[i][j]” será preenchida posteriormente com caracteres especiais para diferenciar as peças brancas, pretas e os espaços em branco.
Lembre-se que essa é apenas a implementação da função. Todo esse processo ocerrerá quando ela for chamada dentro da parte “main” de seu código.
printf("\t \t\t 0 1 2 3 4 5 6 7 \n");
for(i=0;i<8;i++)
{
printf("\n\t\t\t%d ",i);
for(j=0;j<8;j++)
printf("%c ",matriz[i][j]);
}
Laço jogo de dama parte 3 (Origem das peças)
Aqui iremos instruir o jogador a digitar qual a coordenada da peça que ele pretende mover. Vamos armazenar sua escolha nas variáveis “l” e “c”, criadas no começo da função
printf("\n\n\t*************** CORDENADA DA PECA **********************");
printf("\n\tLINHA: ");
scanf("%d",&l);
printf("\n\tCOLUNA: ");
scanf("%d",&c);
Laço jogo de dama parte 4 (Destino das peças)
Aqui iremos instruir o jogador a digitar as coordenadas da posição para onde ele pretende mover a peça selecionada no tópico anterior. Vamos armazenar essa escolha nas variáveis “li” e “co”, criadas no começo da função.
printf("\n\n\t****COORDENADA DA POSICAO QUE A PECA VAI OCULPAR****");
printf("\n\tLINHA: ");
scanf("%d",&li);
printf("\n\tCOLUNA: ");
scanf("%d",&co);
Laço jogo de dama parte 5 (Destino válido?)
Aqui iremos verificar se as coordenadas referentes ao destino do movimento da peça selecionada é válido. Iremos utilizar uma condição simples para verificar se o movimento é válido. Temos que a soma das coordenadas de destino dividido por dois corresponde aos espaços válidos para a realização do movimento, por exemplo:
- A peça da linha 2 e coluna 2, somente poderá mover para a linha 3 e coluna 1 ou 3, o que encaicha perfeitamente na condição.
A condição abaixo da verificação é feita para saber se o jogador está movimentando no sentindo certo, ou seja, caso seja o jogador 1 (parte superior da tela) ele deverá mover de uma coordenada de linha de menor valor para uma de maior valor, ou seja, linha de origem deverá ser menor que a linha de destino e caso seja o jogador 2, ele deverá mover de uma coordenada de linha de maior valor para uma de menor valor, ou seja, linha de origem deverá ser maior que a linha de destino.
if((li+co)%2==0)
{
if((jogador==1&&l<li)||(jogador==2&&l>li))
{
printf("linha\n");
Laço jogo de dama parte 6 – Condições para comer uma peça
Primeiro movimento – Direita ou esquerda
Aqui faremos a verificação apra saber se o movimento da peça foi feita para direita ou para a esquerda. Após verificamos, atribuimos o valor 0 para a posição de onde veio a peça, deixando assim aquela coordenada como um espaço branco, e colocaremos o símbolo da peça movida na coordenada onde o jogador escolheu como destino. A variável “opçao” será utilizado como uma variável auxiliar, e será incrementada sempre que uma das condições seja cumprida.
if(c-1==co||c+1==co)
{
if(co==c-1)
{
matriz[li][co] = jogador;
matriz[l][c] = 0;
opcao++;
}
if(co==c+1)
{
matriz[li][co] = jogador;
matriz[l][c] = 0;
opcao++;
}
}
Substituindo a peça
Aqui vamos realizar a verificação para saber se existe alguma peça “oposto”, ou seja, alguma peça do jogador adversário na coordenada para onde o jogador da vez em questão decidiu mover.
Será feita a verificação da diagonal para a direita e a verificação da diagonal para a esquerda.
- Verificação da diagonal direita:
if(matriz[l+1][c+1]==oposto)
{
if(c+2==co)
{
matriz[li][co] = jogador;
matriz[l][c] = 0;
opcao++;
matriz[l+1][c+1]=0;
}
}
- Verificação da diagonal esquerda:
if(matriz[l+1][c-1]==oposto)
{
if(c-2==co)
{
matriz[li][co] = jogador;
matriz[l][c] = 0;
matriz[l+1][c-1]=0;
opcao++;
}
}
Comendo para trás
Faremos as mesmas verificações do subtópico anterior, porém agora utilizaremos a condição para se o movimento for para trás.
- Verificação da diagonal da direita:
if(matriz[l-1][c+1]==oposto)
{
if(c+2==co)
{
matriz[li][co] = jogador;
matriz[l][c] = 0;
opcao++;
matriz[l-1][c+1]=0;
}
}
- Verificação da diagonal da esquerda:
if(matriz[l-1][c-1]==oposto)
{
if(c-2==co)
{
matriz[li][co] = jogador;
matriz[l][c] = 0;
matriz[l-1][c-1]=0;
opcao++;
}
}
}
Laço do jogo de dama parte 7 (Fim do laço)
Aqui terminaremos nosso laço. Caso o movimento seja inválido, ou seja, não passou pela condição de verificação da validade do movimento, iremos imprimir na tela a mensagem de movimento inválido.
Utilizaremos a variável “opcao” como parametro para sair do laço “do-while”.
else printf("\n\n\t\t__________MOVIMENTO INVALIDO!!_________\n\t\t_________JOGUE NOVAMENTE________\n");//posiçao invalida
}
}while(opcao!=1);
}
Criando função para exibir vencedor
Vamos agora criar uma função para definir quem foi o ganhador. Iremos realizar algumas condiçoes para saber a quantidade restante de peças dos jogadores e basear nisso como parametro para exibir o nome do ganhador.
Quem tem mais peças?
Através da condição a seguir, iremos utilizar um laço “for” para contar a quantidade de peças pretas do jogador 2 e a quantidade de peças brancas do jogador 1.
void ganhador(char matriz[8][8])
{
int i,j;
for(i=0;i<8;i++)
for(j=0;j<8;j++)
{
if(matriz[i][j]==2)
dama.cont1++;
if(matriz[i][j]==1)
dama.cont2++;
}
Vamos comparar?
Aqui vamos criar uma condição para saber quem tem mais peças sobrando na mesa. Feita a comparação, imprimiremos na tela o nome do jogador e o total de peças do mesmo.
- Jogador 2 vence:
if(dama.cont1>dama.cont2)
{
printf("\n\tVENCEDOR........-> %s TOTAL DE PECAS: %d\n\n",dama.game1,dama.cont1);//GAME 1...E...JOGADOR PECA PRETA
strcpy(dama.ganhador, dama.game1);//PONTUACAO DO CONTADOR DO BRANCA
dama.pont_max=dama.cont1;//PONTUCAO MAXIMA DO CONTADOR PECA BRANCA
}
- Jogador 1 vence:
else
{
if(dama.cont1<dama.cont2)//OLHA QUEM TEM MAIS PECAS...
{
printf("\n\tVENCEDOR........-> %s TOTAL DE PECAS: %d\n\n",dama.game2,dama.cont2);//GAME 2 ...E ...JOGADOR PECA BRANCA
strcpy(dama.ganhador, dama.game2);
dama.pont_max=dama.cont2;//PONTUACAO MAXIMA DO CONTADOR PECA BRANCA
}
- Empate:
else{
printf("\n\tEmpate!\n\t%s: %d\n\t%s: %d\n\n\n",dama.game1,dama.cont1,dama.game2,dama.cont2);//CASO DE EMPATE
strcpy(dama.ganhador,"jogo empatado");
dama.pont_max=dama.cont2;//PONTUACAO MAXIMA
}
}
}
Função main – Criando as variaveis da matriz do tabuleiro
Agora jovens, iremos finalmente trabalhar dentro da função main. Começaremos por criar as variáveis que serão utilizadas naqueles parametros, quando chamarmos a função “jogador” iniciada bem no começo deste turtorial.
Nossa matriz será 8×8, ou seja, 8 linhas e 8 colunas. Iniciaremos os contadores dama.cont1 e dama.cont2 com o valor 0.
int main(int argc, char *argv[])
{
char matriz[8][8];
int i,j, jogador=2,oposto=1,opcao=0, opcao2;
dama.cont1=dama.cont2=0;
Preencher a matriz do tabuleiro com caracteres da tabela ASCII
Como o título desse tópico ja diz, vamos preencher a matriz do tabuleiro com alguns caracteres especiais da tabela ASCII. Nesse caso, fiz uso de tres numerações que correspondem à alguns caracteres especiais, cujo quais são:
178- Cor Padrao (corresponde a um quadradinho preto).
1- Caractere jogador 1 (corresponde a uma bolinha branca).
2- Caractere Jogador 2 (corresponde a uma bolinha preta).
0- Caractere Nulo que é onde não tem peça de jogador nenhum. (espaço em branco).
Para saber como é o caractere do número desejado, você pode abri um bloco de notas, segurar a tecla Alt do seu teclado e digitar qualquer um desses números (segurando a tecla Alt).
Vamos atribuir manualmente os valores para preencher a matriz.
- Linha 0 até a linha 2 do tabuleiro: inicialmente teremos os caracteres especiais correspondente as peças brancas e os quadrados pretos:
matriz[0][0]= 1; matriz[0][1]= 178; matriz[0][2]= 1; ... matriz[0][7]= 178; matriz[1][0]= 178; matriz[1][1]= 1; matriz[1][2]= 178; ... matriz[1][7]= 1; matriz[2][0]= 1; matriz[2][1]= 178; matriz[2][2]= 1; ... matriz[2][7]= 178;
- Linha 3 e 4 do tabuleiro: inicialmente teremos os caracteres especiais correspondentes aos quadrados pretos e aos espaços vazios:
matriz[3][0]= 178; matriz[3][1]= 0; matriz[3][2]= 178; ... matriz[3][7]= 0; matriz[4][0]= 0; matriz[4][1]= 178; matriz[4][2]= 0; ... matriz[4][7]= 178;
- Linha 5 até a linha 7 do tabuleiro: inicialmente teremos os caracteres especiais correspondente as peças pretas e os quadrados pretos:
matriz[5][0]= 178; matriz[5][1]= 2; matriz[5][2]= 178; ... matriz[5][7]= 2;
matriz[6][0]= 2; matriz[6][1]= 178; matriz[6][2]= 2; ... matriz[6][7]= 178;
matriz[7][0]= 178; matriz[7][1]= 2; matriz[7][2]= 178; ... matriz[7][7]= 2;
Segundo laço jogo de damas parte 1 (Menu inicial + apresentaçao)
Iniciaremos aqui a apresentação do jogo aos jogadores. Utilizando a função “printf”, esboçe um desenho para aparecer logo que o jogador rodar o programa.
Vamos inicializar aqui o laço para rodar a tela inicial do programa e o menu de interação.
Iremos imprimir na tela o menu com as opçoes que o jogo ofereçe, ler a opção digitada pelo usuário e armazená-la em uma variável.
do{
printf("\n\t__________________________________________________________\n");
printf("\t__________________________________________________________\n");
printf("\t__________________________________________________________\n");
printf("\t__________________ ____________________\n");
printf("\t__________________ ############## ____________________\n");
printf("\t__________________ JOGO DA DAMA ____________________\n");
printf("\t__________________ ############## ____________________\n");
printf("\t__________________________________________________________\n");
printf("\t__________________________________________________________\n");
printf("\t__________________________________________________________\n");
printf("\tEscolha uma das opções abaixo\n\n");
printf("\t 1 Jogar.\n\t 2 Ajuda.\n\t 3 Sair.\n\n");
scanf("%d",&opcao2);
Segundo laço jodo de dama Parte 2 (switch case para a opção escolhida) e fim do laço
Agora vamos fazer um swtich case utilizando a variável “opcao2” como parametro. Lembre-se de que utilizamos ela para saber qual a opção escolhida pelo jogador.
switch(opcao2){
Case 1: iniciando o jogo
Caso o jogador digite 1, entraremos no primeiro caso, onde o jogo se inicia de fato. Primeiro pedimos o nome de cada um dos jogadores, armazenando-os na variável da struct criada nos primeiros passos.
case 1:
printf("\n\n\t\tINFORME O NOME DO JOGADOR PEÇA PRETA:\n\n\t\t\t\t");
scanf("%s",dama.game1);
printf("\n\n\t\tINFORME O NOME DO JOGADOR PECA BRANCA:\n\n\t\t\t\t ");
scanf("%s",dama.game2);
Agora utilizaremos uma variável criada e atribuiremos a ela o valor “clock()” da biblioteca time.h. Essa variável ira poder nos auxiliar para rodarmos o jogo até um intervalo limite de tempo. Enquanto o tempo atual”clock()” – tempo inicial “tempo” for menor que 5000 segundos, iremos começar a preencher a variável que diz respeito ao movimento das peças.
int tempo = clock();
while(clock()-tempo<5000)
{
Agora iremos fazer uso da função que corresponde a jogabilidade do nosso jogo, lembra-se dela? Iremos chamar ela na vez do jogador 1 e depois na do jogador 2.
jogador=1;oposto=2;
jogador1(matriz,jogador,oposto);
jogador=2;oposto=1;
jogador1(matriz,jogador,oposto);
}
Caso a condição do tempo limite se esgote, será imprimido na tela o aviso que o tempo limite foi extrapolado, e será anunciado o vencedor atravez da função “ganhador” criada nos tópicos anteriores.
printf("\n\t\t..........PASSARAM 3 MINUTOS FIM DO JOGO...........\n\n\n");
ganhador(matriz);
break;
Case 2: Informações do jogo
Neste caso iremos mostrar na tela as informações do jogo. Você tem liberdade para escrever as informações que julgue necessárias para compreender o jogo.
case 2:
printf("\n_____________________________O QUE É O JOGO?_______________________________");
printf("\n\t O jogo de Damas é representado por um Tabuleiro dividido em 64 quadrados ...\n");
printf("\n_____________________________ O OBJETIVO _______________________________");
printf("\n\n\t Quem comer o maior número de peças possíveis durante 3 minutos é o vencedor!\n\n");
printf("____________________________________________________________________________\n\n")
break;
Case 3: Saindo do jogo
Caso o jogador escolha a opção 3, iremos imprimir na tela uma mensagem de “fim de jogo”, logo após sairemos do laço caso o valor da variável “opcao2”, que corresponde a escolha do jogador no menu inicial, seja igual a 3.
case 3:
printf("\n\n\n\n\t\t\t FIM DO JOGO\n\n\n\n\n");
break;
}
}while(opcao2!=3);//LACO PARA TERMINAR O SWITCH...
return 0;
}
Seguindo esse guia básico você conseguirá implementar e se divertir com esse jogo junto de seus amigos! 😀
Prossiga Programando; 