diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000000000000000000000000000000000000..23567b34b183d1037608f3eddb27ecafc77a9a8d
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,6 @@
+{
+ "java.project.referencedLibraries": [
+ "lib/**/*.jar"
+ ]
+ }
+
\ No newline at end of file
diff --git a/Struktur b/Struktur
new file mode 100644
index 0000000000000000000000000000000000000000..d13f7b14c87e9c7450a8ca32472cb8debb8e12aa
--- /dev/null
+++ b/Struktur
@@ -0,0 +1,37 @@
+src/
+├── main/
+│ └── Main.java # Startpunkt der Anwendung
+│
+├── models/ # Datenklassen
+│ ├── User.java # Repräsentiert einen Benutzer
+│ ├── GameData.java # Speichert Spielfortschritt (z.B. Level, Score)
+│ ├── Level.java # Repräsentiert ein Level des Spiels
+│
+├── managers/ # Logik und Verwaltung
+│ ├── UserManager.java # Verwaltung der Benutzer (Login/Registrierung)
+│ ├── SessionManager.java # Verwaltung der "angemeldet bleiben"-Sitzung
+│ ├── GameManager.java # Verwaltung des Spielfortschritts
+│
+├── utils/ # Hilfsklassen und Tools
+│ ├── FileHandler.java # Speichern und Laden von Daten
+│ ├── Constants.java # Konstanten für das Spiel
+│
+├── gui/ # GUI-Klassen für Screens
+│ ├── LoginScreen.java # Login-Bildschirm
+│ ├── RegisterScreen.java # Registrierungsbildschirm
+│ ├── StartScreen.java # Startbildschirm (Login/Register Buttons)
+│ ├── MainScreen.java # Hauptmenü (Start Game, Load, Settings, etc.)
+│ ├── GameScreen.java # Der eigentliche Traffic Jam-Spielbildschirm
+│ ├── LoadScreen.java # Laden von Spielständen
+│ ├── SettingsScreen.java # Einstellungen (optional)
+│ ├── HowToPlayScreen.java # Anleitung zum Spiel (optional)
+│ ├── CreditsScreen.java # Credits-Bildschirm (optional)
+│
+├── game/ # Spiellogik
+│ ├── TrafficJamGame.java # Hauptlogik des Spiels
+│ ├── Tile.java # Einzelne Spielfelder (z.B. Autos, Hindernisse)
+│
+└── data/ # Speicherordner für Benutzerdaten und Spielfortschritt
+ ├── users.dat # Binäre Datei mit Benutzerdaten
+ ├── savegame1.dat # Beispiel-Spielstand
+ ├── savegame2.dat # Beispiel-Spielstand
\ No newline at end of file
diff --git a/lib/gson-2.10.jar b/lib/gson-2.10.jar
new file mode 100644
index 0000000000000000000000000000000000000000..4b57f5bec7733e27ec996f03a76193c32e0a3e86
Binary files /dev/null and b/lib/gson-2.10.jar differ
diff --git a/src/data/GameData.json b/src/data/GameData.json
new file mode 100644
index 0000000000000000000000000000000000000000..c9f8b2ebdefc2b8de699d24044e4b77872e0b79f
--- /dev/null
+++ b/src/data/GameData.json
@@ -0,0 +1,16 @@
+{
+ "1": {
+ "highestLevel": 2,
+ "highScores": {
+ "1": 5,
+ "2": 7
+ }
+ },
+ "2": {
+ "highestLevel": 2,
+ "highScores": {
+ "1": 5,
+ "2": 7
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/data/Session.json b/src/data/Session.json
new file mode 100644
index 0000000000000000000000000000000000000000..be1222065f909c10e17b0d66d36d17d0e3567827
--- /dev/null
+++ b/src/data/Session.json
@@ -0,0 +1 @@
+{"id":2,"username":"Paul2","passwordHash":"MJ1s2c3HpzPmzZg/s3EO/B/2zliC2Ihs6we4u8jS+ds\u003d","salt":"5xcEbfypxAEJNEXj/Zuo6A\u003d\u003d","highScore":0}
\ No newline at end of file
diff --git a/src/data/Users.json b/src/data/Users.json
new file mode 100644
index 0000000000000000000000000000000000000000..e8886265db970fc676054e65a81fa5a1bc9e1496
--- /dev/null
+++ b/src/data/Users.json
@@ -0,0 +1 @@
+[{"id":1,"username":"Paul","passwordHash":"4dvqE5OxmjB9OhucOaipFDLMhnh+PMB1bd9Mf2jC0WQ\u003d","salt":"9vtHY/D1k/MKvnxUxhOHlw\u003d\u003d","highScore":0},{"id":2,"username":"Paul2","passwordHash":"MJ1s2c3HpzPmzZg/s3EO/B/2zliC2Ihs6we4u8jS+ds\u003d","salt":"5xcEbfypxAEJNEXj/Zuo6A\u003d\u003d","highScore":0}]
\ No newline at end of file
diff --git a/src/game/Game.java b/src/game/Game.java
new file mode 100644
index 0000000000000000000000000000000000000000..71a1b47fb4005a260ef808308b8698493dee85cf
--- /dev/null
+++ b/src/game/Game.java
@@ -0,0 +1,151 @@
+// File: src/game/Game.java
+package game;
+
+import com.google.gson.Gson;
+import com.google.gson.stream.JsonReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import managers.GameDataManager;
+
+public class Game {
+ private List<Vehicle> vehicles;
+ private Vehicle redCar;
+ private int currentLevel;
+ private int userId;
+
+ public Game() {
+ currentLevel = 1;
+ vehicles = new ArrayList<>();
+ userId = 1; // Default user ID
+ currentLevel = GameDataManager.getHighestLevel(userId); // Load highest level
+ boolean loaded = loadLevel(currentLevel);
+ if (!loaded) {
+ System.out.println("Kein Level gefunden!");
+ }
+ }
+
+ public Game(int level) {
+ currentLevel = level;
+ vehicles = new ArrayList<>();
+ userId = 1; // Default user ID
+ boolean loaded = loadLevel(currentLevel);
+ if (!loaded) {
+ System.out.println("Kein Level gefunden!");
+ }
+ }
+
+ public Game(int userId, int level) {
+ this.userId = userId;
+ currentLevel = level;
+ vehicles = new ArrayList<>();
+ boolean loaded = loadLevel(currentLevel);
+ if (!loaded) {
+ System.out.println("Kein Level gefunden!");
+ }
+ }
+
+ /**
+ * Lädt das Level aus der Datei src/maps/Level_<levelNumber>.json.
+ */
+ public boolean loadLevel(int levelNumber) {
+ String filePath = "src/maps/Level_" + levelNumber + ".json";
+ try {
+ if (!Files.exists(Paths.get(filePath))) {
+ return false;
+ }
+ Gson gson = new Gson();
+ JsonReader reader = new JsonReader(new FileReader(filePath));
+ LevelData levelData = gson.fromJson(reader, LevelData.class);
+ reader.close();
+
+ // Bestehende Fahrzeuge löschen
+ vehicles.clear();
+ redCar = null;
+
+ // Roter Wagen startet immer an der linken Seite in der mittleren Zeile
+ redCar = new Vehicle(0, 2, 2, true, true);
+ vehicles.add(redCar);
+
+ for (VehicleData vData : levelData.vehicles) {
+ // Verhindere, dass blaue Wagen in den Pfad des roten Wagens spawnen
+ if (vData.isRed || (vData.x == 0 && vData.y == 2)) continue;
+ Vehicle v = new Vehicle(vData.x, vData.y, vData.length, vData.isHorizontal, vData.isRed);
+ vehicles.add(v);
+ }
+
+ currentLevel = levelNumber;
+ if (userId != 0) {
+ GameDataManager.updateHighestLevel(userId, currentLevel); // Ensure the current level is updated
+ }
+ return true;
+ } catch (IOException e) {
+ e.printStackTrace();
+ return false;
+ }
+ }
+
+ /**
+ * Versucht, das nächste Level zu laden. Liefert true, wenn ein neues Level gefunden wurde.
+ */
+ public boolean nextLevel() {
+ int nextLevel = currentLevel + 1;
+ boolean loaded = loadLevel(nextLevel);
+ if (loaded && userId != 0) {
+ GameDataManager.updateHighestLevel(userId, nextLevel);
+ }
+ return loaded;
+ }
+
+ public List<Vehicle> getVehicles() {
+ return vehicles;
+ }
+
+ public Vehicle getRedCar() {
+ return redCar;
+ }
+
+ public int getCurrentLevel() {
+ return currentLevel;
+ }
+
+ /**
+ * Gewinnbedingung: Wenn der rote Wagen das rechte Spielfeldende erreicht.
+ */
+ public boolean checkWin() {
+ if (redCar == null) return false;
+ // Bei einem 6x6-Feld: x + Länge == 6
+ return redCar.getX() + redCar.getLength() == 6;
+ }
+
+ // Überprüfung von Kollisionen
+ public boolean checkCollision() {
+ for (Vehicle v : vehicles) {
+ if (v != redCar && redCar.collidesWith(v)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // Setzt das Level zurück
+ public void resetLevel() {
+ loadLevel(currentLevel);
+ }
+
+ // Innere Klassen, um die Level-Daten aus JSON zu repräsentieren
+ public static class LevelData {
+ public List<VehicleData> vehicles;
+ }
+
+ public static class VehicleData {
+ public int x;
+ public int y;
+ public int length;
+ public boolean isHorizontal;
+ public boolean isRed;
+ }
+}
diff --git a/src/game/Vehicle.java b/src/game/Vehicle.java
new file mode 100644
index 0000000000000000000000000000000000000000..91935e8d2ce4948534e0de315c70aa7f86a2cc2c
--- /dev/null
+++ b/src/game/Vehicle.java
@@ -0,0 +1,85 @@
+// File: src/game/Vehicle.java
+package game;
+
+import java.awt.*;
+import java.util.List;
+
+public class Vehicle {
+ private int x, y, length;
+ private boolean isHorizontal, isRed;
+
+ public Vehicle(int x, int y, int length, boolean isHorizontal, boolean isRed) {
+ this.x = x;
+ this.y = y;
+ this.length = length;
+ this.isHorizontal = isHorizontal;
+ this.isRed = isRed;
+ }
+
+ public int getX() {
+ return x;
+ }
+
+ public int getY() {
+ return y;
+ }
+
+ public int getLength() {
+ return length;
+ }
+
+ public boolean isHorizontal() {
+ return isHorizontal;
+ }
+
+ public boolean isRed() {
+ return isRed;
+ }
+
+ public boolean canMove(int dx, int dy, List<Vehicle> vehicles) {
+ int newX = x + dx;
+ int newY = y + dy;
+
+ // Check grid boundaries
+ if (isHorizontal) {
+ if (newX < 0 || newX + length > 6) return false;
+ } else {
+ if (newY < 0 || newY + length > 6) return false;
+ }
+
+ // Check for collisions with other vehicles
+ Rectangle newBounds = new Rectangle(newX * 100, newY * 100,
+ isHorizontal ? length * 100 : 100,
+ isHorizontal ? 100 : length * 100);
+ for (Vehicle v : vehicles) {
+ if (v != this && newBounds.intersects(v.getBounds())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public boolean move(int dx, int dy, List<Vehicle> vehicles) {
+ if (canMove(dx, dy, vehicles)) {
+ x += dx;
+ y += dy;
+ return true;
+ }
+ return false;
+ }
+
+ public void move(int dx, int dy) {
+ x += dx;
+ y += dy;
+ }
+
+ public Rectangle getBounds() {
+ int width = isHorizontal ? length * 100 : 100;
+ int height = isHorizontal ? 100 : length * 100;
+ return new Rectangle(x * 100, y * 100, width, height);
+ }
+
+ public boolean collidesWith(Vehicle other) {
+ return this.getBounds().intersects(other.getBounds());
+ }
+}
diff --git a/src/gui/GameScreen.java b/src/gui/GameScreen.java
new file mode 100644
index 0000000000000000000000000000000000000000..0676205e805989e232543bbfaf92a7d01345d4ad
--- /dev/null
+++ b/src/gui/GameScreen.java
@@ -0,0 +1,267 @@
+// File: src/gui/GameScreen.java
+package gui;
+
+import game.Game;
+import game.Vehicle;
+import managers.GameDataManager;
+import models.User;
+import gui.MainScreen;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.List;
+
+public class GameScreen extends JFrame {
+ private Game game;
+ private GamePanel gamePanel;
+ private JLabel levelLabel;
+ private JLabel moveCounterLabel;
+ private JLabel highScoreLabel;
+ private int moveCounter;
+ private int highScore;
+
+ public GameScreen(User user, int level) {
+ setTitle("Traffic Jam Game");
+ setSize(1280, 720); // Fenstergröße auf 1280x720 Pixel
+ setMinimumSize(new Dimension(1280, 720));
+ setMaximumSize(new Dimension(1280, 720));
+ setResizable(false);
+ setDefaultCloseOperation(EXIT_ON_CLOSE);
+ setLocationRelativeTo(null);
+ getContentPane().setBackground(Color.WHITE);
+
+ game = new Game(user.getId(), level); // Pass the correct user ID
+ moveCounter = 0;
+ highScore = GameDataManager.getHighScore(user.getId(), level);
+
+ // -----------------------------
+ // Header-Panel: Enthält nur das Level-Label
+ // -----------------------------
+ JPanel headerPanel = new JPanel();
+ headerPanel.setLayout(null); // Absolute Positionierung
+ headerPanel.setPreferredSize(new Dimension(1280, 50));
+ headerPanel.setBackground(Color.WHITE);
+
+ // Level-Label in der Mitte des Header-Panels
+ levelLabel = new JLabel("Level: " + game.getCurrentLevel(), SwingConstants.CENTER);
+ levelLabel.setFont(new Font("Arial", Font.BOLD, 16));
+ levelLabel.setOpaque(true);
+ levelLabel.setBackground(Color.WHITE);
+ int levelLabelWidth = 120;
+ int levelLabelX = (1280 - levelLabelWidth) / 2;
+ levelLabel.setBounds(levelLabelX, 10, levelLabelWidth, 30);
+ headerPanel.add(levelLabel);
+ add(headerPanel, BorderLayout.NORTH);
+
+ // -----------------------------
+ // GamePanel: Zeichnet das Spielfeld und die Fahrzeuge
+ // -----------------------------
+ gamePanel = new GamePanel(user);
+ add(gamePanel, BorderLayout.CENTER);
+
+ // -----------------------------
+ // "Züge"-Label als freies Element (nicht in einem Panel)
+ // -----------------------------
+ moveCounterLabel = new JLabel("Züge: " + moveCounter, SwingConstants.LEFT);
+ moveCounterLabel.setFont(new Font("Arial", Font.BOLD, 16));
+ moveCounterLabel.setOpaque(true);
+ moveCounterLabel.setBackground(Color.WHITE);
+ // Feste Positionierung, z. B. x = 940, y = 56
+ moveCounterLabel.setBounds(940, 56, 120, 30);
+ getLayeredPane().add(moveCounterLabel, JLayeredPane.MODAL_LAYER);
+
+ highScoreLabel = new JLabel("Highscore: " + (highScore == Integer.MAX_VALUE ? "N/A" : highScore), SwingConstants.LEFT);
+ highScoreLabel.setFont(new Font("Arial", Font.BOLD, 16));
+ highScoreLabel.setOpaque(true);
+ highScoreLabel.setBackground(Color.WHITE);
+ highScoreLabel.setBounds(940, 86, 120, 30);
+ getLayeredPane().add(highScoreLabel, JLayeredPane.MODAL_LAYER);
+
+ // Add ESC key listener to the GameScreen
+ addKeyListener(new KeyAdapter() {
+ @Override
+ public void keyPressed(KeyEvent e) {
+ if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
+ showPauseDialog(user);
+ }
+ }
+ });
+
+ setVisible(true);
+ }
+
+ private void showPauseDialog(User user) {
+ int response = JOptionPane.showOptionDialog(
+ GameScreen.this,
+ "Was möchten Sie tun?",
+ "Pause",
+ JOptionPane.YES_NO_OPTION,
+ JOptionPane.QUESTION_MESSAGE,
+ null,
+ new String[]{"Nochmal spielen", "Hauptmenü"},
+ "Nochmal spielen");
+
+ if (response == JOptionPane.YES_OPTION) {
+ game.resetLevel();
+ moveCounter = 0;
+ moveCounterLabel.setText("Züge: " + moveCounter);
+ levelLabel.setText("Level: " + game.getCurrentLevel());
+ highScore = GameDataManager.getHighScore(user.getId(), game.getCurrentLevel());
+ highScoreLabel.setText("Highscore: " + (highScore == Integer.MAX_VALUE ? "N/A" : highScore));
+ repaint();
+ } else if (response == JOptionPane.NO_OPTION) {
+ new MainScreen(user); // Return to MainScreen
+ dispose(); // Close the current window
+ }
+ }
+
+ /**
+ * Das Panel, in dem das Spielfeld und die Fahrzeuge gezeichnet werden.
+ */
+ private class GamePanel extends JPanel {
+ private Vehicle selectedVehicle = null;
+ private User user;
+
+ public GamePanel(User user) {
+ this.user = user;
+ setPreferredSize(new Dimension(1280, 720));
+ setBackground(Color.WHITE);
+ setFocusable(true);
+ requestFocusInWindow();
+ setLayout(new GridBagLayout()); // Damit das Spielfeld zentriert wird
+
+ addMouseListener(new MouseAdapter() {
+ @Override
+ public void mousePressed(MouseEvent e) {
+ int mouseX = e.getX();
+ int mouseY = e.getY();
+ int gridSize = 600; // 6x6 Raster, je 100px pro Zelle
+ int xOffset = (getWidth() - gridSize) / 2;
+ int yOffset = (getHeight() - gridSize) / 2;
+
+ // Passe die Mauskoordinaten an den Raster-Offset an
+ mouseX -= xOffset;
+ mouseY -= yOffset;
+
+ // Finde das Fahrzeug, das angeklickt wurde
+ for (Vehicle v : game.getVehicles()) {
+ if (v.getBounds().contains(mouseX, mouseY)) {
+ selectedVehicle = v;
+ break;
+ }
+ }
+ }
+ });
+
+ addKeyListener(new KeyAdapter() {
+ @Override
+ public void keyPressed(KeyEvent e) {
+ if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
+ showPauseDialog(user);
+ }
+
+ if (selectedVehicle != null) {
+ int key = e.getKeyCode();
+ boolean moved = false;
+ if (selectedVehicle.isHorizontal()) {
+ if (key == KeyEvent.VK_LEFT) {
+ moved = selectedVehicle.move(-1, 0, game.getVehicles());
+ } else if (key == KeyEvent.VK_RIGHT) {
+ moved = selectedVehicle.move(1, 0, game.getVehicles());
+ }
+ } else {
+ if (key == KeyEvent.VK_UP) {
+ moved = selectedVehicle.move(0, -1, game.getVehicles());
+ } else if (key == KeyEvent.VK_DOWN) {
+ moved = selectedVehicle.move(0, 1, game.getVehicles());
+ }
+ }
+ if (moved) {
+ moveCounter++;
+ moveCounterLabel.setText("Züge: " + moveCounter);
+ }
+ repaint();
+
+ if (game.checkWin()) {
+ // Vergleiche den aktuellen Zugzähler mit dem gespeicherten Highscore
+ boolean isNewHighScore = moveCounter < highScore;
+ if (isNewHighScore) {
+ highScore = moveCounter;
+ GameDataManager.updateHighScore(user.getId(), game.getCurrentLevel(), highScore);
+ }
+ // Nach dem Gewinn den Highscore immer neu auslesen, um Aktualität zu gewährleisten
+ highScore = GameDataManager.getHighScore(user.getId(), game.getCurrentLevel());
+ highScoreLabel.setText("Highscore: " + (highScore == Integer.MAX_VALUE ? "N/A" : highScore));
+
+ String message = isNewHighScore
+ ? "NEW HIGHSCORE: Versuche " + moveCounter
+ : "Gewonnen: Versuche " + moveCounter;
+
+ int response = JOptionPane.showOptionDialog(
+ GameScreen.this,
+ message + "\nWas möchten Sie tun?",
+ "Gewonnen",
+ JOptionPane.YES_NO_CANCEL_OPTION,
+ JOptionPane.QUESTION_MESSAGE,
+ null,
+ new String[]{"Nochmal spielen", "Nächstes Level", "Hauptmenü"},
+ "Nächstes Level");
+
+ if (response == JOptionPane.YES_OPTION) {
+ game.resetLevel();
+ moveCounter = 0;
+ moveCounterLabel.setText("Züge: " + moveCounter);
+ levelLabel.setText("Level: " + game.getCurrentLevel());
+ highScore = GameDataManager.getHighScore(user.getId(), game.getCurrentLevel());
+ highScoreLabel.setText("Highscore: " + (highScore == Integer.MAX_VALUE ? "N/A" : highScore));
+ repaint();
+ } else if (response == JOptionPane.NO_OPTION) {
+ boolean nextLoaded = game.nextLevel();
+ if (nextLoaded) {
+ moveCounter = 0;
+ moveCounterLabel.setText("Züge: " + moveCounter);
+ levelLabel.setText("Level: " + game.getCurrentLevel());
+ highScore = GameDataManager.getHighScore(user.getId(), game.getCurrentLevel());
+ highScoreLabel.setText("Highscore: " + (highScore == Integer.MAX_VALUE ? "N/A" : highScore));
+ repaint();
+ } else {
+ JOptionPane.showMessageDialog(GameScreen.this, "Alle Levels gespielt!");
+ new MainScreen(user); // Return to MainScreen
+ dispose(); // Close the current window
+ }
+ } else {
+ new MainScreen(user); // Ãœbergibt den Benutzer an MainScreen
+ dispose(); // Schließt das aktuelle Fenster
+ }
+ }
+ }
+ }
+ });
+ }
+
+ @Override
+ protected void paintComponent(Graphics g) {
+ super.paintComponent(g);
+ Graphics2D g2d = (Graphics2D) g;
+ int gridSize = 600; // Rastergröße
+ int xOffset = (getWidth() - gridSize) / 2;
+ int yOffset = (getHeight() - gridSize) / 2;
+
+ // Zeichne das 6x6 Raster (100px pro Zelle)
+ g2d.setColor(Color.LIGHT_GRAY);
+ for (int i = 0; i < 6; i++) {
+ for (int j = 0; j < 6; j++) {
+ g2d.drawRect(xOffset + i * 100, yOffset + j * 100, 100, 100);
+ }
+ }
+ // Zeichne die Fahrzeuge
+ List<Vehicle> vehicles = game.getVehicles();
+ for (Vehicle v : vehicles) {
+ g2d.setColor(v.isRed() ? Color.RED : Color.BLUE);
+ Rectangle bounds = v.getBounds();
+ g2d.fillRect(xOffset + bounds.x, yOffset + bounds.y, bounds.width, bounds.height);
+ }
+ }
+ }
+}
diff --git a/src/gui/LoginScreen.java b/src/gui/LoginScreen.java
new file mode 100644
index 0000000000000000000000000000000000000000..af62ab0a01482b92dbde0e62312382905f3f2331
--- /dev/null
+++ b/src/gui/LoginScreen.java
@@ -0,0 +1,82 @@
+package gui;
+
+import managers.UserManager;
+import managers.SessionManager;
+import models.User;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class LoginScreen extends JFrame {
+ private UserManager userManager;
+
+ public LoginScreen() {
+ userManager = new UserManager();
+
+ setTitle("Login");
+ setSize(400, 300);
+ setDefaultCloseOperation(EXIT_ON_CLOSE);
+ setLocationRelativeTo(null);
+ setLayout(new GridBagLayout());
+
+ GridBagConstraints gbc = new GridBagConstraints();
+ gbc.insets = new Insets(5, 5, 5, 5);
+
+ JLabel usernameLabel = new JLabel("Username:");
+ gbc.gridx = 0;
+ gbc.gridy = 0;
+ add(usernameLabel, gbc);
+
+ JTextField usernameField = new JTextField(20);
+ gbc.gridx = 1;
+ gbc.gridy = 0;
+ add(usernameField, gbc);
+
+ JLabel passwordLabel = new JLabel("Password:");
+ gbc.gridx = 0;
+ gbc.gridy = 1;
+ add(passwordLabel, gbc);
+
+ JPasswordField passwordField = new JPasswordField(20);
+ gbc.gridx = 1;
+ gbc.gridy = 1;
+ add(passwordField, gbc);
+
+ JCheckBox rememberMeCheckBox = new JCheckBox("Remember Me");
+ gbc.gridx = 1;
+ gbc.gridy = 2;
+ add(rememberMeCheckBox, gbc);
+
+ JButton loginButton = new JButton("Login");
+ gbc.gridx = 1;
+ gbc.gridy = 3;
+ add(loginButton, gbc);
+
+ loginButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ String username = usernameField.getText();
+ String password = new String(passwordField.getPassword());
+ User user = userManager.login(username, password);
+ if (user != null) {
+ if (rememberMeCheckBox.isSelected()) {
+ SessionManager.saveSession(user);
+ }
+ JOptionPane.showMessageDialog(LoginScreen.this, "Login erfolgreich!");
+ dispose(); // Close the login screen
+ new MainScreen(user); // Navigate to the main screen
+ } else {
+ JOptionPane.showMessageDialog(LoginScreen.this, "Ungültiger Benutzername oder Passwort.");
+ }
+ }
+ });
+
+ setVisible(true);
+ }
+
+ public static void main(String[] args) {
+ new LoginScreen();
+ }
+}
diff --git a/src/gui/MainScreen.java b/src/gui/MainScreen.java
new file mode 100644
index 0000000000000000000000000000000000000000..33809e6df1422a1272fa06121655e1a73137de1f
--- /dev/null
+++ b/src/gui/MainScreen.java
@@ -0,0 +1,154 @@
+// File: src/gui/MainScreen.java
+package gui;
+
+import managers.SessionManager;
+import models.User;
+import managers.GameDataManager;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class MainScreen extends JFrame {
+
+ public MainScreen(User user) {
+ System.out.println("Initializing MainScreen for user: " + user.getUsername());
+
+ setTitle("Main Menu");
+ setSize(1280, 720);
+ setDefaultCloseOperation(EXIT_ON_CLOSE);
+ setLocationRelativeTo(null);
+ // Hintergrund der ContentPane auf weiß setzen
+ getContentPane().setBackground(Color.WHITE);
+ setLayout(new BorderLayout());
+
+ // ---------------------------
+ // Linkes Panel mit Buttons
+ // ---------------------------
+ JPanel leftPanel = new JPanel();
+ leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.Y_AXIS));
+ leftPanel.setPreferredSize(new Dimension(200, 0)); // feste Breite, Höhe passt sich an
+ leftPanel.setBackground(Color.WHITE);
+
+ // Buttons erstellen
+ JButton newGameButton = new JButton("New Game");
+ JButton playLevelButton = new JButton("Play Level " + getHighestLevel(user));
+ JButton howToPlayButton = new JButton("How To Play");
+ JButton creditsButton = new JButton("Credits");
+ JButton logoutButton = new JButton("Logout");
+
+ // Buttons horizontal zentrieren
+ newGameButton.setAlignmentX(Component.CENTER_ALIGNMENT);
+ playLevelButton.setAlignmentX(Component.CENTER_ALIGNMENT);
+ howToPlayButton.setAlignmentX(Component.CENTER_ALIGNMENT);
+ creditsButton.setAlignmentX(Component.CENTER_ALIGNMENT);
+ logoutButton.setAlignmentX(Component.CENTER_ALIGNMENT);
+
+ // Mit Glue-Elementen werden die Buttons gleichmäßig über die Höhe verteilt
+ leftPanel.add(Box.createVerticalGlue());
+ leftPanel.add(newGameButton);
+ leftPanel.add(Box.createVerticalGlue());
+ leftPanel.add(playLevelButton);
+ leftPanel.add(Box.createVerticalGlue());
+ leftPanel.add(howToPlayButton);
+ leftPanel.add(Box.createVerticalGlue());
+ leftPanel.add(creditsButton);
+ leftPanel.add(Box.createVerticalGlue());
+ leftPanel.add(logoutButton);
+ leftPanel.add(Box.createVerticalGlue());
+
+ add(leftPanel, BorderLayout.WEST);
+
+ // ---------------------------
+ // Oberes Panel: zentrierter Titel & Profilname rechts
+ // ---------------------------
+ JPanel topPanel = new JPanel(new BorderLayout());
+ topPanel.setBackground(Color.WHITE);
+ topPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+
+ // West-Platzhalter: Gleiche Breite wie das Profil-Label, damit der Titel mittig liegt
+ JPanel westPlaceholder = new JPanel();
+ westPlaceholder.setPreferredSize(new Dimension(200, 30));
+ westPlaceholder.setBackground(Color.WHITE);
+ topPanel.add(westPlaceholder, BorderLayout.WEST);
+
+ // East: Profilname (klickbar)
+ JLabel userNameLabel = new JLabel(user.getUsername(), SwingConstants.RIGHT);
+ userNameLabel.setFont(new Font("Arial", Font.BOLD, 16));
+ userNameLabel.setOpaque(true);
+ userNameLabel.setBackground(Color.WHITE);
+ userNameLabel.setCursor(new Cursor(Cursor.HAND_CURSOR));
+ userNameLabel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 10));
+ topPanel.add(userNameLabel, BorderLayout.EAST);
+
+ add(topPanel, BorderLayout.NORTH);
+
+ // ---------------------------
+ // ActionListener für die Buttons
+ // ---------------------------
+ newGameButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ new GameScreen(user, 1); // Neues Spiel, Level 1
+ dispose();
+ }
+ });
+
+ playLevelButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ new GameScreen(user, getHighestLevel(user)); // Höchstes freigeschaltetes Level
+ dispose();
+ }
+ });
+
+ howToPlayButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ JOptionPane.showMessageDialog(MainScreen.this, "How to play instructions...");
+ }
+ });
+
+ creditsButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ JOptionPane.showMessageDialog(MainScreen.this, "Credits...");
+ }
+ });
+
+ logoutButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ handleLogout();
+ }
+ });
+
+ userNameLabel.addMouseListener(new MouseAdapter() {
+ @Override
+ public void mouseClicked(MouseEvent evt) {
+ new ProfileScreen(user); // Profilansicht öffnen
+ }
+ });
+
+ setVisible(true);
+ }
+
+ private void handleLogout() {
+ SessionManager.clearSession();
+ dispose();
+ new StartScreen().setVisible(true);
+ }
+
+ private int getHighestLevel(User user) {
+ return GameDataManager.getHighestLevel(user.getId());
+ }
+
+ public static void main(String[] args) {
+ User user = SessionManager.loadSession();
+ if (user != null) {
+ new MainScreen(user);
+ } else {
+ new LoginScreen().setVisible(true);
+ }
+ }
+}
diff --git a/src/gui/ProfileScreen.java b/src/gui/ProfileScreen.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1d739bc268d7ae32323c13c4a143d361695d22a
--- /dev/null
+++ b/src/gui/ProfileScreen.java
@@ -0,0 +1,61 @@
+package gui;
+
+import managers.SessionManager;
+import managers.UserManager;
+import models.User;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class ProfileScreen extends JFrame {
+ public ProfileScreen(User user) {
+ setTitle("Profile");
+ setSize(400, 300);
+ setDefaultCloseOperation(DISPOSE_ON_CLOSE);
+ setLocationRelativeTo(null);
+ setLayout(new GridBagLayout());
+
+ GridBagConstraints gbc = new GridBagConstraints();
+ gbc.insets = new Insets(5, 5, 5, 5);
+
+ JLabel usernameLabel = new JLabel("Username:");
+ gbc.gridx = 0;
+ gbc.gridy = 0;
+ add(usernameLabel, gbc);
+
+ JLabel usernameValue = new JLabel(user.getUsername());
+ gbc.gridx = 1;
+ gbc.gridy = 0;
+ add(usernameValue, gbc);
+
+ // Button zum Löschen des Accounts
+ JButton deleteAccountButton = new JButton("Account löschen");
+ gbc.gridx = 0;
+ gbc.gridy = 1;
+ gbc.gridwidth = 2;
+ add(deleteAccountButton, gbc);
+
+ deleteAccountButton.addActionListener(e -> {
+ int confirmation = JOptionPane.showConfirmDialog(
+ this,
+ "Sind Sie sicher, dass Sie Ihren Account löschen möchten?",
+ "Account löschen",
+ JOptionPane.YES_NO_OPTION
+ );
+
+ if (confirmation == JOptionPane.YES_OPTION) {
+ UserManager userManager = new UserManager();
+ if (userManager.deleteUser(user.getUsername())) {
+ SessionManager.clearSession();
+ JOptionPane.showMessageDialog(this, "Account erfolgreich gelöscht.");
+ dispose();
+ new StartScreen(); // Zurück zum Startbildschirm
+ } else {
+ JOptionPane.showMessageDialog(this, "Fehler beim Löschen des Accounts.");
+ }
+ }
+ });
+
+ setVisible(true);
+ }
+}
diff --git a/src/gui/RegisterScreen.java b/src/gui/RegisterScreen.java
new file mode 100644
index 0000000000000000000000000000000000000000..b93cd1184ad49a443e7bd4c1890474e05a2d365c
--- /dev/null
+++ b/src/gui/RegisterScreen.java
@@ -0,0 +1,79 @@
+package gui;
+
+import managers.UserManager;
+import managers.SessionManager;
+import models.User;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class RegisterScreen extends JFrame {
+ private UserManager userManager;
+
+ public RegisterScreen() {
+ userManager = new UserManager();
+
+ setTitle("Register");
+ setSize(400, 300);
+ setDefaultCloseOperation(EXIT_ON_CLOSE);
+ setLocationRelativeTo(null);
+ setLayout(new GridBagLayout());
+
+ GridBagConstraints gbc = new GridBagConstraints();
+ gbc.insets = new Insets(5, 5, 5, 5);
+
+ JLabel usernameLabel = new JLabel("Username:");
+ gbc.gridx = 0;
+ gbc.gridy = 0;
+ add(usernameLabel, gbc);
+
+ JTextField usernameField = new JTextField(20);
+ gbc.gridx = 1;
+ gbc.gridy = 0;
+ add(usernameField, gbc);
+
+ JLabel passwordLabel = new JLabel("Password:");
+ gbc.gridx = 0;
+ gbc.gridy = 1;
+ add(passwordLabel, gbc);
+
+ JPasswordField passwordField = new JPasswordField(20);
+ gbc.gridx = 1;
+ gbc.gridy = 1;
+ add(passwordField, gbc);
+
+ JButton registerButton = new JButton("Register");
+ gbc.gridx = 1;
+ gbc.gridy = 2;
+ add(registerButton, gbc);
+
+ registerButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ String username = usernameField.getText();
+ String password = new String(passwordField.getPassword());
+ boolean success = userManager.register(username, password);
+ if (success) {
+ // Direkt einloggen: Hier holen wir den User über den Login-Vorgang (da der Hash bereits erzeugt wurde)
+ User user = userManager.login(username, password);
+ if (user != null) {
+ SessionManager.saveSession(user);
+ JOptionPane.showMessageDialog(RegisterScreen.this, "Registrierung erfolgreich und du bist eingeloggt!");
+ new MainScreen(user); // Navigate to the main screen
+ dispose(); // Close the register screen
+ }
+ } else {
+ JOptionPane.showMessageDialog(RegisterScreen.this, "Username existiert bereits.");
+ }
+ }
+ });
+
+ setVisible(true);
+ }
+
+ public static void main(String[] args) {
+ new RegisterScreen();
+ }
+}
diff --git a/src/gui/StartScreen.java b/src/gui/StartScreen.java
new file mode 100644
index 0000000000000000000000000000000000000000..3dd365b82d5578e5bbab67235113d8d522bb436b
--- /dev/null
+++ b/src/gui/StartScreen.java
@@ -0,0 +1,77 @@
+package gui;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class StartScreen extends JFrame {
+ public StartScreen() {
+ System.out.println("Initializing StartScreen...");
+
+ setTitle("Traffic Jam");
+ setSize(1280, 720);
+ setDefaultCloseOperation(EXIT_ON_CLOSE);
+ setLocationRelativeTo(null);
+ setLayout(new BorderLayout());
+
+ JPanel mainPanel = new JPanel(new GridBagLayout());
+ add(mainPanel, BorderLayout.CENTER);
+
+ JPanel containerPanel = new JPanel();
+ containerPanel.setLayout(null);
+ containerPanel.setPreferredSize(new Dimension(600, 300));
+
+ JLabel titleLabel = new JLabel("Traffic Jam", SwingConstants.CENTER);
+ titleLabel.setFont(new Font("Arial", Font.BOLD, 48));
+ titleLabel.setBounds(0, 20, 600, 60);
+ containerPanel.add(titleLabel);
+
+ JButton loginButton = new JButton("Login");
+ loginButton.setBounds(130, 120, 120, 40);
+ containerPanel.add(loginButton);
+
+ JButton registerButton = new JButton("Register");
+ registerButton.setBounds(350, 120, 120, 40);
+ containerPanel.add(registerButton);
+
+ GridBagConstraints gbc = new GridBagConstraints();
+ gbc.gridx = 0;
+ gbc.gridy = 0;
+ gbc.weightx = 1.0;
+ gbc.weighty = 1.0;
+ gbc.anchor = GridBagConstraints.CENTER;
+ mainPanel.add(containerPanel, gbc);
+
+ JLabel versionLabel = new JLabel("Version 1.0", SwingConstants.RIGHT);
+ versionLabel.setFont(new Font("Arial", Font.ITALIC, 12));
+ JPanel versionPanel = new JPanel(new BorderLayout());
+ versionPanel.add(versionLabel, BorderLayout.EAST);
+ add(versionPanel, BorderLayout.SOUTH);
+
+ loginButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ System.out.println("Login button clicked");
+ dispose(); // Close the start screen
+ new LoginScreen(); // Open the login screen
+ }
+ });
+
+ registerButton.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ System.out.println("Register button clicked");
+ dispose(); // Close the start screen
+ new RegisterScreen(); // Open the register screen
+ }
+ });
+
+ setVisible(true);
+ System.out.println("StartScreen is now visible");
+ }
+
+ public static void main(String[] args) {
+ new StartScreen();
+ }
+}
\ No newline at end of file
diff --git a/src/main/Main.java b/src/main/Main.java
new file mode 100644
index 0000000000000000000000000000000000000000..414c616f020f3fff8ce77481fd9dbe708139a57a
--- /dev/null
+++ b/src/main/Main.java
@@ -0,0 +1,27 @@
+package main;
+
+import managers.SessionManager;
+import models.User;
+
+import javax.swing.*;
+
+import gui.StartScreen;
+import gui.MainScreen;
+
+public class Main {
+ public static void main(String[] args) {
+ System.out.println("Starting application...");
+
+ // Prüfe, ob eine Session existiert
+ User sessionUser = SessionManager.loadSession();
+ if (sessionUser != null) {
+ System.out.println("Session found for user: " + sessionUser.getUsername());
+ JOptionPane.showMessageDialog(null, "Willkommen zurück, " + sessionUser.getUsername() + "!");
+ // Starte den Hauptbildschirm bzw. das Spiel und übergebe den Benutzer
+ new MainScreen(sessionUser);
+ } else {
+ System.out.println("No session found, starting StartScreen...");
+ new StartScreen();
+ }
+ }
+}
diff --git a/src/managers/GameDataManager.java b/src/managers/GameDataManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..9510b200856ab53a9cb0c467fc33f8c517572fba
--- /dev/null
+++ b/src/managers/GameDataManager.java
@@ -0,0 +1,110 @@
+// File: src/managers/GameDataManager.java
+package managers;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+
+import java.io.*;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
+public class GameDataManager {
+ private static final String FILE_PATH = "src/data/GameData.json";
+ private static Map<Integer, UserData> gameData = new HashMap<>();
+
+ static {
+ loadGameData();
+ }
+
+ /**
+ * Gibt den Highscore für den angegebenen User und Level zurück.
+ * Falls noch kein Highscore existiert, wird Integer.MAX_VALUE zurückgegeben.
+ */
+ public static int getHighScore(int userId, int level) {
+ UserData userData = gameData.get(userId);
+ if (userData != null && userData.highScores.containsKey(level)) {
+ int score = userData.highScores.get(level);
+ // Falls der gespeicherte Score 0 ist, betrachten wir ihn als nicht gesetzt.
+ return score == 0 ? Integer.MAX_VALUE : score;
+ }
+ return Integer.MAX_VALUE;
+ }
+
+ /**
+ * Gibt das höchste freigeschaltete Level für den angegebenen User zurück.
+ * Falls keine Daten vorhanden sind, wird 1 zurückgegeben.
+ */
+ public static int getHighestLevel(int userId) {
+ UserData userData = gameData.get(userId);
+ if (userData != null) {
+ return userData.highestLevel;
+ }
+ return 1;
+ }
+
+ /**
+ * Aktualisiert den Highscore für den gegebenen User und Level, falls der neue Score niedriger ist.
+ */
+ public static void updateHighScore(int userId, int level, int score) {
+ UserData userData = gameData.computeIfAbsent(userId, k -> new UserData());
+ int current = userData.highScores.getOrDefault(level, Integer.MAX_VALUE);
+ if (current == 0) {
+ current = Integer.MAX_VALUE;
+ }
+ if (score < current) {
+ userData.highScores.put(level, score);
+ saveGameData();
+ }
+ }
+
+ /**
+ * Aktualisiert das höchste freigeschaltete Level für den gegebenen User, sofern ein höheres Level erreicht wurde.
+ */
+ public static void updateHighestLevel(int userId, int level) {
+ UserData userData = gameData.computeIfAbsent(userId, k -> new UserData());
+ userData.highestLevel = level;
+ saveGameData(); // Ensure the data is saved after updating
+ }
+
+ /**
+ * Lädt die Spieldaten aus der JSON-Datei.
+ */
+ private static void loadGameData() {
+ File file = new File(FILE_PATH);
+ if (file.exists()) {
+ try (Reader reader = new FileReader(file)) {
+ Gson gson = new Gson();
+ Type type = new TypeToken<Map<Integer, UserData>>() {}.getType();
+ Map<Integer, UserData> data = gson.fromJson(reader, type);
+ if (data != null) {
+ gameData = data;
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ /**
+ * Speichert die aktuellen Spieldaten in die JSON-Datei.
+ */
+ private static void saveGameData() {
+ try (Writer writer = new FileWriter(FILE_PATH)) {
+ Gson gson = new GsonBuilder().setPrettyPrinting().create();
+ gson.toJson(gameData, writer);
+ System.out.println("Game data saved to " + FILE_PATH);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Interne Klasse zur Repräsentation der Daten eines Users.
+ */
+ private static class UserData {
+ int highestLevel = 1;
+ Map<Integer, Integer> highScores = new HashMap<>();
+ }
+}
diff --git a/src/managers/SessionManager.java b/src/managers/SessionManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..02f26da98836ed2a9e9d82a21e9c9620f815d2c5
--- /dev/null
+++ b/src/managers/SessionManager.java
@@ -0,0 +1,42 @@
+package managers;
+
+import com.google.gson.Gson;
+import models.User;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public class SessionManager {
+ private static final String SESSION_FILE = "src/data/Session.json";
+ private static final Gson gson = new Gson();
+
+ // Speichert den aktuellen User in der Session-Datei
+ public static void saveSession(User user) {
+ try (Writer writer = new FileWriter(SESSION_FILE)) {
+ gson.toJson(user, writer);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ // Lädt den User aus der Session-Datei (falls vorhanden)
+ public static User loadSession() {
+ if (new File(SESSION_FILE).exists()) {
+ try (Reader reader = new FileReader(SESSION_FILE)) {
+ return gson.fromJson(reader, User.class);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ return null;
+ }
+
+ // Löscht die Session (z. B. beim Logout)
+ public static void clearSession() {
+ try {
+ Files.deleteIfExists(Paths.get(SESSION_FILE));
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/src/managers/UserManager.java b/src/managers/UserManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..e27f15ae946077794418a1f7b6b470c92b97fc90
--- /dev/null
+++ b/src/managers/UserManager.java
@@ -0,0 +1,87 @@
+package managers;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import models.User;
+import utils.PasswordUtils;
+
+import java.io.*;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+public class UserManager {
+ private static final String FILE_PATH = "src/data/Users.json";
+ private List<User> users;
+ private int nextId;
+
+ public UserManager() {
+ users = loadUsers();
+ nextId = users.size() + 1;
+ }
+
+ public boolean register(String username, String password) {
+ if (getUserByUsername(username) != null) {
+ return false; // User already exists
+ }
+ users.add(new User(nextId++, username, password));
+ saveUsers();
+ return true;
+ }
+
+ public User login(String username, String password) {
+ User user = getUserByUsername(username);
+ if (user != null) {
+ // Hash des eingegebenen Passworts mit dem beim Registrieren gespeicherten Salt
+ String hashedInput = PasswordUtils.hashPassword(password, user.getSalt());
+ if (hashedInput.equals(user.getPasswordHash())) {
+ return user;
+ }
+ }
+ return null;
+ }
+
+ public boolean deleteUser(String username) {
+ User user = getUserByUsername(username);
+ if (user != null) {
+ users.remove(user);
+ saveUsers();
+ return true;
+ }
+ return false;
+ }
+
+ private User getUserByUsername(String username) {
+ for (User user : users) {
+ if (user.getUsername().equals(username)) {
+ return user;
+ }
+ }
+ return null;
+ }
+
+ private void saveUsers() {
+ try (Writer writer = new FileWriter(FILE_PATH)) {
+ Gson gson = new Gson();
+ gson.toJson(users, writer);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+
+ private List<User> loadUsers() {
+ if (new File(FILE_PATH).exists()) {
+ try (Reader reader = new FileReader(FILE_PATH)) {
+ Gson gson = new Gson();
+ Type userListType = new TypeToken<ArrayList<User>>() {}.getType();
+ List<User> loadedUsers = gson.fromJson(reader, userListType);
+ if (loadedUsers != null) {
+ return loadedUsers;
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ return new ArrayList<>();
+ }
+}
diff --git a/src/maps/Level_1.json b/src/maps/Level_1.json
new file mode 100644
index 0000000000000000000000000000000000000000..10d3d613e7ca3cf60122bbb52308129721936da3
--- /dev/null
+++ b/src/maps/Level_1.json
@@ -0,0 +1,10 @@
+{
+ "vehicles": [
+ { "x": 0, "y": 0, "length": 2, "isHorizontal": false, "isRed": false },
+ { "x": 2, "y": 0, "length": 2, "isHorizontal": true, "isRed": false },
+ { "x": 4, "y": 1, "length": 2, "isHorizontal": false, "isRed": false },
+ { "x": 1, "y": 4, "length": 2, "isHorizontal": false, "isRed": false },
+ { "x": 2, "y": 3, "length": 2, "isHorizontal": true, "isRed": true },
+ { "x": 5, "y": 4, "length": 2, "isHorizontal": false, "isRed": false }
+ ]
+}
diff --git a/src/maps/level_2.json b/src/maps/level_2.json
new file mode 100644
index 0000000000000000000000000000000000000000..58c7130cac56e5ff5e9a880033748347094ec4d7
--- /dev/null
+++ b/src/maps/level_2.json
@@ -0,0 +1,10 @@
+{
+ "vehicles": [
+ { "x": 0, "y": 0, "length": 2, "isHorizontal": false, "isRed": false },
+ { "x": 4, "y": 2, "length": 2, "isHorizontal": false, "isRed": false },
+ { "x": 4, "y": 4, "length": 2, "isHorizontal": true, "isRed": false },
+ { "x": 3, "y": 1, "length": 2, "isHorizontal": true, "isRed": false },
+ { "x": 0, "y": 2, "length": 2, "isHorizontal": true, "isRed": true }
+ ]
+ }
+
\ No newline at end of file
diff --git a/src/models/User.java b/src/models/User.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac0e4f332c3716c3d70e3677d937592313ed63dd
--- /dev/null
+++ b/src/models/User.java
@@ -0,0 +1,36 @@
+// File: src/models/User.java
+package models;
+
+import java.io.Serializable;
+import utils.PasswordUtils;
+
+public class User implements Serializable {
+ private int id;
+ private String username;
+ private String passwordHash;
+ private String salt;
+
+ public User(int id, String username, String password) {
+ this.id = id;
+ this.username = username;
+ // Generiere einen Salt und erstelle den Passwort-Hash
+ this.salt = PasswordUtils.generateSalt();
+ this.passwordHash = PasswordUtils.hashPassword(password, salt);
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public String getUsername() {
+ return username;
+ }
+
+ public String getPasswordHash() {
+ return passwordHash;
+ }
+
+ public String getSalt() {
+ return salt;
+ }
+}
diff --git a/src/utils/PasswordUtils.java b/src/utils/PasswordUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccf34904bc57b4a387f7b70a85adc96b95f48559
--- /dev/null
+++ b/src/utils/PasswordUtils.java
@@ -0,0 +1,29 @@
+package utils;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Base64;
+
+public class PasswordUtils {
+
+ // Generiert einen zufälligen Salt (Base64-kodiert)
+ public static String generateSalt() {
+ SecureRandom sr = new SecureRandom();
+ byte[] salt = new byte[16]; // 128 Bit Salt
+ sr.nextBytes(salt);
+ return Base64.getEncoder().encodeToString(salt);
+ }
+
+ // Hashing des Passworts unter Verwendung von SHA-256 und dem Salt
+ public static String hashPassword(String password, String salt) {
+ try {
+ MessageDigest md = MessageDigest.getInstance("SHA-256");
+ md.update(salt.getBytes()); // Salt hinzufügen
+ byte[] hashedPassword = md.digest(password.getBytes());
+ return Base64.getEncoder().encodeToString(hashedPassword);
+ } catch (NoSuchAlgorithmException e) {
+ throw new RuntimeException("SHA-256 Algorithmus nicht verfügbar", e);
+ }
+ }
+}