Labs Jogos Java

LABS.DGTI: JOGOS EM JAVA
DESENVOLVIMENTO DE JOGOS EM JAVA 2D.

MINILABS: JOGOS EM JAVA
MARIO JORGE PEREIRA
▸ Desde 2002 desenvolvendo com softwares
com Java. Certiﬁcado de Programador Java
(SCJP) em 2005. Desenvolvimento JSE, JEE e
JME.
▸ Atualmente Analista de Tecnologia da
Informação (IFBaiano), Docente (UCSal) e
Artesão de Software (Dev)

AGENDA
▸ Conceitos Básicos
▸ Animação
▸ Sprites
▸ Colisões

"A GAME IS A SYSTEM IN WHICH PLAYERS
ENGAGE IN AN ARTIFICIAL
CONFLICT, DEFINED BY RULES, THAT RESULTS
IN A QUANTIFIABLE OUTCOME.
Salen e Zimmerman (Rules of play, 2004)

GAME LOOP
CARREGAR
LOAD
ENTRADAS
INPUTS
ATUALIZAR
UPDATE
APRESENTAR
RENDER
DESCARREGAR
UNLOAD

SWING
▸ conjunto de componentes para a construção de
interfaces gráﬁcas de usuário (GUIs)
▸ funcionalidade gráﬁcos ricos e interatividade
aos aplicativos Java.
▸ Os componentes Swing são implementados
inteiramente na linguagem de programação
Java.

COMPONENTES E CONTAINERS
▸ JFrame
▸ JPanel
▸ JButtons
▸ JLabel
▸ JTable

Jogo.java
import javax.swing.JPanel;
public class Jogo extends JPanel {
public Jogo() {
}
}

Aplicacao.java
import java.awt.EventQueue;
import javax.swing.JFrame;
public class Principal extends JFrame {
public Principal() {
initUI();
}
private void initUI() {...}
public static void main(String[] args) {...}
}

MÉTODOS BÁSICOS
▸ add(new Jogo());
▸ Adiciona o local do jogo / tabuleiro
▸ setSize(300, 300);
▸ Deﬁne o tamanho da Janela
▸ setTitle(“Aplicação");
▸ Titulo da Janela
▸ setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
▸ Deﬁne que ao clicar no botão fechar da janela ele vai fechar a aplicação.
▸ setLocationRelativeTo(null);
▸ Faz com que a aplicação inicie no centro da tela

Application.java
private void initUI() {
add(new Jogo());
setSize(300, 300);
setTitle("Aplicação");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
}

SWING VS. THREAD-SAFE
▸ A api Swing não é thread-safe
▸ Event-Dispatch Thread (EDT)
▸ SwingUtilities.invokeLater(Runnable) ou EventQueue.invokeLater(Runnable)
▸ Recomendação: Java 5

Application.java
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
Aplicacao ex = new Aplicacao();
ex.setVisible(true);
}
});
}

DESENHANDO
▸ void paintComponent(Graphics g) {…}
▸ Método que desenha o componentes

Jogo.java
import java.awt.*;
import java.awt.geom.*;
import javax.swing.JPanel;
import static java.awt.RenderingHints.*;
public void paintComponent(Graphics g) {...}
private void desenhar(Graphics g) {...}
}

Jogo.java
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
desenhar(g);
}

DESENHANDO
▸ Graphics2D
▸ RenderingHints
▸ Dimension
▸ Ellipse2D
▸ AfﬁneTransform

Jogo.java (basico)
private void desenhar(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
Dimension size = getSize();
double w = size.getWidth();
double h = size.getHeight();
Ellipse2D e = new Ellipse2D.Double(0, 0, 80, 130);
for (double deg = 0; deg < 360; deg += 5) {
AffineTransform at = AffineTransform.getTranslateInstance(w / 2, h / 2);
at.rotate(Math.toRadians(deg));
g2d.draw(at.createTransformedShape(e));
}
}

