commit 455322ac79c17bb42ace2840cbb373ce47cd1d7f Author: Lenz Wiechers <> Date: Mon Feb 17 16:29:50 2020 +0100 Initial upload diff --git a/README.txt b/README.txt new file mode 100644 index 0000000..397865a --- /dev/null +++ b/README.txt @@ -0,0 +1,3 @@ +A simple Pac-Man clone. +So far. +About to add Path finding for the Ghosts and an A.I. that controls Pac-Man. \ No newline at end of file diff --git a/assets/Blinky.png b/assets/Blinky.png new file mode 100644 index 0000000..6d2affa Binary files /dev/null and b/assets/Blinky.png differ diff --git a/assets/Clyde.png b/assets/Clyde.png new file mode 100644 index 0000000..4f26aa3 Binary files /dev/null and b/assets/Clyde.png differ diff --git a/assets/Inky.png b/assets/Inky.png new file mode 100644 index 0000000..754a0fa Binary files /dev/null and b/assets/Inky.png differ diff --git a/assets/Map.txt b/assets/Map.txt new file mode 100644 index 0000000..38f4b8a --- /dev/null +++ b/assets/Map.txt @@ -0,0 +1,35 @@ +################################## +# # 0 # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # ############################ # +# # P 123 # +################################## +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +# +## \ No newline at end of file diff --git a/assets/Pacman_Down.png b/assets/Pacman_Down.png new file mode 100644 index 0000000..df3d504 Binary files /dev/null and b/assets/Pacman_Down.png differ diff --git a/assets/Pacman_Left.png b/assets/Pacman_Left.png new file mode 100644 index 0000000..6a6fd4e Binary files /dev/null and b/assets/Pacman_Left.png differ diff --git a/assets/Pacman_Original.png b/assets/Pacman_Original.png new file mode 100644 index 0000000..dff9dfb Binary files /dev/null and b/assets/Pacman_Original.png differ diff --git a/assets/Pacman_Right.png b/assets/Pacman_Right.png new file mode 100644 index 0000000..98c86a8 Binary files /dev/null and b/assets/Pacman_Right.png differ diff --git a/assets/Pacman_Up.png b/assets/Pacman_Up.png new file mode 100644 index 0000000..a87d7e6 Binary files /dev/null and b/assets/Pacman_Up.png differ diff --git a/assets/Pinky.png b/assets/Pinky.png new file mode 100644 index 0000000..0b6a1cd Binary files /dev/null and b/assets/Pinky.png differ diff --git a/assets/brick.png b/assets/brick.png new file mode 100644 index 0000000..15db204 Binary files /dev/null and b/assets/brick.png differ diff --git a/bin/Brick.class b/bin/Brick.class new file mode 100644 index 0000000..98f1c69 Binary files /dev/null and b/bin/Brick.class differ diff --git a/bin/Game.class b/bin/Game.class new file mode 100644 index 0000000..70373b0 Binary files /dev/null and b/bin/Game.class differ diff --git a/bin/Ghost.class b/bin/Ghost.class new file mode 100644 index 0000000..bc339ca Binary files /dev/null and b/bin/Ghost.class differ diff --git a/bin/Main.class b/bin/Main.class new file mode 100644 index 0000000..499b059 Binary files /dev/null and b/bin/Main.class differ diff --git a/bin/Map.class b/bin/Map.class new file mode 100644 index 0000000..fb0edde Binary files /dev/null and b/bin/Map.class differ diff --git a/bin/Picture.class b/bin/Picture.class new file mode 100644 index 0000000..3737254 Binary files /dev/null and b/bin/Picture.class differ diff --git a/bin/Player.class b/bin/Player.class new file mode 100644 index 0000000..702cafc Binary files /dev/null and b/bin/Player.class differ diff --git a/src/Brick.class b/src/Brick.class new file mode 100644 index 0000000..28bba17 Binary files /dev/null and b/src/Brick.class differ diff --git a/src/Brick.java b/src/Brick.java new file mode 100644 index 0000000..90f945c --- /dev/null +++ b/src/Brick.java @@ -0,0 +1,21 @@ +// Diese Klasse stellt die einzelnen Bicks (Wände) auf der Map dar. + +public class Brick extends Picture { // Die übergeordnete Klasse ist Picture + + private static final long serialVersionUID = 5556462651856418189L; + + public int xPos; // Position auf dem Frame in x-Richtung + public int yPos; // Position auf dem Frame in y-Richtung + + public Brick(int newXPos, int newYPos) { // Erstellen des Konstruktors mit den Koordinaten, an denen sich der Brick + // beefinden soll. + + super("brick"); // Aufrufen der übergeordneten Klasse + + // Setzen der Positionen: + xPos = newXPos; + yPos = newYPos; + + } + +} diff --git a/src/Game.class b/src/Game.class new file mode 100644 index 0000000..d04c8a9 Binary files /dev/null and b/src/Game.class differ diff --git a/src/Game.java b/src/Game.java new file mode 100644 index 0000000..0ea4bf0 --- /dev/null +++ b/src/Game.java @@ -0,0 +1,154 @@ +import java.awt.Color; + +import javax.swing.JFrame; +import javax.swing.JPanel; + +// In dieser Klasse findet der größte Teil des Spiels statt: +// Rendern von Map, Geistern, Pac-Man etc. +// Überprüfung von Kollisionen verschiedener Elemente (der komplizierteste Teil des Programms) + +public class Game { + + // Deklaration der sichtbaren Elemente + JFrame frame; + JPanel panel; + Player player; + Ghost ghosts[]; + Map map; + + // Delta time: siehe https://en.wikipedia.org/wiki/Delta_timing + private long dt; + private long lastT; + + private int windowSizeX = 800; // Größe des Frame in x-Richtung + private int windowSizeY = 800; // Größe des Frame in y-Richtung + + private int frameLocationX = 100; // Position des Frame auf dem Bildschirm in x-Richtung + private int frameLocationY = 100; // Position des Frame auf dem Bildschirm in x-Richtung + // oben links (0|0) + // nach rechts --> x wird größer + // nach unten --> y wird größer + + public Game() { // Erstellen des Konstruktors (Was soll passieren, sobald dieses Klasse + // aufgerufen wird?) + + frame = new JFrame(); // Fenster + + panel = new JPanel(); // darauf werden alle sichtbaren Elemente gespeichert + + ghosts = new Ghost[4]; // 4 Geister + + player = new Player(); // Pac-Man + + panel.add(player); // Pac-Man wird dem Panel hinzugefügt + frame.addKeyListener(player); // KeyListener wird hinzugefügt, man kann nun Pac-Maan mit der tastatur steuern + + // Einstellen des Frame bezüglich Größe und Position + frame.setSize(windowSizeX, windowSizeY); + frame.setLocation(frameLocationX, frameLocationY); + + frame.setVisible(false); + frame.setTitle("Pac-Man"); // Der Titel des Frame wird auf "Pac-Man" gesetzt + frame.setResizable(false); // Man kann die Größe des Frame nicht verändern + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Wenn der Frame geschlossen wird, wird auch das Programm + // beendet + + // Der Inhalt des Panels wird auf dem Frame angezeigt: + frame.setContentPane(panel); + frame.getContentPane().setLayout(null); + + panel.setBackground(Color.BLACK); // Der Hintergrund ist schwarz + + for (int i = 0; i < ghosts.length; i++) { // für jeden Geist: + ghosts[i] = new Ghost(i); // Erstellen des jeweiligen Geistes + panel.add(ghosts[i]); // Hinzufügen zum Panel des jeiligen Geistes + ghosts[i].setBounds(ghosts[i].getPos('x', 0), ghosts[i].getPos('y', 0), 20, 20); + } + + map = new Map(player, ghosts); // Map auf der gespielt wird + map.mapping(); + + player.setBounds(player.getPos('x', 0), player.getPos('y', 0), 20, 20); // Pac-Man wird das erste Mal gerendert + + for (int i = 0; i < 35; i++) { // für jeden Brick + for (int j = 0; j < 35; j++) { // für jeden Brick + if (Map.bricks[j][i] != null) { // Damit kein Fehler auftritt wegen nicht vorhandenen Bricks + panel.add(Map.bricks[j][i]); // Der jeweilige Brick wird zum panel hinzugefügt + Map.bricks[j][i].setBounds(Map.bricks[j][i].xPos, Map.bricks[j][i].yPos, 20, 20); // Rendern des + + } + } + } + + frame.setVisible(true); + + lastT = System.nanoTime(); // delta time + + while (true) { // Hauptschleife + + dt = System.nanoTime() - lastT; // delta time + lastT = System.nanoTime(); // delta time + + // Zu Beginn jeden Schleifendurchlaufs wird die Position von Pac-Man neu + // gesetzt: + player.setLocation(player.getPos('x', dt), player.getPos('y', dt)); + + // Aktualiesieren der Positionen der Geister: + for (int i = 0; i < ghosts.length; i++) { + ghosts[i].setLocation(ghosts[i].getPos('x', dt), ghosts[i].getPos('y', dt)); + } + + player.calcDir(0); // Berechnen wo Pac-Man als nächstes hin soll + + // Kollision von Pac-Man mit Bricks: + for (int i = 0; i < 35; i++) { // für jeden Brick + for (int j = 0; j < 35; j++) { // für jeden Brick + if (Map.bricks[j][i] != null) { // Damit kein Fehler auftritt wegen nicht vorhandenen Bricks + if (player.getPos('x', 0) < Map.bricks[j][i].xPos + 20 + && player.getPos('x', 0) > Map.bricks[j][i].xPos - 20 + && player.getPos('y', 0) < Map.bricks[j][i].yPos + 20 + && player.getPos('y', 0) > Map.bricks[j][i].yPos - 20) { + if (player.left) { + player.setPos('x', Map.bricks[j][i].xPos + 20); + player.left = false; + } else if (player.right) { + player.setPos('x', Map.bricks[j][i].xPos - 20); + player.right = false; + } else if (player.up) { + player.setPos('y', Map.bricks[j][i].yPos + 20); + player.up = false; + } else if (player.down) { + player.setPos('y', Map.bricks[j][i].yPos - 20); + player.down = false; + } + + } + } + } + } + + for (int i = 0; i < ghosts.length; i++) { + if (player.getPos('x', 0) < ghosts[i].getPos('x', 0) + 20 + && player.getPos('x', 0) > ghosts[i].getPos('x', 0) - 20 + && player.getPos('y', 0) < ghosts[i].getPos('y', 0) + 20 + && player.getPos('y', 0) > ghosts[i].getPos('y', 0) - 20) { + + player.lives--; + System.out.println(player.lives); + map.mapping(); + } + } + delay(10); // Ein delay von 10s zum Ende der Hauptschleife + } + } + + // Methode zum verzögern (warten) in ms + public void delay(int time) { + + try { + Thread.sleep(time); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } +} diff --git a/src/Ghost.class b/src/Ghost.class new file mode 100644 index 0000000..9654b17 Binary files /dev/null and b/src/Ghost.class differ diff --git a/src/Ghost.java b/src/Ghost.java new file mode 100644 index 0000000..6504434 --- /dev/null +++ b/src/Ghost.java @@ -0,0 +1,43 @@ +// Diese Klasse stellt die einzelnen Geister dar. + +public class Ghost extends Picture { // Die übergeordnete Klasse ist Picture + + private static final long serialVersionUID = -5352006665147359473L; + + private int xPos; + private int yPos; + + public Ghost(int index) { + + super("Pinky"); // Aufrufen der übergeordneten Klasse + + //xPos = 150 + 40 * index; + + if (index == 0) { + this.changeSauce("Blinky"); + } else if (index == 2) { + this.changeSauce("Inky"); + } else if (index == 3) { + this.changeSauce("Clyde"); + } + + } + + public int getPos(char coordinate, long dt) { + if (coordinate == 'x') { + return xPos; + } else if (coordinate == 'y') { + return yPos; + } else + return -1; + } + + public void setPos(char coordinate, int newPos) { + if (coordinate == 'x') { + xPos = newPos; + } else if(coordinate == 'y') { + yPos = newPos; + } + } + +} diff --git a/src/Main.class b/src/Main.class new file mode 100644 index 0000000..ca256d9 Binary files /dev/null and b/src/Main.class differ diff --git a/src/Main.java b/src/Main.java new file mode 100644 index 0000000..e8fde2c --- /dev/null +++ b/src/Main.java @@ -0,0 +1,19 @@ + +// Programmiert von Lenz Wiechers im Jahre 2020 + +/// Hauptdatei +// In dieser Datei wird das Spiel erstellt +// Muss ausgeführt werden zum Starten + +public class Main { + + @SuppressWarnings("unused") // Die "unused" - Warnungen werden in dieser Datei nicht mehr angezeigt + public static void main(String[] args) { + + System.setProperty("sun.java2d.opengl", "true"); + + Game game = new Game(); // Das Spiel wird gestartet + + } + +} diff --git a/src/Map.class b/src/Map.class new file mode 100644 index 0000000..c7b9160 Binary files /dev/null and b/src/Map.class differ diff --git a/src/Map.java b/src/Map.java new file mode 100644 index 0000000..f962dae --- /dev/null +++ b/src/Map.java @@ -0,0 +1,67 @@ +import java.io.BufferedReader; +import java.io.FileReader; + +// Diese Klasse ist zuständig für das Laden der Karte +// In der Textdatei map.txt enthalten im "assets" - Ordner kann man anhand von '#' Positionen von Bricks festlegen. Dort wo sich kein '#' befindet, ist also eine Lücke. + +public class Map { + + public static Brick bricks[][] = new Brick[35][35]; // Zweidimensionales Array für alle Bricks + // Zweidimensionale Arrays siehe + // https://de.wikipedia.org/wiki/Feld_(Datentyp)#Mehrdimensional_/_in-sich-mehrdimensional + + BufferedReader reader; // reader zum Einlesen der Text Datei + + Player player; + Ghost ghosts[]; + + String line; // String in dem eingelsene Zeilen der Datei gespeichert werden + + public Map(Player player, Ghost ghosts[]) { // Erstellen des Konstruktors + + this.ghosts = ghosts; + this.player = player; + + } + + public void mapping(){ + try { + + + reader = new BufferedReader(new FileReader("assets/map.txt")); // Einlesen der .txt Datei + + for (int i = 0; i < 35; i++) { // für die ersten 35 Zeilen der Datei: + String line = reader.readLine(); // Einlesen der jeweiligen Zeile + for (int j = 0; j < 35; j++) { // für die ersten 35 Zeichen der jeweiligen Zeile + try { + if (line.charAt(j) == '#') { // Erkennen ob sich dort ein '#' befindet + bricks[i][j] = new Brick(10 + 20 * j, 10 + 20 * i); // wenn ja, soll an der Stelle ein neuer + // Brick erstellt werden + } else if (line.charAt(j) == 'P') { + player.setPos('x', 10 + 20 * j); + player.setPos('y', 10 + 20 * i); + } else if (line.charAt(j) == '0') { + ghosts[0].setPos('x', 10 + 20 * j); + ghosts[0].setPos('y', 10 + 20 * i); + } else if (line.charAt(j) == '1') { + ghosts[1].setPos('x', 10 + 20 * j); + ghosts[1].setPos('y', 10 + 20 * i); + } else if (line.charAt(j) == '2') { + ghosts[2].setPos('x', 10 + 20 * j); + ghosts[2].setPos('y', 10 + 20 * i); + } else if (line.charAt(j) == '3') { + ghosts[3].setPos('x', 10 + 20 * j); + ghosts[3].setPos('y', 10 + 20 * i); + } + } catch (Exception e) { + + } + } + } + } catch (Exception e) { // Falls etwas mit dem Einlesen der Datei schiefläuft: + System.out.println( + "There seems to be an error with the file of the map. Pls use hashes to indicate positions of Walls. ERROR: " + + e); + } + } +} diff --git a/src/Picture.class b/src/Picture.class new file mode 100644 index 0000000..b6bc609 Binary files /dev/null and b/src/Picture.class differ diff --git a/src/Picture.java b/src/Picture.java new file mode 100644 index 0000000..5569808 --- /dev/null +++ b/src/Picture.java @@ -0,0 +1,57 @@ +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; + +import javax.imageio.ImageIO; +import javax.swing.ImageIcon; +import javax.swing.JLabel; +import javax.swing.JOptionPane; + +// Diese Klasse ist die Grundlagee zum Render von Elementen auf dem Frame, anhand der Javax Swing Bibliothek + +public class Picture extends JLabel { // Die übergeordnete Klasse ist JLabel + + private static final long serialVersionUID = 3916370092871263037L; + + BufferedImage pic; // pic ist das eingelesene Bild + + public Picture(String sauce) { // Erstellen des Konstruktors mit der Eingabe sauce --> Name der jeweiligen + // Datei ohne Endung + + super(); // Aufrufen der übergeordneten Klasse + + try { + + pic = ImageIO.read(new File("assets/" + sauce + ".png")); // Einlesen der Datei aus dem "assets" - Ordner + + this.setIcon(new ImageIcon(pic)); // Das eingelesene BufferedImage pic wird auf das JLabel (diese Klasse) + // geladen + + } catch (IOException ex) { + + // Falls es ein Problem mit dem Einlesen der Datei gibt: + JOptionPane.showMessageDialog(null, "Please check your file paths", "Error", JOptionPane.ERROR_MESSAGE); + + } + + } + + // Methode zum auswählen eines anderen Bildes ohne ein neues Objekt erstellen zu + // müssen + public void changeSauce(String newSauce) { + + try { + + pic = ImageIO.read(new File("assets/" + newSauce + ".png")); + + this.setIcon(new ImageIcon(pic)); + + } catch (IOException e) { + + JOptionPane.showMessageDialog(null, "Please check your file paths", "Error", JOptionPane.ERROR_MESSAGE); + + } + + } + +} \ No newline at end of file diff --git a/src/Player.class b/src/Player.class new file mode 100644 index 0000000..e333f5a Binary files /dev/null and b/src/Player.class differ diff --git a/src/Player.java b/src/Player.java new file mode 100644 index 0000000..857f346 --- /dev/null +++ b/src/Player.java @@ -0,0 +1,246 @@ +import java.awt.event.KeyEvent; +import java.awt.event.KeyListener; + +// Diese Klasse stellt die vom Spieler mit den Pfeiltasten gestuerte Figur --> Pac-Man dar + +public class Player extends Picture implements KeyListener { // extends Picture --> Jeder 'Player' ist auch ein + // 'Picture' + // implements KeyListener --> Benötigt zum Erkennen von + // gedrückten Tasten. + + private static final long serialVersionUID = -4225811153447791553L; + + private float xPos; // Position auf dem Frame in x-Richtung + private float yPos; // Position auf dem Frame in y-Richtung + + public int lives = 3; + + private float speed = 0.00000014f; // Diee Geschwindigkeit von Pac-man. In alle Richtungen gleich. Muss so klein + // sein wegen delta time + + public long timer; // Variable die speichert zu welchem Zeitpunkt eine Änderung der Richtung + // vorgenommen wurde, welche nicht sofort durchgeführt wegen kann, wegen einem + // Brick, welcher im Weg ist. --> siehe boolean hui + public int blob = 1000; // Zeit in ms, nachdem die Richtungsangabe auf einer Geraden zurückgesetzt wird + + public boolean right; // Boolean der speichert, ob sich Pac-Man gerade nach rechts bewegt (Analog für + // links, oben, unten) + public boolean pressed_right; // Boolean der speichert, ob Pac-Man als nächstes nach rechts gehen soll (Analog + // für links, oben, unten) + public boolean left; + public boolean pressed_left; + public boolean up; + public boolean pressed_up; + public boolean down; + public boolean pressed_down; + + private boolean hui; // Boolean zur Abfrage, ob gerade ein Brick im Weg ist, um den aktuellen + // Richtungsbefehl durchzuführen. + + public Player() { // Erstellen des Konstruktors + + super("Pacman_Right"); // Aufrufen der übergeordneten Klasse (Picture) + + } + + public void calcDir(int keyCode) { // Methode zum Errechnen der Richtung in die Pacman gerade geht und als nächstes + // gehen soll mit der Eingabe, welche Taste angeschlagen wurde + + // keyCode = 37 --> Pfeiltaste nach links + // keyCode = 39 --> Pfeiltaste nach rechts + // keyCode = 38 --> Pfeiltaste nach oben + // keyCode = 40 --> Pfeiltaste nach unten + + if (keyCode == 37 || pressed_left && System.currentTimeMillis() - timer <= blob) { + for (int i = 0; i < 35; i++) { // für jeden Brick + for (int j = 0; j < 35; j++) { // für jeden Bick + if (Map.bricks[j][i] != null) { // Damit kein Fehler auftritt wegen nicht vorhandenen Bricks + if (Map.bricks[j][i].xPos + 20 == (int) xPos && (int) yPos < Map.bricks[j][i].yPos + 20 + && (int) yPos > Map.bricks[j][i].yPos - 20) { // wenn Pac-Man gerade rechts an einem + // Brick vorbeistreift: + hui = true; // Pac-Man kann gerade nicht nach links gehen + } + } + } + } + if (!hui) { // wenn links von Pac-Man gerade kein Block ist: + + // bewegt sich Pac-Man nun nach links: + left = true; + right = false; + up = false; + down = false; + + // und Pac-Man hat keine Richtung in die er als nächstes soll: + pressed_left = false; + pressed_right = false; + pressed_up = false; + pressed_down = false; + + // und Pac-Man schaut jetzt nach links + this.changeSauce("Pacman_Left"); + } else { // ansonsten: + + // soll Pac-Man sich sobald er kann nach links bewegen + pressed_left = true; + pressed_right = false; + pressed_up = false; + pressed_down = false; + + if (keyCode == 37) // wenn die Pfeiltaste nach links gedrückt wurde: + timer = System.currentTimeMillis(); // wird der Timer, der angibt, wann der Befehl zum nach links + // Abbiegen eingegeben wurde + } + } + + // Analog für rechts, oben, unten: + + if (keyCode == 39 || pressed_right && System.currentTimeMillis() - timer <= blob) { + for (int i = 0; i < 35; i++) { + for (int j = 0; j < 35; j++) { + if (Map.bricks[j][i] != null) { + if (Map.bricks[j][i].xPos - 20 == (int) xPos && (int) yPos < Map.bricks[j][i].yPos + 20 + && (int) yPos > Map.bricks[j][i].yPos - 20) { + hui = true; + } + } + } + } + if (!hui) { + left = false; + right = true; + up = false; + down = false; + pressed_left = false; + pressed_right = false; + pressed_up = false; + pressed_down = false; + this.changeSauce("Pacman_Right"); + } else { + pressed_left = false; + pressed_right = true; + pressed_up = false; + pressed_down = false; + if (keyCode == 39) + timer = System.currentTimeMillis(); + } + } + + if (keyCode == 38 || pressed_up && System.currentTimeMillis() - timer <= blob) { + for (int i = 0; i < 35; i++) { + for (int j = 0; j < 35; j++) { + if (Map.bricks[j][i] != null) { + if (Map.bricks[j][i].yPos + 20 == (int) yPos && (int) xPos < Map.bricks[j][i].xPos + 20 + && (int) xPos > Map.bricks[j][i].xPos - 20) { + hui = true; + } + } + } + } + if (!hui) { + left = false; + right = false; + up = true; + down = false; + pressed_left = false; + pressed_right = false; + pressed_up = false; + pressed_down = false; + this.changeSauce("Pacman_Up"); + } else { + pressed_left = false; + pressed_right = false; + pressed_up = true; + pressed_down = false; + if (keyCode == 38) + timer = System.currentTimeMillis(); + } + } + + if (keyCode == 40 || pressed_down && System.currentTimeMillis() - timer <= blob) { + for (int i = 0; i < 35; i++) { + for (int j = 0; j < 35; j++) { + if (Map.bricks[j][i] != null) { + if (Map.bricks[j][i].yPos - 20 == (int) yPos && (int) xPos < Map.bricks[j][i].xPos + 20 + && (int) xPos > Map.bricks[j][i].xPos - 20) { + hui = true; + } + } + } + } + if (!hui) { + left = false; + right = false; + up = false; + down = true; + pressed_left = false; + pressed_right = false; + pressed_up = false; + pressed_down = false; + this.changeSauce("Pacman_Down"); + } else { + pressed_left = false; + pressed_right = false; + pressed_up = false; + pressed_down = true; + if (keyCode == 40) + timer = System.currentTimeMillis(); + } + } + hui = false; // Muss zurückgesetzt werden + } + + // Methoden zur Erkennung von Tastenanschlägen: + + public void keyPressed(KeyEvent e) { + + calcDir(e.getKeyCode()); // aufrufen von der Methode calcDir mit der Eingabe e.getKeyCode() --> zuletzt + // angeschlagene Taste + + } + + // Die folgenden 2 Methoden sind zwar leer, müssen jedoch trotzdem existieren, + // damit nicht dauerhaft Fehlermeldungen ausgegeben werden: + + public void keyReleased(KeyEvent e) { + + } + + public void keyTyped(KeyEvent e) { + + } + + // Methode zum Errechnen der aktuellen Position + public int getPos(char coordinate, long dt) { // Hier kommt die zuvor erwähnte delta time ins Spiel + + if (coordinate == 'x') { // Auslesen der 'x' - Koordinate: + if (left && dt != 0) { + xPos -= speed * dt; + } else if (right && dt != 0) { + xPos += speed * dt; + } + return (int) xPos; + } else if (coordinate == 'y') { // Auslesen der 'y' - Koordinate: + if (down && dt != 0) { + yPos += speed * dt; + } else if (up && dt != 0) { + yPos -= speed * dt; + } + return (int) yPos; + } else { + return -1; + } + } + + // Methode zum Setzen einer neuen Position: + public void setPos(char coordinate, int newPos) { + + if (coordinate == 'x') { + this.xPos = newPos; + } else if (coordinate == 'y') { + this.yPos = newPos; + } + + } + +}