Olá pessoal!
No tutorial de hoje iremos ver uma maneira de como testar uma colisão
simples entre dois objetos! existe várias formas de testar uma colisão
como: verificar se o objeto tocou a extremidade do outro, verificar se
eles estão se intersectando, ou se ambos tem a mesma coordenada X e , e
após constatar a colisão iremos dizer como esses objetos irão se
comportar durante a colisão!
Vamos ver uma maneira de verificar essas colisões com um único método! então vamos lá! crie um pacote chamado
tutorial10 no nosso projeto
JAVAGAMES2D, e cole no pacote o nosso template pra jogos
Game.java!
Agora observe o código abaixo (leita atentamente os comentários no código):
1: import java.awt.*;
2: import java.awt.image.BufferedImage;
3: import java.io.File;
4: import javax.swing.ImageIcon;
5: import javax.swing.JFrame;
6: public class Game extends JFrame {
7: BufferedImage backBuffer;
8: int FPS = 30;
9: int janelaW = 500;
10: int janelaH = 500;
11: // --------------------------------------------------------------------
12: // OBSERVEM ESSAS VÁRIÁVEIS (ISSO PODERIA SER ATRIBUTOS DE UMA CLASSE!)
13: // --------------------------------------------------------------------
14: int obj1X = 0; // COORDENADA X
15: int obj1Y = 225; // COORDENADA Y
16: int obj1W = 50; // LARGURA = Width
17: int obj1H = 50; // ALTURA = Height
18: boolean objeto1Colediu = false;
19: int obj2X = 400;
20: int obj2Y = 200;
21: int obj2W = 50;
22: int obj2H = 50;
23: // --------------------------------------------------------------------
24: // ESSE MÉTODO VAI MOVER O OBJETO ATÉ A COORDENADA X = 390
25: // PARA QUE ELE TOQUE O OBJETO 2
26: // MAS NÃO IMPORTA COMO ELE SE MOVA, UM MÉTODO VAI TRATAR DE
27: // VERIFICAR SE OUVE COLISÃO OU NÃO!
28: // --------------------------------------------------------------------
29: public void moveObjeto1() {
30: obj1X += 2;
31: if (obj1X > 500) {
32: obj1X = 0;
33: }
34: }
35: // --------------------------------------------------------------------
36: // SE O OBJETO COLEDIR APARECERÁ UM TEXTO INFORMANDO!!!
37: // ESSE MÉTODO VAI SER CHAMANDO LÁ NO DENTRO DO MÉTODO desenharGraficos()
38: // --------------------------------------------------------------------
39: public void exibeTexto() {
40: Graphics bbg = backBuffer.getGraphics();
41: if (objeto1Colediu) {
42: bbg.setColor(Color.RED);
43: bbg.drawString("UIII fui tocado!!!", 200, 100);
44: }
45: }
46: // --------------------------------------------------------------------
47: // ESSE É O NOSSO MÉTODO QUE VAI TRATAR A COLISÃO
48: // ESSE MÉTODO RECEBE COMO ARGUMENTO: X, Y, W, H do Obj1 e Obj2
49: // NÃO SE PREOCUPE NOS VAMOS EXPLICAR ESSA LAVAGEM DE CÓDIGO!!!
50: // --------------------------------------------------------------------
51: public boolean colisao(int obj1X, int obj1Y, int obj1W, int obj1H,
52: int obj2X, int obj2Y, int obj2W, int obj2H) {
53: if ((obj1X >= obj2X && obj1X <= obj2X + obj2W)
54: && (obj1Y >= obj2Y && obj1Y <= obj2Y + obj2H)) {
55: return true;
56: } else if ((obj1X + obj1W >= obj2X && obj1X + obj1W <= obj2X + obj2W)
57: && (obj1Y >= obj2Y && obj1Y <= obj2Y + obj2H)) {
58: return true;
59: } else if ((obj1X >= obj2X && obj1X <= obj2X + obj2W)
60: && (obj1Y + obj1H >= obj2Y && obj1Y + obj1H <= obj2Y + obj2H)) {
61: return true;
62: } else if ((obj1X + obj1W >= obj2X && obj1X + obj1W <= obj2X + obj2W)
63: && (obj1Y + obj1H >= obj2Y && obj1Y + obj1H <= obj2Y + obj2H)) {
64: return true;
65: } else {
66: return false;
67: }
68: }
69: // --------------------------------------------------------------------
70: public void atualizar() {
71: objeto1Colediu = colisao(obj1X, obj1Y, obj1W, obj1H, obj2X, obj2Y,
72: obj2W, obj2H);
73: moveObjeto1();
74: }
75: public void desenharGraficos() {
76: Graphics g = getGraphics(); // ISSO JÁ ESTAVA AQUI
77: Graphics bbg = backBuffer.getGraphics();// ISSO TAMBÉM JÁ ESTAVA AQUI...
78: // ==================================================================================
79: bbg.setColor(Color.WHITE);
80: bbg.fillRect(0, 0, janelaW, janelaH);// DESENHA UM FUNDO BRANCO NA TELA!
81: // EXIBE UM TEXTO CASO O OBJETO COLIDA!
82: exibeTexto();
83: // DESENHA O OBJETO 2
84: bbg.setColor(Color.BLUE);
85: bbg.fillRect(obj2X, obj2Y, obj2W, obj2H);
86: // DESENHA O OBJETO 1 //com transparência
87: // new Color(red,green, blue, alpha) o alpha é o valor da trasnparência
88: // vai de 0 à 255
89: bbg.setColor(new Color(0, 255, 0, 200));
90: bbg.fillRect(obj1X, obj1Y, obj1W, obj1H);
91: // ==================================================================================
92: g.drawImage(backBuffer, 0, 0, this);// OBS: ISSO DEVE FICAR SEMPRE NO
93: // FINAL!
94: }
95: public void inicializar() {
96: setTitle("Tutorial 10 Colisão simples!");
97: setSize(janelaW, janelaH);
98: setResizable(false);
99: setDefaultCloseOperation(EXIT_ON_CLOSE);
100: setLayout(null);
101: setVisible(true);
102: backBuffer = new BufferedImage(janelaW, janelaH,
103: BufferedImage.TYPE_INT_RGB);
104: }
105: public void run() {
106: inicializar();
107: while (true) {
108: atualizar();
109: desenharGraficos();
110: try {
111: Thread.sleep(1000 / FPS);
112: } catch (Exception e) {
113: System.out.println("Thread interrompida!");
114: }
115: }
116: }
117: public static void main(String[] args) {
118: Game game = new Game();
119: game.run();
120: }
121: }
Muito bem... Agora vamos entender o método colisão que é o que está menos comentado no nosso código acima....
Observe a seguinte imagem:
Muito bem... temos um quadrado, e nesse quadrado temos quatro pontos
(marcado de vermelho), cada ponto possui uma coordenada X e Y,
conhecendo apenas as coordenadas e dimensões do nosso quadrado é
possível deduzir as coordenadas de cada um desses quatro pontos, como
mostra o circulo laranja... "blz... entendi... o que devemos fazer
agora...?"
agora vamos verificar se cada um desses pontos está invadindo a área de outro objeto (quadrado...)
Observe a imagem abaixo:
Para verificar se cada ponto do Objeto1 está dentro do Objeto2, temos
que fazer algumas verificações como mostra o circulo laranja, Observe o
nosso ponto P, as coordenadas X do nosso ponto P em relação ao
Objeto2 tem que ser: X de P >= X do Objeto 2 e ao mesmo tempo o X de P
<= X+largura do Objeto 2 ..... E ao mesmo tempo Y de P >= Y do
Objeto 2 e ao mesmo tempo o Y de P <= Y+altura do Objeto 2.
Então essas condições tem que ser verificadas para cada um dos nossos
pontos 1, 2, 3 e 4! Observe novamente o nosso método colisao()
1: public boolean colisao(int obj1X, int obj1Y, int obj1W, int obj1H,
2: int obj2X, int obj2Y, int obj2W, int obj2H) {
3: if ((obj1X >= obj2X && obj1X <= obj2X + obj2W)
4: && (obj1Y >= obj2Y && obj1Y <= obj2Y + obj2H)) {
5: return true;
6: } else if ((obj1X + obj1W >= obj2X && obj1X + obj1W <= obj2X + obj2W)
7: && (obj1Y >= obj2Y && obj1Y <= obj2Y + obj2H)) {
8: return true;
9: } else if ((obj1X >= obj2X && obj1X <= obj2X + obj2W)
10: && (obj1Y + obj1H >= obj2Y && obj1Y + obj1H <= obj2Y + obj2H)) {
11: return true;
12: } else if ((obj1X + obj1W >= obj2X && obj1X + obj1W <= obj2X + obj2W)
13: && (obj1Y + obj1H >= obj2Y && obj1Y + obj1H <= obj2Y + obj2H)) {
14: return true;
15: } else {
16: return false;
17: }
18: }
Então perceba que se um dos nossos pontos invadir o outro objeto, o nosso método irá retornar
TRUE
Observe também que o nosso método foi chamado dentro do método
atualizar, então estará sendo verificado o tempo inteiro se está havendo
colisão ou não, caso haja uma colisão o nosso método retorna TRUE caso
não retorna FALSE. esse valor será retornado para uma variável, caso ela
receba true, um texto será exibido na tela!!!
(Estudem o código atentamente!!!)
Observem como ficou o meu:
Até o nosso próximo tutorial!!!
