domingo, febrero 24, 2013

Pelotas rebotantes: Applet java


Estoy dando mis primeros pasos en Java y, para hacer las cosas más entretenidas, he decidido toquetear un poco el tema gráfico, base para realizar juegos sencillos en este lenguaje.

Para empezar, me he decidido por una pelota que rebota por un cuadro y, ya que me he puesto, ¿por qué no un grupo (hasta un máximo de 25) de pelotas?.

¿Cómo lo he hecho?. A continuación os dejo el código fuente de las cuatro clases que he utilizado.

Primero me dedico a crear la clase que llevará el control de una pelota: su posición, su movimiento y su dibujado.



package es.orujosoft.pelotarebotante;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;

public class Pelota {
 
 private Point posicion;
 private int factorMovimiento, alturaRebote, radio, 
                    angulo, anchoContenedor, altoContenedor;
 private Color color;

 /**
  * Crea una nueva instancia de pelota
  * 
  * @param Graphics g
  */
 
 public Pelota() {
  
  posicion = new Point(0, 0);
  this.setFactorMovimiento(1);
  this.setRadio(50);
  this.setAlturaRebote(100);
  this.angulo = 0;
  
  
 }
 
 /*
  * ******************************************************************************
  * ****************** Inicio del interfaz de la clase ***************************
  * ******************************************************************************
  */
 
 /**
  * 
  * @param int anchoContenedor
  */
 
 public void setAnchoContenedor(int anchoContenedor) {
  
  this.anchoContenedor = anchoContenedor;
  
 }
 
 /**
  * 
  * @return int
  */
 
 public int getAnchoContenedor() {
  
  return this.anchoContenedor;
  
 }
 
 /**
  * 
  * @param int altoContenedor
  */
 
 public void setAltoContenedor(int altoContenedor) {
  
  this.altoContenedor = altoContenedor;
  
 }
 
 /**
  * 
  * @return int
  */
 
 public int getAltoContenedor() {
  
  return this.altoContenedor;
  
 }
 
 /**
  * 
  * @param Point posicion
  */
 
 public void setPosicion(Point posicion) {
  
  this.posicion.x = posicion.x;
  this.posicion.y = posicion.y;
  
 }
 
 /**
  * 
  * @return Point
  */
 
 public Point getPosicion() {
  
  Point posicionAux = new Point();
  posicionAux.x = this.posicion.x;
  posicionAux.y = this.posicion.y;
  return posicionAux;
  
 }
 
 /**
  * 
  * @param int radio
  */
 
 public void setRadio(int radio) {
  
  this.radio = radio;
  
 }
 
 /**
  * 
  * @return int
  */
 
 public int getRadio() {
  
  return this.radio;
  
 }
 
 /**
  * 
  * @param int factorMovimiento
  */
 
 public void setFactorMovimiento(int factorMovimiento) {
  
  this.factorMovimiento = factorMovimiento;
  
 }
 
 /**
  * 
  * @return int
  */
 
 public int getFactorMovimiento() {
  
  return this.factorMovimiento;
  
 }
 
 /**
  * 
  * @param int alturaRebote
  */
 
 public void setAlturaRebote(int alturaRebote) {
  
  this.alturaRebote = alturaRebote;
  
 }
 
 /**
  * 
  * @return int
  */
 
 public int getAlturaRebote() {
  
  return this.alturaRebote;
  
 }
 
 /**
  * 
  * @return Color
  */
 
 public Color getColor() {
  return color;
 }
 
 /*
  * @param Color
  */

 public void setColor(Color color) {
  this.color = color;
 }
 
 public int getAngulo() {
  return angulo;
 }

 public void setAngulo(int angulo) {
  this.angulo = angulo;
 }

 /**************************************************************************
  * *********** Cambia la posición de la pelota en el espacio **************
  * ************************************************************************
  */
 
 
 /*
  * Si no se le pasa un valor realizará un movimiento por defecto según el 
  * factor de movimiento definido en la clase 
  */
 
 public void mueve() {
  
  
  mueve(this.factorMovimiento);
  
 }
 
 /**
  * Calcula la posición cambiando el valor de x y calculando la y en
  * función del ángulo para el movimiento actual
  * 
  * @param int factorMovimiento
  */
 
 public void mueve(int factorMovimiento) {
  
  double anguloEnRadianes;
  
  this.angulo++;
  this.angulo = this.angulo > 180 ? 0 : this.angulo;
  /*
   * Convertimos los grados sexagesimales en radianes
   */
  anguloEnRadianes = (this.angulo*2*Math.PI/360); 
  /*
   * Incrementamos o decremetamos la x según la variables factorMovimiento
   */
  this.posicion.x += this.factorMovimiento;
  /*
   * Controlamos que la x se encuentre siempre entre los límites del applet
   */
  if ((this.posicion.x+this.radio) >= this.anchoContenedor) {
   this.factorMovimiento = -1*this.factorMovimiento;
  }
  if ((this.posicion.x+this.radio)-this.radio <= 0) {
   this.factorMovimiento = -1*this.factorMovimiento;
  }
  /*
   * Calcula la posicion y de la pelota
   */
  this.posicion.y = this.radio + 
                                  (int) (this.alturaRebote*Math.sin(anguloEnRadianes));
  
 }
 