Jogo.java (com perfumaria)
RenderingHints rh = new RenderingHints(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON);
rh.put(KEY_RENDERING, VALUE_RENDER_QUALITY);
g2d.setRenderingHints(rh);
Dimension size = getSize();
double w = size.getWidth();
double h = size.getHeight();
Ellipse2D e = new Ellipse2D.Double(0, 0, 80, 130);
g2d.setStroke(new BasicStroke(1));
g2d.setColor(Color.gray);
for (double deg = 0; deg < 360; deg += 5) {
AffineTransform at = AffineTransform.getTranslateInstance(w / 2, h / 2);
at.rotate(Math.toRadians(deg));
g2d.draw(at.createTransformedShape(e));
}
}

Jogo.java
import java.awt.*;
import javax.swing.*;
private Image imagem;
public Jogo() {
initJogo();
}
private void initJogo() {...}
private void carregaImagem() {...}
public void paintComponent(Graphics g) {…}
}

Jogo.java
private void initJogo() {
carregaImagem();
int w = imagem.getWidth(this);
int h = imagem.getHeight(this);
setPreferredSize(new Dimension(w, h));
}

CARREGANDO IMAGEM
▸ Image imagem
▸ ImageIcon imageIcon
▸ g.drawImage(imagem, 0, 0, null);

Jogo.java
private void carregaImagem() {
ImageIcon ii = new ImageIcon(getClass().getResource("salvador.png"));
imagem = ii.getImage();
}
@Override
desenhar(g);
}
g.drawImage(imagem, 0, 0, null);
}

Aplicacao.java
private void initUI() {
add(new Jogo());
pack();
setTitle("Aplicação");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLocationRelativeTo(null);
}

PROCESSOS E THREADS
▸ Processo
▸ ambiente de execução auto-suﬁciente.
▸ cada processo tem seu próprio espaço de
memória.
▸ Thread
▸ processos leves.
▸ criação de um novo segmento requer menos
recursos do que a criação de um novo
processo.

THREADS

REDIMENSIONAMENTO
▸ setResizable ()
▸ deﬁne se o JFrame pode ser redimensionado.
▸ pack()
▸ redimensiona o JFrame para ajustar ao tamanho ideal.
▸ Note que a ordem pela qual estes dois métodos são chamados é importante.

Jogo.java
import java.awt.*;
import java.awt.event.*;
public class Jogo extends JPanel implements ActionListener {
private final int B_WIDTH = 350;
private final int B_HEIGHT = 350;
private final int INITIAL_X = -40;
private final int INITIAL_Y = -40;
private final int DELAY = 25;
private Image imagem;
private Timer timer;
private int x, y;
...
}

Jogo.java
public Jogo() {...}
private void carregaImagem() {...}
private void initJogo() {...}
public void paintComponent(Graphics g) {...}
public void actionPerformed(ActionEvent e) {...}
}

Jogo.java
public Jogo() {
initJogo();
}
private void carregaImagem() {
ImageIcon ii = new ImageIcon("estrela.png");
imagem = ii.getImage();
}

DOUBLEBUFFER
▸ setDoubleBuffered(true);
▸ O componente JPanel vai usar um Buffer para apresentar.
▸ Signiﬁca que todos os desenhos serão feitos na memória primeiro.
▸ O buffer fora da tela será copiado para a tela.

Jogo.java
setBackground(Color.BLACK);
setPreferredSize(new Dimension(B_WIDTH, B_HEIGHT));
setDoubleBuffered(true);
carregaImagem();
x = INITIAL_X;
y = INITIAL_Y;
timer = new Timer(DELAY, this);
timer.start();
}

TIMER
▸ timer = new Timer(DELAY, this);
▸ timer.start();
▸ TimerSwing e chamar o método start ().
▸ A cada ciclo (DELAY) de tempo o temporizador irá chamar o método
actionPerformed().
▸ Para utilizar o método actionPerformed (), que deve implementar a
interface ActionListener.

TOOLKIT.GETDEFAULTTOOLKIT
▸ no desenhar() chamamos a imagem na janela utilizando o método
drawImage().
▸ o Toolkit.getDefaultToolkit (). Sync ()
▸ sincroniza a parte gráﬁca
▸ protege os eventos gráﬁcos
▸ Sem essa linha, a animação pode não ser suave no Linux.

