Swing 2 Thread.sleep parallel laufen lassen

[Takar110]

Hi Leute,

ich habe leider ein Problem bei dem Spiel "Space Invaders".
Ich habe das Spiel eigentlich fertig, nur ist bei mir alles gleich "schnell" dadurch das ich einen Thread.sleep verwende. Ich möchte aber das sich mein Schiff schneller bewegen lässt, da ich sonst nicht hinterher komme die entgegenkommenden Invaders zu töten.
Meine Frage: Wie verwende ich parallel zwei Thread.sleeps? Ein Thread für die Invader und ein Thread für mein Schiff.

package spaceInvaders;

import java.io.IOException;
import javax.swing.JOptionPane;

public class SpaceSpiel /* implements KeyListener */ {

  boolean spielfeldErstellt = false;
  static boolean schuss = false;
  static int rightLeft = 0;
  static int punkteZaehler = 0;
  static int durchlaufGeschwindigkeit = 400;
  int y = 25;
  int x = 25;
  int ausgangspunktX = 15;
  int ausgangspunktY = 24;
  int position = 0;
  int alteposition = 0;
  String[][] spaceShuttle;

  public String[][] spaceShuttle() throws NumberFormatException, IOException,
    InterruptedException {

    if (!spielfeldErstellt) {
      spaceShuttle = new String[y][x];
      for (int b = 0; b < x; b++) {
        for (int h = 0; h < y; h++) {
          spaceShuttle[h][b] = " ";
        }
      }
      spielfeldErstellt = true;
    }

    for (int b = 0; b < x; b++) {
      for (int h = 0; h < y; h++) {
        if (spaceShuttle[b][h].equals("∇")) {
          if (h >= x - 2 || spaceShuttle[b][h + 1].equals("▲")) {
            JOptionPane.showMessageDialog(null, "Game Over!\nDeine Punktzahl: " + punkteZaehler);
            System.exit(0);
          }
          if (!spaceShuttle[b][h + 1].equals("*")) {
            spaceShuttle[b][h] = " ";
            h++;
            spaceShuttle[b][h] = "∇";
          }

          if (spaceShuttle[b][h + 1].equals("*") || spaceShuttle[b][h].equals("*")) {
            spaceShuttle[b][h] = " ";
            spaceShuttle[b][h + 1] = " ";
            punkteZaehler += 10;
          }
        }
      }
    }

    // Bewegung Schiff
    alteposition = position;
    position += rightLeft;
    if ((x / 2) + position >= x) {
      position = -12;
    }
    if ((x / 2) + position < 0) {
      position = 11;
    }
    int invaders = 1;
    int xKoordinateInvaders = 0;

    spaceShuttle[(x / 2) + position][ausgangspunktY] = "▲";
    if (alteposition != position) {
      spaceShuttle[(x / 2) + alteposition][ausgangspunktY] = " ";
    }

    // Schießen
    if (schuss == true) {
      spaceShuttle[(x / 2) + position][ausgangspunktY - 1] = "*";
    }

    // Geschoss
    for (int h = 0; h < y; h++) {
      for (int b = 0; b < x; b++) {
        if (h == 0) {
          spaceShuttle[b][h] = " ";
        }
        if (spaceShuttle[b][h].equals("*") && !spaceShuttle[b][h - 1].equals("∇") && h != 0) {
          spaceShuttle[b][h - 1] = "*";
          spaceShuttle[b][h] = " ";
        }
      }
    }

    // invaders koordinaten bestimmen
    for (int i = 0; i <= invaders; i++) {
      xKoordinateInvaders = (int) (Math.random() * x - 1);
    }

    // invaders spawnen
    for (int i = 0; i <= invaders; i++) {
      spaceShuttle[xKoordinateInvaders][0] = "∇";
    }

    // Schwierigkeitsgrad
    if (punkteZaehler >= 150) {
      invaders += 2;
    }
    if (punkteZaehler >= 300) {
      invaders += 2;
    }
    if (punkteZaehler >= 550) {
      durchlaufGeschwindigkeit = 300;
    }
    return spaceShuttle;
  }
}

package spaceInvaders;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;

public class Logic implements Runnable {

  String[][] logicSpielfeld = null;
  SpaceSpiel game = new SpaceSpiel();

  private BufferedImage img = new BufferedImage(400, 400, BufferedImage.TYPE_INT_ARGB);

