http://www.antocode.net/?p=121

Con este tutorial de Explosión en Java para juegos en 2D se pueden implementar varias cosas dependiendo de la creatividad de cada uno, así que sin más vueltas veamos de que se trata.

Explosión en Java para juegos en 2D.

antocode.net

1 – Levantar una aplicación en Java
2 – Carga de Sprites en Java
3 – Ubicación de los Sprites en Java – Con esto daremos un aspecto más profesional al juego
4 – Movimiento de Sprites en Java
5 – Rotaciones simples en Java
6 – Colisiones básica en Java
7 – Sonido en Java
8 – También unos pequeños trucos durante el desarrollo

Estos son los puntos que iremos tocando en el Proyecto de Animación en Java 2D, si te interesa pásate por Games-Proyects

Y ya empecé con mi primer proyecto Iniciando el Viaje – Animación en Java, que veremos:

1 – Carga de Sprites en Java

2 – Animación – Movimientos de Sprites en Java

3 – Colisiones simples en Java

4 – Rotaciones simples

5 – Sonido

Estos serán los puntos principales del proyecto el mismo que tendrá una pequeña historia que es sacado de un proyecto personal llamado Roots que no he publicado, también daré unos cuantos tips en el desarrollo del proyecto que se lo hará desde cero; explicando paso a paso el desarrollo del mismo.

Aquí les dejo una pequeña captura de un video que hice para dar a conocer el proyecto. El vídeo acá: Vídeo de Iniciando el viaje

Iniciando el Viaje - Animación en Java

Está es un pequeña captura de cómo irá quedando pero sin el Megaman, sino con un personaje diseñado para el propósito que es el pequeño Lord AntoValls.

Si les interesa este súper proyecto los espero en mi otro Blog Games-Projects para que lo sigan y escuchar sus sugerencias y dudas.

Java Tips & Tricks #1 – Random en Java

Para este ejemplo que es super sencillo, aunque a veces cuando uno no conoce se puede complicar mucho y lo digo por experiencia propia. Necesitamos nada mas que un par de líneas de código. Veamos el ejemplo:

Este método nos devuelve un número aleatorio comprendido entre 0.0 y 1.0 de tipo double:

Math.random()

Entonces basándonos en este método podemos obtener muchos resultados sabiéndolo utilizar. Para este ejemplo lo utilizaremos para crar un número aleatorio o random de 0.0 a 0.1 y enteros menores a 10, veamos:

Para obtener números decimales sólo utilizamos esta línea:

Math.random()

Pero si queremos traer enteros menores a 10, usamos esta que hace multiplicar por 9 el random de decimales y luego hacerle un redondeo:

Math.round(Math.random() * 9))

He realizado un pequeño ejemplo con una ventanita y dos botones que al presionar cada botón muestra un número aleatorio, les adjunto el código para que lo puedan descargar:

Random en Java

Random en Java

Cualquier duda o sugerencia será bienvenida.

package lluvia;

/**
 *
 * @author gmedinac
 */

 import java.awt.*;
 import java.awt.geom.*;
 import java.awt.event.*;
 import java.util.*;
 import javax.swing.*;
 import java.awt.Image;
 import javax.swing.ImageIcon;

public class Lluvia extends JApplet{
 private Image imagen_fondo;
 public static void main(String s[]) {
 JFrame frame = new JFrame();
 frame.setTitle("LLuvia Java");
 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 JApplet applet = new Lluvia();
 applet.init();
 frame.getContentPane().add(applet);
 frame.pack();
 frame.setVisible(true);
 }

 public void init() {
 JPanel panel = new Panel();
 getContentPane().add(panel);   

 }
}

class Panel extends JPanel implements Runnable{
 Point2D.Double[] pts = new Point2D.Double[1200];
 Image imagen_fondo = new ImageIcon(this.getClass().getResource("/recursos/calle07.jpg")).getImage();
 private int alto, ancho;

 public RainPanel() {
 ancho = 200;
 alto = 274;

 setPreferredSize(new Dimension(ancho, alto));
 setBackground(Color.BLACK);
 for (int i = 0; i < pts.length; i++) {
 pts[i] = new Point2D.Double(Math.random(), Math.random());
 }
 Thread thread = new Thread(this);
 thread.start();
 }