Jogo.java
@Override
desenhar(g);
}
g.drawImage(imagem, x, y, this);
Toolkit.getDefaultToolkit().sync();
}

ACTION PERFORMED
▸ actionPerformed()
▸ é chamado pelo timer repetidamente
▸ Dentro do método, alteramos os valores x e y do objeto estrela
▸ repaint ()
▸ Faz com que o método paintComponent () seja chamado

Jogo.java
@Override
public void actionPerformed(ActionEvent e) {
x += 1;
y += 1;
if (y > B_HEIGHT) {
y = INITIAL_Y;
x = INITIAL_X;
}
repaint();
}

Jogo.java
import java.awt.*;
import java.util.TimerTask;
import java.util.Timer;
private final int INITIAL_DELAY = 100;
private final int PERIOD_INTERVAL = 25;
private Image star;
private int x, y;
...
}

UTILITY TIMER
▸ Usamos o java.util.Timer em vez do javax.Swing.Timer
▸ Para os jogos Java Swing desta forma deve ser mais preciso
▸ timer = new Timer();
▸ timer.scheduleAtFixedRate(new ScheduleTask(), INITIAL_DELAY, PERIOD_INTERVAL);
▸ executa o metodo run do ScheduleTask a cada intervalo

Jogo.java
carregaImagem();
x = INITIAL_X;
y = INITIAL_Y;
timer = new Timer();
timer.scheduleAtFixedRate(new ScheduleTask(), INITIAL_DELAY, PERIOD_INTERVAL);
}

Jogo.java
private class Tarefa extends TimerTask {
@Override
public void run() {
x += 1;
y += 1;
if (y > B_HEIGHT) {
y = INITIAL_Y;
x = INITIAL_X;
}
repaint();
}
}

Jogo.java
import java.awt.*;
public class Jogo extends JPanel implements Runnable {
private Image star;
private Thread thread;
private int x, y;
...
}

THREAD
▸ O método run () é chamado apenas uma vez.
▸ loop chamamos de cycle() and the repaint()
▸ addNotify()
▸ executado após o JPanel foi adicionado ao componente JFrame.
▸ Este método é muitas vezes usado para diversas tarefas de inicialização.

Jogo.java
@Override
public void addNotify() {
super.addNotify();
thread = new Thread(this);
thread.start();
}
private void ciclo() {
x += 1;
y += 1;
if (y > B_HEIGHT) {
y = INITIAL_Y;
x = INITIAL_X;
}
}

Jogo.java
@Override
public void run() {
long beforeTime, timeDiff, sleep;
beforeTime = System.currentTimeMillis();
while (true) {
ciclo();
repaint();
timeDiff = System.currentTimeMillis() - beforeTime;
sleep = DELAY - timeDiff;
if (sleep < 0) {
sleep = 2;
}
try {
Thread.sleep(sleep);
} catch (InterruptedException e) {
System.out.println("Interrupted: " + e.getMessage());
}
beforeTime = System.currentTimeMillis();
}
}

Aplicacao.java (Sem mudanças)
import java.awt.EventQueue;
import javax.swing.JFrame;
public class Aplicacao extends JFrame {
private static final long serialVersionUID = 1L;
public Aplicacao() {
initUI();
}
private void initUI() {...}
public static void main(String[] args) {...}
}

Jogo.java
import java.awt.*;
private Nave nave;
public Jogo() {
initJogo();
}
...
}

Jogo.java
addKeyListener(new TAdapter());
setFocusable(true);
nave = new Nave();
timer.start();
}

Jogo.java
@Override
desenhar(g);
}
g2d.drawImage(nave.getImage(), nave.getX(), nave.getY(), this);
}

Jogo.java
@Override
nave.move();
repaint();
}
private class TAdapter extends KeyAdapter {
@Override
public void keyReleased(KeyEvent e) {
nave.keyReleased(e);
}
@Override
public void keyPressed(KeyEvent e) {
nave.keyPressed(e);
}
}

Nave.java
import java.awt.Image;
import java.awt.event.KeyEvent;
import javax.swing.ImageIcon;
public class Nave {
private int dx;
private int dy;
private int x;
private int y;
private Image image;
public Nave() {
initNave();
}
...
}

