HSH/programmieren-projekt
HSH
/
programmieren-projekt
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Network and Frontend #10

Merged
lgc merged 29 commits from ole into main 2024-12-03 12:13:28 +00:00
Conversation 0 Commits 29 Files Changed 28 +812 -97
28 changed files with 812 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.idea/libraries/jlayer_1_0_3.xml
View File

@ -1,8 +1,7 @@
<component name="libraryTable">
<library name="jlayer-1.0.3">
<CLASSES>
<root url="jar://$USER_HOME$/Downloads/jlayer-master/jlayer-master/target/jlayer-1.0.3.jar!/" />
<root url="jar://$USER_HOME$/Downloads/jlayer-1.0.3.jar!/" />
<root url="jar://$PROJECT_DIR$/libs/jlayer-1.0.3.jar!/" />
</CLASSES>
<JAVADOC />
<SOURCES />

BIN
graphics/gameboardempty.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 84 B

BIN
graphics/gameboardx.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 171 B

7
src/AiPlayer.java
View File

@ -1,11 +1,8 @@
import java.util.Random;
import java.awt.Point;
public abstract class AiPlayer extends Player {
public abstract class AiPlayer extends LocalPlayer {
public AiPlayer(int size) {
super(size);
}
public AiPlayer() {}
public Point RandomPoint() {
Random random = new Random(); // Pseudo Random für zufallszahlen
int posx = random.nextInt(super.board.getSize()); // Generiert 0 - 13

80
src/AsyncSocket.java Normal file
View File

@ -0,0 +1,80 @@
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
public class AsyncSocket {
private Socket socket;
private Thread checkerThread;
private AsyncSocketListener handler;
private boolean shouldStop = false;
private BufferedReader in;
private PrintWriter out;
public AsyncSocket(Socket socket, AsyncSocketListener handler) throws IOException {
this.socket = socket;
this.in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
this.out = new PrintWriter(new OutputStreamWriter(this.socket.getOutputStream()));
this.handler = handler;
this.checkerThread = new Thread(() -> {
while (!this.shouldStop) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
if (!this.in.ready()) continue;
if (this.handler == null) continue;
String message = this.in.readLine();
if (message.length() <= 0) continue;
message = message.strip();
this.handler.receive(message);
} catch (IOException e) {
e.printStackTrace();
}
}
});
this.checkerThread.start();
}
public void setHandler(AsyncSocketListener handler) {
this.handler = handler;
}
public void send(SocketPackage socketPackage) {
this.sendLine(socketPackage.toString());
}
public void send(String packageName) {
this.send(packageName, "");
}
public void send(String packageName, String packageContent) {
if (packageContent.length() > 0) {
packageContent = " " + packageContent;
}
this.sendLine(packageName + packageContent);
}
public void sendLine(String message) {
this.out.print(message + "\r\n");
}
public void close() {
this.shouldStop = true;
try {
this.socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

3
src/AsyncSocketListener.java Normal file
View File

@ -0,0 +1,3 @@
public interface AsyncSocketListener {
public void receive(String message);
}

8
src/Board.java
View File

@ -1,4 +1,4 @@
import java.awt.*;
import java.util.List;
public class Board {
@ -13,7 +13,7 @@ public class Board {
this.createShip(size - 13);
}
public HitResponse hit (Point point){
public synchronized HitResponse hit (Point point){
HitResponse response = new HitResponse(HitResponseType.MISS,point);
for (int i = 0; i < this.ships.size(); i++) {
HitResponseType type = this.ships.get(i).shootOnShip(point);
@ -50,7 +50,7 @@ public class Board {
return ships;
}
public boolean addHits(HitResponse hitResponse) {
public synchronized boolean addHits(HitResponse hitResponse) {
if (this.getHitResponsOnPoint(hitResponse.getPoint()) == null){
this.hits.add(hitResponse);
return true;
@ -58,7 +58,7 @@ public class Board {
return false;
}
public HitResponse getHitResponsOnPoint(Point point) {
public synchronized HitResponse getHitResponsOnPoint(Point point) {
for (int i = 0; i < this.hits.size(); i++){
if (this.hits.get(i).getPoint().equals(point)){
return this.hits.get(i);

113
src/GameBoard.java
View File

@ -1,3 +1,114 @@
public class GameBoard {
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class GameBoard extends JPanel {
// Funktionshilfen
//int semesterCounter = 1; //TODO: ersetzen durch param von vorpanel
// Grafiken
ImageIcon backButtonIcon = new ImageIcon("graphics/backButton.png");
ImageIcon gameBoardEmtpy = new ImageIcon("graphics/gameboardempty.png");
ImageIcon gameBoardX = new ImageIcon("graphics/gameboardx.png");
// Labels
JLabel frameTitle = new JLabel("GameBoard");
JLabel kontextText = new JLabel("Beispielhafter Kontext-Text");
//kontextText.setFont(new Font("Roboto", Font.BOLD, 24)); //TODO setFont fixen
JButton backButton = new JButton(backButtonIcon);
// Eigene ModulButtons
JButton leftPlayerModul1 = new JButton("Modul 1"); //TODO: Dynamische Namen durch abgleich mit Semester
JButton leftPlayerModul2 = new JButton("Modul 2");
JButton leftPlayerModul3 = new JButton("Modul 3");
JButton leftPlayerModul4 = new JButton("Modul 4");
JButton leftPlayerModul5 = new JButton("Modul 5");
JButton leftPlayerModul6 = new JButton("Modul 6");
JButton leftPlayerModul7 = new JButton("Reset");
// Gegnerische ModulButtons
JButton rightPlayerModul1 = new JButton("Modul 1");
JButton rightPlayerModul2 = new JButton("Modul 2");
JButton rightPlayerModul3 = new JButton("Modul 3");
JButton rightPlayerModul4 = new JButton("Modul 4");
JButton rightPlayerModul5 = new JButton("Modul 5");
JButton rightPlayerModul6 = new JButton("Modul 6");
JButton rightPlayerModul7 = new JButton("Bereit");
public void buildPanel(MainFrame frame, int semesterCounter) {
// Hauptlayout - BorderLayout für die Anordnung der Komponenten
setLayout(new BorderLayout());
// Panel für das Kontext-Text-Feld
JPanel headerPanel = new JPanel();
headerPanel.setLayout(new BorderLayout());
headerPanel.add(kontextText, BorderLayout.WEST);
headerPanel.add(backButton, BorderLayout.EAST);
// 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(leftPlayerModul2);
leftButtonsPanel.add(leftPlayerModul3);
leftButtonsPanel.add(leftPlayerModul4);
leftButtonsPanel.add(leftPlayerModul5);
leftButtonsPanel.add(leftPlayerModul6);
leftButtonsPanel.add(leftPlayerModul7);
// 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(rightPlayerModul2);
rightButtonsPanel.add(rightPlayerModul3);
rightButtonsPanel.add(rightPlayerModul4);
rightButtonsPanel.add(rightPlayerModul5);
rightButtonsPanel.add(rightPlayerModul6);
rightButtonsPanel.add(rightPlayerModul7);
// Spielfelder erstellen (eigenes und gegnerisches)
int gridSize = 13 + semesterCounter; // Größe des Spielfelds
JPanel ownBoardPanel = new JPanel(new GridLayout(gridSize, gridSize));
JPanel opponentBoardPanel = new JPanel(new GridLayout(gridSize, gridSize));
// Buttons für das eigene Spielfeld hinzufügen
for (int i = 0; i < gridSize; i++) {
for (int j = 0; j < gridSize; j++) {
ownBoardPanel.add(new JButton(gameBoardEmtpy));
}
}
// Buttons für das gegnerische Spielfeld hinzufügen
for (int i = 0; i < gridSize; i++) {
for (int j = 0; j < gridSize; j++) {
opponentBoardPanel.add(new JButton(gameBoardEmtpy));
}
}
// Panel für beide Spielfelder (nebeneinander in der Mitte)
JPanel centerPanel = new JPanel();
centerPanel.setLayout(new GridLayout(1, 2, 20, 0)); // 2 Spielfelder nebeneinander, mit Abstand von 20 Pixeln
centerPanel.add(ownBoardPanel);
centerPanel.add(opponentBoardPanel);
// Panels dem Hauptlayout hinzufügen
add(leftButtonsPanel, BorderLayout.WEST);
add(rightButtonsPanel, BorderLayout.EAST);
add(headerPanel, BorderLayout.NORTH);
add(centerPanel, BorderLayout.CENTER);
}
GameBoard(MainFrame frame,int semesterCounter) {
buildPanel(frame, semesterCounter);
/*
rightPlayerRightButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
toggleRightPlayerIcon();
updateTextFields();
}
}); */
backButton.addActionListener(e -> frame.showPanel("MainMenu"));
}
}

173
src/GameController.java
View File

@ -1,11 +1,160 @@
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class GameController {
// Connection timeout for client sockets in milliseconds
public static final int CONNECTION_TIMEOUT = 10 * 1000;
public void startOnlineGame() {
// fuck you Luca and Ole von Florian und nicht von Florian
}
public static int semesterToBoardSize(int semester) {
return semester + 13;
}
public void startLocalGame(Class<? extends LocalPlayer> localPlayerClass, Class<? extends AiPlayer> enemyClass, int size) throws InstantiationException, IllegalAccessException {
public HashMap<String, Class<? extends OnlinePlayer>> supportedVersions = new HashMap<>(Map.of(
"1.1.0", OnlinePlayer_1_1_0.class
));
public void startOnlineGame(Class<? extends LocalPlayer> localPlayerClass, InetSocketAddress address, int size) throws IOException {
AsyncSocket clientSocket;
boolean localPlayerIsServer = address.getHostName() == null;
if (localPlayerIsServer) {
// SERVER MODE
ServerSocket serverSocket = new ServerSocket(address.getPort());
System.out.println("Waiting for client connection...");
clientSocket = new AsyncSocket(serverSocket.accept(), null);
serverSocket.close();
} else {
// CLIENT MODE
Socket socket = new Socket();
try {
socket.connect(address, CONNECTION_TIMEOUT);
clientSocket = new AsyncSocket(socket, null);
} catch (SocketTimeoutException e) {
e.printStackTrace();
throw new RuntimeException("Connection timed out");
} finally {
socket.close();
}
}
clientSocket.send("VERSION", "Gruppe03 " + String.join(" ", supportedVersions.keySet()));
clientSocket.setHandler((message) -> {
SocketPackage socketPackage = new SocketPackage(message);
if (socketPackage.getName().equals("VERSION")) {
List<String> opponentSupportedVersions = socketPackage.splitData();
String usedVersion = findMostRecentVersion(new ArrayList<String>(supportedVersions.keySet()), opponentSupportedVersions);
if (usedVersion == null) {
throw new RuntimeException("No common versions found");
}
// instantiate players
Class<? extends OnlinePlayer> onlinePlayerClass = supportedVersions.get(usedVersion);
LocalPlayer localPlayer;
OnlinePlayer onlinePlayer;
try {
localPlayer = localPlayerClass.getDeclaredConstructor().newInstance();
onlinePlayer = onlinePlayerClass.getDeclaredConstructor().newInstance((Integer)size, clientSocket);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("Unable to instantiate players");
}
localPlayer.isServer = localPlayerIsServer;
onlinePlayer.isServer = !localPlayerIsServer;
startGameWithInstancedPlayers(localPlayer, onlinePlayer);
} else {
throw new RuntimeException("Unexpected Package received before game initialisation");
}
});
}
/**
* finds the largest common version in two lists of version strings
* @return null if no common versions are found
*/
public String findMostRecentVersion(List<String> versions1, List<String> versions2) {
if (versions1 == null || versions2 == null) return null;
String largestCommonVersion = null;
for (String v1 : versions1) {
if (!checkVersionString(v1)) continue;
for (String v2 : versions2) {
if (!checkVersionString(v2)) continue;
// strings within the lists must be equal
// if no largest common version has been found or currently checked version is larger than
// previous largest common version, new largest version has been found
if (compareVersions(v1, v2) == 0 && (largestCommonVersion == null || compareVersions(v1, largestCommonVersion) >= 1)) {
largestCommonVersion = v1;
continue;
}
}
}
return largestCommonVersion;
}
/**
* compares two version strings
* @return
* 0 if versions are equal
* 1 if version1 is more recent than version2
* -1 otherwise
*/
public int compareVersions(String version1, String version2) {
if (!checkVersionString(version1) || !checkVersionString(version2)) {
throw new IllegalArgumentException("Version is not valid version string");
}
String[] version1Split = version1.split("\\.");
String[] version2Split = version2.split("\\.");
for (int i = 0; i < version1Split.length; i++) {
int v1 = Integer.parseInt(version1Split[i]);
int v2 = Integer.parseInt(version2Split[i]);
if (v1 == v2) continue;
if (v1 > v2) {
return 1;
} else {
return -1;
}
}
return 0;
}
/**
* checks if a provided string matches the format of a version number
*/
public boolean checkVersionString(String versionString) {
return versionString != null && versionString.matches("\\d+\\.\\d+\\.\\d+");
}
public void startLocalGame(Class<? extends LocalPlayer> localPlayerClass, Class<? extends AiPlayer> enemyClass, int size) {
LocalPlayer localPlayer;
AiPlayer aiPlayer;
@ -14,10 +163,20 @@ public class GameController {
aiPlayer = enemyClass.getDeclaredConstructor().newInstance();
} catch (Exception e) {
e.printStackTrace();
return;
throw new RuntimeException("Unable to instantiate players");
}
localPlayer.setEnemy(aiPlayer);
aiPlayer.setEnemy(localPlayer);
localPlayer.createBoard(size);
aiPlayer.createBoard(size);
startGameWithInstancedPlayers(localPlayer, aiPlayer);
}
private void startGameWithInstancedPlayers(LocalPlayer p1, Player p2) {
p1.setEnemy(p2);
p2.setEnemy(p1);
// TODO: frontend configuration
}
}

20
src/HitResponse.java
View File

@ -1,4 +1,4 @@
import java.awt.*;
public class HitResponse {
private HitResponseType type;
@ -9,6 +9,15 @@ public class HitResponse {
this.point = point;
}
public HitResponse (int typeIndex, Point point) {
if (typeIndex >= 0 && typeIndex < HitResponseType.values().length) {
this.type = HitResponseType.values()[typeIndex];
this.point = point;
} else {
throw new IllegalArgumentException();
}
}
public HitResponseType getHitResponse() {
return this.type;
}
@ -20,4 +29,13 @@ public class HitResponse {
public void setType(HitResponseType type) {
this.type = type;
}
@Override
public String toString() {
return this.getPoint().toString() + " " + this.type.ordinal();
}
public HitResponseType getType() {
return type;
}
}

3
src/HumanPlayer.java
View File

@ -1,7 +1,4 @@
public class HumanPlayer extends LocalPlayer {
public HumanPlayer(int size) {
super(size);
}
}

25
src/JoinGame.java
View File

@ -1,10 +1,10 @@
import java.awt.*;
import java.awt.event.ActionEvent;
import javax.swing.JFrame;
import javax.swing.*;
public class JoinGame extends JPanel {
JLabel spielBeitretenLabel= new JLabel("Spiel beitreten");
ImageIcon backButtonIcon = new ImageIcon("graphics/backButton.png");
JLabel spielBeitretenLabel;
JLabel ipLabel = new JLabel("IP-Adresse");
JLabel portLabel = new JLabel("Port");
@ -12,17 +12,25 @@ public class JoinGame extends JPanel {
JTextField portTextField = new JTextField(20);
JButton losButton = new JButton("Los!");
JButton backButton = new JButton(backButtonIcon);
Font robotoFont = new Font("Roboto", Font.BOLD, 45);
public JoinGame(MainFrame frame) {
public JoinGame(MainFrame frame,int g) {
setLayout(null);
buildPanel(frame);
buildPanel(frame,g);
}
private void buildPanel(MainFrame frame) {
private void buildPanel(MainFrame frame,int g) {
if(g==1){
spielBeitretenLabel= new JLabel("Spiel beitreten");
}else{
spielBeitretenLabel= new JLabel("Spiel erstellen");
}
spielBeitretenLabel.setBounds(20,20,700, 100);
losButton.setBounds(320, 225, 100, 50);
backButton.setBounds(1380, 20, 80, 80);
ipLabel.setBounds(50, 125, 200, 30);
portLabel.setBounds(50, 200, 200, 30);
@ -39,6 +47,9 @@ public class JoinGame extends JPanel {
add(losButton);
add(ipTextField);
add(portTextField);
}
add(backButton);
backButton.addActionListener(e -> frame.showPanel("MultiplayerGame"));
losButton.addActionListener(e -> frame.showPanel("Verbinden"));
}
}

54
src/LocalPlayer.java
View File

@ -1,8 +1,58 @@
import java.util.Random;
public class LocalPlayer extends Player {
LocalPlayer(int size) {
super(size);
public LocalPlayer(){
super();
Random random = new Random();
this.myCoin = random.nextBoolean();
}
@Override
public synchronized void receiveShoot(Point point) {
HitResponse hitResponse = board.getHitResponsOnPoint(point);
if (!(hitResponse == null)){
enemy.receiveHit(hitResponse);
} else {
hitResponse = this.board.hit(point);
enemy.receiveHit(hitResponse);
}
switch (hitResponse.getType()) {
case HIT, SUNK -> this.myTurn = false;
case MISS -> this.myTurn = true;
case VICTORY -> System.out.println("Game Over"); //TODO Was halt bei victory passiert ist hier wurder verloheren
}
}
@Override
public synchronized void receiveHit(HitResponse hitResponse) {
enemy.board.addHits(hitResponse);
switch (hitResponse.getType()) {
case HIT, SUNK -> this.myTurn = true;
case MISS -> this.myTurn = false;
case VICTORY -> System.out.println("Win"); // TODO was halt beim victory passier ist hier wurde gewonnen
}
}
@Override
public synchronized void receiveCoin(boolean coin) {
if (!this.haseReceivedCoin) {
boolean result = coin ^ this.myCoin; // XOR
this.myTurn = result == this.isServer;
this.haseReceivedCoin = true;
}
}
public void sendCoin() {
enemy.receiveCoin(this.myCoin);
}
@Override
public void shoot(Point point){
this.myTurn = false;
enemy.receiveShoot(point);
}
}

54
src/MainFrame.java
View File

@ -6,6 +6,16 @@ public class MainFrame extends JFrame {
private CardLayout cardLayout;
private JPanel mainPanel;
// ---------- //
// Diverse Hilfsvariablen (für Parameterübergabe etc.)
// Von startMultiplayerGame an JoinGame
int localMult;
// Von startLocalGame an GameBoard
int semesterCounter;
// ---------- //
public MainFrame() {
setTitle("Studium Versenken");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
@ -27,13 +37,18 @@ public class MainFrame extends JFrame {
startLocalGame localGame = new startLocalGame(this);
startMultiplayerGame multiplayerGame = new startMultiplayerGame(this);
coinToss coinToss = new coinToss(this);
JoinGame joinGame = new JoinGame(this);
Verbinden verbinden = new Verbinden(this);
//JoinGame joinGame = new JoinGame(this,localMult);
//GameBoard gameBoard = new GameBoard(this, localMult);
mainPanel.add(mainMenuView, "MainMenu");
mainPanel.add(localGame, "LocalGame");
mainPanel.add(multiplayerGame, "MultiplayerGame");
mainPanel.add(coinToss, "coinToss");
mainPanel.add(joinGame, "JoinGame");
mainPanel.add(verbinden, "Verbinden");
//mainPanel.add(joinGame, "JoinGame");
//mainPanel.add(gameBoard, "GameBoard");
// Hauptpanel in JFrame hinzufügen
add(mainPanel);
@ -45,6 +60,41 @@ public class MainFrame extends JFrame {
public void showPanel(String panelName) {
cardLayout.show(mainPanel, panelName);
}
// --- ShowPanel der startMultiplayerGame Klasse
public void showPanelSMG(String panelName, int num) {
this.localMult = num;
//if (!isPanelPresent(panelName)) { //TODO potentiell raus
JoinGame joinGame = new JoinGame(this, localMult);
mainPanel.add(joinGame, panelName);
mainPanel.revalidate(); // Refresh
mainPanel.repaint();
//}
cardLayout.show(mainPanel, panelName); // Show the panel
}
// --- ShowPanel der startLocalGame Klasse
public void showPanelSLG(String panelName,int semesterCounter) {
this.semesterCounter = semesterCounter;
//if (!isPanelPresent(panelName)) { //TODO potentiell raus
GameBoard gameBoard = new GameBoard(this, semesterCounter);
mainPanel.add(gameBoard, 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;
} */
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {

27
src/MainMenuView.java
View File

@ -1,5 +1,6 @@
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.*;
@ -36,9 +37,29 @@ public class MainMenuView extends JPanel {
add(soundButton);
// Event Listener für Buttons
lokalButton.addActionListener(e -> frame.showPanel("LocalGame"));
multiButton.addActionListener(e -> frame.showPanel("MultiplayerGame"));
soundButton.addActionListener(e -> toggleMute());
lokalButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Lokales Spiel ausgewählt.");
frame.showPanel("LocalGame"); // Panel wechseln
}
});
multiButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Multiplayer-Spiel ausgewählt.");
frame.showPanel("MultiplayerGame"); // Panel wechseln
}
});
soundButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Soundbutton geklickt.");
toggleMute();
}
});
}
private void toggleMute() {

24
src/OnlinePlayer.java
View File

@ -1,11 +1,25 @@
import java.net.Socket;
public abstract class OnlinePlayer extends Player implements AsyncSocketListener{
protected AsyncSocket socket;
protected int wantedBoardSize;
public abstract class OnlinePlayer extends Player{
private Socket socket;
protected boolean hasReceivedCoinPackage;
public OnlinePlayer(int size, Socket socket) {
super(size);
public OnlinePlayer(int size, AsyncSocket socket) {
this.socket = socket;
this.wantedBoardSize = size;
socket.setHandler(this);
//TODO Auto-generated constructor stub
}
public abstract void receive(String message);
@Override
public abstract void receiveShoot(Point point);
@Override
public abstract void receiveHit(HitResponse hitResponse);
@Override
public abstract void receiveCoin(boolean coin);
}

91
src/OnlinePlayer_1_1_0.java Normal file
View File

@ -0,0 +1,91 @@
import java.util.List;
public class OnlinePlayer_1_1_0 extends OnlinePlayer {
public OnlinePlayer_1_1_0(int size, AsyncSocket socket) {
super(size, socket);
}
@Override
public void receive(String message) {
SocketPackage p = new SocketPackage(message);
List<String> data = p.splitData();
switch (p.getName()) {
case "IAM":
if (data.size() < 2) break;
if (this.board != null) break;
int semester = Integer.parseInt(data.get(0));
String username = p.getData().substring(data.get(0).length() + 1);
int usedBoardSize = Math.min(GameController.semesterToBoardSize(semester), this.wantedBoardSize);
this.setName(username);
this.createBoard(usedBoardSize);
this.enemy.createBoard(usedBoardSize);
break;
// TODO: IAMU
case "COIN":
if(!this.hasReceivedCoinPackage && (p.getData().equals("1") || p.getData().equals("0"))){
this.myCoin = p.getData().equals("1");
enemy.receiveCoin(this.myCoin);
this.hasReceivedCoinPackage = true;
}
break;
case "SHOOT":
if (Point.isValidSyntax(p.getData())){
Point point = new Point(p.getData());
this.enemy.receiveShoot(point);
}
break;
case "HIT":
if (data.size()==2){
Point point = new Point(data.get(0));
int typeIndex = Integer.parseInt(data.get(1));
if (Point.isValidSyntax(data.get(0)) && typeIndex >= 0 && typeIndex < HitResponseType.values().length){
this.enemy.receiveHit(new HitResponse(typeIndex, point));
}
}
break;
case "CHAT":
//TODO CHAT
break;
default:
//nichts passier da Paket ungültig
break;
}
}
@Override
public synchronized void receiveShoot(Point point){
super.socket.send(new SocketPackage("SHOOT",point.toString()));
}
@Override
public synchronized void receiveHit(HitResponse hitResponse) {
super.socket.send(new SocketPackage("HIT", hitResponse.toString()));
}
@Override
public synchronized void receiveCoin(boolean coin) {
if (!this.haseReceivedCoin) {
super.socket.send(new SocketPackage("COIN", String.valueOf(coin ? 1 : 0)));
this.haseReceivedCoin = true;
}
}
@Override
public synchronized void shoot(Point point) {
super.socket.send(new SocketPackage("SHOOT", point.toString()));
}
}

42
src/Player.java
View File

@ -1,5 +1,4 @@
import java.awt.*;
import java.util.List;
import java.util.Random;
public abstract class Player {
protected boolean myTurn;
@ -8,27 +7,26 @@ public abstract class Player {
protected Player enemy;
protected String name;
protected Board board;
protected boolean myCoin;
public Player(int size) {
protected boolean sendCoin;
protected boolean haseReceivedCoin;
public Player() {
this.haseReceivedCoin = false;
this.sendCoin = false;
}
public void createBoard(int size) {
this.board = new Board(size);
}
public void receiveShoot(Point point) {
HitResponse hitResponse = board.getHitResponsOnPoint(point);
if (!(hitResponse == null)){
enemy.receiveHit(hitResponse);
} else {
enemy.receiveHit(this.board.hit(point));
}
}
public abstract void receiveShoot(Point point);
public void receiveHit(HitResponse hitResponse) {
enemy.board.addHits(hitResponse);
}
public abstract void receiveHit(HitResponse hitResponse);
public void click(Point point) {
}
public abstract void shoot(Point point);
public void beginTrun() {
@ -37,4 +35,14 @@ public abstract class Player {
public void setEnemy(Player enemy) {
this.enemy = enemy;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public abstract void receiveCoin(boolean coin);
}

45
src/Point.java Normal file
View File

@ -0,0 +1,45 @@
public class Point {
private int x;
private int y;
public Point (int x, int y) {
this.setX(x);
this.setY(y);
}
public Point (String str) {
if (Point.isValidSyntax(str)) {
this.setX(str.charAt(0));
this.setY(Integer.parseInt(str.substring(1)));
} else {
throw new IllegalArgumentException("String ist keine gültige Koordinate");
}
}
@Override
public String toString() {
return (char) ('A' + this.x) + String.valueOf(this.y);
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public void setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
public void setX(char c) {
this.x = c - 'A';
}
public static boolean isValidSyntax(String str) {
return str.matches("^[A-Z]\\d+$");
}
}

24
src/Ship.java
View File

@ -1,6 +1,4 @@
import java.awt.Point;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@ -65,21 +63,21 @@ public class Ship {
public boolean setPosition(Point pos, List<Ship> shipsList, int boardSize) {
// ueberpruefe boundaries
if (pos.x < 0 || pos.y < 0 || pos.x >= boardSize || pos.y >= boardSize) {
if (pos.getX() < 0 || pos.getY() < 0 || pos.getX() >= boardSize || pos.getY() >= boardSize) {
return false;
}
// bestimme die Endposition anhand der Ausrichtung
int endX = pos.x;
int endY = pos.y;
int endX = pos.getX();
int endY = pos.getY();
if (this.horizontal) { // rechts links
endX = pos.x + this.size - 1;
endX = pos.getX() + this.size - 1;
if (endX >= boardSize) {
return false;
}
} else { // oben unten
endY = pos.y + this.size - 1;
endY = pos.getY() + this.size - 1;
if (endY >= boardSize) {
return false;
}
@ -88,8 +86,8 @@ public class Ship {
// Liste an Punkten die das Schiff einnehmen wuerde
List<Point> shipPoints = new ArrayList<>();
for (int i = 0; i < this.size; i++) {
int x = this.horizontal ? pos.x + i : pos.x; //falls horizontal dann pos.x + i ansonsten pos.x
int y = this.horizontal ? pos.y : pos.y + i;
int x = this.horizontal ? pos.getX() + i : pos.getX(); //falls horizontal dann pos.x + i ansonsten pos.x
int y = this.horizontal ? pos.getY() : pos.getY() + i;
shipPoints.add(new Point(x, y));
}
@ -125,8 +123,8 @@ public class Ship {
return points;
}
for (int i = 0; i < this.size; i++) {
int x = this.horizontal ? this.position.x + i : this.position.x;
int y = this.horizontal ? this.position.y : this.position.y + i;
int x = this.horizontal ? this.position.getX() + i : this.position.getX();
int y = this.horizontal ? this.position.getY() : this.position.getY() + i;
points.add(new Point(x, y));
}
return points;
@ -137,8 +135,8 @@ public class Ship {
}
public boolean isShipOnPos(Point pos){
if ((this.horizontal && pos.y == this.position.y && pos.x >= this.position.x && pos.x < this.position.x + size) ||
(!(this.horizontal) && pos.x == this.position.x && pos.y >= this.position.y && pos.y < this.position.y + size)) {
if ((this.horizontal && pos.getY() == this.position.getY() && pos.getX() >= this.position.getX() && pos.getX() < this.position.getX() + size) ||
(!(this.horizontal) && pos.getX() == this.position.getX() && pos.getY() >= this.position.getY() && pos.getY() < this.position.getY() + size)) {
return true;
}
return false;

57
src/SocketPackage.java Normal file
View File

@ -0,0 +1,57 @@
import java.util.Arrays;
import java.util.List;
public class SocketPackage {
private String name = "";
private String data = "";
public SocketPackage(String name, String data) {
this.setName(name);
this.setData(data);
}
public SocketPackage() {
this("","");
}
public SocketPackage(String message) {
if (message.length() <= 0) {
throw new IllegalArgumentException("Socket message cannot be empty.");
}
String[] components = message.split(" ");
this.setName(components[0]);
if (components.length > 1) {
this.setData(message.substring(components[0].length() + 1));
} else {
this.setData("");
}
}
public void setName(String name) {
if (name == null) name = "";
this.name = name.toUpperCase();
}
public void setData(String data) {
if (data == null) data = "";
this.data = data;
}
public String getName() {
return this.name;
}
public String getData() {
return this.data;
}
public String toString() {
if (this.data == null || this.data.length() == 0) {
return this.name;
} else {
return this.name + " " + this.data;
}
}
public List<String> splitData() {
return Arrays.asList(this.data.split(" "));
}
}

1
src/SoundHandler.java
View File

@ -3,7 +3,6 @@ import javazoom.jl.player.Player;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

4
src/SpecificAiPlayerEasy.java
View File

@ -1,7 +1,3 @@
public class SpecificAiPlayerEasy extends AiPlayer{
public SpecificAiPlayerEasy(int size) {
super(size);
}
}

4
src/SpecificAiPlayerHard.java
View File

@ -1,7 +1,3 @@
public class SpecificAiPlayerHard extends AiPlayer{
public SpecificAiPlayerHard(int size) {
super(size);
}
}

13
src/SpecificAiPlayerMedium.java
View File

@ -1,15 +1,10 @@
import java.util.ArrayList;
import java.util.List;
import java.awt.Point;
public class SpecificAiPlayerMedium extends AiPlayer{
private List<Point> hitsQueue = new ArrayList<>();
public SpecificAiPlayerMedium(int size) {
super(size);
}
@Override
public void AiShoot() {
Point nextShot = ComputeNextShot();
@ -43,8 +38,8 @@ public class SpecificAiPlayerMedium extends AiPlayer{
}
private void addAdjacentPoints(Point point) {
int x = point.x;
int y = point.y;
int x = point.getX();
int y = point.getY();
// Possible adjacent positions (up, down, left, right)
Point[] adjacentPoints = {
@ -67,7 +62,7 @@ public class SpecificAiPlayerMedium extends AiPlayer{
}
private boolean isValidPoint(Point point) {
return point.x >= 0 && point.x < board.getSize() &&
point.y >= 0 && point.y < board.getSize();
return point.getX() >= 0 && point.getX() < board.getSize() &&
point.getY() >= 0 && point.getY() < board.getSize();
}
}

23
src/Verbinden.java Normal file
View File

@ -0,0 +1,23 @@
import javax.swing.*;
import java.awt.*;
public class Verbinden extends JPanel{
ImageIcon backButtonIcon = new ImageIcon("graphics/backButton.png");
JLabel verbindenLabel = new JLabel("Verbinde . . .",SwingConstants.CENTER);
Font robotoFont = new Font("Roboto", Font.BOLD, 45);
public Verbinden(MainFrame frame) {
setLayout(null);
buildPanel(frame);
}
private void buildPanel(MainFrame frame) {
setLayout(new BorderLayout());
verbindenLabel.setFont(robotoFont.deriveFont(50f));
add(verbindenLabel, BorderLayout.CENTER);
}
}

3
src/startLocalGame.java
View File

@ -1,5 +1,4 @@
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
@ -143,7 +142,7 @@ public class startLocalGame extends JPanel {
backButton.addActionListener(e -> frame.showPanel("MainMenu"));
startButton.addActionListener(e -> frame.showPanel("coinToss")); // TODO ECHTE FUNKTION EINFÜGEN
startButton.addActionListener(e -> frame.showPanelSLG("GameBoard", semesterCounter)); // TODO ECHTE FUNKTION EINFÜGEN
}
private void toggleLeftPlayerIcon() {

6
src/startMultiplayerGame.java
View File

@ -1,12 +1,9 @@
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
public class startMultiplayerGame extends JPanel {
// Funktionshilfen
int semesterCounter = 1; // Semester Counter Label
String PlayerNickname = "Spieler 1";
// Grafiken
ImageIcon backButtonIcon = new ImageIcon("graphics/backButton.png");
ImageIcon humanPlayerIcon = new ImageIcon("graphics/humanPlayer.png");
@ -109,7 +106,8 @@ public class startMultiplayerGame extends JPanel {
// ActionListener für den "Back" Button, um zum vorherigen Panel zurückzukehren
backButton.addActionListener(e -> frame.showPanel("MainMenu"));
joinGameButton.addActionListener(e -> frame.showPanel("JoinGame"));
joinGameButton.addActionListener(e -> frame.showPanelSMG("JoinGame",1));
createGameButton.addActionListener(e -> frame.showPanelSMG("JoinGame",0));
}
// TOGGLE METHODEN