JAVA GAMES 2D::Colisão II::11

Olá pessoal!

No tutorial anterior vimos uma maneira de como verificar uma colisão simples. Nesse tutorial de hoje veremos uma outra forma de verificar se um objeto colidiu com outro, no método anterior não era apenas informado de que houve uma colisão, mas não era informado de qual lado do objeto que estava sendo colidido! Então sabendo qual lado do objeto está sendo tocado, é possível mandar o nosso objeto se comportar de uma maneira dependendo de onde ele foi tocado. Imagine um jogo de Corrida de Carros, caso o carro bata a sua lateral numa parede na pista, ele deve ser empurrado na direção oposta!

Muito bem.... então vamos ao que interessa: como é essa tal técnica? (ah lembrando que: o que tá sendo postado aqui, não são técnicas oficiais padrão! é a forma como eu faço e acho mais simples e funciona! pode ser feito diversas maneiras diferente! essa é epenas uma mera sugestão!)

A técnica é a seguinte: como no tutorial anterior nos iremos traçar os pontos(pontos imaginários... tá lá mais não tá!!!) de colisão no nosso objeto, ah! você pode traçar quantos pontos de colisão você quiser! dependendo do que se pretende fazer! ao ao colidir com com determinado ponto nosso objeto pode se comportar de uma maneira diferente!

Observe a imagem abaixo (ah! essas imagens são produzidas no Inkscape! sugiro estuda-las para usar na confecção do design dos seus games!)

Agora observe como o nosso código de colisão é simples, ele irá tratar de verificar a colisão de um único ponto!

?

1 2 3 4 5 6 7

public boolean colisao(int pontoX, int pontoY, int x, int y, int w, int h) {   if ((pontoX >= x && pontoX <= x + w) && (pontoY >= y && pontoY <= y + h)) {    return true;   } else {    return false;   }  }

Esse método trada de verificar a colisão de um único ponto!, etão você pode traçar quantos pontos imaginários quiser e verificar se o mesmo está colidindo em algum objeto!
colisao(x, y, x2, y2, w, h);

