Trabalho final Programação I

Engenharia de Controle e
Automação

Israel Damazio Araujo Costa

Marcelo Vitor Figueira Dias
Thiago Lotufo Macedo

11/2016

1
 Israel Damazio Araujo Costa
Marcelo Vitor Figueira Dias
Thiago Lotufo Macedo

Relatório de Trabalho final

Trabalho final de Programação I – Pokemon Go

Trabalho de conclusão de período da

matéria Porgramção I, da Instrituição
CEFET/RJ UnED Nova Iguaçu.
Implementar em Linguagem C, o
famoso jogo para smartphone,
Pokemon Go.

Rio de Janeiro
2016

2
Contatos
Tel: (21) 97674-5204
Email: israeldamazio@hotmail.com
Tel: (21) 99212-6225
Email: marcelovfdias@gmail.com
Tel: (21) 99591-9905
Email: thiago.lotufo@hotmail.com

3
 Sumário

1 Introdução ___________________________________ 5
1.1 Descrição do jogo ______________________ 5
2 Funções utilizadas ____________________________ 5
2.1 Preencher Selvagem ___________________ 6
2.2 Preencher Pokemon Computador _________ 6
2.3 Preencher Pokemon Treinador ___________ 6
2.4 Função Primeira Escolha ________________ 6
2.5 Função Fuga _________________________ 7
2.6 Função Debug ________________________ 7
2.7 Função Busca Pokemon ________________ 8
2.8 Função Batalha Pokemon _______________ 8
2.9 Função Atualiza Pokemon Treinador _______ 8
2.10 Função Busca Pokemon Computador ______ 9
2.11 Função Batalha Pokemon Computador _____ 9
2.12 Função Atualiza Pokemon Computador ____ 9
2.13 Função Imprime Matriz _________________ 9
2.14 Função Dica _________________________ 10
2.15 Função Busca Selvagem _______________ 10
2.16 Função Batalha Pokemon Computador ____ 10
3 Bicliotecas __________________________________ 9
3.1 Bibliotecas utilizadas __________________ 11
4 Funcionamento do Programa ____________________12
4.1 Escolhe Posição ______________________ 12
4.1.1 Escolha Manual ______________ 12
4.1.2 Escolha Aleatória _____________ 12
4.1.3 Debug _____________________ 13
4.2 Seguda Escolha _______________________ 13
4.3 Começar Jornada ______________________14
4.4 Encontrar Pokemon Selvagem ____________15
4.5 Capturou Pokemon Selvagem ____________16
4.6 Jogada Computador ___________________ 16
4.7 Batalha Pokemon ______________________18
5 Fim de Jogo _________________________________20
6 Conclusão ___________________________________ 21

4
1 Introdução

O trabalho consiste em implementar o jogo Pokémon utilizando a linguagem C.

O programa não possui interface gráfica, porém chegará bem próximo do que
ocorre no jogo original. Para implementar o programa, deve-se utilizar funções
criadas pelos integrantes do grupo. Tais funções devem constar em bibliotecas
criadas pelos membros do grupo. O jogo apresenta jogadas aleatórias do
computador, e jogadas inseridas pelo usuário para o perfil treinador.

1.1 Descrição do jogo

No jogo você será um treinador e terá um adversário, com quem irá disputar um
número limitado de Pokémons, que serão distribuídos aleatoriamente em uma
matriz, esses Pokémons serão denominados selvagens. O intuito é capturar a
maior quantidade desses monstros e aumentar sua pokedex. Nessa matriz você
terá 4 tipos de Pokémons com características únicas sendo, eles de terra, agua,
planta e eletricidade. E com o uso das pokebolas, o treinador poderá capturar
esses monstrinhos, fazendo assim eles deixarem de ser selvagens e
transformando-os em Pokémons do treinador.
O jogo consiste em percorrer essa matriz a procura da maior quantidade de
Pokémons, ocorrerá basicamente duas ações durante o jogo, a primeira é
capturar Pokémons onde no lançamento da pokebola o treinador terá 50% de
chance de capturar, e a outra parte é a batalha onde no caso do treinador ou o
seu adversário se encontrarem no campo eles irão batalhar utilizando seus
Pokémons.
O jogo termina quando todos os Pokémons do campo deixam de ser selvagens
ou quando o jogador sai do jogo, no caso da primeira opção ganha quem tiver a
maior quantidade de Pokémons.

2 Funções Utilizadas

As funções são ações implementadas dentro do programa, porém são

desenvolvidas fora dele para melhor organização do programa principal.

5
2.1 Função Preenche Selvagem

Protótipo: void preenche_selvagem(int linha, int coluna, ficha_pokemon

pokemon[], int mat[][8],int cont);

Função cujo o intuito é preencher todas as informações dos Pokémons