 public void paintComponent(Graphics g) {
 super.paintComponent(g);
 Graphics2D g2d = (Graphics2D)g;
 g2d.drawImage(imagen_fondo, 0, 0, this);      

 g.setColor(Color.LIGHT_GRAY);
 for (int i = 0; i < pts.length; i++) {
 int x = (int)(ancho*pts[i].x);
 int y = (int)(alto*pts[i].y);
 int h = (int)(5*Math.random());
 g.drawLine(x, y, x, y+h);
 }
 }

 public void run() {
 while(true) {
 for (int i = 0; i < pts.length; i++) {
 double x = pts[i].getX();
 double y = pts[i].getY();
 y += 0.9*Math.random();
 if (y > 1) {
 y = 0.9*Math.random();
 x = Math.random();
 }
 pts[i].setLocation(x, y);
 }
 repaint();
 try {
 Thread.sleep(70);
 } catch (InterruptedException ex) {}
 }
 }
}

Este es el código de las dos clases usadas las dos las tengo en el mismo archivo .java. Ahora explicare un poco el funcionamiento del código:

Ahora tenemos un Array que almacena las posiciones de las líneas para la lluvia. Lo inicializamos con valores aleatorios.

Point2D.Double[] pts = new Point2D.Double[1200];
pts[i] = new Point2D.Double(Math.random(), Math.random());

El método paintComponent dibuja las líneas verticales basada en el valor del arreglo.

 public void paintComponent(Graphics g) {
 super.paintComponent(g);
 Graphics2D g2d = (Graphics2D)g;
 g2d.drawImage(imagen_fondo, 0, 0, this);      

 g.setColor(Color.LIGHT_GRAY);
 for (int i = 0; i < pts.length; i++) {
 int x = (int)(ancho*pts[i].x);
 int y = (int)(alto*pts[i].y);
 int h = (int)(5*Math.random());
 g.drawLine(x, y, x, y+h);
 }
 }

El método run contiene un loop infinito que actualiza las posiciones de las líneas en el arreglo pts. Cada punto se incrementa con un valor aleatorio en la coordenada-y.

Cuando una línea llega al fondo el punto es reiniciado con una posición aleatoria al principio de la pantalla o en él TOP de la pantalla. Después de que el arreglo es actualizado el método repaint es llamado para volver a pintar la pantalla.

Pueden aplicarlo y ver los resultados pueden hacer varias pruebas con imágenes haber como se ve mejor. No soy muy bueno haciendo las combinaciones y en este ejemplo hice varias combinaciones de imágenes de fondo, como pueden apreciar.

Imagen del Proyecto Lluvia

Este ejemplo es algo que aprendí hace unos días, y me parece un buen complemento para proyectos como los plataformas 2D o lo que sea. Les adjunto las imagenes finales del proyecto y una vez mas disculpas por el formato y la manera de postear ya pronto ire mejorando, lo estoy haciendo de a poco es que el Final Fantasy XII me tiene enganchado y del trabajo llego a jugar.

Proyecto Lluvia

Como veremos a continuación esta es nuestra clase inicial del Proyecto a que hemos llamado “Mover_Sprites”.

import javax.swing.JFrame;

public class Mover_Sprites extends JFrame{

 private static final long serialVersionUID = 1L;

 public Mover_Sprites()
 {
 add(new Escenario());
 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 setSize(640, 480);
 setLocationRelativeTo(null);
 setTitle("Mover Sprites");
 setResizable(false);
 setVisible(true);
 }

 public static void main(String[] args)
 {
 new Mover_Sprites();
 }
}

Ahora tenemos otra clase que será nuestro escenario principal, que será donde montaremos el fondo y el sprite que usaremos para movernos en la pantalla.

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;

public class Escenario extends JPanel implements ActionListener {
 /**
 *
 */
 private static final long serialVersionUID = 1L;
 private Timer timer;
 private Nave nave;
 private String escenario = "Luna_Espacio_640_480.jpg";
 ImageIcon image_icon;

 public Escenario(){

 addKeyListener(new TAdapter());
 setFocusable(true);
 setBackground(Color.BLACK);
 setDoubleBuffered(true);

 image_icon = new ImageIcon(this.getClass().getResource(escenario));

 nave = new Nave();
 timer = new Timer(5, this);
 timer.start();        
 }

