UNIVERSIDADE DO ESTADO DO RIO GRANDE DO NORTE – UERN

Pró-Reitoria de Ensino e Graduação – PROEG

Departamento de Ciência da Computação
Campus de Natal – CaN

Daniel Teodolino Barbosa Torres

Um Jogo da Memória Utilizando a Linguagem C

NATAL
2019
Sumário

1 Introdução ............................................................................................................ 3

2 Regras do jogo ..................................................................................................... 4

3 implementação ..................................................................................................... 9

4 dificuldades encontradas.................................................................................... 13
1 INTRODUÇÃO
Este documento descrever a sistemática e a forma de pontuação do desafio
de implementação de um Jogo da Memória. Também serão apresentados as
dificuldades encontradas durante o desenvolvimento do jogo e as soluções
encontradas.

Para a implementação do desafio foram utilizados os seguintes recursos:

Integrated Development Environment (IDE) DEV-C++, Linguagem de Programação
Estruturada C e o Sistema Operacional Windows 10.
2 REGRAS DO JOGO
Neste Jogo da Memória cada rodada é disputada entre um Jogador Computer
(fictício) e um Jogador Real (você). Ao inicar a rodada serão exibidos avisos básicos
e iniciais. Essa notificação garante o entendimento prévio por parte do Jogador Real
e define as premissas essênciais da disputa. Estes avisos são apresentados da
mesma maneira que estão na Figura 1.

Figura 1: Avisos iniciais

O Jogador Fictício denominado de Computer assume o papel de mandante do

jogo e a cada rodada ele é o responsável por sortear, exibir e comparar as cartas.

Após os avisos iniciais o Jogador Fictício denominado de Computer informa ao

seu adversário os níveis de dificuldade do jogo. Conforme seguem:

[1] – Easy;

[2] – Medium;

[3] – Hard; e

[4] – Insane.

Nesse momento o Jogador Real (você) deve informa como deseja iniciar a
disputa. A Figura 2 exibe este momento do jogo.
 Figura 2: Definição do nível de dificuldade

Mas lembre-se: dentro de uma rodada não é possível regredir de nível e o

avanço entre os níveis a cada 5 vitórias do Jogador Real (você). Sendo assim, após
selecionar o nível da rodada, um novo nível só poderá ser escolhido iniciando uma
nova rodada ou a progressão por meio de vitórias.

Os níveis de dificuldade do jogo são baseados na relação quantidade de cartas

exibidas e o tempo de memorização, conforme segue:

[1] - Easy – 6 cartas exibidas - 25 segundos para memorizar;

[2] – Medium – 8 cartas exibidas – 20 segundos para memorizar;

[3] – Hard – 10 cartas exibidas – 15 segundos para memorizar; e

[4] – Insane – 20 cartas exibidas – 10 segundos para memorizar.

 Figura 3: Nível Hard – 10 cartas exibidas – 15 segundos para memorizar

A Figura 3 exibe uma jogada da rodada de nível Hard, com 10 cartas exibidas
e 15 segundos para memorização. Após o tempo de memorização, o Jogador Real
(você) deverar informar carta por carta, na ordem em que o Jogador Fictício definiu.

A Figura 4 mostra em detalhes como devem ser inseridas as respostas do

desafio.

Figura 4: Momento em que o Jogador Real (você) deve informar as respostas

 Após enviar a sequência de cartas, o Jogador Computer realiza uma
comparação, carta por carta para validar a resposta. Após o processo de
comparação o placar do jogo é atualizado, sendo computado 1 ponto para o Jogador
Computer, caso as cartas informadas estejam divergentes das cartas originais ou 1
ponto para o Jogador Real (você) caso as cartas tenham sido informadas na mesma
ordem que apresentadas inicialmente. É muito importante informar que este placar
só será exibido ao finalizar a rodada. A Figura 5 exibe o momento exato após a
comparação e atribuição de 1 ponto para o computador.

Figura 5: Computer Win!

Nesse momento o Jogador Real (você) tem duas opções: a primeira é

continuar na rodada, permanecendo no mesmo nível e tentando vencer do Jogador
Computer; ou finalizar a rodada, onde será exibido o placar final do jogo, confome
exibido na Figura 6.
Figura 6: Placar do Jogo
3 IMPLEMENTAÇÃO

Para a implementação desse Jogo da Memória, foi utilizada a IDE DEV-C++ e

a linguagem de Programação Estruturada C.

As bibliotecas utilizadas foram as seguintes:

//bibliotecas
#include <stdio.h> //Biblioteca responsável por operações de dentrada e saída
#include <stdlib.h> //Biblioteca responsável por alocação de memória, controle de
processos, conversões e outros.
#include <locale.h> //Biblioteca responsável por conversões. Foi utilizada para
utilização da função setlocale - definir idioma.
#include <windows.h> //Biblioteca responsável por partes gráficas. Nesse caso para
utiliza funções para definir titulo da tela
#include <conio.h> // Biblioteda para fornecer entrada / saída do console
#include <time.h> //Utilizada para manipulação de funções com Tempo

Locale.h e Windows.h foram as novidades para o desenvolvimento desse

