Problemas con Thread

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

Código

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

Código

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.

Segundo mensaje, que en el primero no entraba todo el código.

Clase Asteroid - Dibuja y mueve los asteroid, además de método para comprobar coliones.

Código

package asteroides;
 
//Importamos bibliotecas necesarias
import java.awt.*;
import java.awt.geom.Point2D;
 
/**
 * Clase Asteroid - FALLA THREAD
 */
 
public class Asteroid extends Thread {
    EspacioCanvas j1;
    //Tamaño del asteroide
    int tamaño;
    //Posiciones de asteroide
    double horizontal;
    double vertical;
    //Rotación de asteroide
    double angulo;
    double rotAngulo;
    //Direcciones del asteroide (velocidad)
    double dirHorizontal;
    double dirVertical;
    //Saber si esta activado
    boolean activado;
    //Poligono del asteroid con las posiciones
    Polygon asteroid;
    //Posiciones iniciales de los puntos del asteroide
    double [] posicionInicialHorizontal;
    double [] posicionInicialVertical;
    //Posiciones del asteroide explotado
    final double posicionHorizontalExplosion[] = {-2, 2};
    final double posicionVerticalExplosion[] = {-2, 2};
    //Radio del asteroide
    double radioAsteroid = 30;
    //Vida (la explosión)
    double vidaAsteroide;
    //Array para colocar los puntos de los movimientos
    int [] horizontalPts;
    int [] verticalPts;
    int [] horizontalExplosion;
    int [] verticalExplosion; 
    /**
     * Constructor del asteroid
     * @param horizontal
     * @param vertical
     * @param angulo
     * @param rotAngulo
     * @param dirHorizontal
     * @param dirVertical
     * @param tamaño
     */
    public Asteroid(double horizontal, double vertical, double angulo, double rotAngulo, double dirHorizontal, double dirVertical, int tamaño) {
        this.horizontal = horizontal;
        this.vertical = vertical;
        this.angulo = angulo;
        this.rotAngulo = rotAngulo;
        this.dirHorizontal = dirHorizontal;
        this.dirVertical = dirVertical;
        this.tamaño = tamaño;
        activado = true;
        vidaAsteroide = 70;
        j1 = new EspacioCanvas ();
        //Determinamos el tipo de asteroide;
        int numTipo = ((int) (Math.random() * 4) + 1);
        tipoAsteroid(numTipo);
        /**
         * Le damos tres tamaños al asteroide, según estos, tendran un radio, una velocidad y una rotación diferente.
         */
        if (tamaño == 2) {
            for (int cont = 0; cont < posicionInicialHorizontal.length; cont ++) {
                posicionInicialHorizontal[cont] *= 2;
                posicionInicialVertical[cont] *= 2;
            }
            radioAsteroid *= 2;
            this.dirHorizontal /= 2.5;
            this.dirVertical /= 2.5;
            this.rotAngulo /= 2.5;
        }
        else if (tamaño == 1) {
            for (int cont = 0; cont < posicionInicialHorizontal.length; cont ++) {
                posicionInicialHorizontal[cont] *= 1;
                posicionInicialVertical[cont] *= 1;
            }
            radioAsteroid *= 1;
            this.dirHorizontal /= 2;
            this.dirVertical /= 2;
            this.rotAngulo /= 2;
        }
        else if (tamaño < 1) {
            for (int cont = 0; cont < posicionInicialHorizontal.length; cont ++) {
                posicionInicialHorizontal[cont] /= 2;
                posicionInicialVertical[cont] /= 2;
            }
            radioAsteroid /= 2;
            this.dirHorizontal /= 1.5;
            this.dirVertical /= 1.5;
            this.rotAngulo /= 1.5;
        }
        //Creamos las longitudes en los array simples creados para ello
        horizontalPts = new int[posicionInicialHorizontal.length];
        verticalPts = new int[posicionInicialVertical.length];
        horizontalExplosion = new int[posicionHorizontalExplosion.length];
        verticalExplosion = new int[posicionVerticalExplosion.length];
    }
    //Gets y Sets de la clase Asteroide
    public void setActivado(boolean activado) {
        this.activado = activado;
    }
    public Point2D getCentro() {
        return new Point2D.Double(horizontal, vertical);
    }
    public double getRadioAsteroid() {
        return radioAsteroid;
    }
    public int getTamaño() {
        return tamaño;
    }
    public double getHorizontal() {
        return horizontal;
    }
    public double getVertical() {
        return vertical;
    }
    public double getVidaAsteroide() {
        return vidaAsteroide;
    }
    /**
     * Método que determina el tipo de asteroid
     * @param tipo
     */
    public void  tipoAsteroid (int tipo){
        //Posiciones de los diferentes tipos de asteroid
        double [] tipo1Horizontal = {-16, -8, 0, 8, 16, 12, 16, 4, -8, -16, -16};
        double [] tipo1Vertical = {-8, -16, -8, -16, -8, 0, 8, 16, 16, 8, -8};
        double [] tipo2Horizontal = {-12, -16, -8, 0, 8, 16, 8, 16, 8, -4, -8, -16, -12};
        double [] tipo2Vertical = {0, -8, -16, -12, -16, -8, -4, 4, 16, 12, 16, 8, 0};
        double [] tipo3Horizontal = {-8, -16, -4, 8, 16, 16, 8, 0, 0, -8, -16, -8};
        double [] tipo3Vertical = {0, -4, -16, -16, -4, 4, 16, 16, 4, 16, 4, 0};
        double [] tipo4Horizontal = {-4, -8, 4, 16, 16, 4, 16, 8, 4, -8, -16, -16, -4};
        double [] tipo4Vertical = {-8, -16, -16, -8, -4, 0, 8, 16, 12, 16, 4, -8, -8};
        //Según el tipo aleatorio que haya salido, le damos unos valores u otros.       
        if (tipo == 1) {
            posicionInicialHorizontal = tipo1Horizontal;
            posicionInicialVertical = tipo1Vertical;
        }
        else if (tipo == 2) {
            posicionInicialHorizontal = tipo2Horizontal;
            posicionInicialVertical = tipo2Vertical;
        }
        else if (tipo == 3) {
            posicionInicialHorizontal = tipo3Horizontal;
            posicionInicialVertical = tipo3Vertical;
        }
        else if (tipo == 4) {
            posicionInicialHorizontal = tipo4Horizontal;
            posicionInicialVertical = tipo4Vertical;
        }
    }       
    /**
     * Método de dibujar asteroide normal
     * @param g
     */
    public void pintar (Graphics2D g) {
        if (activado) {
            for (int cont = 0; cont < horizontalPts.length; cont ++) {
                horizontalPts[cont] = (int) (posicionInicialHorizontal[cont] * Math.cos(angulo) - posicionInicialVertical[cont] * Math.sin(angulo) + horizontal + 0.5);
                verticalPts[cont] = (int) (posicionInicialHorizontal[cont] * Math.sin(angulo) + posicionInicialVertical[cont] * Math.cos(angulo) + vertical + 0.5);
            }
            g.setColor(Color.WHITE);
            asteroid = new Polygon(this.horizontalPts,this.verticalPts, this.horizontalPts.length);
            g.drawPolygon(asteroid);
        }
    }
    /**
     * Método de dibujar la explosión
     * @param g
     */
    public void pintarExplosion (Graphics g) {
        for (int cont = 0; cont < horizontalExplosion.length; cont ++) {
            horizontalExplosion[cont] = (int) (posicionHorizontalExplosion[cont] * Math.cos(angulo) - posicionVerticalExplosion[cont] * Math.sin(angulo) + horizontal + 0.5);
            verticalExplosion[cont] = (int) (posicionHorizontalExplosion[cont] * Math.sin(angulo) + posicionVerticalExplosion[cont] * Math.cos(angulo) + vertical + 0.5);
        }
        g.setColor(Color.WHITE);
        g.drawPolygon(horizontalExplosion, verticalExplosion, horizontalExplosion.length);
    }
    /**
     * Método de mover el asteroide.
     * @param tamañoAncho
     * @param tamañoAlto
     */
    public synchronized void mover (double tamañoAncho, double tamañoAlto) {
        if (activado) {
            angulo += rotAngulo;
            horizontal += dirHorizontal;
            vertical += dirVertical;
        }
        if (horizontal < (0 - (radioAsteroid))) {
            horizontal += tamañoAncho + (radioAsteroid);
        }
        else if (horizontal > (tamañoAncho + (radioAsteroid))) {
            horizontal -= tamañoAncho + (radioAsteroid);
        }
        if (vertical < (0 - (radioAsteroid))) {
            vertical += tamañoAlto + (radioAsteroid);
        }
        else if (vertical > (tamañoAlto + (radioAsteroid))) {
           vertical -= tamañoAlto + (radioAsteroid);
        }
    }
    /**
     * Método de movimiento del asteroide explotado.
     */
    public synchronized void moverExplosion () {
        angulo += rotAngulo;
        horizontal += dirHorizontal;
        vertical += dirVertical;
        vidaAsteroide --;
    }
    /**
     * Método de la explosión del asteroid
     * @return
     */
    public synchronized Asteroid explota() {
        double horizontalVel = Math.random();
        double verticalVel = Math.random();
        double horizontalDir =  (Math.random() * 2);
        double verticalDir = (Math.random() * 2);
        if (horizontalDir == 1) {
            horizontalVel *= -1;
        }
        if (verticalDir == 1) {
            verticalVel *= -1;
        }
        return new Asteroid (horizontal, vertical, 0, .1, horizontalVel, verticalVel, 0);
    }
    /**
     * Método que comprueba si al asteroide le ha dado un disparo
     * @param disparo
     * @return
     */
      public synchronized boolean colisionDisparo (Disparo disparo){
        if (asteroid.contains(disparo.horizontal, disparo.vertical));
        return asteroid.contains(disparo.horizontal, disparo.vertical);
    }
    /**
     * Método que comprueba si una asteroide choca con una nave
     * @param jugador
     * @return 
     */
    public synchronized boolean colisionNave (Nave jugador){
        if (asteroid.intersects(jugador.nave.getBounds2D()));
        return asteroid.intersects(jugador.nave.getBounds2D());
    }
    /** Método del Thread del asteroide
     * NO FUNCIONA: SI SE PONE AQUÍ EL MOVIMIENTO, EN EL MÉTODO DE ACCIONES ASTEROID DE ESPACIOCANVAS NO DEBE IR.
     */
    @Override
    public void run () {
         while (true) {     
            try {
                mover (j1.ancho, j1.alto);
                moverExplosion ();
                Thread.sleep(40);
                j1.repaint();
            } 
            catch (InterruptedException ex) { }
        }
    }
}

