Buenos días.

Tengo un problema con un ejercicio y no se como solucionarlo.
El problema es que el código hace cada vez una cosa diferente:

- Se queda colapsado
- Se para y no realiza bien todo lo que tiene que hacer
- Da un error del tipo: ArrayOutIndexException
- Funciona correctamente

Dejo el código a ver si alguien puede ayudarme:

Clase principal

package quicksort;
 
import java.util.Stack;
import java.util.Arrays;
 
public class QuicksortTarea {
	static Stack<int[]> pila = new Stack<int[]>();
	static int[] numeros = { 11, 25, 3, 9, 4 };
 
	public static void main(String[] args) {
		System.out.println("Array de números sin ordenar");
		imprimirArrayNumeros(numeros);
		controlPilas();
		// Mostramos el array ordenado
		System.out.println("\nArray de números ordenados");
		imprimirArrayNumeros(numeros);
	}
 
	// Método que muestra el array de números
	public static void imprimirArrayNumeros(int numeros[]) {
		for (int contador = 0; contador < numeros.length; contador++) {
			System.out.print(numeros[contador] + " ");
		}
	}
	public synchronized static void controlPilas() {
		//Introducimos la primera tarea en la pila
		int[] paso1 = new int[3];
		paso1 [0] = 0;
		paso1 [1] = numeros.length-1;
		//Indica si tiene thread 0 - NO / 1 - SI
		paso1 [2] = 0;
		pila.add(paso1);
		while (!pila.isEmpty()) {
			while (pila.get(pila.size()-1)[2] == 0) {
				ThreadTarea tarea = new ThreadTarea(pila, numeros, pila.get(pila.size()-1)[0], pila.get(pila.size()-1)[1]);
				tarea.start();
				pila.get(pila.size()-1)[2] = 1;
			}
		}
	}
}

Clase Thread

package quicksort;
 
import java.util.Arrays;
import java.util.Stack;
 
public class ThreadTarea extends Thread {
	Stack<int[]> pila; 
	int[] array;
	int izquierda;
	int derecha;
 
	public ThreadTarea(Stack<int[]> pila, int[] array, int izquierda, int derecha) {
		this.pila = pila;
		this.array = array;
		this.izquierda = izquierda;
		this.derecha = derecha;	
	}
 
	//Stack<int[]> pila, int[] array
	public void run() {
		//Guardamos los primeros valores de la pila
		int min =  pila.get(pila.size()-1)[0];
		int max =  pila.get(pila.size()-1)[1];
		//Usamos como pivote el valor de la izquierda
		int pivote = array[izquierda];
		System.out.println("\n El pivote es : " + pivote);
		//Creamos un boolean para comprobar el lado del array en el que estamos, siendo lado izquierdo = true y lado derecho = false
		boolean lado = false;
		while (izquierda < derecha) {
			if (lado == true) {
				if (array[izquierda] <= pivote) {
					izquierda++;
				}
				else {
					array[derecha] = array[izquierda];
					derecha--;
					lado = false;
				}
			}
			else {
				if (array[derecha] > pivote) {
					derecha--;
				}
				else {
					array[izquierda] = array[derecha];
					izquierda++;
					lado = true;
				}
			}
		}
		//Cambiamos el pivote de lado
		array[derecha] = pivote;
		// Comprobamos si necesitamos añadir nuevas tareas a la pila
		if (izquierda > min) {
			int[] paso2 = new int[3];
			paso2 [0] = min;
			paso2 [1] = izquierda-1;
			paso2 [2] = 0;
			pila.add(paso2);
		}
		if (derecha < max-1) {
			int[] paso3 = new int[3];
			paso3 [0] = derecha+1;
			paso3 [1] = max;
			paso3 [2] = 0;
			pila.add(paso3);
		}
		//Eliminamos la tarea de la pila porque ya se ha utilizado
		pila.remove(pila.size()-1);
	}
}

Gracias de antemano.

Buenos días a tod@!

Me presento, soy estudiante de un FP de informática y tengo que realizar una "copia" lo más parecida a esta versión de Asteroid: http://www.juegomaniac.com/jugar.php?id=51&ancho=740&alto=510