 /**
  * Dibujamos la pelota recibiendo como argumento un contexto gráfico 
         * donde se dibujará
  */
 
 public void dibuja(Graphics g) {
  
  g.setColor(this.color);
  g.fillOval(this.posicion.x, (this.altoContenedor)-(this.posicion.y), 
                           this.radio, this.radio);
  
 }

}

Es el momento de definir el lienzo donde se dibujará. La clase Canvas.


package es.orujosoft.pelotarebotante;

/*
 * Zona de dibujo dentro del applet
 */

import java.awt.Graphics;

import javax.swing.JPanel;

public class Canvas extends JPanel {
 
 /**
  * 
  */
 private static final long serialVersionUID = 1L;

 /*
  * El constructor no necesita realizar ninguna acción
  */
 
 public Canvas() { 
  
 }
 
 /*
  * Realiza el dibujado dentro del panel de dibujo
  */
 
 public void paint(Graphics g) {
 
  /*
   * Llamamos primero al método paint del sistema (se usa para poder borrar
   * el cuadro)
   */
  
  super.paint(g);
  
  /*
   * Indicamos a cada pelota que se dibuje. 
   */
  
  for (int indice = 0; indice < PelotaRebotante.pelota.length; indice++) {
   PelotaRebotante.pelota[indice].dibuja(g);
  }
 }

}

El temporizador que contendrá el bucle de movimiento (un hilo).


package es.orujosoft.pelotarebotante;

/*
 * Hilo que se encargará de temporizar el applet
 */

public class Temporizador implements Runnable {
 
 public Temporizador() {
  
 }

 @Override
 public void run() {
  
  while (PelotaRebotante.running) {
   try {
    Thread.sleep(10);
    for (int indice=0; 
                                     indice < PelotaRebotante.pelota.length; 
                                     indice++) {
     PelotaRebotante.pelota[indice].mueve();
    }
    PelotaRebotante.canvas.repaint();
   }
   catch (InterruptedException e) {
    
   }
  }

 }

}

Y, finalmente, el applet que lo pondrá todo en marcha.


package es.orujosoft.pelotarebotante;

import java.awt.Color;

public class PelotaRebotante extends JApplet {
 static Pelota[] pelota;
 static boolean running;
 static int numeroPelotas;
 static public Canvas canvas;
 
 private static final long serialVersionUID = 1L;
 
 /*
  * Iniciamos todos los valores del array de pelotas.
  */
 
 static public void reinicia() {
  
  for (int indice = 0; indice < numeroPelotas; indice++) {
   pelota[indice].setAnchoContenedor(canvas.getSize().width);
   pelota[indice].setAltoContenedor(canvas.getSize().height);
   pelota[indice].setRadio((int) (Math.random()*40)+10);
   pelota[indice].setAlturaRebote((int) (Math.random()*canvas.getSize()
                            .height)-pelota[indice].getRadio());
   pelota[indice].setColor(new Color((int) (Math.random()*255), 
                           (int) (Math.random()*255), (int) (Math.random()*255)));
   pelota[indice].setPosicion(new Point((int) ((Math.random()*canvas
                          .getSize().width-pelota[indice].getRadio())
                          +pelota[indice].getRadio()), 0));
   pelota[indice].setAngulo((int) (Math.random()*180));
   pelota[indice].setFactorMovimiento((int) (Math.random()*10)-5);
  }
  canvas.setBackground(new Color((int) (Math.random()*255), 
                        (int) (Math.random()*255), (int) (Math.random()*255)));
  
 }
 
 /*
  * Iniciamos el applet
  */
 
 public void init() {
  
  canvas = new Canvas();
  this.getContentPane().add(canvas);
  canvas.setSize(new Dimension(Integer.parseInt(getParameter("width")),
                                   Integer.parseInt(getParameter("height"))));
  numeroPelotas = (int) (Math.random()*25);
  pelota = new Pelota[numeroPelotas];
  for (int indice = 0; indice < numeroPelotas; indice++) {
   pelota[indice] = new Pelota();
  }
  reinicia();
  
 }
 
 /*
  * Ponemos el applet en marcha
  */
 
 public void start() {
  
  running = true;
  Thread temporizador = new Thread(new Temporizador());
  temporizador.start();
  
 }

}

3 comentarios:

Carlo dijo...

Cuando lo ejecuto me dice que no hay clases main, podrias ayudarme? gracias.

Dhouard dijo...

Ten en cuenta que esto es un applet, por lo que has de incrustarlo dentro de archivo HTML y lanzarlo desde el navegador.

mandy lopez dijo...

NO se si puedes ayudarme tengo que hacer cuando se ejecuta mi programa donde le doy click en el boton no deve de salir dos pelota cuando das click en iniciar 1 solo debe salir uno y en el iniciar 2 solo debe salir uno no otro y darle un color a laas pelotas que sean de diferentes colores