Nave.java
private void initNave() {
ImageIcon ii = new ImageIcon("nave.png");
image = ii.getImage();
x = 40;
y = 60;
}
public void move() {
x += dx;
y += dy;
}
public int getX() { return x; }
public int getY() { return y; }
public Image getImage() { return image; }

Nave.java
int key = e.getKeyCode();
if (key == KeyEvent.VK_LEFT) {
dx = -1;
}
if (key == KeyEvent.VK_RIGHT) {
dx = 1;
}
if (key == KeyEvent.VK_UP) {
dy = -1;
}
if (key == KeyEvent.VK_DOWN) {
dy = 1;
}
}

Nave.java
dx = 0;
}
dx = 0;
}
dy = 0;
}
dy = 0;
}
}

Jogo.java
import java.awt.*;
import java.util.*;
private final int ICRAFT_X = 40;
private final int ICRAFT_Y = 60;
private Nave nave;
public Jogo() {
initJogo();
}
...
}

Jogo.java
setFocusable(true);
nave = new Nave(ICRAFT_X, ICRAFT_Y);
timer.start();
}

Jogo.java
g2d.drawImage(nave.getImage(), nave.getX(), nave.getY(), this);
ArrayList<?> ms = nave.getMissiles();
for (Object m1 : ms) {
Missil m = (Missil) m1;
g2d.drawImage(m.getImage(), m.getX(), m.getY(), this);
}
}

Jogo.java
@Override
updateMissiles();
updateCraft();
repaint();
}

Jogo.java
private void updateMissiles() {
ArrayList<?> ms = nave.getMissiles();
for (int i = 0; i < ms.size(); i++) {
Missil m = (Missil) ms.get(i);
if (m.isVisible()) {
m.move();
} else {
ms.remove(i);
}
}
}

Jogo.java
private void updateCraft() {
nave.move();
}
@Override
}
@Override
nave.keyPressed(e);
}
}

Sprite.java
import java.awt.Image;
import javax.swing.ImageIcon;
public class Sprite {
protected int x;
protected int y;
protected int width;
protected int height;
protected boolean vis;
protected Image image;
public Sprite(int x, int y) {
this.x = x;
this.y = y;
vis = true;
}
...
}

Sprite.java
protected void carregarImagem(String imageName) {
ImageIcon ii = new ImageIcon(imageName);
image = ii.getImage();
}
protected void getImageDimensions() {
width = image.getWidth(null);
height = image.getHeight(null);
}

Sprite.java
public Image getImage() {
return image;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public boolean isVisible() {
return vis;
}
public void setVisible(Boolean visible) {
vis = visible;
}

Missil.java
public class Missil extends Sprite {
private final int BOARD_WIDTH = 390;
private final int MISSILE_SPEED = 2;
public Missil(int x, int y) {
super(x, y);
initMissil();
}
private void initMissil() {
carrregarImagem("missil.png");
getImageDimensions();
}
x += MISSILE_SPEED;
if (x > BOARD_WIDTH) {
vis = false;
}
}
}

Nave.java
import java.awt.event.KeyEvent;
import java.util.ArrayList;
public class Nave extends Sprite {
private int dx;
private int dy;
private ArrayList<Missil> missiles;
public Nave(int x, int y) {
super(x, y);
initNave();
}
...
}

Nave.java
private void initNave() {
missiles = new ArrayList<Missil>();
carrregarImagem("nave.png");
}
x += dx;
y += dy;
}

Nave.java
public ArrayList<Missil> getMissiles() {
return missiles;
}
public void atira() {
missiles.add(new Missil(x + width, y + height / 2));
}

Nave.java
if (key == KeyEvent.VK_SPACE) {
atira();
}
dx = -1;
}
dx = 1;
}
dy = -1;
}
dy = 1;
}
}

Inimigo.java
public class Inimigo extends Sprite {
private final int INITIAL_X = 400;
public Inimigo(int x, int y) {
super(x, y);
initInimigo();
}
private void initInimigo() {
carregaImagem("alien.png");
}
if (x < 0) {
x = INITIAL_X;
}
x -= 1;
}
}

