domingo, 6 de marzo de 2016

Pelotas que rebotan en Java

Aquí tenemos unas pelotas dentro de una ventana que caen y rebotan al llegar al suelo. Este proyecto sigue la misma estructura de animaciones anteriores que hemos realizado en Java, sólo que hemos cambiado el comportamiento de las pelotas.

El funcionamiento es muy sencillo, tenemos 3 botones en la parte izquierda de la ventana que
se encargan de lo siguiente:

Botón Start: se encarga de poner en marcha la animación, controla el timer que nos permite controlar el tiempo dentro de la misma.

Botón Stop: sirve para detener el timer y por lo tanto la animación.

Botón + Pelotas: nos permite añadir mas pelotas, en este caso no aparecen en el mismo sitio, van apareciendo una al lado de la otra.

Las clases necesarias para  poder realizar esta animación cómo se puede ver en el vídeo  de más abajo son 4:

Animación 2d: contiene el main y sirve para que podamos ejecutar la animación fuera del entorno de desarrollo.

IGU: se encarga de la parte gráfica y de la lógica de la animación, digamos que es la clase principal del proyecto.

ImagenesJuego: es la clase encargada de poder "coger" las imágenes para poder usarlas en el proyecto.

Bola: tiene las características de cada bola, posición, cómo se mueven y algunos valores que se utilizan para la animación

Aquí os dejo un vídeo para que podáis ver el resultado:



Si queréis ver el código fuente de alguna clase o tenéis dudas de algo no dudéis en ponerlo en los comentarios.

