Jogos Educativos Online

Transcrição

Jaime Ricardo Moreira Lage
Engenharia Informática
Setembro 2008
-
Relatório da Disciplina de Projecto
Engenharia Informática
Escola Superior de Tecnologia e de Gestão
Jaime Lage
Setembro 2008
-
A Escola Superior de Tecnologia e Gestão não se responsabiliza pelas opiniões
expressas neste relatório.
- iii -
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da disciplina de Projecto.
___________________________________________
Paulo Alves,
Orientador
___________________________________________
Ana Isabel Pereira,
Co-Orientador
___________________________________________
, Arguente
Aceite para avaliação da disciplina de Projecto
- iv -
Prefácio
Como consequência do rápido aumento do número de jogos disponíveis no universo
da Internet, podemos constatar que nem sempre se encontram jogos relacionados com a
matemática. Existem, é certo, alguns portais onde podemos encontrar jogos vocacionados
para os mais novos ou mesmo para os mais velhos, mas o principal objectivo destes portais é
sobretudo entreter e não ensinar.
Este trabalho insere-se na disciplina de Projecto, tendo como objectivo principal o
desenvolvimento de jogos educativos destinados a diversos níveis etários, recorrendo às
ferramentas Gimp e Adobe Flash, no sentido de fomentar a aprendizagem da matemática.
Após a identificação dos requisitos, foram desenvolvidos os planos para a criação dos
jogos. Foram desenvolvidos dois jogos educativos, o Mahjongg e Torre de Hanoi, e também
um portal para alojar os mesmos e para servir de meio de comunicação entre os autores de
diversos trabalhos dentro do projecto Eureka, assim como para a divulgação da exposição
itinerante de jogos da matemática.
Este Projecto encontra-se inserido na iniciativa Ciência Viva, mais especificamente o
projecto Eureka – jogos Matemáticos, proposto pela ESTiG e que tem como principal
objectivo a divulgação da matemática pelas diversas escolas do país.
-v-
Agradecimentos
Este trabalho envolveu várias opiniões de diversos colegas durante a sua criação.
Colegas que partilharam o seu conhecimento e a sua opinião e que tornaram este projecto
num produto atractivo. A todos eles, muito obrigado.
Aos Professores Paulo Alves, Ana Pereira e Luísa Miranda, pela disponibilidade e
paciência com que sempre me receberam e pelos conhecimentos e opiniões que me guiaram
nas horas de aperto.
À família, que sempre me apoiou e possibilitou a minha realização pessoal em todas as
fases da minha vida.
Aos meus amigos, que com as suas opiniões me ajudaram a melhorar este trabalho, e
com o seu tempo me permitiram realizar os testes necessários.
À Ana, que sempre me apoiou, sempre esteve do meu lado, e sempre merecerá o meu
apreço e o seu merecido valor.
- vi -
Conteúdo
PREFÁCIO…………………………………………………………………………….. V
AGRADECIMENTOS………………………………………………………………… VI
CONTEÚDO…………………………………………………………………………… VII
LISTA DE TABELAS……………...………………………………………………….. IX
LISTA DE FIGURAS……………...………………………………………………….. X
ABREVIATURAS, ACRÓNIMOS e DEFINIÇÕES……………………………….. XI
1 INTRODUÇÃO ................................................................................................................. 1 1.1 CONTEXTO ................................................................ Erro! Marcador não definido. 1.2 Enquadramento do Problema ........................................................................................ 2 1.3 Estudo de Caso.............................................................................................................. 2 1.4 Objectivos do Projecto .................................................................................................. 2 1.5 Organização do Relatório ............................................................................................. 3 2 DESCRIÇÃO DO PROBLEMA ......................................... Erro! Marcador não definido. 3 ESTUDOS DE CASO ........................................................................................................ 7 3.1 Mahjongg ...................................................................................................................... 7 3.2 Torre de Hanoi .............................................................................................................. 9 4 ANÁLISE DE REQUISITOS .............................................. Erro! Marcador não definido. 4.1 Mahjongg .................................................................................................................... 10 4.2 Torre de Hanoi ............................................................................................................ 11 4.3 Requisitos do Flash ..................................................................................................... 11 4.4 Requisitos da página “Eurekit” ................................................................................... 12 5 ARQUITECTURA ............................................................... Erro! Marcador não definido. 5.1 Arquitectura da Aplicação .......................................................................................... 13 5.2 Ferramentas e Soluções Tecnológicas ........................................................................ 14 6 IMPLEMENTAÇÃO ...................................................................................................... 17 - vii -
6.1 Mahjongg .................................................................................................................... 17 6.1.1 1º Protótipo ........................................................................................................... 17 6.1.2 2º Protótipo ........................................................................................................... 18 6.1.3 Versão Final ......................................................................................................... 19 6.2 Torre de Hanoi ............................................................................................................ 20 6.3 “Eurekit” ..................................................................................................................... 21 6.4 Considerações ............................................................................................................. 21 7 CODIFICAÇÃO .............................................................................................................. 22 7.1 Mahjongg .................................................................................................................... 22 7.2 Torre de Hanoi ............................................................................................................ 24 8 TESTES / RESULTADOS .............................................................................................. 26 8.1 Crianças........................................................................ Erro! Marcador não definido. 8.1.1 Mahjongg ............................................................................................................. 27 8.1.2 Torre de Hanoi ..................................................................................................... 27 8.2 Jovens .......................................................................................................................... 28 8.2.1 Mahjongg ............................................................................................................. 28 8.2.2 Torre de Hanoi ..................................................................................................... 28 8.3 Alterações aos Jogos ................................................................................................... 29 9 CONCLUSÃO ....................................................................... Erro! Marcador não definido. 9.1 Trabalho Futuro .......................................................................................................... 31 Bibliografia ............................................................................................................................. 32 APÊNDICES ........................................................................................................................... 33 A Interface e Funcionalidades dos Jogos........................................................................... 34 A.1 Mahjongg .................................................................................................................... 34 A.2 Torre de Hanoi ............................................................................................................ 36 A.3 Eurekit ......................................................................................................................... 38 B Código dos Jogos .............................................................................................................. 39 B.1 Código do Mahjongg .................................................................................................. 39 B.1.1 Palco Principal – Durante o jogo.......................................................................... 39 B.1.2 Palco Principal – Antes de se iniciar o jogo ......................................................... 53 B.2 Código da Torre de Hanoi........................................................................................... 57 B.2.1 Palco Principal – Antes do início do jogo ............................................................ 57 B.2.2 Palco Principal – Menu Principal ......................................................................... 57 B.2.3 Palco Principal – Jogo com 5 peças ..................................................................... 59 - viii -
Lista de Tabelas
Tabela .1 – Aceitação dos utilizadores .................................................................................. 26 - ix -
Lista de Figuras
Figura .1 - Mahjongg “Shangai Dynasty” .............................................................................. 7 Figura .2 – “For Kids” ............................................................................................................. 8 Figura .3 - "Shangai" ............................................................................................................... 8 Figura .4 - Torre de Hanoi....................................................................................................... 9 Figura .5 - Comunicação Cliente Æ Servidor / Servidor Æ Base de Dados ..................... 13 Figura .6 - Fim do Jogo Mahjongg ....................................................................................... 15 Figura .7 - Tabela de Pontuações do Mahjongg .................................................................. 15 Figura .8 - Eurekit .................................................................................................................. 16 Figura .9 - 1º Protótipo Mahjongg ........................................................................................ 18 Figura .10 - Mahjongg com tema de Bragança ................................................................... 18 Figura .11 - Mahjongg - Menu Principal ............................................................................. 19 Figura .12 - Menu presente durante o jogo .......................................................................... 19 Figura .13 - Controlo de Volume .......................................................................................... 19 Figura .14 - Mahjongg com tema Tradicional ..................................................................... 20 Figura .15 - Mahjongg com tema Matemático .................................................................... 20 Figura .16 - 1º Protótipo Torre de Hanoi ............................................................................. 20 Figura .17 - Menu Principal Torre de Hanoi ....................................................................... 20 -x-
Abreviaturas, Acrónimos e Definições
WWW – World Wide Web
ESTiG – Escola Superior de Tecnologia e Gestão
JAVA – Mais do que uma linguagem, é uma tecnologia. Basicamente constitui-se por uma
linguagem de programação e um programa para execução denominado de máquina virtual
C++ - Linguagem de programação de alto nível
Flash – Adobe Flash (Anteriormente Macromedia Flash), é um software primariamente de
gráfico vectorial
OOP – Programação Orientada a Objectos (Object Oriented Programming)
Opensource – Programas distribuídos de forma gratuita, embora a verdadeira definição
signifique que os programas são de código aberto
XML – eXtensible Markup Language.
PHP – Hypertext Preprocessor, linguagem de programação muito utilizada para gerar
conteúdos dinâmicos na WWW.
MySQL – Base de Dados opensource
Edutainment – Educational Entertainment – Meio de entretenimento desenhado para
ensinar, bem como entreter.
Mahjongg – Jogo de mesa de origem chinesa, composto por 144 peças
Torre de Hanoi – Quebra-cabeças que consiste em diversas peças colocadas num de três
postes, com o objectivo de mover todas as peças desse poste para um dos outros
ActionScript – Linguagem de programação orientada a objectos disponibilizada pelo Flash
Ciência Viva – Programa da Agência Nacional Para a Cultura Cientifica e Tecnológica
Eureka – Iniciativa criada pelo programa Ciência Viva
Photoshop – Adobe Photoshop – Programa de edição de imagem
MsPaint – Microsoft Paint – Programa de criação de desenhos simples e de edição de
imagem fornecido com qualquer sistema operativo windows
Gimp – Gnu Image Manipulation Program – Programa de edição de imagem de licença livre
xi
Javascript – linguagem de programação de alto nível, interpretada, especialmente
vocacionada para a internet
Director – Adobe Director – Software de criação de jogos, demos e Dvd’s, com possibilidade
de conteúdo em duas ou três dimensões
Shockwave – Adobe Shockwave – Software de reprodução de conteúdos na Internet, sendo
uma plataforma de lançamento de produtos desenvolvidos com a ferramenta Adobe Director
xii
CAPÍTULO 1. INTRODUÇÃO
Capítulo 1
Este capítulo será focado no âmbito em que o
projecto se insere, descrevendo as motivações que
levaram à sua realização e quais os objectivos que se
pretendiam alcançar.
1 INTRODUÇÃO
1.1 CONTEXTO
Existem vários jogos da área do Edutainment que visam estimular a aprendizagem em várias
áreas, tais como a Matemática, Ciências, Língua Portuguesa, entre outras. Estes jogos
inserem-se nesta área e têm como principal objectivo, o aumento do gosto pela matemática,
uma área que segundo relatórios da OCDE se encontra muito deficitária em Portugal, em
comparação com os restantes países europeus.
Para garantir que a matemática não é o problema que querem fazer transparecer, temos que
consciencializar e ajudar a mudar consciências.
Esta mudança de atitudes e de pensamentos deve-se mudar logo nos mais novos, que são
muitas vezes influenciados por pensamentos erróneos dos mais velhos.
As vantagens de uma mudança de pensamento em relação à matemática são várias, realçando
o facto de que ao se intervir nos mais pequenos hoje, mais tarde eles mesmos terão um
importante papel de incentivo à mudança das futuras gerações.
1
1.2 Enquadramento do Problema
A área do Edutainment tem sofrido nos últimos anos grandes evoluções, tendo já sido
adaptada a várias áreas do conhecimento. Com uma difusão continuamente acentuada e com o
lançamento constante de novos jogos, torna-se pertinente a adaptação destes a uma área
específica. Neste caso, à matemática.
1.3 Estudo de Caso
O caso em análise é resultado de uma pesquisa sobre vários jogos do género “Mahjongg” ou,
para melhor diferenciação, “Mahjongg Solitaire”.
Após análise aos diversos jogos disponíveis na Internet, chega-se à conclusão que a diferença
entre eles não é tão notória como seria de esperar, isto porque o número de jogos deste género
é substancialmente elevado. Para a maior parte destes jogos, o princípio é sempre o mesmo, as
mesmas peças, os mesmos desenhos, a mesma música. Não existe melhoramento de um jogo
antigo para um jogo mais recente, mesmo sendo visível que já existem vários jogos do mesmo
género distribuídos por vários locais da Internet.
Tendo sido avaliado os defeitos e as virtudes de vários destes exemplos, partiu-se para o
esboço inicial do que deveria ser mantido, retirado ou acrescentado.
Decidiu-se pela inserção de novas imagens, com temas alegóricos ao Distrito de Bragança e
também relacionado com a Matemática.
Assim pretendia-se tornar este jogo um desafio matemático e com uma vertente mais
vocacionada para o “edutainment”.
Em relação à Torre de Hanoi, o objectivo passava principalmente pela criação deste jogo, sem
lhe retirar o valor original. Analisaram-se também alguns casos e procedeu-se à escolha do
que poderia ser implementado e o que não o seria.
1.4 Objectivos do Projecto
O objectivo central deste projecto consiste no desenvolvimento de um jogo que agregue os
princípios básicos do “Mahjongg”, aliado às tradições de Trás-os-Montes e a alguns cálculos
matemáticos. Adicionalmente será também desenvolvido outro jogo: “Torre de Hanoi”, bem
como uma interface Web, vulgo página da Internet, cujo objectivo é o de permitir a
divulgação duma exposição que integra todos os trabalhos associados ao projecto Eureka –
Jogos Matemáticos proposto pela ESTiG no âmbito da iniciativa Ciência Viva.
Estes objectivos, sendo globais, serviram de ponto de partida para a realização deste projecto.
2
Com o decorrer do projecto foram sendo introduzidos outros objectivos que, pretendeu-se,
dessem mais valor ao resultado final. Apesar de a proposta inicial incidir unicamente sobre
um jogo, o “Mahjongg”, ao longo do tempo acrescentou-se outro jogo, a “Torre de Hanoi”, e
mais tarde, a página “Eurekit”.
1.5 Organização do Relatório
Ao longo deste relatório serão apresentados os jogos desenvolvidos, bem como a sua
interface, a página que permitirá a sua divulgação, e também o necessário enquadramento em
que este trabalho se insere. Esta secção apresenta a organização do relatório, o que constitui
um mapa que permitirá acompanhar esta exposição. Este documento está dividido em 8
capítulos – sendo o primeiro o presente – e respectivos anexos.
Capítulo 2 – Neste capítulo é feita uma descrição do problema, do seu contexto e das
possíveis soluções. Após um estudo global sobre o estado da arte dos jogos educativos, serão
apresentadas possíveis soluções.
Capítulo 3 – Neste capítulo será apresentado um caso específico de um jogo que se encontra
disponível na WWW. Após uma descrição detalhada do jogo, será exposta uma breve
descrição da solução desenvolvida e implementada.
Capítulo 4 – Capítulo relativo ao levantamento de requisitos, apresentando-se aqui os
requisitos do projecto e para a realização.
Capítulo 5 – Neste capítulo apresenta-se a arquitectura global do projecto, a sua interface
gráfica, bem como os principais módulos que realçam o jogo. Também serão apresentadas as
ferramentas utilizadas para desenvolver, criar e testar a aplicação.
Capítulo 6 – Apresentação dos vários protótipos desenvolvidos antes de se escolher uma
solução final. Vantagens e desvantagens de cada uma das soluções apontadas.
Capítulo 7 – Capítulo relativo aos algoritmos utilizados nos jogos.
Capítulo 8 – Neste capítulo serão apresentados os resultados / testes obtidos após o término
do projecto.
Capítulo 9 – Após a análise de todo o processo de desenvolvimento do projecto, serão
expostas as conclusões, assim como trabalho futuro.
3
CAPÍTULO 2. DESCRIÇÃO DO PROBLEMA
Capítulo 2
De forma a melhor compreender o contexto em
que este projecto se insere, será apresentada uma
descrição sobre o problema que se pretende resolver,
apresentando algumas soluções para o problema.
2 DESCRIÇÃO DO PROBLEMA
Com o objectivo de se compreender o contexto do problema em que se insere este projecto,
torna-se pertinente obter respostas para as seguintes perguntas:
•
Os jogos existentes oferecem mais do que divertimento?
•
Existe divulgação deste género de jogos no panorama educativo?
•
Serão as soluções existentes suficientes?
•
Caso exista necessidade de adaptação dos jogos para diferentes áreas do
conhecimento existe essa possibilidade?
Este conjunto de questões será aqui alvo de análise e de resposta, pois nele reside o primeiro
passo para a resolução de vários problemas e objectivos a atingir com este trabalho.
Algumas destas perguntas não serão difíceis de responder, outras, pelo contrário, exibem
outro tipo de exigência. No que diz respeito à escolha do programa e linguagem a utilizar,
existem diversas abordagens possíveis nesse sentido, por exemplo:
o Exemplo 1 - C++
o Exemplo 2 - JAVA
o Exemplo 3 – DIRECTOR e SHOCKWAVE
o Exemplo 4 – FLASH
4
A diferenciação entre estes três exemplos será feita ao nível da interface gráfica tendo em
vista a utilização do jogo online, uma vez que em relação às linguagens de programação,
todas elas têm o mesmo princípio: a Programação Orientada a Objectos (OOP).
No Exemplo 1, C++, consegue-se criar o jogo, mas ao nível gráfico já é requerido outro
trabalho e é uma linguagem que, para criação de projectos na Internet, não granja de muitos
adeptos.
Assim sendo, e embora seja uma linguagem poderosa, para o projecto em questão não é a
escolha mais acertada, pois levantaria alguns problemas na parte gráfica.
Relativamente ao Exemplo 2, JAVA, também, neste caso, estamos perante uma linguagem
bastante poderosa com a qual, sem dúvida, se conseguiria chegar a um resultado final
satisfatório, e com um interface gráfico atractivo. Estamos perante uma linguagem com
inúmeros adeptos e resultados comprovados na Internet.
O problema desta solução é não ser tão poderosa, neste caso, como a solução apresentada no
exemplo 3.
No exemplo 3 é-nos apresentado o ADOBE DIRECTOR (anteriormente Macromedia
Director) e o ADOBE SHOCKWAVE (de igual modo, anteriormente um produto
Macromedia), que juntos demonstram ser uma ferramenta bastante poderosa e bastante
utilizada para o desenvolvimento de animações e jogos para a Internet. Ao ter sido
introduzida a linguagem de programação Lingo, esta ferramenta tornou-se também uma
escolha bastante popular para a criação de CD-ROMs. Este programa suporta projectos
multimédia em duas e em três dimensões, sendo ainda capaz de integrar projectos
desenvolvidos em FLASH. A linguagem Lingo sofreu alterações ao longo do tempo,
utilizando actualmente uma semântica semelhante ao C++ ou ao Javascript.
Embora estejamos perante uma solução bastante poderosa, esta apenas atinge a plenitude ao
ser integrada com o SHOCKWAVE, isto porque, caso se pretenda a sua publicação no
universo cibernético, será necessário recorrer a um plug-in para esse efeito.
Assim sendo, conclui-se que estas ferramentas são bastante poderosas, mas requerem a sua
utilização conjunta para se atingirem todos os objectivos.
Chegamos ao último exemplo e ao programa, e respectiva linguagem, escolhido para a
realização deste trabalho. No exemplo 4 estamos perante o programa FLASH, um programa
que é familiar para muitos programadores, devido às suas inúmeras potencialidades, desde um
simples cartão-de-visita, até páginas para a Internet, e jogos. É precisamente a criação de
jogos que nos interessa para a realização deste trabalho e, apesar do excelente par de
programas apresentado no exemplo 3, o FLASH apresenta-se também como um programa
poderoso. No que diz respeito à linguagem utilizada, o FLASH apresenta-nos o ActionScript,
uma linguagem muito semelhante ao Javascript. Em relação à interface gráfica, o FLASH
merece destaque, isto porque apresenta vários menus que permitem criar, ao nosso gosto, o
interface que desejamos para os nossos jogos.
Em termos gerais, esta é a melhor escolha, pois permite:
I.
II.
Criar uma interface gráfica de maneira bastante simples e intuitiva
Assim como os exemplos anteriores, disponibiliza uma linguagem poderosa que
permite atingir os objectivos
5
III.
Um dos (ou mesmo o) meios de difusão de jogos, entre outras coisas, mais poderoso e
mais utilizado no universo cibernético
IV.
Permite a publicação dos jogos na Internet, sem a necessidade de recorrer a uma
ferramenta externa para esse efeito, o que não sucede com o DIRECTOR.
Quando se analisam soluções, há a necessidade de se avaliar conscientemente o problema
para o qual se pretende obter uma resolução, e a melhor forma para se atingir esse resultado
final. Isto porque, considerando as vantagens e desvantagens de cada uma das opções que se
poderiam tomar, poder-se-á encontrar o melhor compromisso para o problema, isto é, nem
sempre as soluções encontradas são perfeitas, apenas se encontram bons compromissos.
Em relação às perguntas colocadas no início deste capítulo, chegou-se à conclusão de que os
jogos existentes tinham como principal objectivo apenas o divertimento. Encontraram-se no
panorama educativo (páginas da Internet com jogos educativos) alguns destes jogos, mas
infelizmente, o conceito era o mesmo, diversão, e não tanto o de educar. As soluções poderão
ser suficientes, e talvez até já serem muitas, mas o problema manteve-se, não havia filiação a
nenhuma área da educação. A conclusão mais lógica foi que, embora existissem muitos jogos
deste género, havia espaço para a diferenciação. Havia espaço para novas soluções. Optou-se
também por procurar jogos vocacionados para diferentes áreas, o que não se encontrou e,
embora neste caso específico se pretenda aumentar o gosto pela matemática, optou-se por
deixar espaço para a adaptação do Mahjongg para outras áreas.
Para o jogo Torre de Hanoi, o processo de decisão foi o mesmo, pelo que o Flash foi a
tecnologia escolhida.
Para a página “Eurekit”, optou-se pela utilização de uma tecnologia diferente, o Joomla.
Seria possível realizar um trabalho semelhante recorrendo, por exemplo, ao Mambo, também
este uma ferramenta poderosa, mas quando comparados, o Joomla sobressai-se no que diz
respeito ao número de utilizadores, bem como no número de componentes que se podem
utilizar na criação da página. Para os objectivos apresentados, e tendo em conta a
popularidade de cada ferramenta, a escolha final foi o Joomla, o que provou ser uma escolha
acertada.
6
CAPÍTULO 3. CASOS DE ESTUDO
Capítulo 3
Após a apresentação do problema no capítulo
anterior, será apresentado o estudo de caso deste
projecto. Neste capítulo será focada uma possível
solução e quais as particularidades deste caso.
3 ESTUDOS DE CASO
3.1 Mahjongg
Depois de uma breve descrição nos dois primeiros capítulos sobre os jogos, a tecnologia a
adoptar e sobre possíveis soluções, irá ser apresentado com mais detalhe um jogo em
particular para cada um dos que se pretende desenvolver.
Numa primeira fase foi realizado um estudo sobre os requisitos globais e os particulares do
projecto. Após reunir as informações necessárias, foi efectuada uma análise sobre as
tecnologias existentes que possibilitariam atingir a solução final. Finalizada esta etapa,
iniciou-se o desenvolvimento e a implementação utilizando o programa escolhido.
No estudo do estado da arte, foram encontrados diversos tipos de jogos, do qual foi escolhido
um caso particular para análise.
Para melhor se compreender um dos jogos existentes, pode-se visualizar na Figura .1 o
exemplo analisado.
Figura .1 - Mahjongg “Shangai Dynasty”
7
Como se pode ver, somos colocados perante um menu simples, com duas opções, uma para
crianças (Figura .2) e outra, com o nome “Shangai”, que permite jogar o formato mais
comum do “Mahjongg”, ilustrado na Figura .3.
Figura .2 – “For Kids”
Figura .3 - "Shangai"
Após análise do jogo, vemos que as opções são limitadas uma vez que, além de permitir
escolher entre um jogo para crianças e um outro um pouco mais complexo, o jogo apenas tem
a opção de reiniciar. O que significa que se quisermos desfazer uma jogada, pedir ajuda, ver
os movimentos restantes, entre outras opções, não teremos essa disponibilidade. Estamos
então perante um jogo simples, que desempenha o papel de entreter, mas não tanto o de
ensinar.
Podemos então apresentar alguns requisitos, que serão descritos no próximo capítulo, que
parecem ser necessários nestes jogos, mas que nem sempre se encontram disponíveis:
9
9
9
9
9
9
9
9
Novo Jogo
Reiniciar o mesmo jogo
Desfazer a última jogada
Movimentos Restantes
Dica
Ajuda
Grau de Dificuldade
Pontuação apresentada durante o jogo
8
Para além dos requisitos acima mencionados, foram também adicionados outros, que
merecem, talvez, mais destaque, pois são estes que tornam o jogo diferente, e em parte único:
9 Peças com tema alegórico ao Distrito de Bragança
9 Peças com tema alegórico à Matemática
9 Tabela de pontuações
3.2 Torre de Hanoi
No caso do jogo “Torre de Hanoi”, analisou-se o seguinte exemplo:
Figura .4 - Torre de Hanoi
Neste exemplo, podemos constatar as opções disponíveis, que nos mostram apenas, o número
de peças com o qual desejamos jogar e o contacto de correio electrónico. Para além destas
opções, durante o jogo apenas temos disponível a opção de recomeçar um novo jogo.
Foram então definidos alguns pontos a acrescentar no jogo que seria desenvolvido:
9 Menu de Ajuda
9 Uma Opção para pausar o jogo
9 Menu de pontuações
De referir que os estudos de caso analisados, foram desenvolvidos com recurso à tecnologia
Flash, a qual será igualmente utilizada na resolução do nosso problema.
Aquele que poderá ser visto como uma desvantagem desta solução, é o facto de ser necessário
ao utilizador esperar pelo carregamento do jogo antes de o poder jogar. No capítulo de
implementação serão descritos alguns procedimentos que pretendem minimizar esta
desvantagem, optimizando o tempo de carregamento e o tamanho do jogo.
9
CAPÍTULO 4. ANÁLISE DE REQUISITOS
Capítulo 4
Após uma análise inicial dos requisitos do
problema, definiram-se oito requisitos principais, como
ponto de partida para implementar no projecto, e mais
três para o diferenciar. Na Torre de Hanoi, foram
definidos três requisitos. Ao longo do projecto foram
sendo acrescentados outros requisitos.
4 ANÁLISE DE REQUISITOS
A decisão dos requisitos foi definida depois de comparação entre vários modelos de jogo do
estilo que queremos criar. Estas características serviram de rumo ao desenvolvimento do
projecto e à definição de prioridades.
4.1 Mahjongg
Após a referida análise foram então definidos os principais requisitos:
9
9
9
9
9
9
9
9
9
9
9
Peças com tema alegórico ao distrito de Bragança
Peças com tema alegórico à Matemática
Tabela de pontuações
Novo Jogo
Reiniciar
Desfazer jogadas
Movimentos Restantes
Dica
Ajuda
Grau de Dificuldade
Pontuação apresentada durante o jogo
Um dos principais objectivos definidos foi a introdução, para além do tradicional tema do
Mahjongg, de um tema com imagens alegóricas ao distrito de Bragança, isto é, imagens que,
quando observadas, representassem inequivocamente o distrito e o que ele tem para oferecer.
10
Adicionalmente, foi adicionado outro tema, relacionado com a Matemática perfazendo um
total de três temas diferentes.
Foram também introduzidas funcionalidades de melhoria da usabilidade e da acessibilidade
que disponibilizam ao utilizador as opções de criar um novo jogo, recomeçar o jogo actual,
desfazer jogadas, ver as jogadas restantes e uma opção denominada “Dica”, que permitia ver
uma ou várias jogadas possíveis.
Criou-se o menu de ajuda, com instruções de jogabilidade, história do Mahjongg e alguns
truques.
À medida que se foi desenvolvendo o jogo e criando todos estes requisitos, foi-se verificando
a necessidade de novas funcionalidades. Duas das funcionalidades inseridas logo após a
inserção de graus de dificuldade foram:
Opção para jogadores jovens ou para crianças
Função que permitia a execução de acções definidas para os botões do jogo após
seleccionada uma tecla do computador (Figura .12)
4.2 Torre de Hanoi
No caso da Torre de Hanoi, os requisitos definidos foram os seguintes:
9 Menu de Ajuda
9 Uma Opção para pausar o jogo
9 Menu de pontuações
Depois de avaliados os exemplos deste tipo de jogo, optou-se pela introdução de algumas
alterações. A principal alteração pende-se no facto de ser possível guardar a pontuação dos
utilizadores. Além desta opção, é possível colocar o jogo em pause e dispomos de um menu
de ajuda que apresenta a história do jogo, como jogar e informações sobre quem o realizou.
Quando se procedia à avaliação dos diversos jogos existentes, foi notado que poucos eram os
que disponibilizavam uma tabela/meio de armazenamento das pontuações. Optou-se então
pela introdução desse requisito em ambos os jogos (Mahjongg e Torre de Hanoi) de forma a
criar também alguma competitividade entre os utilizadores do jogo.
4.3 Requisitos do Flash
Relativamente à plataforma de desenvolvimento do jogo, o Flash, foram identificados alguns
requisitos:

Evolução e Adaptabilidade:
o Facilidade de introdução de novas funcionalidades nos jogos
desenvolvidos
11

o Execução dos jogos sobre diversas plataformas
o Possibilidade de integração de outros temas com um reduzido esforço
Requisitos Tecnológicos:
o Adopção de ferramentas e soluções opensource, sempre que possível
o Escolha de plataformas de desenvolvimento que permitam no futuro
uma contínua actualização do projecto, se desejável e necessário
o Possibilidade de integração com outros serviços, que poderão ser
desenvolvidos noutras plataformas
Segurança e Fiabilidade
o Quando integrado com outras plataformas (ex: MySql), garantir a
segurança das comunicações
o Capacidade de utilização por um elevado número de utilizadores
Depois de identificados os requisitos necessários ao desenvolvimento do trabalho, constatou-se que haveria a necessidade de integração com outras plataformas como o MySql, neste
caso para a criação da tabela que guardaria os resultados de cada utilizador. Para a integração
deste serviço, houve também a necessidade de se recorrer à utilização da linguagem de
programação “PHP”. Criou-se assim uma ligação entre FALSH Æ PHP Æ MySql.
4.4 Requisitos da página “Eurekit”
No caso da página, os requisitos já estavam definidos, pelo que o trabalho residiu na sua
criação e implementação.
Os requisitos consistiam na:
¾ Criação da página com recurso a uma tecnologia à escolha do aluno
¾ Criação dos menus
¾ Colocação das imagens do IPB e do programa Ciência Viva
Os menus seriam compostos por 5 opções:

Eurekit – Página inicial de apresentação do projecto
Requisitar – Menu onde seria possível requisitar a exposição
Historial – Locais por onde a exposição já teria passado
Equipa – Membros que, de alguma forma, contribuíram para a exposição
Links – Hiperligações importantes a serem mencionadas
12
CAPÍTULO 5. ARQUITECTURA
Capítulo 5
Neste capítulo procede-se à apresentação da
arquitectura global dos jogos, das ferramentas utilizadas
na sua criação e na criação da página, e de todos os
passos posteriores, necessários à sua implementação.
5 ARQUITETURA
5.1 Arquitectura da Aplicação
A arquitectura global dos jogos baseia-se na comunicação entre o FLASH, o PHP e o
MySQL, visto que existe a necessidade de armazenamento das pontuações e a opção
escolhida recaiu sobre o MySQL.
Caso a comunicação com a base de dados falhe, isso não implica que não se possa continuar a
jogar. O único problema será que as pontuações não serão armazenadas, nem de seguida
carregadas para serem apresentadas ao utilizador. Um exemplo das comunicações é
apresentado na Figura .5.
Figura .5 - Comunicação Cliente Æ Servidor / Servidor Æ Base de Dados
13
Como é visível na Figura .5, os jogos estarão disponíveis na Internet através de um servidor
que, estando ligado à base de dados, permite a execução deste com acesso a todas as suas
funcionalidades. A manutenção dos jogos será feita pelo administrador do sistema, cujo
trabalho será principalmente manter a base de dados operacional. Os utilizadores acederão aos
jogos através da Internet.
5.2 Ferramentas e Soluções Tecnológicas
Ao nível das ferramentas utilizadas, depois de uma avaliação dos requisitos e dos objectivos a
atingir, a escolha recaiu sobre o Flash. Esta escolha deveu-se a vários factores, mas destacamse os seguintes:
I.
Permite a criação de uma interface gráfica de maneira bastante simples e intuitiva
II.
Dispõe de uma linguagem poderosa, denominada ActionScript, orientada a objectos,
que permite comunicar com outras linguagens e que, dentro do próprio flash, permite
uma interacção com o “palco principal” que nos dá imensa liberdade
III.
Um dos (ou mesmo o) meios de difusão de jogos, entre outras coisas, mais poderoso e
mais utilizado no universo cibernético
IV.
Documentação existente, tanto na biblioteca da escola, como na Internet, com
inúmeros exemplos e até explicações detalhadas, bem como uma enorme comunidade
a desenvolver projectos recorrendo a esta ferramenta, o que permitiu uma
compreensão e aprendizagem deste novo universo de forma bastante simples
V.
Flexibilidade. Permitiu sempre a inclusão de novas ideias, mostrando que as suas
limitações são relativas, mas ainda assim existem.
A maior desvantagem do uso desta ferramenta foi a necessidade de aprender quase por
completo uma nova linguagem, mas acima de tudo aprender a trabalhar com o ambiente
gráfico. É certo que existem semelhanças com alguns programas de edição de imagem, essa
foi a parte fácil, mas existem outras diferenças. Outras desvantagens foram encontradas ao
longo da criação do jogo, tais como no uso do XML, que mais tarde optou-se por não incluir.
A ideia inicial seria carregar imagens que foram usadas no Flash, directamente de uma pasta,
através do XML. Chegou-se à conclusão de que, quando carregadas para o “palco principal”,
as imagens eram reconhecidas e apresentadas de forma correcta. Mas quando era necessário
carregar uma imagem para ser apresentada como uma das peças do jogo, a qual teria
“acções”, as coisas já não corriam como era esperado, muito devido ao facto de estas imagens
não se encontrarem no “palco principal”, mas sim na biblioteca do jogo e porque, depois de
carregadas, deveriam manter o código (“acções”) que teriam que executar, efeito que não se
verificava.
Relativamente à escolha de uma forma de armazenamento das pontuações, a primeira escolha
recaiu sobre um ficheiro de texto. Exemplo que cedo foi abandonado, pois a segurança
apresentada não seria muita. De seguida optou-se pela utilização de uma base de dados
14
mySQL que recorrendo à linguagem PHP tornou possível o armazenamento e a visualização
dos resultados.
A comunicação seria então efectuada entre o Flash e o PHP. No Flash, o utilizador introduzirá
o seu nome no respectivo campo. A pontuação é contabilizada ao longo do jogo e é
apresentada no final, tal como podemos ver no exemplo da Figura .6.
Após inserido o nome, opcional, os dados são enviados para a base de dados, recorrendo à
seguinte função do Flash:
getURL("highscoreadult.php","_self","POST");
Após receber os dados, o ficheiro “highscoreadult.php” envia os dados para a base de dados
usando o comando MySql:
$sql = "INSERT INTO adult (name, score) VALUES ('$name','$score')";
É chamado outro ficheiro que carrega os dados da base de dados e os apresenta ao utilizador
como se demonstra na Figura .7.
No jogo Torre de Hanoi, o princípio para o armazenamento das pontuações é o mesmo.
Fim do Jogo
NOME :
PONTOS :
Enviar
Figura .6 - Fim do Jogo Mahjongg
Figura .7 - Tabela de Pontuações do Mahjongg
15
Para a criação da página “Eurekit” (Figura .8) a tecnologia adoptada foi o Joomla. Perante o
tempo disponível a escolha recaiu nesta opção, pois mostrou ser uma ferramenta eficaz e,
sendo algo com o qual nunca se tinha trabalhado, uma experiência interessante.
Figura .8 - Eurekit
O Joomla é o CMS (Content Management System) mais requisitado e com maior comunidade
e recursos disponíveis. Aquela que é identificada como a sua principal vantagem refere-se à
possibilidade de se adicionar extensões à página original, ou seja, é possível adicionar
diversos componentes desenvolvidos por utilizadores ou pelos criadores do projecto Joomla,
tornando assim a página personalizada. Para além disso, o Joomla é um projecto de código
aberto, assim como a maioria dos seus componentes encontrados na Internet.
Aliado a tudo isto, o Joomla integra diversos serviços, como por exemplo gestão de
publicidade (banners), sumário de conteúdo no formato RSS, Busca optimizada, estatísticas, e
muitos outros, tendo sido desenvolvido com recurso a duas das linguagens de programação,
PHP e MySQL, mais populares da Internet.
16
CAPÍTULO 6. IMPLEMENTAÇÃO
Capítulo 6
Neste capítulo são apresentados todos os passos
relativos à implementação e os vários protótipos
desenvolvidos.
6 IMPLEMENTAÇÃO
6.1 Mahjongg
6.1.1 1º Protótipo
Após o levantamento inicial dos requisitos e das funções com maior prioridade, foi
desenvolvido um 1º Protótipo.
A implementação deste 1º protótipo estava centrada principalmente na distribuição das
imagens no “palco principal”. Este primeiro esboço ajudou a perceber alguns erros e
possibilidades de melhorias.
A distribuição das imagens no jogo Mahjongg começou por ser feita de maneira manual,
passo que se mostrou lento e pouco atractivo (Figura .9). O abandono deste método deveu-se
à vontade de criar um meio de colocação das imagens de forma rápida e automática. Assim,
procedeu-se à criação de código que cumprisse esse objectivo. Um exemplo de parte desse
código é dado de seguida:
for (i=57; i<144; i++) {
placeTile(i, depth);
depth = depth+2;
}
Nesta porção de código é invocada a função placeTile() que, para as peças entre 57 e 144, irá
colocar as imagens respectivas no “palco principal”.
17
Figura .9 - 1º Protótipo Mahjongg
Como já foi referido, não existem soluções óptimas, apenas bons compromissos. Esse
compromisso ainda não havia sido encontrado, pelo que se passou para um 2º Protótipo.
6.1.2 2º Protótipo
Neste 2º protótipo a principal alteração foi precisamente ao nível do código, cujo objectivo
era a sua optimização, de forma a permitir a colocação das imagens de forma aleatória e
automática, tal como foi descrito no ponto anterior. Essa optimização foi conseguida e depois
de vários testes, as peças estavam a ser colocadas como se pretendia (Figura .10).
Figura .10 - Mahjongg com tema de Bragança
18
6.1.3 Versão Final
Após concluído com sucesso um dos passos mais importantes da fase de implementação, que,
neste caso, era a distribuição das peças, partiu-se para a realização das restantes tarefas. Sendo
elas:
Criação de um menu principal que apresentasse as diferentes escolhas disponíveis aos
utilizadores (Figura .11) que, como se pode ver na imagem, permitia escolher entre
três tipos diferentes de peças, escolher o grau de dificuldade (a diferença entre
dificuldades era feita no número de ajudas disponíveis ao utilizador), o menu de ajuda
e se queríamos um jogo para jovens ou para crianças (a diferença residia no número
de peças disponíveis).
Figura .11 - Mahjongg - Menu Principal
Criação dos requisitos identificados anteriormente que permitissem ao utilizador
executar determinadas acções durante o jogo (Figura .12), acções como anular
jogadas, recomeçar o jogo, pedir para ver uma determinada jogada possível ou saber a
pontuação durante o jogo
Figura .12 - Menu presente durante o jogo
Introdução de código que, quando pressionada determinada tecla, reconhecesse esse
comando e o executasse como se fosse seleccionado o botão com o rato. Podemos
identificar na Figura .12, a vermelho, as teclas a utilizar
Menu que permite controlar o volume, parar ou recomeçar a música do jogo (Figura
.13)
Figura .13 - Controlo de Volume
19
Escolha de três tipos diferentes de peças (Figura .10, 14, e 15)
Figura .15 - Mahjongg com tema Matemático
Figura .14 - Mahjongg com tema Tradicional
Disponibilização de um interface para o armazenamento das pontuações (Figura .6) e
de uma tabela que as apresentasse (Figura .7). Método que recorre ao uso do PHP e do
MySql.
6.2 Torre de Hanoi
No caso do jogo “Torre de Hanoi”, o 1º protótipo começou por ser realizado com 5 peças
(Figura .16). Mostrou-se bastante eficaz e, daí, partiu-se directamente para a versão final que
permite ao utilizador escolher o número de peças com as quais pretende jogar, de três a seis
(Figura .17). Para além desta opção, o utilizador tem ainda acesso a um menu de ajuda e, no
final do jogo, tem a oportunidade de guardar o seu resultado.
Figura .16 - 1º Protótipo Torre de Hanoi
Figura .17 - Menu Principal Torre de Hanoi
20
Durante o jogo o utilizador tem ainda disponíveis duas opções, uma para voltar ao menu
principal e outra para pausar o jogo.
6.3 “Eurekit”
No caso da página “Eurekit”, a primeira tentativa passou pela criação de uma página com
recurso ao XHTML e às CSS, método que cedo foi abandonado. Devido, em especial, ao
tempo disponível para a criação desta página, a escolha final recaiu na ferramenta Joomla.
A versão final desta página foi desenvolvida com recurso a esta ferramenta, tendo sido
adicionado um componente, um template, que foi alterado de modo a ser apresentado como
demonstra a Figura .8. As várias opções disponíveis permitem ao utilizador da página, aceder
à página principal, requisitar a exposição, aceder ao historial da exposição, conhecer os
membros que contribuíram para a exposição e as hiperligações de destaque.
6.4 Considerações
Durante a implementação houve a necessidade de exercer especial atenção num ponto em
particular. O tamanho dos jogos. Isto porque, uma vez que os jogos se destinavam a ser
disponibilizados na Internet, e seria a partir daí que se poderia ter acesso a estes, o seu
tamanho não poderia ser exagerado sob pena de os utilizadores perderem a paciência
enquanto esperam que estes carreguem.
Para optimizar então o tempo de carregamento do jogo e minimizar o seu tamanho, foram
tidas em conta algumas considerações:
9 Reutilizar sempre que possível as imagens guardadas na biblioteca do jogo, para que
não houvesse duplicação, evitando assim o uso desnecessário de espaço
9 Especial atenção nos sons utilizados, para que o tamanho destes não implicasse um
aumento exagerado do tamanho do jogo
9 Criação de botões, menus e apresentação gráfica no próprio flash, evitando assim a
importação de novas imagens
21
CAPÍTULO 7. CODIFICAÇÃO
Capítulo 7
Neste capítulo procede-se à discussão dos
algoritmos implementados nos jogos.
7 CODIFICAÇÃO
A implementação dos jogos foi efectuada com recurso ao flash, mais concretamente, com
auxílio à linguagem ActionScript.
7.1 Mahjongg
O código seguinte permite que o utilizador, quando seleccionada uma tecla do teclado,
execute uma acção exactamente do mesmo modo como se seleccionasse o respectivo botão
com o rato. Neste caso, a variável keylistener vai ler onKeyDown a tecla seleccionada. Caso a
tecla seja o ‘a’, iremos avançar para a frame 3. O valor Ascii será armazenado na variável
keys.
keyListener=new Object();
keyListener.onKeyDown=function()
{
keys=Key.getAscii();
//Main Menu - A - 97
if( keys== 97){
cleartiles();
gotoAndStop(3);}
}
Key.addListener(keyListener);
A pontuação inicial será armazenada na variável global _global.pontos = 100; sendo a pontuação
actulizada a partir da variável _global.ptsomar = 4;
A função function cleartiles() permite retirar todas as peças colocadas no palco principal através
de um ciclo for. Este ciclo invoca a função function ClearTile(i, depth) que vai ler as posições das
peças colocadas no início do jogo.
22
for (i=57; i<144; i++) {
ClearTile(i, depth);
depth = depth+2;
}
Ao contrário da função cleartiles(i, depth), a função function newgame() vai colocar as peças no
palco principal, invocando dentro de cada ciclo for a função placeTile(i, depth). Esta última
função vai colocar, depois de calculadas as posições, cada peça no seu devido lugar, bem
como as máscaras.
for (i=57; i<144; i++) {
depth = depth+2;
}
function placeTile(i, depth){
eval("tile"+i)._x = offsetfact[i]*layeroffset+leftoffset+tilefactx[i]*tilewidth;
eval("tile"+i)._y = offsetfact[i]*layeroffset+topoffset+tilefacty[i]*tileheight;
eval("tile"+i).gotoAndStop(tileface[randomnumber[i]]);
eval("tile"+i).value = tilevalue[randomnumber[i]];
attachMovie("mask", "mask"+i, depth+1);
eval("mask"+i)._x = offsetfact[i]*layeroffset+leftoffset+tilefactx[i]*tilewidth;
eval("mask"+i)._y = offsetfact[i]*layeroffset+topoffset+tilefacty[i]*tileheight;
eval("mask"+i)._alpha = 50;
eval("mask"+i)._visible = false;
}
A função apresentada de seguida permite seleccionar as peças, e testar quais as opções a
tomar de seguida. Ao entrar nas funções de teste, caso a peça que seleccionamos seja a
primeira, é invocada a função select1(i,value);, caso estejamos a seleccionar a segunda peça, é
chamada a função select2(i,value).
function select(i, value) {
suggest = 0;
if (test(i)) {
if (move == 1) {
select2(i, value);
} else {
select1(i, value);
}
// end else if
} else {
noselect();
}
// end else if
}
Caso a peça não esteja livre, é invocada a função noselect() que apresentada uma mensagem.
function noselect() {
message = "A peça não está livre!";
wait();
}
A função wait(), é uma função que permite manter uma determinada acção durante um período
de tempo pré-estabelecido.
23
function wait() {
clearInterval(intervalID);
intervalID = setInterval(score, 1000);
}
A pontuação do utilizador é apresentada durante o jogo recorrendo à função function score().
Uma das opções presentes durante o jogo será a de se desfazerem as jogadas. Essa
possibilidade será possível com recurso à função function undo(). Essa função prevê a
possibilidade de não ser possível desfazer o movimento. Caso seja possível, será invocada a
função function restore(), que recolocará as peças retiradas anteriormente, assim como
actualizará a pontuação.
Ao se escolher a opção de recomeçar o jogo, será invocada a função function restart(). Esta
função verificará se é possível recomeçar e, caso fosse possível, recolocará todas as peças
retiradas até esse momento recorrendo também ela à função function restore(), mas com a
diferença de que na opção anterior, seria o utilizador, ao seleccionar o botão, a escolher o
número de peças a recolocar. Neste caso, as peças retiradas serão todas recolocadas
automaticamente.
Com a função function moves(), será possível saber o número de movimentos disponíveis.
Para a opção de dicas a função invocada será a function hint(), que mostrará ao utilizador uma
jogada possível.
7.2 Torre de Hanoi
No caso da torre de hanoi, a função apresentada irá verificar se as peças se encontram livres,
isto é, se será possível mover uma determinada peça de um local para outro. Isso é possível ao
ser invocada a função function free().
O código apresentado de seguida diz respeito às peças do jogo:
on (press) {
history_x = this._x;
history_y = this._y;
_root.message = "Liberta a peça num dos postes";
_root.free();
if (_root.cont3 == 1) {
startDrag(this, true);
}
}
Quando seleccionada qualquer peça, as primeiras acções serão invocadas recorrendo ao
comando on(press), que permite executar acções no momento em que a peça é seleccionada. Ao
serem seleccionadas as peças, será guardada a sua posição e será mostrada uma mensagem
aos utilizadores. Ao mesmo tempo irá ser verificado se a peça se encontra livre recorrendo
para isso à função free();. Caso a peça se encontre livre, será possível move-la utilizando a
função do Flash startDrag();
24
Ao ser libertada a peça, on (release), serão testadas várias hipóteses:
¾ Se a peça é libertada no poste 1 - eval(_root.tile3._droptarget) == _root.pole1
o Se não existe nenhuma peça maior no poste 1
(_root.pole2tile4size == 1) || (_root.pole2tile5size == 1)