A base de manuales y explicaciones he conseguido ir haciendo poco a poco. El problema es que tengo algunos problemas y no consigo solucionar por más pruebas que realizo. Hay parte de código desactivada porque al quitar el funcionamiento del Thread, funciona.

Aquí os expongo una explicación de uno de los problemas que tengo. Gracias de antemano por molestarse en el leer el post.

Los thread de Asteroid, Disparo y Enemigo:

- Con el Asteroid el problema que tengo es cuando disparo a uno de ellos a la hora de dividirse se queda parado, entiendo que es porque esos nuevos asteroides creados no se ponen en marcha, pero he intentado todas las formas que he creído que deberían de funcionar para que funcionen, pero algo hago mal. Y además en ocasiones no detectan las colisiones. Esta puesto en start porque en el método de Acciones, no funcionaba.

- Con el de Enemigo, el problema es que no detecta las colisiones al poner el Thread, sin él, funciona correctamente. Esta puesto en el método de acciones porque en start no funcionaba.

- El disparo, directamente no funciona, se muestra el disparo, y ya esta, no se mueve.

Os pongo todo el código para que entendáis como lo tengo a ver si alguien sabe dónde esta el fallo.

EspacioFrame - Arranca el juego

package asteroides;
 
//Importamos las librerias necesarias
import java.awt.BorderLayout;
import javax.swing.JFrame;
 
/**
 * Clase del juego que contiene Jframe con la parte del Canvas y se inicia el juego
 */
 
public class EspacioFrame extends JFrame {
    public EspacioFrame() {
        //Iniciamos un espacio que contiene el canvas
        EspacioCanvas jc = new EspacioCanvas ();
        //Lo añadimos
        this.add(jc, BorderLayout.CENTER);
        //Le damos el tamaño que tiene
        this.setSize((int)jc.ancho, (int)jc.alto);
        //Le decimos como debe cerrarse
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //Centramos la ventana
        this.setLocationRelativeTo(null);
        //Le ponemos un titulo a la ventana
        this.setTitle("Asteroid by Sandra Ibañez");  
        //Lo hacemos visible
        this. setVisible (true);
        //Creamos dos bufferstrategy para el paint
        jc.createBufferStrategy(2);
        //Iniciamos el juego que conriene el canvas
        jc.start();
    }
 
    public static void main(String[] args) {
        //Iniciamos el juego
        EspacioFrame j1 = new EspacioFrame();  
        j1.repaint(); 
    }
}

EspacioCanvas: Parte gráfica del juego y acciones del juego

package asteroides;
 
//Importamos librerias
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.Point2D;
import java.awt.image.BufferStrategy;
import java.util.ArrayList;
import javax.swing.JOptionPane;
 
/**
 * Clase del juego que contiene el canvas, y keylistener para las teclas del teclado
 * OBJETIVO; Copiar la versión del juego Asteroid: http://www.juegomaniac.com/jugar.php?id=51&ancho=740&alto=510
 * ESPACIO: DISPARA
 * ARRIBA: ACELERA
 * IRQUIERDA: GIRA IRQUIERDA
 * DERECHA: GIRA DERECHA
 * SHIFT: DESAPARECE DE LA POSICIÓN Y APARECE EN OTRA POSICIÓN ALEATORIA
 */
