Foro de elhacker.net

Programación => Java => Mensaje iniciado por: Z@@K en 15 Julio 2014, 19:07 pm


Título: Aprendiendo a desplazar imagenes
Publicado por: Z@@K en 15 Julio 2014, 19:07 pm
Hola de nuevo!!!

Bueno, les explico, yo soy nuevo programando en Java y me interesa mucho adentrarme en el mundo de la programación... Además ya pasé con éxito la prueba de iniciación en la creación de mi propio "Hola mundo!" así que no me detendré ahora.

Estoy aprendiendo a crear graficos 2D y mostrarlos en un JPanel el cual se agrega a un JFrame, bla bla bla etc

Bueno, si quiero utilizar el teclado de direcciones del pc (arriba, abajo, izquierda y derecha) para darle movimiento a uno de estos graficos (o a una imagen insertada) he aprendido a utilizar la interfaz "KeyListener" junto con la clase "KeyEvent" y una que otra linea de código.

El problema que encuentro en esto es que si mantengo una tecla de dirección presionada el método keyPressed se activa una vez, luego hace una pausa y luego se activa continuamente.

¿como puedo hacer para que desde el momento que que presiona la tecla y la mantenga presionada el método keyPressed se mantenga dando una respuesta continua y no haga esa odiosa pausa?

Que pasen un agradable día.
Gracias por la atención.

Saludos!

Título: Re: Aprendiendo a desplazar imagenes
Publicado por: Zoik en 17 Julio 2014, 22:24 pm
Hola, prueba con alguno de los demás métodos de KeyEvent

Código
  1. 	public void keyReleased(KeyEvent e) {
  2. //detecta evento al soltar tecla
  3. 	}
  4.  
  5. 	public void keyTyped(KeyEvent e) {
  6. //detecta evento al tocar tecla
  7. 	}

Título: Re: Aprendiendo a desplazar imagenes
Publicado por: Z@@K en 18 Julio 2014, 02:31 am
Hola!!!
Soy yo nuevamente : P
Gracias Zoik!, pero fijate que ya solucioné este problema : )

Explicaré como fue solucionado para todos los novatos que se pasen por aquí.

Yo estaba tratando de hacer un juego llamado Ping Pong en Java, de un solo jugador...
ustedes saben, aquel viejo juego de una pelotita revotando por todos lados y un pedazo de tabla intentando impedir que caiga en lo mas profundo de la ventana...

Bueno, el caso es que al fin había terminado el juego por mi propia cuenta (estaba bien feliz), el código es el siguiente:

Código
  1. import java.awt.Color;
  2. import java.awt.Graphics;
  3. import javax.swing.JFrame;
  4. import java.awt.event.KeyEvent;
  5. import java.util.logging.Level;
  6. import java.util.logging.Logger;
  7. import javax.swing.JOptionPane;
  8.  
  9. public class PingPong extends javax.swing.JPanel implements java.awt.event.KeyListener{
  10.     int arriba;
  11.     int abajo;
  12.     int x;
  13.     int y;
  14.     boolean continuar = true;
  15.     Mover motor;
  16.     PingPong(){
  17.         motor= new Mover();
  18.         x=18;
  19.         y=98;
  20.         arriba=82;
  21.         abajo=arriba + 40;
  22.         setFocusable(true);
  23.         addKeyListener(this);
  24.     }
  25.  
  26.     public static void main(String[] agrs){
  27.         JFrame isaac = new JFrame("Hola");
  28.         PingPong daniel = new PingPong();
  29.         isaac.add(daniel);
  30.         isaac.setSize(420, 250);
  31.         isaac.setDefaultCloseOperation(3);
  32.         isaac.setVisible(true);
  33.         daniel.motor.start();
  34.  
  35.     }
  36.  
  37.     public void keyReleased(KeyEvent e) {}
  38.  
  39.     public void keyTyped(KeyEvent e) {}
  40.  
  41.     public void keyPressed(KeyEvent e) {
  42.         if(e.getKeyCode()==KeyEvent.VK_DOWN)
  43.             arriba+=18;
  44.         if(e.getKeyCode()==KeyEvent.VK_UP)
  45.             arriba-=18;
  46.         if(arriba<10)
  47.             arriba=10;
  48.         if(arriba>162)
  49.             arriba=162;
  50.         abajo=arriba + 40;
  51.         repaint();
  52.     }
  53.  
  54.     public void paint(Graphics g){
  55.         super.paint(g);
  56.         g.fillRect(0, 0, 400, 250);
  57.         g.clearRect(0, 10, 382, 192);//Area de movimiento
  58.         g.fillRect(10, arriba, 8, 40);//La tabla
  59.         g.fillRect(x, y, 8, 8);
  60.         //System.out.println(arriba + ", " + abajo);
  61.  
  62.     }
  63.     class Mover extends Thread{
  64.         int velocidad;
  65.         int movimientoX;
  66.         int movimientoY;
  67.         int countLoop=0;
  68.         Mover(){
  69.  
  70.             velocidad=10;
  71.             movimientoX=4;
  72.             movimientoY=-4;
  73.         }
  74.         public void run(){
  75.             while(continuar){
  76.                 try{
  77.                     Thread.currentThread().sleep(velocidad);
  78.                     moverBola();
  79.                     repaint();
  80.                     countLoop++;
  81. 		    System.out.println(countLoop*velocidad/1000);
  82.                     if(x+8<=0){
  83.                         JOptionPane.showMessageDialog(null, "Game Over...\nYou last for " + countLoop*velocidad/1000 + " Seconds!");
  84.                         this.stop();
  85.                     }
  86.  
  87.                 }
  88.                 catch (InterruptedException ex) {
  89.                         Logger.getLogger(PingPong.class.getName()).log(Level.SEVERE, null, ex);
  90.                 }
  91.             }
  92.         }
  93.  
  94.  
  95.         public void moverBola(){
  96.             y+=movimientoY;
  97.             x+=movimientoX;
  98.             check();
  99.         }
  100.  
  101.         public void check(){
  102.             if(y<=10 || y>=194)
  103.                 movimientoY=-movimientoY;
  104.             if(x==374)
  105.                 movimientoX=-movimientoX;
  106.             if(x==18 && movimientoX<0)
  107.                 if(y<abajo && (y+8)>arriba){
  108.                     movimientoX=-movimientoX;
  109.                 }
  110.         }
  111.  
  112.  
  113.     }
  114. }
  115.  

//La linea 88 y 89 de este código no las entiendo, pero siempre las utilizo despues
//del try cuando aplico ese Thread por que
//si no el IDE me dice que las agregue (Las utilizo por que las aprendí de otro
//código de un juego que me encontré hace un par de semanas)

Yo se que visualmente el jueguito está horrible jajaja, pero yo lo hice solo para poner en practica lo aprendido y no le puse mucha importancia a como quedara visualmente...

bueno, el problema era que yo puse en el código que cada vez que el jugador presionara las teclas de arriba o abajo se sumaría o restarían 18 a la posición vertical de la tabla, pero me dí cuenta probando el juego que si el jugador mantenía la tecla de arriba o de abajo presionada con el objetivo de que la tabla corriera continuamente, la tabla primeramente daba un paso y hasta después corría continuamente : (

En ese entonces fue cuando les consulté que podía hacer...
Hasta que en una pagina encontré que explicaban como hacer exactamente este jueguito con el nombre de: "Minitenis" y pude verificar como aplicaron otra lógica para que el movimiento de la tabla sea siempre continuo.

Les comparto la página donde encontré la creacion de "Minitenis":

http://edu4java.com/es/game/game0.html (http://edu4java.com/es/game/game0.html)

La lógica que aplican en el desarrollo de este sencillo juego es que cuando el jugador presiona arriba o abajo, el código que está en el método "keyPressed" cambia la cantidad que se está sumando continuamente (mediante un while) a la posición vertical de la tabla de cero a uno o menos uno (en dependencia de si se aprieta arriba o abajo) y el método "keyReleased" convierte esta cantidad nuevamente a cero...

si no me entendieron pueden ver el código en el link que les mostré, y verán lo ordenado y genial que está comparado con el mío.... jajajaja... bueno, con algo se empieza ;)

Saludos a todos!!!!!
Muchas gracias por su atención.


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines