Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Programación de juegos para principiantes

  • 3 Respuestas
  • 7742 Vistas

0 Usuarios y 2 Visitantes están viendo este tema.

Desconectado Expermicid

  • *
  • Underc0der
  • Mensajes: 457
  • Actividad:
    0%
  • Reputación 0
  • _-Expermicid-_
    • Ver Perfil
  • Skype: expermicid.xd
« en: Abril 06, 2014, 08:58:50 pm »
En esta serie de tutoriales enseñaré conceptos intermedios sobre java (threads, AWT, Swing, etc.) y conceptos básicos para la programación de juegos (game loop, FPS, sprite, etc). Mi idea es que estos tutoriales sirvan tanto para los que desean programar juegos, como para que la gente con un nivel de principiante o intermedio en java pueda aprender y afianzar conceptos de programación java en general, de forma divertida.



Juegos en Java

Hasta hace poco tiempo casi todos los juegos profesionales se desarrollaban en C o C++. Esto ha cambiado, hoy día hay grandes juegos realizados completamente en java. La industria de los juegos para móviles esta creciendo y java es el lenguaje para programar en Android. Android debe ser ya el sistema operativo para smart phones más usado en este momento. Por otro lado, juegos como Minecraft, tienen millones de usuarios a pesar de iniciarse como proyecto de un sólo programador, sin el apoyo de una gran empresa.

Espero, con esta serie de tutoriales, motivarlos a entrar en el mundo de la programación java y en particular de la programación de juegos.

El juego: Mini Tenis

En esta serie de tutoriales desarrollaremos desde cero una versión de uno de los primeros juegos que alcanzaron popularidad en la era de la informática.



Este juego no pretende ser el próximo éxito en ventas sino tan sólo una plataforma desde donde enseñar y quien sabe si inspirar a algún programador principiante a convertirse en el próximo exitoso en el mundo de la informática ;)

Índice

  • Nuestro primer gráfico: JFrame, JPanel, método paint
  • Animación de un objeto en movimiento
  • Sprites
  • Eventos. Capturando las entrada por teclado
  • Agregando el sprite raqueta
  • Detección de colisiones
  • Agregando sonido a nuestro juego
  • Creando una clase Sound para nuestro juego
  • Agregando puntuación y aumentando la velocidad
  • Creando archivo jar ejecutable y qué es la máquina virtual de java
  • Descargar el código fuente de minicraft y configurarlo en eclipse
  • Agregar vista de mapa a Minicraft

Programación de juegos: JFrame, JPanel, método paint

Para dibujar algo necesitamos una superficie donde pintar. Esta superficie o lienzo (Canvas en inglés) donde pintaremos nuestro primer ejemplo es un objeto JPanel. Así como un lienzo necesita un marco para sostenerse, nuestro JPanel estará enmarcado en una ventana modelada por la clase JFrame.



JFrame: La Ventana

El siguiente código crea una ventana con titulo "Mini Tennis" de 300 pixels por 300 pixels. La ventana no será visible hasta que llamemos setVisible(true). Si no incluimos la última línea "frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)", cuando cerremos la ventana el programa no terminará y seguirá ejecutándose.

Código: Java
  1. package com.edu4java.minitennis1;
  2. import javax.swing.JFrame;
  3.  
  4. public class Game {
  5.         public static void main(String[] args) {
  6.                 JFrame frame = new JFrame("Mini Tennis");
  7.                 frame.setSize(300, 300);
  8.                 frame.setVisible(true);
  9.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  10.         }
  11. }

Si ejecutamos obtendremos:



Con estas pocas instrucciones obtenemos una ventana que se puede maximizar, minimizar, cambiar de tamaño con el ratón, etc. En realidad cuando creamos un objeto JFrame iniciamos un motor que maneja la interfaz de usuario. Este motor se comunica con el sistema operativo tanto para pintar en la pantalla como para recibir información del teclado o el ratón. Llamaremos a este motor "Motor AWT" o "Motor Swing" ya que está compuesto por estas dos librerías. En las primeras versiones de java solo existía AWT y luego se agregó Swing. Este Motor utiliza varios hilos de ejecución.

¿Qué es un hilo o thread en java?

Normalmente un programa se ejecuta línea tras línea por un solo procesador en una sola línea o hilo de ejecución. El concepto de hilo (en ingles Thread) permite a un programa iniciar varias ejecuciones concurrentes. Esto es como si existieran varios procesadores ejecutándo al mismo tiempo sus propias secuencias de instrucciones.

Aunque los hilos y la concurrencia son herramientas muy potentes puede traer muchos problemas como que dos hilos accedan a las mismas variables de forma conflictiva. Es interesante considerar que dos hilos pueden estar ejecutando el mismo código de un método a la vez.

Podemos pensar que un hilo es un cocinero preparando un plato leyendo una receta de cocina. Dos hilos concurrentes serían como dos cocineros trabajando en la misma cocina, preparando cada uno un plato leyendo cada uno una receta o también podrían estar leyendo la misma receta. Los conflictos surgen por ejemplo cuando los dos intentan usar una sartén al mismo tiempo.

Motor AWT e Hilo de cola de eventos - Thread AWT-EventQueue-0

El Motor AWT inicia varios Hilos (Threads) que podemos ver en la vista Debug si iniciamos la aplicación con debug y vamos a la perspectiva Debug. Cada hilo es como si fuera un programa independiente ejecutándose al mismo tiempo que los otros hilos. Más adelante veremos más sobre hilos, por lo pronto solo me interesa que recuerden el tercer hilo que vemos en la vista Debug llamado "Thread [AWT-EventQueue-0]" este hilo es el encargado de pintar la pantalla y recibir los eventos del teclado y el ratón.



JPanel: El lienzo (Canvas en inglés)

Para poder pintar necesitamos donde y el donde es un objeto JPanel que incluiremos en la ventana. Extenderemos la clase JPanel para poder sobrescribir el método paint que es el método que llamará el Motor AWT para pintar lo que aparece en la pantalla.

Código: Java
  1. package com.edu4java.minitennis1;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Graphics;
  5. import java.awt.Graphics2D;
  6. import java.awt.RenderingHints;
  7. import java.awt.geom.Ellipse2D;
  8. import javax.swing.JFrame;
  9. import javax.swing.JPanel;
  10.  
  11. @SuppressWarnings("serial")
  12. public class Game2 extends JPanel {
  13.  
  14.         @Override
  15.         public void paint(Graphics g) {
  16.                 Graphics2D g2d = (Graphics2D) g;
  17.                 g2d.setColor(Color.RED);
  18.                 g2d.fillOval(0, 0, 30, 30);
  19.                 g2d.drawOval(0, 50, 30, 30);           
  20.                 g2d.fillRect(50, 0, 30, 30);
  21.                 g2d.drawRect(50, 50, 30, 30);
  22.  
  23.                 g2d.draw(new Ellipse2D.Double(0, 100, 30, 30));
  24.         }
  25.        
  26.         public static void main(String[] args) {
  27.                 JFrame frame = new JFrame("Mini Tennis");
  28.                 frame.add(new Game2());
  29.                 frame.setSize(300, 300);
  30.                 frame.setVisible(true);
  31.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  32.         }
  33. }
    El método paint recibe por parámetro un objeto Graphics2D que extiende de Graphics. Graphics es la vieja clase usada por AWT que ha sido reemplazada por Graphics2D que tiene más y mejor funcionalidad. El parámetro sigue siendo de tipo Graphics por compatibilidad pero nosotros siempre utilizaremos Graphics2D por lo que es necesario crear una variable g2d: "Graphics2D g2d = (Graphics2D) g;". Una vez que tenemos g2d podemos utilizar todos los métodos de Graphics2D para dibujar.

    Lo primero que hacemos es elegir el color que utilizamos para dibujar: "g2d.setColor(Color.RED);". Luego dibujamos unos círculos y cuadrados.

Posicionamiento en el lienzo. Coordenadas x e y

Para dibujar algo dentro del lienzo debemos indicar en que posición comenzaremos a pintar. Para esto cada punto del lienzo tiene una posición (x,y) asociada siendo (0,0) el punto de la esquina superior izquierda.



El primer circulo rojo se pinta con "g2d.fillOval(0, 0, 30, 30)": los primeros dos parámetros son la posición (x,y) y luego se indica el ancho y alto. como resultado tenemos un circulo de 30 pixeles de diámetro en la posición (0,0).

El circulo vacío se pinta con "g2d.drawOval(0, 50, 30, 30)": el la posición x=0 (pegado al margen izquierdo) y la posición y=50 (50 pixeles más abajo del margen superior) pinta un circulo de 30 pixeles de alto y 30 de ancho.

Los rectángulos se pintan con "g2d.fillRect(50, 0, 30, 30)" y "g2d.drawRect(50, 50, 30, 30)" de forma similar a los círculos.

Por último "g2d.draw(new Ellipse2D.Double(0, 100, 30, 30))" pinta el ultimo circulo usando un objeto Ellipse2D.Double.

Existen muchísimos métodos en Graphics2D. Algunos los veremos en siguientes tutoriales.

¿Cuándo el motor AWT llama al método paint?

El motor AWT llama al método paint cada vez que el sistema operativo le informa que es necesario pintar el lienzo. Cuando se carga por primera vez la ventana se llama a paint, si minimizamos y luego recuperamos la ventana se llama a paint, si modificamos el tamaño de la ventana con el ratón se llama a paint.

Podemos comprobar este comportamiento si ponemos un breakpoint en la primer línea del método paint y ejecutamos en modo debug.



