Mensajes

No quiero disputas otra vez más, ya cumplió su ban si se demuestra que copia pues se le volverá a bannear, hasta entonces.. 

PD - Lo muevo a net =P

Si, pero ni aún poniendo un Thread.sleep(90000) se dibuja el fondo... Al final e conseguido resolver el problema de una forma que no me convence mucho pero bueno..

La idea era hacer un juego estilo worms, de tal manera que el suelo se fuese rompiendo a medida que se le disparase. Esto lo logro dibujando sobre un bufferedImage que contiene la imagen del suelo figuras geométricas, así que este es el método dibujar de la clase fondo:

Código (java) [Seleccionar] Expandir


    public void dibujar(Graphics2D g2)
    {
        // Dibujamos el escenario sin agujeros
        Graphics2D gEscenario = buffEscenario.createGraphics();
        Image aux = Toolkit.getDefaultToolkit().getImage(Main.class.getResource(rutaImagen));
        gEscenario.drawImage(aux, 0, 0, null);
       
        // Dibujamos sobre el escenario los agujeros
        gEscenario.drawImage(buffGeom, 0, 0, null);
       
        // Hacemos los agujeros transparentes
        hacerColorTransparente(buffEscenario, Color.magenta);
                               
        // Dibujamos el fondo y el escenario con los agujeros
        g2.drawImage(buffFondo  , 0, 0, null);
        g2.drawImage(buffEscenario, 0, 0, null);
    }


Está bastante menos optimizado que la otra idea, pero por lo menos funciona... a ver si alguien consigue saber por que lo otro no funciona...

Salu2

Pues me supongo que si, por que si no menudo código más feo.. xDDD

Hola

Estoy realizando una aplicación que me tiene que pintar sobre un JFrame una imagen de fondo (cargada en un BufferedImage) e ir pintando dentro de ese mismo BufferedImage distintas figuras geométricas.
El problema es que la imagen de fondo es de tamaño 800x600 que se pinta en la constructora de la clase "Fondo" y no le da tiempo. Pongo el código y luego explico con más detalle:

Main.java:

Código (java) [Seleccionar] Expandir


public class Main extends JFrame
{   
    // Ancho y alto de la ventana
    private final int ANCHO = 800;
    private final int ALTO  = 600;   
   
    // El media tracker
    MediaTracker tracker;
   
    // El fondo
    Fondo fondo;
   
    /***************************************************************************
     **************************       INCIALIZAR      **************************
     ***************************************************************************/
   
    public static void main(String[] args) { new Main(); }
   
    Main()
    {
        // Inicializamos los objetos
        tracker = new MediaTracker(this); // El media tracker que usaré comúnmente a todas las clases
        fondo   = new Fondo(tracker);
       
        // Inicializamos las propiedades de la ventana
        this.setTitle("Roimpiendo texturas");
        this.setSize (ANCHO, ALTO);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setLocation(150, 150);
        this.setVisible(true);       
    }

   
    /***************************************************************************
     **************************        DIBUJAR        **************************
     ***************************************************************************/
   
    private void dobleBuffer(Graphics2D g2)
    {     
        fondo.dibujar(g2, tracker);
       
        repaint();       
    }
   
    public void paint (Graphics g)
    {
        Graphics2D g2 = (Graphics2D) g;
       
        Image mImagen = createImage(ANCHO, ALTO);
        dobleBuffer((Graphics2D)mImagen.getGraphics());
       
        g2.drawImage(mImagen, 0, 20, this);
       
        try { Thread.sleep(100); } catch(Exception e) {}
    }   
}


Fondo.java:

Código (java) [Seleccionar] Expandir


public class Fondo
{
    // Propiedades de las imágenes
    private final String  rutaImagen = "imagenes/fondo.gif";
    private BufferedImage imagen;
   
    public final int anchoImagen = 800;
    public final int altoImagen  = 600;
   
       
    /***************************************************************************
     ***************************    CONSTRUCTORAS    ***************************
     ***************************************************************************/
   
    public Fondo(MediaTracker tracker)
    {
        // Inicializamos el buffer sobre el que pintaremos
        imagen = new BufferedImage (anchoImagen, altoImagen, BufferedImage.TYPE_INT_ARGB);
       
        // Dibujamos dentro del buffer el fondo
        Graphics2D g = imagen.createGraphics();
        Image aux = Toolkit.getDefaultToolkit().getImage(Main.class.getResource(rutaImagen));
       
       
        // Añadimos las imagenes al MediaTracker
        tracker.addImage(aux, 0);

        g.drawImage(aux, 0, 0, null);
       
        // Aquí intento que espere hasta que esté pintado pero sin éxito...       
        try{tracker.waitForAll();}catch(Exception e){}
    }
   
       
    /***************************************************************************
     ***************************       DIBUJAR       ***************************
     ***************************************************************************/
   
    public void dibujar(Graphics2D g2, MediaTracker tracker)
    {             
        g2.drawImage(imagen, 0, 0, null);
        //try{tracker.waitForAll();}catch(Exception e){} // ¿Es necesario?
    }

}



Como podéis ver el mecanismo de la clase fondo es simple, en la constructora dibuja el fondo (se supone que el objeto MediaTracker debería esperar a que lo hiciese...) y en el método dibujar simplemente dibuja el BufferedImage ya que hay otros métodos encargados de dibujar sobre el mismo figuras geométricas como decía al principio.

Ahora mis dos dudas:
1 - ¿Cómo puedo hacer que realmente el programa espere a que el fondo esté pintado?
2 - ¿Está bien inicializado el objeto MediaTracker? Ya que no entiendo muy bien la explicación de la constructora en la documentación:
http://java.sun.com/j2se/1.4.2/docs/api/java/awt/MediaTracker.html

1S4ludo y gracias

Cada tema en su subforo por favor =P

Supongo que en "factura.java" tendrás una clase que herede de JFrame o algo así, crea un objeto de esa clase y listo.

Sale en todos los enlaces de rapidshare, no pasa nada, es solo para habisar de que no está verificado por el foro =P

La mejor documentación es esta:
http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/pecoff_v8.docx

Solo tengo una duda, por ejemplo, yo añado una sección al ejecutable, como podria hacer para que el EntryPoint apuntara a esa nueva sección?

Cambiar el EP es simplemnte cambiar 4 bytes, haya el inicio de la nueva sección y ponle ese valor al EP, ten en cuenta el endian y si es VA o no

Esto va en el foro de Java Busaca por las chinchetas del foro por que hay muchisima documentación sobre swing

Código (java) [Seleccionar] Expandir


File archivo = "tu_ruta";
archivo.length(); // Te devuelve el tamaño


Así puedes hallar el tamaño del archivo para definir el tamaño del buffer

O lo preguntas en el foro de C o lo preguntas aquí, pero no lo preguntes en los dos En que lenguaje estás programando? aunque básicamente ya te han dicho la solución...

Supongo que cada enemigo será un Sprite guardado en un arreglo. Tienes que insertar una condición que verifique si la bala ha llegado a los enemigos, y si llega que se borre la unidad en la que está el enemigo, lo cual mostraría su coordenada vacía.

Para hacer lo que te estoy intentando explicar, hay algunos algoritmos de choques de sprites, te dejo aquí uno que creo que es bastante útil:

http://softwarelibre.uca.es/wikijuegos/Colisiones

Saludos.