Sprite.java
public Rectangle getBounds() {
return new Rectangle(x, y, width, height);
}

Jogo.java
import java.awt.*;
import java.util.ArrayList;
private Nave nave;
private ArrayList<Inimigo> aliens;
private boolean ingame;
private final int ICRAFT_X = 40;
private final int ICRAFT_Y = 60;
...
}

Jogo.java
private final int[][] pos = {
{2380, 29}, {2500, 59}, {1380, 89},
{780, 109}, {580, 139}, {680, 239},
{790, 259}, {760, 50}, {790, 150},
{980, 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}
};

Jogo.java
public Jogo() {
initJogo();
}
setFocusable(true);
ingame = true;
nave = new Nave(ICRAFT_X, ICRAFT_Y);
initAliens();
timer.start();
}

Jogo.java
public void initAliens() {
aliens = new ArrayList<>();
for (int[] p : pos) {
aliens.add(new Inimigo(p[0], p[1]));
}
}

Jogo.java
@Override
if (ingame) {
drawObjects(g);
} else {
drawGameOver(g);
}
}

Jogo.java
private void drawObjects(Graphics g) {
if (nave.isVisible()) {
g.drawImage(nave.getImage(), nave.getX(), nave.getY(),
this);
}
ArrayList<Missil> ms = nave.getMissiles();
for (Missil m : ms) {
g.drawImage(m.getImage(), m.getX(), m.getY(), this);
}
}
for (Inimigo a : aliens) {
if (a.isVisible()) {
g.drawImage(a.getImage(), a.getX(), a.getY(), this);
}
}
g.setColor(Color.WHITE);
g.drawString("Inimigos restantes: " + aliens.size(), 5, 15);
}

Jogo.java
private void drawGameOver(Graphics g) {
String msg = "Game Over";
Font small = new Font("Helvetica", Font.BOLD, 14);
FontMetrics fm = getFontMetrics(small);
g.setColor(Color.white);
g.setFont(small);
g.drawString(msg, (B_WIDTH - fm.stringWidth(msg)) / 2, B_HEIGHT / 2);
}

Jogo.java
@Override
inGame();
updateNave();
updateMissils();
updateInimigo();
checkCollisions();
repaint();
}

Jogo.java
private void inGame() {
if (!ingame) {
timer.stop();
}
}
private void updateNave() {
if (nave.isVisible()) {
nave.move();
}
}

Jogo.java
private void updateMissils() {
for (int i = 0; i < ms.size(); i++) {
Missil m = ms.get(i);
m.move();
} else {
ms.remove(i);
}
}
}

Jogo.java
private void updateInimigos() {
if (aliens.isEmpty()) {
ingame = false;
return;
}
for (int i = 0; i < aliens.size(); i++) {
Inimigo a = aliens.get(i);
if (a.isVisible()) {
a.move();
} else {
aliens.remove(i);
}
}
}

Jogo.java
public void checkCollisions() {
Rectangle r3 = nave.getBounds();
for (Inimigo alien : aliens) {
Rectangle r2 = alien.getBounds();
if (r3.intersects(r2)) {
nave.setVisible(false);
alien.setVisible(false);
ingame = false;
}
}
for (Missil m : ms) {
Rectangle r1 = m.getBounds();
for (Inimigo alien : aliens) {
Rectangle r2 = alien.getBounds();
if (r1.intersects(r2)) {
m.setVisible(false);
alien.setVisible(false);
}
}
}
}

Jogo.java
@Override
}
@Override
nave.keyPressed(e);
}
}

REFERENCIAS
▸ http://www.javaworld.com/article/2077754/core-java/swing-threading-and-
the-event-dispatch-thread.html
▸ http://www.oracle.com/technetwork/articles/java/index-jsp-135444.html
▸ http://zetcode.com
▸ Salen. Katie; Zimmerman, Eric. Rules of Play: Game Design Fundamentals. MIT
PRESS, 2004

Labs Jogos Java

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (7)

Semelhante a Labs Jogos Java

Semelhante a Labs Jogos Java (20)

Mais de Mario Jorge Pereira

Mais de Mario Jorge Pereira (18)

Labs Jogos Java