Es interesante ver que el método paint es ejecutado por el Hilo de cola de eventos (Thread AWT-EventQueue) que como indicamos antes es el encargado de pintar la pantalla.

Game loop y Animación de un objeto

En este tutorial veremos como hacer que un círculo se mueva sobre nuestro lienzo. Esta animación se consigue pintando el círculo en una posición y luego borrando y pintando el círculo en una posición cercana. El efecto logrado es un círculo en movimiento.



Posición del círculo

Como mencionamos antes cada vez que pintamos debemos definir la posición (x,y) donde dibujaremos en este caso el círculo. Para que el círculo se mueva debemos modificar la posición (x,y) cada cierto tiempo y volver a pintar el círculo en la nueva posición.

En nuestro ejemplo mantendremos en dos propiedades llamadas "x" e "y", la posición actual de nuestro círculo. También creamos un método moveBall() que incrementará en 1 tanto a "x" como a "y" cada vez que es llamado. En el método paint dibujamos un circulo de 30 pixeles de diámetro en la posición (x,y) dada por las propiedades antes mencionadas "g2d.fillOval(x, y, 30, 30);".

Game loop

Al final del método main iniciamos un ciclo infinito "while (true)" donde repetidamente llamamos a moveBall() para cambiar la posición del circulo y luego llamamos a repaint() que fuerza al motor AWT a llamar al método paint para repintar el lienzo.

Este ciclo o repetición se conoce como "Game loop" y se caracteriza por realizar dos operaciones:

  • Actualización (Update): actualización de la física de nuestro mundo. En nuestro caso nuestra actualización esta dada tan solo por el método moveBall() que incrementa las propiedades "x" e "y" en 1.
  • Renderizado (Render): aquí se dibuja según el estado actual de nuestro mundo reflejando los cambios realizados en el paso anterior. En nuestro ejemplo este renderizado esta dado por la llamada a repaint() y la subsecuente llamada a paint realizada por el motor AWT o más específicamente por el Hilo de cola de eventos.

[/list]
Código: Java
  1. package com.edu4java.minitennis2;
  2.  
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.RenderingHints;
  6. import javax.swing.JFrame;
  7. import javax.swing.JPanel;
  8.  
  9. @SuppressWarnings("serial")
  10. public class Game extends JPanel {
  11.  
  12.         int x = 0;
  13.         int y = 0;
  14.  
  15.         private void moveBall() {
  16.                 x = x + 1;
  17.                 y = y + 1;
  18.         }
  19.  
  20.         @Override
  21.         public void paint(Graphics g) {
  22.                 super.paint(g);
  23.                 Graphics2D g2d = (Graphics2D) g;
  24.                 g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  25.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  26.                 g2d.fillOval(x, y, 30, 30);
  27.         }
  28.  
  29.         public static void main(String[] args) throws InterruptedException {
  30.                 JFrame frame = new JFrame("Mini Tennis");
  31.                 Game game = new Game();
  32.                 frame.add(game);
  33.                 frame.setSize(300, 400);
  34.                 frame.setVisible(true);
  35.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  36.                
  37.                 while (true) {
  38.                         game.moveBall();
  39.                         game.repaint();
  40.                         Thread.sleep(10);
  41.                 }
  42.         }
  43. }

Al ejecutar el código anterior obtendremos:



Analizando nuestro método paint

Como mencionamos en el tutorial anterior este método se ejecuta cada vez que el sistema operativo le indica a Motor AWT que es necesario pintar el lienzo. Si ejecutamos el método repaint() de un objeto JPanel lo que estamos haciendo es decirle al Motor AWT que ejecute el método paint tan pronto como pueda. La llamada a paint la realizará el Hilo de cola de eventos. Llamando a repaint() logramos que se repinte el lienzo y así poder reflejar el cambio en la posición del circulo.

Código: Java
  1. @Override
  2. public void paint(Graphics g) {
  3.         super.paint(g);
  4.         Graphics2D g2d = (Graphics2D) g;
  5.         g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  6.                         RenderingHints.VALUE_ANTIALIAS_ON);
  7.         g2d.fillOval(x, y, 30, 30);
  8. }

La llamada a "super.paint(g)" limpia la pantalla, si comentamos esta línea podemos ver el siguiente efecto:



La instrucción "g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)" suaviza los bordes de las figuras como se puede ver en el siguiente gráfico. El círculo de la izquierda es sin aplicar ANTIALIAS y el de la derecha aplicando ANTIALIAS.



Analizando la concurrencia y el comportamiento de los hilos

Cuando se inicia la ejecución del método main sólo existe un hilo en ejecución. Esto se puede ver colocando un breakpoint en la primera línea del método main.



Si agregamos un breakpoint en la línea game.repaint() y en la primera línea del método paint y a continuación oprimimos F8 (Resume: ordena que continúe la ejecución hasta el final o hasta que encuentre el próximo breakpoint) obtendremos:



En la vista de la izquierda podemos ver que se han creado cuatro hilos de los cuales dos están detenidos en breakpoints. El Thread main está detenido en la línea 40 en la instrucción game.repaint(). El thread AWT-EventQueue está detenido en el método paint en la línea 22.

Si seleccionamos el thread AWT-EventQueue en la vista Debug y oprimimos F8 repetidamente (2 veces) veremos que no se detiene más en el metodo paint. Esto es porque el sistema operativo no ve motivo para solicitar un repintado del lienzo una vez inicializado.



Si oprimimos F6 (avanza la ejecución del hilo sólo una línea), esta vez sobre el thread main, veremos que el método paint es vuelto a llamar por el thread AWT-EventQueue. Ahora sacamos el breakpoint del método paint, oprimimos F8 y volvemos a tener sólo detenido el thread main.

La siguiente animación nos muestra que pasa en el lienzo cada vez que oprimimos resume (F8) repetidamente. Cada llamada a moveBall() incrementa la posición (x,y) del círculo y la llamada a repaint() le dice al thread AWT-EventQueue que repinte el lienzo.



Por último analicemos la línea "Thread.sleep(10)" (la última instrucción dentro del "Game loop"). Para esto comentamos la línea con // y ejecutamos sin debug. El resultado es que no se pinta el círculo en el lienzo. ¿Por qué pasa esto? Esto es debido a que el thread main se apodera del procesador y no lo comparte con el thread AWT-EventQueue que entonces no puede llamar al método paint.

"Thread.sleep(10)" le dice al procesador que el thread que se está ejecutando descanse por 10 milisegundos lo que permite que el procesador ejecute otros threads y en particular el thread AWT-EventQueue que llama al método paint.

Me gustaría aclarar que en este ejemplo la solución planteada es muy pobre y sólo pretende ilustrar los conceptos de "game loop", threads y concurrencia. Existen mejores formas de manejar el game loop y la concurrencia en un juego y las veremos en los próximos tutoriales.

Sprites - Velocidad y dirección

Cada objeto que se mueve en la pantalla tiene características propias como la posición (x,y), la velocidad y la dirección en que se mueve, etc. Todas estas características se pueden aislar en un objeto que llamaremos Sprite.



Velocidad y dirección

En el tutorial anterior logramos que la pelota (el círculo) se moviera hacia abajo y a la derecha a un píxel por vuelta en el Game Loop. Cuando llegaba al limite de la pantalla la pelota seguía su curso desapareciendo del lienzo. Lo que haremos a continuación es que la pelota rebote en los limites del lienzo cambiando su dirección.

Código: Java
  1. package com.edu4java.minitennis3;
  2.  
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.RenderingHints;
  6. import javax.swing.JFrame;
  7. import javax.swing.JPanel;
  8.  
  9. @SuppressWarnings("serial")
  10. public class Game extends JPanel {
  11.  
  12.         int x = 0;
  13.         int y = 0;
  14.         int xa = 1;
  15.         int ya = 1;
  16.  
  17.         private void moveBall() {
  18.                 if (x + xa < 0)
  19.                         xa = 1;
  20.                 if (x + xa > getWidth() - 30)
  21.                         xa = -1;
  22.                 if (y + ya < 0)
  23.                         ya = 1;
  24.                 if (y + ya > getHeight() - 30)
  25.                         ya = -1;
  26.                
  27.                 x = x + xa;
  28.                 y = y + ya;
  29.         }
  30.  
  31.         @Override
  32.         public void paint(Graphics g) {
  33.                 super.paint(g);
  34.                 Graphics2D g2d = (Graphics2D) g;
  35.                 g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  36.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  37.                 g.fillOval(x, y, 30, 30);
  38.  
  39.         }
  40.  
  41.         public static void main(String[] args) throws InterruptedException {
  42.                 JFrame frame = new JFrame("Mini Tennis");
  43.                 Game game = new Game();
  44.                 frame.add(game);
  45.                 frame.setSize(300, 400);
  46.                 frame.setVisible(true);
  47.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  48.                
  49.                 while (true) {
  50.                         game.moveBall();
  51.                         game.repaint();
  52.                         Thread.sleep(10);
  53.                 }
  54.         }
  55. }

En el código anterior se agregaron dos propiedades "xa" y "ya" que representan la velocidad en que se mueve la pelota. Si xa=1, la pelota se mueve hacia la derecha a un píxel por vuelta del Game Loop y si xa=-1, la pelota se mueve hacia la izquierda. Similarmente ya=1 mueve hacia abajo y ya=-1 mueve hacia arriba. Esto lo logramos con las líneas "x = x + xa" e "y = y + ya" del método moveBall().

