package bolaslocas;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.JComponent;
/**
*
* @author Yacoobs
* 7 de diciembre del 2017 a las 9:00
* Este secillo programa genera un bucle cerrado de repintados con el metodo repaint().
* Al mismo tiempo si pulsas la barra Spaciadora esta va generando aleatoriamente pelotas en fraciones
* de 50 unidades por pulsacion, sale un marcador donde se recuentan la cantidad de pelotas y otro que marca
* los FPS fotogramas por segundo de refresco de la pantalla. Usando el metodo System.nanoTime().
* De fondo se muestra una imagen de 1280 * 1024 y las pelotas son un BufferedImage o un fillOvalo().
* Espero que disfruten y aprendan lo sencillo que es mover imagenes sobre un Frame.
*/
public class BolasLocas extends javax.swing.JFrame {
private String version="V.0.1";
//Estas variables definen el tamaño de nuestro Frame.
private int DimensionX=1280;
private int DimensionY=720;
//Estas Variables Vector almacenan una serie de array de Posiciones X e Y de la pelota en movimiento.
private Vector<Integer> PosicionX = new Vector<>(50000,0);
private Vector<Integer> PosicionY = new Vector<>(50000,0);
//Estas Variables Vector almacenan el Aumento o Disminucion del valor X o Y. Esto crea el movimiento de la Bola.
private Vector<Integer> X = new Vector<>(50000,0);
private Vector<Integer> Y = new Vector<>(50000,0);
//Almacena la cantidad de Bolas en la pantalla.
private int Numero_Bolas;
//Almacena las imagenes que seran cargadas por la parte grafica.
private BufferedImage Image, Pelota;
//Da valor continuo al bucle While().
private boolean Empezar;
//Almacena el tiempo obtenido por el metodo nanoTime().
private long Obtener_Tiempo;
//Se usa para comparar con el tiempo Obtenido +1 segundo despues.
private long Obtener_Despues;
//La usamos para pasar el tiempo nano en segundos.
private final long divide=1000000000;
//Almacenamos los fps obtenidos despues de 1 segundo.
private int obten;
//Alamacenamos los Frames por segundos que hace nuestro Frame durante 1 segundo.
private int fps;
//Constructor del programa.
public BolasLocas() {
setTitle(version);
initComponents();
setBounds(0,0,DimensionX,DimensionY);
try { Image = ImageIO.read(new File("ImgFondo.jpg").getAbsoluteFile()); Pelota = ImageIO.read(new File("Pelota.png").getAbsoluteFile()); } catch (IOException ex) { System.out.println("Error Ruta "); System.out.println(ex);
}
//Añadimos la clase interna a nuestro Frame.
add(new FrameGraficos());
Empezar=true;
//Metodo encargado de crear un bucle infinito que solamente se encarga de hacer un refresco de pantalla.
CrearBucle();
}
public class FrameGraficos extends JComponent{
public void paint(Graphics g){
Graphics2D g2 = (Graphics2D) g;
g2.drawImage(Image, 0 , 0, 1280, 720, this); //Se imprime una imagen de fondo en el Frame.
//
int N=0;
for (int PosX:PosicionX){ //Recorremos con un bucle el Vector PosicionX.
int PosY = PosicionY.get(N); //Guardamos y obtenemos la PosicionY del Vector.
int LaX = X.get(N); //Obtenemos el incremento de X.
int LaY = Y.get(N); //Obtenemos el incremento de Y
g2.drawImage(Pelota, PosX, PosY, this);
g2.setColor(Color.red);
//g2.fillOval(PosX, PosY,10, 10);
//Este metodo se encarga del movimiento de la bola pasando 5 argumentos necesarios para la gestion.
BolaImpata_Perimetro(PosX, PosY, LaX, LaY, N);
N++;
}
//Calculo de los Fps fotogramas por segundo o tasa de refresco.
//Devuelve el valor actual del temporizador de sistema más preciso disponible, en nanosegundos, lo dividimos entre 1 a la potencia
//de 9, para simplificar el numero a segundos.
Obtener_Tiempo = System.nanoTime()/divide;
if (Obtener_Tiempo>Obtener_Despues+1){ //Condicion se cumple siempre y cuando transcurra un segundo despues del obtenido.
Obtener_Despues=System.nanoTime()/divide; //Volvemos almadenar el tiempo obtenido por nanoTime().
obten=fps; //Guardamos en la variable obten los fps obtenidos en refresco.
fps=0; //Reiniciamos la variable fps a 0.
}
fps++;
if (Empezar){ g2.setColor(Color.GREEN);
}else{ g2.setColor(Color.RED);
}
g2.setFont(new Font("Verdana",Font.BOLD,40)); g2.drawString("Fps: " + obten, 10, 50); g2.setFont(new Font("Verdana",Font.BOLD,20)); g2.drawString("Bolas: " + Numero_Bolas, 650, 50);
}
}
//Metodo encargado de crear el Bucle infinito con refresco.
public void CrearBucle(){
Thread hilo = new Thread(new Runnable() { //Ese hilo de ejecucion se crea para no bloquear el programa principal.
@Override
public void run() {
while (Empezar){ //Bucle cerrado mientras la condicion se cumpla.
try { //Crea una pausa de 30 ms a mayor numero menor cantidad de refrescos menos fps a menor cantidad mas fps mas refresco.
Thread.sleep(30);
} catch (InterruptedException ex) { Logger.getLogger(BolasLocas.class.getName()).log(Level.SEVERE, null, ex);
}
repaint(); //Redibujado, refresco, repintado del Frame.
}
}
});
hilo.start(); //Inicio del metodo run() Thread.
}
//Evalua las condiciones de la pelota cuando imparta en las cuatro posiciones del Frame,
public void BolaImpata_Perimetro(int Posicion_BolaX, int Posicion_BolaY, int LaX, int LaY, int N){
//Hacemos el movimiento de la bola sumando el contenido de X e Y...
Posicion_BolaX +=LaX;
Posicion_BolaY +=LaY;
//Cuando la bola impacta sobre la superficie de la pared de la izquierda
if (Posicion_BolaX<0){ LaX = -LaX;
}
//Cuando la bola impacta sobre la superficie de la pared de arriba.
if (Posicion_BolaY<0){ LaY = -LaY;
}
int Perimetro_Derecho = getWidth();
//Cuando la bola impacta sobre la superficie de la pared de la derecha.
if (Posicion_BolaX>Perimetro_Derecho-20){ LaX = -LaX;
}
//Cuando la bola sobre pasa la parte inferior de la plataforma y perdemos una bola de juego....
if (Posicion_BolaY>getHeight()-50){ LaY = -LaY;
}
//Vamos modificando los vectores obteniendo el indice correspondiente y su nueva poscion BolaX y BolaY.
PosicionX.set(N, Posicion_BolaX);
PosicionY.set(N, Posicion_BolaY);
//Iden de lo mismo pero el incremento o decremento del valos LaX y LaY de la posicion del Vector.
X.set(N, LaX);
Y.set(N, LaY);
}
@SuppressWarnings("unchecked") // <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setResizable(false);
addKeyListener(new java.awt.event.KeyAdapter() { public void keyPressed(java.awt.event.KeyEvent evt) { formKeyPressed(evt);
}
});
pack();
}// </editor-fold>
private void formKeyPressed(java.awt.event.KeyEvent evt) {
int Code = evt.getKeyCode();
if (Code==32){ //Creamos este bucle for para generar 50 pelotas por cada golpe de tecla.
for (int g=0;g<50;g++){ int PoX = (int) (Math.random()*(getWidth()-80));
int PoY = (int) (Math.random()*(getHeight()-80));
int Xx = (int) (Math.random()*9+1);
Numero_Bolas++;
PosicionX.add(PoX);
PosicionY.add(PoY);
X.add(Xx);
Y.add(Xx);
}
}
if (Code==27){ if (Empezar){ Empezar=false;
}else{ Empezar=true;
CrearBucle();
}
}
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new BolasLocas().setVisible(true);
}
});
}
// Variables declaration - do not modify
// End of variables declaration
}
Crear cuenta
Comentarios sobre la versión: Fps V0.1 (0)
No hay comentarios