UNVERSDADE DO OESTE DE SANTA CATARNA UNOESC

RCARDO SASSANOVCZ
JOGO DA MEMRA EM ANDROD PARA PRTCA DE PALAVRAS EM NGLS
USANDO COCOS2D E TEORA DE FLOW
Xanxer SC
2013
RCARDO SASSANOVCZ
JOGO DA MEMRA EM ANDROD PARA PRTCA DE PALAVRAS EM NGLS
USANDO COCOS2D E TEORA DE FLOW
Trabalho de Concluso de Curso apresentado ao Curso
Superior de Tecnologia em Anlise e Desenvolvimento de
Sistemas, rea de Cincias Exatas e da Terra, da Universidade
do Oeste de Santa Catarina, como requisito obteno do
grau de Tecnlogo em Anlise e Desenvolvimento de Sistemas.
Professor orientador: Cristiano Agosti
Xanxer SC
2013
RCARDO SASSANOVCZ
JOGO DA MEMRA EM ANDROD PARA PRTCA DE PALAVRAS EM NGLES
USANDO COCOS2D E TEORA DE FLOW
Trabalho de Concluso de Curso apresentado ao Curso
Superior de Tecnologia em Anlise e Desenvolvimento de
Sistemas, rea de Cincias Exatas e da Terra, da Universidade
do Oeste de Santa Catarina, como requisito obteno do
grau de Tecnlogo em Anlise e Desenvolvimento de Sistemas.
Aprovada em
BANCA EXAMINADORA
________________________________________
Andr Luiz Forchesao
________________________________________
Rosic!er Fe!ippi "uerari
________________________________________
Crisiano A#osi
A$RADECIMEN%O&
Agradecer primeiramente a Deus por me dar sabedoria, pacincia e fora a
cada dia.
Agradeo a minha famlia que por todo esse tempo esteve sempre disposta a
me ajudar e me apoiar.
A minha namorada Cintia Cella, que por vrios dias dedicou grande parte do
seu tempo para me ajudar e incentivar a realizar esse trabalho, no s durante esse
perodo mas sim em todos esse maravilhosos anos.
Agradeo ao meus colegas de trabalho que disponibilizaram um pouco do seu
tempo para me ajudar a desviar os obstculos e dar um passo final a esse projeto.
Ao professor Cristiano Agosti, que orientou este projeto e a meu amigo Victor,
por tambm se disponibilizar e ajudar no desenvolvimento deste trabalho.
A professora Rosicler Puerari, por estar sempre disposta a ajudar, e resolver
os problemas, e todos os que se envolveram de alguma maneira neste projeto.
Leve na sua memria para o resto de sua vida, as coisas boas que surgiram no
meio das dificuldades. Elas sero uma prova de sua capacidade em vencer as
provas e lhe daro confiana na presena divina, que nos auxilia em qualquer
situao, em qualquer tempo, diante de qualquer obstculo.
Chico Xavier
RE&'MO
De acordo com muitas pessoas, os dias, esto passando muito rpido, motivo de
muito trabalho e pouco tempo para lazer. Diante desse fato, surgiu a necessidade de
desenvolver um jogo, para cativar as pessoas que no possuem tempo livre no dia a
dia e que gostariam de aprender uma nova linguagem, como o ingls. Para associar
o ingls, a memorizao de palavras, e o curto tempo, foi desenvolvido um jogo da
memria para a plataforma Android, que por sua vez usada em smartphones e
tablets. Para auxiliar no desenvolvimento, o framework Cocos2d tambm usado,
melhorando ainda mais as interfaces que o jogo possuir. Neste jogo, o jogador
poder estar visualizando em cada acerto de figuras a descrio dela em ingls.
Para no perder o foco, e no deixar que o jogo fique chato, o desenvolvimento do
jogo feito utilizando a teoria de Flow, juntamente com o conceito dos jogos ldicos.
Palavras-chave: Jogo. Memria. Android. Cocos2d. Teoria de Flow. ngls.
AB&%RAC%
According to many people, the days are passing too fast, cause a lot of work and
little time for leisure. Given this fact, the need arose to develop a game to captivate
people who do not have free time on a daily basis and would like to learn a new
language, like English. To associate the English, the memorization of words, and the
short time we have developed a memory game for the Android platform, which in turn
is used in smartphones and tablets. To assist in developing the framework Cocos2d
is also used, further enhancing the interfaces match exists. n this game, the player
may be viewing figures in each hit her description in English. Not to lose focus, and
not let the game get boring, game development is done using the theory of Flow,
along with the concept of fun games.
Keywords: Game. Memory. Android. Cocos2d. Theory of Flow. English.
LI&%A DE FI$'RA&
&'M(RIO
1 NTRODUO......................................................................................................... 14
1.1TEMA......................................................................................................................14
1.2 PROBLEMA...........................................................................................................14
1.3 OBJETVOS.......................................................................................................... 15
1.3.1Objetivo Geral......................................................................................................15
1.3.2Objetivos Especficos.......................................................................................... 15
1.4JUSTFCATVA...................................................................................................... 15
2 FUNDAMENTAO TERCA................................................................................ 17
2.1LNGUAGEM NGLESA PARA BRASLERO........................................................ 17
2.1.1As quatro habilidades no aprendizado do ingls................................................ 17
2.2ATVDADES LDCAS..........................................................................................17
2.2.1Jogo da memria.................................................................................................18
2.3TEORA DE FLOW................................................................................................. 18
2.4ANDROD............................................................................................................... 19
2.4.1Android SDK........................................................................................................ 19
2.4.2Banco de dados SQLite...................................................................................... 20
2.5FRAMEWORK COCOS2D..................................................................................... 21
2.5.1Layers.................................................................................................................. 21
2.5.2Scenes.................................................................................................................22
2.5.3Sprites................................................................................................................. 22
2.5.4Director................................................................................................................ 23
3METODOLOGA........................................................................................................ 24
4DESENVOLVMENTO............................................................................................... 25
4.1FUNCONAMENTO DO JOGO.............................................................................. 25
.................................................................................................................................... 25
4.2CONFGURAO.................................................................................................. 26
4.3PROGRAMAO...................................................................................................27
4.3.1Tela de Ttulo....................................................................................................... 27
4.3.2Tela de Configuraes.........................................................................................30
4.3.3Tela do Jogo........................................................................................................ 31
4.3.4Tela Final do Jogo............................................................................................... 39
4.3.5Tira Dvidas.........................................................................................................40
4.3.6Pontuao........................................................................................................... 41
4.3.7Sobre................................................................................................................... 43
5CONSDERAES FNAS...................................................................................... 45
REFERNCAS........................................................................................................... 46
11
1 IN%ROD')*O
Vive-se em um mundo globalizado e que ainda h pessoas que no
conseguem aprender um segundo idioma por vrios motivos. Essas dificuldades
ficam ainda maior quando estuda-se por conta prpria, sem professor ou algum
com mais experincia na lngua para ajudar. nfelizmente devido ao estilo de vida
que a maioria da populao leva, principalmente das grandes cidades, tem-se pouco
tempo para dedicar ao estudo de um idioma, uma tarefa rdua ou quase
impossvel para muitas pessoas, e que por isso acabam por desistir de aprender
uma segunda lngua, como o ingls.
Para ajudar estas pessoas, o contedo deste trabalho ser o
desenvolvimento de um aplicativo para smartphone, usando teorias para
desenvolvimento de jogos juntamente com a prtica dos jogos ldicos, agrupando
tudo isso em uma maneira de ajudar na memorizao de palavras em ingls, atravs
de um jogo da memria.
Hoje em dia h uma quantidade grande de pessoas que buscam jogos como
meio de se divertir, com isso, o jogo vai ser desenvolvido para a plataforma Android,
que por sua vez tem uma grande quantidade de usurios, e alm do mais um
software gratuito, suprindo assim uma maior quantidade de usurios interessados no
aplicativo.
O aplicativo ser gratuito e destina a todo o pblico que tem dificuldade em
gravar palavras da linguagem inglesa, e que no tem tempo no dia a dia para
estudar, para que assim, nas horas vagas possa se divertir e ao mesmo tempo
aprender, utilizando um jogo da memria.
1.1 TEMA
Desenvolvimento de um Jogo da memria na plataforma Android, usando o
framework Cocos2D para auxiliar na memorizao de palavras da lngua nglesa.
12
1.2 PROBLEMA
A lngua inglesa atualmente no mais propriedade exclusiva dos ingleses,
pois, a lngua de escolha em todo o mundo para comunicao entre pessoal de
diferentes culturas. Erros so cometidos no momento de desenvolver esta
linguagem, estes erros esto vinculados diretamente a cultura, hbitos de
comunicao e vcios de linguagem.
Os usurios brasileiros da lngua inglesa so forte exemplo desses erros, pois
costumam deixar o portugus influenciar sobre o ingls. E alm disso o dia a dia
est cada vez mais corrido, deixando assim quem gostaria de estar se envolvendo
mais com est lngua, sem tempo para isso.
No entanto, a inteno principal do aplicativo auxiliar no desenvolvimento do
ingls para usurios que possuem dificuldade com o mesmo, e que no tem muito
tempo disponvel durante o dia. Atravs deste aplicativo, o objetivo elaborar um
mtodo com que a pessoa que esteja jogando, possa evoluir a sua memria visual.
Geralmente no ingls existem habilidades que podem ajudar na sua fixao, como
ler, escrever, ouvir e falar, ou seja, utilizar estas habilidades durante o jogo, para
melhor fixao.
A grande maioria da populao atual, possui como aparelhos celulares, um
smartphone, ento surgiu um segundo desafio, o qual constitui a anlise de como
desenvolver um aplicativo para a plataforma Android. Para auxiliar no
desenvolvimento tambm ir ser usado um framework especfico para jogos, o
framework Cocos2D.
1.3 OBJETVOS
1.3.1 O+,eivo $era!
Desenvolver um aplicativo para a plataforma Android, com a inteno de
auxiliar na fixao do ingls, atravs de um jogo de memria.
13
1.3.2 O+,eivos Espec-.icos
Entender como funciona um jogo de memria e as atividades ldicas.
Utilizar a teoria de flow, para que seja mantido o foco em um
determinado assunto.
Utilizar a plataforma Android para o desenvolvimento do aplicativo.
Desenvolver as habilidades da linguagem inglesa no aplicativo.
Conhecer o framework Cocos2D para ajudar no desenvolvimento da
interface do jogo.
1.4 JUSTFCATVA
O ngls uma linguagem estrangeira classificada como o terceiro idioma
mais falado do mundo, e para os currculos brasileiros est sendo um grande
requisito na maioria das reas trabalhistas, sendo assim, ainda muitos Brasileiros
tem dificuldade na aprendizagem desta lngua.
Para melhor fixao a aprendizagem de palavras em ingls surgiu a
necessidade de implementar esta aprendizagem de um modo divertido onde cada
usurio poderia acessar seu dispositivo mvel nas suas horas vagas, para passar o
seu tempo aprendendo e se divertindo ao mesmo tempo. Ento surgiu a ideia de
fazer um jogo da memria, direcionado para a plataforma Android, uma das mais
usadas em aparelhos mobile, como smartphones e tablets.
Este aplicativo se encarregara de deixar claro palavras em ingls atravs da
memria visual adquirida no jogo. Este aplicativo ter ainda auxlio de um framework
chamado de Cocos2d, que atravs de seus componentes, ir facilitar o
desenvolvimento.
14
2 F'NDAMEN%A)*O %E/RICA
2.1 LNGUAGEM NGLESA PARA BRASLERO
A necessidade de se ter um segundo idioma hoje inevitvel, quando
procuramos emprego, a maioria das empresas exigem ter um segundo idioma onde
geralmente o ingls, pelo fato de ser uma linguagem utilizada no mundo todo. O
importante tambm que aprendemos uma linguagem estrangeira no apenas para
conseguir entrar no mercado de trabalho, mas para interao no mundo
social(acadmico, cientifico, tecnolgico, humano).
O brasileiro est diante de uma realidade, a qual se vem a conscientizar o
estudo da linguagem inglesa. A cada dia mais somos dependentes de linguagens
estrangeiras, com o avano da tecnologia e da internet, a linguagem inglesa a que
est mais presente no cotidiano do brasileiro.
Est lngua vem se aproximando dia a dia, esta presente nas escolas, na rua,
sites de internet, no comercio, etc., est se tornando uma rotina, mas para muitas
pessoas isso passa a ser uma verdadeira dor de cabea, conseguir entender e ser
entendido na linguagem alvo, sentir o progresso e vencer o desafio de ler, escrever e
falar, isso pode se tornar um aspecto de crescimento pessoal muito positivo. Escutar,
falar, escrever e ler, estes so alguns itens de habilidades do aprendizado do ingls
(HARASN et al, 2005).
2.1.1 As 0uaro ha+i!idades no aprendizado do in#!1s
A lngua inglesa a primeira opo de segunda lngua utilizada em todo o
mundo, pode se afirmar que uma lngua universal, a lngua de referncia para
comunicao entre as pessoas em qualquer meio. Escrever, falar, ouvir e ler so as
quatro habilidades que utilizamos para nos comunicar, e so necessrias no
momento da aprendizagem de uma lngua para que esta seja desenvolvida com
fluncia.
15
Para o mercado de trabalho a lngua inglesa se tornou essencial na conquista
de vagas. O principal objetivo de contratar um funcionrio que domine fluentemente
a lngua inglesa a comunicao e a troca de informaes entre as empresas, pelos
seus representantes independente de suas origens. Desenvolvimento, crescimento e
ampliao dos conhecimentos enriquecendo a cultura do indivduo outro
importante fator que trs inmeras vantagens a quem domina o ingls. Com a
internet, para uma pesquisa eficiente e avanada fundamental o conhecimento do
ingls.
nmeros so as vantagens de um brasileiro aprender e desenvolver
fluentemente a lngua inglesa, porm, atualmente a maioria da populao brasileira
se enquadra no nvel bsico intermedirio, o domnio com fluncia ainda um
diferencial para conquistar cargos mais altos. Para se ter este domnio no existem
mtodos milagrosos e sim necessrio desenvolver as quatro habilidades da lngua
com excelncia. O ensino da escrita e da leitura e vrias aulas voltadas a
conversao desenvolvendo tambm a habilidade auditiva so necessrios para se
alcanar este objetivo, possuindo assim um timo currculo e um amplo
enriquecimento cultural.
2.2 ATVDADES LDCAS
O ldico tem sua origem na palavra latina "ludus" que quer dizer "jogo. Se
achasse confinada a sua origem ?, o termo ldico estaria se referindo apenas ao
jogar, ao brincar, ao movimento espontneo. A ideia que o ldico seja visto de uma
maneira mais geral, associada ao aprender brincando. O desenvolvimento do
aspecto ldico facilita a aprendizagem do desenvolvimento pessoal, social e cultural,
e ainda colabora para uma boa sade mental.(MANZANO, 2013).
Segundo Maurcio (2013), A ldicidade assunto que tem conquistado espao
no panorama nacional, principalmente na educao infantil, por ser o brinquedo, a
essncia da infncia e seu uso permitirem um trabalho pedaggico que possibilita a
produo do conhecimento, da aprendizagem e do desenvolvimento de jovens.
Como j citado o objetivo deste projeto ajudar as pessoas a memorizar
palavras da linguagem inglesa, brincando, em momentos oportunos. O jogo da
16
memria tambm tem como caracterstica isso, aprender brincando, ao mesmo
tempo que voc se diverte voc estar memorizando as palavras que encontrou.
2.2.1 2o#o da mem3ria
Antigo Egito, pases do Oriente Mdio, China, vrias so as suspeitas de
onde surgiu o jogo da memria. Este jogo tem seu surgimento h muitos anos,
podendo ser afirmado, que sua origem uma das mais antigas. Por esse motivo se
tem grande dvida do local onde ele surgiu, o porqu surgiu, e como comeou a ser
jogado. Certamente foi inventado ainda antes da escrita, antes de se ter uma histria
do homem, pois para sua realizao necessrio apenas algumas figuras iguais e
pares, pedras e sinais, onde a figura possa ser vista e escondida do jogador. Devido
a essa simplicidade fica ocultada a sua origem. (DVERSO, 2013).
A versatilidade que este jogo possui, devido ao emprego de qualquer tema e a
facilidade de se jogar, torna-o bem utilizado em qualquer parte do mundo, e em
qualquer idade. Pois possui a opo de escolha, sendo independente das
diferenas culturais e religiosas. um jogo capaz de exercitar a criatividade e a
memria de qualquer pessoa. Levando o ser humano a treinar a memria visual
armazenada no crebro e tambm a criatividade para escolha do tema.
Com o surgimento da internet, o jogo da memria pode comear a ser jogado
atravs dela, levando assim a sua maior dissipao pelo mundo e a escolha de
muitos temas diferentes, variando do gosto de cada jogador. Na internet
encontramos muitos temas como, os desenhos clssicos da Disney; os heris da
Marvell; super heris como o Batman, a Mulher maravilha e o Super Homem; figuras
geomtricas; desenhos engraados com personagens cmicos; smbolos religiosos
e personagens famosos do mundo dos vdeos games.
O que realmente importa que o jogo da memria tanto real quanto virtual
uma maravilhosa fonte para diverso, aprendizado e treinamento da memria.
Sendo independente do seu tema, sua aplicao efetiva tanto em crianas, adultos
e idosos, principalmente em crianas em formao e idosos com problema de
17
memria. Tornando momentos em famlia um passatempo saudvel, com grande
alegria, enquanto se exercita o crebro.
2.3 TEORA DE FLOW
Criada pelo psiclogo Mihaly Csikszentmihalyi, a teoria de flow se aplica a
vrios comportamentos do ser humano, a teoria de certo modo interpretada em um
estado que o ser humano pode alcanar quando realiza determinadas atividades
que envolvem a felicidade, ou seja os prazeres e as gratificaes.
(SELGMAN,2004).
Os prazeres so atividades que geram alegria, satisfao, algo que venha
deixar a pessoa relaxada e confortvel como por exemplo, comer chocolate, ver TV
por quanto tempo quiser, fazer alguma atividade que quando completada deixe com
uma sensao de bem-estar.
Para compreender as gratificaes Seligman (2004, p. 254) destaca que:
Jogar uma partida de tnis que exija da nossa capacidade agradvel,
assim como ler um livro que nos traga revelaes ou ter uma conversa que
nos leve a expressar ideias que nem sabamos ter. Fechar um negcio ou
dar por terminado um trabalho bem feito agradvel. Talvez nenhuma
dessas experincias seja especialmente prazerosa no momento em que
acontece, mas, depois, ao lembrar, dizemos "Foi bom, e gostaramos que
acontecessem novamente.
A teoria se aplica e surge quando a tarefa desafiadora e exige certa
habilidade, quando se tem um envolvimento natural pelo assunto ou pela atividade,
e exista concentrao.
Quando o assunto jogos, pode ser compreendido comparando dois estados,
os jogos casuais e jogos hardcore. Casuais so jogos que possui um nvel mais fcil
de compreenso e que no exigem muito de ateno excessiva, relaxando a mente
de quem est jogando. Pode se interpretar os jogos casuais como se estivessem
jogando mais por passatempo, diverso simples e rpida, encarando o jogo com
meros prazeres.
J os jogadores hardcore, so aqueles que gostam de jogos desafiadores e
bem complexos, gostam de tarefas rduas e que nelas conquiste algo, como por
18
exemplo, um trofu, e ao finalizar ter suas habilidades superadas, sentindo excitao
por isto.
O que faz est teoria muito especial, principalmente para desenvolvedores de
jogos, que podem ser desenvolvidos, com a mesma linha de raciocnio, focando
em qual vai ser o pblico do jogo e desenvolver de um mtodo que no tire o foco do
estado de flow, mantendo sempre uma estabilidade entre habilidades e desafio,
assim chegando ao sucesso de seus jogos.
2.4 ANDROD
Android um sistema operacional, direcionado para aplicativos de aparelhos
mveis com uma grande capacidade de memria e processamento, como
smartphones e tablets, isso tudo comeou quando a Google comprou a Android nc.
uma pequena empresa na Califrnia, desde ento o Android desenvolvida pela
Open Handset Alliance, um grupo que rene vrias empresas, dentre elas a Google.
Como vrios outros sistemas operacionais o Android tambm baseado em Linux e
est sendo desenvolvido desde 2005.
Em 2007 saiu a primeira verso do Android, se tratava de uma verso Beta,
ainda no muito confivel, pois estava em testes, no tinha documentao e ainda
nenhum aparelho rodando Android estava disponvel. O Android veio com objetivos
tanto para o usurio final quanto para o desenvolvedor. Diante disso Ferrarini (2012,
p. 04) destaca que:
Para o usurio final, o Android tem o objetivo de ser um sistema voltado
conectividade, localizao e preferncias do usurio. Trocando em midos,
ele pretende ser extremamente personalizvel e, acima de tudo, tirar proveito
da nternet e dos Servios em Nuvem. Para o desenvolvedor de software, tem
o propsito de permitir a criao rpida e descomplicada de aplicaes
nativas, incorporando no seu framework diversas ferramentas que auxiliam o
processo de codificao e preparao do software para o mercado, como por
exemplo, a possibilidade da concepo de interfaces grficas inteiramente em
XML, recursos avanados de internacionalizao e distribuio de aplicativos
pelo Google Play.
19
O desenvolvimento para a plataforma Android baseado na linguagem Java
1
,
com uma estrutura completa e uma grande quantidade de recursos disponveis
como: armazenamento, conectividade, udio, vdeo e muito outros. Alm disso a
plataforma de cdigo aberto, permitindo fabricantes de aparelhos realizarem
alteraes no cdigo do Android, para deixar com a cara do aparelho, e o melhor de
tudo que no tem custo. sso valido para qualquer desenvolvedor, podendo
pegar o cdigo puro e modifica-lo com a sua cara, e assim podendo contribuir para
melhorias.
Para desenvolver na plataforma necessrio o conhecimento da linguagem
Java e para a parte de criao de telas o uso de xml, para realizar o
desenvolvimento a Google disponibiliza j um kit de software e ferramenta pronta,
com todos os plug-ins necessrios.
2.4.1 Android &D4
O Android SDK contm todas as ferramentas necessrias para a construo,
depurao e testes de um projeto, est ferramenta fornecida gratuitamente pela
Google e contm total consonncia com a linguagem Java.
O SDK tambm traz um emulador prprio, chamado de AVD Manager, que
possvel fazer testes sem usar o smartphone ou tablet, pois o mesmo faz o trabalho
de um aparelho real.
Na Google O de 2013 foi anunciado a nova DE para desenvolvimento em
Android, que foi chamado de Android Studio, essa DE contm os componentes
essenciais do Android SDK e inclui tudo que preciso para projetar, depurar e testar
um aplicativo Android. A Google ainda ressalta que o Android Studio ainda uma
verso inacabada, e pode vir a surgir bugs durante o desenvolvimento (GETTNG,
2013).
O Android Studio traz ainda mais novidades para os desenvolvedores, ou seja
a construo dos projetos agora ser feita por uma ferramenta chamada de Gradle e
traz uma proposta de ser flexvel e de fcil manipulao, com uma simples linha de
1