Antes de ejecutar las instrucciones anteriores verificamos que la pelota no salga de los márgenes del lienzo. Por ejemplo cuando la pelota alcance el margen derecho o lo que es lo mismo cuando (x + xa > getWidth() - 30) lo que haremos es cambiar la dirección del movimiento sobre el eje x o lo que es lo mismo asignar menos uno a xa "xa = -1".

Código: Java
  1. private void moveBall() {
  2.         if (x + xa < 0)
  3.                 xa = 1;
  4.         if (x + xa > getWidth() - 30)
  5.                 xa = -1;
  6.         if (y + ya < 0)
  7.                 ya = 1;
  8.         if (y + ya > getHeight() - 30)
  9.                 ya = -1;
  10.                
  11.         x = x + xa;
  12.         y = y + ya;
  13.        
  14. }

Cada sentencia if limita un borde del lienzo.

Crear el Sprite Ball (pelota en inglés)

La idea es crear una clase llamada Ball que aisle todo lo referente a la pelota. En el siguiente código podemos ver como extraemos todo el código referente a la pelota de la clase Game2 y lo incorporamos a nuestra nueva clase Ball.

Código: Java
  1. package com.edu4java.minitennis3;
  2.  
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.RenderingHints;
  6. import javax.swing.JFrame;
  7. import javax.swing.JPanel;
  8.  
  9. @SuppressWarnings("serial")
  10. public class Game2 extends JPanel {
  11.  
  12.         Ball ball = new Ball(this);
  13.  
  14.         private void move() {
  15.                 ball.move();
  16.         }
  17.  
  18.         @Override
  19.         public void paint(Graphics g) {
  20.                 super.paint(g);
  21.                 Graphics2D g2d = (Graphics2D) g;
  22.                 g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  23.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  24.                 ball.paint(g2d);
  25.         }
  26.  
  27.         public static void main(String[] args) throws InterruptedException {
  28.                 JFrame frame = new JFrame("Mini Tennis");
  29.                 Game2 game = new Game2();
  30.                 frame.add(game);
  31.                 frame.setSize(300, 400);
  32.                 frame.setVisible(true);
  33.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  34.                
  35.                 while (true) {
  36.                         game.move();
  37.                         game.repaint();
  38.                         Thread.sleep(10);
  39.                 }
  40.         }
  41. }

El Sprite Ball necesita que le envíen una referencia al objeto Game para obtener los limites del lienzo y así saber cuando debe cambiar de dirección. En el método move() de la clase Ball se llama a game.getWidth() y game.getHeight().

Código: Java
  1. package com.edu4java.minitennis3;
  2.  
  3. import java.awt.Graphics2D;
  4.  
  5. public class Ball {
  6.         int x = 0;
  7.         int y = 0;
  8.         int xa = 1;
  9.         int ya = 1;
  10.         private Game2 game;
  11.  
  12.         public Ball(Game2 game) {
  13.                 this.game= game;
  14.         }
  15.  
  16.         void move() {
  17.                 if (x + xa < 0)
  18.                         xa = 1;
  19.                 if (x + xa > game.getWidth() - 30)
  20.                         xa = -1;
  21.                 if (y + ya < 0)
  22.                         ya = 1;
  23.                 if (y + ya > game.getHeight() - 30)
  24.                         ya = -1;
  25.  
  26.                 x = x + xa;
  27.                 y = y + ya;
  28.         }
  29.  
  30.         public void paint(Graphics2D g) {
  31.                 g.fillOval(x, y, 30, 30);
  32.         }
  33. }

Si ejecutamos Game2 obtendremos el mismo resultado que si ejecutamos la versión anterior Game. La conveniencia de esta separación del código referente a la pelota en una clase de tipo Sprite se vuelve más obvia cuando incluimos la raqueta mediante un nuevo Sprite en un próximo tutorial.
« Última modificación: Abril 06, 2014, 09:18:10 pm por Expermicid »

Desconectado Expermicid

  • *
  • Underc0der
  • Mensajes: 457
  • Actividad:
    0%
  • Reputación 0
  • _-Expermicid-_
    • Ver Perfil
  • Skype: expermicid.xd
« Respuesta #1 en: Abril 06, 2014, 09:04:25 pm »
Eventos. Capturando las entrada por teclado

En este tutorial veremos como funcionan los eventos y en particular como obtener la información acerca de los eventos producidos en el teclado desde un programa java. Además explicaremos el concepto y uso de clases anónimas que es el método más comúnmente usado para manejar eventos en java. Abandonaremos nuestro juego momentáneamente y haremos un simple ejemplo de captura de eventos.



Ejemplo de lectura del teclado

Para leer del teclado es necesario registrar un objeto que se encargue de "escuchar si una tecla es presionada". Este objeto conocido como "Listener" u "oyente" y tendrá métodos que serán llamados cuando alguien presione una tecla. En nuestro ejemplo el Listener se registra en el JPanel (o KeyboardExample) usando el método addKeyListener(KeyListener listener).

Código: Java
  1. package com.edu4java.minitennis4;
  2.  
  3. import java.awt.event.KeyEvent;
  4. import java.awt.event.KeyListener;
  5. import javax.swing.JFrame;
  6. import javax.swing.JPanel;
  7.  
  8. @SuppressWarnings("serial")
  9. public class KeyboardExample extends JPanel {
  10.        
  11.         public KeyboardExample() {
  12.                 KeyListener listener = new MyKeyListener();
  13.                 addKeyListener(listener);
  14.                 setFocusable(true);
  15.         }
  16.        
  17.         public static void main(String[] args) {
  18.                 JFrame frame = new JFrame("Mini Tennis");
  19.                 KeyboardExample keyboardExample = new KeyboardExample();
  20.                 frame.add(keyboardExample);
  21.                 frame.setSize(200, 200);
  22.                 frame.setVisible(true);
  23.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  24.         }
  25.  
  26.         public class MyKeyListener implements KeyListener {
  27.                 @Override
  28.                 public void keyTyped(KeyEvent e) {
  29.                 }
  30.  
  31.                 @Override
  32.                 public void keyPressed(KeyEvent e) {
  33.                         System.out.println("keyPressed="+KeyEvent.getKeyText(e.getKeyCode()));
  34.                 }
  35.  
  36.                 @Override
  37.                 public void keyReleased(KeyEvent e) {
  38.                         System.out.println("keyReleased="+KeyEvent.getKeyText(e.getKeyCode()));
  39.                 }
  40.         }
  41. }

En el constructor de la clase KeyboardExample creamos el listener y lo registramos. Para que un objeto JPanel reciba las notificaciones del teclado es necesario incluir la instrucción setFocusable(true) que permite que KeyboardExample reciba el foco.

Código: Java
  1. public KeyboardExample() {
  2.         KeyListener listener = new MyKeyListener();
  3.         addKeyListener(listener);
  4.         setFocusable(true);
  5. }

La clase MyKeyListener es la que uso para crear el objeto Listener. Este Listener imprimirá en la consola el nombre del método y la tecla afectada por el evento.

Código: Java
  1. public class MyKeyListener implements KeyListener {
  2.         @Override
  3.         public void keyTyped(KeyEvent e) {
  4.         }
  5.  
  6.         @Override
  7.         public void keyPressed(KeyEvent e) {
  8.                 System.out.println("keyPressed="+KeyEvent.getKeyText(e.getKeyCode()));
  9.         }
  10.  
  11.         @Override
  12.         public void keyReleased(KeyEvent e) {
  13.                 System.out.println("keyReleased="+KeyEvent.getKeyText(e.getKeyCode()));
  14.         }
  15. }

Una vez registrado, cuando KeyboardExample (nuestro JPanel) tenga el foco y alguien oprima una tecla KeyboardExample informará al objeto listener registrado. El objeto Listener de nuestro ejemplo implementa la interfaz KeyListener que tiene los métodos keyTyped(), keyPressed() y keyReleased(). El método keyPressed será llamado cada vez que una tecla sea oprimida (y varias veces si se mantiene oprimida). El método keyReleased será llamado cuando solemos una tecla.

Los métodos antes mencionados reciben como parámetro un objeto KeyEvent que contiene información sobre que tecla se ha oprimido o soltado. Usando e.getKeyCode() podemos obtener el código de la tecla y si le pasamos un código de tecla a la función estatica KeyEvent.getKeyText(...) podemos obtener el texto asociado a la tecla.

¿Cómo funcionan los eventos en AWT/Swing?

Lo eventos del ratón y el teclado son controlados por el sistema operativo. El motor AWT, en particular el thread AWT-Windows se comunica con el sistema operativo y se entera de si hubo un evento. Cuando encuentra un nuevo evento lo coloca en la "Cola de Eventos" para que sea atendido cuando le llegue su turno por el Thread AWT-EventQueue.



Cuando el Thread AWT-EventQueue atiende a un evento se fija a que componente afecta y le informa. En nuestro caso el componente es el JPanel que informa a todos los listeners que se hayan registrado para recibir notificaciones de ese evento.

En el caso del teclado la llamada addKeyListener(KeyListener listener) es la que realiza este registro. Si queremos registrar un objeto para escuchar los eventos del ratón podemos usar addMouseListener(MouseListener listener).

Si quieren profundizar en como funcionan los eventos en AWT/Swing les recomiendo el siguiente artículo.

Clase anónima

En el ejemplo anterior la clase MyKeyListener será solo usada una vez por lo que podríamos reemplazarla por una clase anónima. KeyboardExample2 muestra como sería:

Código: Java
  1. package com.edu4java.minitennis4;
  2.  
  3. import java.awt.event.KeyEvent;
  4. import java.awt.event.KeyListener;
  5. import javax.swing.JFrame;
  6. import javax.swing.JPanel;
  7.  
  8. @SuppressWarnings("serial")
  9. public class KeyboardExample2 extends JPanel {
  10.        
  11.         public KeyboardExample2() {
  12.                 KeyListener listener = new KeyListener() {
  13.                         @Override
  14.                         public void keyTyped(KeyEvent e) {
  15.                         }
  16.  
  17.                         @Override
  18.                         public void keyPressed(KeyEvent e) {
  19.                                 System.out.println("keyPressed="+KeyEvent.getKeyText(e.getKeyCode()));
  20.                         }
  21.  
  22.                         @Override
  23.                         public void keyReleased(KeyEvent e) {
  24.                                 System.out.println("keyReleased="+KeyEvent.getKeyText(e.getKeyCode()));
  25.                         }
  26.                 };
  27.                 addKeyListener(listener);
  28.                 setFocusable(true);
  29.         }
  30.        
  31.         public static void main(String[] args) {
  32.                 JFrame frame = new JFrame("Mini Tennis");
  33.                 KeyboardExample2 keyboardExample = new KeyboardExample2();
  34.                 frame.add(keyboardExample);
  35.                 frame.setSize(200, 200);
  36.                 frame.setVisible(true);
  37.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  38.         }
  39. }

En el constructor de la clase KeyboardExample2 podemos ver como se reemplaza

Código: Java
  1. KeyListener listener = new MyKeyListener();

por

Código: Java
  1. KeyListener listener = new KeyListener() {
  2.         @Override
  3.         public void keyTyped(KeyEvent e) {
  4.         }
  5.  
  6.         @Override
  7.         public void keyPressed(KeyEvent e) {
  8.                 System.out.println("keyPressed="+KeyEvent.getKeyText(e.getKeyCode()));
  9.         }
  10.  
  11.         @Override
  12.         public void keyReleased(KeyEvent e) {
  13.                 System.out.println("keyReleased="+KeyEvent.getKeyText(e.getKeyCode()));
  14.         }
  15. };

Esta instrucción tiene el mismo efecto que la anterior. Reemplaza la definición de la clase MyKeyListener por una clase anónima que hace exactamente lo mismo.

La forma de crear un objeto desde una clase anónima es reemplazar el nombre de la clase a crear por una definición que empieza por la interfaz a implementar seguida por () y luego dentro de {} la definición de la clase como hacemos normalmente.

Aunque parezca un poco extraño esta es la forma más cómoda de implementar Listeners de eventos y es la forma que más encontrarán en código java avanzado.

Ahora sigamos con el desarrollo de nuestro juego en el próximo tutorial.

Agregando el sprite raqueta

En este tutorial agregaremos la raqueta mediante un Sprite llamado Racquet. La raqueta se moverá hacia la izquierda o derecha cuando oprimamos las teclas del cursor por lo que nuestro programa necesita leer del teclado.



Nuevo Sprite Racquet

Lo primero que hacemos es agregar en la clase Game una nueva propiedad llamada racquet donde mantendremos el Sprite que maneja la raqueta. En el método move() añadimos una llamada a racquet.move() y en paint() una llamada a racquet.paint(). Hasta ahora todo es similar al sprite Ball pero como la posición de la raqueta responde al teclado tenemos que hacer algo más.

Código: Java
  1. package com.edu4java.minitennis5;
  2.  
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.RenderingHints;
  6. import java.awt.event.KeyEvent;
  7. import java.awt.event.KeyListener;
  8. import javax.swing.JFrame;
  9. import javax.swing.JPanel;
  10.  
  11. @SuppressWarnings("serial")
  12. public class Game extends JPanel {
  13.  
  14.         Ball ball = new Ball(this);
  15.         Racquet racquet = new Racquet(this);
  16.  
  17.         public Game() {
  18.                 addKeyListener(new KeyListener() {
  19.                         @Override
  20.                         public void keyTyped(KeyEvent e) {
  21.                         }
  22.  
  23.                         @Override
  24.                         public void keyReleased(KeyEvent e) {
  25.                                 racquet.keyReleased(e);
  26.                         }
  27.  
  28.                         @Override
  29.                         public void keyPressed(KeyEvent e) {
  30.                                 racquet.keyPressed(e);
  31.                         }
  32.                 });
  33.                 setFocusable(true);
  34.         }
  35.        
  36.         private void move() {
  37.                 ball.move();
  38.                 racquet.move();
  39.         }
  40.  
  41.         @Override
  42.         public void paint(Graphics g) {
  43.                 super.paint(g);
  44.                 Graphics2D g2d = (Graphics2D) g;
  45.                 g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  46.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  47.                 ball.paint(g2d);
  48.                 racquet.paint(g2d);
  49.         }
  50.  
  51.         public static void main(String[] args) throws InterruptedException {
  52.                 JFrame frame = new JFrame("Mini Tennis");
  53.                 Game game = new Game();
  54.                 frame.add(game);
  55.                 frame.setSize(300, 400);
  56.                 frame.setVisible(true);
  57.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  58.                
  59.                 while (true) {
  60.                         game.move();
  61.                         game.repaint();
  62.                         Thread.sleep(10);
  63.                 }
  64.         }
  65. }

En el constructor de la clase game se puede ver como se registra un listener para capturar los eventos del teclado. En el método keyPressed() del listener informamos a la raqueta que una tecla ha sido oprimida llamando a racquet.keyPressed(e). Lo mismo hacemos para keyReleased(). Con esto el Sprite racquet se enterará cuando una tecla sea oprimida. Veamos ahora las clases Ball y Racquet que implementan los sprites.

Código: Java
  1. package com.edu4java.minitennis5;
  2.  
  3. import java.awt.Graphics2D;
  4.  
  5. public class Ball {
  6.         int x = 0;
  7.         int y = 0;
  8.         int xa = 1;
  9.         int ya = 1;
  10.         private Game game;
  11.  
  12.         public Ball(Game game) {
  13.                 this.game= game;
  14.         }
  15.  
  16.         void move() {
  17.                 if (x + xa < 0)
  18.                         xa = 1;
  19.                 if (x + xa > game.getWidth() - 30)
  20.                         xa = -1;
  21.                 if (y + ya < 0)
  22.                         ya = 1;
  23.                 if (y + ya > game.getHeight() - 30)
  24.                         ya = -1;
  25.  
  26.                 x = x + xa;
  27.                 y = y + ya;
  28.         }
  29.  
  30.         public void paint(Graphics2D g) {
  31.                 g.fillOval(x, y, 30, 30);
  32.         }
  33. }

La clase Ball no tiene cambios. Comparémosla con la clase Racquet:

Código: Java
  1. package com.edu4java.minitennis5;
  2.  
  3. import java.awt.Graphics2D;
  4. import java.awt.event.KeyEvent;
  5.  
  6. public class Racquet {
  7.         int x = 0;
  8.         int xa = 0;
  9.         private Game game;
  10.  
  11.         public Racquet(Game game) {
  12.                 this.game= game;
  13.         }
  14.  
  15.         public void move() {
  16.                 if (x + xa > 0 && x + xa < game.getWidth()-60)
  17.                         x = x + xa;
  18.         }
  19.  
  20.         public void paint(Graphics2D g) {
  21.                 g.fillRect(x, 330, 60, 10);
  22.         }
  23.  
  24.         public void keyReleased(KeyEvent e) {
  25.                 xa = 0;
  26.         }
  27.  
  28.         public void keyPressed(KeyEvent e) {
  29.                 if (e.getKeyCode() == KeyEvent.VK_LEFT)
  30.                         xa = -1;
  31.                 if (e.getKeyCode() == KeyEvent.VK_RIGHT)
  32.                         xa = 1;
  33.         }
  34. }

A diferencia de Ball, Racquet no tiene propiedades para la posición "y" ni la velocidad "ya". Esto es debido a que la raqueta no variará su posición vertical, solo se moverá hacia la izquierda o derecha, nunca hacia arriba o abajo. En el método paint la instrucción g.fillRect(x, 330, 60, 10) define un rectángulo de 60 por 10 pixeles en la posición (x,y)=(x,330). Como vemos "x" puede variar pero "y" está fijada a 330 pixeles del limite superior del lienzo.

El método move() es similar al de Ball en el sentido de incrementar en "xa" la posición "x" y controlar que el sprite no se salga de los limites.

Código: Java
  1. public void move() {
  2.         if (x + xa > 0 && x + xa < game.getWidth()-60)
  3.                 x = x + xa;
  4. }

Inicialmente el valor de "x" es cero lo que indica que la raqueta estará en el limite izquierdo del lienzo. "xa" también está inicializado a cero, lo que hace que en principio la raqueta aparezca estática ya que x = x + xa no modificará "x" mientras "xa" sea cero.

Cuando alguien presione una tecla el método keyPressed de Racquet será llamado y este pondrá "xa" en 1 si la tecla presionada es la de dirección derecha (KeyEvent.VK_RIGHT) lo que a su vez hará que la raqueta se mueva a la derecha la próxima vez que se llame al método move (recordar x = x + xa). De la misma forma si se presiona la tecla KeyEvent.VK_LEFT se moverá a la izquierda.

Código: Java
  1. public void keyPressed(KeyEvent e) {
  2.         if (e.getKeyCode() == KeyEvent.VK_LEFT)
  3.                 xa = -1;
  4.         if (e.getKeyCode() == KeyEvent.VK_RIGHT)
  5.                 xa = 1;
  6. }

Cuando una tecla deja de ser presionada el método keyReleased es llamado y "xa" pasa a valer cero lo que hace que el movimiento de la raqueta se detenga.

