rafael dos passos fortes
DESCRIPTION
TRANSCRIPT
UNIVERSIDADE DO VALE DO ITAJAÍ
CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
WEB API PARA DISPONIBILIZAÇÃO DE JOGOS EDUCATIVOS EM
AMBIENTES VIRTUAIS
Área de Informática na Educação
por
Rafael dos Passos Fortes
Benjamin Grando Moreira, M. Eng.
Orientador
Itajaí (SC), novembro de 2009
UNIVERSIDADE DO VALE DO ITAJAÍ
CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
WEB API PARA DISPONIBILIZAÇÃO DE JOGOS EDUCATIVOS EM
AMBIENTES VIRTUAIS
Área de Informática na Educação
por
Rafael dos Passos Fortes
Relatório apresentado à Banca Examinadora do
Trabalho de Conclusão do Curso de Ciência da
Computação para análise e aprovação.
Orientador: Benjamin Grando Moreira, M. Eng
Itajaí (SC), novembro de 2009
ii
DEDICATÓRIA
A minha mãe (Sônia) pela educação que
me proporcionou e por sempre me apoiar,
a minha tia (Deisy) por me apoiar todos esses
anos e ser uma grande amiga nas horas difíceis,
e a minha vó (Edith) que sempre torceu por mim
e nunca me deixou desistir.
iii
AGRADECIMENTOS
A minha mãe (Sônia) pela educação que me proporcionou além do grande apoio esses anos
para que eu conseguisse cursar a faculdade.
A minha tia (Deisy) por estar presente comigo todos esses anos, sempre me apoiar nos
momentos difíceis e fazer o melhor almoço da região.
A minha vó (Edith) por ser uma grande companheira ao longo desses anos e sempre orar por
mim.
Ao meu irmão (Rodrigo) por sempre dar aquela força nos momentos mais difíceis.
A todos os meus amigos, em especial Arthur e William que sempre foram grandes
companheiros, deram idéias e apoiaram as minhas decisões.
Ao meu orientador (Benjamin) pelo conhecimento passado e horas gastas de apoio.
iv
SUMÁRIO
DEDICATÓRIA ......................................................................................... ii
LISTA DE ABREVIATURAS.................................................................. vi
LISTA DE FIGURAS ............................................................................... vii
RESUMO .................................................................................................. viii
ABSTRACT ................................................................................................ ix
1 INTRODUÇÃO .................................................................................... 10
1.1 PROBLEMATIZAÇÃO ................................................................................... 12
1.1.1 Formulação do Problema ............................................................................... 12
1.1.2 Solução Proposta ............................................................................................. 12
1.2 OBJETIVOS ...................................................................................................... 13
1.2.1 Objetivo Geral ................................................................................................. 13
1.2.2 Objetivos Específicos ...................................................................................... 13
1.3 METODOLOGIA .............................................................................................. 14
1.4 ESTRUTURA DO TRABALHO ..................................................................... 14
2 FUNDAMENTAÇÃO TEÓRICA ...................................................... 16
2.1 PROBLEMAS DA EDUCAÇÃO E ENSINO NO BRASIL .......................... 16
2.2 JOGOS NA EDUCAÇÃO COMO FORMA DE ENSINO ........................... 17
2.3 WEB API ............................................................................................................ 19
2.3.1 Visão geral ....................................................................................................... 19
2.4 INTELIGÊNCIA ARTIFICIAL ...................................................................... 21
2.4.1 Definição .......................................................................................................... 21
2.4.2 Algoritmo de Inteligência Artificial MINIMAX .......................................... 22
2.5 SOLUÇÕES SIMILARES ................................................................................ 24
2.5.1 Jogo da memória educativo online ................................................................ 24
2.5.2 Jogo da velha dos bichos ................................................................................. 25
2.5.3 Super Trunfo Árvores Brasileiras ................................................................. 27
2.5.4 Análise das soluções similares ........................................................................ 28
3 DESENVOLVIMENTO ...................................................................... 29
3.1 JOGOS DESENVOLVIDOS ............................................................................ 29
3.2 ANÁLISE DOS REQUISITOS IDENTIFICADOS ....................................... 29
3.2.1 Requisitos funcionais ...................................................................................... 29
3.2.2 Requisitos não-funcionais ............................................................................... 29
3.2.3 Regras de negócio ............................................................................................ 30
3.3 JOGO DA MEMÓRIA ..................................................................................... 30
3.3.1 Configuração do Jogo da Memória ............................................................... 34
3.4 JOGO DA VELHA ............................................................................................ 35
3.4.1 Configuração do Jogo da Velha ..................................................................... 39
v
3.5 SUPER TRUNFO .............................................................................................. 40
3.5.1 Configuração do Super Trunfo ..................................................................... 44
3.6 WEB API NO PROJETO ................................................................................. 45
3.6.1 Descrição .......................................................................................................... 45
3.6.2 Pré requisitos para uso da Web API ............................................................. 45
3.6.3 Geração do arquivo XML .............................................................................. 45
3.6.4 Google AJAX Search API .............................................................................. 47
3.6.5 Web API no lado do cliente ............................................................................ 49
3.6.6 Web API no servidor ...................................................................................... 50
3.6.7 Proxy................................................................................................................. 51
3.7 TECNOLOGIAS NECESSÁRIAS PARA A IMPLEMENTAÇÃO ............ 52
3.7.1 PHP ................................................................................................................... 53
3.7.2 JavaScript ........................................................................................................ 53
3.7.3 Prototype .......................................................................................................... 54
3.7.4 HTML .............................................................................................................. 54
3.7.5 CSS ................................................................................................................... 54
3.7.6 DOM ................................................................................................................. 55
3.7.7 XML ................................................................................................................. 55
3.8 ALGORITMOS DE INTELIGÊNCIA ARTIFICIAL .................................. 56
3.8.1 Jogo da Memória e seu mecanismo de Inteligência Artificial .................... 56
3.8.2 Super Trunfo e Inteligência Artificial ........................................................... 58
3.9 DIFICULDADES ENCONTRADAS NA IMPLEMENTAÇÃO .................. 58
4 CONCLUSÕES .................................................................................... 60
4.1 TRABALHOS FUTUROS ................................................................................ 61
REFERÊNCIAS BIBLIOGRÁFICAS ................................................... 62
vi
LISTA DE ABREVIATURAS
AJAX Asynchronous Javascript And XML
API Application Programming Interface
CEPAL Comissão Econômica para a América Latina e o Caribe
CSS Cascading Style Sheets
DETRAN Departamento Estadual de Trânsito
DOM Document Object Model
GPL General Public License
HTML Hypertext Markup Language
IA Inteligência Artificial
IPEA Instituto de Pesquisa Econômica Aplicada
MEC Ministério da Educação
OO Orientação a Objeto
PHP Hypertext Preprocessor
SOAP Simple Object Access Protocol
UML Unified Modeling Language
UNESCO United Nations Educational, Scientific and Cultural Organization
UNICEF United Nations Children’s Fund
UNIVALI Universidade do Vale do Itajaí
TCC Trabalho de Conclusão de Curso
W3C World Wide Web Consortium
XML Extensible Markup Language
vii
LISTA DE FIGURAS
Figura 1. Utilização da Web API Google Maps ................................................................................. 20
Figura 2. Árvore construída pelo algoritmo MINIMAX .................................................................... 23 Figura 3. Pseudocódigo do algoritmo MINIMAX ............................................................................. 24 Figura 4. Jogo da memória educativo online ..................................................................................... 25 Figura 5. Tabuleiro do jogo da velha dos bichos ............................................................................... 26 Figura 6. Super Trunfo Árvores Brasileiras ....................................................................................... 27
Figura 7. Diagrama de atividades do Jogo da Memória ..................................................................... 31 Figura 8. Trecho do arquivo XML de configuração do Jogo da Memória ........................................ 32 Figura 9. Jogo da Memória em andamento ........................................................................................ 33
Figura 10. Configuração do Jogo da Memória ................................................................................... 34 Figura 11. Diagrama de atividades do jogo da velha ......................................................................... 36 Figura 12. Trecho do arquivo XML de configuração do Jogo da Velha ........................................... 37 Figura 13. Jogo da Velha em andamento ........................................................................................... 38
Figura 14. Configuração do Jogo da Velha ........................................................................................ 39 Figura 15. Diagrama de atividades do Super Trunfo ......................................................................... 41 Figura 16. Trecho do arquivo XML de configuração do Super Trunfo ............................................. 42 Figura 17. Super Trunfo em andamento ............................................................................................. 43
Figura 18. Configuração do Super Trunfo ......................................................................................... 44 Figura 19. Código do gerador XML ................................................................................................... 47
Figura 20. Código do Google AJAX Search API .............................................................................. 48 Figura 21. Exemplo de utilização da Web API .................................................................................. 49
Figura 22. Exemplo do código fonte da Web API ............................................................................. 51 Figura 23. Proxy ................................................................................................................................. 52
Figura 24. Estrutura básica de um arquivo XML ............................................................................... 56
viii
RESUMO
FORTES, Rafael dos Passos. Web API para disponibilização de jogos educativos em ambientes
virtuais. Itajaí, 2009. 64 f. Trabalho de Conclusão de Curso (Graduação em Ciência da
Computação)–Centro de Ciências Tecnológicas da Terra e do Mar, Universidade do Vale do Itajaí,
Itajaí, 2009.
Este projeto apresenta uma Web API que disponibiliza três jogos educacionais para crianças
desenvolvidos com o objetivo de auxiliar atividades educacionais em ambientes virtuais de
aprendizagem e sites em geral. Jogos educacionais podem contribuir de forma muito eficiente em
atividades de aprendizagem, tendo um alto grau de aceitação por parte de crianças. A Web API
desenvolvida neste projeto é o mecanismo que possibilita a disponibilização dos jogos
desenvolvidos através da inclusão de um código JavaScript no ambiente virtual. Desta forma,
qualquer pessoa interessada poderá incluir os jogos em seu ambiente e/ou site. O tema dos jogos é
customizável, sendo simples de configurar através de uma interface de configuração que está
embutida na Web API. Esta interface é responsável pela criação de um arquivo XML, que é
utilizado nos jogos. Os jogos desenvolvidos foram: Jogo da memória, Jogo da velha e Super
Trunfo.
Palavras-chave: Web API. Jogos na Educação. Informática na Educação.
ix
ABSTRACT
This project provides a web API that offers three educational games to children developed to
helping educational activities in virtual learning environments and sites. Educational games can
contribute very effectively in learning activities, with a high degree of acceptance by children. The
Web API developed in this project is a mechanism that enables the provision of games only
including JavaScript code in a virtual environment. Anyone interested may include games in their
environment and / or website. The theme of the game is customizable, and easy to set through a
configuration interface that is embedded in the Web API. This interface is responsible for creating
an XML file, which is used in games. The games developed was: the memory game, Tic tac toe, and
Super Trunfo.
Keywords: Web API. Educative Games. Informatic Education.
1 INTRODUÇÃO
Nos dias atuais, o Brasil sofre com vários problemas nas mais diversas áreas como má
distribuição de renda, corrupção, ensino precário por falta de investimento na educação, dentre
tantos outros.
Segundo Barros (2006) a relação entre educação e desenvolvimento já foi profundamente
comprovada por órgãos nacionais como o IPEA e internacionais vinculados às Nações Unidas como
CEPAL, UNESCO e UNICEF. Todos alertam para os riscos de não se investir na educação como
condição para deter o aumento das desigualdades e o avanço da pobreza.
A educação no Brasil necessita de estímulos. Seja para evitar a evasão escolar, seja para
atrair mais alunos para a sala de aula. Analisando este contexto, encontrou-se uma atividade que
tem o objetivo de estimular e atrair crianças e jovens para a sala de aula. Trata-se de jogos
educativos.
Jogos estão presentes nas vidas das pessoas freqüentemente, proporcionando lazer e
diversão. Unindo educação à diversão, encontra-se uma forma agradável de ensinar, aumentando a
produtividade do aprendizado, deixando os aluno mais interessados, propiciando uma maior
atratividade ao estudo.
Esta inclusão através da educação foi feita por meio do computador. Com o avanço da
tecnologia barateando os custos, e programas como inclusão digital, o acesso ao computador fica
mais fácil a cada dia. Tendo em vista que os computadores estão presentes com muita freqüência
nas vidas das pessoas e o acesso a eles já está bem simplificado, foram criados jogos para fins
educacionais, para serem jogados através do computador. Aproveitando também o fato de que as
crianças de hoje em dia são muito ligadas à informática e a jogos eletrônicos. Através de jogos
educacionais por meio do computador surgiram então os ambientes virtuais de ensino.
O objetivo principal de um ambiente virtual de ensino é fazer com que o aluno possa
aprender sozinho ou em grupo, com um conteúdo flexível, previamente configurado.
Segundo Lopes (2001), ambientes virtuais de ensino tornam possível a integração de
diferentes mídias: áudio, vídeo, imagens, textos, planilhas, dentre outras, que são comumente
utilizadas pelas pessoas como forma de comunicação no seu dia-a-dia.
11
Através de um ambiente virtual é possível educar a distância, em tempo real, sem a
necessidade de um professor presente. Tal característica auxilia no desenvolvimento intelectual do
aluno, obrigando-o a resolver as questões sem a ajuda de um professor.
Com base nesses itens foram desenvolvidos três jogos, para fins educacionais, possibilitando
a customização do conteúdo a ser utilizado. Os jogos abrangem quaisquer matérias de ensino
fundamental, haja vista que seu conteúdo pode ser definido a partir do arquivo XML. Estes jogos
são distribuídos em forma de uma Web API.
Para o desenvolvimento destes jogos bem como o da Web API, foram utilizados alguns
frameworks de forma a facilitar o desenvolvimento. Tais frameworks serão explicados
posteriormente. O objetivo principal de um framework é facilitar o desenvolvimento de aplicações,
provendo ao desenvolvedor, inúmeras funcionalidades de forma a agilizar o processo de
desenvolvimento. Existem inúmeros frameworks em diversas linguagens de programação (ZEMEL,
2009).
Segundo Marin (2009), API (Application Programming Interface ou Interface de
Programação de Aplicativos) é um conjunto de rotinas e padrões estabelecidos por um software
para utilização de suas funcionalidades por programas aplicativos. Através de uma API, programas
aplicativos, web ou desktop, podem utilizar seus serviços, sem precisar envolver-se em detalhes de
sua implementação.
Como exemplo pode-se citar a API do Google Maps. Basicamente o Google desenvolveu
uma API para possibilitar que qualquer site utilize o aplicativo Google Maps de maneira simples. O
desenvolvedor não precisa se preocupar com detalhes profundos de programação pelo fato de
possuir uma série de rotinas simples de utilizar.
Através de um arquivo XML é possível alterar partes da Web API do Google Maps
inserindo, por exemplo, pontos que seriam de interesse no mapa. Sendo assim, a proposta deste
trabalho fez uso de um arquivo XML para tornar possível alimentar o jogo com as informações
necessárias referentes ao conteúdo a ser utilizado no momento do jogo.
Segundo Alecrim (2003), a linguagem XML (Extensible Markup Language ou Linguagem
extensível de formatação) é definida como o formato universal para dados estruturados na Web.
Esses dados consistem em tabelas, desenhos, parâmetros de configuração, etc. A linguagem então
12
trata de definir regras que permitem escrever esses documentos de forma que sejam adequadamente
visíveis ao computador.
Além de ter um modo multiplayer no qual dois alunos podem se enfrentar, os jogos também
possuem mecanismos de inteligência artificial. Esta característica possibilita ao aluno enfrentar o
computador.
1.1 PROBLEMATIZAÇÃO
1.1.1 Formulação do Problema
Atualmente o Brasil sofre com problemas sérios na educação e necessita de estímulos, seja
para evitar a evasão escolar, seja para atrair mais alunos para a sala de aula. Um jogo educativo
pode ser uma peça muito importante no desenvolvimento intelectual de um aluno. Ele aumenta o
interesse do aluno pelo estudo e acaba facilitando a forma de aprendizado. Quando um aluno
encontra dificuldades em entender determinada matéria, ele acaba também tendo desinteresse pelo
estudo. Isso gera uma série de fatores que fazem com que o aluno não tenha sucesso ao ingressar na
vida profissional. Com base neste contexto, foram desenvolvidos jogos educativos bem como uma
Web API com o objetivo de estimular os alunos, visto que os jogos aumentam o aproveitamento nos
estudos.
1.1.2 Solução Proposta
Como resultado final deste trabalho, obteve-se os seguintes jogos:
Jogo da Memória;
Jogo da Velha; e
Super Trunfo.
Estes jogos são disponibilizados através de uma Web API, possibilitando o uso dos mesmos,
de maneira bem simples, fazendo uso de instruções Javascript para que sejam inclusas em um site.
Desta forma, qualquer pessoa interessada pode incluir este aplicativo em seu site. O tema dos jogos
é customizável, sendo simples de configurar através de um arquivo XML.
Neste trabalho de conclusão de curso, foram utilizadas as seguintes tecnologias:
PHP;
13
JavaScript; e
XML.
Os jogos possuem seus respectivos conteúdos totalmente customizáveis pelo educador
através do arquivo XML. Assim que a partida é concluída o ambiente pergunta se o jogador deseja
iniciar uma nova partida. Caso a resposta seja sim o ambiente carrega um novo XML
automaticamente, dando início a uma nova partida com o mesmo tema.
No arquivo de configuração do jogo pode ser utilizado palavras e imagens para melhorar a
jogabilidade.
Pode-se usar como exemplo uma aula de matemática em um ambiente virtual de ensino,
mais precisamente, através do jogo da memória. No jogo da memória tradicional casam-se os pares
iguais, porém neste jogo da memória podem-se casar perguntas com respostas corretas. Por
exemplo, a carta 9 x 5 casa com a carta 45. Caso o aluno consiga casar um determinado par, ele
prossegue jogando. Ao errar, ele passará a sua vez ao adversário que, caso seja o computador,
poderá memorizar as ultimas jogadas e assim determinar a melhor jogada a ser realizada através de
seu mecanismo de inteligência artificial. O jogo termina quando todos os pares forem encontrados.
Ao término da partida, o ambiente faz uma requisição AJAX para carregar uma nova partida sobre
o mesmo tema.
1.2 OBJETIVOS
1.2.1 Objetivo Geral
O objetivo geral deste trabalho é apresentar os jogos propostos para fins educacionais,
bem como a Web API que possibilita a distribuição dos mesmos em Ambientes Virtuais de Ensino.
1.2.2 Objetivos Específicos
Os objetivos específicos deste projeto são:
Pesquisar e analisar soluções semelhantes;
Determinar os jogos a serem desenvolvidos;
Determinar os requisitos exigidos pelos jogos;
14
Pesquisar e validar as tecnologias necessárias para a implementação dos jogos e da
Web API;
Determinar os algoritmos de Inteligência Artificial;
Modelar os jogos e a Web API de forma conceitual;
Implementar os jogos e a Web API;
Documentar o desenvolvimento dos jogos e da Web API; e
Documentar os resultados dos jogos e da Web API.
1.3 Metodologia
A metodologia seguida para o desenvolvimento deste projeto baseou-se nos seguintes
aspectos:
Definição do tema: através de conversas e reuniões com o orientador, definiu-se o problema,
e como ele deveria ser tratado.
Definição das Tecnologias e ferramentas que foram utilizadas: através de pesquisas, testes,
experiências com desenvolvimento e reuniões com o orientador, definiu-se quais tecnologias foram
utilizadas para o desenvolvimento do projeto.
Levantamento Bibliográfico: estudos e pesquisas de conceitos das tecnologias abordadas, e
da utilização dos jogos como forma de aprendizado.
Desenvolvimento do projeto: a Web API e os jogos foram desenvolvidos com o uso das
linguagens PHP e JavaScript. Em paralelo ao desenvolvimento os conteúdos de teste foram
incluídos nos jogos de forma a facilitar o desenvolvimento.
Documentação do desenvolvimento: documentado todo o projeto de pesquisa, além da
elaboração de artigos científicos.
1.4 Estrutura do trabalho
Este Trabalho de Conclusão está estruturado em 4 capítulos.
Capitulo 1, Introdução, onde tem-se uma visão geral do projeto.
Capitulo 2, Fundamentação Teórica, foi desenvolvido a revisão bibliográfica sobre os
assuntos e tecnologias e técnicas abordadas neste projeto;
15
Capitulo 3, apresenta o projeto detalhado do sistema desenvolvido, incluindo sua
especificação, modelagem UML e as respectivas telas. Foi discutido como foi implementado o
sistema proposto.
E para concluir, o Capitulo 4 apresenta as conclusões reiteradas durante do processo de
desenvolvimento do projeto além de apresentar sugestões para futuros trabalho a partir deste.
16
2 FUNDAMENTAÇÃO TEÓRICA
Neste capítulo são abordados alguns problemas da educação e ensino no Brasil, assim como
jogos na educação como forma de ensino. Posteriormente são apresentadas soluções semelhantes e
as definições dos jogos desenvolvidos. Também são abordadas as tecnologias utilizadas para a
implementação dos jogos e da Web API, bem como os algoritmos de inteligência artificial.
2.1 Problemas da educação e ensino no Brasil
Há muito tempo o Brasil vem sofrendo com sérios problemas na área de educação. Segundo
Caiado (2008):
(...) um país para se evoluir necessita de uma educação de qualidade como um dos
principais pontos de partida, fato esse considerado meio que distante da realidade brasileira.
Um país não progride com uma educação precária, todas as pessoas necessitam e devem ter
acesso à, no mínimo, educação básica.
Segundo Barros (2006) a relação entre educação e desenvolvimento já foi profundamente
comprovada por órgãos nacionais como o IPEA, e internacionais vinculados às Nações Unidas
como CEPAL, UNESCO e UNICEF. Todos alertam para os riscos de não se investir na educação
como condição para deter o aumento das desigualdades e o avanço da pobreza.
Na China tem-se um ótimo exemplo de um bom modelo de educação. De acordo com o site
oglobo, a educação que os estudantes chineses recebem atualmente poderá ter uma grande
influência sobre como o país poderá ser comandado em 2020. Os chineses de hoje possuem uma
formação mais aberta que a de seus pais, começando a estudar inglês mais cedo e participando de
programas de intercâmbio fora do país. As tecnologias também influenciam bastante (O Globo,
2009).
No Brasil o negócio é totalmente diferente. O analfabetismo é um dos maiores problemas da
educação no Brasil. A desigualdade social e o baixo poder aquisitivo são determinantes para o alto
índice de analfabetismo. O Brasil tem o segundo maior índice de analfabetismo da América do Sul
e o nono maior da América Latina, conforme mostra a Tabela 1 (ARAGAKI, 2007).
17
Tabela 1. Índice de analfabetismo na América Latina. Dados de 2005
Posição País Índice de analfabetismo
1° Haiti 45,2%
2° Nicarágua 31,9%
3° Guatemala 28,2%
4° Honduras 22,0%
5° El Salvador 18,9%
6° República Dominicana 14,5%
7° Bolívia 11,7%
8° Jamaica 11,3%
9° Brasil 11,1%
Fonte: UOL (2009)
Pode-se analisar que o Brasil diminuiu consideravelmente o seu índice de analfabetismo se
for comparado ao ano de 1996, quando possuía um índice de 29,1% (UOL, 2009). No entanto muita
coisa ainda deve melhorar para que a educação do Brasil esteja no mesmo nível dos países
desenvolvidos.
Segundo Buarque (2007):
(...) a educação não é um valor fundamental no imaginário da população brasileira, seja
pobre ou seja rica. O rico gasta dinheiro na educação do filho não é para que ele seja
educado, é para que ele tenha um bom salário depois de adulto. O pobre no Brasil ficou tão
acostumado a ser relegado que ele não considera a educação como algo fundamental. Um
pobre brasileiro acredita que tem direito a ter um carro igual ao rico, mas não acredita que
tem direito de ter uma escola igual à do rico.
O país necessita de investimentos, seja para erradicar o analfabetismo, seja para diminuir a
evasão escolar. Crianças em vez de estarem na escola estudando estão trabalhando para ajudar a
aumentar a renda de sua família. Isso é um atraso para o país, haja vista que as crianças são o futuro
e esperança do mesmo (BUARQUE, 2007).
2.2 Jogos na educação como forma de ensino
O termo jogo pode ser definido como uma atividade que auxilia no desenvolvimento
pessoal. Ele altera o estado físico e mental, trazendo emoções diferentes para quem perde e para
quem ganha. Huizinga (2004) define jogo como:
18
(...) uma atividade voluntária exercida dentro de certos e determinados limites de tempo e
espaço, seguindo regras livremente consentidas, mas absolutamente obrigatórias, dotado de
um fim em si mesmo, acompanhado de um sentimento de tensão e alegria e de uma
consciência de ser diferente de vida cotidiana.
A variedade de acontecimentos que são denominadas de jogo é muito grande. Denomina-se
jogo uma partida de futebol, uma partida de xadrez, um tabuleiro com peões, dentre tantos outros.
São situações bem diferentes que recebem a mesma denominação. No caso de jogos, quando são
utilizados para realizar atividades de ensino, deixam de exercer sua função lúdica. Segundo
Kishimoto (2003):
(...) o uso de brinquedos e jogos destinados a criar situações de brincadeiras em sala de aula
nem sempre foi aceito. Conforme a visão que o adulto tem da criança e da instituição
infantil, o jogo torna-se marginalizado. Se a criança é vista como um ser que deve ser
apenas disciplinado para aquisição de conhecimentos em instituições de ensino acadêmico,
não se aceita o jogo.
Jogos foram, e são, até hoje, amplamente usados em diversas sociedades para outros fins que
não sejam diversão e distração. A própria sociedade romana destinava os jogos para a formação de
soldados e cidadãos obedientes. Segundo Kishimoto (2003), a Ratio Studiorum, uma coletânea
privada fundamentada em experiências decorridas no colégio romano, ensina o latim da seguinte
forma: a gramática aparece em cinco tabelas. A primeira para o gênero e a declinação. A segunda
para as conjugações. A terceira para os pretéritos e as duas últimas para a sintaxe e o número.
Através de exercícios de caráter lúdico, o ensino padrão é substituído pelas tábuas murais, um
método menos atrativo.
Jogos estão presentes nas vidas das pessoas freqüentemente, proporcionando lazer e
diversão. Unindo educação à diversão, encontra-se uma forma agradável de ensinar, aumentando a
produtividade do aprendizado, deixando os alunos mais interessados, propiciando uma maior
atratividade ao estudo. Utilizando exercícios de caráter lúdico pode-se conseguir resultados muito
expressivos.
O objetivo principal de um ambiente virtual de ensino é fazer com que o aluno possa
aprender sozinho ou em grupo, com um conteúdo flexível, previamente configurado (LOPES,
2001).
19
Segundo Lopes (2001), ambientes virtuais de ensino tornam possível a integração de
diferentes mídias: áudio, vídeo, imagens, textos, planilhas, dentre outras, que são comumente
utilizadas pelas pessoas como forma de comunicação no seu dia-a-dia.
Através de um ambiente virtual é possível educar a distância, em tempo real, sem a
necessidade de um professor presente. Tal característica auxilia no desenvolvimento intelectual do
aluno, obrigando-o a resolver as questões sem a ajuda de um professor.
É importante frisar que os jogos não possuem dificuldade nem facilidade alta. Foi
encontrado um meio termo de dificuldade, assim o interesse do aluno pelo jogo aumenta.
2.3 Web API
Neste item será dada uma visão geral sobre Web API, além de mostrar seu funcionamento,
vantagens, desvantagens e exemplos de Web APIs utilizadas nos dias atuais.
2.3.1 Visão geral
API é o acrônimo de Application Programming Interface ou interface de programação de
aplicativos. A Web API estabelece um conjunto de rotinas a serem usadas para que se possa
usufruir das funcionalidades de um sistema na web. Através da chamada de simples rotinas tem-se o
resultado da funcionalidade, sem que seja necessário entrar em muitos detalhes da implementação
da funcionalidade em questão. Segundo Roos (2009), “uma interface entre aplicativo e programação
(API) é um conjunto de instruções e padrões de programação para acesso a um aplicativo de
software baseado na Web, ou ferramenta de Web”.
Vantagens de uma Web API:
Inúmeras funcionalidades disponíveis com alto grau de facilidade para serem
aplicadas através das rotinas; e
Reduz o tempo de desenvolvimento.
Desvantagens:
Número de funcionalidades limitadas: nem sempre se tem o que precisa;
Dificuldade em adicionar funcionalidades: leva-se um tempo para entender o código
e posteriormente adicionar funcionalidades; e
20
Problemas na rede: pode ocorrer algum tipo de problema no servidor que mantém a
Web API, impossibilitando o uso da mesma.
Hoje têm-se inúmeras Web APIs que são amplamente usadas pela comunidade de
desenvolvedores por todo o mundo. Pode-se citar a API do Google Maps, Google Analytics,
Amazon, dentre outros. A Amazon.com liberou a sua API para ser usada por quaisquer sites que
tenham interesse em obter informações detalhadas dos seus produtos. Graças ao uso desta API, é
possível exibir os produtos da Amazon de forma independente com preços atualizados, dentre
outras funcionalidades. O Google também possui uma API para manipulação de dados geográficos.
Através do Google Maps é possível ver o mapa do mundo de diferentes formas, calculando rotas,
dentre outras funcionalidades. A Figura 1 mostra como é feito o uso da Web API do Google Maps.
Figura 1. Utilização da Web API Google Maps
Fonte: Google (2009)
Segundo Webdic (2009), API é “um formato de mensagem, usado por um programa para
comunicar-se com um outro programa que fornece serviços para ele. Por exemplo, através das APIs
do Windows é possível comunicar-se com o sistema operacional para acessar alguns recursos
disponibilizados por ele.”
21
Quando se fala em Web API, não se pode deixar de falar em SOAP, acrônimo de Simple
Object Access Protocol. Trata-se de um protocolo de comunicação comumente utilizado por
aplicações Web que necessitam realizar a troca de informações. Tal troca é realizada através de
arquivos XML. A Google SOAP Search API utiliza este protocolo para realizar a comunicação
entre as aplicações web. Graças a esse conjunto de tecnologias, pode-se incluir a busca do Google
em um site de forma bem facilitada, fazendo o uso de algumas instruções.
2.4 Inteligência Artificial
Neste item será explicado o conceito de Inteligência Artificial bem como o funcionamento
de um algoritmo de Inteligência Artificial.
2.4.1 Definição
Inteligência Artificial (IA) é uma área da Ciência da Computação que busca simular em um
computador o comportamento humano, sendo uma área muito importante nos dias de hoje. A
Inteligência Artificial vem revolucionando e facilitando a vida na humanidade através da
automatização de tarefas, dentre outros, com pouquíssima ou quase nenhuma probabilidade de erro.
A área de IA cresce conforme vai crescendo a capacidade computacional dos computadores.
Segundo Ciriaco (2008), “Inteligência Artificial é um ramo da ciência da computação que se propõe
a elaborar dispositivos que simulem a capacidade humana de raciocinar, perceber, tomar decisões e
resolver problemas, enfim, a capacidade de ser inteligente.”
Nos anos iniciais da IA, em meados de 1960 a área foi realmente um sucesso, levando em
conta que em anos anteriores os computadores apenas realizavam o cálculo de contas matemáticas e
então já era possível que um computador realizasse uma tarefa de forma consistente.
Existe uma série de jogos em diversos estilos que utilizam Inteligência Artificial como, por
exemplo:
Xadrez;
Jogo da velha;
Quake; e
Fifa Soccer.
22
IA pode ser separada em dois ramos (TAVARES, 2009):
Inteligência Artificial Forte: é classificada como autoconsciente, baseada em um
computador que consiga raciocinar e resolver problemas. Muitos estudos já foram
realizados, porém pouco se progrediu, ao contrário da Inteligência Artificial Fraca; e
Inteligência Artificial Fraca: trata da noção de como lidar com problemas que sejam
determinísticos. Uma máquina com tal inteligência agiria como se fosse inteligente,
porém não tem autoconsciência ou noção de si, ou seja, não é capaz de raciocinar e
resolver problemas. Existe um teste para determinar a inteligência em máquinas
denominada Teste de Turing.
O detalhamento do Teste de Turing foge ao escopo deste projeto que visa apenas dar uma
visão geral da área.
2.4.2 Algoritmo de Inteligência Artificial MINIMAX
MINIMAX, criado por Von Neumann em 1928, é um algoritmo de inteligência artificial
utilizado para minimizar a perda máxima possível. É comumente utilizado em jogos de tabuleiro e
em jogos aonde se pode prever jogadas, isto é, em jogos aonde não há dependência de sorte para a
realização da jogada. Um exemplo de um jogo previsível é o xadrez e um jogo que se depende da
sorte é o gamão, aonde se lançam dados. Também é aplicável ao jogo da velha aonde cada jogador
pode vencer, empatar ou perder. Se um jogador pode vencer com um movimento, logo sua melhor
jogada é realizar este movimento. Se o outro jogador pode prever que um movimento pode dar a
vitória ao adversário e que outro movimento pode levar a um empate então ele realiza a jogada que
levará ao empate. Conforme o desenrolar do jogo vai ficando mais fácil prever as jogadas, haja vista
que o número de opções diminui a cada rodada. Enquanto um jogador tenta maximizar suas chances
de ganhar, o outro tenta minimizar estas chances. Daí então derivou-se o nome MINIMAX (Giga
Mundo, 2009).
O MINIMAX baseia-se em uma árvore de decisões, ou seja, constrói uma árvore contendo
todos os possíveis estados do jogo e de qual estado pode-se chegar a outro. A Figura 2 mostra o
exemplo de uma árvore construída pelo algoritmo (Giga Mundo, 2009).
23
Figura 2. Árvore construída pelo algoritmo MINIMAX
Fonte: Centria (1998)
Tratando-se do jogo da velha, o algoritmo é facilmente aplicável, haja vista que o número de
possibilidades é baixo, porém em um jogo de xadrez a utilização deste algoritmo já não é
interessante tendo em vista inúmeras possibilidades e várias peças. Para se aplicar o MINIMAX em
um jogo de xadrez um computador dos dias de hoje levaria muito tempo para analisar uma jogada,
tornando inviável a utilização do algoritmo. Existem hoje computadores com extrema capacidade
computacional e outros algoritmos utilizados para o xadrez (Giga Mundo, 2009).
O algoritmo MINIMAX é freqüentemente citado em teoria dos jogos e Inteligência
Artificial, na busca competitiva. Sua utilização é bastante especializada e utilizada em jogos
determinísticos de revezamento de dois jogadores (RUSSEL ; NORVIG, 2004).
A Figura 3 ilustra o pseudocódigo para o algoritmo.
24
Figura 3. Pseudocódigo do algoritmo MINIMAX
Fonte: Wikipedia (2009)
2.5 Soluções Similares
Para o desenvolvimento deste projeto, foi necessário um estudo descrevendo algumas
aplicações similares, mostrando seus pontos positivos e negativos, com o intuito de coletar
informações e dados para o desenvolvimento deste projeto.
2.5.1 Jogo da memória educativo online
Este projeto, apesar de não ser disponibilizado em forma de uma Web API, possibilita que
qualquer pessoa possa jogar através da internet, sem qualquer necessidade de instalação do software
no computador. Ele segue os padrões de um jogo da memória aonde se devem casar as cartas que
possuem conteúdos correspondentes, neste caso, pares iguais. O diferencial deste jogo é o conteúdo
das cartas que possui sinais de trânsito, conforme mostra a Figura 4.
O jogo utiliza a tecnologia flash, tão logo necessitando apenas a instalação de plugins que
trabalham em conjunto com o browser. Não utiliza nenhum algoritmo de Inteligência Artificial pelo
fato de não haver adversário na partida, isto é, somente o jogador humano joga. O jogo é finalizado
quando o jogador encontra todos os pares correspondentes. O responsável por este jogo é o
DETRAN do estado de Sergipe. (DETRAN-SE, 2009).
25
Figura 4. Jogo da memória educativo online
Fonte: DETRAN-SE (2009)
Pode-se observar que o par encontrado na Figura 4 informa que o pedestre deve atravessar
na faixa. Este tipo de conteúdo ajuda no desenvolvimento das crianças e jovens, visto que uma boa
educação no trânsito não só por parte de motoristas, mas também por parte dos pedestres pode
evitar acidentes.
2.5.2 Jogo da velha dos bichos
Desenvolvido por Kátia Stocco Smole com direitos autorais do MEC, este projeto tem como
objetivo desenvolver noções de adição, cálculo mental, raciocínio estratégico, comparação de
quantidades e localização espacial, incluindo a solução de situações-problemas. Não se trata de uma
Web API. No site que está referenciado na bibliografia, está apenas um link para download
contendo um arquivo para ser impresso por qualquer pessoa que tenha interesse em jogar o jogo.
Este arquivo é um tabuleiro, conforme mostra a Figura 5 (SMOLE, 2009).
Características do jogo:
Número de jogadores: dois;
26
Material necessário: um tabuleiro por dupla, ilustrado na Figura 5, 16 fichas (botões,
grãos, etc) sendo oito de uma cor e as restantes de outra;
Na sua vez de jogar o jogador escolhe dois números do tabuleiro e faz com eles uma
adição. Depois coloca sua ficha em uma casa do tabuleiro que represente a soma ou
total. Por exemplo, se um jogador escolhe os números 2 e 3, cuja soma é 5, ele pode
marcar no tabuleiro com sua ficha as borboletas, as moscas ou os caracóis;
A cada vez um jogador coloca apenas 1 ficha no tabuleiro; e
Vence o jogador que primeiro conseguir alinhar seguidamente suas fichas na
horizontal, na vertical ou na diagonal.
Figura 5. Tabuleiro do jogo da velha dos bichos
Fonte: MEC (2009)
27
2.5.3 Super Trunfo Árvores Brasileiras
Este projeto funciona da mesma forma que o projeto anterior no que tange a forma de jogar.
Joga-se ao vivo com uma pessoa, sem o uso do computador. Qualquer pessoa que tenha interesse
em jogar este jogo, pode fazer o download do arquivo que contém as cartas conforme mostra a
Figura 6, e imprimir.
As regras são as mesmas que de um jogo Super Trunfo padrão. O jogador escolhe um
atributo da carta e o atributo é comparado ao mesmo atributo da carta do adversário. Vence a rodada
o jogador que possuir o maior atributo. Aquele que vencer a rodada define o próximo atributo a ser
comparado (Progresso Verde, 2009).
Figura 6. Super Trunfo Árvores Brasileiras
Fonte: Progresso Verde (2009)
28
2.5.4 Análise das soluções similares
Com base nas soluções analisadas anteriormente, viu-se que os jogos utilizados possuem
uma grande capacidade de entreter e ao mesmo tempo ensinar gerando um alto grau de interesse por
parte de quem joga, e sendo altamente aceitáveis por educadores. Tratam-se de jogos extremamente
simples de se jogar, porém com um resultado muito interessante. São jogos que já são conhecidos
por muitas pessoas e que certamente serviram como uma ótima referência para a definição dos
jogos deste projeto.
29
3 DESENVOLVIMENTO
Para o desenvolvimento deste projeto foram levantados requisitos funcionais, requisitos não
funcionais e regras de negócio dos jogos. Também foi criado um diagrama de atividade para cada
jogo para ilustrar o fluxo de execução. As telas para ilustrar o funcionamento dos jogos também se
encontram abaixo.
3.1 Jogos desenvolvidos
Os jogos que foram desenvolvidos neste projeto são:
Jogo da Memória;
Jogo da Velha; e
Super Trunfo.
3.2 Análise dos requisitos identificados
Para o desenvolvimento do projeto foi necessária a definição dos jogos bem como a análise
e identificação de requisitos da Web API e dos jogos.
3.2.1 Requisitos funcionais
A Web API e os jogos deverão funcionar nos navegadores Internet Explorer e
Mozilla Firefox;
A Web API deverá prover um mecanismo de configuração do conteúdo dos jogos; e
Os jogos devem possibilitar o uso de imagens e conteúdos textuais.
3.2.2 Requisitos não-funcionais
Os jogos e a Web API deverão ser concebidos utilizando as tecnologias registradas
sob licença GPL (PHP, apache, Fedora Core);
O tempo de resposta da Web API não deve ultrapassar 20 segundos;
A Web API e os jogos deverão ter uma interface intuitiva; e
30
A Web API e os jogos deverão estar em conformidade W3C de HTML, CSS e
JavaScript.
3.2.3 Regras de negócio
A configuração dos jogos será de responsabilidade do administrador;
Os jogos deverão apresentar mensagens indicando de qual jogador é a vez;
Os jogos deverão apresentar o placar atualizado de cada jogador, rodada a rodada;
Os jogos deverão exibir uma mensagem perguntando se o jogador gostaria de jogar
outra partida;
Os jogos deverão informar o vencedor ao final da partida;
Jogo da memória: O jogo deverá possibilitar uma partida entre duas pessoas e entre
uma pessoa e o computador;
Jogo da memória e Super Trunfo: Os jogos deverão possibilitar ao usuário continuar
realizando jogadas em caso de acerto; e
Os jogos devem possibilitar que o usuário sempre inicie jogando.
3.3 Jogo da Memória
O jogo da memória consiste em um número pré-definido de peças espalhadas pela tela,
viradas para baixo, onde cada peça tem seu respectivo par. O conteúdo de cada peça é definido pelo
usuário. Pode-se usar, por exemplo:
Contas matemáticas;
Figuras; e
Estados e cidades.
O conteúdo é totalmente flexível, desde que haja sempre pares correspondentes. Ganha o
jogo o jogador que acertar o maior número de pares possíveis. O jogador vira duas peças por vez.
Se acertar o par, o mesmo fica desvirado e o jogador continua jogando. Em caso de erro a peça
31
volta a ficar virada e a vez é do outro jogador. O jogo possibilita uma partida entre duas pessoas e
entre uma pessoa e o computador. Há um mecanismo de inteligência artificial que será detalhado
posteriormente para que o computador escolha as peças em sua vez. O computador memoriza um
número definido posteriormente de peças que foram viradas e desviradas, ou seja, que não foi
correspondente a do outro par. Em sua vez ele escolhe de forma randômica uma peça de sua
memória e verifica se há o par correspondente em sua memória. Caso isto aconteça, ele escolhe o
par, senão escolhe uma posição randômica da tela.
O diagrama de atividades do Jogo da Memória está ilustrado na Figura 7.
Figura 7. Diagrama de atividades do Jogo da Memória
O arquivo XML utilizado pelo Jogo da Memória está ilustrado na Figura 8.
32
Figura 8. Trecho do arquivo XML de configuração do Jogo da Memória
A Figura 8 ilustra o arquivo XML resultante da configuração prévia do administrador. O
administrador define a matéria e o tema que o jogo irá abranger bem como as cartas e pares
correspondentes. No exemplo da Figura 8, o administrador definiu a matéria Geografia e escolheu
como tema os estados do Brasil. Para cada carta definida, o administrador define seu par
correspondente. Neste exemplo foram utilizado imagens e conteúdos textuais.
A Figura 9 ilustra o jogo da memória em andamento correspondente ao arquivo XML
ilustrado na Figura 8.
33
Figura 9. Jogo da Memória em andamento
No topo da Figura 9 está descrito o nome do jogo em questão, no caso Jogo da Memória.
Logo abaixo a matéria e o tema que foram configurados previamente no configurador do Jogo da
Memória. Abaixo pode-se ver a mensagem carregando juntamente com uma barra de carregando.
Esta imagem aparece quando o usuário solicita alguma ação, neste caso quando ele escolhe alguma
carta a ser virada. Em seguida tem-se o placar atual do jogo. Neste caso o jogador 01 está vencendo
por 2 x 0. Por fim tem-se a informação de qual jogador é a vez, além do tabuleiro de cartas.
34
3.3.1 Configuração do Jogo da Memória
A configuração do Jogo da Memória consiste em uma página, separada do jogo, que contém
os campos necessários para a entrada dos dados. A Figura 10 ilustra o configurador do Jogo da
Memória.
Figura 10. Configuração do Jogo da Memória
Ao preencher os campos o usuário deve clicar sobre o botão salvar. Feito isso será gerado
um arquivo XML resultante da configuração que estará alocado no servidor aonde se encontra a
Web API. Também fica disponível o link do arquivo XML para que o usuário possa fazer alterações
manuais e incluí-lo em seu domínio na internet.
35
3.4 Jogo da Velha
O jogo da velha consiste em conseguir realizar uma seqüência de três símbolos iguais, na
vertical, horizontal ou diagonal. Para o jogador realizar uma jogada, basta ele clicar em uma
posição. Ao clicar aparece uma pergunta com suas respectivas resposta, que já foi configurada
anteriormente, sendo que somente uma está correta. Se a resposta estiver correta a jogada é
realizada, caso contrário, é exibida a resposta correta ao aluno e o mesmo terá que escolher outra
posição para jogar. Em caso de erro em todas as posições possíveis no momento, é passada a vez ao
computador. A exemplo do jogo da memória, as perguntas deste jogo são totalmente flexíveis,
como por exemplo:
Contas matemáticas;
Perguntas de história; e
Perguntas de geografia.
Para que o computador realize as suas jogadas é utilizado o algoritmo de Inteligência
Artificial denominado MINIMAX.
O diagrama de atividades do Jogo da Velha está ilustrado na Figura 11.
36
Figura 11. Diagrama de atividades do jogo da velha
O arquivo XML utilizado pelo jogo da velha está ilustrado na Figura 12.
37
Figura 12. Trecho do arquivo XML de configuração do Jogo da Velha
A Figura 12 ilustra o arquivo XML resultante da configuração prévia do administrador. O
administrador define a matéria e tema que o jogo irá abranger, bem como as perguntas e respostas
correspondentes, além de informar a resposta certa para cada pergunta. No exemplo da Figura 12, o
administrador definiu a matéria Geografia e escolheu como tema bandeiras estaduais.
A Figura 13 ilustra o Jogo da Velha em andamento correspondente ao arquivo XML
ilustrado na Figura 12.
38
Figura 13. Jogo da Velha em andamento
39
No topo da Figura 13 está descrito o nome do jogo em questão, no caso Jogo da Velha. Logo
abaixo a matéria e o tema que foram configurados previamente no configurador do Jogo da Velha.
Abaixo pode-se ver a mensagem carregando juntamente com uma barra de carregando. Esta
imagem aparece quando o usuário solicita alguma ação, neste caso quando ele escolhe alguma
posição. Ao clicar em uma posição imediatamente aparece uma pergunta logo acima do tabuleiro
juntamente com as possíveis respostas sendo que somente uma está correta. O usuário então escolhe
a resposta e clica sobre o botão responder. Por final tem a informação de qual jogador é a vez.
3.4.1 Configuração do Jogo da Velha
A configuração do Jogo da Velha, a exemplo do configurador do Jogo da Memória, consiste
em uma página, separada do jogo que contém os campos necessários para a entrada dos dados. A
Figura 14 ilustra o configurador do Jogo da Velha.
Figura 14. Configuração do Jogo da Velha
40
Ao preencher os campos o usuário deve clicar sobre o botão salvar. Feito isso será gerado
um arquivo XML resultante da configuração que estará alocado no servidor aonde se encontra a
Web API. Também fica disponível o link do arquivo XML para que o usuário possa fazer alterações
manuais e incluí-lo em seu domínio na internet.
3.5 Super Trunfo
O Super Trunfo é um jogo que consiste em cartas que possuem atributos e valores. Para o
jogador realizar uma jogada, ele escolhe um atributo que é comparado ao mesmo atributo da carta
atual de seu adversário. O atributo que possuir o maior valor vence a rodada. Os atributos e seus
respectivos valores serão configurados previamente, podendo possuir qualquer tipo de informação.
Por exemplo, um super trunfo na área de geografia:
Carta Brasil. Atributo: População. Valor: 190.000.000; e
Carta Argentina. Atributo: População. Valor: 37.000.000.
Neste caso, a carta Brasil vence a rodada e o jogador da carta continua escolhendo os
atributos das cartas que forem vindo seqüencialmente, até que a sua escolha perca para o atributo da
carta do adversário.
Para que o computador possa realizar as suas jogadas, é utilizado um mecanismo de
Inteligência Artificial que será detalhado posteriormente. Ele tem em sua memória uma lista com os
atributos possíveis e os valores máximos. Assim ele realiza um cálculo com os atributos de sua
carta atual para definir o melhor atributo a ser utilizado.
O diagrama de atividades do Super Trunfo está ilustrado na Figura 15.
41
Figura 15. Diagrama de atividades do Super Trunfo
O arquivo XML utilizado pelo Super Trunfo está ilustrado abaixo na Figura 16.
42
Figura 16. Trecho do arquivo XML de configuração do Super Trunfo
O arquivo XML ilustrado na Figura 16 é resultado da configuração prévia do jogo pelo
administrador do site. Isto será detalhado na análise de requisitos. Tem-se um exemplo de um jogo
Super Trunfo com o estados. Pode-se observar que o administrador do site definiu a matéria e tema
do jogo bem como quatro atributos para todas as cartas, haja vista que nome e imagem são
informações obrigatórias. Imagem é opcional, porém sempre existirá a opção do administrador
enviar uma imagem para cada carta, ao contrário dos atributos que foram definidos na configuração.
Pode-se observar que o atributo possui um valor e uma avaliação. O valor, como o nome já diz, diz
respeito ao valor do atributo e a avaliação do atributo informa se o atributo deve ser o maior ou
menor possível para vencer a rodada. Por exemplo, se área for escolhida, vence a maior área, ao
contrário da mortalidade infantil que vence o menor.
43
A Figura 17 ilustra o jogo Super Trunfo em andamento correspondente ao arquivo XML
ilustrado na Figura 16.
Figura 17. Super Trunfo em andamento
No topo da Figura 17 está descrito o nome do jogo em questão, no caso Super Trunfo. Logo
abaixo a matéria e o tema que foram configurados previamente no configurador do Super Trunfo.
Um pouco mais abaixo tem-se a informação de qual jogador é a vez bem como a quantidade de
cartas de cada jogador. Vale ressaltar que o jogador que não tiver cartas perde o jogo. A Figura 17
ilustra duas cartas. Elas representam os estados brasileiros Maranhão e Rio de Janeiro. Tem-se o
nome das cartas bem como a imagem delas abaixo, no caso a bandeira bem como seus respectivos
44
atributos. O jogador que estava na vez escolheu o atributo população e foi exibido então o resultado
da comparação dos atributos.
3.5.1 Configuração do Super Trunfo
A configuração do Super Trunfo, a exemplo do configurador do Jogo da Memória e do Jogo
da Velha, consiste em uma página, separada do jogo que contém os campos necessários para a
entrada dos dados. A Figura 18 ilustra o configurador do Super Trunfo.
Figura 18. Configuração do Super Trunfo
45
Ao preencher os campos o usuário deve clicar sobre o botão salvar. Feito isso será gerado
um arquivo XML resultante da configuração que estará alocado no servidor aonde se encontra a
Web API. Também é disponível o link do arquivo XML para que o usuário possa fazer alterações
manuais e incluí-lo em seu domínio na internet.
3.6 Web API no projeto
Neste item será explicado como funciona a Web API deste projeto, bem como as formas de
utilizá-la.
3.6.1 Descrição
A Web API desenvolvida neste projeto segue a mesma linha de uma Web API convencional.
O administrador de um site, que fará uso da Web API adicionará um código Javascript em sua
página e após isso terá inúmeras rotinas a sua disposição.
3.6.2 Pré requisitos para uso da Web API
Para utilizar a Web API é necessário seguir os pré requisitos descritos abaixo:
Hospedagem com PHP: o cliente deve possuir hospedagem com PHP configurado;
Domínio: o cliente deverá fazer uso da Web API de um domínio na internet.
Exemplo: www.dominio.com.br. Isso se faz necessário para carregar o arquivo XML
correto caso o usuário não especifique o endereço do seu arquivo;
Cada jogo e seu respectivo configurador devem possuir uma página dedicada.
Exemplo: se for utilizar os três jogos então deve-se criar seis páginas pois tem-se três
jogos e três configuradores; e
Para instanciar um objeto do tipo RFortesWebAPI, responsável por prover todas as
funções, a variável utilizada deverá ter o nome game.
3.6.3 Geração do arquivo XML
A geração do arquivo XML é um item indispensável da Web API. Através dela é possível
criar um arquivo no formato XML informando todas as configurações necessárias para o bom
funcionamento dos jogos. Para que possa ser gerado o arquivo XML o administrador do site deve
46
criar uma página HTML para cada configurador do respectivo jogo, e nesta página chamar uma
função denominada configuraJogo que é responsável por tal tarefa. Ao chamar esta função é exibida
na tela uma interface para configuração do jogo selecionado. Esta interface possibilita ao
administrador utilizar imagens e palavras para configurar o jogo. Para utilizar imagens, a Web API
utiliza outra API denominada Google AJAX Search API que será explicada posteriormente.
O gerador de arquivos XML gera o arquivo no servidor onde a Web API está localizada e
também informa o link do arquivo para que o usuário possa analisar o formato do arquivo, baixá-lo
e alterá-lo. Feita a geração do arquivo, o administrador já está pronto para carregar o jogo
configurado em sua página principal. A Figura 19 mostra um código de exemplo de como utilizar o
gerador de XML na página HTML de configuração.
47
Figura 19. Código do gerador XML
3.6.4 Google AJAX Search API
A Google AJAX Search API é uma biblioteca Javascript que permite incorporar a pesquisa
do Google em quaisquer páginas ou aplicativos da web. Ela fornece mecanismos que executam
pesquisas em diversos serviços do Google como pesquisas na web, pesquisa de vídeos, pesquisa de
notícias, pesquisa de imagens e pesquisa em blogs. Foi desenvolvida para oferecer suporte a páginas
que têm por finalidade ajudar usuários a criar conteúdo como quadro de avisos e blogs, permitindo
que eles copiem os resultados da pesquisa diretamente em suas mensagens. Com a Google AJAX
Search API é possível incluir imagens nos jogos. O mecanismo de busca de imagens está disponível
48
na interface de configuração de jogos. Ao buscar um determinado conteúdo a Google AJAX Search
API se encarrega de buscar imagens com a palavra chave definida pelo administrador. Caso haja
mais de um resultado para a palavra buscada o administrador se encarrega de escolher a imagem em
meio a lista dos resultados. A Figura 20 mostra um exemplo de código simples da Google AJAX
Search API.
Figura 20. Código do Google AJAX Search API
Fonte: Google (2009)
49
3.6.5 Web API no lado do cliente
O cliente tem funções superficiais a sua disposição, ou seja, não precisa saber dos detalhes
da implementação da Web API, que por sinal está no lado do servidor. Pode-se citar algumas
rotinas para o cliente como:
Inicializa: rotina utilizada para criar um novo objeto do tipo Web API, para que seja
possível utilizar as funcionalidades; e
Carrega jogo: rotina utilizada para carregar o jogo no ambiente.
A Figura 21 mostra como será aplicada a Web API em uma página.
Figura 21. Exemplo de utilização da Web API
Pode-se observar na linha 6 é feita a inclusão da Web API, que está em outro domínio, o
que possibilita a utilização por quaisquer sites. Na linha 10 é criada uma função que é necessária
para o funcionamento da Web API e dos jogos. Neste caso foi chamada de inicializa, contendo dois
comandos. O primeiro comando é a criação do objeto do tipo RFortesWebAPI. Após este comando,
50
a variável game tem a sua disposição as funcionalidades da Web API. Neste caso ela utilizou a
rotina carregaJogo, passando por parâmetro o jogo a ser carregado e o identificador do div que
receberá o jogo. Pode-se ressaltar que o identificador é o atributo id do elemento HTML div.
3.6.6 Web API no servidor
No servidor é que ocorre toda a execução. A Web API localizada no servidor contém todas
as funções necessárias para o bom funcionamento dos jogos. Pode-se citar algumas rotinas como:
carregaNoDiv: função responsável por realizar uma determinada ação utilizando a
tecnologia AJAX. É a base para toda a Web API;
carregaJogo: função responsável por determinar o jogo a ser carregado. Trabalha em
conjunto com a função carregaNoDiv; e
realizaJogada: função responsável por realizar uma jogada. Também trabalha em
conjunto com a função carregaNoDiv.
A Figura 22 mostra um trecho da Web API.
51
Figura 22. Exemplo do código fonte da Web API
A função carregaJogo é responsável por carregar o jogo solicitado pelo administrador. É
exibido no elemento HTML div em que o administrador solicitou. A Figura 22 o trecho inicial do
código fonte da Web API.
3.6.7 Proxy
Para o funcionamento da Web API é necessário o uso de um proxy. Trata-se de um arquivo
com linhas de programação responsável por fazer a troca de informações entre domínios distintos,
isto é, trata-se de uma ponte de comunicação. O uso do proxy se fez necessário devido ao fato dos
52
navegadores atuais implementarem mecanismos de segurança que impedem a troca de informações
entre domínios utilizando AJAX. Para que a troca de informações ocorra normalmente o usuário
que irá utilizar a Web API deverá ter este proxy em seu domínio para que tudo funcione
normalmente.
Segundo Antispam (2009):
(...) um proxy é um servidor que atua como intermediário entre um cliente e outro servidor,
ou seja, um serviço de proxy faz conexões em nome de outros clientes. Quando um proxy
está mal configurado, ele permite o redirecionamento indiscriminado de conexões de
terceiros para quaisquer endereços IP e portas, sendo denominado proxy aberto. Proxies
abertos são também intencionalmente instalados por códigos maliciosos, como bots e
cavalos-de-tróia.
A Figura 23 ilustra o fluxo de funcionamento da Web API de uma ponta a outra passando
pelo proxy.
Figura 23. Proxy
3.7 Tecnologias necessárias para a implementação
Para desenvolvimento dos jogos foi necessário o uso das seguintes tecnologias, que serão
apresentadas detalhadamente a seguir:
PHP;
JavaScript;
HTML;
53
CSS;
DOM; e
XML.
3.7.1 PHP
PHP é um acrônimo para Hypertext Preprocessor. Trata-se de uma linguagem de
programação de código aberto utilizada amplamente em todo o mundo. É voltada para
desenvolvimento de web sites e sistemas web. É uma forma de gerar conteúdo de forma dinâmica.
Possui algumas características interessantes:
Velocidade e robustez;
Código estruturado e orientado a objeto;
Portabilidade; e
Sintaxe similar ao C.
3.7.2 JavaScript
JavaScript é uma linguagem de programação client-side, ou seja, executada no cliente, ao
contrário do PHP que é executado no servidor. Foi criada em 1995 pela Netscape com o nome
LiveScript. Os principais objetivos da linguagem eram:
Validar formulário no lado do cliente; e
Interação com a página.
As principais características da linguagem são:
Tipo de variáveis não definidos;
É interpretada, ao invés de compilada; e
Oferece suporte a expressão regular.
54
Existe um fusão desta linguagem com o CSS, formando o DHTML. (Dynamic HTML).
Com o JavaScript é possíveis modificar elementos de estilos de uma página, podendo alterar a
interface de forma dinâmica.
3.7.3 Prototype
Prototype é um framework JavaScript que vista facilitar o desenvolvimento de aplicações
dinâmicas para web. Ele oferece estilos de classe familiares a OO, extenso suporte ao AJAX e fácil
manipulação de DOM. (Prototype, 2009). O framework trabalha com as seguintes plataformas
atualmente:
Microsoft Internet Explorer para Windows, versão 6.0 e superiores;
Mozilla Firefox 1.5 e superiores;
Apple Safari 2.0.4 e superiores;
Opera 9.25 e superiores; e
Chrome 1.0 e superiores.
3.7.4 HTML
O HTML (Hyper Text Markup Language) é uma linguagem de marcação de texto utilizada
para desenvolver páginas web. Os documentos HTML são interpretados por um navegador. Por ser
um simples arquivo de texto, o HTML pode ser aberto por qualquer editor de texto. É composto por
tags.
As tags ou etiquetas não diferenciam letras maiúsculas de minúsculas ou seja, body e BoDy
são equivalentes no código (Html, 2009).
3.7.5 CSS
Acrônimo de Cascading Style Sheets, o CSS é uma linguagem de estilos utilizada para
definir a forma como os elementos de uma linguagem de marcação de texto como o HTML, se
comportam. Um dos grandes pontos negativos não é necessariamente o CSS em si e sim os
navegadores que o interpretam de formas diferentes, logo o desenvolvedor deve se preocupar em
conseguir obter os mesmos resultados, porém de formas diferentes. Existem padrões, porém há
55
navegadores que preferem seguir seus próprios padrões ao invés de seguir um padrão determinado
para a leitura e interpretação do CSS (Html, 2009).
Segundo MACEDO (2004) o CSS é uma linguagem de formatação de estilo utilizada para
definir a apresentação de documentos escritos em linguagens de marcação como HTML, XHML ou
XML. Seu principal benefício é prover a separação entre a formatação e o conteúdo de um
documento que será apresentado na tela, através de definições de fontes, cores, tamanhos e outras
propriedades de formatação.
3.7.6 DOM
DOM (Document Object Model - Modelo de Objetos de Documentos) é uma API que
manipula elementos HTML e XML. Com DOM é possível alterar, criar e navegar pela estrutura de
um documento composto por tags.
Segundo VAGNER (2007), o modelo DOM é baseado no modelo hierarquia, em formato de
uma árvore. Cada elemento ou texto é considerado um nó, e através desses nós você pode alterar as
estruturas da sua página. O DOM pode ser manipulado por qualquer linguagem script client-side
(JavaScript, Vbscript e etc.).
Inicialmente cada navegador possuía um interpretador DOM. Isso gerou uma série de
problemas de operatividade. Com o passar do tempo criou-se um padrão e os navegadores tiveram
de se adaptar para chegar até o que se tem nos dias de hoje.
3.7.7 XML
Acrônimo de eXtensible Markup Language, XML tem como proposta facilitar a troca de
informações em ambientes web.
Segundo Alecrim (2003), a linguagem XML (Extensible Markup Language ou Linguagem
extensível de formatação) é definida como o formato universal para dados estruturados na Web.
Esses dados consistem em tabelas, desenhos, parâmetros de configuração, etc. A linguagem então
trata de definir regras que permitem escrever esses documentos de forma que sejam adequadamente
visíveis ao computador.
O XML é parecido com o HTML. Ele é composto por tags, conforme mostra a Figura 24.
56
Figura 24. Estrutura básica de um arquivo XML
Possui como características:
Separa o conteúdo da formatação;
Simplicidade e legibilidade para humanos e computadores; e
Não possui nomes de tags definidas, portanto o número possível de tags é infinita.
3.8 Algoritmos de inteligência artificial
Para possibilitar que o usuário tenha um adversário nos jogos compostos pela Web API, foi
necessário utilizar mecanismos de Inteligência Artificial. O jogo da velha utiliza um algoritmo
denominado MINIMAX que foi detalhado anteriormente, enquanto os outros jogos utilizarão dois
mecanismos customizados que serão explicados a seguir.
3.8.1 Jogo da Memória e seu mecanismo de Inteligência Artificial
Conforme foi descrito anteriormente, o jogo da memória faz uso de um mecanismo de
inteligência artificial para possibilitar a realização de jogadas por parte do computador. Isso fará
com que o usuário tenha um adversário na partida.
A inteligência do computador é composta pelos seguintes itens:
Memória de jogadas realizadas pelo usuário sem sucesso;
57
Memória de jogadas realizadas pelo computador sem sucesso; e
Mecanismo de sorteio da realização da jogada.
Memória de jogadas realizadas pelo usuário sem sucesso
Este mecanismo é o responsável por armazenar todas as jogadas realizadas pelo usuário que
não obtiveram sucesso, ou seja, que não foram pares correspondentes e guardado em um array de
tamanho dinâmico cada posição das jogadas sem sucesso do usuário. Esta memória é atualizada
constantemente, visto que no caso de um acerto do jogador a memória irá remover aquela posição.
Memória de jogadas realizadas pelo computador sem sucesso
Este mecanismo é o responsável por armazenar todas as jogadas realizadas pelo computador
que não obtiveram sucesso, ou seja, que não foram pares correspondentes. Este mecanismo trabalha
de forma similar ao mecanismo anteriormente citado. É guardado em um array de tamanho
dinâmico cada posição das jogadas sem sucesso do computador. A memória é atualizada
constantemente caso o computador acerte posteriormente uma jogada que porventura possa estar na
memória de jogadas realizadas sem sucesso. Se for o caso, a posição é removida do array.
Mecanismo de sorteio da realização da jogada
Este mecanismo é o responsável pela realização de jogadas do computador. Ele atua em
conjunto com os dois mecanismos anteriormente citados, a memória de jogadas realizadas pelo
usuário sem sucesso e a memória de jogadas realizadas pelo computador sem sucesso. O sorteio da
realização da jogada segue os seguintes passos:
É sorteada uma carta que esteja disponível na tela, sendo que esta carta ainda não
está na memória de jogadas realizadas sem sucesso do computador e do usuário. Isto
é desconsiderado conforme o jogo for ocorrendo e a memória crescendo; e
Após o sorteio da posição, a carta é virada. O computador então procura o par
equivalente em sua memória de jogadas realizadas sem sucesso. Caso não encontre,
procura na memória de jogadas realizadas sem sucesso do usuário. Encontrando em
uma das duas memórias, escolhe então a posição para enfim realizar uma jogada de
sucesso. Caso não encontre, sorteia outra posição da tela que não esteja na sua
memória e na memória do usuário de jogadas realizadas sem sucesso.
58
3.8.2 Super Trunfo e Inteligência Artificial
Da mesma forma que o jogo da memória possui um mecanismo de inteligência artificial
customizado, o super trunfo também faz uso de um mecanismo customizado.
A inteligência é composta pelo seguinte item:
Mecanismo para realização da jogada.
Mecanismo de sorteio da realização da jogada
Este mecanismo é o responsável pela realização das jogadas do computador. Para realizar a
jogada o algoritmo deve escolher o atributo da carta atual que mais compense naquele momento.
Isto se faz através de um cálculo que é realizado. O jogo é composto por um número de cartas pré
definidos e pré configurados quanto aos seus atributos e valores. Estes atributos e valores estão
armazenados em um arquivo XML e também em um array, para agilizar a consulta. O computador
então realiza um cálculo comparativo de cada valor dos respectivos atributos da carta atual com os
melhores valores de atributos do jogo. A fórmula do cálculo é a seguinte:
atributoAtual / melhorAtributo * 100 Equação 1
O resultado deste cálculo se dá em porcentagem. Quanto mais próximo de 100% melhor a
jogada. O atributo que obtiver o maior percentual é escolhido pelo algoritmo para a jogada.
3.9 Dificuldades encontradas na implementação
Inicialmente a maior dificuldade foi em realizar a comunicação entre dois domínios distintos
utilizando a tecnologia AJAX. Isso se deu pelo fato dos navegadores implementarem mecanismos
de segurança de forma a impossibilitar que tal ação ocorra. Esta dificuldade foi contornada através
do uso de um proxy, que foi explicado anteriormente neste trabalho. O proxy faz a função de ponte
de comunicação entre os domínios de forma a possibilitar a troca de informações. A segunda
dificuldade encontrada foi referente à sessão do jogo. Por se tratar de jogos que são carregados
dinamicamente de outro domínio não era possível utilizar sessão, que é uma funcionalidade da
linguagem PHP. Como todos os jogos utilizam desse mecanismo para manter o contexto do jogo
como pontuação, acertos, erros, dentre outras informações, foi necessário implementar uma forma
alternativa de manter o contexto. Isso se fez possível salvando o contexto na variável $_POST. Foi
59
criado então um código HTML com campos ocultos e seus respectivos nomes e valores. Outra
dificuldade foi encontrar uma forma de submeter um formulário através do proxy para o domínio
em que se encontra a Web API.
4 CONCLUSÕES
O desenvolvimento deste trabalho foi motivado pela possibilidade de ajudar a melhorar a
qualidade de ensino para crianças e jovens através de jogos educativos, haja vista que o ensino no
Brasil ainda tem muito a melhorar no que tange a vários aspectos como infra-estrutura, mão de
obra, material, dentre outros. Também foi motivado pela carência de ferramentas deste gênero nos
dias atuais.
O objetivo principal deste projeto foi possibilitar a inclusão e utilização de jogos educativos
em sites ou ambientes virtuais de ensino de forma simples e eficiente, além de possibilitar a
customização dos conteúdos dos respectivos jogos através dos configuradores de conteúdos. Para
alcançar este objetivo, na primeira etapa do trabalho foi necessário realizar um estudo com base nas
ferramentas existentes para determinar quais jogos seriam desenvolvidos. Determinados os jogos foi
feito então um estudo para determinar as técnicas de desenvolvimento a serem utilizadas bem como
a definição de requisitos e regras de negócio.
Na segunda etapa do trabalho foi realizado um estudo para determinar as técnicas de
inteligência artificial dos jogos a fim de prover um modo em que o jogador pudesse enfrentar o
computador. Feito isso, deu-se então início ao desenvolvimento da Web API e dos jogos e seus
respectivos configuradores.
Durante a validação foi possível encontrar alguns problemas quanto ao desempenho dos
jogos. Isso ocorre pelo fato de se trabalhar no ambiente internet. A internet depende de uma série de
fatores para funcionar de forma eficaz em um determinado momento e quando isso não acontece o
desempenho dos jogos fica abaixo do normal.
A principal dificuldade foi encontrar uma maneira em realizar a comunicação entre dois
domínios distintos de forma a contornar o mecanismo de segurança dos navegadores. Fica como
sugestão para trabalhos futuros o aumento do número de jogos disponibilizados para esta Web API
bem como melhoria nos jogos na parte de animações.
Espera-se que a ferramenta gerada por este trabalho possa ser bem usufruída cumprindo as
expectativas iniciais em colaborar com a educação.
61
4.1 Trabalhos futuros
Durante o processo de desenvolvimento deste projeto notou-se a possibilidade de se
aprimorar o sistema desenvolvido com incrementos que poderão melhorar significativamente os
jogos e a Web API no que diz respeito a desempenho e jogabilidade. Tais aprimoramentos são:
Realização de testes para verificar se os jogos desenvolvidos auxiliam na educação;
Adequações nos jogos para auxiliar de forma mais efetiva na educação, com base nos
testes propostos;
Desenvolvimento de novos jogos para a Web API disponibilizar;
Desenvolver mecanismos de persistência na comunição, em caso de uma falha; e
Implementação de ranking para cada jogo gravando nome e pontuação de cada
jogador.
REFERÊNCIAS BIBLIOGRÁFICAS
ALECRIM, Emerson. Linguagem XML. 2003. Disponível em:
<http://www.infowester.com/lingxml.php>. Acesso em 24 mar. 2009.
Antispam. Como ocorre o abuso das redes. 2009. Disponível em:
http://www.antispam.br/admin/porta25/motivacao/. Acesso em 21 out. 2009.
ARAGAKI, Bruno. Brasil tem segundo maior índice de analfabetismo da América do Sul.
2007. Disponível em: <http://noticias.uol.com.br/educacao/ultnot/ult105u5900.jhtm>. Acesso em
06 abr. 2009.
BARROS, José Cláudio. Educação e desenvolvimento. 2006. Disponível em:
<http://www.care.org.br/Noticia.asp?CodConteudo=271>. Acesso em 12 mar. 2009.
BBC Brasil. CHINA moderniza educação para garantir liderança econômica. 2009. Disponível
em: <http://oglobo.globo.com/economia/mat/2009/04/02/china-moderniza-educacao-para-garantir-
lideranca-economica-755104585.asp>. Acesso em 08 abr. 2009.
BUARQUE, Cristovam. Combate ao analfabetismo. 2007. Disponível em:
<http://www.un.org/av/radio/pt/detail/3698.html>. Acesso em 06 abr. 2009.
CAIADO, Elen Cristine M. Campos. Educação no Brasil. 2008. Disponível em
<http://www.brasilescola.com/educacao/educacao-no-brasil.htm>. Acesso em 07 abr. 2009.
CENTRIA. Mini-max. 1998. Disponível em < http://centria.fct.unl.pt/~jja/iia/old/P4/p4.htm#4.1>.
Acesso em 13 jul. 2009.
CIRIACO, Douglas. O que é inteligência artificial? 2008. Disponível em:
<http://www.baixaki.com.br/info/1039-o-que-e-inteligencia-artificial-.htm>. Acesso em: 27 mai.
2009.
DETRAN-SE. Jogo da memória online. 2009. Disponível em:
<http://www.detran.se.gov.br/jogos_memoria.asp>. Acesso em 05 mai. 2009.
GIGA MUNDO. O algoritmo MINIMAX, corte Alpha-Beta e outros refinamentos. 2009.
Disponível em <http://www.computacao.gigamundo.com/2009/03/17/o-algoritmo-minimax-corte-
alpha-beta-e-outros-refinamentos/>. Acesso em 13 jul. 2009.
63
HTML. O que é CSS? 2009. Disponível em < http://pt-br.html.net/tutorials/css/lesson1.asp>.
Acesso em 08 dez. 2009.
HTML. O que é HTML? 2009. Disponível em < http://pt-
br.html.net/tutorials/HTML/lesson2.asp>. Acesso em 08 dez. 2009.
HUIZINGA, Johan. Homo ludens: o jogo como elemento da cultura. São Paulo: Perspectiva, 2004.
KISHIMOTO, Morchida Tizuko. O jogo e a educação infantil. 2003. Disponível em:
http://books.google.com/books?hl=pt-
BR&lr=&id=MSPPXYdSAC4C&oi=fnd&pg=PA1&dq=jogos+educação&ots=rIJMIfEgYH&sig=b
8UP9ueemlyaWVCAECfUpaV8Nkw#PPA15,M1>. Acesso em: 06 mai. 2009.
LOPES, G. S. Ambientes Virtuais de Ensino - Aspectos Estruturais e Tecnológicos. Dissertação
(Mestrado em Engenharia de Produção) – Pós-Graduação em Engenharia de Produção,
Universidade Federal de Santa Catarina. Florianópolis, 2001.
MACEDO, M. D. S. Construindo Sites Adotando Padrões Web. Rio de Janeiro: Ciência
Moderna, 2004.
MARIN, Rafael. APIs e mashups. 2007. Disponível em <http://rafaelmarin.net/apis-e-mashups>
Acesso em 10 mar. 2009.
NJogos. Dígitos duplos. 2009. Disponível em:
<http://www.njogos.com.br/jogar/1342/Jogos_Educativos._Digitos_Duplos/>. Acesso em 08 abr.
2009.
Progresso Verde. Super trunfo árvores brasileiras. 2009. Disponível em:
<http://progressoverde.blogspot.com/2008/03/super-trunfo-rvores-brasileiras.html>. Acesso em: 16
abr. 2009.
Prototype. API. 2009. Disponível em: < http://api.prototypejs.org/>. Acesso em 22 out. 2009.
ROOS, Dave. O que é uma API? 2005. Disponível em:
<http://informatica.hsw.uol.com.br/conferencia-api1.htm>. Acesso em 10 mai. 2009.
RUSSEL, S. E; Norvig P. Inteligência artificial. Rio de Janeiro: Elsevier, 2004.
64
SMOLE, Kátia Stocco. Jogo da velha dos bichos. 2009. Disponível em:
<http://objetoseducacionais2.mec.gov.br/handle/mec/6789>. Acesso em 05 mai. 2009.
TAVARES, Wladimir Araújo. Inteligência artificial. 2009. Disponível em: <
http://lia.ufc.br/~wladimir/ia/aula1.pdf >. Acesso em 13 jul. 2009.
VAGNER, Edson. Entendendo o DOM. 2007. Disponível em:
<http://www.plugmasters.com.br/sys/materias/794/1/Entendendo-o-DOM>. Acesso em 30 abr.
2009.
Webdic. Definição de API. 2009. Disponível em: <http://dicionario.babylon.com/API>. Acesso em
05 mai. 2009.
ZEMEL, Tárcio. O que é um framework? 2009. Disponível em: <
http://codeigniterbrasil.com/passos-iniciais/o-que-e-um-framework-definicao-e-beneficios-de-se-
usar-frameworks/>. Acesso em: 07 dez. 2009.