In diesem Tutorial werden wir eine Java-Applikation entwickeln, die das Spiel Vier Gewinnt ermöglicht. Wir werden die Spiellogik implementieren, Benutzereingaben verarbeiten und das Spiel auf der Konsole anzeigen. Schauen wir uns nun den Java-Code genauer an.
Schritt 1: Projektstruktur und Klassen erstellen
- Erstelle ein neues Java-Projekt und definiere die Paketstruktur.
- Erstelle die Klassen "GameBoard" für das Spielbrett, "Player" für die Spieler und "GameController" für die Spielsteuerung.
Schritt 2: Spiellogik implementieren
- Definiere die Spielregeln, wie die Größe des Spielbretts und die Anzahl der benötigten Steine in einer Reihe.
- Implementiere Methoden zum Platzieren von Spielsteinen und Überprüfen von Gewinnbedingungen.
Schritt 3: Benutzereingaben verarbeiten
- Verwende die "java.util.Scanner"-Klasse, um Benutzereingaben zu lesen.
- Schreibe eine Methode, um die Spalte auszuwählen, in die der Spieler seinen Spielstein setzen möchte.
- Validiere die Eingabe und behandele Fehlerfälle, z.B. wenn die Spalte voll ist oder eine ungültige Spalte ausgewählt wurde.
Schritt 4: Spielanzeige
- Implementiere eine Methode, um das Spielbrett auf der Konsole anzuzeigen.
- Verwende Schleifen und bedingte Anweisungen, um das Spielbrett und die Spielsteine zu visualisieren.
Schritt 5: Spielablauf steuern
- Implementiere Methoden im "GameController", um den Spielablauf zu steuern.
- Wechsle zwischen den Spielern nach jedem Zug.
- Beende das Spiel, wenn ein Spieler gewonnen hat oder das Spiel unentschieden ist.
Implementierung
Die Klasse "GameBoard" repräsentiert das Spielbrett. Sie speichert die Anzahl der Zeilen und Spalten, sowie ein zweidimensionales Array ("board"), um den aktuellen Zustand des Spielbretts zu halten. Die Methode "initializeBoard()" initialisiert das Spielbrett mit leeren Feldern. "placePiece()" ermöglicht das Platzieren eines Spielsteins in einer bestimmten Spalte, und "checkWin()" überprüft, ob ein Spieler gewonnen hat. Die Methode "isBoardFull()" prüft, ob das Spielbrett voll ist, und "displayBoard()" zeigt das Spielbrett auf der Konsole an.
Die Klasse "Player" repräsentiert einen Spieler. Sie enthält den Namen des Spielers und das Zeichen (X oder O), das er verwendet.
Die Klasse "GameController" ist der Spielcontroller. Sie initialisiert das Spielbrett und die beiden Spieler. Die Methode "startGame()" startet das Spiel und enthält die Hauptspielschleife. In jeder Runde wird das Spielbrett angezeigt und der aktuelle Spieler aufgefordert, eine Spalte für seinen Spielstein auszuwählen. Der Spielstein wird dann platziert und überprüft, ob der Spieler gewonnen hat oder das Spiel unentschieden ist. Der aktuelle Spieler wechselt nach jedem Zug.
Die Klasse "Main" ist die Hauptklasse des Programms. Hier wird der GameController erstellt und das Spiel gestartet.
Code
// GameBoard.java
public class GameBoard {
private int rows;
private int columns;
private char[][] board;
public GameBoard(int rows, int columns) {
this.rows = rows;
this.columns = columns;
this.board = new char[rows][columns];
initializeBoard();
}
private void initializeBoard() {
for (int row = 0; row < rows; row++) {
for (int col = 0; col < columns; col++) {
board[row][col] = ' ';
}
}
}
public void placePiece(int col, char piece) {
for (int row = rows - 1; row >= 0; row--) {
if (board[row][col] == ' ') {
board[row][col] = piece;
return;
}
}
System.out.println("Column is full. Please choose another column.");
}
//checkWin Methode
public boolean checkWin(Player player) {
// Überprüfe horizontale Linien
for (int row = 0; row < ROWS; row++) {
for (int col = 0; col < COLS - 3; col++) {
if (board[row][col] == player.getSymbol() &&
board[row][col + 1] == player.getSymbol() &&
board[row][col + 2] == player.getSymbol() &&
board[row][col + 3] == player.getSymbol()) {
return true;
}
}
}
// Überprüfe vertikale Linien
for (int row = 0; row < ROWS - 3; row++) {
for (int col = 0; col < COLS; col++) {
if (board[row][col] == player.getSymbol() &&
board[row + 1][col] == player.getSymbol() &&
board[row + 2][col] == player.getSymbol() &&
board[row + 3][col] == player.getSymbol()) {
return true;
}
}
}
// Überprüfe diagonale Linien (nach rechts oben)
for (int row = 0; row < ROWS - 3; row++) {
for (int col = 0; col < COLS - 3; col++) {
if (board[row][col] == player.getSymbol() &&
board[row + 1][col + 1] == player.getSymbol() &&
board[row + 2][col + 2] == player.getSymbol() &&
board[row + 3][col + 3] == player.getSymbol()) {
return true;
}
}
}
// Überprüfe diagonale Linien (nach links oben)
for (int row = 0; row < ROWS - 3; row++) {
for (int col = 3; col < COLS; col++) {
if (board[row][col] == player.getSymbol() &&
board[row + 1][col - 1] == player.getSymbol() &&
board[row + 2][col - 2] == player.getSymbol() &&
board[row + 3][col - 3] == player.getSymbol()) {
return true;
}
}
}
return false; // Kein Gewinner gefunden
}Die Methode checkWin(Player player) überprüft, ob der
übergebene Spieler gewonnen hat, indem sie alle möglichen Kombinationen
von vier aufeinanderfolgenden Symbolen (Spielsteine) auf dem Spielbrett
überprüft: horizontal, vertikal und diagonal. Wenn eine solche
Kombination gefunden wird, wird true zurückgegeben, andernfalls false.
//isBoardFull Methode
public boolean isBoardFull() {
for (int row = 0; row < ROWS; row++) {
for (int col = 0; col < COLS; col++) {
if (board[row][col] == ' ') {
return false; // Es gibt leere Felder, das Spielbrett ist nicht voll
}
}
}
return true; // Das Spielbrett ist voll
}Die Methode isBoardFull() überprüft, ob das Spielbrett voll ist, indem sie nach leeren Feldern sucht. Wenn ein leeres Feld gefunden wird, wird false zurückgegeben, andernfalls true.
//displayBoard Methode
public void displayBoard() {
for (int row = 0; row < ROWS; row++) {
for (int col = 0; col < COLS; col++) {
System.out.print(board[row][col] + " ");
}
System.out.println();
}
System.out.println();
}Die Methode displayBoard() zeigt das Spielbrett auf der
Konsole an, indem sie jedes Feld nacheinander ausgibt. Dadurch wird eine
visuelle Darstellung des Spielbretts erzeugt.
// Player.java
public class Player {
private String name;
private char piece;
public Player(String name, char piece) {
this.name = name;
this.piece = piece;
}
public String getName() {
return name;
}
public char getPiece() {
return piece;
}
}
// GameController.java
import java.util.Scanner;
public class GameController {
private GameBoard gameBoard;
private Player player1;
private Player player2;
private Player currentPlayer;
public GameController(int rows, int columns) {
this.gameBoard = new GameBoard(rows, columns);
this.player1 = new Player("Player 1", 'X');
this.player2 = new Player("Player 2", 'O');
this.currentPlayer = player1;
}
public void startGame() {
boolean gameOver = false;
Scanner scanner = new Scanner(System.in);
while (!gameOver) {
gameBoard.displayBoard();
System.out.println(currentPlayer.getName() + ", choose a column to place your piece: ");
int col = scanner.nextInt() - 1;
gameBoard.placePiece(col, currentPlayer.getPiece());
if (gameBoard.checkWin(currentPlayer.getPiece())) {
System.out.println(currentPlayer.getName() + " wins!");
gameOver = true;
} else if (gameBoard.isBoardFull()) {
System.out.println("It's a tie! The board is full.");
gameOver = true;
} else {
currentPlayer = (currentPlayer == player1) ? player2 : player1;
}
}
scanner.close();
}
}
// Main.java
public class Main { public static void main(String[] args) { GameController gameController = new GameController(6, 7); gameController.startGame(); } }
Ihr Autor: Julien Rösch