¾ Se a peça não é libertada em nenhum poste
Entre outras coisas, destaque para a fórmula de cálculo das pontuações,
pontos=(1 / _global.clickcounter)*1000;
onde a variável global clickcounter armazena o número de “clicks” dados pelos utilizadores.
A função getURL(); que permite o armazenamento das pontuações ao invocar, neste caso, a
página highscore3pcs.php
getURL("hanois3pcs/highscore3pcs.php","_self","POST");
Todo o código, de ambos os jogos, encontra-se disponível no Apêndice B.
25
CAPÍTULO 8. TESTES / RESULTADOS
Capítulo 8
Neste capítulo serão apresentados os testes
realizados e os resultados obtidos.
8 TESTES / RESULTADOS
Para se chegar aos resultados apresentados procedeu-se à realização de testes recorrendo a
utilizadores de várias idades. Os testes consistiram na receptividade dos utilizadores
relativamente a vários aspectos, destacando-se:
¾
¾
¾
¾
As cores apresentadas e as imagens escolhidas
A interactividade dos menus e a facilidade de utilização
Os sons utilizados
A jogabilidade e o gosto pelos temas abordados
Foram ainda efectuados testes ao nível da inserção de novos conteúdos, isto é, com que
facilidade se poderia alterar as imagens de apresentação, alterar os sons, entre outras
alterações.
Com este conjunto de testes pretendeu-se garantir a aceitação do jogo por parte dos
utilizadores, melhorar alguns aspectos que poderiam não estar de acordo com as definições
iniciais e tentar assegurar que, caso fosse desejável e necessário, possíveis alterações
poderiam ser efectuadas sem perder o valor inicial do projecto.
Alguns testes foram separados em faixas etárias, visto que se pretende que o jogo seja
abrangente entre os possíveis utilizadores.
Tabela .1 – Aceitação dos utilizadores
Tipo de
Utilizadores
[Faixa Etária]
Crianças
[9-14]
Jovens
[15-20]
Número de
Utilizadores
7
10
Aceitação
Tema de Bragança
Tema Tradicional
Tema da Matemática
Boa Razoável Má Boa Razoável Má Boa Razoável Má
5
2
0
2
4
1
0
1
6
8
2
0
26
7
3
0
0
5
5
8.1 Crianças
8.1.1 Mahjongg
Inicialmente foi feita uma apresentação do jogo Mahjongg aos utilizadores mais jovens, que
obteve algum desinteresse e desconfiança por parte destes. A razão por detrás desta reacção
esteve, constatou-se mais tarde, no facto dos jovens terem irmãos e este tipo de jogo não fazer
parte da gama que normalmente usufruem.
Ultrapassada a reacção inicial, e com a ajuda de alguns utilizadores mais aventureiros,
procederam-se aos testes.
Ao nível das cores a aceitação foi positiva. No que diz respeito às imagens (Temas)
escolhidas, a aceitação mais positiva foi constatada no uso do tema de Bragança (Tabela .1,
Figura .10), onde cinco dos sete utilizadores inquiridos escolheram este tema como o mais
atractivo. Em relação ao tema mais tradicional (Figura .14), este posicionou-se na segunda
posição da tabela de aceitação, com duas opiniões boas e quatro razoáveis(Tabela .1), sendo a
sua receptividade mesmo assim positiva. Por último, o tema com expressões matemáticas
(Figura .15), que dos três apresentados foi o que obteve a pior aceitação. Como é possível
constatar na Tabela .1, os utilizadores pertencentes a esta faixa etária demonstraram o seu
descontentamento ao atribuírem 6 votos negativos e um razoável a este tema.
A interactividade dos menus não foi muito explorada, tendo sido a tecla D, que corresponde
ao botão ‘Dicas’ (Figura .12) apresentado durante o jogo, o atalho mais utilizado.
A avaliação dos sons pautou-se pela falta de opiniões, tornando esta tarefa inconclusiva.
Como conclusão dos testes efectuados com este grupo, foi notada uma boa aceitação por parte
dos utilizadores, tendo sido possível mudar opiniões.
8.1.2 Torre de Hanoi
No caso da Torre de Hanoi, a aceitação foi também ela positiva, sendo de destacar o pouco
recurso aos níveis com mais peças disponíveis. Foi igualmente feita avaliação aos sons e às
imagens apresentadas. Mais uma vez, a avaliação dos sons pautou-se pela falta de
comentários. No caso das cores utilizadas, foi feito um levantamento das opiniões que
mostraram pouca aceitação das apresentadas nas peças e nos menus, excepção feita no caso
do menu de ajuda. crianças.
27
8.2 Jovens
8.2.1 Mahjongg
Ultrapassada a primeira fase de testes, procedeu-se à avaliação dos jogos com utilizadores de
uma faixa etária superior. Neste caso, utilizadores com idades compreendidas entre os quinze
e os vinte anos de idade.
Ao se proceder à apresentação do jogo Mahjongg, a reacção inicial mostrou-se pouco
positiva.
A avaliação foi feita em várias etapas, pondo à prova, na primeira etapa, as cores utilizadas.
As opiniões foram várias, das quais se destacam: “cores muito bonitas”; cores “para
crianças”.
Na segunda etapa procedeu-se à avaliação das imagens utilizadas nos temas. Dos três temas a
avaliar, o que obteve os melhores resultados foi o tema de Bragança (Figura .10), obtendo
todas as pontuações positivas. Na segunda posição encontra-se o tema tradicional (Figura
.14), com uma pontuação não muito diferente da obtida pelo tema analisado anteriormente
(Tabela .1). O último tema analisado, o matemático (Figura .15), foi, a par com o tema de
Bragança, um dos que despertou mais interesse. Apesar da pontuação ser a pior, dos três, foi
possível constatar o interesse dos utilizadores.
Na análise à interactividade dos menus destacou-se o uso da tecla ‘D’. Assim como no caso
dos utilizadores mais jovens, neste caso também foi esta opção a obter o maior destaque.
Na etapa relativa à avaliação dos sons utilizados, os resultados foram satisfatórios, com
opiniões positivas.
Para os testes efectuados com estes utilizadores, conclui-se que houve aceitação do jogo por
parte destes, destacando-se os temas de Bragança como o mais apreciado e o da matemática
como o de maior grau de exigência.
8.2.2 Torre de Hanoi
Em relação ao jogo Torre de Hanoi foram igualmente efectuados testes, durante os quais se
constatou o grau de exigência requerido para resolver os problemas. Presenciou-se um
aumento do grau de dificuldade proporcional ao aumento do número de peças do jogo.
28
8.3 Alterações aos Jogos
Quando analisados os jogos e a possibilidade de alterações aos mesmos, chegou-se à
conclusão de que essa opção estaria disponível em qualquer altura. Muito do trabalho já
estava garantido por parte do Flash, que permite adicionar a cada uma das bibliotecas dos
jogos (praticamente) qualquer conteúdo desejado. Assim sendo, bastaria apenas ao
administrador criar as peças dos jogos a adicionar e colocá-las na biblioteca. Concluído o
processo de criação e adição, restaria vincular as peças para que estas sejam distribuídas
automática e aleatoriamente.
Ao nível dos sons, o conceito é muito semelhante. Basta adicionar o som à biblioteca,
referenciar o som com um nome inequívoco e invocar esse som através do código.
Qualquer outra alteração, quer ao nível dos menus, das imagens ou da base de dados, não
implicam, depois de compreendido o conceito, muito trabalho para além do inicial. Isto
porque, o Flash é bastante intuitivo e bastante semelhante, em certos aspectos, a alguns
programas de edição de imagem, o que permite uma compreensão mais rápida de algumas das
suas potencialidades.
29
CAPÍTULO 9. CONCLUSÃO
Capítulo 9
Terminada a fase de testes e, eventualmente, o
projecto, chega a altura de tirar conclusões sobre o
trabalho desenvolvido. Serão também apresentadas
possíveis alterações ao projecto efectuado e uma secção
de trabalho futuro.
9 CONCLUSÃO
Como foi descrito na introdução, este projecto tinha como objectivo o desenvolvimento de
jogos educativos, com recurso à tecnologia Flash, que suscitassem o gosto pela matemática.
O principal problema passava pelo aumento do gosto pela matemática nos mais jovens. Uma
solução encontrada foi a criação de jogos, nomeadamente, o Mahjongg e a Torre de Hanoi.
Para a concretização destes, recorreu-se, sobretudo, às tecnologias GIMP e Adobe Flash.
Além destas, houve necessidade de utilização do PHP e do MySql, e também de outros
programas de edição de imagem como o MsPaint ou o Photoshop.
No caso da página “Eurekit”, a tecnologia adoptada foi o Joomla, tendo-se recorrido, sempre
que necessário, e possível, ao Javascript, HMTL e PHP.
Como confirmação dos resultados obtidos face aos objectivos que se almejavam alcançar,
testou-se, junto daqueles que se pretende que sejam os utilizadores finais, os jogos e vários
aspectos que os integram. A razão pela qual se optou por este tipo de testes (interacção
directa) teve a ver com ao facto de a reacção ser mais genuína ao ser captada no momento.
Relativamente à interface Web onde se encontram disponíveis os jogos, esta parte do projecto
foi acrescentada no final, que se pretendeu ser uma mais-valia e que tinha como objectivo
permitir uma divulgação de todos os trabalhos relacionados com os projectos propostos no
âmbito da iniciativa Ciência Viva, mais especificamente, o projecto Eureka, proposto pela
ESTiG.
Assim conseguiu-se garantir que todos os objectivos propostos inicialmente foram atingidos,
tendo-se verificado que além dos objectivos definidos como fulcrais, outros foram sendo
adicionados ao longo do tempo, que foram também solucionados com sucesso. Os objectivos
30
CAPÍTULO 9. CONCLUSÃO
adicionados posteriormente foram a tabela de pontuações, a Torre de Hanoi e a página Web
“Eurekit”.
Conta-se ainda, como resposta aos desafios propostos inicialmente, com um conjunto de
testes satisfatórios para confirmação dos objectivos.
9.1 Trabalho Futuro
Apesar de terem sido atingidos os objectivos propostos, existem ainda alguns requisitos que
poderiam ser melhorados, pelo que se apresentam como trabalho a desenvolver no futuro.
O primeiro destes objectivos passa pela introdução de mais algoritmos no Mahjongg que
permitam a distribuição das peças de outras maneiras diferentes. Outro ponto que foi
reparado, mas que poderá ainda sofrer alterações, é as imagens apresentadas no tema da
matemática. Apesar de o esboço inicial das peças a apresentar neste tema ter sido descartado,
notou-se que a escolha final não recebeu 100% de aceitação por parte dos utilizadores, tendo
mesmo recebido reprovação por parte de alguns utilizadores.
Outras funcionalidades interessantes a desenvolver, seriam a utilização do jogo Mahjongg
virado para outras áreas como as ciências ou as línguas, entre outras.
Outro ponto que foi abordado ao longo do projecto, mas que, infelizmente, foi abandonado,
passaria pela integração destes jogos com o XML. Neste caso, para as imagens que se
queriam usar, a escolha acabou por não ser a mais acertada, mas o recurso a esta integração
entre Flash e XML, mostrou ser uma poderosa ferramenta conjunta para situações
semelhantes e para outras tarefas.
No caso da Torre de Hanoi, poder-se-á aumentar o número de peças com as quais é possível
jogar, de forma a aumentar ainda mais o grau de dificuldade. Além desta alteração, ficaria
interessante o uso de um cronómetro, visível ao utilizador, para contabilizar o tempo de jogo.
31
BIBLIOGRAFIA
Bibliografia
[FA 01]
Ferreira, P. Azevedo, E. Flash 5 Conceitos e Prática, 2ª Edição. FCA – Editora de Informática,
LDA – Fevereiro de 2001
[M 05]
Manzi, F. Flash 8 Professional Criando Além da Animação, 1ª Edição. Editora ÉricaLDA –
2005
[Wikipedia 08]
Portal com informação sobre o jogo Mahjongg - http://pt.wikipedia.org/wiki/Mahjong
[SPIL GAMES B.V. 08] Portal de jogos - http://www.ojogos.com.br/
[iMasters FFPA Informática Ltda 01]
Portal virtual com informação e exemplos de programação http://imasters.uol.com.br/canal/programacao
[InforMark]
Portal da internet com vários jogos de entretenimento – Caso particular, Mahjongg –
http://www.alemdeeducar.com.br/jogos/flash/mahjongg/mahjongg.shtml
[Games ON 07]
Página da internet com diversos jogos – Caso Particular – Torre de Hanoi –
http://www.gameson.com.br/Jogos-Online/ClassicoPuzzle/Torre-de-Hanoi.html
[Wikipedia 08]
Portal com informação sobre o jogo Torre de Hanoi http://pt.wikipedia.org/wiki/Torre_de_Hanoi
[Refsnes Data 99]
Página com diversa informação e exemplos sobre linguagens de programação http://www.w3schools.com/
[The PHP Group 01]
Portal com informação sobre a linguagem php - http://www.php.net
[Jupitermedia Corporation 08]
- http://www.flashkit.com/
Portal da internet destinado aos utilizadores do Flash, com exemplos e ajudas
[VISUALWORK 02]
Página com diversos tipos de exemplos e tutoriais para programação e
desenvolvimento na plataforma Flash - http://www.flashwebtraining.com/
[MXStudio 03]
Portal com vários exemplos, tutoriais e ajudas para programação e desenvolvimento
na plataforma Flash - http://www.mxstudio.com.br/
[Kirupa 99]
Portal destinado aos criadores em ambiente flash - http://www.kirupa.com/
[Open Source Matters, Inc 05]
joomla - http://www.joomla.org/
Página sobre a criação de portais para a internet com base na tecnologia
[STD Group Inc 08]
Portal com templates para aplicação em páginas criadas com recurso à tecnologia
joomla - http://www.siteground.com/
32
APÊNDICES
33
Apêndice A
A
Interface e Funcionalidades dos Jogos
A.1 Mahjongg
34
Tabela de pontuações do Mahjongg – Posições ordenadas de forma descendente
35
A.2 Torre de Hanoi
36
37
A.3 Eurekit
A página apresentada destina-se à divulgação dos trabalhos realizados no âmbito do projecto Eureka – Ciência
Viva, proposto pela ESTiG.
Estão disponíveis os menus:
• Eurekit, que apresenta a página principal;
• Requisitar, que permite a qualquer professor requisitar a exposição para a sua escola;
• Historial, que mostra os locais por onde a exposição já passou;
• Equipa, que apresenta os elementos envolvidos no projecto;
• Links, onde se encontram outras páginas de interesse;
38
Apêndice B
B
Código dos Jogos
B.1 Código do Mahjongg
De seguida, apresenta-se algum do código mais importante no desenvolvimento do jogo Mahjongg.
B.1.1 Palco Principal – Durante o jogo
Key.removeListener(keyList);
//Função que permite usar as teclas para as mesmas funções dos botões
//Function that uses the keys with the same functions of the buttons
keyListener=new Object();
keyListener.onKeyDown=function()
{
trace(keys);
//Main Menu - A - 97
if( keys== 97){
cleartiles();
gotoAndStop(3);}
//Novo Jogo
//New Game - N - 110
if( keys== 110){
newgame();}
//Recomeçar - R - 114
//Restart
if( keys== 114){
restart();}
//Voltar Atrás - V - 118
//GoBack
39
if( keys== 118){
undo();}
//Movimentos - M - 109
//Moves
if( keys== 109){
moves();}
//Dica - D - 100
//Hint
if( keys== 100){
hint();}
}
Key.addListener(keyListener);
//variável global com a pontuação do jogador e outra para somar os pontos ou subtrair
//global int with the start score of the player and another int to add or subtract to the global score
_global.pontos = 100;
_global.ptsomar = 4;
//função para retirar as tiles que foram colocadas
//function used to clear the tiles assembled with function newgame
function cleartiles() {
counter = totaltiles;
for (i=0; i<totaltiles; i++) {
random = Math.floor(Math.random()*(i+1));
randomnumber[i] = randomnumber[random];
randomnumber[random] = i;
}
// end of for
var depth = 100;
for (i=57; i<144; i++) {
depth = depth+2;
}
// end of for
for (i=21; i<57; i++) {
depth = depth+2;
}
// end of for
for (i=5; i<21; i++) {
40
depth = depth+2;
}
// end of for
for (i=1; i<5; i++) {
depth = depth+2;
}
// end of for
for (i=0; i<1; i++) {
depth = depth+2;
}
// end of for
wait();
}
//end of function
//Function used by the function above
//Função usada pela função anterior
function ClearTile(i, depth) {
if (_global.oplayout == 1) {
attachMovie("tiles", "tile"+i, depth);
} else if (_global.oplayout == 2) {
attachMovie("traditionaltiles", "tile"+i, depth);
attachMovie("mathtiles", "tile"+i, depth);
}
eval("tile"+i)._visible = false;
}
//end of function
//Function to create a new game
//função para criar um novo jogo
function newgame() {
message = "Jogo Pronto: "+totaltiles+" peças foram posicionadas.";
move = 0;
sel = 0;
41
suggest = 0;
back = 0;
random = Math.floor(Math.random()*(i+1));
randomnumber[i] = randomnumber[random];
randomnumber[random] = i;
}
// end of for
var depth = 100;
if(_global.adult==true)
{
for (i=57; i<144; i++) {
depth = depth+2;
}
// end of for
for (i=21; i<57; i++) {
depth = depth+2;
}
// end of for
for (i=5; i<21; i++) {
depth = depth+2;
}
// end of for
for (i=1; i<5; i++) {
depth = depth+2;
}
// end of for
for (i=0; i<1; i++) {
depth = depth+2;
}
// end of for
}
else if(_global.kids==true)
{
for (i=21; i<56; i++) {
42
depth = depth+2;
}
// end of for
for (i=5; i<21; i++) {
depth = depth+2;
}
// end of for
for (i=1; i<5; i++) {
depth = depth+2;
}
// end of for
for (i=0; i<1; i++) {
depth = depth+2;
}
// end of for
}
wait();
}
// End of the function
//Function the places the tiles
//Função para colocar as peças
function placeTile(i, depth) {
attachMovie("tiles", "tile"+i, depth);
attachMovie("traditionaltiles", "tile"+i, depth);
attachMovie("mathtiles", "tile"+i, depth);
}
attachMovie("mask", "mask"+i, depth+1);
eval("mask"+i)._x = offsetfact[i]*layeroffset+leftoffset+tilefactx[i]*tilewidth;
eval("mask"+i)._y = offsetfact[i]*layeroffset+topoffset+tilefacty[i]*tileheight;
43
eval("mask"+i)._alpha = 50;
}
//function to select the tile
//função para seleccionar a peça
function select(i, value) {
suggest = 0;
if (test(i)) {
if (move == 1) {
select2(i, value);
} else {
select1(i, value);
}
// end else if
} else {
noselect();
}
// end else if
}
//Function that runs to tell that the tile is not free
//Função que avisa quando selecionamos uma peça que não está livre
function noselect() {
message = "A peça não está livre!";
wait();
}
//Function used to warn that the tiles are different
//Função que avisa quando seleccionamos peças diferentes
function nomatch() {
message = "As peças são diferentes!";
_global.pontos = _global.pontos-ptsomar;
trace(_global.pontos);
wait();
}
//Function that warns while no tile is selected
//Função que corre enquanto nenhuma peça é seleccionada
function equal() {
44
message = "Nenhuma peça selecionada.";
eval("mask"+sel)._visible = false;
move = 0;
wait();
}
//Function will run when we select the first tile
//Função que corre depois de selecionada a primeira peça
function select1(i, value) {
store[0] = i;
store[1] = value;
message = "Peça selecionada...";
sel = i;
eval("mask"+sel)._visible = true;
move = 1;
wait();
}
//Function that runs when we select the second tile. This function will compare and remove if true both tiles
//Função que correrá depois de selecionada a segunda peça. Será feita e comparação e respectiva remoção das
peças
function select2(i, value) {
if (store[1] != value) {
nomatch();
} else {
//if(tileface[1]==(tileface[34]||tileface[35])||tileface[36]) ||
tileface[2]==(tileface[33]||tileface[35])||tileface[36]) ||tileface[3]==(tileface[33]||tileface[34])||tileface[36]) ||
tileface[4]==(tileface[33]||tileface[34])||tileface[35]))
//{
history[history.length] = store[0];
history[history.length] = i;
eval("tile"+store[0])._visible = false;
eval("mask"+store[0])._visible = false;
eval("tile"+i)._visible = false;
message = "As peças selecionadas são iguais!";
_global.pontos = _global.pontos+ptsomar+ptsomar;
move = 0;
++back;
counter = counter-2;
45
wait();
}
//}
// end else if
}
//Function will wait during an interval of time
//Função espera(). Usa um intervalo de tempo para fazer esperar
function wait() {
}
//Function that shows the score and if the game is over, will call a file to save the score
//Função que mostra os pontos durante o jogo e que chamará um ficheiro externo
//para guardar os pontos na base de dados quando o jogo terminar
function score() {
if (suggest == 1) {
eval("mask"+hints[0])._visible = false;
eval("mask"+hints[1])._visible = false;
hints[hints.length] = hints[0];
hints[hints.length] = hints[1];
for (i=0; i<hints.length-2; i++) {
hints[i] = hints[i+2];
}
// end of for
hints.length = hints.length-2;
}
// end if
if (counter != 0) {
message = "Resultado: "+(totaltiles-counter+_global.pontos);
} else {
message = "Resultado: "+(totaltiles-counter+_global.pontos)+" Parabéns!";
Key.removeListener (keyListener);
_root.cleartiles();
gotoAndStop(5);
//loadMovieNum("score.swf", 10);
}
// end else if
46
}
//Function used to undo the last move
//Função usada para desfazer o último movimento
function undo() {
if (history.length == 0) {
message = "É impossível voltar atrás!";
suggest = 0;
move = 0;
wait();
} else {
restore();
message = "Movimento desfeito.";
_global.pontos = _global.pontos-ptsomar-ptsomar;
suggest = 0;
move = 0;
--back;
counter = counter+2;
wait();
}
// end else if
}
//Function that will restore all the tiles removed
//Função que irá repor todas as peças retiradas
function restore() {
eval("tile"+history[history.length-1])._visible = true;
eval("tile"+history[history.length-2])._visible = true;
history.length = history.length-2;
}
//Function will use function restore() to place the removed tiles
//Função que irá colocar as peças retiradas usando a função restore()
function restart() {
if (_global.opplay == 1) {
_global.remainhint = 30;
47
} else if (_global.opplay == 2) {
} else if (_global.opplay == 3) {
}
if (ihistory.length == 0) {
message = "É impossível recomeçar!";
suggest = 0;
move = 0;
wait();
} else {
for (i=0; i<back; i++) {
restore();
}
// end of for
message = "Jogo Recomeçado.";
suggest = 0;
move = 0;
back = 0;
wait();
}
// end else if
}
//Function that will show the number of moves that we have left
//Função que mostra o número de movimentos possíveis disponíveis
function moves() {
suggest = 0;
remain = 0;
free = new Array();
if (test(i)) {
free[free.length] = eval("tile"+i).value;
}
// end if
}
// end of for
48
free.sort();
for (i=0; i<free.length-1; i++) {
if (free[i] == free[i+1] && free[i] == free[i+2] && free[i] == free[i+3]) {
remain = remain+2;
i = i+3;
}
// end if
if (free[i] == free[i+1] && free[i] == free[i+2]) {
++remain;
i = i+2;
}
// end if
if (free[i] == free[i+1]) {
++remain;
++i;
}
// end if
}
// end of for
if (remain == 0) {
message = "Game over: Não há mais movimentos possíveis!";
_root.cleartiles();
gotoAndStop(5);
} else {
message = "Movimentos possíveis: "+remain;
}
// end else if
move = 0;
wait();
}
//Function that shows a pair of free tiles
//Função que mostra um par de peças livres
function hint() {
if (remainhint>0) {
if (suggest == 0) {
free = new Array();
49
hints = new Array();
if (test(i)) {
free[free.length] = new Array(eval("tile"+i).value, i);
}
// end if
}
// end of for
free.sort();
for (i=0; i<free.length-1; i++) {
if (free[i][0] == free[i+1][0]) {
hints[hints.length] = free[i][1];
hints[hints.length] = free[i+1][1];
}
// end if
}
// end of for
if (hints.length == 0) {
message = "Game over: Não há mais movimentos possíveis!";
suggest = 0;
_root.cleartiles();
gotoAndStop(5);
} else {
remainmsg();
suggest = 1;
}
// end else if
} else if (suggest == 1) {
remainmsg();
}
// end else if
} else {
message = "Já não tens mais ajudas disponíveis";
}
move = 0;
wait();
}
50
//Function tha shows how many helps you still have
//Função Que mostra quantas ajudas ainda temos
function remainmsg() {
message = "Movimento Possível";
wait();
eval("mask"+hints[0])._visible = true;
eval("mask"+hints[1])._visible = true;
//hints that we still can use
_global.remainhint = _global.remainhint-1;
message = "Ajudas restantes: "+_global.remainhint;
}
//Function that test the moves available
//Função que testa os movimentos possiveis
function test(i) {
lr = !(eval("tile"+(i-1))._visible) || !(eval("tile"+(i+1))._visible);
loop = new Array();
vari = new Array(10, 11, 14, 15, 28, 29, 30, 31, 34, 35, 36, 37, 40, 41, 42, 43, 46, 47, 48, 49, 70, 71, 72,
73, 74, 75, 79, 80, 81, 82, 83, 84, 91, 92, 93, 94, 95, 96, 103, 104, 105, 106, 107, 108, 116, 117, 118, 119, 120,
121, 125, 126, 127, 128, 129, 130);
for (j=1; j<57; j++) {
loop[j] = i == vari[j-1] && (lr && !(eval("tile"+j)._visible));
}
// end of for
cond = (i == 0 || i == 5 || i == 8 || i == 9 || i == 12 || i == 13 || i == 16 || i == 17 || i == 20 || i == 21 || i ==
26 || i == 27 || i == 32 || i == 33 || i == 38 || i == 39 || i == 44 || i == 45 || i == 50 || i == 51 || i == 56 || i == 57 || i
== 68 || i == 69 || i == 76 || i == 77 || i == 86 || i == 87 || i == 113 || i == 114 || i == 123 || i == 124 || i == 131 || i
== 132 || i == 143 || i>=1 && i<=4 && !tile0._visible || (i == 6 || i == 7 || i == 18 || i == 19 || i>=22 && i<=25 ||
i>=52 && i<=55 || i>=58 && i<=67 || i == 78 || i == 85 || i>=88 && i<=90 || i == 97 || i == 98 || i == 101 || i ==
102 || i>=109 && i<=111 || i == 115 || i == 122 || i == 133 || i>=134 && i<=142) && lr || loop[1] || loop[2] ||
loop[3] || loop[4] || loop[5] || loop[6] || loop[7] || loop[8] || loop[9] || loop[10] || loop[11] || loop[12] || loop[13] ||
loop[14] || loop[15] || loop[16] || loop[17] || loop[18] || loop[19] || loop[20] || loop[21] || loop[22] || loop[23] ||
loop[54] || loop[55] || loop[56] || i == 99 && (!tile98._visible || !tile112._visible) || i == 100 && (!tile87._visible
|| !tile101._visible) || i == 112 && (!tile99._visible && !tile111._visible || !tile113._visible)) &&
eval("tile"+i)._visible;
return (cond);
}
stop();
var topoffset = 20;
var leftoffset = 20;
var tileheight = 64;
51
var tilewidth = 65;
var layeroffset = -4;
var tilevalue = new Array(10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15,
15, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23,
23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30,
30, 31, 31, 31, 31, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 38,
38, 38, 38, 39, 39, 39, 39, 40, 40, 40, 40, 41, 41, 41, 41, 42, 42, 42, 42, 43, 43, 43, 43, 44, 44, 44, 44, 45, 45, 45,
45);
var tileface = new Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
133, 134, 135, 136, 137, 138, 139, 140,141, 142, 143, 144);
} else {
var tileface = new Array(1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8,
8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16,
16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24,
24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, 30, 31, 31, 31,
31, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 36, 37, 38, 39, 40, 41, 42);
}
var offsetfact = new Array(4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
var tilefacty = new Array(3.500000E+000, 3, 3, 4, 4, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 1, 1, 1, 1, 1, 1, 2, 2,
2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3.500000E+000, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3.500000E+000, 3.500000E+000, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7);
var tilefactx = new Array(6.500000E+000, 6, 7, 6, 7, 5, 6, 7, 8, 5, 6, 7, 8, 5, 6, 7, 8, 5, 6, 7, 8, 4, 5, 6, 7, 8, 9, 4, 5,
6, 7, 8, 9, 4, 5, 6, 7, 8, 9, 4, 5, 6, 7, 8, 9, 4, 5, 6, 7, 8, 9, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 3, 4, 5, 6,
7, 8, 9, 10, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
var move = 0;
if(_global.kids==true)
{
var totaltiles = 56;
}
else if(_global.adult==true)
{
var totaltiles = 144;
}
var counter;
var randomnumber = new Array(n);
var sel = 0;
var suggest = 0;
var back = 0;
52
var history = new Array();
var free = new Array();
var hints = new Array();
var store = new Array(2);
this.onLoad = newgame();
B.1.2 Palco Principal – Antes de se iniciar o jogo
Durante o carregamento do jogo:
bytes_loaded = Math.round(this.getBytesLoaded());
bytes_total = Math.round(this.getBytesTotal());
getPercent = bytes_loaded/bytes_total;
this.loadBar._width = getPercent*100;
this.loadText = Math.round(getPercent*100)+"%";
if (bytes_loaded == bytes_total)
{
this.gotoAndPlay(3);
}
Na segunda frame durante o carregamento:
this.gotoAndStop(1);
No Menu Principal:
btnplay._visible=false;
//Função que permite usar as teclas para as mesmas funções dos botões
//Function that uses the keys with the same functions of the buttons
keyList=new Object();
keyList.onKeyDown=function()
{
trace(keys);
//Jovens - O - 111
if( keys== 111){
_global.adult=true;
_global.kids=false;
txtka.text="Escolheste a opção: 'Jovens'";
if((_global.opplay==1 || _global.opplay==2 ||_global.opplay==3) && (_global.oplayout == 1 ||
_global.oplayout == 2 || _global.oplayout == 3))
{
_root.btnplay._visible=true;
}
}
//crianças - C - 99
53
if( keys== 99){
_global.kids=true;
_global.adult=false;
txtka.text="Escolheste a opção: 'Crianças'";
if((_global.opplay==1 || _global.opplay==2 ||_global.opplay==3) && (_global.oplayout == 1 ||
_global.oplayout == 2 || _global.oplayout == 3))
{
}
}
//Fácil - F - 102
//easy
if( keys== 102){
_global.opplay = 1;
_root.easy1.gotoAndStop(2);
_root.medium1.gotoAndStop(1);
_root.hard1.gotoAndStop(1);
if ((_global.oplayout == 1 || _global.oplayout == 2 || _global.oplayout == 3)
&&(_global.kids==true || _global.adult==true)) {
btnplay._visible = true;
}
txthelp.text = "No nível Fácil tens 30 ajudas";}
//Médio
//Medium - M - 109
if( keys== 109){
_global.opplay=2;
}
_global.remainhint=15;
txthelp.text="No nível Médio tens 15 ajudas";}
//Difícil - D - 100
//Hard
if( keys== 100){
_global.opplay=3;
}
_global.remainhint=5;
txthelp.text="No nível Difícil tens 5 ajudas";}
//Jogar - J - 106
//Play
if( keys== 106){
if((_global.kids==true || _global.adult==true) && (_global.opplay==1 ||
_global.opplay==2 ||_global.opplay==3) && (_global.oplayout == 1 || _global.oplayout == 2 || _global.oplayout
== 3))
{
gotoAndStop(4);
}
}
54
//Tema de Bragança - 1 - 49
//Tiles with Bragança layer
if( keys== 49){
mcbragtiles.gotoAndStop(3);
bragtest = 1;
_root.mctradtiles.gotoAndStop(1);
_root.mcmathtiles.gotoAndStop(1);
_global.oplayout=1;
_root.txtlayout.text="Escolheste: Tema de Bragança";
if((_global.opplay==1 || _global.opplay==2 ||_global.opplay==3) && (_global.kids==true ||
_global.adult==true))
{
}}
//Tema Tradicional - 2 - 50
//Tiles with traditional layer
if( keys== 50){
mctradtiles.gotoAndStop(3);
bragtest = 1;
_root.mcbragtiles.gotoAndStop(1);
_root.mcmathtiles.gotoAndStop(1);
_global.oplayout=2;
_root.txtlayout.text="Escolheste: Tema Tradicional";
{
}}
//Tema de Matemática - 3 - 51
//Tiles with Math layer
if( keys== 51){
mcmathtiles.gotoAndStop(3);
bragtest = 1;
_root.mctradtiles.gotoAndStop(1);
_root.mcbragtiles.gotoAndStop(1);
_global.oplayout=3;
_root.txtlayout.text="Escolheste: Tema da Matemática";
{
}}
//Ajuda - H - 104
if(keys==104)
{
attachMovie("mchelp","mchelp1",100);
mchelp1._x=500;
mchelp1._y=300;
mcbragtiles._visible=false;
mctradtiles._visible=false;
mcmathtiles._visible=false;
txtchoose._visible=false;
easy1._visible=false;
easy2._visible=false;
medium1._visible=false;
medium2._visible=false;
hard1._visible=false;
hard2._visible=false;
txthelp._visible=false;
txtlayout._visible=false;
55
kids._visible=false;
adult._visible=false;
}
}
Key.addListener(keyList);
stop();
No fim do jogo:
Key.removeListener(keyList);
if(_global.pontos + totaltiles - counter < 100)
{
pontostxt="100";
}
else
{
pontostxt=_global.pontos + totaltiles - counter;
}
function waitscore() {
}
stop();
Ao pressionar o botão “enviar”:
on(release)
{
_root.wait();
if(_global.adult==true)
{
getURL("highscoreadult.php","_self","POST");
}
if(_global.kids==true)
{
getURL("highscorekids.php","_self","POST");
}
//gotoAndStop(6);
}
Código de cada uma das peças:
on (press)
{
var nr = int(_name.substr(4));
_root.select(nr, value);
56
tilesound.start(0,1);
}
B.2 Código da Torre de Hanoi
B.2.1 Palco Principal – Antes do início do jogo
bytes_loaded = Math.round(this.getBytesLoaded());
bytes_total = Math.round(this.getBytesTotal());
getPercent = bytes_loaded/bytes_total;
this.loadBar._width = getPercent*100;
this.loadText = Math.round(getPercent*100)+"%";
if (bytes_loaded == bytes_total)
{
this.gotoAndStop(3);
}
Na frame 2:
this.gotoAndPlay(1);
B.2.2 Palco Principal – Menu Principal
op1=0;
op2=0;
op3=0;
op4=0;
my_sound = new Sound();
my_sound.attachSound("som");
stop();
Ao seleccionar a opção “Jogar”:
on (release) {
my_sound.start();
57
if (txtop.text == 3) {
op1 = 1;
gotoAndStop(4);
} else if (txtop.text == 4) {
op2 = 1;
gotoAndStop(5);
op3 = 1;
gotoAndStop(6);
op4 = 1;
gotoAndStop(7);
} else {
txterror.text = "Tens de inserir um número entre 3 e 6";
}
}
Ao seleccionar o botão “Ajuda”:
on(release)
{
attachMovie("mchelp","mchelp1",100);
mchelp1._x=300;
mchelp1._y=200;
btnop._visible=false;
txtop._visible=false;
btnhelp._visible=false;
}
Após a escolha do número de peças (exemplo no caso de 5 peças):
if (op3 == 1) {
loadMovieNum("hanoi5pcs/hanoi5pcs.swf", 2);
}
nao._visible=false;
sim._visible=false;
menu5pecas._visible=true;
voltar._visible=false;
58
B.2.3 Palco Principal – Jogo com 5 peças
Para os restantes jogos, o código é em tudo semelhante.
stop();
//variáveis da primeira posição
var firstpos5 = 1;
var firstpos4 = 1;
var firstpos3 = 1;
var firstpos2 = 1;
var firstpos1 = 1;
//Contador para saber se as peças estão livres
var cont1 = 0;
var cont2 = 0;
var cont3 = 0;
var cont4 = 0;
var cont5 = 1;
//Marcador para saber em que pole se encontra a tile
var pole1tile1size = 1;
//variável fixa com a altura que deve ser adicionada às tiles
var altura = 30;
//variáveis com os valores da quantidade de tiles que se encontram em cada pole
var poleval1 = 5, poleval2 = 0, poleval3 = 0;
//indicadores sobre em que pole se encontravam as tiles
var tilehistory1 = 1;
59
//variável global com a pontuação do jogador e outra para somar os pontos ou subtrair
_global.clickcounter=0;
//função para ver se as peças estão livres
function free() {
//********************************************
//****************
//*******
****************
Condições para o pole1 *******
//****************
****************
//********************************************
//código para a tile2 no pole1
//se estiverem todas
if ((pole1tile2size == 1) && (pole1tile1size == 1)) {
cont2 = 1;
cont1 = 0;
}
//se não estiver a 2
if ((pole1tile2size != 1) && (pole1tile1size == 1)) {
cont1 = 1;
}
if ((pole1tile2size == 1) && (pole1tile1size != 1)) {
cont2 = 1;
}
if ((pole1tile3size == 1) && (pole1tile2size == 1) && (pole1tile1size == 1)) {
cont3 = 1;
cont2 = 0;
cont1 = 0;
}
if ((pole1tile3size != 1) && (pole1tile2size == 1) && (pole1tile1size == 1)) {
cont2 = 1;
cont1 = 0;
}
60
if ((pole1tile3size == 1) && (pole1tile2size != 1) && (pole1tile1size == 1)) {
cont3 = 1;
cont1 = 0;
}
if ((pole1tile3size == 1) && (pole1tile2size == 1) && (pole1tile1size != 1)) {
cont3 = 1;
cont2 = 0;
}
//se não estiver a 2 e a 1
if ((pole1tile3size == 1) && (pole1tile2size != 1) && (pole1tile1size != 1)) {
cont3 = 1;
}
if ((pole1tile4size == 1) && (pole1tile3size == 1) && (pole1tile2size == 1) && (pole1tile1size == 1))
{
cont4 = 1;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
if ((pole1tile4size != 1) && (pole1tile3size == 1) && (pole1tile2size == 1) && (pole1tile1size == 1)) {
cont3 = 1;
cont2 = 0;
cont1 = 0;
}
if ((pole1tile4size == 1) && (pole1tile3size != 1) && (pole1tile2size == 1) && (pole1tile1size == 1)) {
cont4 = 1;
cont2 = 0;
cont1 = 0;
}
if ((pole1tile4size == 1) && (pole1tile3size == 1) && (pole1tile2size != 1) && (pole1tile1size == 1)) {
cont4 = 1;
cont3 = 0;
cont1 = 0;
}
61
if ((pole1tile4size == 1) && (pole1tile3size == 1) && (pole1tile2size == 1) && (pole1tile1size != 1)) {
cont4 = 1;
cont3 = 0;
cont2 = 0;
}
if ((pole1tile4size == 1) && (pole1tile3size != 1) && (pole1tile2size != 1) && (pole1tile1size == 1)) {
cont4 = 1;
cont1 = 0;
}
if ((pole1tile4size == 1) && (pole1tile3size != 1) && (pole1tile2size == 1) && (pole1tile1size != 1)) {
cont4 = 1;
cont2 = 0;
}
if ((pole1tile4size == 1) && (pole1tile3size == 1) && (pole1tile2size != 1) && (pole1tile1size != 1)) {
cont4 = 1;
cont3 = 0;
}
// se não estiver a 3, a 2 e a 1
if ((pole1tile4size == 1) && (pole1tile3size != 1) && (pole1tile2size != 1) && (pole1tile1size != 1)) {
cont4 = 1;
}
if ((pole1tile5size == 1) && (pole1tile4size == 1) && (pole1tile3size == 1) && (pole1tile2size == 1)
&& (pole1tile1size == 1)) {
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
/*
if ((pole1tile5size != 1) && (pole1tile4size == 1) && (pole1tile3size == 1) && (pole1tile2size
== 1) && (pole1tile1size == 1)) {
cont4 = 1;
cont3 = 0;
cont2 = 0;
62
cont1 = 0;
}
*/
if ((pole1tile5size == 1) && (pole1tile4size != 1) && (pole1tile3size == 1) && (pole1tile2size == 1)
cont5 = 1;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
if ((pole1tile5size == 1) && (pole1tile4size == 1) && (pole1tile3size != 1) && (pole1tile2size == 1)
cont5 = 1;
cont4 = 0;
cont2 = 0;
cont1 = 0;
}
if ((pole1tile5size == 1) && (pole1tile4size == 1) && (pole1tile3size == 1) && (pole1tile2size != 1)
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont1 = 0;
}
&& (pole1tile1size != 1)) {
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont2 = 0;
}
if ((pole1tile5size == 1) && (pole1tile4size != 1) && (pole1tile3size != 1) && (pole1tile2size == 1)
cont5 = 1;
cont2 = 0;
cont1 = 0;
}
63
if ((pole1tile5size == 1) && (pole1tile4size != 1) && (pole1tile3size == 1) && (pole1tile2size != 1)
cont5 = 1;
cont3 = 0;
cont1 = 0;
}
cont5 = 1;
cont3 = 0;
cont2 = 0;
}
if ((pole1tile5size == 1) && (pole1tile4size == 1) && (pole1tile3size != 1) && (pole1tile2size != 1)
cont5 = 1;
cont4 = 0;
cont1 = 0;
}
cont5 = 1;
cont4 = 0;
cont2 = 0;
}
cont5 = 1;
cont4 = 0;
cont3 = 0;
}
//se não estiver a 4, a 3 e 2
if ((pole1tile5size == 1) && (pole1tile4size != 1) && (pole1tile3size != 1) && (pole1tile2size != 1)
cont5 = 1;
cont1 = 0;
}
//se não estiver a 4, a 3 e a 1
64
cont5 = 1;
cont2 = 0;
}
//se não estiver a 4 a 2 e a 1
cont5 = 1;
cont3 = 0;
}
cont5 = 1;
cont4 = 0;
}
// se não estiver a 4, a 3, a 2 e a 1
cont5 = 1;
cont4 = 0;
}
//********************************************
//****************
//*******
****************
//****************
****************
//********************************************
cont2 = 1;
cont1 = 0;
}
cont1 = 1;
}
cont2 = 1;
65
}
cont3 = 1;
cont2 = 0;
cont1 = 0;
}
cont2 = 1;
cont1 = 0;
}
cont3 = 1;
cont1 = 0;
}
cont3 = 1;
cont2 = 0;
}
cont3 = 1;
}
{
cont4 = 1;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
cont3 = 1;
cont2 = 0;
66
cont1 = 0;
}
cont4 = 1;
cont2 = 0;
cont1 = 0;
}
cont4 = 1;
cont3 = 0;
cont1 = 0;
}
cont4 = 1;
cont3 = 0;
cont2 = 0;
}
cont4 = 1;
cont1 = 0;
}
cont4 = 1;
cont2 = 0;
}
cont4 = 1;
cont3 = 0;
}
cont4 = 1;
}
67
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont2 = 0;
cont1 = 0;
gotoAndPlay(2);
}
/*
== 1) && (pole2tile1size == 1)) {
cont4 = 1;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
*/
cont5 = 1;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
cont5 = 1;
cont4 = 0;
cont2 = 0;
cont1 = 0;
}
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont1 = 0;
68
}
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont2 = 0;
}
cont5 = 1;
cont2 = 0;
cont1 = 0;
}
cont5 = 1;
cont3 = 0;
cont1 = 0;
}
cont5 = 1;
cont3 = 0;
cont2 = 0;
}
cont5 = 1;
cont4 = 0;
cont1 = 0;
}
cont5 = 1;
cont4 = 0;
69
cont2 = 0;
}
cont5 = 1;
cont4 = 0;
cont3 = 0;
}
cont5 = 1;
cont1 = 0;
}
cont5 = 1;
cont2 = 0;
}
cont5 = 1;
cont3 = 0;
}
cont5 = 1;
cont4 = 0;
}
cont5 = 1;
cont4 = 0;
}
70
//********************************************
//****************
//*******
****************
//****************
****************
//********************************************
cont2 = 1;
cont1 = 0;
}
cont1 = 1;
}
cont2 = 1;
}
cont3 = 1;
cont2 = 0;
cont1 = 0;
}
cont2 = 1;
cont1 = 0;
}
cont3 = 1;
cont1 = 0;
}
cont3 = 1;
cont2 = 0;
71
}
cont3 = 1;
}
{
cont4 = 1;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
cont3 = 1;
cont2 = 0;
cont1 = 0;
}
cont4 = 1;
cont2 = 0;
cont1 = 0;
}
cont4 = 1;
cont3 = 0;
cont1 = 0;
}
cont4 = 1;
cont3 = 0;
cont2 = 0;
}
72
cont4 = 1;
cont1 = 0;
}
cont4 = 1;
cont2 = 0;
}
cont4 = 1;
cont3 = 0;
}
cont4 = 1;
}
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont2 = 0;
cont1 = 0;
//assim que estiverem todas vai para os records
gotoAndPlay(2);
}
/*
== 1) && (pole3tile1size == 1)) {
cont4 = 1;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
*/
73
cont5 = 1;
cont3 = 0;
cont2 = 0;
cont1 = 0;
}
cont5 = 1;
cont4 = 0;
cont2 = 0;
cont1 = 0;
}
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont1 = 0;
}
cont5 = 1;
cont4 = 0;
cont3 = 0;
cont2 = 0;
}
cont5 = 1;
cont2 = 0;
cont1 = 0;
}
cont5 = 1;
cont3 = 0;
cont1 = 0;
74
}
cont5 = 1;
cont3 = 0;
cont2 = 0;
}
cont5 = 1;
cont4 = 0;
cont1 = 0;
}
cont5 = 1;
cont4 = 0;
cont2 = 0;
}
cont5 = 1;
cont4 = 0;
cont3 = 0;
}
cont5 = 1;
cont1 = 0;
}
cont5 = 1;
cont2 = 0;
}
75
cont5 = 1;
cont3 = 0;
}
cont5 = 1;
cont4 = 0;
}
cont5 = 1;
cont4 = 0;
}
}
76