Clase Enemigo - Ovni: Movimiento y dibujo. Incorpora sus dibujos

Código

package asteroides;
 
//Importar librerias necesarias
import java.awt.*;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.Random;
 
/**
 * Clase Nave - Enemigo - FALLA EL THREAD
 * EL MOVIMIENTO DEL THREAD FUNCIONA, PERO NO DETECTA LAS COLISONES
 */
 
public class Enemigo extends Thread {
    EspacioCanvas j1;
    //Vidas del ovni
    int vida;
    //Posición del ovni
    double horizontal;
    double vertical;
    //Angulo del platilla
    double angulo;
    //Poligono del ovni
    Polygon ovni;
    //Eje del ovni
    final double eje = -3.1588;
    //Direcciones del ovni
    double dirHorizontal;
    double dirVertical;
    //Variables para el disparo
    int contador;
    int tiempoDisparo;
    //Posiciones del ovni
    double [] posicionInicialHorizontal;
    double [] posicionInicialVertical;
    int [] puntosHorizontal;
    int [] puntosVertical;
    //ArrayList de los disparos del ovni
    ArrayList <Disparo> disparosOvni;
    /**
     * Constructor del ovni
     * @param horizontal
     * @param vertical
     */
    public Enemigo(double horizontal, double vertical) {
        this.horizontal = horizontal;
        this.vertical = vertical;
        this.angulo = eje;
        contador = 0;
        vida = 1;
        //Determinamos el tipo de asteroide;
        int numTipo = ((int) (Math.random() * 2) + 1);
        tipoEnemigo (numTipo);
        //Creamos los array
        puntosHorizontal = new int[posicionInicialHorizontal.length];
        puntosVertical = new int[posicionInicialVertical.length];
        disparosOvni = new ArrayList <Disparo>();
        j1 = new EspacioCanvas ();
    }
    //GETS Y SETS
    public Disparo disparo (Enemigo ovni) {
        return new Disparo (ovni);
    }
    public Point2D getCentro() {
        return new Point2D.Double(horizontal, vertical);
    }
    public int getVida() {
        return vida;
    }
    public double getHorizontal() {
        return horizontal;
    }
    public double getVertical() {
        return vertical;
    }
    public void setHorizontal(double horizontal) {
        this.horizontal = horizontal;
    }
    public void setVertical (double vertical) {
        this.vertical = vertical;
    }
 
