Ciência Da Computação - Desenvolvimento de um jogo em linguagem Java
description
Transcript of Ciência Da Computação - Desenvolvimento de um jogo em linguagem Java
Ciência da Computação
Título
“Desenvolvimento de um jogo com
utilização de interface gráfica”
2
Sumário Título ............................................................................................................................................. 1
Objetivo ........................................................................................................................................ 3
Introdução .................................................................................................................................... 4
Regras e funcionamento do Jogo ............................................................................................ 6
Como Jogar ................................................................................................................................. 8
Plano de desenvolvimento do jogo .......................................................................................... 9
Projeto do Programa(Linhas de Código) .............................................................................. 15
3
Objetivo Um dos objetivos deste trabalho é tratar sobre o conteúdo da disciplina
'ALPOO', no intuito de desenvolver uma aplicação na linguagem Java,
utilizando com base conhecimentos adquiridos em sala de aula e por meio de
pesquisas e estudos a parte, podendo assim, aprender mais sobre esta
linguagem e suas formas de se programar.
Outro objetivo do trabalho, sendo ele, o tema a ser abordado, focando
somente no meio ambiente e suas preocupações, como a alta poluição
podendo ter como visão ambiental um jogo que desperte em seus jogadores, o
interesse de se aprofundar no assunto.
4
Introdução História do Jogo
“Stic Flic”, (Nome do jogo) se passa em São Paulo no ano de 2035. O
mundo inteiro encontra-se em estado critico. Em São Paulo não é diferente: o
ar poluído, a água escassa e o céu contaminado por uma espécie de nuvem
tóxica radioativa complementa o senário do jogo.
“Dherick” é um homem que passou por mutações devido a tal nuvem
radioativa. Adquiriu poderes e é o único que pode salvar a metrópole dessa
terrível situação.
O personagem principal voa pela cidade, para destruir as nuvens toxicas
e livrar a população desse mal. Controle “Dherick” e ajude-o a salvar a cidade.
5
Criação do Jogo
Para a criação do jogo, usufruirmos dos pacotes “Swing” e “Awt” para as
funções de imagens e eventos. Foram criadas Classes para cada estrutura,
tornando fácil a leitura das linhas de código. O jogo interage diretamente com o
teclado do computador, as teclas foram usadas para a locomoção e “poder” do
personagem.
Um feito muito importante dentro das linhas de código, foi a inserção de
imagens dentro do jogo pelo imageIcon, contido no pacote “Swing”
(javax.swing.imageIcon).
Um breve resumo das classes
ContainerDeJanelas: Essa classe fica encarregada de “formatar” todos
os parâmetros contidos na janela. Exemplo: Tamanho da tela, nome da janela,
visibilidade e etc. Ela é apenas a estrutura base para o restante das classes.
Observação: O método main se encontra na mesma.
Dherick: Define as coordenadas do personagem. Exemplo: movimentos
do mesmo na tela pelo teclado do computador.
Fase: É a imagem de fundo na tela principal do jogo, como as outras
classes segue seus parâmetros para a “formatação” da mesma. Exemplo:
determina o fim da tela “até onde o personagem Dherick pode ir”.
Poder: O personagem “Dherick” terá um tipo de “poder” para acabar com
as nuvens radioativas. Nessa classe é onde o “poder” é definido. Exemplo:
velocidade do poder, de onde esse poder vai ter que sair, até onde ele tem que
chegar e o que acontece quando esse poder atinge um inimigo.
Nuvem: Semelhante a classe Poder . Exemplo: a velocidade da nuvem e
o que acontece quando ela é atingida pelo poder do personagem Dherick.
Algumas das imagens expostas no jogo foram pegas da internet. Após
receberem tratamentos foram colocadas no jogo.
As paginas seguintes mostram com mais detalhes todos os processos
para a criação do jogo.
6
Regras e funcionamento do Jogo
Stic Flic é fácil e simples de jogar. O personagem principal sobrevoa a
cidade e seu objetivo é acabar com os elementos radioativos que vem em sua
direção. Atire contra todos os elementos e ganhe o jogo.
Se o personagem principal for atingido, você perde o jogo. Para tentar
novamente basta teclar a tecla ENTER.
Imagens do jogo:
7
Na parte superior embaixo de “Menu”, (INIMIGOS) encontra-se um
contador. A quantidade de inimigos será diminuída a cada nuvem atingida,
quando o total de inimigos for igual a zero, o jogo acaba e você vence.
Na barra de “Menu”, existem duas opções, sair e sobre. A opção sair
tem a mesma função do “x” superior á direita, e a opção “sobre” ao ser clicada,
mostra os desenvolvedores do projeto.
Observações: Joga-se com apenas um único player (um jogador),
existem dois tipos de inimigos e o cenário é fixo (a imagem de fundo).
Nessa outra imagem abaixo, vemos o personagem atirando:
8
Como Jogar
As teclas “Setas” do teclado faz o personagem se locomover.
Cima, baixo, direita ou esquerda.
Pressionando a Barra de espaço, o poder é liberado.
Pressionando “Enter” em qualquer momento da partida, o jogo será
reiniciado.
9
Plano de desenvolvimento do jogo
Usando componentes dos pacotes Java Swing e Awt, criamos um jogo com o tema “Educação Ambiental” que poderá ser jogado por apenas uma pessoa. Um jogo simples e divertido onde uma criança ou até mesmo um adulto pode “viajar” no futuro e aprender sobre Educação Ambiental.
Explicações de algumas classes presentes no jogo:
public Dherick(){ ImageIcon referencia = new ImageIcon("res\\Dherick.png"); imagem = referencia.getImage(); altura = imagem.getHeight(null); largura = imagem.getWidth(null); poderes = new ArrayList<Poder>(); this.x = 100; this.y = 100; }
Na classe “Dherick”, encontramos o método construtor. Onde é definida
a imagem utilizada no jogo e as coordenadas do personagem.
public void mexer(){ x += dx; y += dy; if(this.x < 1){ x = 1; } if(this.x > 412){ x = 412; } if(this.y < 1){ y = 1; } if(this.y > 339){ y = 339; } }
10
No método “mexe” temos as variáveis x, y, dx e dy que foram criadas no
começo da classe. Esse método vai fazer o personagem se locomover e
também determinar o limite permitido que ele pode percorrer na tela do jogo.
public void atira(){
this.poderes.add(new Poder(x + largura, y + altura/2));
}
public Rectangle getBounds(){
return new Rectangle(x, y, largura, altura);
}
No Método “atira” Podemos definir a principal ação do personagem, que
será usada para eliminar os oponentes do jogo. Este método vai fazer com que
o personagem lance seu poder com velocidade, altura e largura definidas tudo
neste método. Nele se usa a classe 'Poder' que no caso é o objeto lançado por
Dherick.
public class Nuvem {
private Image imagem;
private int x, y;
private int largura, altura;
private boolean isVisivel;
private static final int LARGURA_TELA = 500;
private static final int VELOCIDADE = 1;
private static int contador = 0;
A Classe “Nuvem” Possui as Variáveis x, y, largura, altura do tipo
inteiro, isVisivel do tipo boolean, imagem do tipo image.
11
Foram usados para definir os aspectos da nuvem, no caso, os inimigos
que aparecerão na Tela. Definindo Altura e Largura e Velocidade.
public void mexer
if(this.x < 0){
this.x = LARGURA_TELA;
}else{
this.x -= VELOCIDADE;
}
O método “mexer” Desta Classe foi usado para definir o percurso da
nuvem na Tela de jogo e a Velocidade com que ela irá percorrer.
public class Poder {
private Image imagem;
private int x, y;
private int altura, largura;
private boolean isVisivel;
private static final int LARGURA_TELA = 500;
private static final int VELOCIDADE = 2;
A Classe “Poder” foi criada para definir o poder do personagem que será
usada no método “atirar” da classe “Dherick”, o poder foi definido pelas
variáveis imagem do tipo Image, para definir o visual do poder e o aspecto,
a variável x e y, altura e largura do tipo int para definir a posição do poder.
public boolean isVisivel() {
return isVisivel;
}
public void setVisivel(boolean isVisivel) {
12
this.isVisivel = isVisivel;
}
public Image getImagem() {
return imagem;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public Rectangle getBounds(){
return new Rectangle(x, y, largura, altura);
}
}
O método “isVisible” é usado para definir a visibilidade da nuvem no jogo,
tendo a possibilidade de ser eliminada da tela se ela percorrer a Tela por
inteira, sendo assim, voltara a sua posição inicial, assim sucessivamente até
que o jogador a destrua.
public class Fase extends JPanel implements ActionListener {
private Image fundo;
private Dherick dherick;
private Timer timer;
private boolean emJogo;
private List<Nuvem> nuvens;
private int[][] coordenadas = { { 2380, 29 }, { 2600, 59 }, {1380, 89 },
13
{ 780, 109 }, { 580, 139 }, { 880, 239 }, { 790, 259 },
{ 760, 50 }, { 790, 150 }, { 1980, 209 }, { 560, 45 }, { 510, 70 },
{ 930, 159 }, { 590, 80 }, { 530, 60 }, { 940, 59 }, { 990, 30 },
{ 920, 200 }, { 900, 259 }, { 660, 50 }, { 540, 90 }, { 810, 220 },
{ 860, 20 }, { 740, 180 }, { 820, 128 }, { 490, 170 }, { 700, 30 },
{ 920, 300 }, { 856, 328 }, { 456, 320 } };
A Classe “Fase” é basicamente a estrutura do jogo, onde tudo vai
acontecer, nela irá conter as variáveis fundo para definir o cenário do jogo, a
variável Dherick que será o personagem principal controlado pelo jogador que
já foi definido na classe “Dherick”, nuvem que será os inimigos a serem
destruídos que também foram definidos em uma classe especial chamada
“Nuvem”, coordenadas que será o espaço que o jogador terá para jogar e por
onde são definidos os parâmetros por onde cada objeto irá passar.
public void inicializaNuvens() {
nuvens = new ArrayList<Nuvem>();
for (int i = 0; i < coordenadas.length; i++) {
nuvens.add(new Nuvem(coordenadas[i][0], coordenadas[i][1]));
}
O método “inicializaNuvens” irá ser usado para iniciar as nuvens do jogo,
sendo definidas por onde passarão.
public class ContainerDeJanelas extends JFrame {
/**
*
*/
private static final long serialVersionUID = 1L;
public ContainerDeJanelas() {
14
JMenuBar barraMenu = new JMenuBar();
JMenu menu = new JMenu("Menu");
JMenuItem sobre = new JMenuItem("Sobre");
A Classe “ContainerDeJanelas” será usada para criação da
Janela onde será aplicada a criação do jogo, contendo Menu, MenuItem,
MenuBar,
Isso Desenvolverá um Menu, que ao ser clicado pelo usuario, irá
exibir um “JMenuItem” Que no caso será as opções que esse menu irá conter,
Tendo um item "Sobre" Que nele será inseridos algumas informações básicas
como um JOptionPane.showMessageDialog Contendo : "Jogo desenvolvido
por Adenilson, Diniz, Erik e Eric Jordão”, "Informações" no Caso os créditos do
jogo, Terá também o item "Sair" Que ao ser clicado pelo usuário o jogo será
fechado e encerrado.
15
Projeto do Programa (Linhas de Código)
Container de Janelas
package jogo;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JSeparator;
public class ContainerDeJanelas extends JFrame {
/**
*
*/
private static final long serialVersionUID = 1L;
public ContainerDeJanelas() {
JMenuBar barraMenu = new JMenuBar();
JMenu menu = new JMenu("Menu");
16
JMenuItem sobre = new JMenuItem("Sobre");
sobre.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(null,
"Jogo desenvolvido por Adenilson",
Diniz, Erik e Eric Jordão, "Informações",
JOptionPane.INFORMATION_MESSAGE);
}
});
JMenuItem sair = new JMenuItem("Sair");
sair.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
menu.add(sobre);
menu.add(new JSeparator());
menu.add(sair);
17
barraMenu.add(menu);
setJMenuBar(barraMenu);
add(new Fase());
setTitle("Stic Flic");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(500, 420);
setLocationRelativeTo(null);
setResizable(false);
setVisible(true);
}
public static void main(String[] args) {
new ContainerDeJanelas();
}
}
Fase
package jogo;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
18
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.List;
import javax.swing.Timer;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
public class Fase extends JPanel implements ActionListener {
private Image fundo;
private Dherick dherick;
private Timer timer;
private boolean emJogo;
private List<Nuvem> nuvens;
private int[][] coordenadas = { { 2380, 29 }, { 2600, 59 }, { 1380, 89 },
{ 780, 109 }, { 580, 139 }, { 880, 239 }, { 790, 259 },
{ 760, 50 }, { 790, 150 }, { 1980, 209 }, { 560, 45 }, { 510, 70 },
{ 930, 159 }, { 590, 80 }, { 530, 60 }, { 940, 59 }, { 990, 30 },
{ 920, 200 }, { 900, 259 }, { 660, 50 }, { 540, 90 }, { 810, 220 },
{ 860, 20 }, { 740, 180 }, { 820, 128 }, { 490, 170 }, { 700, 30 },
{ 920, 300 }, { 856, 328 }, { 456, 320 } };
19
public Fase() {
setFocusable(true);
setDoubleBuffered(true);
addKeyListener(new TecladoAdapter());
ImageIcon referencia = new ImageIcon("res\\Fase.jpg");
fundo = referencia.getImage();
dherick = new Dherick();
emJogo = true;
inicializaNuvens();
timer = new Timer(5, this);
timer.start();
}
public void inicializaNuvens() {
nuvens = new ArrayList<Nuvem>();
for (int i = 0; i < coordenadas.length; i++) {
nuvens.add(new Nuvem(coordenadas[i][0], coordenadas[i][1]));
}
}
public void paint(Graphics g) {
20
Graphics2D graficos = (Graphics2D) g;
graficos.drawImage(fundo, 0, 0, null);
if (emJogo) {
graficos.drawImage(dherick.getImagem(), dherick.getX(),
dherick.getY(), this);
List<Poder> poderes = dherick.getPoderes();
for (int i = 0; i < poderes.size(); i++) {
Poder p = (Poder) poderes.get(i);
graficos.drawImage(p.getImagem(), p.getX(), p.getY(), this);
}
for (int i = 0; i < nuvens.size(); i++) {
Nuvem in = nuvens.get(i);
graficos.drawImage(in.getImagem(), in.getX(), in.getY(), this);
}
graficos.setColor(Color.WHITE);
graficos.drawString("INIMIGOS: " + nuvens.size(), 5, 15);
} else {
ImageIcon fimJogo = new ImageIcon("res\\Game_Over.jpg");
21
graficos.drawImage(fimJogo.getImage(), 0, 0, null);
}
g.dispose();
}
@Override
public void actionPerformed(ActionEvent arg0) {
if (nuvens.size() == 0) {
emJogo = false;
}
List<Poder> poderes = dherick.getPoderes();
for (int i = 0; i < poderes.size(); i++) {
Poder p = (Poder) poderes.get(i);
if (p.isVisivel()) {
p.mexer();
} else {
poderes.remove(i);
}
}
for (int i = 0; i < nuvens.size(); i++) {
Nuvem in = nuvens.get(i);
22
if (in.isVisivel()) {
in.mexer();
} else {
nuvens.remove(i);
}
}
dherick.mexer();
checarColisoes();
repaint();
}
public void checarColisoes() {
Rectangle formaDherick = dherick.getBounds();
Rectangle formaNuvem;
Rectangle formaPoder;
for (int i = 0; i < nuvens.size(); i++) {
Nuvem tempNuvem = nuvens.get(i);
formaNuvem = tempNuvem.getBounds();
if (formaDherick.intersects(formaNuvem)) {
dherick.setVisivel(false);
tempNuvem.setVisivel(false);
emJogo = false;
}
23
}
List<Poder> poderes = dherick.getPoderes();
for (int i = 0; i < poderes.size(); i++) {
Poder tempPoder = poderes.get(i);
formaPoder = tempPoder.getBounds();
for (int j = 0; j < nuvens.size(); j++) {
Nuvem tempNuvem = nuvens.get(j);
formaNuvem = tempNuvem.getBounds();
if (formaPoder.intersects(formaNuvem)) {
tempNuvem.setVisivel(false);
tempPoder.setVisivel(false);
}
}
}
}
private class TecladoAdapter extends KeyAdapter {
@Override
public void keyPressed(KeyEvent e) {
24
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
emJogo = true;
dherick = new Dherick();
inicializaNuvens();
}
dherick.keyPressed(e);
}
@Override
public void keyReleased(KeyEvent e) {
dherick.keyRelease(e);
}
}
}
Dherick
package jogo;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.List;
import javax.swing.ImageIcon;
25
public class Dherick {
private int x, y;
private int dx, dy;
private int altura, largura;
private Image imagem;
private boolean isVisivel;
private List<Poder> poderes;
public Dherick(){
ImageIcon referencia = new ImageIcon("res\\Dherick.png");
imagem = referencia.getImage();
altura = imagem.getHeight(null);
largura = imagem.getWidth(null);
poderes = new ArrayList<Poder>();
this.x = 100;
this.y = 100;
}
public void mexer(){
x += dx; //1 e 412
y += dy; //1 e 339
26
if(this.x < 1){
x = 1;
}
if(this.x > 412){
x = 412;
}
if(this.y < 1){
y = 1;
}
if(this.y > 339){
y = 339;
}
}
public List<Poder> getPoderes() {
return poderes;
}
public int getX() {
return x;
}
27
public int getY() {
return y;
}
public Image getImagem() {
return imagem;
}
public boolean isVisivel() {
return isVisivel;
}
public void setVisivel(boolean isVisivel) {
this.isVisivel = isVisivel;
}
public void atira(){
this.poderes.add(new Poder(x + largura, y + altura/2));
}
public Rectangle getBounds(){
return new Rectangle(x, y, largura, altura);
}
public void keyPressed(KeyEvent tecla){
int codigo = tecla.getKeyCode();
28
if(codigo == KeyEvent.VK_SPACE){
atira();
}
if(codigo == KeyEvent.VK_UP){
dy = -1;
}
if(codigo == KeyEvent.VK_DOWN){
dy = 1;
}
if(codigo == KeyEvent.VK_LEFT){
dx = -1;
}
if(codigo == KeyEvent.VK_RIGHT){
dx = 1;
}
}
public void keyRelease(KeyEvent tecla){
int codigo = tecla.getKeyCode();
if(codigo == KeyEvent.VK_UP){
dy = 0;
}
29
if(codigo == KeyEvent.VK_DOWN){
dy = 0;
}
if(codigo == KeyEvent.VK_LEFT){
dx = 0;
}
if(codigo == KeyEvent.VK_RIGHT){
dx = 0;
}
}
}
Nuvem
package jogo;
import java.awt.Image;
import java.awt.Rectangle;
import javax.swing.ImageIcon;
public class Nuvem {
private Image imagem;
30
private int x, y;
private int largura, altura;
private boolean isVisivel;
private static final int LARGURA_TELA = 500;
private static final int VELOCIDADE = 1;
private static int contador = 0;
public Nuvem(int x, int y){
this.x = x;
this.y = y;
ImageIcon referencia;
System.out.println(contador);
if(contador++ % 3 == 0){
referencia = new ImageIcon("res\\Radiacao.png");
}else{
referencia = new ImageIcon("res\\Nuvem.png");
}
imagem = referencia.getImage();
this.largura = imagem.getHeight(null);
this.altura = imagem.getWidth(null);
31
isVisivel= true;
}
public void mexer(){
if(this.x < 0){
this.x = LARGURA_TELA;
}else{
this.x -= VELOCIDADE;
}
}
public boolean isVisivel() {
return isVisivel;
}
public void setVisivel(boolean isVisivel) {
this.isVisivel = isVisivel;
}
public Image getImagem() {
return imagem;
}
public int getX() {
return x;
}
32
public int getY() {
return y;
}
public Rectangle getBounds(){
return new Rectangle(x, y, largura, altura);
}
}
Poder
package jogo;
import java.awt.Image;
import java.awt.Rectangle;
import javax.swing.ImageIcon;
public class Poder {
private Image imagem;
private int x, y;
private int altura, largura;
private boolean isVisivel;
private static final int LARGURA_TELA = 500;
private static final int VELOCIDADE = 2;
33
public Poder(int x, int y){
this.x = x;
this.y = y;
ImageIcon referencia = new ImageIcon("res\\Poder.png");
imagem = referencia.getImage();
this.largura = imagem.getHeight(null);
this.altura = imagem.getWidth(null);
isVisivel= true;
}
public void mexer(){
this.x += VELOCIDADE;
if(this.x > LARGURA_TELA){
isVisivel = false;
}
}
public boolean isVisivel() {
return isVisivel;
}
public void setVisivel(boolean isVisivel) {
this.isVisivel = isVisivel;
}
34
public Image getImagem() {
return imagem;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public Rectangle getBounds(){
return new Rectangle(x, y, largura, altura);
}
}
35