Linguagem de programaco.
20
cdigo voc tem um projeto Java que compila, testa e empacota um JAR como
exemplo a figura (Figura 1).
Figura :Comando executado para gerenciar plugins do Android
Fonte: O autor.
Gradle similar a ferramenta Maven
2
, mas baseada em trabalhos e conceito
diferente, tudo para simplificar o cdigo e auxiliar o programador. (GRADLE, 2013).
2.4.2 Banco de dados &5Lie
Banco de dados um componente do sistema indispensvel, ou seja, a
maioria das aplicaes hoje em dia, possui um repositrio para a persistncia de
seus dados, e considerado um dos pontos principais, no desenvolvimento de uma
aplicao.
Antigamente, o armazenamento dos dados de um sistema era feita atravs de
arquivos do prprio sistema operacional, e isso gerava uma complexidade para os
programadores, ou seja, o sistema era que deveria gerenciar estes arquivos, definir
a localizao, controle de segurana, etc. Estes problemas, foram solucionados
quando surgiu o Sistema Gerenciador de Banco de Dados (SGBD), que composto
em um conjunto de programas, que gerenciam um banco de dados, tirando a
responsabilidade da aplicao cliente, o gerenciamento de acesso, manipulao e
organizao dos dados. (SQLite, 2011)
Para aplicaes de dispositivos moveis, a falta de recurso como memria,
processador e armazenamento, fazem com que os desenvolvedores no consigam
utilizar dos recursos que o SGBD traz. Entretanto a plataforma Android trouxe
suporte nativo ao SQLite. Pode ser subentendido como uma ferramenta, mais
precisamente uma biblioteca, onde pode ser integrada a programas, sem restrio
de linguagens, com objetivo da manipulao dos dados utilizando instrues em
SQL.
2

