Trabalho em greenfoot

Centro de Competências das Ciências Exatas e da Engenharia

Programação Orientada por Objetos

Licenciatura em Engenharia Informática (LEI)

Trabalho em Greenfoot

“The Forbidden Book”

Grupo I 21

Discente: Vitor Faria nº 2110312




Programação Orientada por Objetos Página 1

Índice Introdução .................................................................................................................................... 2

Alterações à ideia inicial ............................................................................................................... 2

Objetivos ....................................................................................................................................... 3

Requisitos do Greenfoot .............................................................................................................. 3

Requisitos Programação Orientada por Objetos ......................................................................... 7

Conclusão .................................................................................................................................... 13

Bibliografia .................................................................................................................................. 14





Introdução

Este trabalho feito é realizado no âmbito da disciplina “Programação Orientada por Objetos”, incidindo na plataforma “Greenfoot” e em conceitos de programação orientada por objetos.

Foi-nos proposto, pela regente da disciplina, que desenvolvêssemos uma aplicação, de tema livre, usando a plataforma “Greenfoot” (aplicação Java que ajuda na escrita de programas ou aplicações- Através desta, podemos interagir diretamente com os componentes, o que facilita bastante a aprendizagem da “linguagem” Java).

Optámos por um jogo- sobre um tema de sobrenatural. Assim, o cenário decorre num espaço imaginário onde dois amigos, num dia absolutamente normal de escola, fazem a descoberta de um livro antigo japonês. Ao folhear o livro, numa página específica, é despoletada toda a ação. São de imediato transportados para “Yomi-no-koni” ( palavra japonesa que corresponde à "terra dos mortos", de acordo com a mitologia "Shinto"). Este, é o lugar para onde os mortos vão depois da vida e uma vez indo ao coração de “Yomi”, não está ao alcance de todos o retorno para a "terra dos vivos". Para conseguir voltar, o nosso protagonista (que será o agente principal do jogo) terá de abater aqueles que estão em “Yomi-no-koni”, passando por três estados (níveis) até chegar ao confronto final com “Satã”.

Na elaboração deste jogo recorremos, à regente da disciplina , aos slides disponibilizados e à auto investigação, para conseguirmos atingir nossos objetivos.

Alterações à ideia inicial

No princípio tínhamos pensado num enredo diferente, mas com o desenrolar do

trabalho evoluímos para o atual. Assim, “Satã” estava pensado para ir perdendo a cor, mas

mantivemos a sua cor. No disparo acrescentámos características - Assim, e agora, depois de

atingir um certo número de inimigos (não é um número certo, visto ser calculado por

probabilidade) ficamos com a opção das “explosões”, opção assegurada através da utilização da

tecla “shift”. E, também, com a energia no máximo, temos a hipótese através de um “click”, no

rato, de mudar para metralhadora.

Finalmente, temos as evoluções normalmente decorrentes da elaboração do trabalho,

que também não estavam previstas, e pensadas, mas que, ou para cumprir com os objetivos de





programação orientada por objetos, ou para enriquecer o jogo acabaram por ir sendo

implementadas.

Objetivos

O nosso objetivo aquando da realização deste trabalho foi , não só conseguirmos

implementar um jogo aprazível de ser jogado, mas também demonstrar domínio da plataforma

“Greenfoot” e utilização das suas funcionalidades, como compreensão do paradigma de

programação por objetos e aplicação dos respetivos conceitos.

Requisitos do Greenfoot

Manipulação de sons

Como podemos observar no exemplo da figura 1 para a música de fundo. Onde

declaramos uma variável “music” apenas para esta classe do tipo “GreenfootSound” em que

guarda a nossa música de fundo e depois é usada nos métodos criados para começar e parar

a musica.

Figura 1 implementação da música de fundo

Manipulação de cores, como demonstra a figura 2

Tivemos de importar “java.awt.Color”, depois declaramos três variáveis red, green, blue,

para representarem as cores do modelo RGB, porque têm uma representação numérica,

dando-nos assim a hipótese de manipular a intensidade das cores. Depois no método

“private void drawScore()” criado para desenhar o “score” criamos um objeto da classe