public class EspacioCanvas extends Canvas implements KeyListener, Runnable {
    //Tamaño de la ventana del juego
    double ancho;
    double alto;
    //Variables de tiempo
    long refrescar;
    long inicio;
    long fin;
    //Variables de jugador
    int vidas;
    long puntos;
    String nombre;
    //Nave
    Nave nave;
    //Booleans para saber si hay colisión
    boolean colisionNave;
    //ArrayList de disparos
    ArrayList<Disparo> disparos;
    //Variables del disparo
    final double tiempoDisparo = 10;
    double tiempoFinalDisparo;
    //ArrayList de los asteroid
    ArrayList <Asteroid> asteroides;
    //Número de asteroides con los que se inicia el juego
    int numeroAsteroides = 4;
    //ArrayList de asteroides eliminados
    ArrayList<Asteroid> asteroidEliminado;
    ArrayList<Enemigo> ovni;
    //Threads para arranque (tiempo para iniciar), espera (tiempo para actualizar), naveFuera (tiempo que la nave desaparece, cuando choca o se mueve a otro sitio)
    Thread arranque;
    Thread espera;
    //Dimension de la ventana
    Dimension dim;
    //Booleans para el paint, y mostrar nave o no (por colisión)
    boolean repintar = false;
    boolean mostrarNave = false;
    boolean ovn = false;
    int contador;
    int vidaOvni = 1;
    long contSalirOvni;
    /**
     * Constructor de la clase.
     */
    public EspacioCanvas () {
        //Configuraciones de la ventana
        setIgnoreRepaint (false);
        resize (740, 510);
        dim = getSize ();
        ancho = dim.width;
        alto = dim.height;
        //Tiempo de actualización
        refrescar = 25;
        //Cogemos las acciones del teclado
        addKeyListener(this);
        setFocusable(true);
        //Creamos una nave nueva en el centro
        nave = new Nave(ancho/2, alto/2, 30, 0.10, 0.5, 0.90);
        //Boolean relacionado con la nave, falsos
        colisionNave = false;
        //Número de vidas
        vidas = 3;
        //Declaramos los arrayList
        asteroides = new ArrayList<Asteroid>();
        asteroidEliminado = new ArrayList <Asteroid>();
        disparos = new ArrayList<Disparo>();
        ovni = new ArrayList <Enemigo>();
    }
    /**
     * Get de las vidas de la nave - jugador
     * @return 
     */
    public int getVidas() {
        return vidas;
    }
    /**
     * Método de dibujar, mediante bufferstrategy se guardan los elementos y se van actualizando según las acciones
     * @param g 
     */
    @Override
    public void paint (Graphics g) {
        //Si el boolean es cierto, sigue
        if (repintar) 
            return;
        repintar = true;
        //Creamos una dimensión nueva con la anterior
        Dimension dNueva = dim;
        dNueva = getSize();
        //Cogemos el bufferstrategy
        BufferStrategy buffer = getBufferStrategy();
        //Le pasamos al graphics el dibujo
        Graphics imagen = buffer.getDrawGraphics();
        //Y la clase le pasamos el resultado
        super.paint(imagen);
        Graphics2D g2d = (Graphics2D) imagen;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        //Le ponemos fondo negro
        setBackground(Color.BLACK);
        //Pinta relleno de todo el juego
        g2d.fillRect(0, 0, (int) ancho, (int) alto);
        //Cogemos el color blanco
        g2d.setColor(Color.WHITE);
        //Dibujamos un string dónde se muestra la puntuación
        g2d.drawString(""+puntos, 30, 30);
        //Recorremos el array de los asteroides y los pintamos
        for (int cont = 0; cont < asteroides.size(); cont ++) { 
            asteroides.get(cont).pintar(g2d);
        }
        //Recorremos el array de los asteroides eliminados, cuando son disparados
        for (int cont = 0; cont < asteroidEliminado.size() ; cont ++) { 
            asteroidEliminado.get(cont).pintarExplosion(g2d);
        }
        //Pintamos disparos cuando se realizan
        for (int cont = 0; cont < disparos.size(); cont ++) { 
            disparos.get(cont).pintar(g2d);
        }
        //Si se debe mostrar el ovni, se muestra
        if (ovn) {
            for (int cont = 0; cont < ovni.size(); cont ++) {
                ovni.get(cont).pintar(g2d);
            }
        }
        //Si el boolean de mostrar la nave esta activado, la dibujamos
        if (mostrarNave) {
            nave.pintar(g2d);
        }
        //Si la nave ha chocado
        while (colisionNave) {
            colocarNave();
        }
        //Posición
        g2d.translate(40, 45);
        //Tamaño
        g2d.scale(0.50, 0.50);
        //Recorremos las vidas
        for (int cont = 0; cont < this.getVidas(); cont ++) {
            //Mostramos los dibujos en pequeño de la nave para las vidas
            g2d.setColor(Color.white);
            int [] posicionInicialHorizontal = {-8, 0, -6, 6, 8, 0};
            int [] posicionInicialVertical = {10, -10, 6, 6, 10, -10};
            g2d.drawPolygon(posicionInicialHorizontal, posicionInicialVertical, posicionInicialHorizontal.length);
            g2d.translate(30, 0);
        }
        //Si graphics es diferentre de null
        if (imagen != null) {
            imagen.dispose();
        }
        //Cerramos el buffer
        buffer.show();
        Toolkit.getDefaultToolkit().sync();
        //False el repintar
        repintar = false;
    }
    @Override
    public void update (Graphics g) {
        paint(g);
    }
 