selvagens, dentro da estrutura ficha_pokemon.

2.2 Função Preenche Pokemon Computador

Protótipo: void preenche_pokemon_computador(int linha, int coluna,

ficha_pokemon pokemon[], int mat[][8],int cont, ficha_treinador computador, int
qtd1);

Função cujo o intuito é preencher todas as informações do Pokémon inicial do

computador, dentro da estrutura ficha_pokemon e na estrutura ficha_trinador.

2.3 Função Preenche Pokemon Treinador

Protótipo: void preenche_pokemon_treinador(int linha, int coluna,

ficha_pokemon pokemon[], int mat[][8],int cont, ficha_treinador treinador, int qtd);

Função cujo o intuito é preencher todas as informações do Pokémon inicial do

treinador, dentro da estrutura ficha_pokemon e na estrutura ficha_trinador.

2.4 Função Primeira Escolha

Protótipo: void primeira_escolha(char escolha[], int mat[][8], char letra[], int

*linha, int *coluna);

6
Função que transforma uma String em um valor inteiro por meio da tabela ASCII,
ela transforma as letras do alfabeto em números reais sendo comparados as
letras de A à H, com os números de 1 a 8.
Nesta função tivemos um pouco de dificuldade para transformar as letras em
números, porém como dito na descrição com o uso da tabela ASCII, que detém
o valor inteiro da letra denominada, transformamos em números podendo assim
implementar funções como a preenche_pokemon_treinador citada acima.

2.5 Função Fuga

Protótipo: void fuga(int linha, int coluna, ficha_pokemon pokemon[], int

mat[][8],int cont);

Função que muda a posição de Pokémons que escapam quando há alguma

tentativa de captura pelo treinador ou pelo computador.
Nesta função não tivemos dificuldade, porém ela possui uma linha de código um
pouco extensa pois pelo fato de existirem 4 tipos de Pokémons e eles não
poderem sair da sua área denominada tivemos que implementar algumas
condições para que isso não ocorra.

2.6 Função Debug

Protótipo: void debug(char escolha[], int mat[][8], char letra[], int *linha, int
*coluna, int *linha_computador, int *coluna_computador);

Função utilizada para a correção do programa, nela você poderá digitar em uma
Sting as posições dos Pokémons do treinador e do computador de forma extensa
e denominar a posição exata que quer colocá-los.
Nesta função tivemos um problema parecido com o ocorrido na função
primeira_escolha, porém ele foi ainda maior pois desta vez tivemos que mandar
de volta não só 2 valores mais 4, duplicando a dificuldade, mas ela foi efetuada
corretamente no programa.

7
2.7 Função Busca Pokemon

Protótipo: void busca_pokemon(int linha, int coluna, ficha_pokemon pokemon[],

int mat[][8],int cont, ficha_treinador treinador, ficha_treinador computador);

Está função tem como intuito buscar dentro da matriz a posição denominada pelo
usuário e informar se há ou não algum Pokémon na posição, dentro da mesma
posição caso haja algum Pokémon se dá basicamente o jogo em si, onde caso
haja o Pokémon é consultado o status dele dando assim ao jogador as opções
de ação de jogo.
Caso o Pokémon seja selvagem a opção dada ao jogador é capturar Pokémons,
utilizando a pokebola, o usuário tem a opção de lança-la ou não.
Caso o Pokémon seja do próprio treinador ele perderá a vez pois ele não terá
nenhuma opção de ação há se fazer.
E caso o Pokémon seja do computador é atribuída a uma outra função chamada
batalha (item 2.8).

2.8 Função Batalha Pokemon

Protótipo: void batalha_pokemon(int linha, int coluna, ficha_pokemon

pokemon[], int mat[][8],int cont);

Esta função está implementada dentro da função busca_pokemon e ela tem o

intuito de simular a batalha entre o Pokémon do treinador e o do computador.
O treinador escolhe um Pokémon para batalhar com o Pokémon encontrado, a
vida de cada Pokémon é subtraída pelo Pokémon adversário e quem terminar
vivo ganha. O Pokémon vencedor ganha a experiência e que através de uma
função que os atualiza eles podem subir de nível ou não.

2.9 Função Atualiza Pokemon Treinador

Protótipo: void atualiza_pokemon_treinador(int linha, int coluna,

ficha_pokemon pokemon[], int mat[][8], int cont, int aux1);

8
Esta função é bem simples ela atualiza as informações do Pokémon após a
batalha, atualiza a experiência, nível, força e vida.

2.10 Função Busca Pokemon Computador

Protótipo: void busca_pokemon_computador(int linha, int coluna,

ficha_pokemon pokemon[], int mat[][8],int cont, ficha_treinador treinador,
ficha_treinador computador);