 public void paint(Graphics g) {
 super.paint(g);

 Graphics2D g2d = (Graphics2D)g;
 g2d.drawImage(image_icon.getImage(), 0, 0, this);        
 g2d.drawImage(nave.getImage(), nave.getX(), nave.getY(), this);

 Toolkit.getDefaultToolkit().sync();
 g.dispose();
 }

 public void actionPerformed(ActionEvent e){
 nave.move();
 repaint();
 }

 private class TAdapter extends KeyAdapter{

 public void keyReleased(KeyEvent e){
 nave.keyReleased(e);
 }
 public void keyPressed(KeyEvent e){
 nave.keyPressed(e);
 }
 }
}

El método paint, se encarga de dibujar a nuestra nave para este caso y al escenario. Donde le indicaremos la imagen que queremos pintar y las coordenadas del objeto.

g2d.drawImage(nave.getImage(), nave.getX(), nave.getY(), this);

El método actionPerformed es llamado cada 5ms, que se encarga de pintar los movimientos del Sprite y del Escenario.

public void actionPerformed(ActionEvent e){
 nave.move();
 repaint();
 }

Nuestra clase Nave, será la que contendrá todos los movientos de nuestra nave.

import java.awt.Image;
import java.awt.event.KeyEvent;
import javax.swing.ImageIcon;

public class Nave {
 private String nave = "nave_pequeña.png";
 private int dx;
 private int dy;
 private int x;
 private int y;
 private Image image;

 public Nave()
 {        
 ImageIcon image_icon = new ImageIcon(this.getClass().getResource(nave));
 image = image_icon.getImage();
 x = 40;
 y = 60;
 }

 public void move()
 {
 if (dx > 0 && x <= 640 - 38)
 x += dx;
 else
 if (dx < 0 && x >= 2)
 x += dx;

 if (dy > 0 && y <= 480 - 50)
 y += dy;
 else
 if (dy < 0 && y >= 2)
 y += dy;

 }
 public int getX()
 {
 return x;
 }
 public int getY()
 {
 return y;
 }
 public Image getImage()
 {
 return image;
 }
 public void keyPressed(KeyEvent e)
 {
 int key = e.getKeyCode();

 if (key == KeyEvent.VK_RIGHT)
 {
 dx = 5;
 }
 if (key == KeyEvent.VK_LEFT)
 {
 dx = -5;
 }
 if (key == KeyEvent.VK_UP)
 {
 dy = -5;
 }
 if (key == KeyEvent.VK_DOWN)
 {
 dy = 5;
 }        
 }

 public void keyReleased(KeyEvent e)
 {
 int key = e.getKeyCode();

 if (key == KeyEvent.VK_RIGHT)
 {
 dx = 0;
 }
 if (key == KeyEvent.VK_LEFT)
 {
 dx = 0;
 }
 if (key == KeyEvent.VK_UP)
 {
 dy = 0;
 }
 if (key == KeyEvent.VK_DOWN)
 {
 dy = 0;
 }      
 }

}

Los métodos keyPressed y keyReleased, son los encargados de controlar los movimientos de nuestra nave tanto al presionar com al soltar las teclas.

El método move, cambia las coordenadas del Sprite, Estas con “X” y “Y” y estos valores son usados por el método paint para dibujar el Sprite en pantalla.

Aquí les presento 2 métodos uno simple que consiste solo en controlar los movimientos y otro un poco mas avanzado para darle una limitante a nuestra nave y no se salga de pantalla.

Método simple:

public void move(){
 x += dx;
 y += dy;
}

Método no tan simple, partiendo de este método pueden darle la limitante de pantalla a su nave, para este tutotial simplemente queme los bordes de la pantalla y los reste por el tamaño de la nave.

public void move()
{
 if (dx > 0 && x <= 640 - 38)
 x += dx;
 else
 if (dx < 0 && x >= 2)
 x += dx;
 if (dy > 0 && y <= 480 - 50)
 y += dy;
 else
 if (dy < 0 && y >= 2)
 y += dy;
}

Cuando soltemos la tecla izquierda del cursor, la nave se dentendrá. Lo mismo y controlando cada dirección haremos para el resto.

if (key == KeyEvent.VK_LEFT){
 dx = 0;
}

Resultado final.

Ejemplo de Movimiento de Sprites en Java

Espero les sirva este pequeño tutorial y disculpen un poco la presentación del código pero soy un poco nuevo todavía pero ya iré mejorando.

Les dejo las imágenes del Proyecto:

Nave pequeña

Escenario