Abaixo segue o nosso exemplo do tutorial de hoje:

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 colidiuEsquerda = false;  
19:   boolean colidiuDireita = false;  
20:   boolean colidiuCima = false;  
21:   boolean colidiuBaixo = false;  
22:   int obj2X = 400;  
23:   int obj2Y = 200;  
24:   int obj2W = 50;  
25:   int obj2H = 50;  
26:   // --------------------------------------------------------------------  
27:   // ESSE MÉTODO VAI MOVER O OBJETO ATÉ A COORDENADA X = 500  
28:   // PARA QUE ELE TOQUE O OBJETO 2  
29:   // E A CADA VEZ QUE ELE CHEGAR NO FINAL DA TELA, VOLTA PRA O COMEÇO  
30:   // EM COM UMA NOVA COORDENADA Y ALEATÓRIA!!!  
31:   // --------------------------------------------------------------------  
32:   public void moveObjeto1() {  
33:   obj1X += 5;  
34:   if (obj1X > 500) {  
35:    obj1X = 0;  
36:    obj1Y = (int)(Math.random()*100)+150;  
37:   }  
38:   }  
39:   // --------------------------------------------------------------------  
40:   // SE O OBJETO COLEDIR EM UM DOS PONTOS, EXIBIRÁ UM TEXTO DIZENDO QUAL FOI TOCADO  
41:   // ESSE MÉTODO VAI SER CHAMANDO LÁ NO DENTRO DO MÉTODO desenharGraficos()  
42:   // --------------------------------------------------------------------  
43:   public void exibeTexto() {  
44:   Graphics bbg = backBuffer.getGraphics();  
45:   bbg.setColor(Color.RED);  
46:   if (colidiuEsquerda) {  
47:    bbg.drawString("COLISÃO: ESQUERDA!!!", 200, 110);  
48:   }  
49:   if (colidiuDireita) {  
50:    bbg.drawString("COLISÃO: DIREITA!!!", 200, 120);  
51:   }  
52:   if (colidiuCima) {  
53:    bbg.drawString("COLISÃO: CIMA!!!", 200, 130);  
54:   }  
55:   if (colidiuBaixo) {  
56:    bbg.drawString("COLISÃO: BAIXO!!!", 200, 140);  
57:   }  
58:   }  
59:   // --------------------------------------------------------------------  
60:   // ESSE É O NOSSO MÉTODO QUE VAI TRATAR A COLISÃO DE APENAS UM PONTO  
61:   // ESSE MÉTODO RECEBE COMO ARGUMENTO: X, Y DO PONTO E  
62:   //X,Y,W,H DO OBJETO ONDE VAI COLIDIR!  
63:   // --------------------------------------------------------------------  
64:   public boolean colisao(int pontoX, int pontoY, int x, int y, int w, int h) {  
65:   if ((pontoX >= x && pontoX <= x + w) && (pontoY >= y && pontoY <= y + h)) {  
66:    return true;  
67:   } else {  
68:    return false;  
69:   }  
70:   }  
71:   // --------------------------------------------------------------------  
72:   public void atualizar() {  
73:   //AQUI VAMOS VERIFICAR SE CADA PONTO ESTÁ SENDO TOCADO NO OBJETO 2  
74:   colidiuEsquerda = colisao(obj1X, obj1Y+obj1H/2, obj2X, obj2Y, obj2W, obj2H);  
75:   colidiuDireita = colisao(obj1X+obj1W, obj1Y+obj1H/2, obj2X, obj2Y, obj2W, obj2H);  
76:   colidiuCima = colisao(obj1X+obj1W/2, obj1Y, obj2X, obj2Y, obj2W, obj2H);  
77:   colidiuBaixo = colisao(obj1X+obj1W/2, obj1Y+obj1H, obj2X, obj2Y, obj2W, obj2H);  
78:   moveObjeto1();  
79:   }  
80:   public void desenharGraficos() {  
81:   Graphics g = getGraphics(); // ISSO JÁ ESTAVA AQUI  
82:   Graphics bbg = backBuffer.getGraphics();// ISSO TAMBÉM JÁ ESTAVA AQUI...  
83:   // ==================================================================================  
84:   bbg.setColor(Color.WHITE);  
85:   bbg.fillRect(0, 0, janelaW, janelaH);// DESENHA UM FUNDO BRANCO NA TELA!  
86:   // EXIBE UM TEXTO CASO O OBJETO COLIDA!  
87:   exibeTexto();  
88:   // DESENHA O OBJETO 2  
89:   bbg.setColor(Color.BLUE);  
90:   bbg.fillRect(obj2X, obj2Y, obj2W, obj2H);  
91:   // DESENHA O OBJETO 1 //com transparência  
92:   // new Color(red,green, blue, alpha) o alpha é o valor da trasnparência  
93:   // vai de 0 à 255  
94:   bbg.setColor(new Color(0, 255, 0, 200));  
95:   bbg.fillRect(obj1X, obj1Y, obj1W, obj1H);  
96:   // ==================================================================================  
97:   g.drawImage(backBuffer, 0, 0, this);// OBS: ISSO DEVE FICAR SEMPRE NO  
98:        // FINAL!  
99:   }  
100:   public void inicializar() {  
101:   setTitle("Tutorial 11 Colisão!");  
102:   setSize(janelaW, janelaH);  
103:   setResizable(false);  
104:   setDefaultCloseOperation(EXIT_ON_CLOSE);  
105:   setLayout(null);  
106:   setVisible(true);  
107:   backBuffer = new BufferedImage(janelaW, janelaH,  
108:    BufferedImage.TYPE_INT_RGB);  
109:   }  
110:   public void run() {  
111:   inicializar();  
112:   while (true) {  
113:    atualizar();  
114:    desenharGraficos();  
115:    try {  
116:    Thread.sleep(1000 / FPS);  
117:    } catch (Exception e) {  
118:    System.out.println("Thread interrompida!");  
119:    }  
120:   }  
121:   }  
122:   public static void main(String[] args) {  
123:   Game game = new Game();  
124:   game.run();  
125:   }  
126:  }  

(leiam atentamente os comentários do código!)
Muito simples não é pessoal ?
Vejam como ficou o meu:

Muito bem!!!.... até o próximo tutorial!!!