src/BoardDisplay.java

@@ -2,14 +2,32 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
+import java.util.ArrayList;
+import java.util.List;
 
+/**
+ * TODO Klassenbeschreibung
+ */
 public class BoardDisplay extends JPanel {
-    public BoardDisplay(int gridSize, Icon buttonIcon) {
+    private JButton[][] fields;
-        super(new GridLayout(gridSize + 1, gridSize + 1)); // +1 wegen extra Zeile/Splate
+    private int gridSize;
+    private List <Ship> ships;
 
+    /**
+     * Konstruktor der startLocalGame.
+     * TODO fertig schreiben
+     * @param gridSize
+     * @param player
+     */
+    public BoardDisplay(int gridSize, Player player) {
+        super(new GridLayout(gridSize + 1, gridSize + 1)); // +1 wegen extra Zeile/Splate
+        this.fields = new JButton[gridSize][gridSize];
+        this.ships = new ArrayList<>();
         // Erstellung von Spielfeld
         for (int i = 0; i <= gridSize; i++) {
             for (int j = 0; j <= gridSize; j++) {
+                final int x = i; // Temporäre Variable
+                final int y = j; // Temporäre Variable
                 if (i == 0 && j == 0) {
                     add(new JLabel(" "));
                 } else if (i == 0) {
@@ -28,27 +46,116 @@ public class BoardDisplay extends JPanel {
                     field.setBackground(Color.LIGHT_GRAY);
                     field.setOpaque(true);
                     field.setBorderPainted(true);
+                    fields[i - 1][j - 1] = field;
+                    add(field);
+                    //field.addMouseListener(new MouseAdapter() {
+                       // @Override
+                        //public void mouseClicked(MouseEvent e) {
+                         //   if (SwingUtilities.isRightMouseButton(e)) {
+                         //       handleFieldClick(field);
+                         //   }
+                       // }
 
+                        //@Override
+                        //public void mouseExited(MouseEvent e) {
+                            // field.setBackground(Color.LIGHT_GRAY);
+                       // }
+                   // });
+                    int finalI = i;
+                    int finalJ = j;
                     field.addMouseListener(new MouseAdapter() {
                         @Override
                         public void mouseClicked(MouseEvent e) {
-                            if(SwingUtilities.isRightMouseButton(e)) {
+                            Point o= new Point(finalI, finalJ);
-                                handleFieldClick(field);
+                            System.out.println(o);
-                            }
+                            handleFieldClick(field, o,player);
-                        }
-
-                        @Override
-                        public void mouseExited(MouseEvent e) {
-                           // field.setBackground(Color.LIGHT_GRAY);
                         }
                     });
-                    add(field);
+                }
+            }
+        }
+
+       // this.ships = new ArrayList<Ship>();
+    }
+
+    /**
+     * TODO Funktion beschreiben etc.
+     * @param ship
+     * @param o
+     * @param horizontal
+     * @param player
+     * @return
+     */
+    private boolean setShip(Ship ship, Point o, boolean horizontal,Player player) {
+        //boolean a = true;
+        if (placeable(ship, ship.getPosition(), horizontal)) {
+            ship.setPosition(new Point(o.getX(),o.getY()),player.getBoard().getShips(),gridSize);
+            ship.setHorizontal(horizontal);
+            ships.add(ship);
+            List<Point> occupied = ship.getOccupiedPoints();
+            for(Point p: occupied) {
+                fields[p.getX()][p.getY()].setBackground(Color.LIGHT_GRAY);
+            }
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    /*private boolean placeable(Ship ship,Point o, boolean horizontal) {
+        if (horizontal && (o.getX() + ship.getSize() > gridSize)) { // Fehler
+            return false;
+        }
+        if (!horizontal && (o.getY() + ship.getSize() > gridSize)) {
+            return false;
+        }
+        return true;
+    }*/
+
+    /**
+     * TODO Funktion beschreiben etc.
+     * @param ship
+     * @param o
+     * @param horizontal
+     * @return
+     */
+    private boolean placeable(Ship ship, Point o, boolean horizontal) {
+        if (horizontal && (o.getX() + ship.getSize() > gridSize)) {
+            return false;
+        }
+        if (!horizontal && (o.getY() + ship.getSize() > gridSize)) {
+            return false;
+        }
+
+        // Prüfen auf Kollision mit bestehenden Schiffen
+        for (Ship other : ships) {
+            for (Point p : other.getOccupiedPoints()) {
+                for (Point newP : ship.getOccupiedPoints()) {
+                    if (p.equals(newP)) {
+                        return false; // Überschneidung gefunden
                     }
                 }
             }
         }
 
-    private void handleFieldClick(JButton field) {
+        return true;
-        field.setBackground(Color.RED);
+    }
+
+
+    private void selectShip(MouseEvent e) {
+        Ship current = (Ship) e.getSource();
+    }
+
+    /**
+     * TODO Funktion beschreiben etc.
+     * @param field
+     * @param o
+     * @param player
+     */
+    private void handleFieldClick(JButton field, Point o,Player player) {
+        // Beispiel: Setze ein Schiff bei einem Klick
+        if (setShip(new Ship(3, "TestShip"), o, true,player)) {
+            field.setBackground(Color.BLUE); // Visualisiere Schiff
+        }
     }
 }

src/GameBoard.java

@@ -4,7 +4,14 @@ import javax.swing.*;
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseAdapter;
+import java.util.List;
 
+/**
+ * Das GameBoard dient als Panel, in dem das tatsächliche Spiel stattfindet.
+ * Der Benutzer kann hier seine Schiffe platzieren, das Spiel starten etc.
+ */
 public class GameBoard extends JPanel {
     // Funktionshilfen
     //int semesterCounter = 1; //TODO: ersetzen durch param von vorpanel
@@ -21,6 +28,15 @@ public class GameBoard extends JPanel {
 
     JButton backButton = new JButton(backButtonIcon);
     // Eigene ModulButtons
+
+    /**
+     * Konstruktor von GameBoard.
+     * @param frame Der Mainframe der Anwendung über den alle Panels angezeigt werden.
+     * @param semesterCounter Ausgewähltes Semester
+     * @param p1 Erstes Spielerobjekt
+     * @param p2 Zweites Spielerobjekt
+     */
+    GameBoard(MainFrame frame, int semesterCounter,Player p1, Player p2) {
         JToggleButton leftPlayerModul1 = new JToggleButton("Modul 1"); //TODO: Dynamische Namen durch abgleich mit Semester
         JToggleButton leftPlayerModul2 = new JToggleButton("Modul 2");
         JToggleButton leftPlayerModul3 = new JToggleButton("Modul 3");
@@ -29,6 +45,11 @@ public class GameBoard extends JPanel {
         JToggleButton leftPlayerModul6 = new JToggleButton("Modul 6");
         JToggleButton leftPlayerModul7 = new JToggleButton("Reset");
 
+        JToggleButton[] leftPlayerButtons=new JToggleButton[]{
+                leftPlayerModul1, leftPlayerModul2, leftPlayerModul3, leftPlayerModul4,
+                leftPlayerModul5, leftPlayerModul6, leftPlayerModul7,
+        };
+
         // Gegnerische ModulButtons
         JToggleButton rightPlayerModul1 = new JToggleButton("Modul 1");
         JToggleButton rightPlayerModul2 = new JToggleButton("Modul 2");
@@ -38,7 +59,39 @@ public class GameBoard extends JPanel {
         JToggleButton rightPlayerModul6 = new JToggleButton("Modul 6");
         JToggleButton rightPlayerModul7 = new JToggleButton("Bereit");
 
-    public void buildPanel(MainFrame frame, int semesterCounter) {
+        JToggleButton[] rightlayerButtons=new JToggleButton[]{
+                rightPlayerModul1, rightPlayerModul2, rightPlayerModul3, rightPlayerModul4,
+                rightPlayerModul5, rightPlayerModul6, rightPlayerModul7,
+        };
+
+        buildPanel(frame, semesterCounter,p1,p2,leftPlayerButtons,rightlayerButtons);
+        List<Ship> shipsP1 =p1.getBoard().getShips();
+        updateButtonLabels(shipsP1,leftPlayerButtons);
+        backButton.addActionListener(e -> frame.showPanel("MainMenu"));
+    }
+
+    /**
+     * TODO Funktion beschreiben etc.
+     * @param ships
+     * @param buttons
+     */
+    private void updateButtonLabels(List<Ship> ships,JToggleButton[] buttons) {
+        for(int i=0;i<buttons.length &&i<ships.size();i++ ) {
+            Ship ship = ships.get(i);
+            buttons[i].setText(ship.getName());
+        }
+    }
+
+    /**
+     * TODO Funktion beschreiben etc.
+     * @param frame
+     * @param semesterCounter
+     * @param p1
+     * @param p2
+     * @param leftButtons
+     * @param rightButtons
+     */
+    public void buildPanel(MainFrame frame, int semesterCounter,Player p1,Player p2,JToggleButton[] leftButtons,JToggleButton[] rightButtons) {
         // Hauptlayout - BorderLayout für die Anordnung der Komponenten
         setLayout(new BorderLayout());
 
@@ -51,51 +104,51 @@ public class GameBoard extends JPanel {
         // Panel für die Buttons des linken Spielers (ganz links)
         JPanel leftButtonsPanel = new JPanel();
         leftButtonsPanel.setLayout(new GridLayout(7, 1)); // 6 Buttons untereinander
-        leftButtonsPanel.add(leftPlayerModul1);
+        leftButtonsPanel.add(leftButtons[0]);
-        leftButtonsPanel.add(leftPlayerModul2);
+        leftButtonsPanel.add(leftButtons[1]);
-        leftButtonsPanel.add(leftPlayerModul3);
+        leftButtonsPanel.add(leftButtons[2]);
-        leftButtonsPanel.add(leftPlayerModul4);
+        leftButtonsPanel.add(leftButtons[3]);
-        leftButtonsPanel.add(leftPlayerModul5);
+        leftButtonsPanel.add(leftButtons[4]);
-        leftButtonsPanel.add(leftPlayerModul6);
+        leftButtonsPanel.add(leftButtons[5]);
-        leftButtonsPanel.add(leftPlayerModul7);
+        leftButtonsPanel.add(leftButtons[6]);
 
         // Panel für die Buttons des rechten Spielers (ganz rechts)
         JPanel rightButtonsPanel = new JPanel();
         rightButtonsPanel.setLayout(new GridLayout(7, 1)); // 6 Buttons untereinander
-        rightButtonsPanel.add(rightPlayerModul1);
+        rightButtonsPanel.add(rightButtons[0]);
-        rightButtonsPanel.add(rightPlayerModul2);
+        rightButtonsPanel.add(rightButtons[1]);
-        rightButtonsPanel.add(rightPlayerModul3);
+        rightButtonsPanel.add(rightButtons[2]);
-        rightButtonsPanel.add(rightPlayerModul4);
+        rightButtonsPanel.add(rightButtons[3]);
-        rightButtonsPanel.add(rightPlayerModul5);
+        rightButtonsPanel.add(rightButtons[4]);
-        rightButtonsPanel.add(rightPlayerModul6);
+        rightButtonsPanel.add(rightButtons[5]);
-        rightButtonsPanel.add(rightPlayerModul7);
+        rightButtonsPanel.add(rightButtons[6]);
 
         // Spielfelder erstellen (eigenes und gegnerisches)
         int gridSize = GameController.semesterToBoardSize(semesterCounter); // Größe des Spielfelds
         // Spielfelder werden in BoardDisplay erstellt
         //JPanel ownBoardPanel = new JPanel(new GridLayout(gridSize, gridSize));
         //JPanel opponentBoardPanel = new JPanel(new GridLayout(gridSize, gridSize));
-        JPanel ownBoardPanel = new BoardDisplay(gridSize, gameBoardEmtpy);
+        JPanel ownBoardPanel = new BoardDisplay(gridSize,p1);
-        JPanel opponentBoardPanel = new BoardDisplay(gridSize, gameBoardEmtpy);
+        JPanel opponentBoardPanel = new BoardDisplay(gridSize, p2);
 
         //Buttons in eine Gruppe packen damit diese beim drücken eines anderen Buttons wieder entwählt werden
         ButtonGroup leftButtonGroup= new ButtonGroup();
-        leftButtonGroup.add(rightPlayerModul1);
+        leftButtonGroup.add(leftButtons[0]);
-        leftButtonGroup.add(rightPlayerModul2);
+        leftButtonGroup.add(leftButtons[1]);
-        leftButtonGroup.add(rightPlayerModul3);
+        leftButtonGroup.add(leftButtons[2]);
-        leftButtonGroup.add(rightPlayerModul4);
+        leftButtonGroup.add(leftButtons[3]);
-        leftButtonGroup.add(rightPlayerModul5);
+        leftButtonGroup.add(leftButtons[4]);
-        leftButtonGroup.add(rightPlayerModul6);
+        leftButtonGroup.add(leftButtons[5]);
-        leftButtonGroup.add(rightPlayerModul7);
+        leftButtonGroup.add(leftButtons[6]);
 
         ButtonGroup rightButtonGroup= new ButtonGroup();
-        rightButtonGroup.add(leftPlayerModul1);
+        rightButtonGroup.add(rightButtons[0]);
-        rightButtonGroup.add(leftPlayerModul2);
+        rightButtonGroup.add(rightButtons[1]);
-        rightButtonGroup.add(leftPlayerModul3);
+        rightButtonGroup.add(rightButtons[2]);
-        rightButtonGroup.add(leftPlayerModul4);
+        rightButtonGroup.add(rightButtons[3]);
-        rightButtonGroup.add(leftPlayerModul5);
+        rightButtonGroup.add(rightButtons[4]);
-        rightButtonGroup.add(leftPlayerModul6);
+        rightButtonGroup.add(rightButtons[5]);
-        rightButtonGroup.add(leftPlayerModul7);
+        rightButtonGroup.add(rightButtons[6]);
 
         // Panel für beide Spielfelder (nebeneinander in der Mitte)
         JPanel centerPanel = new JPanel();
@@ -108,18 +161,6 @@ public class GameBoard extends JPanel {
         add(rightButtonsPanel, BorderLayout.EAST);
         add(headerPanel, BorderLayout.NORTH);
         add(centerPanel, BorderLayout.CENTER);
-    }
 
-    GameBoard(MainFrame frame, int semesterCounter,Player p1, Player p2) {
-        buildPanel(frame, semesterCounter);
-        /*
-        rightPlayerRightButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                toggleRightPlayerIcon();
-                updateTextFields();
-            }
-        }); */
-        backButton.addActionListener(e -> frame.showPanel("MainMenu"));
     }
 }

src/JoinGame.java

@@ -5,34 +5,50 @@ import java.awt.event.ActionListener;
 import java.io.IOException;
 import java.net.InetSocketAddress;
 
-/*
+/**
-TODO: evtl an Lucas: die "JoinGame" muss noch informationen erhalten, welche Spieler erstellt wurden und welches Semester
+ * Das JoinGame Panel dient zum setzten des Ports/IP-Adresse.
-Also die startMultiplayerGame muss JoinGame mit parametern für (HumanPlayer/AiEasy/AiNormal/AiHard, Semesteranzahl, Spielername) (3 Parameter) erhalten
+ * Anschließend kann das Verbinden Panel gezeigt werden.
-
  */
-
-
 public class JoinGame extends JPanel {
+    // Grafiken
     ImageIcon backButtonIcon = new ImageIcon("graphics/backButton.png");
 
+    // Labels
     JLabel spielBeitretenLabel;
     JLabel ipLabel = new JLabel("IP-Adresse");
     JLabel portLabel = new JLabel("Port");
 
+    // Textfelder
     JTextField ipTextField = new JTextField(20);
     JTextField portTextField = new JTextField(20);
 
+    // Buttons
     JButton losButton = new JButton("Los!");
     JButton backButton = new JButton(backButtonIcon);
 
+    // Font
     Font robotoFont = new Font("Roboto", Font.BOLD, 45);
 
-    public JoinGame(MainFrame frame,int g) {
+    /**
+     * Erstellt mittels Funktionsaufrufen das Panel.
+     * @param frame Der Mainframe der Anwendung über den alle Panels angezeigt werden.
+     * @param g int-Anzeige, ob es sich um "spiel erstellen" oder "spiel beitreten" handelt.
+     * @param playerType int-Anzeige, ob es sich um einen HumanPlayer,AIEasy... handelt.
+     * @param playerName Name des Spielers
+     */
+    public JoinGame(MainFrame frame,int g,int playerType,String playerName) {
         setLayout(null);
-        buildPanel(frame,g);
+        buildPanel(frame,g,playerType,playerName);
     }
 
-    private void buildPanel(MainFrame frame,int g) {
+    /**
+     * Erstellt das Panel.
+     * @param frame Der Mainframe der Anwendung über den alle Panels angezeigt werden.
+     * @param g int-Anzeige, ob es sich um "spiel erstellen" oder "spiel beitreten" handelt.
+     * @param playerType int-Anzeige, ob es sich um einen HumanPlayer,AIEasy... handelt.
+     * @param playerName Name des Spielers
+     */
+    private void buildPanel(MainFrame frame,int g,int playerType,String playerName) {
         if(g==1){
             spielBeitretenLabel= new JLabel("Spiel beitreten");
         }else{
@@ -43,12 +59,14 @@ public class JoinGame extends JPanel {
         losButton.setBounds(320, 225, 100, 50);
         backButton.setBounds(1380, 20, 80, 80);
 
-        ipLabel.setBounds(50, 125, 200, 30);
         portLabel.setBounds(50, 200, 200, 30);
 
+        if(g==1) { //Wenn man Spiel erstellen will werden IP-Felder nicht angezeigt.
+            ipLabel.setBounds(50, 125, 200, 30);
             ipTextField.setBounds(50, 150, 250, 50);
-        portTextField.setBounds(50, 225, 250, 50);
+        }
 
+        portTextField.setBounds(50, 225, 250, 50);
 
         spielBeitretenLabel.setFont(robotoFont.deriveFont(50f));
 
@@ -59,38 +77,45 @@ public class JoinGame extends JPanel {
         add(ipTextField);
         add(portTextField);
         add(backButton);
+        // ActionListener für Buttons
+        // Um in das MultiplayerGame zurückzuwechseln.
+        backButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                frame.showPanel("MultiplayerGame");
+            }
+        });
 
-        backButton.addActionListener(e -> frame.showPanel("MultiplayerGame"));
+        // Um das Verbinden Panel anzuzeigen und Daten an Backend weiterzureichen.
-        // losButton.addActionListener(e -> frame.showPanel("Verbinden"));
-
-
         losButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
 
                 String ipAddress = ipTextField.getText();
-                if (ipAddress.equals("")) {
+                if (ipAddress.isEmpty()) {
                     ipAddress = "0.0.0.0";
                 }
-
                 String portText = portTextField.getText();
 
                 int port = Integer.parseInt(portText);
                 InetSocketAddress address = new InetSocketAddress(ipAddress, port);
 
                 frame.showPanel("Verbinden");
-                //public static void startOnlineGame(Class<? extends LocalPlayer> localPlayerClass, String localPlayerName, InetSocketAddress
+
-                //        address, int size) throws IOException {
-                if(true) { //Beispiel (für playertape wäre z.B. 1 humanPlayer etc.)
                 try {
-                        GameController.startOnlineGame(HumanPlayer.class, "TollerTest", address,GameController.semesterToBoardSize(2)); //
+                    if(playerType == 0) {
+                        GameController.startOnlineGame(HumanPlayer.class, playerName, address,GameController.semesterToBoardSize(2));
+                    } else if(playerType == 1) {
+                        GameController.startOnlineGame(SpecificAiPlayerEasy.class, playerName, address,GameController.semesterToBoardSize(2));
+                    } else if (playerType == 2) {
+                        GameController.startOnlineGame(SpecificAiPlayerMedium.class, playerName, address,GameController.semesterToBoardSize(2));
+                    } else if (playerType == 3) {
+                        GameController.startOnlineGame(SpecificAiPlayerHard.class, playerName, address,GameController.semesterToBoardSize(2));
+                    }
                 } catch (IOException ex) {
                     throw new RuntimeException(ex);
                 }
             }
-
-            }
         });
-
     }
 }

src/MainFrame.java

@@ -1,6 +1,10 @@
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * Der MainFrame dient als Hub und Übergreifendes Fenster auf dem alle weiteren Panel angezeigt werden.
+ * Dadurch werden keine weiteren Fenster geöffnet.
+ */
 public class MainFrame extends JFrame {
 
     private CardLayout cardLayout;
@@ -16,7 +20,10 @@ public class MainFrame extends JFrame {
     int semesterCounter;
     // ---------- //
 
-
+    /**
+     * Konstruktor von MainFrame.
+     * Ermöglicht es Panel anzuzeigen.
+     */
     public MainFrame() {
 
         GameController.setMainFrame(this);
@@ -26,33 +33,23 @@ public class MainFrame extends JFrame {
         setSize(1500, 1000);
         setLocationRelativeTo(null);
 
-        //JLabel backgroundLabel = new JLabel(new ImageIcon("graphics/mainmenubackground.png"));
-       // backgroundLabel.setBounds(0, 0, 1500, 1000);
-      //  getContentPane().add(backgroundLabel);
-
-       // backgroundLabel.setOpaque(true);
-
         // CardLayout und Hauptpanel erstellen
         cardLayout = new CardLayout();
         mainPanel = new JPanel(cardLayout);
 
-        // Verschiedene Panels erstellen und hinzufügen
+        // Panels erstellen
         MainMenuView mainMenuView = new MainMenuView(this);
         startLocalGame localGame = new startLocalGame(this);
-        //startLocalGameLoadingScreen LocalGameLoadingScreen = new startLocalGameLoadingScreen(this);
         startMultiplayerGame multiplayerGame = new startMultiplayerGame(this);
         coinToss coinToss = new coinToss(this);
         Verbinden verbinden = new Verbinden(this);
-        //JoinGame joinGame = new JoinGame(this,localMult);
-        //GameBoard gameBoard = new GameBoard(this, localMult);
 
+        // Panels hinzufügen
         mainPanel.add(mainMenuView, "MainMenu");
         mainPanel.add(localGame, "LocalGame");
         mainPanel.add(multiplayerGame, "MultiplayerGame");
         mainPanel.add(coinToss, "coinToss");
         mainPanel.add(verbinden, "Verbinden");
-        //mainPanel.add(joinGame, "JoinGame");
-        //mainPanel.add(gameBoard, "GameBoard");
 
         // Hauptpanel in JFrame hinzufügen
         add(mainPanel);
@@ -61,81 +58,60 @@ public class MainFrame extends JFrame {
         cardLayout.show(mainPanel, "MainMenu");
     }
 
-    // Methode, um die Ansicht zu wechseln
+    /**
+     * Methode, um die Ansicht zu wechseln
+     * @param panelName Name des anzuzeigenden Panels
+     */
     public void showPanel(String panelName) {
         cardLayout.show(mainPanel, panelName);
     }
 
-    // --- ShowPanel der startMultiplayerGame Klasse
+    /**
-    public void showPanelSMG(String panelName, int num) {
+     * Spezifische ShowPanel-Funktion der startMultiplayerGame Klasse
+     * @param panelName Name des anzuzeigenden Panels
+     * @param num Hilfsvariable um abzugleichen, ob "Spiel erstellen" oder "Spiel beitreten" ausgewählt wurde
+     * @param playerType Spielertyp(HumanPlayer, AIEasy etc.)
+     * @param playerName Name des Spielers
+     */
+    public void showPanelSMG(String panelName, int num, int playerType,String playerName) {
         this.localMult = num;
 
-        //if (!isPanelPresent(panelName)) { //TODO potentiell raus
+        JoinGame joinGame = new JoinGame(this, localMult, playerType, playerName);
-            JoinGame joinGame = new JoinGame(this, localMult);
         mainPanel.add(joinGame, panelName);
         mainPanel.revalidate(); // Refresh
         mainPanel.repaint();
-        //}
-
         cardLayout.show(mainPanel, panelName); // Show the panel
     }
-    // --- ShowPanel der startLocalGameLoadingScreen Klasse (DURCH BACKEND AUFGERUFEN)
+
+    /**
+     * Spezifische ShowPanel der startLocalGameLoadingScreen Klasse (DURCH BACKEND AUFGERUFEN)
+     * @param panelName Name des anzuzeigenden Panels
+     * @param semesterCounter Ausgewähltes Semester
+     * @param p1 Erstes Spielerobjekt
+     * @param p2 Zweites Spielerobjekt
+     */
     public void showPanelSLG(String panelName,int semesterCounter, Player p1, Player p2) {
         this.semesterCounter = semesterCounter;
 
-            //if (!isPanelPresent(panelName)) { //TODO potentiell raus
-            // gameBoard muss player übergeben bekommen
         GameBoard gameBoard = new GameBoard(this, semesterCounter, p1, p2);
-            //mainPanel.add(mainMenuView, "MainMenu");
         mainPanel.add(gameBoard, panelName);
-            mainPanel.revalidate(); // Refresh
+        mainPanel.revalidate();
         mainPanel.repaint();
-        //}
-
         cardLayout.show(mainPanel, panelName); // Show the panel
     }
 
-    // --- ShowPanel der startLocalGame Klasse
+    /**
+     * Spezifische ShowPanel der startLocalGame Klasse
+     * @param panelName Name des anzuzeigenden Panels
+     * @param semesterCounter Ausgewähltes Semester
+     */
     public void showPanelSLGLS(String panelName,int semesterCounter) {
         this.semesterCounter = semesterCounter;
-        // gameBoard muss player übergeben bekommen
+
         startLocalGameLoadingScreen LocalGameLoadingScreen = new startLocalGameLoadingScreen(this, semesterCounter);
         mainPanel.add(LocalGameLoadingScreen, panelName);
         mainPanel.revalidate(); // Refresh
         mainPanel.repaint();
-        //}
-
         cardLayout.show(mainPanel, panelName); // Show the panel
     }
-
-    /* TODO ist dies unnötig?
-    private boolean isPanelPresent(String panelName) {
-        for (Component component : mainPanel.getComponents()) {
-            if (panelName.equals(mainPanel.getClientProperty("name"))) {
-                return true;
-            }
-        }
-        return false;
-    } */
-
-    // Methoden für übergabe von playern an GameBoard
-    /*
-    public void setPlayerData() {
-        this.semesterCounter = semesterCounter;
-
-        //if (!isPanelPresent(panelName)) { //TODO potentiell raus
-        // gameBoard muss player übergeben bekommen
-        GameBoard gameBoard = new GameBoard(this, semesterCounter);
-        mainPanel.add(gameBoard, panelName);
-        mainPanel.revalidate(); // Refresh
-        mainPanel.repaint();
-    }*/
-
-
-    public static void main(String[] args) {
-        SwingUtilities.invokeLater(() -> {
-            MainFrame frame = new MainFrame();
-            frame.setVisible(true);
-        });
-    }
 }

src/Player.java

@@ -43,6 +43,9 @@ public abstract class Player {
         return this.name;
     }
 
+    public Board getBoard() {
+        return this.board;
+    }
 
     public abstract void receiveCoin(boolean coin);
 }

src/Ship.java

@@ -159,4 +159,15 @@ public class Ship {
 	public boolean isSunk() {
 		return sunk;
 	}
+
+	public void setHorizontal(boolean horizontal) {
+		this.horizontal = horizontal;
+	}
+
+	public int getSize() {
+		return size;
+	}
+	public String getName() {
+		return name;
+	}
 }

src/Verbinden.java

@@ -1,6 +1,9 @@
 import javax.swing.*;
 import java.awt.*;
 
+/**
+ * Das Verbinden Panel dient als "Überblende", während im Backend das Spiel erstellt/ eine Verbindung hergestellt wird.
+ */
 public class Verbinden extends JPanel{
 
         ImageIcon backButtonIcon = new ImageIcon("graphics/backButton.png");
@@ -9,11 +12,19 @@ public class Verbinden extends JPanel{
 
         Font robotoFont = new Font("Roboto", Font.BOLD, 45);
 
+    /**
+     * Konstruktor der startLocalGame.
+     * @param frame Der Mainframe der Anwendung über den alle Panels angezeigt werden.
+     */
     public Verbinden(MainFrame frame) {
             setLayout(null);
             buildPanel(frame);
         }
 
+    /**
+     * Baut Panel auf.
+     * @param frame Der Mainframe der Anwendung über den alle Panels angezeigt werden.
+     */
     private void buildPanel(MainFrame frame) {
             setLayout(new BorderLayout());
             verbindenLabel.setFont(robotoFont.deriveFont(50f));

src/startLocalGame.java

@@ -2,12 +2,13 @@ import javax.swing.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
-// TODO
+/**
-// Evtl. ist Namen selber setzten noch unmöglich
+ * Das startLocalGame Panel dient dem Erstellen eines lokalen Spiels.
-//
+ * Hier kann der Benutzer Spieler inklusive Namen und das Semester, in dem sich der Benutzer befindet, einstellen.
-
+ */
 public class startLocalGame extends JPanel {
     // Player
+    // TODO: entfernen
     Player p1;
     Player p2;
 
@@ -23,7 +24,7 @@ public class startLocalGame extends JPanel {
     ImageIcon aiPlayerNormalIcon = new ImageIcon("graphics/botPlayerNormal.png");
     ImageIcon aiPlayerHardIcon = new ImageIcon("graphics/botPlayerHard.png");
 
-    // Labels und Buttons
+    // Labels
     JLabel frameTitle = new JLabel("Lokales Spiel");
     JLabel semesterLabel = new JLabel("Semester");
     JLabel leftPlayerName = new JLabel("Name");
@@ -32,6 +33,7 @@ public class startLocalGame extends JPanel {
     JLabel rightPlayerIcon = new JLabel(aiPlayerEasyIcon);
     JLabel semesterCounterLabel = new JLabel(String.valueOf(semesterCounter));
 
+    // Buttons
     JButton backButton = new JButton(backButtonIcon);
     JButton leftPlayerLeftButton = new JButton("<-");
     JButton leftPlayerRightButton = new JButton("->");
@@ -42,12 +44,20 @@ public class startLocalGame extends JPanel {
     JButton startButton = new JButton("Start!");
     JButton testButton = new JButton("Test");
 
+    // Textfelder
     JTextField leftPlayerTextField = new JTextField(20);
     JTextField rightPlayerTextField = new JTextField(20);
 
-    // Methode zur Erstellung des Panels
+    /**
+     * Konstruktor der startLocalGame.
+     * Fügt Buttons, Textfelder und Label hinzu.
+     * Fügt ebenfalls ActionListeners hinzu, damit Buttons etc. ihre gewünschte Funktion haben
+     *
+     * @param frame Der Mainframe der Anwendung über den alle Panels angezeigt werden.
+     */
     startLocalGame(MainFrame frame) {
-        setLayout(null);  // Stelle das Layout des Panels ein
+        // Layout des Panels
+        setLayout(null);
 
         // Setze Komponentenpositionen
         frameTitle.setBounds(20, 20, 200, 30);
@@ -107,8 +117,8 @@ public class startLocalGame extends JPanel {
         rightPlayerTextField.setText(rightPlayerNickname);
         add(rightPlayerTextField);
 
-
         // ActionListener für Buttons
+        // Um das Semester zu erhöhen.
         semesterUpButton.addActionListener(e -> {
             if (semesterCounter < 6) {
                 semesterCounter++;
@@ -116,6 +126,7 @@ public class startLocalGame extends JPanel {
             }
         });
 
+        // Um das Semester zu senken.
         semesterDownButton.addActionListener(e -> {
             if (semesterCounter > 1) {
                 semesterCounter--;
@@ -123,6 +134,7 @@ public class startLocalGame extends JPanel {
             }
         });
 
+        // Um linken Player nach links zu "rotieren".
         leftPlayerLeftButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
@@ -131,6 +143,7 @@ public class startLocalGame extends JPanel {
             }
         });
 
+        // Um linken Player nach rechts zu "rotieren".
         leftPlayerRightButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
@@ -139,6 +152,7 @@ public class startLocalGame extends JPanel {
             }
         });
 
+        // Um rechten Player nach links zu "rotieren".
         rightPlayerLeftButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
@@ -147,6 +161,7 @@ public class startLocalGame extends JPanel {
             }
         });
 
+        // Um den rechten Player nach rechts zu "rotieren".
         rightPlayerRightButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
@@ -155,9 +170,38 @@ public class startLocalGame extends JPanel {
             }
         });
 
-        backButton.addActionListener(e -> frame.showPanel("MainMenu"));
+        // Um Namen des linken Spielers zu speichern.
-        testButton.addActionListener(e -> frame.showPanelSLG("GameBoard",1,p1,p2));
+        leftPlayerTextField.addActionListener(e -> {
-        //startButton.addActionListener(e -> frame.showPanelSLG("GameBoard", semesterCounter,p1, p2)); // TODO ECHTE FUNKTION EINFÜGEN
+            leftPlayerNickname = leftPlayerTextField.getText();
+            System.out.println("Linker Spielername geändert zu: " + leftPlayerNickname); // Debugging-Ausgabe
+        });
+
+        // Um Namen des linken Spielers zu speichern, auch wenn nicht Enter gedrückt wird.
+        leftPlayerTextField.addFocusListener(new java.awt.event.FocusAdapter() {
+            @Override
+            public void focusLost(java.awt.event.FocusEvent evt) {
+                leftPlayerNickname = leftPlayerTextField.getText();
+                System.out.println("Linker Spielername geändert zu: " + leftPlayerNickname); // Debugging-Ausgabe
+            }
+        });
+
+        // Um zum MainMenu zu wechseln.
+        backButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                frame.showPanel("MainMenu");
+            }
+        });
+
+        // Um zum Gameboard zu wechseln.
+        testButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                frame.showPanelSLG("GameBoard",1,p1,p2);
+            }
+        });
+
+        // Um zum startLocalGameLoadingScreen zu wechseln und Daten an Backend weiterzureichen.
         startButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
@@ -200,7 +244,11 @@ public class startLocalGame extends JPanel {
         });
 
     }
+    // Hilfsfunktionen
 
+    /**
+     * Setzt das jeweils "nächste" Icon, wenn der leftPlayerLeftButton gedrückt wird.
+     */
     private void toggleLeftPlayerIconLeft() {
         if (leftPlayerIcon.getIcon() == humanPlayerIcon) {
             leftPlayerIcon.setIcon(aiPlayerHardIcon);
@@ -213,6 +261,9 @@ public class startLocalGame extends JPanel {
         }
     }
 
+    /**
+     * Setzt das jeweils "nächste" Icon, wenn der leftPlayerRightButton gedrückt wird.
+     */
     private void toggleLeftPlayerIconRight() {
         if (leftPlayerIcon.getIcon() == humanPlayerIcon) {
             leftPlayerIcon.setIcon(aiPlayerEasyIcon);
@@ -225,6 +276,9 @@ public class startLocalGame extends JPanel {
         }
     }
 
+    /**
+     * Setzt das jeweils "nächste" Icon, wenn der RightPlayerLeftButton gedrückt wird.
+     */
     private void toggleRightPlayerIconLeft() {
         if (rightPlayerIcon.getIcon() == aiPlayerEasyIcon) {
             rightPlayerIcon.setIcon(aiPlayerHardIcon);
@@ -235,6 +289,9 @@ public class startLocalGame extends JPanel {
         }
     }
 
+    /**
+     * Setzt das jeweils "nächste" Icon, wenn der RightPlayerRightButton gedrückt wird.
+     */
     private void toggleRightPlayerIconRight() {
         if (rightPlayerIcon.getIcon() == aiPlayerEasyIcon) {
             rightPlayerIcon.setIcon(aiPlayerNormalIcon);
@@ -245,11 +302,13 @@ public class startLocalGame extends JPanel {
         }
     }
 
-    // Methode zum Aktualisieren der Textfelder basierend auf den ausgewählten Icons
+    /**
+     * Aktualisiert die Textfelder basierend auf den Icons
+     */
     private void updateTextFields() {
-        // Linker Spieler
+        // Für Linken Spieler
         if (leftPlayerIcon.getIcon() == humanPlayerIcon) {
-            leftPlayerTextField.setText("Spieler 1");
+            leftPlayerTextField.setText(leftPlayerNickname);
         } else if (leftPlayerIcon.getIcon() == aiPlayerEasyIcon){
             leftPlayerTextField.setText("Einfach");
         } else if (leftPlayerIcon.getIcon() == aiPlayerNormalIcon) {
@@ -258,7 +317,7 @@ public class startLocalGame extends JPanel {
             leftPlayerTextField.setText("Schwer");
         }
 
-        // Rechter Spieler
+        // Für Rechten Spieler
         if (rightPlayerIcon.getIcon() == aiPlayerEasyIcon){
             rightPlayerTextField.setText("Einfach");
         } else if (rightPlayerIcon.getIcon() == aiPlayerNormalIcon) {

src/startLocalGameLoadingScreen.java

@@ -1,9 +1,19 @@
 import javax.swing.*;
 import java.awt.*;
-//Kann evtl. als genereller LoadingScreen verwendet werden und nicht "nur" für localGame
+
+/**
+ * Das startLocalGameLoadingScreen Panel dient als "Überblende", während im Backend das Spiel erstellt wird.
+ * Hier wird lediglich Text angezeigt
+ */
 public class startLocalGameLoadingScreen extends JPanel{
+    /**
+     * Konstruktor der startLocalGameLoadingScreen.
+     * @param frame Der Mainframe der Anwendung über den alle Panels angezeigt werden.
+     * @param semesterCounter Ein Zähler, der das gewählte Semester speichert (hier unbenutzt)
+     */
     startLocalGameLoadingScreen(MainFrame frame, int semesterCounter) {
-        // Layout setzen
+
+        // Layout des Panels
         setLayout(new BorderLayout());
 
         // Label mit dem Text erstellen
@@ -11,8 +21,8 @@ public class startLocalGameLoadingScreen extends JPanel{
         loadingLabel.setHorizontalAlignment(SwingConstants.CENTER); // Horizontal zentrieren
         loadingLabel.setVerticalAlignment(SwingConstants.CENTER); // Vertikal zentrieren
 
-        // Schriftgröße anpassen (optional)
+        // Schriftgröße anpassen
-        loadingLabel.setFont(new Font("Arial", Font.PLAIN, 18));
+        loadingLabel.setFont(new Font("Roboto", Font.BOLD, 45));
 
         // Label zum Panel hinzufügen
         add(loadingLabel, BorderLayout.CENTER);

src/startMultiplayerGame.java

@@ -1,13 +1,17 @@
 import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 
-// TODO
+/**
-// Evtl. ist Namen selber setzten noch unmöglich
+ * Das startMultiplayerGame Panel dient dem Erstellen eines Online Spiels.
-//
+ * Hier kann der Benutzer Spieler inklusive Namen und das Semester, in dem sich der Benutzer befindet, einstellen.
-
+ */
 public class startMultiplayerGame extends JPanel {
+
     // Funktionshilfen
-    int semesterCounter = 1; // Semester Counter Label
+    int semesterCounter = 1;
     String PlayerNickname = "Spieler 1";
+
     // Grafiken
     ImageIcon backButtonIcon = new ImageIcon("graphics/backButton.png");
     ImageIcon humanPlayerIcon = new ImageIcon("graphics/humanPlayer.png");
@@ -34,11 +38,18 @@ public class startMultiplayerGame extends JPanel {
     // Textfelder
     JTextField PlayerTextField = new JTextField(20);
 
-    // Konstruktor
+    /**
+     * Konstruktor der startLocalGame.
+     * Fügt Buttons, Textfelder und Label hinzu.
+     * Fügt ebenfalls ActionListeners hinzu, damit Buttons etc. ihre gewünschte Funktion haben
+     * @param frame Der Mainframe der Anwendung über den alle Panels angezeigt werden.
+     */
     startMultiplayerGame(MainFrame frame) {
-        setLayout(null);  // Setze das Layout für das Panel auf null
 
-        // Setze Komponentenpositionen und füge sie dem Panel hinzu
+        // Layout des Panels
+        setLayout(null);
+
+        // Setze Komponentenpositionen
         frameTitle.setBounds(20, 20, 200, 30);
         add(frameTitle);
 
@@ -55,7 +66,6 @@ public class startMultiplayerGame extends JPanel {
         semesterCounterLabel.setHorizontalAlignment(SwingConstants.CENTER);
         add(semesterCounterLabel);
 
-        // Füge Buttons hinzu und setze ihre Positionen
         backButton.setBounds(1380, 20, 80, 80);
         add(backButton);
 
@@ -77,22 +87,12 @@ public class startMultiplayerGame extends JPanel {
         createGameButton.setBounds(1100, 550, 200, 50);
         add(createGameButton);
 
-        // Füge das Textfeld hinzu
         PlayerTextField.setBounds(50, 650, 250, 50);
         PlayerTextField.setText(PlayerNickname);
         add(PlayerTextField);
 
-        /* TODO: Muss in Lucas klasse rein.
-        public static void startOnlineGame(Class<? extends LocalPlayer> localPlayerClass, String localPlayerName, InetSocketAddress
-        address, int size) throws IOException {
-        */
-
-        //GameController.startOnlineGame(...);
-
-
-
         // ActionListener für Buttons
-        // SEMESTERBUTTONS
+        // Um das Semester zu erhöhen.
         semesterUpButton.addActionListener(e -> {
             if (semesterCounter < 6) {
                 semesterCounter++;
@@ -100,6 +100,7 @@ public class startMultiplayerGame extends JPanel {
             }
         });
 
+        // Um das Semester zu senken.
         semesterDownButton.addActionListener(e -> {
             if (semesterCounter > 1) {
                 semesterCounter--;
@@ -107,25 +108,80 @@ public class startMultiplayerGame extends JPanel {
             }
         });
 
-        // PLAYERTOGGLEBUTTONS
+        // Um Player nach links zu "rotieren".
         PlayerLeftButton.addActionListener(e -> {
             togglePlayerIconLeft();
             updateTextFields();
         });
 
+        // Um Player nach rechts zu "rotieren".
         PlayerRightButton.addActionListener(e -> {
             togglePlayerIconRight();
             updateTextFields();
         });
 
-        // ActionListener für den "Back" Button, um zum vorherigen Panel zurückzukehren
+        // Um Namen des linken Spielers zu speichern.
+        PlayerTextField.addActionListener(e -> {
+            PlayerNickname = PlayerTextField.getText();
+            System.out.println("Linker Spielername geändert zu: " + PlayerNickname); // Debugging-Ausgabe
+        });
 
-        backButton.addActionListener(e -> frame.showPanel("MainMenu"));
+        // Um Namen des linken Spielers zu speichern, auch wenn nicht Enter gedrückt wird.
-        joinGameButton.addActionListener(e -> frame.showPanelSMG("JoinGame",1));
+        PlayerTextField.addFocusListener(new java.awt.event.FocusAdapter() {
-        createGameButton.addActionListener(e -> frame.showPanelSMG("JoinGame",0));
+            @Override
+            public void focusLost(java.awt.event.FocusEvent evt) {
+                PlayerNickname = PlayerTextField.getText();
+                System.out.println("Linker Spielername geändert zu: " + PlayerNickname); // Debugging-Ausgabe
+            }
+        });
+
+        // Um zum MainMenu zu wechseln.
+        backButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                frame.showPanel("MainMenu");
+            }
+        });
+
+        // Um zu JoinGame mit richtigen Parametern zu wechseln.
+        joinGameButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if (PlayerIcon.getIcon() == humanPlayerIcon) {
+                    frame.showPanelSMG("JoinGame",1,0, PlayerNickname);
+                } else if ( PlayerIcon.getIcon() == aiPlayerEasyIcon) {
+                    frame.showPanelSMG("JoinGame",1,1, PlayerNickname);
+                } else if ( PlayerIcon.getIcon() == aiPlayerNormalIcon) {
+                    frame.showPanelSMG("JoinGame",1,2, PlayerNickname);
+                } else if ( PlayerIcon.getIcon() == aiPlayerHardIcon) {
+                    frame.showPanelSMG("JoinGame",1,3, PlayerNickname);
+                }
+            }
+        });
+
+        // Um zu JoinGame mit richtigen Parametern zu wechseln.
+        createGameButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                //Parameter -> panelName, Spiel erstellen oder beitreten (int), Spielertyp(int 0-3), Spielername
+                if (PlayerIcon.getIcon() == humanPlayerIcon) { // TODO Wird name wirklich weitergegeben?
+                    frame.showPanelSMG("JoinGame",0,0, PlayerNickname);
+                } else if ( PlayerIcon.getIcon() == aiPlayerEasyIcon) {
+                    frame.showPanelSMG("JoinGame",0,1, PlayerNickname);
+                } else if ( PlayerIcon.getIcon() == aiPlayerNormalIcon) {
+                    frame.showPanelSMG("JoinGame",0,2, PlayerNickname);
+                } else if ( PlayerIcon.getIcon() == aiPlayerHardIcon) {
+                    frame.showPanelSMG("JoinGame",0,3, PlayerNickname);
+                }
+            }
+        });
     }
 
-    // TOGGLE METHODEN
+    // Hilfsfunktionen
+
+    /**
+     * Setzt das jeweils "nächste" Icon, wenn der PlayerLeftButton gedrückt wird.
+     */
     private void togglePlayerIconLeft() {
         if (PlayerIcon.getIcon() == humanPlayerIcon) {
             PlayerIcon.setIcon(aiPlayerHardIcon);
@@ -138,6 +194,9 @@ public class startMultiplayerGame extends JPanel {
         }
     }
 
+    /**
+     * Setzt das jeweils "nächste" Icon, wenn der PlayerRightButton gedrückt wird.
+     */
     private void togglePlayerIconRight() {
         if (PlayerIcon.getIcon() == humanPlayerIcon) {
             PlayerIcon.setIcon(aiPlayerEasyIcon);
@@ -150,9 +209,12 @@ public class startMultiplayerGame extends JPanel {
         }
     }
 
+    /**
+     * Aktualisiert die Textfelder basierend auf den Icons
+     */
     private void updateTextFields() {
         if (PlayerIcon.getIcon() == humanPlayerIcon) {
-            PlayerTextField.setText("Spieler 1");
+            PlayerTextField.setText(PlayerNickname);
         } else if (PlayerIcon.getIcon() == aiPlayerEasyIcon){
             PlayerTextField.setText("Einfach");
         } else if (PlayerIcon.getIcon() == aiPlayerNormalIcon) {