Ferramenta de automao de compilao.
21
O desenvolvedor pode criar o banco de dados e as tabelas, tambm pode
manipular seus dados atravs dos comandos do SQL padro. O SQLite tambm
disponibiliza j os servios de persistncia de dados, com isso trazendo um ganho
considervel de produtividade.
67879 :ers;es
Existem diversos tipos de verses, que atualmente so usadas para
desenvolvimento, e que esto ainda sendo rodadas em vrios aparelhos no
mercado, segundo estatsticas do site de developer's do Android, as duas verses
que atualmente esto sendo mais ocupadas no mercado so as 2.3.x Ginger Bread
com 36,4% e a 4.1.x Jelly Bean com 29.0% (DASHBOARDS, 2013).
Com base nestas estticas o projeto ser construdo com a verso 4.1.x Jelly
Bean, por ser uma verso um pouco mais recente e que est com um grande
numero de usurios e tem um numero maior de AP's, o que ajuda no
desenvolvimento e na usabilidade das funes que os aparelhos oferecem.
A verso que ser utilizada tambm compatvel com o framework
3
que ser
utilizado na aplicao.
2.5 FRAMEWORK COCOS2D
O Cocos2D foi criada por Ricardo Quesada (2008), um framework de cdigo
aberto para a construo de jogos 2D, demonstraes e outras aplicaes grficas.
Cocos2d foi desenvolvido em Python e desde ento foi portada para diversas
linguagens como C++, JavaScript, Objective-C e Java (LETE, 2013).
3