“color” composto pelas nossas variáveis das cores “myColor = new Color ( red , green ,

blue)”. Variáveis essas que vão variando de valores, graças aos ciclos “if” criados dentro do

método “private void paint()” (como ilustrado na figura 2), criando o efeito desejado





Figura 2. Implementação do efeito das letras do “Score”

Animação.

Para a animação começamos por declarar uma vetor do tipo GreenfootImage com o

nome anima1 (“private GreenfootImage [] anima1;”). No “construtor” definimos o vetor

com dimensão 3 com cada posição a ter uma imagem diferente e definimos a primeira

imagem como sendo a imagem da primeira posição do vetor. Depois implementamos um

método para ir navegando no vetor de maneira a ir mudando de imagem e criar a sensação

de animação, como exemplificado na figura 3.





Figura 3: Implementação da animação do Zombie_slime

Transparência

Na implementação do efeito transparência começamos por declarar uma variável

“imagemFumo” do tipo “GreenfootImage”, depois implementamos o método onde a

variável do tipo “GreenfootImage” irá receber a própria imagem da classe (getImage()) de

seguida declaramos uma variável do tipo “inteiro” onde irá guardar o valor da textura

devolvido por “imagemFumo.getTransparency”. Depois com um ciclo “if” manipulamos

essa textura de forma a criar o efeito da transparência com a ajuda do “método

removeObject(this)”.





Manipulação do Tamanho

Na classe “addpoints” usamos o método “scale()” (próprio do Greenfoot) para dar novo

tamanho a “image2” utilizamos também o valor da variável “totalPoints” para o cumprimento

ir variando .

“image2.scale( totalPoints , 15);”

Utilização do Rato e Teclado

Aqui implementamos dois métodos um para a utilização do rato que chamamos

“followmouse”, onde declaramos uma variável “follow” para guardar o valor devolvido pelo

método “getMouseInfo()” e depois com um ciclo “if” que só acontece se o valor de “follow” for

diferente de “0” definimos a localização do objeto da classe “student” com os valores da

variável follow. Para a utilização do teclado implementamos um método com dois ciclos “if”

condicionados pelo retorno do método “isKeyDown” (True ou False) e depis com a invocação

do método “turn()” colocamos o argumento que define o sentido do movimento

Utilização do Rato Utilização do Teclado





Texto

Para criação de texto implementamos uma subclasse específica para o efeito servindo de

“construtor” do nosso texto para de seguida na classe “Menu” adicionarmos uma objeto desta

classe com as características que definimos em seu construtor tal como ilustra a figura 4.

Figura 4: Definição do Texto

Requisitos Programação Orientada por Objetos

Métodos

Os métodos são criados para podermos interagir com os objetos e quando invocados

realizam um determinado comportamento nos objetos.

Para definir métodos precisamos declarar; o tipo de método, retorno, nome, parâmetros de

entrada. Quanto ao tipo pode ser private (só pode ser acedido dentro da classe em que foi

criado), protected (pode ser acedido dentro da sua classe e pelas suas subclasses) e public (pode

ser acedido por qualquer classe). Exemplificado na figura 5.

Assinatura do Método Corpo Método

Figura 5: Caracterização de Método

Implementamos vários métodos, salvo algumas exceções foi em todas as classes.





Atributos

Podem ser locais (no corpo do método) ou globais fora dos métodos. O estado interno de

um objeto é dado pelos seus atributos, utilizando o “Inspect” podemos observar os atributos de

cada objeto. Um atributo tem um nome, um tipo de dados e a sua visibilidade (private,

protected, public).

Atributos Globais Atributos Locais

Figura 6. Atributos

Inicialização de objetos usando os construtores

Um construtor é o método principal de uma classe pois sem ele nenhuma classe inicia. Como

o nome indica um construtor constrói a classe por isso ao criarmos um objeto,

Os construtores foram bastante importantes neste trabalho desde a simples atribuição de uma

imagem aos objetos como à passagem de parâmetros pelos construtores entre os mundos.

Herança com um mínimo de 2 níveis além de Actor;