  @Override
  public void run() {

    while (true) {
      try {
        logicSpielfeld = game.spaceShuttle();
      } catch (NumberFormatException | IOException | InterruptedException e2) {
        e2.printStackTrace();
      }
      Graphics g = img.getGraphics();
      g.setColor(Color.blue);
      g.fillRect(0, 0, 400, 400);
      try {
        for (int b = 0; b < game.x; b++) {
          for (int h = 0; h < game.y; h++) {
            if (logicSpielfeld[b][h].equals("∇")) {
              g.setColor(Color.green);
              g.drawOval(b * 16, h * 16, 11, 11);
            }
            if (logicSpielfeld[b][h].equals("▲")) {
              g.setColor(Color.black);
              g.fillOval(b * 16, h * 16, 15, 15);
            }
            if (logicSpielfeld[b][h].equals("*")) {
              g.setColor(Color.red);
              g.fillOval(b * 16, h * 17, 4, 4);
            }
            String punkteAusgabe = "Punkte: " + SpaceSpiel.punkteZaehler;
            g.setColor(Color.white);
            g.drawString(punkteAusgabe, 10, 390);
          }
        }

      } catch (NumberFormatException e1) {
        e1.printStackTrace();
      }
      View.getInstance().setImg(img);

      try {
        Thread.sleep(SpaceSpiel.durchlaufGeschwindigkeit);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
}

package spaceInvaders;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class View extends JFrame {

  private static final long serialVersionUID = 1L;

  public static View instance = null;
  private JPanel gamePanel = new JPanel();
  private BufferedImage img;

  public BufferedImage getImg() {
    return img;
  }

  public void setImg(BufferedImage img) {
    this.img = img;
    repaint();
  }

  public static View getInstance() {
    if (instance == null)
      instance = new View();
    return instance;
  }

  private View() {
    super("Space Invaders");

    instance = this;
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setContentPane(gamePanel);
    setSize(428, 469);
    setLocation(400, 300);
    setVisible(true);

    addKeyListener(new KeyListener() {
      @Override

      public void keyTyped(KeyEvent e) {
      }

      public void keyPressed(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_LEFT) {
          SpaceSpiel.rightLeft = -1;
        }
        if (key == KeyEvent.VK_RIGHT) {
          SpaceSpiel.rightLeft = 1;
        }
        if (key == KeyEvent.VK_UP) {
          SpaceSpiel.schuss = true;
        }
      }

      public void keyReleased(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_LEFT) {
          SpaceSpiel.rightLeft = 0;
        }
        if (key == KeyEvent.VK_RIGHT) {
          SpaceSpiel.rightLeft = 0;
        }
        if (key == KeyEvent.VK_UP) {
          SpaceSpiel.schuss = false;
        }
      }
    });

    Thread t = new Thread(new Logic());
    t.start();
  }

  public void paint(Graphics g) {
    g.drawImage(img, 5, 22, 417, 441, new ImageObserver() {

      @Override
      public boolean imageUpdate(Image arg0, int arg1, int arg2,
        int arg3, int arg4, int arg5) {
        return true;
      }
    });

  }

  public static void main(String[] args) {
    View.getInstance();
  }
}

 

[Joose]

Das Problem ist du dein 2d Array 1:1 als Spielfeld anzeigst.
Dadurch kannst du deine Objekte alle immer nur um x Felder in eine Richtung bewegen.

Richtiger wäre es den Spieler um a Pixel zu bewegen und die Gegner um b Pixel.
Dadurch ergeben sich dann gefühlt unterschiedliche Geschwindigkeiten.
Mit deiner aktuellen Version wäre es unter anderem nicht möglich zwischen zwei (benachbarten) Gegner durchzuschießen.

Mögliche Lösung:
Sprich anstatt deine Objekte (Gegner, Spieler und Geschoss) in einem 2d Array zu verwalten solltest du eine einfache Liste verwenden.
Für die Objekte am Spielfeld werden Klassen erstellt und diese haben jeweils eine x und y Position. Dadurch kannst du sie an der richtigen Position zeichnen und unterschiedlich verschieben.

 

[Takar110]

Mh.. sowas in der Art hatte ich mir schon gedacht :/
Dann werde ich mich mal an die arbeit machen und meinen Code komplett überarbeiten!

Danke für die schnelle Antwort!

 

[Joose]

Dein Code scheint ja zu funktionieren, das ist schon mal super! (Daher auf jedenfall mal sichern)
Aber wie du eben siehst sind deiner Implementierung Grenzen gesetzt, das kommt immer wieder vor.
Das ist nur eine Übungs- und Erfahrungssache, sowas schon im vorhinein zu bedenken

Viel Glück und Spaß bei der Überarbeitung

 

[Takar110]

Ja, das stimmt.

Dankeschön