Conjunto de classes que colaboram para realizar uma responsabilidade para um domnio de um
subsistema da aplicao.
22
O Cocos2d de cdigo aberto. sto signifca que no h restrio alguma
que impea de aprender com o cdigo do mecanismo de jogos, ou de fazer
alteraes nele, onde for necessrio.
O framework Cocos2D na plataforma Android utiliza a linguagem Java para
ser codificado. Aborta uma comunidade open source e sempre tem algum pronto
para responder a uma questo, e os desenvolvedores, em geral, esto abertos ao
compartilhamento de conhecimentos e informaes.
As principais caractersticas que incluem neste framework : Controle de
fluxo, Sprites, Maps, Transitions, Menus, Renderizao de texto, BSD License,
OpenGL Based: a acelerao de hardware. Com objetivo de criar um jogo utilizando
o framework Cocos2D, preciso fazer o download da biblioteca. Jar (cocos2d-
android.jar) e us-la como uma biblioteca de referncia no Build-Path da aplicao.
2.5.1 Layers
Segundo Leite (2012, p57) "Criar telas com o CCLayer do Cocos2D criar
telas pensando em camadas que se sobrepem. Essas camadas so transparentes,
a menos quando definidas de outra forma, e quando colocadas uma sobre as outras
definem a tela final.
Layers nada mais que vrias telas com o fundo transparente e quando
esto separadas voc poder editar elas, sem alterar nada das outras e quando
juntas formam a real forma de sua tela, uma teoria bastante usada. Essa teoria se
aplica no s para o desenvolvimento de jogos e ao Cocos2D, mas para vrios
outras ferramentas. Tambm pode ser representada pela figura (Figura 1) abaixo:
23
Figura : Exemplo com vrios Layers
Fonte: http://www.autocadcentral.com/tutorials/Lesson%207/lesson7.html
Um exemplo de ferramenta que utiliza Layers seria o Adobe Photoshop, l a
teoria a mesma, usado vrios Layers para edio de fotos, e que quando todas
juntas representam uma nica imagem, e com a opo para alterar a imagem
separadamente por layer.
2.5.2 Scenes
Outro objeto importante do Cocos2D so as Scenes. A Scene um pedao do
fluxo do jogo mais ou menos independente, a ideia que com estas Scenes
poderamos inicializar telas do jogo. Um jogo pode ter quantas Scenes forem
necessrias, porm apenas uma poder estar ativa por vez.
Scene implementado pela Classe CCScene no Coco2D. Cada CCScene
possui no mnimo um CCLayer ou seja composta por uma ou mais camadas, e
cada scene pode ser representado por uma tela do jogo, por exemplo, a tela de
ajuda, tela de menu, tela de configurao, etc.
24
2.5.3 Sprites
Umas das vantagens de utilizar Sprites como objetos do Cocos2D que
ganhamos algumas possibilidades de animao. Os Sprites so em sua essncia,
uma imagem grande que consiste em vrias outras imagens menores, (geralmente
do mesmo personagem ou objeto, em diferentes fases de uma animao), sendo
assim, acompanhado por um segundo arquivo, chamado de lista de propriedade,
que contm as coordenadas para cada imagem individual dentro da folha de Sprite
principal (LETE, 2013).
Um dos principais benefcios do uso de Sprites, que, geralmente so mais
rpidos, apenas uma imagem carregada em vez de vrias, tornando o processo
mais rpido. Um Sprite no Cocos2D como qualquer outro Sprite, ou seja, uma
imagem 2D que pode ser movida, rotacionada, ter sua escala alterada, animada, etc.
Para melhor entender, a figura (Figura 3) mostra uma imagem de Sprite usada no
jogo de Super Nintendo que se chamava Super Mario Bros este jogo realmente
garantia horas de diverso. Veja o exemplo:
Figura : Sprites Super Mario Bros
Fonte: http://www.smbhq.com/users/sprite/smwsheet.gif
2.5.4 Director
O Director o componente que se preocupa com idas e vindas entre as
scenes, ou seja, transies de telas do jogo. Ele sabe tudo, como por exemplo, qual
scene est ativa atualmente e gerencia uma pilha de telas, aguardando suas
chamadas para fazer as transies. Qualquer substituio de cena feita pelo
director. O director implementado pela classe CCDirector (LETE, 2013).
25
3 ME%ODOLO$IA
Primeiramente para iniciar o projeto ser preciso entender como funciona o
Jogo da memria, e de como o ldico pode ajudar a entender seus princpios. O
assunto que ser abordado neste jogo o auxlio na fixao de palavras,
direcionado a linguagem inglesa, para usurios que tenham algum tipo de
dificuldade ou alguma controversa como o tempo, e para que isso seja feito da
maneira certa, ser usado a teoria de flow, para no desfocar do propsito do jogo, e
deixar o jogo um pouco mais interessante, viciante.
Atravs do jogo da memria ser construdo um aplicativo para a plataforma
Android, que possui um pblico, relativamente grande, sem contar que o
desenvolvimento baseado na linguagem Java, o que facilita ainda mais a
construo do aplicativo. O jogo possui um banco de dados nativo, chamado SQLite,
que facilita o armazenamento dos dados e unifica a aplicao, o SQLite ser usado
para fazer a persistncia da pontuao do jogo.
Todo o desenvolvimento ser feito utilizando a ferramenta que a Google
disponibiliza, chamado de Android Studio, essa ferramenta contm os componentes
essenciais do Android SDK, e tudo que preciso para projetar, depurar e testar um
aplicativo Android atravs da nova ferramenta de construo Gradle.
Ainda, para auxiliar no desenvolvimento ser utilizado um framework
chamado de Cocos2D, que poder ajudar na criao de telas, a partir dos seus
principais componentes, como os Layers, Scenes e Sprites.
Este jogo ento ser um jogo da memria que por sua vez visar auxiliar, e
cativar as pessoas a estudar a lngua inglesa.
26
4 DE&EN:OL:IMEN%O
4.1 FUNCONAMENTO DO JOGO
Figura : Fluxograma do jogo
Fonte: O autor.