    public void colocarNave () {
        //Restamos vidas
        vidas--;
        //Colocamos la nave al centro
        nave.setHorizontal(ancho / 2);
        nave.setVertical(alto / 2);
        //Volvemos a mostrar la nave
        mostrarNave = true;
        colisionNave = false;
    }
    @Override
    public void keyTyped(KeyEvent e) {}
    /**
     * Método que para cuando se pulsan las teclas 
     * @param e 
     */
    @Override
    public void keyPressed(KeyEvent e) {
        //Cogemos el código de la tecla presionada para saber que acción hace
        int tecla = e.getKeyCode();
        //Si la tecla es el espacio, dispara
        if (tecla == KeyEvent.VK_SPACE) {
            nave.disparo = true;
            if (tiempoFinalDisparo <= 0) {
                disparos.add(nave.disparo());
                tiempoFinalDisparo = tiempoDisparo;
            }
        }
        //Si la tecla es la de arriba, aumenta velocidad
        if (tecla == KeyEvent.VK_UP) {
            nave.acelerador = true;
        }
        //Si es la de derecha, va a la derecha
        if (tecla == KeyEvent.VK_RIGHT) {
            nave.derecha = true;
        }
        //Si es la de la irquierda, va a la irquierda
        if (tecla == KeyEvent.VK_LEFT) {
            nave.irzquierda = true;
        }
        //Si se pulsa la tecla shift, la nave desaparece de donde esta y aparece en otra posición
        if (tecla == KeyEvent.VK_SHIFT) {
            mostrarNave = false;
            double h = (Math.random() * ancho) + 1;
            double v = (Math.random() * alto) + 1;
            nave.setHorizontal(h);
            nave.setVertical(v);
            mostrarNave = true;
        }
    }
    /**
     * Método que se activa cuando las teclas se sueltam
     * @param e 
     */ 
    @Override
    public void keyReleased(KeyEvent e) {
        //Cogemos el código
        int tecla = e.getKeyCode();
        //Y desactivamos la opción de cada tecla
        if (tecla == KeyEvent.VK_SPACE) {
            nave.disparo = false;
        }
        if (tecla == KeyEvent.VK_UP) {
            nave.acelerador = false;
        }
        if (tecla == KeyEvent.VK_RIGHT) {
            nave.derecha = false;
        }
        if (tecla == KeyEvent.VK_LEFT) {
            nave.irzquierda = false;
        }
    }
    /**
     * Método para añadir más asteroides al juego según se van pasando pantallas.
     */
    public synchronized void masAsteroides() {
        //Damos el valor del numero de asteroides
        int numAsteroides = numeroAsteroides;
        //Tamaño del asteroide
        int tamaño;
        //Recorremos hasta encotrar el número de asteorides necesarios, según el nivel
        for (int cont = 0; cont < numeroAsteroides; cont ++) {
            //Escogemos posiciones aleatorias
            double asteroidHorizontal = (Math.random() * ancho) + 1;
            double asteroidVertical = (Math.random() * alto) + 1;
            //Escogemos una velocidad aleatoria de cada posición
            double velocidadHorizontal = Math.random() + 1; 
            double velocidadVertical = Math.random() + 1;
            //Escogemos la dirección
            double direccionHorizontal = (Math.random() * 2);
            double direccionVertical =  (Math.random() * 2);
            //Si la dirección es igual a 1
            if (direccionHorizontal == 1) {
                //A la velocidad le damos la vuelta
                velocidadHorizontal *= (-1);
            }  
            if (direccionVertical == 1) {
                velocidadVertical *= (-1);
            }
            tamaño = 2;
            //Añadimos el nuevo asteroide con los datos obtenidos 
            Asteroid ast = new Asteroid(asteroidHorizontal, asteroidVertical, 0, .1, velocidadHorizontal, velocidadVertical, tamaño);
            asteroides.add(ast);
            //Restamos el número por poner
            numAsteroides --;
            //Cogemos el centro del asteroide y la nave
            Point2D asteroidCenter = asteroides.get(cont).getCentro();
            Point2D naveCenter = nave.getCentro();
            //Calculamos la distancia
            double distancia = asteroidCenter.distance(naveCenter);
            ///Si la distancia entre el asteroide y la nave es menor de 80, no se crea 
            if (distancia <= 80) {
                asteroides.remove(cont);
                cont --;
                numAsteroides ++;
            }
        }
    }
    /**
     * Método que comprueba las acciones y colisiones relacionadas con los Asteroid y el ovni.
     */
    public synchronized void compruebaAccionesColisiones() {
       accionesAsteroid ();
       accionesOvni ();
    }
    /**
     * Método que determina las acciones del asteroid en función de su movimiento y choques
     * COLISIÓN CON LA NAVE 
     * COLISIÓN CON LOS DISPAROS DE LA NAVE
     * COLISIÓN CON LOS DISPAROS DEL OVNI.
     */
    public synchronized void accionesAsteroid(){
        //Recorremos los asteroides y los ponemos en movimiento
        for (int contA = 0; contA < asteroides.size(); contA ++) { 
//            asteroides.get(contA).start();
//            asteroides.get(contA).mover(ancho, alto);
            try {
                //Comprueba si chocan con la nave
                if (asteroides.get(contA).colisionNave(nave)) { 
                    //Los añadimos a los eliminados y explotamos
                    asteroidEliminado.add(asteroides.get(contA).explota());
                    //Los dividimos
                    divisionAsteroides(contA);
                    //si a la nave se le acaban las vidas
                    if (vidas <= 0 && !colisionNave) {
                        colisionNave = true;
                        mostrarNave = false;
                    }
                    //Si aún le quedan vidas
                    if (vidas > 0) {
                        colisionNave = true;
                        mostrarNave = false;
                        nave.setHorizontal(ancho/2);
                        nave.setVertical(alto/2);
                        nave.getRotAngulo();
                    }
                    //Restamos vida a la nave
                    vidas --;
                }
                //Comprueban si chocan con un disparo de la nave
                for (int contD = 0; contD < disparos.size(); contD ++) {
                    if (asteroides.get(contA).colisionDisparo(disparos.get(contD))) {
                        disparos.get(contD).limite = 0;
                        //Se le quita tiempo de vida
                        asteroides.get(contA).vidaAsteroide --;
                        if (asteroides.get(contA).vidaAsteroide > 0) { 
                            Asteroid a = asteroides.get(contA); 
                            //Según el radio del asteroid se da una puntuación o otra
                            if (a.getRadioAsteroid() >= 60) {
                                //Añadiomos los asteroides en el array
                                for (int contAE = 0; contAE < 3; contAE++) {
                                    asteroidEliminado.add(a.explota());
                                }
                                //Los dividimos el dos
                                divisionAsteroides(contA);
                                //Sumamos los puntos correspondientes
                                puntos += 20;
                            } 
                            else if (a.getRadioAsteroid() >= 30) {
                                for (int contAE = 0; contAE < 3; contAE++) {
                                    asteroidEliminado.add(a.explota());
                                }
                                divisionAsteroides(contA);
                                puntos += 50;
                            } 
                            else {
                                for (int contAE = 0; contAE < 3; contAE++) {
                                    asteroidEliminado.add(a.explota());
                                }
                                //Llegado a este punto, se eliminan
                                asteroides.remove(contA);
                                puntos += 100;
                            }
                        }
                        //Vamos eliminando los disparos
                        disparos.remove(contD);
                    }
                }
                //Comprueba si choca con los disparos del ovni, recorre los arraylist de ovni y el de disparos
                for (int contO = 0; contO < ovni.size(); contO ++) {
                    for (int contD = 0; contD <  ovni.get(contO).disparosOvni.size(); contD++ ) {
                        if (asteroides.get(contA).colisionDisparo(ovni.get(contO).disparosOvni.get(contD))) {
                            asteroides.get(contA).vidaAsteroide --;
                            ovni.get(contO).disparosOvni.get(contD).limite = 0;
                            if (asteroides.get(contA).vidaAsteroide > 0) {
                                Asteroid a = asteroides.get(contA);
                                asteroidEliminado.add(a.explota());
                                divisionAsteroides(contA);
                                asteroides.remove(contA);
                            }
                            if (asteroides.get(contA).vidaAsteroide <= 0) {
                                asteroides.remove(contA);
                            }
                        }
                    }
                    ovni.get(contO).disparosOvni.remove(this);
                }
            }
            catch (NullPointerException e) {}
        }
    }
    /**
     * Acciones que se realizan en función del movimiento y choques del ovni
     * COLISIÓN CON LOS DISPAROS DE LA NAVE
     * COLISIÓN CON LOS ASTEROID
     * COLISIÓN CON LA NAVE
     * COLISIÓN DE LA NAVE CON LOS DISPAROS DEL OVNI.
     */
    public synchronized void accionesOvni() {
        //Determinamos de forma aleatoria, cuando sale
        int aleatorio = (int) (Math.random() * 1000);
        if (contSalirOvni > 700) {
            //Si el número aleatorio es menor que el número de asteroides, sale
            if (aleatorio < asteroides.size()) {
                ovn = true;
            }
            //Le añadimos un ovni, si no hay ninguno
            if (ovn && ovni.size() < 1) {
                ovni.add(new Enemigo(-10, Math.random() * alto));
            }
        }
        try {
            //Recorremos y los vamos moviendo
            for (int contO = 0; contO < ovni.size(); contO ++) {
                ovni.get(contO).start();
//                ovni.get(contO).mover(ancho, alto);
                //Si el ovni se queda si vida, no sale
                if (vidaOvni == 0) {
                    ovn = false;
                }
                //Busca otro numero aleatorio, si es menor a número de asteroides, se le da vida.
                if (aleatorio < asteroides.size()) {
                    vidaOvni = 1;
                }
                //Comrpueba si le da un disparo de la nave
                for (int contD = 0; contD < disparos.size(); contD ++) {
                    if (ovni.get(contO).colisionDisparo(disparos.get(contD))) {
                        //Se le quita la vida al ovni
                        ovni.get(contO).vida --; 
                        vidaOvni --;
                        disparos.get(contD).limite = 0;
                        //Y puntuación
                        puntos += 120;
                    }
                }
                //Recorremos los asteroides para comprobar si se choca con alguno
                for (int contA = 0; contA < asteroides.size(); contA ++) { 
                    if (ovni.get(contO).colisionAsteroid(asteroides.get(contA))) {
                        ovni.get(contO).vida --;
                        vidaOvni --;
                        asteroidEliminado.add(asteroides.get(contA).explota());
                        divisionAsteroides(contA);
                        asteroides.remove(contA); 
                    }
                }
                //Comprueba si colisiona con la nave
                if (ovni.get(contO).colisionNave(nave)) { 
                    //Si la nave aún tiene vida
                    if(vidas > 0 && !colisionNave){
                        nave.setHorizontal(ancho/2);
                        nave.setVertical(alto/2);
                        colisionNave = true;
                        mostrarNave = false;
                    }
                    ovni.get(contO).vida --; 
                    vidaOvni --;
                    //Si no tiene vidas
                    if (vidas <= 0) { 
                        mostrarNave = false;
                        colisionNave = true;
                    }
                    vidas --;
                }
                //Comprueba si la nave es colisionada con un disparo del ovni
                if (nave.colisionDisparo(ovni.get(contO).disparosOvni) && !colisionNave) { //pregunta si lan ave colisiona con los disparos del ovni
                    //Si la nave no tiene vidas
                    if (nave.vida <= 0) {
                        mostrarNave = false;
                        colisionNave = true;
                    }
                    //Si le quedan
                    if (nave.vida > 0) {
                        mostrarNave = false;
                        nave.setHorizontal(ancho/2);
                        nave.setVertical(alto/2);
                        nave.getRotAngulo();
                        colisionNave = true;
                    }
                    vidas --;
                }
                ovni.get(contO).disparosOvni.remove(this);
            }
        } 
        catch (Exception e) {}
        //Recorremos el array list y si no tiene vidas ni el ovni o la nave, se eliminan.
        for (int cont = 0; cont < ovni.size(); cont ++) {
            if (ovni.get(cont).vida <= 0 || nave.vida <= 0) {
                ovni.remove(cont); 
            }
        }
    }
    /**
     * Método de la division de los asteroides.
     * @param num 
     */
    public synchronized void divisionAsteroides (int num) {
        //Seleccionamos el asteroide que se ha disparado
        Asteroid a = asteroides.get(num);
        //Cogemos las posiciones
        double asteroideHorizontal = a.getHorizontal();
        double asteroideVertical = a.getVertical();
        //Y dividimos el tamaño original en dos
        int tamaño = (a.getTamaño() / 2);
        //Recorremos los dos asteorides nuevos para determinar velocidad y dirección
        for (int cont = 0; cont < 2; cont++) {
            double velocidadHorizontal = Math.random() + 1; 
            double velocidadVertical = Math.random() + 1; 
            double direccionHorizontal = (Math.random() * 2);
            double direccionVertical =  (Math.random() * 2);
            //Si la dirección es igual 1, giramos la velocidad
            if (direccionHorizontal == 1) {
                velocidadHorizontal *= (-1);
            }
            if (direccionVertical == 1) {
                velocidadVertical *= (-1);
            }
            //Añadimos los nuevos asteroides
            asteroides.add(new Asteroid(asteroideHorizontal, asteroideVertical, 0, .1, velocidadHorizontal, velocidadVertical, tamaño));
        }
        //Eliminamos el asteoride del array
        asteroides.remove(num);
    }
    /**
     * Método de inicio - FALLAN LOS THREAD.
     */
    public void start () {
        if (arranque == null) {
            arranque = new Thread(this);
            arranque.start();
        }
        while (true) {
            for (int contO = 0; contO < asteroides.size(); contO ++) {
                asteroides.get(contO).start();
 
            }
            for (int contO = 0; contO < disparos.size(); contO ++) {
                disparos.get(contO).start();
            }
        }
    }
    /**
     * Método de arranque.
     */
    @Override
    public void run() {
        //Esperamos tres segundos antes de mostrar los elementos
        try {
            arranque.sleep(3000);
        } 
        catch (InterruptedException ex) { }
        //Mientras sea cierto
        while (true) {
            //Mostramos la nave
            mostrarNave = true;
            //Ponemos los asteroides
            masAsteroides();
            //Mientras las vidas sean mayores que cero
            while (vidas >= 0) {
                //Iniciamos un contador de tiempo
                inicio = System.currentTimeMillis();
                //Damos movimiento a nave, asteroides y disparos
                nave.mover(ancho, alto);
                for (int cont = 0; cont < asteroidEliminado.size(); cont ++) {
                    asteroidEliminado.get(cont).moverExplosion();
                    if (asteroidEliminado.get(cont).getVidaAsteroide() <= 0) {
                        asteroidEliminado.remove(cont);
                    }
                }
                for (int cont = 0; cont < disparos.size(); cont++) {
                    disparos.get(cont).mover(ancho, alto);
                    if (!disparos.get(cont).getActivado()) {
                        disparos.remove(cont);
                    }
                }
                //Restamos tiempo de disparo
                tiempoFinalDisparo --;
                //Comprobamos las colisones
                compruebaAccionesColisiones(); 
                //Repintamos
                repaint();
                //Si terminamos los asteroides y con el ovni aumentamos los asteroides.
                if (asteroides.isEmpty() && !ovn) {
                    //Aumentamos el número de asteroides
                    numeroAsteroides ++;
                    //Añadimos asteroides
                    masAsteroides();
                    //Damos true a que puede salir
                    ovn = true;
                    contSalirOvni = 0;
                }
                //Hacer
                try {
                    //Asignamos un nuevo contador de tiempo al final
                    fin = System.currentTimeMillis();
                    //Si la diferencia de refrescar entre la diferencia de fin e inicio es mayor a 0
                    if (refrescar - (fin - inicio) > 0) {
                        //Tiempo de espera es refrescar menos la diferencia
                        Thread.sleep(refrescar - (fin - inicio));
                    }
                } 
                catch (InterruptedException e) {}
                contSalirOvni ++;
            }
            stop();
        }
    }
    /**
     * Método de finalización del juego.
     */
    public void stop () {
        if (arranque != null) {
            arranque = null;
            System.exit(0);  
        }
    }
}
 

Primera parte del código.