Código: Java
  1. public void keyReleased(KeyEvent e) {
  2.         xa = 0;
  3. }

Si ejecutamos el ejemplo podemos ver como la pelota se mueve rebotando contra los límites y la raqueta se mueve cuando presionamos las teclas de dirección correspondientes. Pero cuando la pelota choca con la raqueta la atraviesa pareciendo como si esta no existiese. En el próximo tutorial veremos como hacer que la pelota rebote sobre la raqueta.

Desconectado Expermicid

  • *
  • Underc0der
  • Mensajes: 457
  • Actividad:
    0%
  • Reputación 0
  • _-Expermicid-_
    • Ver Perfil
  • Skype: expermicid.xd
« Respuesta #2 en: Abril 06, 2014, 09:08:42 pm »
Detección de colisiones

En este tutorial aprenderemos como detectar cuando un sprite choca con otro. En nuestro juego haremos que la pelota rebote contra la raqueta. Además haremos que el juego termine si la pelota alcanza el limite inferior del lienzo mostrando una ventana popup con el clásico mensaje "Game Over".



Game Over

A continuación vemos nuestra clase Game que es idéntica a la anterior con la sola diferencia de que se ha agregado el método gameOver();

Código: Java
  1. package com.edu4java.minitennis6;
  2.  
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.RenderingHints;
  6. import java.awt.event.KeyEvent;
  7. import java.awt.event.KeyListener;
  8. import javax.swing.JFrame;
  9. import javax.swing.JOptionPane;
  10. import javax.swing.JPanel;
  11.  
  12. @SuppressWarnings("serial")
  13. public class Game extends JPanel {
  14.  
  15.         Ball ball = new Ball(this);
  16.         Racquet racquet = new Racquet(this);
  17.  
  18.         public Game() {
  19.                 addKeyListener(new KeyListener() {
  20.                         @Override
  21.                         public void keyTyped(KeyEvent e) {
  22.                         }
  23.  
  24.                         @Override
  25.                         public void keyReleased(KeyEvent e) {
  26.                                 racquet.keyReleased(e);
  27.                         }
  28.  
  29.                         @Override
  30.                         public void keyPressed(KeyEvent e) {
  31.                                 racquet.keyPressed(e);
  32.                         }
  33.                 });
  34.                 setFocusable(true);
  35.         }
  36.        
  37.         private void move() {
  38.                 ball.move();
  39.                 racquet.move();
  40.         }
  41.  
  42.         @Override
  43.         public void paint(Graphics g) {
  44.                 super.paint(g);
  45.                 Graphics2D g2d = (Graphics2D) g;
  46.                 g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  47.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  48.                 ball.paint(g2d);
  49.                 racquet.paint(g2d);
  50.         }
  51.        
  52.         public void gameOver() {
  53.                 JOptionPane.showMessageDialog(this, "Game Over", "Game Over", JOptionPane.YES_NO_OPTION);
  54.                 System.exit(ABORT);
  55.         }
  56.  
  57.         public static void main(String[] args) throws InterruptedException {
  58.                 JFrame frame = new JFrame("Mini Tennis");
  59.                 Game game = new Game();
  60.                 frame.add(game);
  61.                 frame.setSize(300, 400);
  62.                 frame.setVisible(true);
  63.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  64.                
  65.                 while (true) {
  66.                         game.move();
  67.                         game.repaint();
  68.                         Thread.sleep(10);
  69.                 }
  70.         }
  71. }

El método gameOver() lanza un popup usando JOptionPane.showMessageDialog con el mensaje "Game Over" y un solo botón "Aceptar". Después del popup, System.exit(ABORT) hace que se termine el programa. El método gameOver() es público ya que será llamado desde el sprite Ball cuando detecte que ha llegado al límite inferior del lienzo.

Colisión de Sprites

Para detectar la colisión entre la pelota y la raqueta usaremos rectángulos. El caso de la pelota crearemos un cuadrado alrededor de la pelota como se ve el la figura 2.



La clase java.awt.Rectangle tiene un método intersects(Rectangle r) que retorna true cuando dos rectángulos ocupan el mismo espacio como en el caso de la figura 3 o 4. Cabe destacar que este método no es exacto ya que en la figura 4 la pelota no toca a la raqueta pero para nuestro ejemplo será más que suficiente.

A continuación vemos la clase Racquet donde el único cambio funcional es que se ha agregado el método getBounds() que retorna un objeto de tipo rectángulo indicando la posición de la raqueta. Este método será usado por el sprite Ball para saber la posición de la raqueta y así detectar la colisión.

Código: Java
  1. package com.edu4java.minitennis6;
  2.  
  3. import java.awt.Graphics2D;
  4. import java.awt.Rectangle;
  5. import java.awt.event.KeyEvent;
  6.  
  7. public class Racquet {
  8.         private static final int Y = 330;
  9.         private static final int WITH = 60;
  10.         private static final int HEIGHT = 10;
  11.         int x = 0;
  12.         int xa = 0;
  13.         private Game game;
  14.  
  15.         public Racquet(Game game) {
  16.                 this.game = game;
  17.         }
  18.  
  19.         public void move() {
  20.                 if (x + xa > 0 && x + xa < game.getWidth() - WITH)
  21.                         x = x + xa;
  22.         }
  23.  
  24.         public void paint(Graphics2D g) {
  25.                 g.fillRect(x, Y, WITH, HEIGHT);
  26.         }
  27.  
  28.         public void keyReleased(KeyEvent e) {
  29.                 xa = 0;
  30.         }
  31.  
  32.         public void keyPressed(KeyEvent e) {
  33.                 if (e.getKeyCode() == KeyEvent.VK_LEFT)
  34.                         xa = -1;
  35.                 if (e.getKeyCode() == KeyEvent.VK_RIGHT)
  36.                         xa = 1;
  37.         }
  38.  
  39.         public Rectangle getBounds() {
  40.                 return new Rectangle(x, Y, WITH, HEIGHT);
  41.         }
  42.  
  43.         public int getTopY() {
  44.                 return Y - HEIGHT;
  45.         }
  46. }

Otro cambio que funcionalmente no afecta pero que es una buena práctica de programación es la inclusión de constantes:

Código: Java
  1. private static final int Y = 330;
  2. private static final int WITH = 60;
  3. private static final int HEIGH = 20;

Como antes mencionamos el valor de posición "y" estaba fijo en 330. Este valor es usado tanto en el método paint como en getBounds. Si queremos cambiarlo ahora sólo tenemos que cambiarlo en un sólo lugar evitando el posible error que se produciría si lo cambiáramos en un método y en otro no.

La forma de definir una constante en java es declarando una propiedad "static final" y en mayúsculas. El compilador permite usar minúsculas pero el estándar dice que se deben usar mayúsculas para los nombres de las constantes.

Por último la clase Ball:

Código: Java
  1. package com.edu4java.minitennis6;
  2.  
  3. import java.awt.Graphics2D;
  4. import java.awt.Rectangle;
  5.  
  6. public class Ball {
  7.         private static final int DIAMETER = 30;
  8.         int x = 0;
  9.         int y = 0;
  10.         int xa = 1;
  11.         int ya = 1;
  12.         private Game game;
  13.  
  14.         public Ball(Game game) {
  15.                 this.game= game;
  16.         }
  17.  
  18.         void move() {
  19.                 if (x + xa < 0)
  20.                         xa = 1;
  21.                 if (x + xa > game.getWidth() - DIAMETER)
  22.                         xa = -1;
  23.                 if (y + ya < 0)
  24.                         ya = 1;
  25.                 if (y + ya > game.getHeight() - DIAMETER)
  26.                         game.gameOver();
  27.                 if (collision()){
  28.                         ya = -1;
  29.                         y = game.racquet.getTopY() - DIAMETER;
  30.                 }
  31.                 x = x + xa;
  32.                 y = y + ya;
  33.         }
  34.  
  35.         private boolean collision() {
  36.                 return game.racquet.getBounds().intersects(getBounds());
  37.         }
  38.  
  39.         public void paint(Graphics2D g) {
  40.                 g.fillOval(x, y, DIAMETER, DIAMETER);
  41.         }
  42.        
  43.         public Rectangle getBounds() {
  44.                 return new Rectangle(x, y, DIAMETER, DIAMETER);
  45.         }
  46. }

De forma similar a la clase Racquet se ha incluido el método getBounds() y la constante DIAMETER.

Más interesante es la aparición de un nuevo método llamado collision() que retorna true (verdadero) si el rectángulo ocupado por la raqueta "game.racquet.getBounds()" intersecta al rectángulo que encierra a la pelota "getBounds()".

Código: Java
  1. private boolean collision() {
  2.         return game.racquet.getBounds().intersects(getBounds());
  3. }

Si la colisión se produce, además de cambiar la dirección ajustaremos la posición de la pelota. Si la colisión es por el lado (figura 1), la pelota podría estar varios pixeles por debajo de la cara superior de la raqueta. En el siguiente game loop aunque la pelota se movería hacia arriba (figura 2) podría todavía estar en colisión con la raqueta.



Para evitar esto colocamos a la pelota sobre la raqueta (figura 3) mediante:

Código: Java
  1. y = game.racquet.getTopY() - DIAMETER;

El método getTopY() de Racquet nos da la posición en el eje y de la parte superior de la raqueta y restando DIAMETER conseguimos la posición y exacta donde colocar la pelota para que esté sobre la raqueta.

Por último es el método move() de la clase Ball el que usa los nuevos métodos collision() y gameOver() de la clase Game. El rebote al alcanzar el lÍmite inferior ha sido reemplazado por una llamada a game.gameOver().

Código: Java
  1. if (y + ya > game.getHeight() - DIAMETER)
  2.         game.gameOver();

Y poniendo un nuevo condicional usando el método collision() logramos que la pelota rebote hacia arriba si esta colisiona con la raqueta:

Código: Java
  1. if (collision())
  2.         ya = -1;
     
Si ejecutamos el ejemplo podemos ver:



Agregando sonido a nuestro juego

Un juego sin sonido no está completo. En este tutorial agregaremos música de fondo, el ruido del rebote de la pelota y un "Game Over" con voz graciosa al terminar el juego. Para evitar problemas de copyright vamos a crear nosotros mismos los sonidos.



Creando sonidos

Para crear los sonidos me tomé la libertad de buscar en Google "free audio editor" y como respuesta encontré http://free-audio-editor.com/. Tengo que decir que la versión gratis de este producto es potente y fácil de manejar.



Con este editor he creado los archivos: back.wav, gameover.wav y ball.wav. En el video de youtube pueden ver como lo hice y crearlos ustedes mismos. También pueden descargar y usar estos tres que en esta misma línea los declaro libres de copyright. Lo que tienen que hacer es copiar estos archivos al paquete com.edu4java.minitennis7.



Reproducir sonidos usando AudioClip

Para reproducir los archivos de sonido usaremos la clase AudioClip. Crearemos objetos AudioClip usando el método estático de la clase Applet: Applet.newAudioClip(URL url). Este método necesita un objeto URL que le indique donde está el archivo de audio que queremos cargar para luego reproducir. La siguiente instrucción crea un objeto URL utilizando una ubicación en Internet:

Código: Java
  1. URL url = new URL("http://www.edu4java.com/es/game/sound/back.wav");

La siguiente utiliza un directorio dentro del sistema de archivos local:

Código: Java
  1. URL url = new URL("file:/C:/eclipseClasic/workspace/minitennis/src/com/edu4java/minitennis7/back.wav");

Nosotros buscaremos nuestro archivo utilizando el classpath. Este es el sistema que usa java para cargar las clases o mejor dicho los archivos *.class que definen las clases del programa. Para obtener un URL desde el classpath se utiliza el método getResource(String name) de la clase Class donde name es el nombre del archivo que queremos obtener.

A continuación vemos dos formas de como conseguir el URL del archivo "back.wav" que está en el mismo paquete que la clase SoundTest o lo que es lo mismo en el mismo directorio donde esta el archivo SoundTest.class.

Código: Java
  1. URL url = SoundTest.class.getResource("back.wav");
  2. URL url = new SoundTest().getClass().getResource("back.wav");

Tanto "SoundTest.class" como "new SoundTest().getClass()" nos dan un objeto class que tiene el método getResource que queremos usar.

He creado la clase SoundTest con el sólo propósito de mostrarles como trabaja AudioClip y no es necesaria para nuestro juego. A continuación se muestra el código fuente de SoundTest completo:

Código: Java
  1. package com.edu4java.minitennis7;
  2.  
  3. import java.applet.Applet;
  4. import java.applet.AudioClip;
  5. import java.net.URL;
  6.  
  7. public class SoundTest {
  8.         public static void main(String[] args) throws Exception {
  9.  
  10. //              System.out.println("1");
  11. //              URL url = new URL("http://www.edu4java.com/es/game/sound/back.wav");
  12. //              System.out.println("2");
  13. //              AudioClip clip = Applet.newAudioClip(url);
  14. //              System.out.println("3");
  15. //              clip.play();
  16. //              System.out.println("4");
  17. //              Thread.sleep(1000);
  18.  
  19. //              URL url = new URL(
  20. //                      "file:/C:/eclipseClasic/workspace/minitennis/src/com/edu4java/minitennis7/back.wav");
  21.  
  22.                 URL url = SoundTest.class.getResource("back.wav");
  23.                 AudioClip clip = Applet.newAudioClip(url);
  24.                 AudioClip clip2 = Applet.newAudioClip(url);
  25.                 clip.play();
  26.                 Thread.sleep(1000);
  27.                 clip2.loop();
  28.                 Thread.sleep(20000);
  29.                 clip2.stop();
  30.                
  31.                 System.out.println("end");
  32.         }
  33. }

De esta forma el archivo back.wav se obtienen desde el classpath. El classpath es el conjunto de directorios y archivos *.jar desde donde nuestro programa puede leer las clases (archivos *.class).

Una ventaja de esta metodología es que sólo tenemos que indicar la posición del archivo con respecto a la clase que lo usa. En nuestro caso como está en el mismo paquete basta con el nombre "back.wav". Otra ventaja es que los archivos de sonido se pueden incluir en un archivo *.jar. Veremos más sobre archivos *.jar más adelante. Una ves que tenemos el objeto URL podemos crear objetos AudioClip usando Applet.newAudioClip(url).

Código: Java
  1. AudioClip clip = Applet.newAudioClip(url);
  2. AudioClip clip2 = Applet.newAudioClip(url);

El objeto AudioClip tiene un método play() que inicia un thread independiente que reproduce sólo una vez el audio contenido en el archivo. Para reproducir el audio en forma repetitiva podemos usar el método loop() de AudioClip que reproducirá el sonido una y otra vez hasta que se llame al método stop sobre el mismo objeto AudioClip.

Dos audioClips pueden reproducirse al mismo tiempo. En el ejemplo creo dos audioClips con el mismo audio: clip y clip2. Reproduzco clip con play, espero un segundo Thread.sleep(1000) y reproduzco clip2 con loop. El resultado es una mezcla de los dos audios. Por ultimo después de 20 segundos Thread.sleep(20000) llamo a clip2.stop() y detengo la repetición de clip2.

Desconectado Expermicid

  • *
  • Underc0der
  • Mensajes: 457
  • Actividad:
    0%
  • Reputación 0
  • _-Expermicid-_
    • Ver Perfil
  • Skype: expermicid.xd
« Respuesta #3 en: Abril 06, 2014, 09:09:17 pm »
Creando una clase Sound para nuestro juego

Para guardar los audioclips de nuestro juego creamos una clase Sound que tendrá una constante con un audioclip por cada sonido que usemos. Estas constantes son públicas para que cualquier objeto que tenga acceso a ellas pueda reproducirlas. Por ejemplo en la clase Ball podemos reproducir el sonido del rebote de la pelota usando Sound.BALL.play() en el momento que detectamos que la pelota cambia de dirección.



Código: Java
  1. package com.edu4java.minitennis7;
  2.  
  3. import java.applet.Applet;
  4. import java.applet.AudioClip;
  5.  
  6. public class Sound {
  7.         public static final AudioClip BALL = Applet.newAudioClip(Sound.class.getResource("ball.wav"));
  8.         public static final AudioClip GAMEOVER = Applet.newAudioClip(Sound.class.getResource("gameover.wav"));
  9.         public static final AudioClip BACK = Applet.newAudioClip(Sound.class.getResource("back.wav"));
  10. }

Los objetos audioclips se crearán al cargarse la clase Sound la primera vez que alguien use la clase Sound. A partir de este momento serán reutilizados una y otra vez. Ahora veamos las modificaciones en la clase Game:

Código: Java
  1. package com.edu4java.minitennis7;
  2.  
  3. import java.awt.Graphics;
  4. import java.awt.Graphics2D;
  5. import java.awt.RenderingHints;
  6. import java.awt.event.KeyEvent;
  7. import java.awt.event.KeyListener;
  8. import javax.swing.JFrame;
  9. import javax.swing.JOptionPane;
  10. import javax.swing.JPanel;
  11.  
  12. @SuppressWarnings("serial")
  13. public class Game extends JPanel {
  14.  
  15.         Ball ball = new Ball(this);
  16.         Racquet racquet = new Racquet(this);
  17.  
  18.         public Game() {
  19.                 addKeyListener(new KeyListener() {
  20.                         @Override
  21.                         public void keyTyped(KeyEvent e) {
  22.                         }
  23.  
  24.                         @Override
  25.                         public void keyReleased(KeyEvent e) {
  26.                                 racquet.keyReleased(e);
  27.                         }
  28.  
  29.                         @Override
  30.                         public void keyPressed(KeyEvent e) {
  31.                                 racquet.keyPressed(e);
  32.                         }
  33.                 });
  34.                 setFocusable(true);
  35.                 Sound.BACK.loop();
  36.         }
  37.        
  38.         private void move() {
  39.                 ball.move();
  40.                 racquet.move();
  41.         }
  42.  
  43.         @Override
  44.         public void paint(Graphics g) {
  45.                 super.paint(g);
  46.                 Graphics2D g2d = (Graphics2D) g;
  47.                 g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  48.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  49.                 ball.paint(g2d);
  50.                 racquet.paint(g2d);
  51.         }
  52.        
  53.         public void gameOver() {
  54.                 Sound.BACK.stop();
  55.                 Sound.GAMEOVER.play();
  56.                 JOptionPane.showMessageDialog(this, "Game Over", "Game Over", JOptionPane.YES_NO_OPTION);
  57.                 System.exit(ABORT);
  58.         }
  59.  
  60.         public static void main(String[] args) throws InterruptedException {
  61.                 JFrame frame = new JFrame("Mini Tennis");
  62.                 Game game = new Game();
  63.                 frame.add(game);
  64.                 frame.setSize(300, 400);
  65.                 frame.setVisible(true);
  66.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  67.                
  68.                 while (true) {
  69.                         game.move();
  70.                         game.repaint();
  71.                         Thread.sleep(10);
  72.                 }
  73.         }
  74. }

En la última línea del constructor de la clase Game añadimos Sound.BACK.loop(), lo que iniciará la reproducción de nuestra música de fondo que se repetirá hasta que se alcance el método gameOver(), donde detenemos la música de fondo con Sound.BACK.stop(). A continuación de Sound.BACK.stop() y antes del popup informamos que se termino la partida reproduciendo "Game Over" Sound.GAMEOVER.play().

En la clase Ball modificamos el método move() para que se reproduzca Sound.BALL cuando la pelota rebote.

Código: Java
  1. package com.edu4java.minitennis7;
  2.  
  3. import java.awt.Graphics2D;
  4. import java.awt.Rectangle;
  5.  
  6. public class Ball {
  7.         private static final int DIAMETER = 30;
  8.        
  9.         int x = 0;
  10.         int y = 0;
  11.         int xa = 1;
  12.         int ya = 1;
  13.         private Game game;
  14.  
  15.         public Ball(Game game) {
  16.                 this.game = game;
  17.         }
  18.  
  19.         void move() {
  20.                 boolean changeDirection = true;
  21.                 if (x + xa < 0)
  22.                         xa = 1;
  23.                 else if (x + xa > game.getWidth() - DIAMETER)
  24.                         xa = -1;
  25.                 else if (y + ya < 0)
  26.                         ya = 1;
  27.                 else if (y + ya > game.getHeight() - DIAMETER)
  28.                         game.gameOver();
  29.                 else if (collision()){
  30.                         ya = -1;
  31.                         y = game.racquet.getTopY() - DIAMETER;
  32.                 } else
  33.                         changeDirection = false;
  34.                
  35.                 if (changeDirection)
  36.                         Sound.BALL.play();
  37.                 x = x + xa;
  38.                 y = y + ya;
  39.         }
  40.  
  41.         private boolean collision() {
  42.                 return game.racquet.getBounds().intersects(getBounds());
  43.         }
  44.  
  45.         public void paint(Graphics2D g) {
  46.                 g.fillOval(x, y, DIAMETER, DIAMETER);
  47.         }
  48.  
  49.         public Rectangle getBounds() {
  50.                 return new Rectangle(x, y, DIAMETER, DIAMETER);
  51.         }
  52. }

Lo que hice en move() es agregar una variable changeDirection que inicializo a true. Añadiendo un else a cada if y colocando un changeDirection = false que sólo se ejecutará si ninguna condición en los if es cumplida, conseguimos enterarnos si la bola ha rebotado. Si la pelota ha rebotado changeDirection será verdadero y Sound.BALL.play() será ejecutado.

Agregando puntuación y aumentando la velocidad

Todo juego necesita una medida de logro o éxito. En nuestro caso incluiremos en el rincón izquierdo de la pantalla nuestra puntuación que no será más que la cantidad de veces que logramos pegarle a la pelota con la raqueta. Por otro lado el juego debería ser cada vez más difícil para no matar de aburrimiento al jugador. Para esto aumentaremos la velocidad del juego cada vez que rebote la pelota en la raqueta.



Los objetos móviles del juego son la pelota y la raqueta. Modificando la velocidad de movimiento de estos dos objetos modificaremos la velocidad del juego. Vamos a incluir una propiedad llamada speed en la clase Game para mantener la velocidad del juego. La propiedad speed será inicialmente 1 e irá incrementándose cada vez que le demos a la pelota con la raqueta.

Para la puntuación necesitaríamos otra propiedad a incrementar cada vez que golpeemos la pelota. En vez de crear una nueva propiedad se me ocurrió reutilizar speed. El único inconveniente es que las puntuaciones suelen iniciarse en 0 y no en 1 como speed. La solución que se me ocurrió fue agregar un método getScore() que retorne el valor de speed menos uno.

Código: Java
  1. private int getScore() {
  2.         return speed - 1;
  3. }

Veamos las modificaciones hechas en la clase Game:

Código: Java
  1. package com.edu4java.minitennis8;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Font;
  5. import java.awt.Graphics;
  6. import java.awt.Graphics2D;
  7. import java.awt.RenderingHints;
  8. import java.awt.event.KeyEvent;
  9. import java.awt.event.KeyListener;
  10. import javax.swing.JFrame;
  11. import javax.swing.JOptionPane;
  12. import javax.swing.JPanel;
  13.  
  14. @SuppressWarnings("serial")
  15. public class Game extends JPanel {
  16.  
  17.         Ball ball = new Ball(this);
  18.         Racquet racquet = new Racquet(this);
  19.         int speed = 1;
  20.  
  21.         private int getScore() {
  22.                 return speed - 1;
  23.         }
  24.  
  25.         public Game() {
  26.                 addKeyListener(new KeyListener() {
  27.                         @Override
  28.                         public void keyTyped(KeyEvent e) {
  29.                         }
  30.  
  31.                         @Override
  32.                         public void keyReleased(KeyEvent e) {
  33.                                 racquet.keyReleased(e);
  34.                         }
  35.  
  36.                         @Override
  37.                         public void keyPressed(KeyEvent e) {
  38.                                 racquet.keyPressed(e);
  39.                         }
  40.                 });
  41.                 setFocusable(true);
  42.                 Sound.BACK.loop();
  43.         }
  44.  
  45.         private void move() {
  46.                 ball.move();
  47.                 racquet.move();
  48.         }
  49.  
  50.         @Override
  51.         public void paint(Graphics g) {
  52.                 super.paint(g);
  53.                 Graphics2D g2d = (Graphics2D) g;
  54.                 g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  55.                                 RenderingHints.VALUE_ANTIALIAS_ON);
  56.                 ball.paint(g2d);
  57.                 racquet.paint(g2d);
  58.  
  59.                 g2d.setColor(Color.GRAY);
  60.                 g2d.setFont(new Font("Verdana", Font.BOLD, 30));
  61.                 g2d.drawString(String.valueOf(getScore()), 10, 30);
  62.         }
  63.  
  64.         public void gameOver() {
  65.                 Sound.BACK.stop();
  66.                 Sound.GAMEOVER.play();
  67.                 JOptionPane.showMessageDialog(this, "your score is: " + getScore(),
  68.                                 "Game Over", JOptionPane.YES_NO_OPTION);
  69.                 System.exit(ABORT);
  70.         }
  71.  
  72.         public static void main(String[] args) throws InterruptedException {
  73.                 JFrame frame = new JFrame("Mini Tennis");
  74.                 Game game = new Game();
  75.                 frame.add(game);
  76.                 frame.setSize(300, 400);
  77.                 frame.setVisible(true);
  78.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  79.  
  80.                 while (true) {
  81.                         game.move();
  82.                         game.repaint();
  83.                         Thread.sleep(10);
  84.                 }
  85.         }
  86. }

Para pintar la puntuación en el rincón superior izquierdo al final del método paint he agregado:

Código: Java
  1. g2d.setColor(Color.GRAY);
  2. g2d.setFont(new Font("Verdana", Font.BOLD, 30));
  3. g2d.drawString(String.valueOf(getScore()), 10, 30);

En la primera línea elegimos el color gris, en la segunda línea el tipo de letra Verdana, negrita de 30 pixeles y finalmente en la posición (x,y) igual a (10,30) donde dibujamos la puntuación.

En el método gameOver() modificamos el segundo parámetro para mostrar la puntuación alcanzada:

Código: Java
  1. JOptionPane.showMessageDialog(this, "your score is: " + getScore(),"Game Over", JOptionPane.YES_NO_OPTION);

En la clase Ball el método move() ha sido modificado para considerar la nueva propiedad de velocidad "game.speed". Cuando la pelota cambiaba de dirección las propiedades de velocidad xa y ya eran modificadas a 1 o -1. Ahora considerando la velocidad estas propiedades son cambiadas a game.speed o -game.speed. También se ha agregado en el condicional if(collision()) que la velocidad se incremente "game.speed++".

Código: Java
  1. package com.edu4java.minitennis8;
  2.  
  3. import java.awt.Graphics2D;
  4. import java.awt.Rectangle;
  5.  
  6. public class Ball {
  7.         private static final int DIAMETER = 30;
  8.        
  9.         int x = 0;
  10.         int y = 0;
  11.         int xa = 1;
  12.         int ya = 1;
  13.         private Game game;
  14.  
  15.         public Ball(Game game) {
  16.                 this.game = game;
  17.         }
  18.  
  19.         void move() {
  20.                 boolean changeDirection = true;
  21.                 if (x + xa < 0)
  22.                         xa = game.speed;
  23.                 else if (x + xa > game.getWidth() - DIAMETER)
  24.                         xa = -game.speed;
  25.                 else if (y + ya < 0)
  26.                         ya = game.speed;
  27.                 else if (y + ya > game.getHeight() - DIAMETER)
  28.                         game.gameOver();
  29.                 else if (collision()){
  30.                         ya = -game.speed;
  31.                         y = game.racquet.getTopY() - DIAMETER;
  32.                         game.speed++;
  33.                 } else
  34.                         changeDirection = false;
  35.                
  36.                 if (changeDirection)
  37.                         Sound.BALL.play();
  38.                 x = x + xa;
  39.                 y = y + ya;
  40.         }
  41.  
  42.         private boolean collision() {
  43.                 return game.racquet.getBounds().intersects(getBounds());
  44.         }
  45.  
  46.         public void paint(Graphics2D g) {
  47.                 g.fillOval(x, y, DIAMETER, DIAMETER);
  48.         }
  49.  
  50.         public Rectangle getBounds() {
  51.                 return new Rectangle(x, y, DIAMETER, DIAMETER);
  52.         }
  53. }