Para melhor entendimento no decorrer deste desenvolvimento, as telas que
foram desenvolvidas sero visualizadas a seguir, na figura (Figura 5) tem-se as trs
principais telas do jogo, na tela de ttulo o jogador ter trs botes, um para jogar o
outro para ver a pontuao e outro para ajuda. Pressionado o boto "jogar abrira a
tela de configuraes, onde o jogador estar configurando o jogo, para a nova
partida. Realizada a configurao e com o boto "comear pressionado a tela do
jogo finalmente estar presente para comear a partida.
27
Figura : Telas do jogo, Ttulo, Configurao, Jogo.
Fonte: O autor.
Com o jogo j em execuo, basta o jogador, procurar o par de cada figura
que se encontra escondido, assim que for memorizado e encontrado o par, uma
mensagem em verde dever aparecer na parte inferior da tela, com a descrio da
figura em ingls, contribudo com a memorizao. Quando o jogador encontrar todas
as figuras, ser ento direcionado para o trmino do jogo, em uma tela de final do
jogo, onde o jogador identificar que venceu a partida. Essas telas so visualizadas
na figura (Figura 6) abaixo:
28
Figura : Tela do jogo, incio e final, tela final do jogo.
Fonte O autor.
Ainda na tela de final do jogo, tem-se dois botes: um para iniciar o jogo
novamente e o outro para rever todas as figuras que foram jogadas na categoria
configurada. niciado o jogo novamente, voltar a tela de ttulo que ter o boto
pontuao com o sistema de pontos do jogo, indicando os jogadores e os seus
respectivos pontos. Para finalizar ainda tem-se a tela de ajuda, que nada mais que
um pequeno resumo do jogo, para que o jogador entenda o motivo e o objetivo do
jogo. Essas telas podem ser visualizadas a seguir na figura (Figura 7):
29
Figura : Telas de categorias escolhida, pontuao e ajuda
Fonte: O autor.
4.2 CONFGURAO
Para comear a desenvolver este projeto, preciso configurar o ambiente de
desenvolvimento, para isso ser usado o Android Studio, uma DE de
desenvolvimento para Android recm lanada pela Google.
O primeiro passo criar um novo projeto Android. Para isso em !ile " #e$
%ro&ect, abrir uma tela para criao de um novo projeto, nesta tela informa-se o
nome do projeto e em qual verso do Android o projeto ser desenvolvido, o projeto
dever se chamar '&ogodamemoria( e ser compilado na verso ).*.+.
Para fazer a construo e compilao, o Android Studio tem uma nova
ferramenta, chamada Gradle, em que a Google est apostando, e tambm acredita
que ir melhorar a experincia do desenvolvedor para Android, para entender melhor
como funciona o Gradle e tambm a criao de um novo projeto pode ser
encontrado no seguinte endereo: http://www.gradleware.com/res
ources/tech/android.
30
Aps isso ser a vez de adicionar a biblioteca do framework Cocos2d, que
ser utilizado para o desenvolvimento do jogo. Para configurar, ser preciso
adicionar o cocos2D-android.jar na pasta libs do projeto, este arquivo pode ser
encontrado no seguinte endereo: "https://code.google.com/p/cocos2d-android-
1/downloads/detail?name=cocos2d-android.jar&can=2&q. Depois disso, clicar com
o boto direito em cima do arquivo .jar e escolher a opo "Add as Library, pronto, o
projeto j est reconhecendo todas as classes do framework Cocos2d.
Agora preciso informar ao Gradle que ser utilizado o Cocos2d na
aplicao, e que preciso compilar com ele junto. No projeto dever existir um
arquivo chamado "jogodamemoria.iml no final desse arquivo ser adicionado o
cdigo ilustrado na (Figura 8) informando ao "jogodamemoria.iml que o projeto est
recebendo uma nova biblioteca. Depois de feitas estas configuraes o projeto j
est pronto para ser desenvolvido e depurado.
Figura : Declarao da biblioteca Cocos2D
Fonte: O autor.
4.3 PROGRAMAO
Depois de configurado preciso criar e entender como ser a estrutura de
arvore do projeto, para isso analise a figura (Figura 9) abaixo:
31
Figura : Estrutura de arvore do projeto
Fonte: O autor.
Dentro da pasta 'res(, utiliza-se as pastas 'dra$able...( conforme a
configurao do smartphone. Nestas pastas sero adicionadas imagens da
aplicao, quando usadas em telas de xml.
A pasta "layout contm todos os arquivos .xml que faro parte do jogo. Ainda
no diretrio 'res( utiliza-se tambm a pasta 'ra$(, esta pasta, ser aplicado todos os
arquivos de udio do jogo.
No diretrio 'src( contm todas as classes do jogo, organizados da seguinte
maneira, pasta "banco ter os arquivos relacionado ao banco de dados SQlite, que
ser usado para gravar e manipular os dados da pontuao de cada jogador. A pasta
'configuracoes( ter as classes controladoras do jogo, entre elas, as configuraes
de resoluo do jogo, diretrio de imagens e tambm o controlador das mensagens
exibidas em tela. Dentro da pasta '&ogo( ter algumas subpastas para que o projeto
possa ficar melhor organizado, entre elas, 'adapter( que futuramente ser adicionado
a classe adapter do jogador, para fazer a manipulao de List,ie$
)
.
4

Componente usado para manipular listas em Android.

32
A pasta 'cenas( ter todas as classes de telas do jogo. Seguindo o raciocnio
tem-se a pasta 'controle( onde ser feito o controle interno do jogo, como um boto e
o menu de botes de cada tela. Para garantirmos que cada boto poder ser clicado
e tambm saber qual foi ele, na pasta 'interfaces( ser adicionado uma interface para
o menu de botes deixando obrigatrio o uso dele em cada tela.
Dentro da pasta 'ob&etos( dever ser informado todas as classes de objetos do
jogo, por exemplo o jogador e a pontuao, sero objetos do jogo. Por fim tem-se a
pasta 'tela( que ser configurada a imagem de fundo de todo o jogo.
4.3.1 %e!a de %-u!o
A primeira tela do jogo ser a tela de abertura, para isso no Cocos2d utiliza-se
uma classe chamada --La.er, uma classe que herdada de --La.er ser de fcil
manipulao, e com isso poder ser criado a tela de abertura que desejar, ento na
pasta 'cenas( do diretrio 'src( ir ser adicionado uma nova classe chamada
'/elade/itulo.&ava( como mostra a (Figura 10):
Figura : Classe 'TeladeTitulo.java'
Fonte: O autor
Essa classe, precisa entender de CCLayer, para ento criar uma nova cena
do jogo, feito isto, esta cena ter 3 camadas, entre elas a imagem de fundo, a logo,
33
e os botes, tudo isso, formar a tela de ttulo do jogo. Para isso ser preciso criar
as classes que compem estes Layers, ou seja no diretrio 'src(, na pasta 'tela', ir
ser criado uma nova classe chamada '0creen1ac2ground.&ava( que ficar com o
seguinte cdigo:
Figura : Classe 'ScreenBackground.java'
Fonte: O autor.
Neste trecho do cdigo, passado como parmetro, no construtor a imagem
que ser usada no background, esta classe entende de CCSprite por isso
possibilitar manipular a imagem passada como parmetro. Agora ser criada a
classe '3enu1uttons/ela/itulo.&ava( nesta classe ser adicionado a imagem e
posio para cada boto da tela, como mostra a (Figura 12):
Figura : Construtor 'MenuButtonsTelaTitulo()'
Fonte: O autor.
Neste trecho pode-se observar que os botes so habilitados para serem
tocados, direcionado imagens e posio para cada um deles, e por fim so
adicionados na tela com o mtodo add-hild45, este boto que est sendo
instanciando, na realidade ser um boto personalizado pelo Cocos2d, ou seja
criado ele no diretrio 'src( dentro da pasta 'controle( e ficar com o seguinte cdigo:
34
Figura : Classe 'Button.java'
Fonte: O autor.
Este boto que foi criado, permite passar como parmetro uma imagem do
tipo String, e esta String ser um atributo do tipo CCSprite, que possibilitar
manipular qualquer tipo de imagem.
Ainda nesta classe tem-se os mtodos criados para saber qual boto foi
chamado, depois disso, preciso de alguma maneira avisar a tela de ttulo de qual
foi este boto. Para isso, ser criado uma interface, chamada de '1utton6elegate(,
ser criado no diretrio 'src( dentro da pasta 'interfaces(, esta interface ser
responsvel em avisar as telas, sobre qual dos botes que est sendo clicado. O
cdigo da interface ficar como mostra a (Figura 14):
Figura : nterface 'ButtonDelegate.java'
Fonte: o autor.
Agora preciso implementar a classe '1utton6elegate( na classe
'3enu1uttons/ela/itulo( e adicionar o mtodo criado na interface. Feito isso j se
consegue saber qual boto foi clicado e tambm realizar alguma ao quando
clicado. Com essa interface, futuramente se precisar ainda ocupar algum tipo de
35
boto no jogo, o cdigo ficar desacoplado e concentrado somente em um lugar,
deixando assim a repetio de cdigo.
Ainda na tela de ttulo, ser adicionado os botes, imagens, que esto sendo
passadas como parmetro, do tipo String, para deixar isso de forma esttica e
desacoplada, ser criado uma classe onde se concentrar todas as imagens. Estas
imagens instanciadas ficaro na pasta 'assets( que fica na raiz do projeto. Nesta
pasta ser colocado todas as imagens que iro aparecem no jogo e tambm ser
instanciadas dentro de uma nica classe, para isso preciso criar a classe
'7ssets.&ava( que est no diretrio 'src(, dentro da pasta 'configuracoes(. A classe fica
parecida com o cdigo do (Figura 15) abaixo:
Figura : Classe 'Assets.java'
Fonte: O autor.
As imagens sero instanciadas como uma String e o Cocos2d se encarregar
de peg-las na pasta assets. Com esta classe ser perdido menos tempo, quando
chegar a hora de adicionar uma imagem a um boto ou um objeto que ir no jogo. A
primeira parte est feita e dever ficar conforme ilustrada na (Figura 16):
36
Figura : Tela de Ttulo
Fonte: O autor.
4.3.2 %e!a de Con.i#ura<;es
Ao clicar no boto Jogar, uma nova tela dever aparecer, ou seja, dever
surgir a tela de configurao da partida, nesta tela dever ser solicitado ao jogador, o
seu nome, e em qual categoria ele gostaria de jogar, e tambm qual ser a
dificuldade que ele vai enfrentar.
Nesta parte ser enfrentado a primeira dificuldade com o Cocos2d, ele no
possui nenhum Widget
5
, por exemplo: RadioButton ou EditText, para esta parte do
jogo ento ser possvel estar utilizando um layout xml, nativo do Android, ou seja
neste layout ser possvel que o jogador informe todas estas informaes
necessrias para dar sequncia ao jogo.
5

Componente grfico do Android
37
Para isso, ser criado uma nova activity, que ser chamada de
'%repara8ogo7ctivit.( ela ficar localizada na raiz do diretrio 'src(, ficar de acordo
com a (Figura 17):
Figura : Activity 'PreparaJogoActivity.java'
Fonte: O autor.
No construtor da activity ser chamado o mtodo cria-onfiguracao45, este
mtodo recebera a escolha que o jogador fez e essas configuraes sero
guardadas em uma classe chamada '-onf.&ava( est classe ter somente os
atributos, nome do jogador, dificuldade escolhida e qual categoria ser realizada a
partida, ainda nesta classe ser criado o construtor juntamente com os get's e set's
dos atributos.
Os dados que sero armazenados ficaro temporariamente na memria,
somente at comear um novo jogo. Aps inserir as configuraes escolhidas pelo
jogador, ser chamado a Tela do Jogo.
Junto com a activity '%repara8ogo7ctivit.( ser criado o layout
'activit.9prepara9&ogo.xml( que ir conter componentes do tipo, :adio1utton,
38
:adio;roup e Edit/ext, que sero usados para receber informaes do jogador e
poder dar sequncia ao jogo. Depois de adicionado os widgets a parte visual ficar
como mostra a figura (Figura 18):
Figura : Tela de Configuraes
Fonte: O autor.
4.3.3 %e!a do 2o#o
At o momento, foi criado a tela de ttulo, na qual o jogador ter algumas
opes a escolher, e que quando clicar no boto de jogar, aparecer a tela de
configurao, solicitando algumas informaes ao jogador, o jogador ento dever
informar o seu nome, qual dificuldade do jogo e em qual categoria jogar. Feito isso, a
activity
6
'%repara8ogo7ctivit.( dever fazer a verificao e abrir a tela do jogo.
Dando sequncia agora ser preciso criar a tela do jogo, para isso ser criado
a classe '/ela6o8ogo.&ava( no diretrio 'src( dentro da pasta 'cenas( e ser feito a
6

Atividade da aplicao usada para interao com o usurio.
39
mesma coisa que a tela de ttulo, adicionar o background, criar o construtor e
instanciar uma nova CCScene. O cdigo ficar parecido com a figura (Figura 19).
Figura : Classe 'TelaDoJogo.java'
Fonte: O autor.
Seguindo a lgica de um jogo da memria, o jogo consiste em vrias peas, e
para conseguir vencer, o jogador precisa achar o par de cada uma delas, ou seja
duas imagens sempre devero ser iguais. Neste jogo ter duas opes de
dificuldade, fcil que consiste em quatro colunas e quatro linhas, chegando em um
total de dezesseis figuras, sendo que somente oito sero diferente e a difcil que
consiste em quatro linhas e quatro colunas, totalizando vinte e quatro figuras, e doze
que sero diferentes.
Para fazer isto ser preciso construir uma nova classe, nesta classe ser
adicionado todas as imagens necessrias na tela e tambm fazer toda a parte lgica
da jogada. Na prtica ento ser criado uma classe para cada dificuldade que ir
existir no jogo, as classes tero o mesmo objetivo e os mesmos mtodos, ser
mudado apenas a quantidade de imagens que ter em cada uma. As duas classes
sero criadas no diretrio 'src( dentro da pasta 'controle( sero chamadas de
'3enu1uttons/ela8ogo6ificil( e '3enu1uttons/ela8ogo!acil(, como exemplo o cdigo
ficar parecido como mostra a figura (Figura 20).
40
Figura : Classe 'MenuButtonsTelaJogoDificil'
Fonte: O autor.
Na figura (Figura 20) pode se observar todos os mtodos que sero
construdos para fazer a parte lgica do jogo, ser criado ainda alguns atributos, os
quais poder ser observado na figura (Figura 21) abaixo:
Figura : Atributos da Classe 'MenuButtonsTelaJogoDificil.java'
Fonte: O autor.
Para cada imagem que ser colocada em tela, ser criado um atributo de
CCSprite, depois que forem criados, ser adicionado todos dentro de um Array
tambm do tipo CCSprite. Feito isso ser preciso adicionar imagens e posio para
cada atributo do array. Para fazer est alimentao de cada imagem e posio ser
preciso criar um for(), que ir percorrer o tamanho total do array. O cdigo ficar
como mostra a figura (Figura 22).
41
Figura : Mtodos 'setmagens()' 'setPosicoes()'
Fonte: O autor.
A imagem que foi adicionado agora, apenas a imagem que esconder a
imagem verdadeira. A imagem verdadeira que corresponde a est posio e a este
objeto ser passado mais tarde, quando ser verificado a imagem que foi
pressionada pelo jogador. Em seguida no mtodo 'set%osicoes( ser adicionado a
posio de cada imagem e tambm ser aproveitado para adicion-las na tela do
jogo.
Para conseguir gerenciar o tamanho da tela e conseguir adicionar a posio
de cada objeto, o Cocos2d tem uma classe que gerencia tudo isso, s ser preciso
implementar ela. Para isso dever ser criado uma nova classe, e nela adicionar
mtodos estticos para poder usar em qualquer lugar do jogo, a classe se chamara,
'-onf6ispositivo.&ava( e ficar no diretrio 'src( dentro da pasta 'configuracoes(,
dentro desta classe ser implementado as funes que o Cocos2d j traz prontas e
que sero importadas da classe CGPoint. O cdigo para esta classe ficar igual ao
da figura (Figura 23).
42
Figura : Classe 'ConfDispositivo.java'
Fonte: O autor.
O mtodo 'resolucao6a/ela( ser do tipo CGPoint e ir esperar como
parmetro a configurao da tela, que ser passado pelos mtodos 'screen<idth(
(largura da tela) e 'screen=eight( (altura da tela).
Foi desenvolvido os mtodos de adicionar imagem, e para cada imagem
tambm foi adicionado uma posio, feito isso o prximo passo colocar estes
mtodos no construtor da mesma classe que quando chamada pela tela de ttulo ir
popular a tela do jogo.
Visualmente a tela do jogo est populada e com todas as imagens
adicionadas como mostra a figura (Figura 24).
43
Figura : Tela do Jogo
Fonte: O autor.
A figura (Figura 24) mostra a tela do jogo com todas as imagens adicionadas,
essa tela seria com a dificuldade do tipo difcil.
Agora hora de partir para parte da lgica do jogo, onde ser usado a
escolha de dificuldade e categoria que o jogador fez na tela de configurao do jogo.
Nesta parte ser usado o mtodo 'button-lic2ed45( , este mtodo pegara a imagem
que foi clicada pelo jogador, e ento virar a imagem para que se possa ver
realmente o que ter atrs dela.
Figura : Mtodo buttonCliked(), primeira jogada
Fonte: O autor.
Para saber quando foi a primeira imagem que o jogador clicou utiliza-se a
varivel 'ultimo1otao-licado(, est varivel est inicializada com -1 que far com que
na primeira verificao da jogada entre no comparador. Aps a comparao ser
44
avaliada, ser necessrio guardar a posio atual para a varivel 'primeira%osicao(,
feito isso ser executado o mtodo mostra45.
Dentro do mtodo 'mostra45( ser feito com que a imagem atual fique invisvel
e mostre a que estiver relacionada com a mesma posio do array passada por
parmetro, depois de adicionada a imagem nova, ser restabelecida a posio que
foi guardada na varivel 'primeira%osicao( e que foi passada por parmetro no
mtodo. O cdigo ficar como mostra a figura (Figura 26).
Figura : Mtodo 'mostra()'
Fonte: O autor.
A imagem de substituio que foi passada, foi a posio de um array de String
que foi criado na classe '7ssets.&ava( com a categoria escolhida pelo jogador na tela
de configurao do jogo, por isso na classe '7ssets.&ava( ser preciso criar um array
com a mesma quantidade de posies que o jogador iniciou o jogo. O cdigo ficar
como mostra a figura (Figura 27).
Figura : Array de categorias
Fonte: O autor.
Para finalizar a primeira jogada, depois de executar o mtodo mostra(), ser
atribudo um valor a varivel 'ultimo1otao-licado(, que receber o valor da posio
do array que est sendo executada.
Para continuar a lgica, a primeira jogada fez com que o jogador clicasse em
uma das imagens e mostrasse qual era a imagem real que estava atrs e guardasse
a posio do vetor na varivel 'ultimo1otao-licado(, agora o jogador precisa achar o
45
seu par, e consequentemente, ser preciso iniciar a segunda jogada, para isso na
segunda jogada ser mudado o comparador para verificar se a varivel
'retorno-ategoria( (Categoria escolhida pelo jogador) na posio que est sendo
feito a verificao for igual a 'retorno-ategoria( na posio que guardamos na
varivel 'ultimo1otao-licado(, se est verificao for vlida, porque o jogador
acertou o par que estava procurando, e ento dever mostrar a imagem da posio
clicada e colocar o valor da varivel 'ultimo1otao-licado( para -1, para que volte a
validar a primeira jogada. A figura (Figura 28) mostra como ficou o cdigo da
segunda jogada.
Figura : Segunda jogada
Fonte: O autor.
Ainda na segunda jogada ter mais trs tarefas a serem executadas quando
obteve acerto, a primeira que mostra uma mensagem na tela dizendo qual o nome
da imagem que o jogador acertou, a segunda, que ser o acrscimo de pontos no
jogo e a terceira a verificao para saber se o jogo chegou ao fim.
A mensagem ser simples, ser mostrada atravs de um /oast, essa classe
no Android permite mostrar mensagem durante alguns segundos na tela, e logo
desaparecer. Para que seja possvel mostrar essa mensagem em outros lugares do
projeto tambm e no precisar reescrever o cdigo, ser criado uma classe
'/oast3anager( no diretrio 'src( dentro da pasta 'configuracoes( que ficar
armazenado todo o cdigo. O cdigo para esta classe ficar como mostra a figura
(Figura 29).
46
Figura : Classe 'ToastManager.java'
Fonte: O autor.
Nesta classe ser criado o mtodo 'sho$45( que ser esttico e por parmetro
ser passado o context da classe que for usar ele, o texto que ser escrito e
mostrado na tela, e qual ser o tipo da mensagem, se mensagem de erro ou de
sucesso.
Para diferenciar essas mensagem ser criado um layout xml dentro da pasta
'layout' e se chamara 'toast9la.out.xml' nele, ser adicionado um simples /ext,ie$,
o /ext,ie$ ser o componente que mostrara a mensagem no jogo. Para que as
mensagens se diferenciem de erro e sucesso ser aplicado um estilo para o
/ext,ie$ que foi criado no 'toast9la.out.xml( para isso ser criado mais 2 arquivos
xml dentro da pasta 'dra$able( que ficaro com o seguinte nome
'toast9bac2ground9green.xml( para mensagem de sucesso e
'toast9bac2ground9red.xml( para mensagem de erro. O cdigo dos dois arquivos
podem ser visualizado na figura (Figura 30).
47
Figura : Arquivos xml de mensagens Toast (erro e sucesso)
Fonte: O autor.
Para finalizar a parte da mensagem a classe /oast3anager ento ser
chamada aps o mtodo mostra45 da segunda jogada.
Para cada acerto de um par, ser mostrado uma mensagem via Toast com o
significado da imagem em ingls como mostra a figura (Figura 31), para que o
jogador possa estar armazenando e adquirindo o aprendizado da palavra em ingls.
Figura : Mensagem em ngls
Fonte: O autor.
Agora ser a vez do acrscimo de pontos, na hora do acerto do par, ou seja,
toda vez que o jogador acertar um par, os pontos sero alimentados e para isso ser
preciso criar uma classe chamada '0core.&ava( que ficar no diretrio 'src( dentro da
pasta 'ob&etos( que ficar com o cdigo que mostra na figura (Figura 32).
48
Figura : Classe 'Score.java'
Fonte: O autor.
No construtor da classe ser criado uma varivel 'text( do tipo
--1itmap!ont7tlas, est classe do framework Cocos2d, ela gerencia um arquivo
de fontes e para conseguir fazer isso, ela precisa de um arquivo. fnt que ser a fonte
do jogo, para isso ser passado por parmetro o arquivo que ele ir carregar,
chamado de '>ni0ans0emi1old9#umbers9+)?.fnt( esse arquivo ser adicionado na
pasta 'assets' que fica na raiz do projeto. Aps isso, adicionado um tamanho para
a fonte e a posio que ela ficar na tela.
A classe ainda ter os mtodos de acrescentar e diminuir os pontos, ambos
sero simples. O mtodo 'acrecenta45(, acrescentara 10 pontos a cada vez que for
chamado e o mtodo 'tira()' diminuir 3 pontos, se a pontuao ficar negativa, a cor
dele ir ficar vermelha, ao contrrio ficar branca.
Para integrar a pontuao com a tela do jogo, no construtor da classe
'/elado&ogo.&ava( ser acrescentado um novo La.er chamado 'scoreLa.er( e esse
Layer recebera o score criado na classe '0core.&ava( o cdigo ficar como mostra a
figura (Figura 33).
49
Figura : Layer 'score' referente a classe 'TelaDoJogo.java'
Fonte: O autor.
Para finalizar est parte, ser criado uma varivel do tipo /ela6o8ogo e ser
chamada de delegate, feito isso, s chamar o mtodo acrescenta na segunda
jogada que ficar depois de mostrar a mensagem.
Bom, esses mtodos sero executados, caso o jogador acerte o par de
figuras, ainda tem-se o mtodo para verificar o final da partida, mas este mtodo
ficar para ser feito em breve, antes ser preciso fazer uma condio para que se o
jogador no acerte o par, as imagens retornem a se esconder e a pontuao
diminua, pois ele errou.
Para isso ser acrescentado aps a verificao da segunda jogada o 'else'
que representa o "se no, faa isso ou seja, se o jogador no acertar a segunda
jogada, cair no prximo passo que ser o 'else', o cdigo para isso ilustrado na
figura (Figura 34).
Figura : Funo executada ao errar a segunda jogada
Fonte: O autor.
Quando este processo for executado, ser preciso mostrar a imagem por um
tempo para que o jogador, consiga ver ela, mas isso ser rpido, em um tempo de 1
segundo, para fazer isso, ser preciso usar a classe Thread do Java, est classe
tem um mtodo 'run()' que ser onde ficar o cdigo. Para usar a classe Thread ser
50
preciso atribuir o :unnable que definir o mtodo de execuo, e que tambm
deixara impor o tempo para a execuo do mtodo 'run45'.
A lgica ficou da seguinte maneira. A imagens ser visualizada e o mtodo
'run45' ser executado, ou seja, depois de 1 segundo ele ser executado. Dentro do
mtodo ento, ser escondido a imagem, atravs do mtodo 'esconde45', este
mtodo ser igual ao mtodo 'mostra45', s que ao invs de passar a imagem
correspondente ao acerto, ser passado a imagem que esconde mostrado uma
mensagem que o jogador errou, diminura os pontos e tambm ser zerado algumas
variveis para que na prxima jogada no acontea nenhum problema.
Continuando a lgica que tinha sido imposto para a segunda jogada, ser a
vez de verificar o final da partida, atravs do mtodo 'verifica!inal6o8ogo45(, neste
mtodo ser verificado se o total de acertos foi igual ao total de figuras que tem na
jogada, ser comparado com a varivel 'quant1otoes-licados(, est varivel
alimentada cada vez que o jogador acerta um par de figuras. Se a varivel chegar ao
nmero de imagens que tiver na jogada, o que tem dentro do mtodo executado,
ou seja:
nsere um novo jogador no banco.
Mostra mensagem de parabns.
Para o som de fundo, e executa o som de final do jogo.
Chama a tela do final do jogo.
O cdigo para este processo ilustrado na figura (Figura 35) logo abaixo:
Figura : Mtodo 'verificaFinalDoJogo()'
Fonte: O autor.
Para conseguir inserir um novo jogador e deixar o mesmo armazenado, ser
preciso usar um banco de dados, para isso primeiro preciso criar uma classe
'8ogador.&ava(, para poder atribuir o nome, e os pontos. Est classe ser simples,
51
ser criada no diretrio 'src( dentro da pasta 'ob&etos( e ter apenas 3 atributos, o id,
o nome do jogador, e os pontos, ser necessrio tambm, criar um construtor e
gerar os mtodos get's e set's de todos os atributos.
Depois disso, preciso criar o banco de dados, e a tabela jogador, ser
preciso ento criar uma classe no diretrio 'src( dentro da pasta 'banco( com o nome
de '1anco6ados.&ava' essa classe ter o cdigo com os scripts para criao do
banco de dados e da tabela do jogador. Ainda nesta classe ter um mtodo esttico
que toda vez que chamado, fara a conexo com o banco de dados. O cdigo para
esta classe ficar como mostra a figura (Figura 36).
Figura : Classe 'BancoDados.java'
Fonte: O autor.
Criado os scripts para a criao do banco e da tabela, agora ser preciso
executar eles, como mostra a figura (Figura 36), dentro do mtodo 'get6145' feito a
instancia de uma classe chamada '0@Lite=elper' passando os scripts criados na
classe '1anco6ados.&ava( e retornado novamente o banco de dados.
Para que seja executado os scripts ento ser preciso criar a classe
'0@Lite=elper.&ava( que ficar no diretrio 'src( dentro da pasta 'banco( o cdigo para
esta classe ficar como mostra a figura (Figura 37).
52
Figura : Classe 'SQLiteHelper.java'
Fonte: O autor.
A classe 0@Lite=elper entende de 0@LiteApen=elper, com isso, ser
possvel criar os mtodo on-reate45 e on>pgrade45, esses dois mtodos, se
encarregaro de criar e atualizar o banco de dados, com os scripts que sero
passados para eles.
Agora ser preciso criar uma classe para gerenciar o banco de dados e criar
os mtodos para persistir e buscar estes dados, para isso, no diretrio 'src( dentro da
pasta 'ob&etos( ser criado a classe '8ogador6ao.&ava(, o cdigo para esta classe
ficar como mostra a figura (Figura 38).
Figura : Classe 'JogadorDao.java'
Fonte: O autor.
53
Para fazer a conexo com o banco 0@Lite, ser criado uma varivel da classe
'0@Lite6atabase(, essa classe permitir ter acesso a mtodos j criados como
insert, update e ainda possvel executar scritps prprios.
O mtodo 'salvar45' quando chamado, pegar os dados que foram passados
para a classe 8ogador, para fazer a persistncia dos dados. E o mtodo 'listar45'
buscara no banco todos os dados da tabela jogador que foi criado.
Agora que o banco de dados est configurado, preciso voltar ao mtodo
'insere8ogador45( e informar estas informaes a ele. O cdigo para este mtodo
ficar como mostra a figura (Figura 39).
Figura : Mtodo 'insereJogador'
Fonte: O autor.
Neste mtodo primeiramente feito uma verificao, para saber se a varivel
que recebe o nome do jogador e que foi passado na tela de configurao, vazia,
se for, ser atribudo um nome padro, chamado de "Player e aps est verificao
ser inserido o jogador, com o nome e o total de pontos que obteve no jogo. Este
mtodo executado dentro do mtodo 'verifica!inal6o8ogo45' que mostrado na
figura (Figura 35).
Continuando o processo do mtodo 'verifica!inal6o8ogo45' aps inserir o
jogador ser mostrado uma mensagem de parabns em ingls, que ficar
"Congratulations!, aps isso a tela de final do jogo chamada e o som de fundo
parado. No lugar do som de fundo e posto um som de sucesso. Para adicionar um
arquivo de udio com o Cocos2d muito fcil, com uma linha de cdigo j se
consegue adicionar o som, como exemplo a figura (Figura 40) mostra como fica a
linha de cdigo para o som.
Figura : Adicionando som
54
Fonte: O autor.
Com isso se termina todas as etapas da parte lgica do jogo, que seriam a
primeira jogada, a segunda jogada e em caso de erro, a volta das duas figuras a
serem escondidas. Essa etapa feita at o jogador conseguir chegar at a ultimo
par e conseguir vencer o jogo. Como mostra a figura (Figura 41).
Figura : Termino do jogo
Fonte: O autor.
4.3.4 %e!a Fina! do 2o#o
Quando o jogador vencer o jogo, vir a tela de final do jogo, indicando que o
jogo acabou. A tela final ter a imagem de background, uma imagem com a logo e
mensagem de que o jogador venceu, um boto para indicar o reinicio do jogo e mais
um boto, que servir de auxlio ao jogador, onde ele poder ver todas as imagens
novamente correspondente a categoria que escolheu, l ter a imagem e o
55
significado de cada uma delas em ingls e portugus, para fazer isso ser
necessrio criar uma nova classe que se chamara 'FinaDoJogo.java' esta classe
ser criada no diretrio 'src' dentro da pasta 'cenas' o cdigo para esta classe ficar
como mostra a figura (Figura 42).
Figura : Classe FinalDoJogo
Fonte: O autor.
Esta tela, no ser diferente das outras telas, ser implementado a interface
1utton6elegate e junto j ser criado o mtodo 'button-lic2ed45', para saber qual
boto ser clicado.
No Construtor da classe, ser adicionado a imagem de background, a
imagem da logo, com a descrio "Venceuuu!! e os dois botes, onde o boto jogar
novamente, direcionara para a tela de ttulo e o outro servir para acompanhar o que
viu durante o jogo. A tela ficar como mostra a figura (Figura 43).
56
Figura : Tela de final do jogo
Fonte: O autor.
4.3.5 %ira D=vidas
Quando o boto "Tire dvidas! reveja o que viu nesta partida for clicado pelo
jogador, ser executada uma inteno e carregara uma outra tela, que ser feita por
uma activity e um arquivo xml.
Para isso, primeiramente ser preciso criar a classe 'Btens7ctivit..&ava( na raiz
do diretrio 'src' nesta classe, dentro do mtodo, onCreate() ter o seguinte cdigo.
Figura : Mtodo 'onCreate()' da classe 'tensActivity.java'
Fonte: O autor.
57
Junto com est activity, ser criado o layout xml, por isso, no diretrio 'res(
dentro da pasta 'la.out( ser criado o arquivo xml 'activit.9final9list.xml(, neste
layout, ser adicionado uma ListView, onde ser preenchida com as imagens que foi
processado o jogo.
Com o layout criado, ser a vez de executar o mtodo
'verifica-ategoriaEApcao45' neste mtodo ser verificado qual categoria e dificuldade
o jogador escolheu no jogo, quando ele, achar qual foi estas opes executara o
mtodo 'populateBtemList!rutasEas.45( ou o mtodo de acordo com a opo que o
usurio escolheu. Antes de executar algum desses mtodos, preciso criar uma
classe que se chama 'Btem.&ava(, ser criada no diretrio 'src( dentro da pasta
'ob&etos(, essa classe ser simples, ter apenas 3 atributos entre eles, a descrio
da imagem, a imagem que ser do tipo 'int( e a traduo da imagem. Depois de criar
os atributos ser necessrio tambm criar o construtor da classe e os get(s e set(s de
cada atributo.
Depois de criado a classe tem, ser necessrio instanciar a mesma na
activity Btens7ctivit., alm de instanciar, ser preciso criar uma lista de itens, o
cdigo para isso visualizado na figura (Figura 45).
Figura : Lista de tem
Fonte: O autor.
Agora preciso popular esta lista, ou seja, est lista de itens preenchida,
atravs do mtodo 'populateBtemList!rutasEas.45(. O cdigo para estes mtodos
ficaro como exemplo da figura (Figura 46).
Figura : Mtodo 'populatetemListFrutasEasy()'
Fonte: o autor.
58
Lembrando que para cada categoria ou dificuldade, ter um mtodo,
semelhante ao 'populateBtemList!rutasEas.45(, a diferena ser somente a
quantidade de itens, e o tipo da categoria.
Feito isso, o mtodo 'verifica-ategoriaEApcao45' j estar completo e j
possvel verificar qual tipo de categoria e dificuldade sero adicionados.
O prximo passo o mtodo 'populateList,ie$45(, ou seja at o momento,
com o mtodo 'verifica-ategoriaEApcao45 foi possvel adicionar vrios itens dentro
de uma lista, agora ser preciso adicionar cada item dessa lista na List,ie$ que foi
criada no layout 'activit.9final9list.xml(.
Primeiramente ser preciso criar mais um arquivo xml, que ser chamado de
'activit.9final9item.xml(, neste arquivo ser criado trs widgets, o primeiro ser uma
Bmage,ie$, este componente recebera a figura correspondente a categoria que o
jogador escolheu antes de iniciar a partida e as outras duas sero /ext,ie$, um
deles recebera o significado da imagem em ingls e o outro em portugus, os trs
componentes ficaro em uma nica linha, um do lado do outro, ou seja, essa linha
que foi criada com os trs componentes alinhados na vertical, correspondera a uma
linha da List,ie$.
Agora preciso relacionar os item da lista de tem 'items(, com o item do xml
'activit.9final9item.xml(, com isso, cada item da lista, 'items(, ser aplicado na
ListView, como um item do xml 'activit.9final9item.xml(. O cdigo para esse
procedimento ficar como mostra a figura (Figura 47):
59
Figura : Mtodo 'populateListView()'
Fonte: O autor.
Feito isso, o resultado de quando o boto "Tire dvidas! reveja o que viu nesta
partida da tela de final do jogo for pressionado, ficar como mostra a figura (Figura
48).
Figura : Tela de tira dvidas
Fonte: O autor.
60
4.3.6 "onua<>o
Com isso termina a partida do jogo, mas ainda ser preciso montar a tela de
pontuao e uma tela descrevendo um pouco sobre o jogo, portanto ser preciso
voltar para a tela de ttulo, l tm-se mais dois botes, onde um serve para exibir a
tela de pontuao e o outro para ajudar o jogador a entender como funciona o jogo.
Por primeiro ser desenvolvida a pontuao, que ser uma parte fundamental
do jogo, ou seja, a teoria de Flow impem que criar uma certa dificuldade ou gerar
competitividade, tambm gera prazer para diversos jogadores, fazendo deste jogo,
viciante e fascinante, ou seja, este jogador que se sentiu feliz ao joga-lo, voltara para
jogar novamente.
Para desenvolver a tela de pontuao, praticamente ser usado a mesma
lgica que foi imposta para a tela de tirar dvidas, no final do jogo. Para isso ser
preciso criar uma activity na raiz do diretrio 'src' que se chamar,
'8ogador7ctivit..&ava(, nesta activity ter o mtodo 'on-reate45( usado para mostrar o
contedo que ter no layout xml que ser criado para carregar a lista de pontuaes.
Basicamente sero duas etapas, buscar no banco de dados, todos os jogadores
com seus respectivos pontos, pegar este resultado e adicionar em uma List,ie$.
Lembrando que est classe precisa entender de 'List7ctivit.', pois ser necessrio
usar alguns mtodos dessa classe. O cdigo para o mtodo 'on-reate45( ficar como
mostra a figura (Figura 49).
Figura : Classe 'JogadorActivity.java'
Fonte: O autor.

No diretrio 'src( dentro da pasta 'adapter' ser criado a classe
'8ogador7dapter.&ava(, est classe, ter o trabalho de pegar a lista de jogadores e
61
introduzir objeto por objeto dentro de uma List,ie$, para isso ser preciso criar o
layout que recebera a List,ie$, ser criado no diretrio 'res( dentro da pasta 'la.out'
e se chamara 'activit.9&ogador9list.xml(, dentro deste layout ser apenas adicionado
a List,ie$.
Agora preciso criar o layout do item, que preenchera a List,ie$, ento
novamente ser criado no diretrio 'res( dentro da pasta 'la.out( e se chamara
'activity_jogador_item.xml'. Dentro deste layout ser adicionado apenas dois
TextView, um deles, ser o nome do jogador, e o outro a pontuao.
Os dados de pontuao so resgatados atravs do mtodo 'listar45( j criado
na classe '&ogador6ao.&ava(, o retorno desta lista ser passado para uma lista de
jogadores e com a lista em mos, ser preciso criar uma nova classe para que seja
feita a gravao de cada item na List,ie$, basicamente ter a mesma lgica feita na
List,ie$ de tira dvidas. O cdigo para esta classe ficar como mostra a figura
(Figura 50).
Figura : Classe 'jogadorAdapter.java'
Fonte: O autor.
Feito isso faltara apenas executar todo este processo, usando o mtodo da
classe 'setList7dapter45(, passando como parmetro a instncia feita pela classe
JogadorAdapter. O resultado para est classe ficar como mostra a figura (Figura
51).
62
Figura : Tela de pontuao
Fonte: O autor.
Para finalizar a tela de posies, preciso ordenar a pontuao, para que se
saiba quem est liderando o placar do jogo, esse passo ser simples, apenas ser
acrescentado o mtodo '-ollections.sort4&ogadores5C' dentro do mtodo 'on-reate45'
da classe '8ogador7ctivit.', feito isso a pontuao ser ordenada, e o jogador com
maior pontuao, ficar no topo da lista.
Ainda ser preciso construir um mtodo para excluir um jogador da lista de
pontuaes e para isso ser preciso saber qual item da lista foi selecionado, para
depois apagar o registro do banco. Lembrando que quando for selecionado algum
jogador, ser preciso interagir com o jogador, solicitando uma confirmao desta
ao, ou seja, verificar se ele realmente quer apagar aquele jogador.
O mtodo para saber em qual posio ou qual jogador foi selecionado, ser o
onListtemClick, com este mtodo, possvel saber qual posio foi selecionado da
lista. Aps saber qual a posio, ser possvel apagar o jogador, comparando a
63
posio selecionada da ListView, com a posio da lista de jogadores. Antes de
apagar o jogador, necessrio criar um AlertDialog, pedindo a confirmao da
excluso.
O prximo passo ser atualizar a lista, para que o jogador excludo saia da
ListView, para isso ser criado um mtodo, onde ser limpada a lista e adicionada
novamente. cdigo para todo este processo ficar como mostra a figura (Figura 52).
Figura : Mtodos 'onListtemClick()' e 'atualizaLista()'
Fonte: O autor.
4.3.7 &o+re
Para finalizar o desenvolvimento deste jogo, ser feito um pequeno Dialogo,
descrevendo um pouco sobre o jogo, para isso ser criado um layout xml com o
nome de 'dialog9help.xml' e nele ser adicionado dois TextView, em um deles ser
adicionado o ttulo e o outro o texto. Ter tambm um Button, para fechar o Dialog. O
cdigo e a tela sero mostradas nas figuras (Figura 53) e (Figura 54).
64
Figura : Mtodo 'criaDialogHELP()'
Fonte: O autor.
Figura : Dialog de Ajuda
Fonte: O autor.
65
5 CON&IDERA)?E& FINAI&
Com base em um jogo da memria convencional, foi possvel relacionar o
jogo, com a lngua inglesa, essa interao acontece quando o jogador acha o par de
figuras, que ento exibido em um formato de mensagem na tela, isso tudo em
ingls, o jogo ainda, teve a implementao que a teoria de flow impem, fazendo
que o jogo no saia do foco e acabe ficando cansativo e chato.
Atravs deste trabalho afirmo que apesar de estar falando do
desenvolvimento de um jogo, foi de simples desenvolvimento e sem maiores
complicaes. Desenvolver para Android foi uma experincia sensacional, despertou
muito interesse e vontade de ir mais afundo em questo de games, ainda mais com
o auxlio que o framework Cocos2d trouxe neste projeto. Este framework, ainda tem
muitas funcionalidades a serem exploradas, pode-se dizer que de todas as
funcionalidades que existem, foi usado somente 30% de todo o potencial que ele
dispem.
Com tudo o propsito do projeto foi atingido, o jogo foi desenvolvido e a
cativao do pblico alvo est presente, incentivando o usurio a competir e se
envolver com ele, fazendo com que o jogador aprenda todas as categorias que
estavam adicionadas no projeto.
Algumas dificuldades foram encontradas durante o desenvolvimento do jogo
com o framework Cocos2D, como a insero de Widgets, para fazer a interao com
o jogador, para solucionar este pequeno problema, foi preciso usar componentes do
Android e criar arquivos xml para interligar com o Cocos2D.
Como sugestes futuras, deixo um convite para o pesquisador que se
interessar, desenvolver ainda mais as habilidades do ingls, como por exemplo,
adicionar arquivos de udio na descrio de cada figura, gerar uma interao com o
jogador durante e no final de cada partida, acrescentar em cada acerto uma
premiao ao jogador deixando o jogo ainda mais divertido.
66
REFER@NCIA&
DAMBROSO, Naiara Joo Karina Viviane de et al. "roposa DidAicoB"eda#3#ica
de L-n#ua In#!esa. Xanxer: Grafica mpramax, 2007. 112p.
DASHBOARDS, junho 2013. Disponvel
em:<http://developer.android.com/about/dashboards/index.html>. Acesso em: 08 jun.
2013.
DVERSO, Jogos de Memria Online Exerccio e. 2o#os de Mem3ria On!ine C
EDerc-cio e Divers>o. 2013. Disponvel em:
<http://www.ancorador.com.br/tecnologia/jogos/jogos-de-memoria-online-exercicio-e-
diversao>. Acesso em: 01 jun. 2013.
FERRARN, Algusto. Conhecendo o Android. Mobile Magazine, Edio 42 04-11.
2012.
GETTNG Started with Android Studio, maio 2013. Disponvel em:
<http://developer.android.com/sdk/installing/studio.html>. Acesso em: 07 jun. 2013.
GRADLE: The New Android Build System, maio 2013. Disponvel
em:<http://www.gradleware.com/resources/tech/android>. Acesso em: 14 nov. 2013.
LETE, Anderson. Desenvo!vimeno de 2o#os para AndroidE explore sua
imaginao com o framework Cocos2D. So Paulo: Casa do Cdigo, 2012. 170p.
NETWORK, Oracle Technology. 2ava e Oriena<>o a O+,eos. Disponvel em:
<http://www.caelum.com.br/apostila-java-orientacao-objetos/>. Acesso em: 28 abr.
2013.
MANZANO, Adriana; DOHME, Vanessa. As vana#ens do uso de aividades
!=dicas no ensino de idiomas. Disponvel em: <http://www.sbs.com.br/e-talks/as-
vantagens-do-uso-de-atividades-ludicas-no-ensino-de-idiomas/>. Acesso em: 31
maio 2013.
MAURCO, Juliana Tavares. Aprender BrincandoE O L=dico na Aprendiza#em.
Disponvel em: <http://www.profala.com/arteducesp140.htm>. Acesso em: 31 maio
2013.
67
SELGMAN, Martin. Fe!icidade au1nica: usando a nova psicologia positiva para a
realizao permanente. Rio de Janeiro: Objetiva, 2004. 333 p.
VASCONCELOS, Nelson Glauber de. &5Lie no Android. Disponvel em:
<http://www.devmedia.com.br/websys.4/webreader.asp?
cat=5&revista=webmobile_34 - a-3249>. Acesso em: 01 maio 2013.