    public void tipoEnemigo (int enemigo) {
        double [] posicionInicialHorizontal1 = {8, 12, -12, 14, 20, -20, 20, 14, -14, -20, -14, -12, -8};
        double [] posicionInicialVertical1 = {12, 6, 6, 6, 0, 0, 0, -6, -6, 0, 6, 6, 12};
        double [] posicionInicialHorizontalPeque = {4, 6, -6, 7, 10, 10, 10, 7, -7, -10, -7, -6, -4};
        double [] posicionInicialVerticalPeque = {6, 3, 3, 3, 0, 0, 0, -3, -3, 0, 3, 3, 6};
        if (enemigo == 1) {
            posicionInicialHorizontal = posicionInicialHorizontal1;
            posicionInicialVertical = posicionInicialVertical1;
        }
        else if (enemigo == 2) {
            posicionInicialHorizontal = posicionInicialHorizontalPeque;
            posicionInicialVertical = posicionInicialVerticalPeque;
        }
    }
    /**
     * Método de dibujar el ovni
     * @param g 
     */
    public void pintar(Graphics2D g) {
        //Para la figura del ovni
        for (int cont = 0; cont < puntosHorizontal.length; cont ++) {
            //Calculamos las posiciones de la posicion
            puntosHorizontal[cont] = (int) (posicionInicialHorizontal[cont] * Math.cos(angulo) - posicionInicialVertical[cont] * Math.sin(angulo) + horizontal + 0.5);
            puntosVertical[cont] = (int) (posicionInicialHorizontal[cont] * Math.sin(angulo) + posicionInicialVertical[cont] * Math.cos(angulo) + vertical + 0.5);
        }
        //Para dibujar los disparos del ovni
        ovni = new Polygon (this.puntosHorizontal, this.puntosVertical, this.puntosHorizontal.length);
        for (int cont = 0; cont < disparosOvni.size(); cont ++) {
            disparosOvni.get(cont).pintar(g);
        }
        //Color del ovni
        g.setColor(Color.WHITE);
        g.drawPolygon(ovni);
    }
    /**
     * Método de mover el ovni
     * @param tamañoAncho
     * @param tamañoAlto 
     */
    public synchronized void mover(double tamañoAncho, double tamañoAlto) {
        //Movimientos aleatorios del platillo
        Random r = new Random();
        if (contador == 0 || contador %150 == 0) {
            dirHorizontal = Math.random()*3*((r.nextInt(2)==0?-1:1)*1);
            dirVertical = Math.random()*3*((r.nextInt(2)==0?-1:1)*1);
        }
        //Le añadimos las direcciones
        horizontal += dirHorizontal;
        vertical += dirVertical;
        //Si llega a los bordes, vuelve por el otro extremo
        if (horizontal < 0) {
            horizontal += tamañoAncho;
        } 
        if (horizontal > tamañoAncho) {
            horizontal -= tamañoAncho;
        }
        if (vertical < 0) {
            vertical += tamañoAlto;
        } 
        if (vertical > tamañoAlto) {
            vertical -= tamañoAlto;
        }
        contador ++;
        //Añadimos los disparos, según el calculos a los valores del contador
        if (this.tiempoDisparo == 0 || this.tiempoDisparo %45 == 0) {
                this.disparosOvni.add(disparo(this));
        }
        this.tiempoDisparo ++;
        //Vamos moviendo los disparos
        for (int cont = 0; cont < disparosOvni.size(); cont ++) {
            disparosOvni.get(cont).mover(tamañoAncho, tamañoAlto);
            //Comprobamos si han llegado a su limite
            if (disparosOvni.get(cont).limite <= 0) {
                disparosOvni.remove(cont);
            }
        }
    }
    /**
     * Método que comprueba si choca con un asteroide
     * @param asteroide
     * @return 
     */
    public synchronized boolean colisionAsteroid (Asteroid asteroide){
        if(ovni.intersects(asteroide.asteroid.getBounds()));
        return ovni.intersects(asteroide.asteroid.getBounds());
    }
    /**
     * Método que comprueba si choca con la nave
     * @param nave
     * @return 
     */
    public synchronized boolean colisionNave (Nave nave){
        if (ovni.intersects(nave.nave.getBounds2D()));
        return ovni.intersects(nave.nave.getBounds2D());
    }
    /**
     * Método que comprobar si le da ha dado un disparo.
     * @param disparo
     * @return 
     */
    public synchronized boolean colisionDisparo (Disparo disparo){
        if (ovni.contains(disparo.horizontal, disparo.vertical));
        return ovni.contains(disparo.horizontal, disparo.vertical);
    }
    /** Método del Thread del ovni
     * NO FUNCIONA: SI SE PONE AQUÍ EL MOVIMIENTO, EN EL MÉTODO DE ACCIONES DE ESPACIO CANVAS NO DEBE IR.
    */
    @Override
    public void run () {
        while (true) {       
            try {
                mover (j1.ancho, j1.alto);
                Thread.sleep (60);
                j1.repaint();
            } 
            catch (InterruptedException ex) { }
        }
    }
}

Clase Disparo - Movimiento y pintar. Relacionado con la nave y el ovni

Código

package asteroides;
 
//Importamos bibliotecas necesarias
import java.awt.*;
import java.awt.geom.Point2D;
 
/** CLASE DISPARO - Lo usa la nave y el enemigo - FALLA EL THREAD
 */
 
public class Disparo extends Thread {
    EspacioCanvas j1;
    //Velocidad del disparo
    final double velocidadDisparo = 12;
    //Posiciones y angulo del disparo 
    double horizontal;
    double vertical;
    double angulo;
    //Direcciones del disparo
    double dirHorizontal;
    double dirVertical;
    //Limite del disparo
    int limite; 
    //Boolean para ver si se ha activado el disparo
    boolean activado;
    //Radio del disparo
    double radioDisparo = 0.5;
//    int [] puntosHorizontal, puntosVertical;
    /**
     * Constructor del disparo de la Nave
     * @param horizontal
     * @param vertical
     * @param angulo
     * @param velEnvioH
     * @param velEnvioV
     * @param limite 
     */
    public Disparo(double horizontal, double vertical, double angulo, double velEnvioH, double velEnvioV, int limite) {
        this.horizontal = horizontal;
        this.vertical = vertical;
        this.angulo = angulo;
        dirHorizontal = velocidadDisparo * Math.cos(angulo) + velEnvioH;
        dirVertical = velocidadDisparo * Math.sin(angulo) + velEnvioV;
        this.limite = 35;
        activado = true;
        j1 = new EspacioCanvas ();
    }
    /**
     * Constructor disparo para Ovni
     * @param ovni 
     */
    public Disparo (Enemigo ovni){
        this.limite = 60;
        this.angulo = ovni.angulo;
        this.horizontal = ovni.horizontal;
        this.vertical = ovni.vertical;
        this.dirHorizontal = ovni.dirHorizontal;
        this.dirVertical = ovni.dirVertical;
    }
    //Gets del disparo
    public boolean getActivado() {
        return activado;
    }
    public Point2D getCentro() {
        return new Point2D.Double(horizontal, vertical);
    }
    public double getRadioDisparo() {
        return radioDisparo;
    }
    /**
     * Método de dibujar el disparo cuando se activa
     * @param g 
     */
    public void pintar(Graphics2D g){
//        Graphics2D g = g0;
        g.setColor(Color.WHITE);
        g.fillOval((int)horizontal, (int)vertical, 3, 3);
    }  
    /**
     * Método de movimiento del disparo una vez activado
     * @param tamañoAncho
     * @param tamañoAlto 
     */
    public synchronized void mover (double tamañoAncho, double tamañoAlto) {
        //Si se ha activado el disparo
        if (activado) {
            //A horizontal y vertical le sumamos la dirección
            horizontal += dirHorizontal;
            vertical += dirVertical;
        }
        //Si el disparo supera los limites de los lados, vuelve por el otro extremo
        if (horizontal < 0) {                     
            horizontal += tamañoAncho; 
        } 
        else if (horizontal > tamañoAncho) {
            horizontal -= tamañoAncho;
        }
        if (vertical < 0) {
            vertical += tamañoAlto;
        } 
        else if (vertical > tamañoAlto) {
            vertical -= tamañoAlto;
        }
        //Se resta tiempo
        limite --;
        //Si no queda tiempo, el disparo se desactiva
        if (limite == 0) {
            activado = false;
        }
    }
    /** Método del Thread del disparo
     * NO FUNCIONA: SI SE PONE AQUÍ EL MOVIMIENTO, EN EL RUN DE ESPACIOCANVAS NO DEBE IR.
     */
    @Override
    public void run () {
        while (true) {       
            try {
                mover (j1.ancho, j1.alto);
                Thread.sleep (10);
                j1.repaint();
            } 
            catch (InterruptedException ex) { }
        }
    }
}