18 comentarios:

  1. Respuestas
    1. hola, te voy poniendo el código de cada clase lo pruebas y si te funciona bien te voy pasando los siguientes, ok?

      Eliminar
  2. podrian pasarme los codigos porfavor gracias es un buen aporte mmm

    ResponderEliminar
    Respuestas
    1. hola, el proyecto está estructurado en 4 clases, si quieres te las voy poniendo una a una con su código fuente completo, ok?

      Eliminar
  3. hola sera que me puedes ayudar con el codigo

    ResponderEliminar
    Respuestas
    1. si, son 4 clases, si quieres te las voy poniendo y vas viendo si te funciona, ok?

      Eliminar
  4. el código por favor

    ResponderEliminar
    Respuestas
    1. hola, te voy pasando clases y vas compilando, si lo pongo todo de golpe te vas a liar, ok?

      Eliminar
    2. hola, perdona la tardanza, la primera clase que es la que contiene el main para ejecutar la aplicación es así:


      public class Animacion2d
      {
      public static void main(String[] args) {
      new IGU();
      }
      }

      Como ves es muy simple, solo crea un objeto IGU que es donde está la ventana y toda la parte gráfica de la aplicación

      Eliminar
  5. Respuestas
    1. hola, no, todo el control de tiempo y ejecuciones se hace con timer

      Eliminar
  6. aigo pasame el codigo pe yaaa!!!! te lo suplio

    ResponderEliminar
    Respuestas
    1. hola, en los comentarios ya he puesto el código de algunas clases y la estructura del proyecto, si quieres el código de alguna clase más dímelo y te lo pongo

      Eliminar
  7. Hola, podrías pasar el código de la clase IGU. Muchas gracias de antemano. Muy buen proyecto, me sirve mucho.

    ResponderEliminar
    Respuestas
    1. Hola, te lo pongo en 2 partes que no cabe todo en un comentario, aquí va la parte 1:


      import java.awt.Canvas;
      import java.awt.Color;
      import java.awt.Dimension;
      import java.awt.Graphics;
      import java.awt.image.BufferedImage;
      import java.util.HashMap;
      import javax.swing.*;
      import java.awt.event.*;
      import java.util.ArrayList;
      import java.util.Random;
      import java.awt.*;

      public class IGU extends Canvas {
      public int Ancho = 800;//ancho del panel de juego
      public int Alto = 600;//alto del panel de juego
      public int Velocidad = 15;//valor que controla el timer
      public int contador = 0;
      public int posHorizontalBolaRebote = 50;

      public BufferedImage buffer;//buffer para guardar las imagenes
      ImagenesJuego img = new ImagenesJuego();
      public ArrayList Pelotas = new ArrayList();//arraylist para almacenar las pelotas

      public JButton boton1, boton2, boton3;//botones del juego
      Bola bola = new Bola (50,30);
      public Timer timerJuego;//para el timer que controlará el juego (tiempo de los movimientos)

      public IGU() {

      buffer = new BufferedImage(Ancho,Alto, BufferedImage.TYPE_INT_RGB);
      JFrame ventana = new JFrame("JuegoSoftware.com Eh cómo rebotan!!");

      JPanel panel = (JPanel)ventana.getContentPane();
      setBounds(200,0,Ancho,Alto);

      //panel de botones de la parte izquierda de la ventana
      JPanel panel3 = new JPanel();
      boton1=new JButton("Start");
      boton2=new JButton("Stop");
      boton3=new JButton("+ Pelotas");

      panel3.setBackground(Color.blue);
      panel3.setLocation(0,0);
      panel3.setSize(200,Alto-38);
      panel3.setLayout(new GridLayout(3,1));
      panel3.add(boton1);
      panel3.add(boton2);
      panel3.add(boton3);

      boton1.addActionListener(new o_Start());//oyente boton cambio1
      boton2.addActionListener(new o_Stop());//oyente boton cambio2
      boton3.addActionListener(new o_Pelotas());//oyente boton cambio3

      ventana.add(panel3);
      panel.setPreferredSize(new Dimension(Ancho,Alto));
      panel.setLayout(null);
      panel.add(this);

      ventana.setBounds(0,0,Ancho+200,Alto);
      ventana.setLocationRelativeTo(null);//hace que la ventana aparezca en el centro de la pantalla
      ventana.setVisible(true);//hace que la ventana sea visible
      ventana.setResizable(false);//hace que la ventana no se pueda cambiar de tamaño (maximizar, minimizar)

      //hace que finalice el programa al cerrar la ventana
      ventana.addWindowListener( new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
      System.exit(0);
      }
      });

      //timer para controlar la velocidad del juego
      ActionListener juego = new ActionListener()
      {
      public void actionPerformed (ActionEvent e)
      {
      game();
      }
      };
      timerJuego = new Timer (Velocidad,juego);

      }

      //clase privada para el boton Cambio1
      private class o_Start implements ActionListener{
      public void actionPerformed(ActionEvent e)
      {
      timerJuego.start();
      }
      }

      //clase privada para el boton Cambio2
      private class o_Stop implements ActionListener{
      public void actionPerformed(ActionEvent e)
      {
      timerJuego.stop();
      }
      }

      //clase privada para el boton Cambio3
      private class o_Pelotas implements ActionListener{
      public void actionPerformed(ActionEvent e)
      {
      annadirPelotas();
      }
      }

      Eliminar
    2. y aquí va la parte que falta:

      /***************************************************************************************************************
      * Métodos con la lógica del juego
      **************************************************************************************************************/


      //añade pelotas al arraylist
      public void annadirPelotas(){
      Pelotas.add(new Bola(posHorizontalBolaRebote,0));
      posHorizontalBolaRebote=posHorizontalBolaRebote+100;
      }

      /***************************************************************************************************************
      * Métodos encargados de la parte gráfica
      **************************************************************************************************************/
      //pinta el mundo con los UFOS y tiene la posibilidad de ir cambiando de gráficos
      public void pintaTodo() {

      Graphics g = buffer.getGraphics();
      g.setColor(Color.WHITE);
      g.fillRect(0,0,getWidth(),getHeight());

      for(int i=0; i<Pelotas.size();i++){
      g.drawImage(img.getImagen("bola.gif"), Pelotas.get(i).getPosX(), Pelotas.get(i).getPosY(),this);//pinta los pelotas
      }

      //g.drawImage(img.getImagen("bola.gif"), bola.getPosX(), bola.getPosY(),this);

      getGraphics().drawImage(buffer,0,0,this);

      }
      //métodos para evitar el parpadeo
      public void paint(Graphics g) {}

      public void update(Graphics g) {}

      /***************************************************************************************************************
      * Métodos principal del juego
      **************************************************************************************************************/
      //procedimiento que se encarga del juego
      public void game() {
      for(int j = 0; j<Pelotas.size();j++){
      Pelotas.get(j).rebote();
      }

      pintaTodo();

      }
      }

      Eliminar