Herança é uma técnica no Java em que classes derivadas de uma superclasse podem herdar

métodos e atributos. Uma classe derivada de outra classe chama-se subclasse e a classe que

herda para as subclasses chama-se superclasse.

A palavra-chave na herança é “extends”, se fizermos por exemplo:

“public class SubClass extends SuperClass”

Estamos a declarar que “SuperClass” é a superclasse e “SubClass” é a subclasse.

A utilização de herança no “Greenfoot” é simplificada pois basta clicar numa classe e

escolher “New Subclass…” ou então simplesmente manipularmos o texto de declaração de

maneira a obtermos o pretendido.





Temos no nosso jogo várias superclasses => subclasses:

World => History

=> win

=> Yomi_no_Koni

=>History3

World => History2

=> GameOver

=> Menu

Actor => Upgrades

=> Slime

=> PaintWorlds

=> Bullet

=> Zombie

=> Student

=> Explosion

=> Score

Upgrades => Points

Points => Fog

PaintWorlds => Book

=> Title

=> PplayB

=> HowtoB

=> TryAgain

=> GameOverTitle

=> Click

=> YouWin

=> Exit

=> Help





PaintWorlds => Story

Help => Help2

=> Help1

Story => StoryWin

=> Story1

Story => Story2

=> Story3

Bullet => Bullet1

=> BossBullets

Zombie => Zombie_boss

=> Zombie_slime

=> Zombie_Weak

=> Zombie_strong

Student => DummyStudent

Score => AddPoints

=> PointsBoard

=> ScoreBoard

ScoreBoard => Level2

=> Level3

"Overriding" de métodos;

“Overriding” acontece quando uma subclasse tem um método com o mesmo nome,

mesmos parâmetros e o mesmo tipo de retorno que a sua superclasse. O que acontece é que o

método que é herdado da superclasse é substituído pelo da subclasse, de modo que o método

que atua é o novo. Como demonstramos na figura 6 com um exemplo nosso do método

“moves”.





Figura 7: Overriding

"Overloading" de métodos;

“Overloading” acontece quando dentro duma mesma classe temos duas funções com o

mesmo nome e tipos de retorno iguais, no entanto recebem argumentos diferentes. Esta técnica

pode servir quando criamos duas ou mais funções com comportamentos parecidos mas que

recebem diferentes tipos de argumentos. Como neste exemplo que utilizamos para quando o

“Zombie_boss” volta ao “mundo” pela segunda vez no lado contrário e diferente.

Figura 8: Overloading

Encapsulamento

O encapsulamento é uma medida de segurança na linguagem Java, de forma que o código

não seja acedido de forma aleatória fora da sua classe. O encapsulamento pode ser

assegurado de três formas usando as palavas chave:

Private: Só pode ser acedido dentro da sua classe.

Protected: Pode ser acedido dentro da sua classe e pelas suas subclasses.

Public: Pode ser acedido por qualquer classe.





Utilização de listas (List).

Estes exemplos apresentados na figura 8 foram os por nós utilizados no nosso jogo

Figura 9: Listas





Conclusão

Com a elaboração deste trabalho tivemos a oportunidade de entrar em

contacto com a plataforma “Greenfoot”, a necessidade de fazermos

investigação para conseguimos atingir os requisitos do enunciado fez-nos

ganhar uma maior consolidação de conhecimentos tanto, da plataforma como

sobre os conceitos de programação por objetos.

Pensamos nós ter conseguido desenvolver um jogo, na nossa opinião,

de acordo com o que nos propusemos, tendo sido capaz de cumprir com todos

os requisitos do enunciado.





Bibliografia

[1] http://moodle.dme.uma.pt (disciplina Programação Orientada por Objetos).

[2] “Enunciado do Trabalho em Greenfoot 2015.pdf”, http://moodle.dme.uma.pt

(Programação Orientada por Objetos).

[3] Fóruns, http://www.greenfoot.org/topics

http://moodle.dme.uma.pt/

http://moodle.dme.uma.pt/

http://www.greenfoot.org/topics

Trabalho em greenfoot

Software

Transcript of Trabalho em greenfoot