Clase Nave: Movimiento y dibujo, el KeyListener esta en el Espacio Canvas

Código

package asteroides;
 
//Importar librerias necesarias
import java.awt.*;
import java.awt.geom.Point2D;
import java.util.ArrayList;
 
/**
 * Clase Nave - Jugador
 */
public class Nave  {
    EspacioCanvas j1;
    //Poligono de la nave
    Polygon nave; 
    //Atributos del movimiento de la nave
    double aceleracion;
    double arrastre;
    //Radio de la nave
    double radio = 12;
    //Posición de la nave
    double horizontal;
    double vertical;
    //Rotación de la nave
    double angulo;
    double rotAngulo;
    //Direcciones de la nave
    double dirHorizontal;
    double dirVertical;
    //Booleans del movimiento y disparo
    boolean acelerador;
    boolean irzquierda; 
    boolean derecha;
    boolean disparo;
    //Posiciones de la nave
    final int [] posicionInicialHorizontal = {-12, 12, -12, -5, -5};
    final int [] posicionInicialVertical = {8, 0, -8, -5, 5};
    //Posiciones del acelerador
    final double [] posicionEmpujeInicialHorizontal = {-4, - 12, - 4};
    final double [] posicionEmpujeInicialVertical = {-3, 0 , 3};
    int vida;
    int [] puntosHorizontal;
    int [] puntosVertical;
    int [] inicioEmpujeHorizontal;
    int [] inicioEmpujeVertical;
    /**
     * Constructor de la nave
     * @param horizontal
     * @param vertical
     * @param angulo
     * @param rotAngulo
     * @param aceleracion
     * @param arrastre 
     */
    public Nave(double horizontal, double vertical, double angulo, double rotAngulo, double aceleracion, double arrastre) {
        this.horizontal = horizontal;
        this.vertical = vertical;
        this.angulo = angulo;
        this.rotAngulo = rotAngulo;
        this.aceleracion = aceleracion;;
        this.arrastre = arrastre;
        acelerador = false;
        irzquierda = false;
        derecha = false;
        vida = 3;
        //Creamos los array
        puntosHorizontal = new int[posicionInicialHorizontal.length];
        puntosVertical = new int[posicionInicialVertical.length];
        inicioEmpujeHorizontal = new int[posicionEmpujeInicialHorizontal.length];
        inicioEmpujeVertical = new int[posicionEmpujeInicialVertical.length];
    }
    //GETS Y SETS
    public Disparo disparo () {
        return new Disparo (horizontal, vertical, angulo, dirHorizontal, dirVertical, 50);
    }
    public void setAcelerador(boolean acelerador) {
        this.acelerador = acelerador;
    }
    public void setIrzquierda(boolean irzquierda) {
        this.irzquierda = irzquierda;
    }
    public void setDerecha(boolean derecha) {
        this.derecha = derecha;
    }
    public Point2D getCentro() {
        return new Point2D.Double(horizontal, vertical);
    }
    public double getRadio() {
        return radio;
    }
    public double getRotAngulo () {
        return rotAngulo;
    }
    public double getHorizontal() {
        return horizontal;
    }
    public double getVertical() {
        return vertical;
    }
    public void setHorizontal(double horizontal) {
        this.horizontal = horizontal;
    }
    public void setVertical (double vertical) {
        this.vertical = vertical;
    }
    /**
     * Método de dibujar la nave.
     * @param g 
     */
    public void pintar(Graphics2D g) {
        //Si esta pulsado el acelerador
        if (acelerador) {
            //Recorremos para calcular los delanteros
            for (int cont = 0; cont < inicioEmpujeHorizontal.length; cont ++) {
                //Calculamos el movimiento                 
                inicioEmpujeHorizontal[cont] = (int) (posicionEmpujeInicialHorizontal[cont] * Math.cos(angulo) - posicionEmpujeInicialVertical[cont] * Math.sin(angulo) + horizontal + 0.5);
                inicioEmpujeVertical[cont] = (int) (posicionEmpujeInicialHorizontal[cont] * Math.sin(angulo) + posicionEmpujeInicialVertical[cont] * Math.cos(angulo) + vertical + 0.5);
            }
            //Color de la nave
            g.setColor(Color.WHITE);
            //Señalamos los puntos del acelerador
            g.drawPolyline(inicioEmpujeHorizontal, inicioEmpujeVertical, inicioEmpujeHorizontal.length);
        }
        //Para el movimiento de la nave, recorremos
        for (int cont = 0; cont < puntosHorizontal.length; cont ++) {
            //Calculamos las posiciones de la posicion
            puntosHorizontal[cont] = (int) (posicionInicialHorizontal[cont] * Math.cos(angulo) - posicionInicialVertical[cont] * Math.sin(angulo) + horizontal + 0.5);
            puntosVertical[cont] = (int) (posicionInicialHorizontal[cont] * Math.sin(angulo) + posicionInicialVertical[cont] * Math.cos(angulo) + vertical + 0.5);
        }
        //Color de la nave
        g.setColor(Color.WHITE);
        nave = new Polygon (puntosHorizontal, puntosVertical, puntosHorizontal.length);
        //Señalamos los puntos de la nave
        g.drawPolygon(nave);
    }
    /**
     * Método de mover la nave
     * @param tamañoAncho
     * @param tamañoAlto 
     */
    public synchronized void mover(double tamañoAncho, double tamañoAlto) {
        //Comprobamos hacia donde va la nave, ségun la tecla pulsada
 
        if (irzquierda) {
            angulo -= rotAngulo;
        }
        if (acelerador) {
            dirHorizontal += aceleracion * Math.cos(angulo);
            dirVertical += aceleracion * Math.sin(angulo);
        }
        if (derecha) {
            angulo += rotAngulo;
        }
        //Le añadimos las direcciones
        horizontal += dirHorizontal;
        vertical += dirVertical;
        //Múltiplamos el arrastre a la dirección
        dirHorizontal *= arrastre;
        dirVertical *= arrastre;
        //Si llega a los bordes, vuelve por el otro extremo
        if (horizontal < 0) {
            horizontal += tamañoAncho;
        } 
        else if (horizontal > tamañoAncho) {
            horizontal -= tamañoAncho;
        }
        if (vertical < 0) {
            vertical += tamañoAlto;
        } 
        else if (vertical > tamañoAlto) {
            vertical -= tamañoAlto;
        }
    }
    /**
     * Método que comprueba si le da un disparo suyo o no
     * @param disparos
     * @return 
     */
    public synchronized boolean colisionDisparo (ArrayList <Disparo> disparos){
        for (int cont = 0; cont < j1.disparos.size(); cont ++) {
            if (nave.contains(j1.disparos.get(cont).horizontal, j1.disparos.get(cont).vertical)){
                return true;
            }
        }
        return false;
    }
}

Gracias de antemano por vuestro tiempo.