Está é uma função espelho da função busca_pokémon, porém ela utiliza valores
aleatórios para implementar a jogada do computador

2.11 Função Batalha Pokemon Computador

Protótipo: void batalha_pokemon_computador(int linha, int coluna,

ficha_pokemon pokemon[], int mat[][8], int cont);

Esta é uma função espelho da função batalha Pokémon, com valores atribuídos
a informações dos Pokémons do computador.

2.12 Função Atualiza Pokemon Computador

Protótipo: void atualiza_pokemon_computador(int linha, int coluna,

ficha_pokemon pokemon[], int mat[][8], int cont, int aux1);

Esta é uma função espelho da função atualiza_pokemon_treinador, com valores

atribuídos aos Pokémons do computador.

2.13 Função Imprime Matriz

Protótipo: void imprime_matriz(int mat [][8], ficha_pokemon pokemon[]);

Esta função imprime a matriz de exibição do game, nela aparecem somente os

Pokémons do treinador.

9
2.14 Função Dica

Protótipo: void dica(int mat[][8], char letra[], char palavra[]);

Dica é uma função que percorre uma linha e uma coluna dada pelo usuário na
matriz e diz a quantidade de Pokémons encontrada em cada uma.

2.15 Função Busca Selvagem

Protótipo: int busca_selvagem(ficha_pokemon pokemon[], int selvagem, int

teste);

Função que analisa a quantidade de Pokémons selvagens na matriz, e caso ela

retorne o valor 0, o jogo é finalizado e é impresso uma mensagem informando o
vencedor que no caso é o time que possui o maior número de Pokémons.

2.16 Função Batalha Pokemon Computador

Protótipo: void batalha_pokemon_computador(int linha, int coluna,

ficha_pokemon pokemon[], int mat[][8], int cont);

Função que o computador utiliza para batalhar com o Pokémon adversário

encontrado. Esta função faz com que o computador escolha um Pokémon
aleatório em sua lista, e batalhe com o Pokémon do treinador. Utiliza os mesmos
parâmetros da função Batalha Pokémon Treinador.

3 Bibliotecas

Para a criação do programa, utilizamos diversas bibliotecas. Bibliotecas são

arquivos que armazenam funções e comandos. Tais comandos são utilizados na
implementação de valores em variáveis, manipulação de dados, etc.

10
3.1 Bibliotecas utilizadas

 #include<stdio.h> - Utilizada em quase todos os programas em C. Possui

comandos como o Scanf, Printf, etc.

 #include<stdlib.h> - Utilizada na maioria dos programas em C. Possui

comandos como o System(“PAUSE”) para aguardar o Enter para finalizar
o programa, System(“CLS”) para limpar a tela.

 #include<math.h> - Utilizada para implementações matemáticas, ou seja,

resolver equações e problemas. Temos como exemplo o pow(); que é
utilizado para calcular a potência de um número e/ou variável.

 #include<string.h> - Biblioteca utilizada para manipular strings. Possui

funções pré definidas para concatenar, preencher, copiar, contar
caracteres, e outras. Essencial para a realização do programa, levando
em consideração as strings utilizadas pelo grupo.

 #include<locale.h> - Biblioteca utilizada para mudar o idioma e exibição.

Como sabemos, a linguagem nativa do C e do computador é o Inglês.
Com esta biblioteca, utilizamos a função para mostrar acentos, Ç, e
outras.

 #include<time.h> - Biblioteca para implementar a função de sorteio,

rand()%; Sem essa função, as jogadas aleatórias não seriam viabilizadas.

 #include<unistd.h> - Biblioteca utilizada para implementar a função

Sleep(); que possibilita o jogar, ver as informações por um determinado
período de tempo, antes que a tela seja limpa para que o jogo tenha
sequência.

11
  #include<conio.h> - Biblioteca utilizada para a função getchar(); Onde o
jogador deveria utilizar a tecla enter para dar continuação na jogada.

 #include "pokelib.h" – Biblioteca criada pelo grupo. Nesta biblioteca,

constam todas as funções criadas para que o jogo pudesse ser
implementado.

4 Funcionamento do Programa

4.1 Escolhe posição

O jogador possui um menu com 3 opções, onde a primeira consiste em uma

Escolha manual, a segunda em Uma escolha aleatória e a terceira em um
Debug, onde ele irá informar a posição de seu Pokémon, e a posição do
Pokémon do seu oponente.

Nesta tela, o jogador escolhe uma opção para posicionar seu Pokémon.

4.1.1 Escolha manual

O jogador escolhia a posição de seu Pokémon inicial através de uma String, onde
a linha é informada por uma letra de A à H e a coluna através de um número de
1 à 8.

12
4.1.2 Escolha aleatória

O jogador escolhe a segunda opção, e em seguida, o programa gera uma