desafio, a primeira possibilitou definir um idioma para que os caracteres com acento
fossem impressos da forma correta. Já a segunda, possibilitou realizar uma
personalização da tela do executável, inserindo um título na janela.

Figura 7: Título da Janela

Ao longo do desenvolvimento do jogo, foi percebido a necessidade de criar

funções, tanto pela necessidade de utilizar o mesmo trecho de código em diversas
partes da implementação, quanto pela especificidade de determinado trecho de
código.

A função VOID PLAY(), por exemplo, foi definida para reconhecer “ENTERs”
do jogo. Sendo o ENTER definido pela tabela ANSII como o decimal 13, sendo
assim a função solicita que o usuário precione ENTER em determinado momento do
jogo, e permanece nesse estado até que a tecla digitada seja igual ao número inteiro
decimal 13, que corresponde ao ENTER.

//Função para reconhecer um ENTER do teclado por meio do código ANSII

void play(){
int c;

printf ("\n\nPressione ENTER para iniciar");

do{
c = getch();
}while (c != 13);
}

Código 1: Função VOID PLAY()

A função VOID AVISOS(), é um outro exemplo de função sem retorno que

exibe notificações aos Jogadores e além disso realiza a chamada da função PLAY()
para reconhecer um ENTER, sendo este o Play/Início do jogo.

//Função sem retorno para exibir avisos

void avisos(){

printf ("\nESTE É UM JOGO DA MEMÓRIA.\n\n");

printf ("Serão apresentadas cartas aleatorias.\n\n");
printf ("Você terá um tempo entre 25 e 10 segundos para decorar as
cartas exibidas e depois escreve-las na\nordem em que foram exibidas.\n\n");
play();
system ("cls");
}

Código 2: Função VOID AVISOS ()

A função INT TAMANHOJOGO(INT MENU), é uma função que recebe um

Parâmetro inteiro e retorna um resultado inteiro. Essa função é responsável por
definir a quantidade de cartas do jogo (tamanho do jogo) essa definição é realizada
com base no nível de dificuldade do jogo. Este nível pode ser escolhido quando
iniciada a rodada ou pode ir progredindo a cada 5 vitórias do Jogador Real (você).

//Função que define o tamanho do jogo (quantidade de cartas) com base na função
menuLevel.
int tamanhoJogo(int menu){
int qtCartas, level;

level = menu; // recebe o level do jogo - informado pelo usuário

switch (level){
case 1:
qtCartas = 6; // inicializa a variavel que vai definir um jogo com
6 cartas
break;

case 2:
qtCartas = 8; // inicializa a variavel que vai definir um jogo com
8 cartas
break;

case 3:
qtCartas = 10; // inicializa a variavel que vai definir um jogo
com 10 cartas
break;

case 4:
qtCartas = 20; // inicializa a variavel que vai definir um jogo
com 20 cartas
break;

default:
printf ("\nVerifique a sua opção\n\n");
}
return qtCartas; // retorna a quantidade de cartas do jogo.
}

Código 3: Função INT TAMANHOJOGO(INT MENU)

A função INT TEMPO (INT QTCARTAS), é uma função que recebe um

Parâmetro inteiro (a quantidade de cartas) e retorna um resultado inteiro (o tempo
relacionado a cada quantidade de cartas). Essa função é responsável por definir o
tempo que o Jogador Real (você) terá para memorizar as cartas apresentadas.
 //Função que define o tempo de memorizacao com base no tamanho do jogo
(quantidade de cartas)
int tempo(int qtCartas){
int timeLevel, retTamanhoJogo;

retTamanhoJogo = qtCartas; // recebe o tamanho do jogo

if (retTamanhoJogo == 6){ // para um jogo de 6 cartas define um tempo de

25 segundos
timeLevel = 25;
}
else if (retTamanhoJogo == 8){ // para um jogo de 8 cartas define um
tempo de 20 segundos
timeLevel = 20;
}
else if (retTamanhoJogo == 10){ // para um jogo de 10 cartas define um
tempo de 15 segundos
timeLevel = 15;
}
else if (retTamanhoJogo == 20){ // para um jogo de 20 cartas define um
tempo de 10 segundos
timeLevel = 10;
}
return timeLevel;
}

Código 4: Função INT TEMPO (INT QTCARTAS)

A função principal INT MAIN (VOID), possui a definição das seguintes variáveis
e de uma constante utilizada para definir o tamanho máximo do vetor que armazena
as cartas.

//função principal
int main(void){

//declaração da constante
#define TamanhoJogo 20

//variáveis
int i = 0, j = 0, placar = 0, placarComputer = 0, placarJogador = 0,
cartas=0, opc=0, tempoSegundos, rodada = 1, cont = 1;
char c;
int cartasAleatorias[TamanhoJogo];
int cartasRespostas[TamanhoJogo];

Código 5: Definição de constante e declaração de variáveis

4 DIFICULDADES ENCONTRADAS
Durante a implementação desse desafio, as principais dificuldades encontradas
foram:

 idealizar uma lógica para criar um jogo utilizando o conceito de matriz;

 idealizar a sistemática do jogo. Como o Jogador Real (você) poderia
interagir com o computador;
 comparar as cartas informadas com as cartas apresentadas; e
 computar a pontuação das rodadas.