DESENVOLVIMENTO DE UM JOGO COM UTILIZAÇÃO DE INTERFACE GRÁFICA APS UNIP PARTE ESCRITE E CÓDIGO FONTE

Prévia do material em texto

UNIVERSIDADE PAULISTA
Ciência da Computação
DESENVOLVIMENTO DE UM JOGO COM UTILIZAÇÃO DE INTERFACE GRÁFICA
SÃO PAULO
2020
ÍNDICE
Objetivo e motivação do trabalho.................................................................................4
Introdução.....................................................................................................................6
Regras do jogo..............................................................................................................9
conceitos gerais.........................................................................................................9
Personagem Principal...............................................................................................9
Inimigos...................................................................................................................10
Ambiente..................................................................................................................10
Jogabilidade............................................................................................................11
Plano de desenvolvimento do jogo.............................................................................13
Geral........................................................................................................................13
Container.................................................................................................................13
Fase.........................................................................................................................15
Inimigo.....................................................................................................................17
Nébula.....................................................................................................................18
Player.......................................................................................................................19
Tiro...........................................................................................................................21
Relatório Com as linhas de código do programa.......................................................23
OBJETIVO E MOTIVAÇÃO DO TRABALHO
Este trabalho tem como objetivo alertar a sociedade sobre a importância e os cuidados
com o meio ambiente, mostrando os problemas e as consequências causada pelo
homem ao meio em que habita, visto que, a cada ano a taxa de lixo no planeta e no
espaço só aumenta. Contudo, tentamos buscar uma forma de conscientizar a
população.
Nos dias atuais as grandes metrópoles vêm sofrendo demasiadamente com a questão
do meio ambiente devido ao grande crescimento populacional sem controle, a falta de
saneamento básico e de investimento na educação da nossa população. Com isso,
deve-se incentivar as empresas que atuam na área de tecnologia e entretenimento, a
investirem em meios de comunicação em massa que atinjam de forma sutil ou
impactante a população sobre as questões ambientais.
Segundo a ONU, as mudanças climáticas estão acelerando e isso é uma grande
ameaça há sobrevivência de milhões de pessoas, animais e plantas. Pois provoca
episódios meteorológicos, tais como, secas, incêndios e inundações cada vez mais
frequente e de forma extrema, esses fenômenos nos obrigam a criar formas de
conscientizar a população sobre as consequências causada pela falta de cuidados com
o planeta.
Devido aos grandes danos e catástrofes como os mencionados anteriormente, a
questão ambiental tornou-se um problema emergencial e de uma grande necessidade.
Então buscamos recursos que amenize a destruição do ambiente em que vivemos.
Diante desse quadro, corporações conscientes da necessidade de medidas
emergenciais vêm buscando formas através da mídia, jogos de entretenimento e dos
mais diversos recursos tecnológicos, atingir principalmente a população mais jovem
sobre essa realidade e a necessidade de lutarmos por um mundo melhor, para nós e
para as futuras gerações.
Portanto, pensando em tudo o que foi abordado acima, nós criamos esse jogo com o
intuito de mostrar a toda a população brasileira a importância de cuidar do meio
ambiente de um modo geral e especificadamente a importância de praticar a
reciclagem.
Como o jogo se passa no espaço, é válido falar de um assunto pouco conhecido, o lixo
espacial.
O lixo espacial é todo e qualquer objeto que não tenha mais utilidade, que é lançado no
espaço que orbita a Planeta Terra. Segundo a NASA, desde 1957 cerca de 4.000
satélites foram lançados na órbita do nosso planeta. Sabendo-se que o lixo espacial
representa perigo para satélites ativos, o jogo é basicamente um alien destruindo os
lixos espaciais (representados por lixos comuns), com intuito de "proteger" os satélites
ativos e passar uma lição para os usuários: se alienígenas existem, eles estão de
alguma forma ajudando o meio ambiente.
INTRODUÇÃO
Sem dúvidas, um dos maiores problemas enfrentamos na sociedade moderna, pós
revolução industrial, é a grande quantidade de resíduo gerado pela população mundial.
Por exemplo, apenas aqui no Brasil, em média, cada pessoa produz 387 kg por ano. E
segundo dados divulgados pela Associação Brasileira de Empresas de Limpeza
Pública e Resíduos Especiais (Abrelpe), em 2015, foram geradas 79,9 milhões de
toneladas de lixo em todo o País.
E a situação fica mais alarmante porque, a quantidade de lixo produzido no Brasil
cresce a uma taxa cinco vezes maior que o da população.
Se, por um lado, diversas iniciativas têm sido implementadas para diminuir a
quantidade de resíduos gerados, por exemplo, embalagens econômicas e retornáveis,
que diminuem os impactos ambientais causados durante sua produção, por outro lado
é necessário explorar melhor uma velha conhecida dos brasileiros que é fundamental
para auxiliar nesse quadro: a reciclagem.
Desde o início da humanidade o ser humano produz lixo de alguma forma. Os
nômades, por exemplo, já descartavam o que sobravam dos animais que eles caçavam
pela sua trajetória. E à medida que o homem foi se tornando um ser de sociedade, a
quantidade de lixo e resíduos foram aumentando gradualmente.
Segundo um recente estudo feito pela Universidade Estadual do Rio de Janeiro
(UERJ), civilizações antigas como os hindus, que é uma das sociedades mais antigas
do mundo, já tinha sistemas de esgoto. E outras civilizações, não tão antigas, como os
israelitas, por exemplo, já tinha regras estabelecidas de como eles deviam descartar
seus excrementos e os restos dos animais sacrificados, bem como os cadáveres e o
lixo produzido no reino.
Porém, na segunda metade do século XIX, com a Revolução Industrial, houve um
aumento significativo na produção de lixo, causando graves impactos sanitários. Foi
necessário programar novas medidas para amenizar a complicada situação dos bairros
operários e também dos bairros nobres.
Com isso, surgiu a necessidade de pensar em alternativas que não fossem
simplesmente estocar todo esse lixo em aterros ou descartá-lo de forma irregular no
ambiente, já que a maior parte do "lixo moderno" demora muito mais tempo para se
desintegrar naturalmente como por exemplo, uma garrafa PET, que leva em média 400
anos para se decompor. Assim, a reciclagem assumiu um papel importante diante de
tal necessidade.
Segundo a Política Nacional de Resíduos Sólidos (PNRS), reciclagem é o processo em
que há a transformação do resíduo sólido que não seria aproveitado, com mudanças
em seus estados físico, físico-químico ou biológico, de modo a atribuir características
ao resíduo para que ele se torne novamente matéria-prima ou produto. Ou seja,
reciclagem é o processo que visa pegar materiais usados, que seriam descartados com
o lixo comum, e transformá-los em novos produtos visando a reutilização dos mesmos.
Os materiais mais comuns a serem reciclados são, respectivamente, latas de alumínio,
embalagens PET e papel. A reciclagem desses materiais proporcionauma utilização
mais racional dos recursos naturais, consequentemente, causando um impacto menor
na natureza.
E a reciclagem traz consigo vários benefícios, tanto para os seres humanos quanto
para a natureza como, melhoria na limpeza da cidade e um aumento na qualidade de
vida da população, contribui para diminuir a poluição do solo, água e ar, prolonga a vida
útil de aterros sanitários, melhora a produção de compostos orgânicos, gera empregos
para a população não qualificada, gera receita com a comercialização dos recicláveis,
dentre outros.
No entanto, mesmo com tantas vantagens, apena 3% do total de lixo no brasil, que
poderia ser reciclado, é de fato reciclado. O que nos faz pensar em métodos para
conscientizar a população, em especial os mais jovens, sobre as vantagens da
reciclagem.
E com o intuito de mostrar a importância da reciclagem para o público mais jovem,
criamos esse jogo. Assim todos irão aprender de uma maneira divertida, intuitiva e por
meio da tecnologia, a reciclar o lixo.
REGRAS DO JOGO
Conceitos gerais
O nosso jogo foi inspirado em um jogo chamado Aero Fighters, que é um jogo
eletrônico com rolagem vertical. Originalmente, foi lançado com nome de “Super
Wings” em fliperamas do ano de 1992.
Neste jogo clássico dos fliperamas, o jogador é um piloto de avião e tem o desafio de
destruir as bases inimigas. Detonar todas as naves que estão contra você, desbloquear
novas armas e conquistar grandes territórios é o objetivo desse jogo.
Nesse tipo de jogo, o jogador se envolve em um ataque, disparando em um grande
número de inimigos. Foi extremamente popular ao longo dos anos 1980. Hoje em dia,
especificadamente, jogos nesse estilo não fazem tanto sucesso como antigamente,
porém esse gênerode jogo permanece vivo no Japão.
Esses jogo, conhecido no Brasil como "Jogos de Navezinhas", é mais conhecido pelo
termo shoot ' em up. Shoot ' em up é um subgênero dos jogos eletrônicos de tiro, que
nada mais é o tipo de jogo que já foi citado acima. Asteroids foi outro exemplo de shoot
'em up extremamente popular, seu ano de lançamento foi 1979 pela Atari (empresa de
produtos eletrônicos). Asteroids exigia movimentos rápidos, reação rápida e reflexo,
habilidades que frequentemente são requeridas em shoot 'em ups.
Personagem Principal
O personagem principal foi inspirado em um alienígena assim como o veículo que ele
está montado tem característicos de histórias de extraterrestres.
Inimigos
Os inimigos desse jogo são os lixos e nesse jogo encontramos cinco tipos de lixo
sendo eles:
• A casca de banana
• A lata usada
• A caixa de leite
• A bolinha de papel
• Maça
Ambiente
O jogo se passa em um ambiente urbano! O jogo ocorre em uma cidade que,
geralmente, tem grande concentração de pessoas e em decorrência disso acaba tendo
muito mais lixos jogados em lugares indevidos, que acabam trazendo grandes
problemas para o meio ambiente e principalmente, para a própria sociedade, trazendo
situações como os alagamentos, poluição nos mares, morte de espécies, como por
exemplo as tartarugas, que possuem um iminigo que ganhou fama nos últimos anos, o
canudo plástico.
Jogabilidade
O jogo consiste em utilizar os tiros da nave para eliminar todos os lixos que estão
sendo lançados. O jogo acaba quando o alienígena tem uma colisão com algum dos
inimigos.
O jogo em si é muito simples de se entender, as teclas que são utilizadas para jogar
são:
• Seta para cima: é usada para mover o personagem principal para cima.
• Seta para baixo: é usada para mover o personagem para baixo.
• Seta para o lado direito: é usada para mover o personagem para o lado direito.
• Seta para o lado esquerdo: é usada para mover o personagem para o lado
esquerdo.
• Tecla A: é usada para atirar nos inimigos.
Quando você perde, aparece uma janela com a mensagem dizendo que você perdeu,
como ilustrado abaixo:
Após a mensagem informando que você perdeu, aparece outra janela com uma
mensagem perguntando para o jogador se gostaria de jogar novamente.
Se o jogador selecionar a opção Sim, o jogo reinicia. Caso o jogador selecione a opção
Não, o jogo se encerra.
PLANO DE DESENVOLVIMENTO DO JOGO
Geral
Com o objetivo de não se tornar repetitivo tudo que foi utilizado no código para o
desenvolvimento do projeto como classes padrões do Java, pesquisas em fóruns e
vídeos, criamos essa parte denominada “geral” para citar tudo que foi utilizado durante
o processo de criação do nosso jogo.
As ferramentas utilizadas foram:
Eclipse - Para a criação e desenvolvimento de todo o projeto.
Gimp - Para edição do tamanho das figuras de modo que coubesse na tela em um
tamanho agradável, bem como a configuração exata para a imagem de fundo.
Essa ferramenta também foi utilizada para a remoção do fundo das imagens, deixando
apenas o que de fato era importante para o jogo.
Fóruns - Para aperfeiçoamento de algumas configurações já criadas e entendimento de
algumas classes.
Youtube - Para aperfeiçoamento de algumas configurações já criadas e entendimento
de algumas classes.
Os elementos utilizados foram:
Container
A classe Container.java, é relativo ao “Container”, cujo se trata da “janela” em si, que se
abre quando o programa é executado.
Dentro da classe Container.java, há algumas características, que serão explicadas a
seguir:
public class Container extends JFrame
Nessa parte do código, é especificado o nome da classe, que é o “Container”, e essa
classe herda de outra classe, denominada JFrame, que é uma classe padrão do Java,
que torna possível criar uma interface gráfica na linguagem Java.
setTitle("Educacao Ambiental");
O setTitle, serve para definir o título da janela que o programa abrirá (o título que
aparece no canto superior esquerdo nas janelas).
ImageIcon icone = new ImageIcon("res\\icone.png");
this.setIconImage(icone.getImage());
Aqui, é especificado pro programa, o ícone da janela, que fica ao lado esquerdo do
título, encontrado no canto superior esquerdo da tela.
setSize(1300,700);
O setSize, serve para definir o tamanho da janela que será aberta para o usuário, em
pixels, e com o padrão de respectivamente largura, e altura.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Esse método, serve para definir, qual ação será executada quando o usuário apertar no
botão x, de fechar, localizado no canto superior direito da tela, está setado nesse
programa, para quando o usuário clicar no botão, para fechar o programa, como deve
ser.
setLocationRelativeTo(null);
Esse método serve para que a janela abra centralizada no monitor do usuário.
this.setResizable(false);
Esse método tem o intuito de fazer com que a janela do jogo não seja redimensionável,
para evitar problemas de enquadramento do jogo, tamanho das imagens etc.
setVisible(true);
Esse método serve para setar a janela como visível.
Fase
private Image fundo;
ImageIcon referencia = new ImageIcon("res\\fundo.jpg");
fundo = referencia.getImage();
Essas três linhas, servem para colocar a imagem de fundo no jogo.
private Player player;
player = new Player();
player.load();
Essas linhas servem para colocar a nave, que o jogador controla na tela.
private List<Inimigo> inimigo;
inicializaInimigos();
public void inicializaInimigos() {
int coordenadas[] = new int[40];
inimigo = new ArrayList<Inimigo>();
String[] vetor = new String[5];
vetor[0] = "res\\banana.png";
vetor[1] = "res\\bolinha.png";
vetor[2] = "res\\caixa-de-leite.png";
vetor[3] = "res\\latinha.png";
vetor[4] = "res\\maca.png";
for (int i = 0; i < coordenadas.length; i++) {
Random numero = new Random();
int a = numero.nextInt(5);
int x = (int) (Math.random() * 8000 + 1024);
int y = (int) (Math.random() * 650 + 30);
inimigo.add(new Inimigo(x, y, vetor[a]));
Toda essa parte do código, serve para controlar os inimigos. Os inimigos foram
colocados em um vetor, e atribuído um certo valor para cada um, para que assim,
tornasse possível o aparecimento dos inimigos em ordem aleatória para o jogador na
tela.
private Imagenebulosa;
private List<Nebula> nebulas;
ImageIcon iiNebulosa = new ImageIcon("res\\Nebula.png");
nebulosa = iiNebulosa.getImage();
for (int i = 0; i < coordenadas.length; i++) {
int x = (int) (Math.random() * 1050 + 1024);
int y = (int) ((Math.random() * 768) - (Math.random() * 768));
nebulas.add(new Nebula(x, y));
for (int j = 0; j < nebulas.size(); j++) {
Nebula n = nebulas.get(j);
n.load();
graficos.drawImage(n.getImagem(), n.getX(), n.getY(), this);}
for (int p = 0; p < nebulas.size(); p++) {
Nebula on = nebulas.get(p);
if (on.isVisivel()) {
on.update();}
else {
nebulas.remove(p);
}
}
Essa parte do código, é responsável por controlar as nebulosas (as “fumaças” coloridas
que aparecem na tela), elas são iniciadas e colocadas em partes aleatórias da tela
durante o jogo.
checarColisoes();
public void checarColisoes() {
Rectangle formaNave = player.getBounds();
Rectangle formaInimigo1;
Rectangle formaTiro;
for (int i = 0; i < inimigo.size(); i++) {
Inimigo tempInimigo1 = inimigo.get(i);
formaInimigo1 = tempInimigo1.getBounds();
if (formaNave.intersects(formaInimigo1)) {
player.setVisivel(false);
tempInimigo1.setVisivel(false);
JOptionPane.showMessageDialog(null, "Voc� perdeu :(");
int dialogButton = JOptionPane.YES_NO_OPTION;
int dialogResult = JOptionPane.showConfirmDialog(this, "Deseja jogar
novamente?", "Fim de jogo!",
dialogButton);
if (dialogResult == 0) {
JOptionPane.showMessageDialog(null, "Reiniciando...");
inicializaInimigos();
inicializaNebulas();
player = new Player();
player.load();
emJogo = true;
return;}
else {
JOptionPane.showMessageDialog(null, "Encerrando...");
System.exit(0);
emJogo = false;}
Aqui, estamos diante de uma parte bem importante do jogo, que é um método que
serve para checar colisões, assim que o inimigo encosta na nave, o jogador perde o
jogo, e então é mostrada a tela de game over, onde pergunta pro jogador se vai querer
jogar novamente, ou encerrar o jogo.
for (int j = 0; j < tiros.size(); j++) {
Tiro tempTiro = tiros.get(j);
formaTiro = tempTiro.getBounds();
for (int k = 0; k < inimigo.size(); k++) {
Inimigo tempInimigo1 = inimigo.get(k);
formaInimigo1 = tempInimigo1.getBounds();
if (formaTiro.intersects(formaInimigo1)) {
tempInimigo1.setVisivel(false);
tempTiro.setVisivel(false);
}
}
}
Essa parte do código também faz parte do checador de colisões, porém esta, checa a
colisão do tiro que sai da nave, com o inimigo, e caso colidam, destrói o inimigo.
Inimigo
private int x, y;
Essa linha é responsável por gerenciar a posição dos inimigos na tela, por x, sendo a
posição horizontal, e y, a posição vertical deles.
private boolean isVisivel;
Aqui, é setado a visibilidade do inimigo, que quando é true, significa que o inimigo está
ativo na tela, e quando se torna false, ele foi destruído pelo jogador.
private static int VELOCIDADE = 9;
Nessa linha do código, temos uma variável que define a velocidade dos inimigos, que
pode ser facilmente alterada afim de aumentar ou diminuir a dificuldade do jogo.
public Rectangle getBounds() {
return new Rectangle(x, y, largura, altura);
Esse método, é responsável por pegar as dimensões do inimigo e, criar o hitbox, que
diz exatamente onde vai acontecer a colisão, caso a nave encoste no objeto.
Nébula
A criação da nébula foi um método utilizado para animação da interface, de modo que
ela não ficasse tão monótona apenas com a animação do player e seus alvos. Ela não
tem nenhuma função de modificar a jogabilidade, sendo apenas um efeito visual.
Para a criação da mesma, foi elaborado os seguintes passos:
public class Nebula {
private Image imagem;
private int x, y;
private int largura, altura;
private boolean isVisivel;
private static int VELOCIDADE = 1;
Esse trecho de código define os comandos de inserção da imagem da nébula, a
posição onde ela vai surgir na tela e a velocidade em que ela vai percorrer a área do
jogo.
public void load() {
ImageIcon referencia = new ImageIcon("res\\Nebula.png");
imagem = referencia.getImage();
this.largura = imagem.getWidth(null);
this.altura = imagem.getHeight(null);
}
Aqui estamos apontando ao programa qual será a imagem declarada para se tornar a
nossa nébula dentro do jogo, em qual diretório se encontra a imagem.
public void update() {
if(this.x < -(this.largura)) {
this.x = largura;
Random a = new Random();
int m = a.nextInt(500);
this.x = m + 1300;
Random r = new Random();
int n = r.nextInt(700);
this.y = n;
}
else {
this.x -= VELOCIDADE;
}
Aqui, temos como objetivo definir a localização da inicialização da nébula, neste caso,
foi definida um aparecimento randômico da fumaça. Ela aparece em algum ponto da
interface e percorre em linha reta até o outro lado.
Player
A criação do player foi feita com base em pesquisas de como seria a movimentação do
personagem no campo de batalha, como seria o método utilizado para que pudessem
ser disparados os tiros contra os lixos que vinham aleatoriamente do lado oposto do
mesmo.
Para a criação do mesmo, foi elaborado os seguintes passos:
public class Player {
private int x, y;
private int dx, dy;
private Image imagem;
private int altura, largura;
private List <Tiro> tiros;
private boolean isVisivel;
Nesse trecho de código estamos declarando a inserção do nosso player na interface,
as variáveis de movimentação, e os tiros que serão configurados posteriormente.
public Player() {
this.x= 100;
this.y = 700/2;
isVisivel= true;
tiros = new ArrayList<Tiro>();
}
Método construtor para definição de onde será a posição inicial de nosso player.
public void load() {
ImageIcon referencia = new ImageIcon("res\\alien.png");
imagem = referencia.getImage();
altura = imagem.getHeight(null);
largura = imagem.getWidth(null);
}
Apontamento de qual será a imagem utilizada para utilização do player, nesse caso, o
alien.
public void tiroSimples() {
this.tiros.add(new Tiro(x + (largura/2), y + (altura/2)));
}
public Rectangle getBounds() {
return new Rectangle(x, y, largura, altura);
}
Esses trechos de código definem a posição de onde o tiro irá sair da nave (configurado
para sair de modo centralizado) e a colisão do mesmo para com seu alvo.
public void keypressed(KeyEvent tecla) {
int codigo = tecla.getKeyCode();
if(codigo== KeyEvent.VK_A) {
tiroSimples();
}
if(codigo== KeyEvent.VK_UP) {
dy = -3;
}
if(codigo== KeyEvent.VK_DOWN) {
dy = 3;
}
if(codigo== KeyEvent.VK_LEFT) {
dx = -3;
}
if(codigo== KeyEvent.VK_RIGHT) {
dx = 3;
}
}
Aqui configuramos as teclas mais padronizadas para esse tipo de jogo. As setas para
movimentar o player e a tecla de disparo escolhida, que foi a letra ”A”.
public void keyRelease(KeyEvent tecla) {
int codigo = tecla.getKeyCode();
if(codigo== KeyEvent.VK_UP) {
dy = 0;
}
if(codigo== KeyEvent.VK_DOWN) {
dy = 0;
}
if(codigo== KeyEvent.VK_LEFT) {
dx = 0;
}
if(codigo== KeyEvent.VK_RIGHT) {
dx = 0;
}
Aqui configuramos para que caso não haja movimentos definidos pelo jogador, a nave
permaneça parada.
Tiro
A criação do tiro foi projetada para que tivéssemos alguma forma de combater a
poluição ambiental, destruindo os objetos antes que eles pudessem acertar nosso
player, fazendo com que o jogo se encerre caso haja conflito entre a nave e os dejetos.
Para tal feito, definimos a seguinte produção do destrutor de lixos:
public class Tiro {
private Image imagem;
private int x, y;
private int largura, altura;
private boolean isVisivel;
private static final int LARGURA = 1366;
private static int VELOCIDADE = 2;
public Tiro (int x, int y) {
this.x = x;
this.y = y;
isVisivel = true;
}
Definição para inserção da imagem do tiro na tela, a posição de onde ele deverá sair e
percorrer. Caso haja colisão, foi definido para que o tiro suma, afim de não deixar a
impressão falsa de não ter acertado o alvo. A velocidade do tiro foi definida de modo à
não fugir muito da jogabilidade de outros jogos com a mesma performance.
public void load() {
ImageIcon referencia = new ImageIcon("res\\tiro.png");
imagem = referencia.getImage();
this.largura = imagem.getWidth(null);this.altura = imagem.getHeight(null);
}
Aqui temos o apontamento da imagem a ser utilizada como tiro para o programa.
public void update() {
this.x += VELOCIDADE;
if (this.x > LARGURA) {
isVisivel = false;
}
Definição de código para que o tiro desapareça assim que alcançar o limite máximo da
tela.
public Rectangle getBounds() {
return new Rectangle(x, y, largura, altura);
Parte do código que define se houve colisão entre o tiro e o objeto alvo.
RELATÓRIO COM AS LINHAS DE CÓDIGO DO PROGRAMA
Container
package meujogo;
import java.awt.Image;
import java.awt.Toolkit;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import meujogo.modelo.Fase;
public class Container extends JFrame{
public Container (){
add(new Fase());
setTitle("Educacao Ambiental");
ImageIcon icone = new ImageIcon("res\\icone.png");
this.setIconImage(icone.getImage());
setSize(1300,700);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
this.setResizable(false);
setVisible(true);
}
public static void main (String [] args){
new Container();
}
}
Fase
package meujogo.modelo;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
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 java.util.Random;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;
public class Fase extends JPanel implements ActionListener {
private Image fundo;
private Image nebulosa;
private Player player;
private Timer timer;
private List<Inimigo> inimigo;
private List<Nebula> nebulas;
private boolean emJogo;
public Fase() {
TesteInicio();
}
public void TesteInicio() {
setFocusable(true);
setDoubleBuffered(true);
ImageIcon referencia = new ImageIcon("res\\fundo.jpg");
fundo = referencia.getImage();
ImageIcon iiNebulosa = new ImageIcon("res\\Nebula.png");
nebulosa = iiNebulosa.getImage();
player = new Player();
player.load();
addKeyListener(new TecladoAdapter());
timer = new Timer(5, this);
timer.start();
inicializaInimigos();
inicializaNebulas();
emJogo = true;
}
public void inicializaInimigos() {
int coordenadas[] = new int[40];
inimigo = new ArrayList<Inimigo>();
String[] vetor = new String[5];
vetor[0] = "res\\banana.png";
vetor[1] = "res\\bolinha.png";
vetor[2] = "res\\caixa-de-leite.png";
vetor[3] = "res\\latinha.png";
vetor[4] = "res\\maca.png";
for (int i = 0; i < coordenadas.length; i++) {
Random numero = new Random();
int a = numero.nextInt(5);
int x = (int) (Math.random() * 8000 + 1024);
int y = (int) (Math.random() * 650 + 30);
inimigo.add(new Inimigo(x, y, vetor[a]));
}
}
public void inicializaNebulas() {
int coordenadas[] = new int[2];
nebulas = new ArrayList<Nebula>();
for (int i = 0; i < coordenadas.length; i++) {
int x = (int) (Math.random() * 1050 + 1024);
int y = (int) ((Math.random() * 768) - (Math.random() * 768));
nebulas.add(new Nebula(x, y));
}
}
public void paint(Graphics g) {
Graphics2D graficos = (Graphics2D) g;
if (emJogo == true) {
graficos.drawImage(fundo, 0, 0, null);
for (int j = 0; j < nebulas.size(); j++) {
Nebula n = nebulas.get(j);
n.load();
graficos.drawImage(n.getImagem(), n.getX(), n.getY(),
this);
}
List<Tiro> tiros = player.getTiros();
for (int i = 0; i < tiros.size(); i++) {
Tiro m = tiros.get(i);
m.load();
graficos.drawImage(m.getImagem(), m.getX(), m.getY(),
this);
}
graficos.drawImage(player.getImagem(), player.getX(),
player.getY(), this);
for (int o = 0; o < inimigo.size(); o++) {
Inimigo in = inimigo.get(o);
in.load();
graficos.drawImage(in.getImagem(), in.getX(), in.getY(),
this);
}
}
g.dispose();
}
@Override
public void actionPerformed(ActionEvent e) {
player.update();
for (int p = 0; p < nebulas.size(); p++) {
Nebula on = nebulas.get(p);
if (on.isVisivel()) {
on.update();
}
else {
nebulas.remove(p);
}
}
List<Tiro> tiros = player.getTiros();
for (int i = 0; i < tiros.size(); i++) {
Tiro m = tiros.get(i);
if (m.isVisivel()) {
m.update();
} else {
tiros.remove(i);
}
}
for (int o = 0; o < inimigo.size(); o++) {
Inimigo in = inimigo.get(o);
if (in.isVisivel()) {
in.update();
} else {
inimigo.remove(o);
}
}
checarColisoes();
repaint();
}
public void checarColisoes() {
Rectangle formaNave = player.getBounds();
Rectangle formaInimigo1;
Rectangle formaTiro;
for (int i = 0; i < inimigo.size(); i++) {
Inimigo tempInimigo1 = inimigo.get(i);
formaInimigo1 = tempInimigo1.getBounds();
if (formaNave.intersects(formaInimigo1)) {
player.setVisivel(false);
tempInimigo1.setVisivel(false);
JOptionPane.showMessageDialog(null, "Voce perdeu :(");
int dialogButton = JOptionPane.YES_NO_OPTION;
int dialogResult = JOptionPane.showConfirmDialog(this,
"Deseja jogar novamente?", "Fim de jogo!",
dialogButton);
if (dialogResult == 0) {
JOptionPane.showMessageDialog(null,
"Reiniciando...");
inicializaInimigos();
inicializaNebulas();
player = new Player();
player.load();
emJogo = true;
return;
} else {
JOptionPane.showMessageDialog(null,
"Encerrando...");
System.exit(0);
emJogo = false;
}
}
}
List<Tiro> tiros = player.getTiros();
for (int j = 0; j < tiros.size(); j++) {
Tiro tempTiro = tiros.get(j);
formaTiro = tempTiro.getBounds();
for (int k = 0; k < inimigo.size(); k++) {
Inimigo tempInimigo1 = inimigo.get(k);
formaInimigo1 = tempInimigo1.getBounds();
if (formaTiro.intersects(formaInimigo1)) {
tempInimigo1.setVisivel(false);
tempTiro.setVisivel(false);
}
}
}
}
private class TecladoAdapter extends KeyAdapter {
@Override
public void keyPressed(KeyEvent e) {
player.keypressed(e);
}
@Override
public void keyReleased(KeyEvent e) {
player.keyRelease(e);
}
}
}
Inimigo
package meujogo.modelo;
import java.awt.Image;
import java.awt.Rectangle;
import java.util.Random;
import javax.swing.ImageIcon;
public class Inimigo {
private Image imagem;
private int x, y;
private int largura, altura;
private boolean isVisivel;
private static int VELOCIDADE = 2;
public Inimigo (int x, int y, String imagem) {
ImageIcon referencia = new ImageIcon(imagem);
this.imagem = referencia.getImage();
this.x = x;
this.y = y;
isVisivel = true;}
public void load() {
this.largura = imagem.getWidth(null);
this.altura = imagem.getHeight(null);
}
public void update() {
this.x -= VELOCIDADE;
}
public Rectangle getBounds() {
return new Rectangle(x, y, largura, altura);
}
public boolean isVisivel() {
return isVisivel;
}
public void setVisivel(boolean isVisivel) {
this.isVisivel = isVisivel;
}
public static int getVELOCIDADE() {
return VELOCIDADE;
}
public static void setVELOCIDADE(int vELOCIDADE) {
VELOCIDADE = vELOCIDADE;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public Image getImagem() {
return imagem;
}
}
Nébula
package meujogo.modelo;
import java.awt.Image;
import java.awt.Rectangle;
import java.util.Random;
import javax.swing.ImageIcon;
public class Nebula {
private Image imagem;
private int x, y;
private int largura, altura;
private boolean isVisivel;
private static int VELOCIDADE = 1;
public Nebula (int x, int y) {
this.x = x;
this.y = y;
isVisivel = true;
}
public void load() {
ImageIcon referencia = new ImageIcon("res\\Nebula.png");
imagem = referencia.getImage();
this.largura = imagem.getWidth(null);
this.altura = imagem.getHeight(null);
}
public void update() {
if(this.x < -(this.largura)) {
this.x = largura;
Random a = new Random();
int m = a.nextInt(500);
this.x = m + 1300;
Random r = new Random();
int n = r.nextInt(700);
this.y = n;
}
else {
this.x -= VELOCIDADE;
}
}
public boolean isVisivel() {
return isVisivel;
}
public void setVisivel(boolean isVisivel) {
this.isVisivel = isVisivel;
}
public static int getVELOCIDADE() {
return VELOCIDADE;
}
public static void setVELOCIDADE(int vELOCIDADE) {
VELOCIDADE = vELOCIDADE;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public Image getImagem() {
return imagem;
}
}
Playerpackage meujogo.modelo;
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;
public class Player {
private int x, y;
private int dx, dy;
private Image imagem;
private int altura, largura;
private List <Tiro> tiros;
private boolean isVisivel;
public Player() {
this.x= 100;
this.y = 700/2;
isVisivel= true;
tiros = new ArrayList<Tiro>();
}
public void load() {
ImageIcon referencia = new ImageIcon("res\\alien.png");
imagem = referencia.getImage();
altura = imagem.getHeight(null);
largura = imagem.getWidth(null);
}
public void update() {
x += dx;
y += dy;
}
public void tiroSimples() {
this.tiros.add(new Tiro(x + (largura/2), y + (altura/2)));
}
public Rectangle getBounds() {
return new Rectangle(x, y, largura, altura);
}
public void keypressed(KeyEvent tecla) {
int codigo = tecla.getKeyCode();
if(codigo== KeyEvent.VK_A) {
tiroSimples();
}
if(codigo== KeyEvent.VK_UP) {
dy = -3;
}
if(codigo== KeyEvent.VK_DOWN) {
dy = 3;
}
if(codigo== KeyEvent.VK_LEFT) {
dx = -3;
}
if(codigo== KeyEvent.VK_RIGHT) {
dx = 3;
}
}
public void keyRelease(KeyEvent tecla) {
int codigo = tecla.getKeyCode();
if(codigo== KeyEvent.VK_UP) {
dy = 0;
}
if(codigo== KeyEvent.VK_DOWN) {
dy = 0;
}
if(codigo== KeyEvent.VK_LEFT) {
dx = 0;
}
if(codigo== KeyEvent.VK_RIGHT) {
dx = 0;
}
}
public boolean isVisivel() {
return isVisivel;
}
public void setVisivel(boolean isVisivel) {
this.isVisivel = isVisivel;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public Image getImagem() {
return imagem;
}
public List<Tiro> getTiros() {
return tiros;
}
}
Tiro
package meujogo.modelo;
import java.awt.Image;
import java.awt.Rectangle;
import javax.swing.ImageIcon;
public class Tiro {
private Image imagem;
private int x, y;
private int largura, altura;
private boolean isVisivel;
private static final int LARGURA = 1366;
private static int VELOCIDADE = 2;
public Tiro (int x, int y) {
this.x = x;
this.y = y;
isVisivel = true;
}
public void load() {
ImageIcon referencia = new ImageIcon("res\\tiro.png");
imagem = referencia.getImage();
this.largura = imagem.getWidth(null);
this.altura = imagem.getHeight(null);
}
public void update() {
this.x += VELOCIDADE;
if (this.x > LARGURA) {
isVisivel = false;
}
}
public Rectangle getBounds() {
return new Rectangle(x, y, largura, altura);
}
public boolean isVisivel() {
return isVisivel;
}
public void setVisivel(boolean isVisivel) {
this.isVisivel = isVisivel;
}
public static int getVELOCIDADE() {
return VELOCIDADE;
}
public static void setVELOCIDADE(int vELOCIDADE) {
VELOCIDADE = vELOCIDADE;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public Image getImagem() {
return imagem;
}
}
REFERÊNCIAS
AMARO, D. 97% do lixo produzido no Brasil não é reciclado. Disponível em:
http://edicaodobrasil.com.br/2020/01/31/97-do-lixo-produzido-no-brasil-nao-e-reciclado.
Acesso em: 25 maio 2020.
Blog eCycle. Reciclagem: o que é e qual a importância. Disponível em:
https://www.ecycle.com.br/2046-reciclagem. Acesso em: 23 maio 2020.
Blog Ambiente Brasil. Reciclagem. Disponível em:
https://ambientes.ambientebrasil.com.br/residuos/reciclagem/reciclagem.html. Acesso
em: 23 maio 2020.
Mation. JOGO 2D JAVA. Disponível em:
https://www.youtube.com/playlist?list=PLlW3qrNjsvBwUmUk9kio7bNT3GR554FH5.
Acesso em: 15 maio 2020.
Rodrigues, R. Lixo Espacial. Disponível em:
https://brasilescola.uol.com.br/geografia/lixo-espacial.htm. Acesso em: 25 maio 2020.
http://edicaodobrasil.com.br/2020/01/31/97-do-lixo-produzido-no-brasil-nao-e-reciclado/
https://www.ecycle.com.br/2046-reciclagem
https://ambientes.ambientebrasil.com.br/residuos/reciclagem/reciclagem.html
https://www.youtube.com/playlist?list=PLlW3qrNjsvBwUmUk9kio7bNT3GR554FH5
https://brasilescola.uol.com.br/geografia/lixo-espacial.htm
Wikipédia. Jogo eletrônico de tiro. Disponível em:
https://pt.m.wikipedia.org/wiki/Jogo_eletr%C3%B4nico_de_tiro. Acesso em: 27 maio 2020.
Wikipédia. Shoot 'em up. Disponível em: https://pt.m.wikipedia.org/wiki/Shoot_%27em_up.
Acesso em: 27 maio 2020.
Wikipédia. Asteroids. Disponível em: https://pt.m.wikipedia.org/wiki/Asteroids. Acesso em: 27
maio 2020.
Wikipédia. Atari. Disponível em: https://pt.m.wikipedia.org/wiki/Atari. Acesso em: 27 maio
2020.
Wikipédia. Aero Fighters. Disponível em: https://pt.m.wikipedia.org/wiki/Aero_Fighters.
Acesso em: 27 maio 2020.
https://pt.m.wikipedia.org/wiki/Jogo_eletr%F4nico_de_tiro
https://pt.m.wikipedia.org/wiki/Shoot_'em_up
https://pt.m.wikipedia.org/wiki/Asteroids
https://pt.m.wikipedia.org/wiki/Atari
https://pt.m.wikipedia.org/wiki/Aero_Fighters