jogo da memÓria em android para prÁtica de palavras em ingles usando cocos2d e teoria de flow
DESCRIPTION
Trabalho de Conclusão de Curso (TCC) do Acadêmico Ricardo Sassanovicz na Universidade do Oeste de Santa Catarina Unoesc.TRANSCRIPT
UNIVERSIDADE DO OESTE DE SANTA CATARINA – UNOESC
RICARDO SASSANOVICZ
JOGO DA MEMÓRIA EM ANDROID PARA PRÁTICA DE PALAVRAS EM INGLÊS
USANDO COCOS2D E TEORIA DE FLOW
Xanxerê – SC
2013
RICARDO SASSANOVICZ
JOGO DA MEMÓRIA EM ANDROID PARA PRÁTICA DE PALAVRAS EM INGLÊS
USANDO COCOS2D E TEORIA DE FLOW
Trabalho de Conclusão de Curso apresentado ao CursoSuperior de Tecnologia em Análise e Desenvolvimento deSistemas, Área de Ciências Exatas e da Terra, da Universidadedo Oeste de Santa Catarina, como requisito à obtenção dograu de Tecnólogo em Análise e Desenvolvimento de Sistemas.
Professor orientador: Cristiano Agosti
Xanxerê – SC
2013
RICARDO SASSANOVICZ
JOGO DA MEMÓRIA EM ANDROID PARA PRÁTICA DE PALAVRAS EM INGLES
USANDO COCOS2D E TEORIA DE FLOW
Trabalho de Conclusão de Curso apresentado ao CursoSuperior de Tecnologia em Análise e Desenvolvimento deSistemas, Área de Ciências Exatas e da Terra, da Universidadedo Oeste de Santa Catarina, como requisito à obtenção dograu de Tecnólogo em Análise e Desenvolvimento de Sistemas.
Aprovada em
BANCA EXAMINADORA
________________________________________
André Luiz Forchesatto
________________________________________
Rosicler Felippi Puerari
________________________________________
Cristiano Agosti
AGRADECIMENTOS
Agradecer primeiramente a Deus por me dar sabedoria, paciência e força a
cada dia.
Agradeço a minha família que por todo esse tempo esteve sempre disposta a
me ajudar e me apoiar.
A minha namorada Cintia Cella, que por vários dias dedicou grande parte do
seu tempo para me ajudar e incentivar a realizar esse trabalho, não só durante esse
período mas sim em todos esse maravilhosos anos.
Agradeço ao meus colegas de trabalho que disponibilizaram um pouco do seu
tempo para me ajudar a desviar os obstáculos e dar um passo final a esse projeto.
Ao professor Cristiano Agosti, que orientou este projeto e a meu amigo Victor,
por também 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 memória para o resto de sua vida, as coisas boas que surgiram nomeio das dificuldades. Elas serão uma prova de sua capacidade em vencer asprovas e lhe darão confiança na presença divina, que nos auxilia em qualquer
situação, em qualquer tempo, diante de qualquer obstáculo.”Chico Xavier
RESUMO
De acordo com muitas pessoas, os dias, estão passando muito rápido, motivo de
muito trabalho e pouco tempo para lazer. Diante desse fato, surgiu a necessidade de
desenvolver um jogo, para cativar as pessoas que não possuem tempo livre no dia a
dia e que gostariam de aprender uma nova linguagem, como o inglês. Para associar
o inglês, a memorização de palavras, e o curto tempo, foi desenvolvido um jogo da
memória para a plataforma Android, que por sua vez é usada em smartphones e
tablets. Para auxiliar no desenvolvimento, o framework Cocos2d também é usado,
melhorando ainda mais as interfaces que o jogo possuir. Neste jogo, o jogador
poderá estar visualizando em cada acerto de figuras a descrição dela em inglês.
Para não perder o foco, e não deixar que o jogo fique chato, o desenvolvimento do
jogo é feito utilizando a teoria de Flow, juntamente com o conceito dos jogos lúdicos.
Palavras-chave: Jogo. Memória. Android. Cocos2d. Teoria de Flow. Inglês.
ABSTRACT
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. In 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.
LISTA DE FIGURAS
SUMÁRIO
1 INTRODUÇÃO......................................................................................................... 14
1.1TEMA......................................................................................................................14
1.2 PROBLEMA...........................................................................................................14
1.3 OBJETIVOS.......................................................................................................... 15
1.3.1Objetivo Geral......................................................................................................15
1.3.2Objetivos Específicos.......................................................................................... 15
1.4JUSTIFICATIVA......................................................................................................15
2 FUNDAMENTAÇÃO TEÓRICA................................................................................17
2.1LINGUAGEM INGLESA PARA BRASILEIRO........................................................ 17
2.1.1As quatro habilidades no aprendizado do inglês................................................ 17
2.2ATIVIDADES LÚDICAS..........................................................................................17
2.2.1Jogo da memória.................................................................................................18
2.3TEORIA DE FLOW.................................................................................................18
2.4ANDROID............................................................................................................... 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
3METODOLOGIA........................................................................................................24
4DESENVOLVIMENTO...............................................................................................25
4.1FUNCIONAMENTO DO JOGO.............................................................................. 25
....................................................................................................................................25
4.2CONFIGURAÇÃO.................................................................................................. 26
4.3PROGRAMAÇÃO...................................................................................................27
4.3.1Tela de Título....................................................................................................... 27
4.3.2Tela de Configurações.........................................................................................30
4.3.3Tela do Jogo........................................................................................................ 31
4.3.4Tela Final do Jogo............................................................................................... 39
4.3.5Tira Dúvidas.........................................................................................................40
4.3.6Pontuação........................................................................................................... 41
4.3.7Sobre................................................................................................................... 43
5CONSIDERAÇÕES FINAIS...................................................................................... 45
REFERÊNCIAS........................................................................................................... 46
11
1 INTRODUÇÃO
Vive-se em um mundo globalizado e que ainda há pessoas que não
conseguem aprender um segundo idioma por vários motivos. Essas dificuldades
ficam ainda maior quando estuda-se por conta própria, sem professor ou alguém
com mais experiência na língua para ajudar. Infelizmente devido ao estilo de vida
que a maioria da população leva, principalmente das grandes cidades, tem-se pouco
tempo para dedicar ao estudo de um idioma, é uma tarefa árdua ou quase
impossível para muitas pessoas, e que por isso acabam por desistir de aprender
uma segunda língua, como o inglês.
Para ajudar estas pessoas, o conteúdo deste trabalho será o
desenvolvimento de um aplicativo para smartphone, usando teorias para
desenvolvimento de jogos juntamente com a prática dos jogos lúdicos, agrupando
tudo isso em uma maneira de ajudar na memorização de palavras em inglês, através
de um jogo da memória.
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 usuários, e além do mais é um
software gratuito, suprindo assim uma maior quantidade de usuários interessados no
aplicativo.
O aplicativo será gratuito e destina a todo o público que tem dificuldade em
gravar palavras da linguagem inglesa, e que não 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 memória.
1.1 TEMA
Desenvolvimento de um Jogo da memória na plataforma Android, usando o
framework Cocos2D para auxiliar na memorização de palavras da língua Inglesa.
12
1.2 PROBLEMA
A língua inglesa atualmente não é mais propriedade exclusiva dos ingleses,
pois, é a língua de escolha em todo o mundo para comunicação entre pessoal de
diferentes culturas. Erros são cometidos no momento de desenvolver esta
linguagem, estes erros estão vinculados diretamente a cultura, hábitos de
comunicação e vícios de linguagem.
Os usuários brasileiros da língua inglesa são forte exemplo desses erros, pois
costumam deixar o português influenciar sobre o inglês. E além disso o dia a dia
está cada vez mais corrido, deixando assim quem gostaria de estar se envolvendo
mais com está língua, sem tempo para isso.
No entanto, a intenção principal do aplicativo é auxiliar no desenvolvimento do
inglês para usuários que possuem dificuldade com o mesmo, e que não tem muito
tempo disponível durante o dia. Através deste aplicativo, o objetivo é elaborar um
método com que a pessoa que esteja jogando, possa evoluir a sua memória visual.
Geralmente no inglês existem habilidades que podem ajudar na sua fixação, como
ler, escrever, ouvir e falar, ou seja, utilizar estas habilidades durante o jogo, para
melhor fixação.
A grande maioria da população atual, possui como aparelhos celulares, um
smartphone, então surgiu um segundo desafio, o qual constitui a análise de como
desenvolver um aplicativo para a plataforma Android. Para auxiliar no
desenvolvimento também irá ser usado um framework específico para jogos, o
framework Cocos2D.
1.3 OBJETIVOS
1.3.1 Objetivo Geral
Desenvolver um aplicativo para a plataforma Android, com a intenção de
auxiliar na fixação do inglês, através de um jogo de memória.
13
1.3.2 Objetivos Específicos
• Entender como funciona um jogo de memória e as atividades lúdicas.
• 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 JUSTIFICATIVA
O Inglês é uma linguagem estrangeira classificada como o terceiro idioma
mais falado do mundo, e para os currículos brasileiros está sendo um grande
requisito na maioria das áreas trabalhistas, sendo assim, ainda muitos Brasileiros
tem dificuldade na aprendizagem desta língua.
Para melhor fixação a aprendizagem de palavras em inglês surgiu a
necessidade de implementar esta aprendizagem de um modo divertido onde cada
usuário poderia acessar seu dispositivo móvel nas suas horas vagas, para passar o
seu tempo aprendendo e se divertindo ao mesmo tempo. Então surgiu a ideia de
fazer um jogo da memória, 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 inglês através da
memória visual adquirida no jogo. Este aplicativo terá ainda auxílio de um framework
chamado de Cocos2d, que através de seus componentes, irá facilitar o
desenvolvimento.
14
2 FUNDAMENTAÇÃO TEÓRICA
2.1 LINGUAGEM INGLESA PARA BRASILEIRO
A necessidade de se ter um segundo idioma hoje é inevitável, quando
procuramos emprego, a maioria das empresas exigem ter um segundo idioma onde
geralmente é o inglês, pelo fato de ser uma linguagem utilizada no mundo todo. O
importante também é que aprendemos uma linguagem estrangeira não apenas para
conseguir entrar no mercado de trabalho, mas para interação no mundo
social(acadêmico, cientifico, tecnológico, 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 avanço da tecnologia e da internet, a linguagem inglesa é a que
está mais presente no cotidiano do brasileiro.
Está língua 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 cabeça, 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 são alguns itens de habilidades do aprendizado do inglês
(HARASIN et al, 2005).
2.1.1 As quatro habilidades no aprendizado do inglês
A língua inglesa é a primeira opção de segunda língua utilizada em todo o
mundo, pode se afirmar que é uma língua universal, a língua de referência para
comunicação entre as pessoas em qualquer meio. Escrever, falar, ouvir e ler são as
quatro habilidades que utilizamos para nos comunicar, e são necessárias no
momento da aprendizagem de uma língua para que esta seja desenvolvida com
fluência.
15
Para o mercado de trabalho a língua inglesa se tornou essencial na conquista
de vagas. O principal objetivo de contratar um funcionário que domine fluentemente
a língua inglesa é a comunicação e a troca de informações entre as empresas, pelos
seus representantes independente de suas origens. Desenvolvimento, crescimento e
ampliação dos conhecimentos enriquecendo a cultura do indivíduo é outro
importante fator que trás inúmeras vantagens a quem domina o inglês. Com a
internet, para uma pesquisa eficiente e avançada é fundamental o conhecimento do
inglês.
Inúmeros são as vantagens de um brasileiro aprender e desenvolver
fluentemente a língua inglesa, porém, atualmente a maioria da população brasileira
se enquadra no nível básico à intermediário, o domínio com fluência ainda é um
diferencial para conquistar cargos mais altos. Para se ter este domínio não existem
métodos milagrosos e sim é necessário desenvolver as quatro habilidades da língua
com excelência. O ensino da escrita e da leitura e várias aulas voltadas a
conversação desenvolvendo também a habilidade auditiva são necessários para se
alcançar este objetivo, possuindo assim um ótimo currículo e um amplo
enriquecimento cultural.
2.2 ATIVIDADES LÚDICAS
O lúdico tem sua origem na palavra latina "ludus" que quer dizer "jogo”. Se
achasse confinada a sua origem ?, o termo lúdico estaria se referindo apenas ao
jogar, ao brincar, ao movimento espontâneo. A ideia é que o lúdico seja visto de uma
maneira mais geral, associada ao aprender brincando. O desenvolvimento do
aspecto lúdico facilita a aprendizagem do desenvolvimento pessoal, social e cultural,
e ainda colabora para uma boa saúde mental.(MANZANO, 2013).
Segundo Maurício (2013), A lúdicidade é assunto que tem conquistado espaço
no panorama nacional, principalmente na educação infantil, por ser o brinquedo, a
essência da infância e seu uso permitirem um trabalho pedagógico que possibilita a
produção 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
memória também tem como característica isso, aprender brincando, ao mesmo
tempo que você se diverte você estará memorizando as palavras que encontrou.
2.2.1 Jogo da memória
Antigo Egito, países do Oriente Médio, China, várias são as suspeitas de
onde surgiu o jogo da memória. Este jogo tem seu surgimento há muitos anos,
podendo ser afirmado, que sua origem é uma das mais antigas. Por esse motivo se
tem grande dúvida do local onde ele surgiu, o porquê surgiu, e como começou a ser
jogado. Certamente foi inventado ainda antes da escrita, antes de se ter uma história
do homem, pois para sua realização é necessário 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. (DIVERSÃO, 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 opção de escolha, sendo independente das
diferenças culturais e religiosas. É um jogo capaz de exercitar a criatividade e a
memória de qualquer pessoa. Levando o ser humano a treinar a memória visual
armazenada no cérebro e também a criatividade para escolha do tema.
Com o surgimento da internet, o jogo da memória pode começar a ser jogado
através dela, levando assim a sua maior dissipação pelo mundo e a escolha de
muitos temas diferentes, variando do gosto de cada jogador. Na internet
encontramos muitos temas como, os desenhos clássicos da Disney; os heróis da
Marvell; super heróis como o Batman, a Mulher maravilha e o Super Homem; figuras
geométricas; desenhos engraçados com personagens cômicos; símbolos religiosos
e personagens famosos do mundo dos vídeos games.
O que realmente importa é que o jogo da memória tanto real quanto virtual é
uma maravilhosa fonte para diversão, aprendizado e treinamento da memória.
Sendo independente do seu tema, sua aplicação é efetiva tanto em crianças, adultos
e idosos, principalmente em crianças em formação e idosos com problema de
17
memória. Tornando momentos em família um passatempo saudável, com grande
alegria, enquanto se exercita o cérebro.
2.3 TEORIA DE FLOW
Criada pelo psicólogo Mihaly Csikszentmihalyi, a teoria de flow se aplica a
vários comportamentos do ser humano, a teoria de certo modo é interpretada em um
estado que o ser humano pode alcançar quando realiza determinadas atividades
que envolvem a felicidade, ou seja os prazeres e as gratificações.
(SELIGMAN,2004).
Os prazeres são atividades que geram alegria, satisfação, algo que venha
deixar a pessoa relaxada e confortável como por exemplo, comer chocolate, ver TV
por quanto tempo quiser, fazer alguma atividade que quando completada deixe com
uma sensação de bem-estar.
Para compreender as gratificações Seligman (2004, p. 254) destaca que:
Jogar uma partida de tênis que exija da nossa capacidade é agradável,assim como ler um livro que nos traga revelações ou ter uma conversa quenos leve a expressar ideias que nem sabíamos ter. Fechar um negócio oudar por terminado um trabalho bem feito é agradável. Talvez nenhumadessas experiências seja especialmente prazerosa no momento em queacontece, mas, depois, ao lembrar, dizemos “Foi bom”, e gostaríamos queacontecessem 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 concentração.
Quando o assunto é jogos, pode ser compreendido comparando dois estados,
os jogos casuais e jogos hardcore. Casuais são jogos que possui um nível mais fácil
de compreensão e que não exigem muito de atenção excessiva, relaxando a mente
de quem está jogando. Pode se interpretar os jogos casuais como se estivessem
jogando mais por passatempo, diversão simples e rápida, encarando o jogo com
meros prazeres.
Já os jogadores hardcore, são aqueles que gostam de jogos desafiadores e
bem complexos, gostam de tarefas árduas e que nelas conquiste algo, como por
18
exemplo, um troféu, e ao finalizar ter suas habilidades superadas, sentindo excitação
por isto.
O que faz está teoria muito especial, principalmente para desenvolvedores de
jogos, é que podem ser desenvolvidos, com a mesma linha de raciocínio, focando
em qual vai ser o público do jogo e desenvolver de um método que não tire o foco do
estado de flow, mantendo sempre uma estabilidade entre habilidades e desafio,
assim chegando ao sucesso de seus jogos.
2.4 ANDROID
Android é um sistema operacional, direcionado para aplicativos de aparelhos
móveis com uma grande capacidade de memória e processamento, como
smartphones e tablets, isso tudo começou quando a Google comprou a Android Inc.
uma pequena empresa na Califórnia, desde então o Android é desenvolvida pela
Open Handset Alliance, um grupo que reúne várias empresas, dentre elas a Google.
Como vários outros sistemas operacionais o Android também é baseado em Linux e
está sendo desenvolvido desde 2005.
Em 2007 saiu a primeira versão do Android, se tratava de uma versão Beta,
ainda não muito confiável, pois estava em testes, não tinha documentação e ainda
nenhum aparelho rodando Android estava disponível. O Android veio com objetivos
tanto para o usuário final quanto para o desenvolvedor. Diante disso Ferrarini (2012,
p. 04) destaca que:
Para o usuário final, o Android tem o objetivo de ser um sistema voltado àconectividade, localização e preferências do usuário. Trocando em miúdos,ele pretende ser extremamente personalizável e, acima de tudo, tirar proveitoda Internet e dos Serviços em Nuvem. Para o desenvolvedor de software, temo propósito de permitir a criação rápida e descomplicada de aplicaçõesnativas, incorporando no seu framework diversas ferramentas que auxiliam oprocesso de codificação e preparação do software para o mercado, como porexemplo, a possibilidade da concepção de interfaces gráficas inteiramente emXML, recursos avançados de internacionalização e distribuição de aplicativospelo Google Play.
19
O desenvolvimento para a plataforma Android é baseado na linguagem Java1,
com uma estrutura completa e uma grande quantidade de recursos disponíveis
como: armazenamento, conectividade, áudio, vídeo e muito outros. Além disso a
plataforma é de código aberto, permitindo fabricantes de aparelhos realizarem
alterações no código do Android, para deixar com a cara do aparelho, e o melhor de
tudo é que não tem custo. Isso é valido para qualquer desenvolvedor, podendo
pegar o código puro e modifica-lo com a sua cara, e assim podendo contribuir para
melhorias.
Para desenvolver na plataforma é necessário o conhecimento da linguagem
Java e para a parte de criação 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 necessários.
2.4.1 Android SDK
O Android SDK contém todas as ferramentas necessárias para a construção,
depuração e testes de um projeto, está ferramenta é fornecida gratuitamente pela
Google e contém total consonância com a linguagem Java.
O SDK também traz um emulador próprio, chamado de AVD Manager, que é
possível fazer testes sem usar o smartphone ou tablet, pois o mesmo faz o trabalho
de um aparelho real.
Na Google IO de 2013 foi anunciado a nova IDE para desenvolvimento em
Android, que foi chamado de Android Studio, essa IDE contém 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
versão inacabada, e pode vir a surgir bugs durante o desenvolvimento (GETTING,
2013).
O Android Studio traz ainda mais novidades para os desenvolvedores, ou seja
a construção dos projetos agora será feita por uma ferramenta chamada de Gradle e
traz uma proposta de ser flexível e de fácil manipulação, com uma simples linha de
1� Linguagem de programacão.
20
código 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 AndroidFonte: O autor.
Gradle é similar a ferramenta Maven2, mas é baseada em trabalhos e conceito
diferente, tudo para simplificar o código e auxiliar o programador. (GRADLE, 2013).
2.4.2 Banco de dados SQLite
Banco de dados é um componente do sistema indispensável, ou seja, a
maioria das aplicações hoje em dia, possui um repositório para a persistência de
seus dados, e é considerado um dos pontos principais, no desenvolvimento de uma
aplicação.
Antigamente, o armazenamento dos dados de um sistema era feita através de
arquivos do próprio sistema operacional, e isso gerava uma complexidade para os
programadores, ou seja, o sistema era que deveria gerenciar estes arquivos, definir
a localização, controle de segurança, 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 aplicação cliente, o gerenciamento de acesso, manipulação e
organização dos dados. (SQLite, 2011)
Para aplicações de dispositivos moveis, a falta de recurso como memória,
processador e armazenamento, fazem com que os desenvolvedores não 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 restrição
de linguagens, com objetivo da manipulação dos dados utilizando instruções em
SQL.
2� Ferramenta de automação de compilação.
21
O desenvolvedor pode criar o banco de dados e as tabelas, também pode
manipular seus dados através dos comandos do SQL padrão. O SQLite também
disponibiliza já os serviços de persistência de dados, com isso trazendo um ganho
considerável de produtividade.
2.4.3 Versões
Existem diversos tipos de versões, que atualmente são usadas para
desenvolvimento, e que estão ainda sendo rodadas em vários aparelhos no
mercado, segundo estatísticas do site de developer’s do Android, as duas versões
que atualmente estão sendo mais ocupadas no mercado são as 2.3.x Ginger Bread
com 36,4% e a 4.1.x Jelly Bean com 29.0% (DASHBOARDS, 2013).
Com base nestas estáticas o projeto será construído com a versão 4.1.x Jelly
Bean, por ser uma versão um pouco mais recente e que está com um grande
numero de usuários e tem um numero maior de API’s, o que ajuda no
desenvolvimento e na usabilidade das funções que os aparelhos oferecem.
A versão que será utilizada também é compatível com o framework3 que será
utilizado na aplicação.
2.5 FRAMEWORK COCOS2D
O Cocos2D foi criada por Ricardo Quesada (2008), é um framework de código
aberto para a construção de jogos 2D, demonstrações e outras aplicações gráficas.
Cocos2d foi desenvolvido em Python e desde então foi portada para diversas
linguagens como C++, JavaScript, Objective-C e Java (LEITE, 2013).
3� Conjunto de classes que colaboram para realizar uma responsabilidade para um domínio de um subsistema da aplicação.
22
O Cocos2d é de código aberto. Isto significa que não há restrição alguma
que impeça de aprender com o código do mecanismo de jogos, ou de fazer
alterações nele, onde for necessário.
O framework Cocos2D na plataforma Android utiliza a linguagem Java para
ser codificado. Aborta uma comunidade open source e sempre tem alguém pronto
para responder a uma questão, e os desenvolvedores, em geral, estão abertos ao
compartilhamento de conhecimentos e informações.
As principais características que incluem neste framework é: Controle de
fluxo, Sprites, Maps, Transitions, Menus, Renderização de texto, BSD License,
OpenGL Based: a aceleração 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 referência no Build-Path da aplicação.
2.5.1 Layers
Segundo Leite (2012, p57) “Criar telas com o CCLayer do Cocos2D é criar
telas pensando em camadas que se sobrepõem. Essas camadas são transparentes,
a menos quando definidas de outra forma, e quando colocadas uma sobre as outras
definem a tela final.”
Layers nada mais é que várias telas com o fundo transparente e quando
estão 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 não só para o desenvolvimento de jogos e ao Cocos2D, mas para vários
outras ferramentas. Também pode ser representada pela figura (Figura 1) abaixo:
23
Figura : Exemplo com vários LayersFonte: 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 vários Layers para edição de fotos, e que quando todas
juntas representam uma única imagem, e com a opção para alterar a imagem
separadamente por layer.
2.5.2 Scenes
Outro objeto importante do Cocos2D são as Scenes. A Scene é um pedaço do
fluxo do jogo mais ou menos independente, a ideia é que com estas Scenes
poderíamos inicializar telas do jogo. Um jogo pode ter quantas Scenes forem
necessárias, porém apenas uma poderá estar ativa por vez.
Scene é implementado pela Classe CCScene no Coco2D. Cada CCScene
possui no mínimo 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 configuração, etc.
24
2.5.3 Sprites
Umas das vantagens de utilizar Sprites como objetos do Cocos2D é que
ganhamos algumas possibilidades de animação. Os Sprites são em sua essência,
uma imagem grande que consiste em várias outras imagens menores, (geralmente
do mesmo personagem ou objeto, em diferentes fases de uma animação), sendo
assim, é acompanhado por um segundo arquivo, chamado de lista de propriedade,
que contém as coordenadas para cada imagem individual dentro da folha de Sprite
principal (LEITE, 2013).
Um dos principais benefícios do uso de Sprites, é que, geralmente são mais
rápidos, apenas uma imagem é carregada em vez de várias, tornando o processo
mais rápido. 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 diversão. Veja o exemplo:
Figura : Sprites Super Mario BrosFonte: 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, transições 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 transições. Qualquer substituição de cena é feita pelo
director. O director é implementado pela classe CCDirector (LEITE, 2013).
25
3 METODOLOGIA
Primeiramente para iniciar o projeto será preciso entender como funciona o
Jogo da memória, e de como o lúdico pode ajudar a entender seus princípios. O
assunto que será abordado neste jogo é o auxílio na fixação de palavras,
direcionado a linguagem inglesa, para usuários 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 não desfocar do propósito do jogo, e
deixar o jogo um pouco mais interessante, viciante.
Através do jogo da memória será construído um aplicativo para a plataforma
Android, que possui um público, relativamente grande, sem contar que o
desenvolvimento é baseado na linguagem Java, o que facilita ainda mais a
construção do aplicativo. O jogo possui um banco de dados nativo, chamado SQLite,
que facilita o armazenamento dos dados e unifica a aplicação, o SQLite será usado
para fazer a persistência da pontuação do jogo.
Todo o desenvolvimento será feito utilizando a ferramenta que a Google
disponibiliza, chamado de Android Studio, essa ferramenta contém os componentes
essenciais do Android SDK, e tudo que é preciso para projetar, depurar e testar um
aplicativo Android através da nova ferramenta de construção Gradle.
Ainda, para auxiliar no desenvolvimento será utilizado um framework
chamado de Cocos2D, que poderá ajudar na criação de telas, a partir dos seus
principais componentes, como os Layers, Scenes e Sprites.
Este jogo então será um jogo da memória que por sua vez visará auxiliar, e
cativar as pessoas a estudar a língua inglesa.
26
4 DESENVOLVIMENTO
4.1 FUNCIONAMENTO DO JOGO
Figura : Fluxograma do jogo Fonte: O autor.
Para melhor entendimento no decorrer deste desenvolvimento, as telas que
foram desenvolvidas serão visualizadas a seguir, na figura (Figura 5) tem-se as três
principais telas do jogo, na tela de título o jogador terá três botões, um para jogar o
outro para ver a pontuação e outro para ajuda. Pressionado o botão “jogar” abrira a
tela de configurações, onde o jogador estará configurando o jogo, para a nova
partida. Realizada a configuração e com o botão “começar” pressionado a tela do
jogo finalmente estará presente para começar a partida.
27
Figura : Telas do jogo, Título, Configuração, Jogo.Fonte: O autor.
Com o jogo já em execução, 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 descrição da
figura em inglês, contribuído com a memorização. Quando o jogador encontrar todas
as figuras, será então direcionado para o término do jogo, em uma tela de final do
jogo, onde o jogador identificará que venceu a partida. Essas telas são visualizadas
na figura (Figura 6) abaixo:
28
Figura : Tela do jogo, início e final, tela final do jogo.Fonte O autor.
Ainda na tela de final do jogo, tem-se dois botões: um para iniciar o jogo
novamente e o outro para rever todas as figuras que foram jogadas na categoria
configurada. Iniciado o jogo novamente, voltará a tela de título que terá o botão
pontuação 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, pontuação e ajudaFonte: O autor.
4.2 CONFIGURAÇÃO
Para começar a desenvolver este projeto, é preciso configurar o ambiente de
desenvolvimento, para isso será usado o Android Studio, uma IDE de
desenvolvimento para Android recém lançada pela Google.
O primeiro passo é criar um novo projeto Android. Para isso em File > New
Project, abrirá uma tela para criação de um novo projeto, nesta tela informa-se o
nome do projeto e em qual versão do Android o projeto será desenvolvido, o projeto
deverá se chamar ‘jogodamemoria’ e será compilado na versão 4.1.2.
Para fazer a construção e compilação, o Android Studio tem uma nova
ferramenta, chamada Gradle, em que a Google está apostando, e também acredita
que irá melhorar a experiência do desenvolvedor para Android, para entender melhor
como funciona o Gradle e também a criação de um novo projeto pode ser
encontrado no seguinte endereço: http://www.gradleware.com/res
ources/tech/android.
30
Após 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 endereço: “https://code.google.com/p/cocos2d-android-
1/downloads/detail?name=cocos2d-android.jar&can=2&q”. Depois disso, clicar com
o botão direito em cima do arquivo .jar e escolher a opção “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
aplicação, e que é preciso compilar com ele junto. No projeto deverá existir um
arquivo chamado “jogodamemoria.iml” no final desse arquivo será adicionado o
código ilustrado na (Figura 8) informando ao “jogodamemoria.iml” que o projeto está
recebendo uma nova biblioteca. Depois de feitas estas configurações o projeto já
está pronto para ser desenvolvido e depurado.
Figura : Declaração da biblioteca Cocos2DFonte: O autor.
4.3 PROGRAMAÇÃO
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 projetoFonte: O autor.
Dentro da pasta ‘res’, utiliza-se as pastas ‘drawable...’ conforme a
configuração do smartphone. Nestas pastas serão adicionadas imagens da
aplicação, quando usadas em telas de xml.
A pasta “layout” contém todos os arquivos .xml que farão parte do jogo. Ainda
no diretório ‘res’ utiliza-se também a pasta ‘raw’, esta pasta, será aplicado todos os
arquivos de áudio do jogo.
No diretório ‘src’ contém 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 pontuação de cada jogador. A pasta
‘configuracoes’ terá as classes controladoras do jogo, entre elas, as configurações
de resolução do jogo, diretório de imagens e também o controlador das mensagens
exibidas em tela. Dentro da pasta ‘jogo’ 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 manipulação de ListView4.
4� Componente usado para manipular listas em Android.
32
A pasta ‘cenas’ terá todas as classes de telas do jogo. Seguindo o raciocínio
tem-se a pasta ‘controle’ onde será feito o controle interno do jogo, como um botão e
o menu de botões de cada tela. Para garantirmos que cada botão poderá ser clicado
e também saber qual foi ele, na pasta ‘interfaces’ será adicionado uma interface para
o menu de botões deixando obrigatório o uso dele em cada tela.
Dentro da pasta ‘objetos’ deverá ser informado todas as classes de objetos do
jogo, por exemplo o jogador e a pontuação, serão objetos do jogo. Por fim tem-se a
pasta ‘tela’ que será configurada a imagem de fundo de todo o jogo.
4.3.1 Tela de Título
A primeira tela do jogo será a tela de abertura, para isso no Cocos2d utiliza-se
uma classe chamada CCLayer, uma classe que é herdada de CCLayer será de fácil
manipulação, e com isso poderá ser criado a tela de abertura que desejar, então na
pasta ‘cenas’ do diretório ‘src’ irá ser adicionado uma nova classe chamada
‘TeladeTitulo.java’ como mostra a (Figura 10):
Figura : Classe 'TeladeTitulo.java'Fonte: O autor
Essa classe, precisa entender de CCLayer, para então criar uma nova cena
do jogo, feito isto, esta cena terá 3 camadas, entre elas a imagem de fundo, a logo,
33
e os botões, tudo isso, formará a tela de título do jogo. Para isso será preciso criar
as classes que compõem estes Layers, ou seja no diretório ‘src’, na pasta ‘tela’, irá
ser criado uma nova classe chamada ‘ScreenBackground.java’ que ficará com o
seguinte código:
Figura : Classe 'ScreenBackground.java'Fonte: O autor.
Neste trecho do código, é passado como parâmetro, no construtor a imagem
que será usada no background, esta classe entende de CCSprite por isso
possibilitará manipular a imagem passada como parâmetro. Agora será criada a
classe ‘MenuButtonsTelaTitulo.java’ nesta classe será adicionado a imagem e
posição para cada botão da tela, como mostra a (Figura 12):
Figura : Construtor 'MenuButtonsTelaTitulo()'Fonte: O autor.
Neste trecho pode-se observar que os botões são habilitados para serem
tocados, é direcionado imagens e posição para cada um deles, e por fim são
adicionados na tela com o método addChild(), este botão que está sendo
instanciando, na realidade será um botão personalizado pelo Cocos2d, ou seja é
criado ele no diretório ‘src’ dentro da pasta ‘controle’ e ficará com o seguinte código:
34
Figura : Classe 'Button.java'Fonte: O autor.
Este botão que foi criado, permite passar como parâmetro 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 métodos criados para saber qual botão foi
chamado, depois disso, é preciso de alguma maneira avisar a tela de título de qual
foi este botão. Para isso, será criado uma interface, chamada de ‘ButtonDelegate’,
será criado no diretório ‘src’ dentro da pasta ‘interfaces’, esta interface será
responsável em avisar as telas, sobre qual dos botões que está sendo clicado. O
código da interface ficará como mostra a (Figura 14):
Figura : Interface 'ButtonDelegate.java'Fonte: o autor.
Agora é preciso implementar a classe ‘ButtonDelegate’ na classe
‘MenuButtonsTelaTitulo’ e adicionar o método criado na interface. Feito isso já se
consegue saber qual botão foi clicado e também realizar alguma ação quando
clicado. Com essa interface, futuramente se precisará ainda ocupar algum tipo de
35
botão no jogo, o código ficará desacoplado e concentrado somente em um lugar,
deixando assim a repetição de código.
Ainda na tela de título, será adicionado os botões, imagens, que estão sendo
passadas como parâmetro, do tipo String, para deixar isso de forma estática e
desacoplada, será criado uma classe onde se concentrará todas as imagens. Estas
imagens instanciadas ficarão na pasta ‘assets’ que fica na raiz do projeto. Nesta
pasta será colocado todas as imagens que irão aparecem no jogo e também será
instanciadas dentro de uma única classe, para isso é preciso criar a classe
‘Assets.java’ que está no diretório ‘src’, dentro da pasta ‘configuracoes’. A classe fica
parecida com o código do (Figura 15) abaixo:
Figura : Classe 'Assets.java'Fonte: O autor.
As imagens serão 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 botão ou um objeto que irá no jogo. A
primeira parte está feita e deverá ficar conforme ilustrada na (Figura 16):
36
Figura : Tela de TítuloFonte: O autor.
4.3.2 Tela de Configurações
Ao clicar no botão Jogar, uma nova tela deverá aparecer, ou seja, deverá
surgir a tela de configuração da partida, nesta tela deverá ser solicitado ao jogador, o
seu nome, e em qual categoria ele gostaria de jogar, e também qual será a
dificuldade que ele vai enfrentar.
Nesta parte será enfrentado a primeira dificuldade com o Cocos2d, ele não
possui nenhum Widget5, por exemplo: RadioButton ou EditText, para esta parte do
jogo então será possível estar utilizando um layout xml, nativo do Android, ou seja
neste layout será possível que o jogador informe todas estas informações
necessárias para dar sequência ao jogo.
5� Componente gráfico do Android
37
Para isso, será criado uma nova activity, que será chamada de
‘PreparaJogoActivity’ ela ficará localizada na raiz do diretório ‘src’, ficará de acordo
com a (Figura 17):
Figura : Activity 'PreparaJogoActivity.java'Fonte: O autor.
No construtor da activity será chamado o método criaConfiguracao(), este
método recebera a escolha que o jogador fez e essas configurações serão
guardadas em uma classe chamada ‘Conf.java’ 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 serão armazenados ficarão temporariamente na memória,
somente até começar um novo jogo. Após inserir as configurações escolhidas pelo
jogador, será chamado a Tela do Jogo.
Junto com a activity ‘PreparaJogoActivity’ será criado o layout
‘activity_prepara_jogo.xml’ que irá conter componentes do tipo, RadioButton,
38
RadioGroup e EditText, que serão usados para receber informações do jogador e
poder dar sequência ao jogo. Depois de adicionado os widgets a parte visual ficará
como mostra a figura (Figura 18):
Figura : Tela de ConfiguraçõesFonte: O autor.
4.3.3 Tela do Jogo
Até o momento, foi criado a tela de título, na qual o jogador terá algumas
opções a escolher, e que quando clicar no botão de jogar, aparecerá a tela de
configuração, solicitando algumas informações ao jogador, o jogador então deverá
informar o seu nome, qual dificuldade do jogo e em qual categoria jogar. Feito isso, a
activity6 ‘PreparaJogoActivity’ deverá fazer a verificação e abrir a tela do jogo.
Dando sequência agora será preciso criar a tela do jogo, para isso será criado
a classe ‘TelaDoJogo.java’ no diretório ‘src’ dentro da pasta ‘cenas’ e será feito a
6� Atividade da aplicação usada para interação com o usuário.
39
mesma coisa que a tela de título, adicionar o background, criar o construtor e
instanciar uma nova CCScene. O código ficará parecido com a figura (Figura 19).
Figura : Classe 'TelaDoJogo.java'Fonte: O autor.
Seguindo a lógica de um jogo da memória, o jogo consiste em várias peças, e
para conseguir vencer, o jogador precisa achar o par de cada uma delas, ou seja
duas imagens sempre deverão ser iguais. Neste jogo terá duas opções de
dificuldade, fácil que consiste em quatro colunas e quatro linhas, chegando em um
total de dezesseis figuras, sendo que somente oito serão diferente e a difícil que
consiste em quatro linhas e quatro colunas, totalizando vinte e quatro figuras, e doze
que serão diferentes.
Para fazer isto será preciso construir uma nova classe, nesta classe será
adicionado todas as imagens necessárias na tela e também fazer toda a parte lógica
da jogada. Na prática então será criado uma classe para cada dificuldade que irá
existir no jogo, as classes terão o mesmo objetivo e os mesmos métodos, será
mudado apenas a quantidade de imagens que terá em cada uma. As duas classes
serão criadas no diretório ‘src’ dentro da pasta ‘controle’ serão chamadas de
‘MenuButtonsTelaJogoDificil’ e ‘MenuButtonsTelaJogoFacil’, como exemplo o código
ficará parecido como mostra a figura (Figura 20).
40
Figura : Classe 'MenuButtonsTelaJogoDificil'Fonte: O autor.
Na figura (Figura 20) pode se observar todos os métodos que serão
construídos para fazer a parte lógica 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
também do tipo CCSprite. Feito isso será preciso adicionar imagens e posição para
cada atributo do array. Para fazer está alimentação de cada imagem e posição será
preciso criar um for(), que irá percorrer o tamanho total do array. O código ficará
como mostra a figura (Figura 22).
41
Figura : Métodos 'setImagens()' '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á posição e a este
objeto será passado mais tarde, quando será verificado a imagem que foi
pressionada pelo jogador. Em seguida no método ‘setPosicoes’ será adicionado a
posição de cada imagem e também será aproveitado para adicioná-las na tela do
jogo.
Para conseguir gerenciar o tamanho da tela e conseguir adicionar a posição
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
métodos estáticos para poder usar em qualquer lugar do jogo, a classe se chamara,
‘ConfDispositivo.java’ e ficará no diretório ‘src’ dentro da pasta ‘configuracoes’,
dentro desta classe será implementado as funções que o Cocos2d já traz prontas e
que serão importadas da classe CGPoint. O código para esta classe ficará igual ao
da figura (Figura 23).
42
Figura : Classe 'ConfDispositivo.java'Fonte: O autor.
O método ‘resolucaoDaTela’ será do tipo CGPoint e irá esperar como
parâmetro a configuração da tela, que será passado pelos métodos ‘screenWidth’
(largura da tela) e ‘screenHeight’ (altura da tela).
Foi desenvolvido os métodos de adicionar imagem, e para cada imagem
também foi adicionado uma posição, feito isso o próximo passo é colocar estes
métodos no construtor da mesma classe que quando chamada pela tela de título 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 JogoFonte: O autor.
A figura (Figura 24) mostra a tela do jogo com todas as imagens adicionadas,
essa tela seria com a dificuldade do tipo difícil.
Agora é hora de partir para parte da lógica do jogo, onde será usado a
escolha de dificuldade e categoria que o jogador fez na tela de configuração do jogo.
Nesta parte será usado o método ‘buttonClicked()’ , este método pegara a imagem
que foi clicada pelo jogador, e então virará a imagem para que se possa ver
realmente o que terá atrás dela.
Figura : Método buttonCliked(), primeira jogadaFonte: O autor.
Para saber quando foi a primeira imagem que o jogador clicou utiliza-se a
variável ‘ultimoBotaoClicado’, está variável está inicializada com -1 que fará com que
na primeira verificação da jogada entre no comparador. Após a comparação ser
44
avaliada, será necessário guardar a posição atual para a variável ‘primeiraPosicao’,
feito isso será executado o método mostra().
Dentro do método ‘mostra()’ será feito com que a imagem atual fique invisível
e mostre a que estiver relacionada com a mesma posição do array passada por
parâmetro, depois de adicionada a imagem nova, será restabelecida a posição que
foi guardada na variável ‘primeiraPosicao’ e que foi passada por parâmetro no
método. O código ficará como mostra a figura (Figura 26).
Figura : Método 'mostra()'Fonte: O autor.
A imagem de substituição que foi passada, foi a posição de um array de String
que foi criado na classe ‘Assets.java’ com a categoria escolhida pelo jogador na tela
de configuração do jogo, por isso na classe ‘Assets.java’ será preciso criar um array
com a mesma quantidade de posições que o jogador iniciou o jogo. O código ficará
como mostra a figura (Figura 27).
Figura : Array de categoriasFonte: O autor.
Para finalizar a primeira jogada, depois de executar o método mostra(), será
atribuído um valor a variável ‘ultimoBotaoClicado’, que receberá o valor da posição
do array que está sendo executada.
Para continuar a lógica, a primeira jogada fez com que o jogador clicasse em
uma das imagens e mostrasse qual era a imagem real que estava atrás e guardasse
a posição do vetor na variável ‘ultimoBotaoClicado’, 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 variável
‘retornoCategoria’ (Categoria escolhida pelo jogador) na posição que está sendo
feito a verificação for igual a ‘retornoCategoria’ na posição que guardamos na
variável ‘ultimoBotaoClicado’, se está verificação for válida, é porque o jogador
acertou o par que estava procurando, e então deverá mostrar a imagem da posição
clicada e colocar o valor da variável ‘ultimoBotaoClicado’ para -1, para que volte a
validar a primeira jogada. A figura (Figura 28) mostra como ficou o código da
segunda jogada.
Figura : Segunda jogadaFonte: O autor.
Ainda na segunda jogada terá mais três 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 acréscimo de pontos no
jogo e a terceira a verificação para saber se o jogo chegou ao fim.
A mensagem será simples, será mostrada através de um Toast, essa classe
no Android permite mostrar mensagem durante alguns segundos na tela, e logo
desaparecer. Para que seja possível mostrar essa mensagem em outros lugares do
projeto também e não precisar reescrever o código, será criado uma classe
‘ToastManager’ no diretório ‘src’ dentro da pasta ‘configuracoes’ que ficará
armazenado todo o código. O código para esta classe ficará como mostra a figura
(Figura 29).
46
Figura : Classe 'ToastManager.java'Fonte: O autor.
Nesta classe será criado o método ‘show()’ que será estático e por parâmetro
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 ‘toast_layout.xml’ nele, será adicionado um simples TextView,
o TextView 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
TextView que foi criado no ‘toast_layout.xml’ para isso será criado mais 2 arquivos
xml dentro da pasta ‘drawable’ que ficarão com o seguinte nome
‘toast_background_green.xml’ para mensagem de sucesso e
‘toast_background_red.xml’ para mensagem de erro. O código 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 ToastManager então será
chamada após o método mostra() da segunda jogada.
Para cada acerto de um par, será mostrado uma mensagem via Toast com o
significado da imagem em inglês como mostra a figura (Figura 31), para que o
jogador possa estar armazenando e adquirindo o aprendizado da palavra em inglês.
Figura : Mensagem em InglêsFonte: O autor.
Agora será a vez do acréscimo de pontos, na hora do acerto do par, ou seja,
toda vez que o jogador acertar um par, os pontos serão alimentados e para isso será
preciso criar uma classe chamada ‘Score.java’ que ficará no diretório ‘src’ dentro da
pasta ‘objetos’ que ficará com o código que mostra na figura (Figura 32).
48
Figura : Classe 'Score.java'Fonte: O autor.
No construtor da classe será criado uma variável ‘text’ do tipo
CCBitmapFontAtlas, 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 parâmetro o arquivo que ele irá carregar,
chamado de ‘UniSansSemiBold_Numbers_240.fnt’ esse arquivo será adicionado na
pasta ‘assets’ que fica na raiz do projeto. Após isso, é adicionado um tamanho para
a fonte e a posição que ela ficará na tela.
A classe ainda terá os métodos de acrescentar e diminuir os pontos, ambos
serão simples. O método ‘acrecenta()’, acrescentara 10 pontos a cada vez que for
chamado e o método ‘tira()’ diminuirá 3 pontos, se a pontuação ficar negativa, a cor
dele irá ficar vermelha, ao contrário ficará branca.
Para integrar a pontuação com a tela do jogo, no construtor da classe
‘Teladojogo.java’ será acrescentado um novo Layer chamado ‘scoreLayer’ e esse
Layer recebera o score criado na classe ‘Score.java’ o código 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 variável do tipo TelaDoJogo e será
chamada de delegate, feito isso, é só chamar o método acrescenta na segunda
jogada que ficará depois de mostrar a mensagem.
Bom, esses métodos serão executados, caso o jogador acerte o par de
figuras, ainda tem-se o método para verificar o final da partida, mas este método
ficará para ser feito em breve, antes será preciso fazer uma condição para que se o
jogador não acerte o par, as imagens retornem a se esconder e a pontuação
diminua, pois ele errou.
Para isso será acrescentado após a verificação da segunda jogada o ‘else’
que representa o “se não, faça isso” ou seja, se o jogador não acertar a segunda
jogada, cairá no próximo passo que será o ‘else’, o código para isso é ilustrado na
figura (Figura 34).
Figura : Função executada ao errar a segunda jogadaFonte: 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á rápido, em um tempo de 1
segundo, para fazer isso, será preciso usar a classe Thread do Java, está classe
tem um método ‘run()’ que será onde ficará o código. Para usar a classe Thread será
50
preciso atribuir o Runnable que definirá o método de execução, e que também
deixara impor o tempo para a execução do método ‘run()’.
A lógica ficou da seguinte maneira. A imagens será visualizada e o método
‘run()’ será executado, ou seja, depois de 1 segundo ele será executado. Dentro do
método então, será escondido a imagem, através do método ‘esconde()’, este
método será igual ao método ‘mostra()’, só que ao invés de passar a imagem
correspondente ao acerto, será passado a imagem que esconde mostrado uma
mensagem que o jogador errou, diminuíra os pontos e também será zerado algumas
variáveis para que na próxima jogada não aconteça nenhum problema.
Continuando a lógica que tinha sido imposto para a segunda jogada, será a
vez de verificar o final da partida, através do método ‘verificaFinalDoJogo()’, neste
método será verificado se o total de acertos foi igual ao total de figuras que tem na
jogada, será comparado com a variável ‘quantBotoesClicados’, está variável é
alimentada cada vez que o jogador acerta um par de figuras. Se a variável chegar ao
número de imagens que tiver na jogada, o que tem dentro do método é executado,
ou seja:
• Insere um novo jogador no banco.• Mostra mensagem de parabéns.• Para o som de fundo, e executa o som de final do jogo.• Chama a tela do final do jogo.
O código para este processo é ilustrado na figura (Figura 35) logo abaixo:
Figura : Método '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
‘Jogador.java’, para poder atribuir o nome, e os pontos. Está classe será simples,
51
será criada no diretório ‘src’ dentro da pasta ‘objetos’ e terá apenas 3 atributos, o id,
o nome do jogador, e os pontos, será necessário também, criar um construtor e
gerar os métodos get’s e set’s de todos os atributos.
Depois disso, é preciso criar o banco de dados, e a tabela jogador, será
preciso então criar uma classe no diretório ‘src’ dentro da pasta ‘banco’ com o nome
de ‘BancoDados.java’ essa classe terá o código com os scripts para criação do
banco de dados e da tabela do jogador. Ainda nesta classe terá um método estático
que toda vez que chamado, fara a conexão com o banco de dados. O código para
esta classe ficará como mostra a figura (Figura 36).
Figura : Classe 'BancoDados.java'Fonte: O autor.
Criado os scripts para a criação do banco e da tabela, agora será preciso
executar eles, como mostra a figura (Figura 36), dentro do método ‘getDB()’ é feito a
instancia de uma classe chamada ‘SQLiteHelper’ passando os scripts criados na
classe ‘BancoDados.java’ e retornado novamente o banco de dados.
Para que seja executado os scripts então será preciso criar a classe
‘SQLiteHelper.java’ que ficará no diretório ‘src’ dentro da pasta ‘banco’ o código para
esta classe ficará como mostra a figura (Figura 37).
52
Figura : Classe 'SQLiteHelper.java'Fonte: O autor.
A classe SQLiteHelper entende de SQLiteOpenHelper, com isso, será
possível criar os método onCreate() e onUpgrade(), esses dois métodos, se
encarregarão de criar e atualizar o banco de dados, com os scripts que serão
passados para eles.
Agora será preciso criar uma classe para gerenciar o banco de dados e criar
os métodos para persistir e buscar estes dados, para isso, no diretório ‘src’ dentro da
pasta ‘objetos’ será criado a classe ‘JogadorDao.java’, o código para esta classe
ficará como mostra a figura (Figura 38).
Figura : Classe 'JogadorDao.java'Fonte: O autor.
53
Para fazer a conexão com o banco SQLite, será criado uma variável da classe
‘SQLiteDatabase’, essa classe permitirá ter acesso a métodos já criados como
insert, update e ainda é possível executar scritps próprios.
O método ‘salvar()’ quando chamado, pegará os dados que foram passados
para a classe Jogador, para fazer a persistência dos dados. E o método ‘listar()’
buscara no banco todos os dados da tabela jogador que foi criado.
Agora que o banco de dados está configurado, é preciso voltar ao método
‘insereJogador()’ e informar estas informações a ele. O código para este método
ficará como mostra a figura (Figura 39).
Figura : Método 'insereJogador'Fonte: O autor.
Neste método primeiramente é feito uma verificação, para saber se a variável
que recebe o nome do jogador e que foi passado na tela de configuração, é vazia,
se for, será atribuído um nome padrão, chamado de “Player” e após está verificação
será inserido o jogador, com o nome e o total de pontos que obteve no jogo. Este
método é executado dentro do método ‘verificaFinalDoJogo()’ que é mostrado na
figura (Figura 35).
Continuando o processo do método ‘verificaFinalDoJogo()’ após inserir o
jogador será mostrado uma mensagem de parabéns em inglês, que ficará
“Congratulations!”, após 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 fácil, com uma linha de código já se
consegue adicionar o som, como exemplo a figura (Figura 40) mostra como é fica a
linha de código para o som.
Figura : Adicionando som
54
Fonte: O autor.
Com isso se termina todas as etapas da parte lógica 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 jogoFonte: O autor.
4.3.4 Tela Final do Jogo
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 botão para indicar o reinicio do jogo e mais
um botão, que servirá de auxílio 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 inglês e português, para fazer isso será
necessário criar uma nova classe que se chamara ‘FinaDoJogo.java’ esta classe
será criada no diretório ‘src’ dentro da pasta ‘cenas’ o código para esta classe ficará
como mostra a figura (Figura 42).
Figura : Classe FinalDoJogoFonte: O autor.
Esta tela, não será diferente das outras telas, será implementado a interface
ButtonDelegate e junto já será criado o método ‘buttonClicked()’, para saber qual
botão será clicado.
No Construtor da classe, será adicionado a imagem de background, a
imagem da logo, com a descrição “Venceuuu!!” e os dois botões, onde o botão jogar
novamente, direcionara para a tela de título 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 jogoFonte: O autor.
4.3.5 Tira Dúvidas
Quando o botão “Tire dúvidas! reveja o que viu nesta partida” for clicado pelo
jogador, será executada uma intenção e carregara uma outra tela, que será feita por
uma activity e um arquivo xml.
Para isso, primeiramente será preciso criar a classe ‘ItensActivity.java’ na raiz
do diretório ‘src’ nesta classe, dentro do método, onCreate() terá o seguinte código.
Figura : Método ‘onCreate()’ da classe 'ItensActivity.java'Fonte: O autor.
57
Junto com está activity, será criado o layout xml, por isso, no diretório ‘res’
dentro da pasta ‘layout’ será criado o arquivo xml ‘activity_final_list.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 método
‘verificaCategoriaEOpcao()’ neste método será verificado qual categoria e dificuldade
o jogador escolheu no jogo, quando ele, achar qual foi estas opções executara o
método ‘populateItemListFrutasEasy()’ ou o método de acordo com a opção que o
usuário escolheu. Antes de executar algum desses métodos, é preciso criar uma
classe que se chama ‘Item.java’, será criada no diretório ‘src’ dentro da pasta
‘objetos’, essa classe será simples, terá apenas 3 atributos entre eles, a descrição
da imagem, a imagem que será do tipo ‘int’ e a tradução da imagem. Depois de criar
os atributos será necessário também criar o construtor da classe e os get’s e set’s de
cada atributo.
Depois de criado a classe Item, será necessário instanciar a mesma na
activity ItensActivity, além de instanciar, será preciso criar uma lista de itens, o
código para isso é visualizado na figura (Figura 45).
Figura : Lista de ItemFonte: O autor.
Agora é preciso popular esta lista, ou seja, está lista de itens é preenchida,
através do método ‘populateItemListFrutasEasy()’. O código para estes métodos
ficarão como exemplo da figura (Figura 46).
Figura : Método ‘populateItemListFrutasEasy()’Fonte: o autor.
58
Lembrando que para cada categoria ou dificuldade, terá um método,
semelhante ao ‘populateItemListFrutasEasy()’, a diferença será somente a
quantidade de itens, e o tipo da categoria.
Feito isso, o método ‘verificaCategoriaEOpcao()’ já estará completo e já é
possível verificar qual tipo de categoria e dificuldade serão adicionados.
O próximo passo é o método ‘populateListView()’, ou seja até o momento,
com o método ‘verificaCategoriaEOpcao() foi possível adicionar vários itens dentro
de uma lista, agora será preciso adicionar cada item dessa lista na ListView que foi
criada no layout ‘activity_final_list.xml’.
Primeiramente será preciso criar mais um arquivo xml, que será chamado de
‘activity_final_item.xml’, neste arquivo será criado três widgets, o primeiro será uma
ImageView, este componente recebera a figura correspondente a categoria que o
jogador escolheu antes de iniciar a partida e as outras duas serão TextView, um
deles recebera o significado da imagem em inglês e o outro em português, os três
componentes ficarão em uma única linha, um do lado do outro, ou seja, essa linha
que foi criada com os três componentes alinhados na vertical, correspondera a uma
linha da ListView.
Agora é preciso relacionar os item da lista de Item ‘items’, com o item do xml
‘activity_final_item.xml’, com isso, cada item da lista, ‘items’, será aplicado na
ListView, como um item do xml ‘activity_final_item.xml’. O código para esse
procedimento ficará como mostra a figura (Figura 47):
59
Figura : Método ‘populateListView()’Fonte: O autor.
Feito isso, o resultado de quando o botão “Tire dúvidas! 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 dúvidasFonte: O autor.
60
4.3.6 Pontuação
Com isso termina a partida do jogo, mas ainda será preciso montar a tela de
pontuação e uma tela descrevendo um pouco sobre o jogo, portanto será preciso
voltar para a tela de título, lá têm-se mais dois botões, onde um serve para exibir a
tela de pontuação e o outro para ajudar o jogador a entender como funciona o jogo.
Por primeiro será desenvolvida a pontuação, que será uma parte fundamental
do jogo, ou seja, a teoria de Flow impõem que criar uma certa dificuldade ou gerar
competitividade, também 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 pontuação, praticamente será usado a mesma
lógica que foi imposta para a tela de tirar dúvidas, no final do jogo. Para isso será
preciso criar uma activity na raiz do diretório ‘src’ que se chamará,
‘JogadorActivity.java’, nesta activity terá o método ‘onCreate()’ usado para mostrar o
conteúdo que terá no layout xml que será criado para carregar a lista de pontuações.
Basicamente serão duas etapas, buscar no banco de dados, todos os jogadores
com seus respectivos pontos, pegar este resultado e adicionar em uma ListView.
Lembrando que está classe precisa entender de ‘ListActivity’, pois será necessário
usar alguns métodos dessa classe. O código para o método ‘onCreate()’ ficará como
mostra a figura (Figura 49).
Figura : Classe 'JogadorActivity.java'Fonte: O autor.
No diretório ‘src’ dentro da pasta ‘adapter’ será criado a classe
‘JogadorAdapter.java’, está classe, terá o trabalho de pegar a lista de jogadores e
61
introduzir objeto por objeto dentro de uma ListView, para isso será preciso criar o
layout que recebera a ListView, será criado no diretório ‘res’ dentro da pasta ‘layout’
e se chamara ‘activity_jogador_list.xml’, dentro deste layout será apenas adicionado
a ListView.
Agora é preciso criar o layout do item, que preenchera a ListView, então
novamente será criado no diretório ‘res’ dentro da pasta ‘layout’ 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 pontuação.
Os dados de pontuação são resgatados através do método ‘listar()’ já criado
na classe ‘jogadorDao.java’, o retorno desta lista será passado para uma lista de
jogadores e com a lista em mãos, será preciso criar uma nova classe para que seja
feita a gravação de cada item na ListView, basicamente terá a mesma lógica feita na
ListView de tira dúvidas. O código 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 método da
classe ‘setListAdapter()’, passando como parâmetro a instância feita pela classe
JogadorAdapter. O resultado para está classe ficará como mostra a figura (Figura
51).
62
Figura : Tela de pontuaçãoFonte: O autor.
Para finalizar a tela de posições, é preciso ordenar a pontuação, para que se
saiba quem está liderando o placar do jogo, esse passo será simples, apenas será
acrescentado o método ‘Collections.sort(jogadores);’ dentro do método ‘onCreate()’
da classe ‘JogadorActivity’, feito isso a pontuação será ordenada, e o jogador com
maior pontuação, ficará no topo da lista.
Ainda será preciso construir um método para excluir um jogador da lista de
pontuações 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 confirmação desta
ação, ou seja, verificar se ele realmente quer apagar aquele jogador.
O método para saber em qual posição ou qual jogador foi selecionado, será o
onListItemClick, com este método, é possível saber qual posição foi selecionado da
lista. Após saber qual é a posição, será possível apagar o jogador, comparando a
63
posição selecionada da ListView, com a posição da lista de jogadores. Antes de
apagar o jogador, é necessário criar um AlertDialog, pedindo a confirmação da
exclusão.
O próximo passo será atualizar a lista, para que o jogador excluído saia da
ListView, para isso será criado um método, onde será limpada a lista e adicionada
novamente. código para todo este processo ficará como mostra a figura (Figura 52).
Figura : Métodos 'onListItemClick()' e 'atualizaLista()'Fonte: O autor.
4.3.7 Sobre
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 ‘dialog_help.xml’ e nele será adicionado dois TextView, em um deles será
adicionado o título e o outro o texto. Terá também um Button, para fechar o Dialog. O
código e a tela serão mostradas nas figuras (Figura 53) e (Figura 54).
64
Figura : Método 'criaDialogHELP()'Fonte: O autor.
Figura : Dialog de AjudaFonte: O autor.
65
5 CONSIDERAÇÕES FINAIS
Com base em um jogo da memória convencional, foi possível relacionar o
jogo, com a língua inglesa, essa interação acontece quando o jogador acha o par de
figuras, que então é exibido em um formato de mensagem na tela, isso tudo em
inglês, o jogo ainda, teve a implementação que a teoria de flow impõem, fazendo
que o jogo não saia do foco e acabe ficando cansativo e chato.
Através deste trabalho afirmo que apesar de estar falando do
desenvolvimento de um jogo, foi de simples desenvolvimento e sem maiores
complicações. Desenvolver para Android foi uma experiência sensacional, despertou
muito interesse e vontade de ir mais afundo em questão de games, ainda mais com
o auxílio 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
dispõem.
Com tudo o propósito do projeto foi atingido, o jogo foi desenvolvido e a
cativação do público alvo está presente, incentivando o usuário 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 inserção de Widgets, para fazer a interação com
o jogador, para solucionar este pequeno problema, foi preciso usar componentes do
Android e criar arquivos xml para interligar com o Cocos2D.
Como sugestões futuras, deixo um convite para o pesquisador que se
interessar, desenvolver ainda mais as habilidades do inglês, como por exemplo,
adicionar arquivos de áudio na descrição de cada figura, gerar uma interação com o
jogador durante e no final de cada partida, acrescentar em cada acerto uma
premiação ao jogador deixando o jogo ainda mais divertido.
66
REFERÊNCIAS
DAMBROSO, Naiara João Karina Viviane de et al. Proposta Didático-Pedagógicade Língua Inglesa. Xanxerê: Grafica Impramax, 2007. 112p.
DASHBOARDS, junho 2013. Disponível em:<http://developer.android.com/about/dashboards/index.html>. Acesso em: 08 jun. 2013.
DIVERSÃO, Jogos de Memória Online – Exercício e. Jogos de Memória Online – Exercício e Diversão. 2013. Disponível em: <http://www.ancorador.com.br/tecnologia/jogos/jogos-de-memoria-online-exercicio-e-diversao>. Acesso em: 01 jun. 2013.
FERRARINI, Algusto. Conhecendo o Android. Mobile Magazine, Edição 42 04-11. 2012.
GETTING Started with Android Studio, maio 2013. Disponível em: <http://developer.android.com/sdk/installing/studio.html>. Acesso em: 07 jun. 2013.
GRADLE: The New Android Build System, maio 2013. Disponívelem:<http://www.gradleware.com/resources/tech/android>. Acesso em: 14 nov. 2013.
LEITE, Anderson. Desenvolvimento de Jogos para Android: explore sua imaginação com o framework Cocos2D. São Paulo: Casa do Código, 2012. 170p.
NETWORK, Oracle Technology. Java e Orientação a Objetos. Disponível em: <http://www.caelum.com.br/apostila-java-orientacao-objetos/>. Acesso em: 28 abr. 2013.
MANZANO, Adriana; DOHME, Vanessa. As vantagens do uso de atividades lúdicas no ensino de idiomas. Disponível em: <http://www.sbs.com.br/e-talks/as-vantagens-do-uso-de-atividades-ludicas-no-ensino-de-idiomas/>. Acesso em: 31 maio 2013.
MAURÍCIO, Juliana Tavares. Aprender Brincando: O Lúdico na Aprendizagem. Disponível em: <http://www.profala.com/arteducesp140.htm>. Acesso em: 31 maio 2013.
67
SELIGMAN, Martin. Felicidade autêntica: usando a nova psicologia positiva para a realização permanente. Rio de Janeiro: Objetiva, 2004. 333 p.
VASCONCELOS, Nelson Glauber de. SQLite no Android. Disponível em: <http://www.devmedia.com.br/websys.4/webreader.asp?cat=5&revista=webmobile_34 - a-3249>. Acesso em: 01 maio 2013.