posição aleatória para posicionar o pokemon do mesmo, e do seu adversário. A
posição nunca é a mesma para os dois jogadores.

4.1.3 Debug

O Debug consiste em uma String, que vai receber a posição do jogador, e a

posição do computador. O único formato aceito pelo computador é
T(X,Y);C(X,Y), onde X é a linha e Y é a coluna.

4.2 Segunda Escolha

Após escolher seu Pokemon, e a posição do mesmo no tabuleiro, o Jogador

deve escolher se deseja ver seus dados novamente, o começar a jornada
pokemon. Ao Escolher a jornada pokemon, os pokemons selvagens são
distribuidos e posicionados dentro do tabuleiro. A posição deles não se repete.

Nesta tela, o jogador escolhe uma opção para começar a Jornada.

13
4.3 Começar a Jornada Pokemon

Ao escolher a opção 2, os pokemons selvagens são sorteados e a jornada

começa. O Jogador pode escolher entre as diversas posições da matriz. Se
achar um pokemon selvagem, tem a opção de capturado. Se achar um
pokemon próprio, nada acontece e a rodada muda. Se achar um pokemon do
computador, pode batalhar contra ele para ganhar experiência e pontos.

Nesta tela, o jogador visualiza sua posição na matriz, já preenchida.

4.4 Encontra Pokemon Selvagem

Ao procurar por pokemons no tabuleiro, caso encontre, uma tela será exibida
para que o jogador possa tentar capturar o mesmo. Se isso ocorrer, ele adiciona
o novo pokemon a matriz do jogador e continua para a próxima jogada. Caso ele
não o capture, o pokemon foge para outra posição da matriz, sempre respeitando
o seu tipo: Eletricidade, Água, Ar e Terra.

14
 Nesta tela, o jogador não encontrou nenhum pokemon selvagem em sua rodada.

Nesta tela, o jogador encontrou um pokemon, e decide se irá captura-lo.

4.5 Capturou Pokemon Selvagem

15
Como vimos na tela anterior, o Jogador pode escolher se deseja ou não capturar
o pokemon. Caso capture o Pokemon, ele entra para o seu time e é mostrado na
matriz principal.

Nesta tela, o jogador encontrou um pokemon e o capturou.

4.6 Jogada do Computador

Toda jogada feita pelo computador é aleatória, ou seja, ele irá fazer tudo que o
Treinador fizer, mas de uma forma sorteada. Ele busca pokemons, captura
pokemons e batalha contra o treinado. Também recebe experiência por luta, e
pontos.

16
 Nesta tela, o computador encontrou um Pokémon mas não o capturou.

4.7 Batalha Pokemon

Caso o computador encontre um pokemon do Treinador, ou vice-versa, os dois

podem batalhar, afim de adquirir mais evoluções para o pokemon e experiência
para o treinador. As jogadas são de forma aleatória, ou seja, há um sorteio para
quem irá atacar primeiro. Caso o Treinador encontre um pokemon do
Computador, ele pode escolher qual pokemon de sua pokedex irá utiliza. Isso
também ocorre com o Computador.
Se o computador encontra um pokemon do Treinador, ele irá, obrigatoriamente,
batalhar contra o pokemon daquela posição, independente de nível, tipo ou força.

17
Nesta tela, o treinador encontrou um Pokémon do computador e escolhe o seu.

Nesta tela, a batalha começa.

18
 Nesta tela, o ataque do Pokémon é deferido contra o oponente.

Caso o oponente leve um ataque que tire toda a sua vida, a luta acaba e a vitória
é dada ao Pokémon vencedor.

Nesta tela, o Pokémon vencedor recebe seus prêmio, e o treinador sua experiência.

19
5 Fim de Jogo

Caso o Jogador escolha a opção fim de jogo, uma nova tela é gerada.

Nesta tela, o Treinador escolheu a opção fim de jogo.

Caso isso ocorra, o treinador pode escolher se quer Reiniciar o Jogo, Recomeçar
ou Sair definitivamente.

Nesta tela, o Treinador escolheu a opção fim de jogo.

20
6 Conclusão

Com o desenvolvimento do programa, todos os integrantes do grupo

conseguiram aprender a Linguagem C, suas usabilidades e suas principais
funções. Com isso, esta atividade foi de grande aprendizado para o Grupo.
Cumprimos com todas as exigências que o projeto requisitava. Foi desenvolvido
um algoritmo complexo, porém, bem organizado e estruturado, afim de que
possa ser realizada uma fácil correção e avaliação do mesmo.
Sendo assim, o Trabalho Final de Programação I, cumpriu o seu maior papel e
desafio, que é ajudar no aprendizado da matéria e engrandecer os
conhecimentos dos envolvidos.

21