A continuación vemos la clase Racquet:

Código: Java
  1. package com.edu4java.minitennis8;
  2.  
  3. import java.awt.Graphics2D;
  4. import java.awt.Rectangle;
  5. import java.awt.event.KeyEvent;
  6.  
  7. public class Racquet {
  8.         private static final int Y = 330;
  9.         private static final int WITH = 60;
  10.         private static final int HEIGHT = 10;
  11.         int x = 0;
  12.         int xa = 0;
  13.         private Game game;
  14.  
  15.         public Racquet(Game game) {
  16.                 this.game = game;
  17.         }
  18.  
  19.         public void move() {
  20.                 if (x + xa > 0 && x + xa < game.getWidth() - WITH)
  21.                         x = x + xa;
  22.         }
  23.  
  24.         public void paint(Graphics2D g) {
  25.                 g.fillRect(x, Y, WITH, HEIGHT);
  26.         }
  27.  
  28.         public void keyReleased(KeyEvent e) {
  29.                 xa = 0;
  30.         }
  31.  
  32.         public void keyPressed(KeyEvent e) {
  33.                 if (e.getKeyCode() == KeyEvent.VK_LEFT)
  34.                         xa = -game.speed;
  35.                 if (e.getKeyCode() == KeyEvent.VK_RIGHT)
  36.                         xa = game.speed;
  37.         }
  38.  
  39.         public Rectangle getBounds() {
  40.                 return new Rectangle(x, Y, WITH, HEIGHT);
  41.         }
  42.  
  43.         public int getTopY() {
  44.                 return Y - HEIGHT;
  45.         }
  46. }

Aquí la modificación es similar que en Ball. En el método keyPressed(KeyEvent e) la modificación de la velocidad xa pasa de -1 y 1 a -game.speed y game.speed.

Nota: según el estándar de "Java Beans" el acceso a la propiedad "game.speed" debería hacerse usando un método de la forma "game.getSpeed()". El accesos directo a una propiedad es considerado casi un pecado mortal en el ámbito de java empresarial. Curiosamente en el entorno de desarrollo de juegos es muy común y esta justificado por eficiencia. Esto es especialmente importante en programación para móviles donde los recursos suelen ser más escasos.

Creando archivo jar ejecutable y qué es la máquina virtual de java.

En este tutorial veremos como crear un archivo ejecutable para una aplicación java, en particular para nuestro juego. Un programa java necesita una maquina virtual para ser ejecutado. A continuación también explicaremos que es la máquina virtual de java y brevemente como funciona.



La máquina virtual de java; Java Virtual Machine (JVM)

Antes de java lo más normal era escribir un programa en un lenguaje de programación de alto nivel como C o Pascal y luego traducirlo a lenguaje de máquina con un compilador. El "lenguaje máquina" o "código máquina" es el lenguaje que entiende la máquina (ordenador o computadora). Una máquina con Windows y un Mac de Apple hablan distinto lenguaje de máquina. Luego se necesita un compilador diferente para cada máquina.

En el caso de java cuando usamos el compilador no obtenemos código máquina. Lo que obtenemos es un código llamado bytecode que no se ejecuta directamente sobre una máquina real. Este bytecode solo se puede ejecutar en una máquina virtual. Una máquina virtual es un programa que se hace pasar por una máquina. Para cada sistema operativo diferente existirá un programa de máquina virtual especifico pero el bytecode que ejecutan será el mismo.



Como el bytecode es el mismo potencialmente puede ser ejecutado es cualquier sistema operativo siempre y cuando exista una implementación de JVM para este SO. En esta idea se basa la famosa frase: "Write once, run anywhere" (WORA) "escribir una vez, ejecutar en cualquier parte".

Compilación y ejecución en java

Existen dos versiones de instalación de java para cada sistema operativo: JRE y JDK. JRE Java Runtime Environment, es una versión reducida que contiene la JVM pero que no incluye el compilador java. JDK Java Development Kit contiene la JVM, el compilador java y muchas herramientas adicionales para el desarrollo de aplicaciones java. Si no tiene instalada la versión JDK tendrán que instalarla para poder continuar con este tutorial.

Si tenemos instalado la JDK tendremos un directorio donde estarán todos los archivos que componen la plataforma java. Este directorio es conocido como java Home o JAVA_HOME. En mi caso este es "C:\Program Files (x86)\Java\jdk1.6.0_21".

Dentro de JAVA_HOME existe una carpeta bin que contiene los ejecutable entre los que podemos encontrar: El compilador: javac.exe y la máquina virtual: java.exe.

Para ejemplificar como funcionan estos programas vamos a crear un archivo llamado HelloWorld.java en un directorio C:\testjava con el siguiente contenido:

Código: Java
  1. import javax.swing.JOptionPane;
  2.  
  3. public class HelloWorld {
  4.         public static void main(String[] args) {
  5.                 System.out.println("Hello World ;)");
  6.                 JOptionPane.showMessageDialog(null, "Hello World");
  7.         }
  8. }

Luego abrimos una ventana de comandos, ejecutamos "cd C:\testjava" para posicionarnos en el directorio donde esta nuestro archivo java y luego para compilar ejecutamos:

Código: [Seleccionar]
javac HelloWorld.java
o
"C:\Program Files (x86)\Java\jdk1.7.0_05\bin\javac" HelloWorld.java

Como resultado podemos ver que se ha creado un nuevo archivo HellowWorld.class con el bytecode. Podemos ejecutar este bytecode con la siguiente instrucción:

Código: [Seleccionar]
java HelloWorld
o
"C:\Program Files (x86)\Java\jdk1.7.0_05\bin\java" HelloWorld

Un programa java normalmente esta compuesto por varios archivos java y por consiguiente muchos archivos *.class. Además están los archivos de recursos como los sonidos en nuestra aplicación. Java permite empaquetar una aplicación con todos los archivos antes mencionados en un archivo *.jar.

Archivo JAR

Un archivo jar no es más que un archivo comprimido con el algoritmo de compresión ZIP que puede contener:

Los archivos *.class que se generan a partir de compilar los archivos *.java que componen nuestra aplicación.
Los archivos de recursos que necesita nuestra aplicación (Por ejemplo los archivo de sonido *.wav)
Opcionalmente se puede incluir los archivos de código fuente *.java
Opcionalmente puede existir un archivo de configuración "META-INF/MANIFEST.MF".
Crear un archivo JAR ejecutable

Para que el archivo jar sea ejecutable hay que incluir en el archivo MANIFEST.MF una línea indicando la clase que contiene el método estático main() que se usará para iniciar la aplicación. En nuestro ejemplo anterior sería:

Código: [Seleccionar]
Main-Class: HelloWorld
Es importante destacar que al final de la línea hay que agregar un retorno de carro para que funcione. Los invito a crear un archivo testjava.zip que contenga el archivo HelloWorld.class, el directorio META-INF y dentro el archivo MANIFEST.MF con la linea Main-Class: HelloWorld. Para esto pueden usar los programas Winzip o WinRAR que pueden descargar gratuitamente (buscar en Google).



Una vez creado el archivo testjava.zip, lo renombramos a testjava.jar y lo ejecutamos desde la línea de comandos:



También podemos ejecutar haciendo doble click sobre el archivo JAR.

Como crear un archivo JAR ejecutable desde eclipse

Para crear un JAR ejecutable basta con ir a File-Export, seleccionar Runnable JAR file



Como se ve a continuación, en "Launch configuration" seleccionamos la que usamos para ejecutar la versión final de nuestra aplicación y en "Export destination" indicamos donde queremos guardar nuestro JAR y con que nombre:





Si java está bien instalado sobre Windows, con un doble click sobre minitennis.jar sería suficiente para ejecutar nuestra aplicación.

Examinando minitennis.jar

Si descomprimimos nuestro archivo minitennis.jar encontraremos los archivos *.class que componen nuestro juego. Estos archivos están dentro del árbol de directorios con los nombres de los paquetes java que contienen a las clases.

Además dentro de META-INF/MANIFEST.MF podemos ver en la última línea como se indica que el juego debe iniciarse con el método main() de la clase Game que esta en el paquete com.edu4java.minitennis8.



Eclipse realiza un excelente trabajo compilando, ejecutando y creando archivos JAR pero es bueno entender que por debajo eclipse usa la instalación de java de forma similar a nuestro ejemplo HelloWorld.

Bueno, esto es todo ... nos vemos en el próximo tutorial ;)

Saludos

Fuente: edu4java

 

¿Te gustó el post? COMPARTILO!



Java al Extremo [Todo lo que Necesitas Para Aprender Java] [Multi]

Iniciado por Mr.Kratos

Respuestas: 0
Vistas: 2783
Último mensaje Julio 20, 2018, 05:21:12 pm
por Mr.Kratos
Retazo: Cambiar el LookAndFeel para el tiempo de ejecución

Iniciado por Adalher

Respuestas: 1
Vistas: 2914
Último mensaje Enero 15, 2019, 09:57:14 am
por Elchito33
[Aporte] Mi primera aplicacion para celular

Iniciado por Only

Respuestas: 4
Vistas: 4054
Último mensaje Noviembre 06, 2011, 07:41:24 am
por sisvot1
Conversor ASCI a Hex para inyecciones by andresg888

Iniciado por ProcessKill

Respuestas: 0
Vistas: 2439
Último mensaje Febrero 24, 2010, 04:13:18 pm
por ProcessKill
Juego del Gato para aprendices.

Iniciado por coke951

Respuestas: 1
Vistas: 3229
Último mensaje Septiembre 10, 2015, 11:55:40 pm
por LKI