Java:
import java.util.Scanner;
/**
* Spiel: Connect6. "Connect 6 is a two-player strategy game similar to Gomoku.
* Two players, Black and White, alternately place two stones of their own
* colour, black and white respectively, on empty intersections of a Go-like
* board, except that Black (the first player) places one stone only for the
* first move. The one who gets six or more stones in a row (horizontally,
* vertically or diagonally) first wins the game." - Wikipedia.
*
* @author michaeldietz
*
*/
public class Connect6 {
public static char color; // Die Farbe des Steins, der als naechste gespielt wird.
public static char[][] board; // Das Spielbrett.
public static int x, y; // Spielfeldgroeße.
public static int r, s; // Koordinaten des Feldes, auf das der naechste Stein gespielt wird.
public static Scanner scanner = new Scanner(System.in);
public static boolean gameNotOver = true;
public static void main(String[] args) throws Exception {
x = reihenAnzahl();
y = spaltenAnzahl();
System.out.println();
board = new char[x][y];
fillBoard(board); // füllt die Felder mit dem Zeichen '.'.
printBoard(board); // Zeichnet das Spielfeld.
playGame(board); // Spiel beginnt.
}
/**
* Spielt das Spiel Connect6. Spieler black beginnt zuerst. Spiel endet,
* wenn einer der beiden Spieler 6 Felder in einer waagerechten, diagonalen
* oder senkrechten hat.
*
* @param board
*/
public static void playGame(char[][] board) throws Exception{
boolean blackTurn = true;
boolean firstTurn = true;
while (gameNotOver) { // solange das Spiel nicht zu Ende ist.
if (blackTurn) { // black ist am Zug.
System.out.println("\nBlack ist am Zug:");
if (firstTurn) { // In der ersten Runde darf black nur einen Stein platzieren. Ansonsten immer zwei.
gibKoordinaten('B'); // Fragt nach den Koordinaten.
printBoard(board); // Zeichnet das aktuelle Spielbrett.
blackTurn = !blackTurn; // beendet Runde und white beginnt.
firstTurn = !firstTurn; // die erste Runde ist vorbei und ab jetzt darf jeder zwei Steine platzieren.
}
else { // ab dem zweiten Zug.
for (int i = 0; i < 2; i++) { // wiederholt das ganze zweimal, da jeder zwei Steine platzieren darf.
gibKoordinaten('B'); // Fragt nach den Koordinaten.
printBoard(board); // Zeichnet das aktuelle Spielbrett.
if (gameWinner()) {
gameNotOver = false;
System.out.println("Glückwunsch, Spieler " + color + " hat das Spiel gewonnen!" );
break;
}
}
blackTurn = !blackTurn; // beendet Runde und white beginnt.
}
}
else { // white ist am Zug.
System.out.println("\nWhite ist am Zug:");
for (int i = 0; i < 2; i++) { // wiederholt das ganze zweimal, da jeder zwei Steine platzieren darf.
gibKoordinaten('W'); // Fragt nach den Koordinaten.
printBoard(board); // Zeichnet das aktuelle Spielbrett.
if (gameWinner()) {
gameNotOver = false;
System.out.println("Glückwunsch, Spieler " + color + " hat das Spiel gewonnen!" );
break;
}
}
blackTurn = !blackTurn; // beendet Runde und black beginnt.
}
}
}
/**
* (Spielfeldkomponente beginnt hier und kann unabhängig vom anderen modifziert werden.)
* Zeichnet das Spielbrett.
*
* @param board
*/
public static void printBoard(char[][] board) {
for (int i = 0; i < board.length; i++) { // für jede Reihe...
for (int j = 0; j < board[I].length; j++) { // für jede Spalte...
System.out.print("|" + board[I][j]);
}
System.out.println("|");
}
}
/**
* Füllt das Spielbrett mit dem Defaultwert '.' aus.
*
* @param board
*/
public static void fillBoard(char[][] board) {
for (int i = 0; i < board.length; i++) { // für jede Reihe...
for (int j = 0; j < board[I].length; j++) { // für jede Spalte...
board[I][j] = '.'; // Belege das Feld mit dem Initialisierungswert.
}
}
}
/**
* (Spielfeldkomponente endet hier)
* Kontrolliert, ob das Feld schon besetzt ist oder nicht. Liefert true,
* wenn das Feld noch nicht besetzt ist, liefert false, wenn das Feld
* besetzt ist. Wenn das Feld noch nicht besetzt ist, platziert es den zu spielenden
* Stein an diese Stelle.
*
* @param board
* @param color
* @param x
* @param y
* [USER=49078]@Return[/USER]
*/
public static boolean checkField(char[][] board, char color, int x, int y) {
if (board[x][y] == '.') { // Wenn das Feld leer ist...
board[x][y] = color;
return true;
} else { // ansonsten...
System.out.println("Das Feld ist bereits besetzt. Bitte wiederholen sie ihre Eingabe.\n");
return false;
}
}
/**
* (Dialogkomponente beginnt hier und kann unabhängig vom anderen modifiziert werden.)
* Fragt nach der Reihe, in welche der Spieler seinen Stein platzieren
* möchte.
*
* [USER=49078]@Return[/USER] Reihenkoordinate
*/
public static int gibReihenKoordinate(int a) {
int i = 0;
System.out.println("Bitte geben sie ein, in welche Reihe sie spielen möchten(1-" + a + ").");
String o = scanner.nextLine();
if (o.equalsIgnoreCase("beenden")) {
System.exit(0);
}
else {
i = Integer.parseInt(o) - 1;
while (i < 0 || i > a - 1) { // solange sich die Eingabe außerhalb des Feldes befindet...
System.out.println("Reihenposition befindet sich außerhalb des Spielfeldes. Bitte wiederholen sie ihre Eingabe.");
System.out.println("Bitte geben sie ein, in welche Reihe sie spielen möchten(1-" + a + ").");
o = scanner.nextLine();
if (o.equalsIgnoreCase("beenden")) {
System.exit(0);
}
else {
i = Integer.parseInt(o) - 1;
}
}
}
return i;
}
/**
* Fragt nach der Spalte, in welche der Spieler seinen Stein platzieren
* möchte.
*
* [USER=49078]@Return[/USER] Spaltenkoordinate
*/
public static int gibSpaltenKoordinate(int b) {
int i = 0;
System.out.println("Bitte geben sie ein, in welche Spalte sie spielen möchten(1-" + b + ").");
String o = scanner.nextLine();
if (o.equalsIgnoreCase("beenden")) {
System.exit(0);
}
else {
i = Integer.parseInt(o) - 1;
while (i < 0 || i > b - 1) { // solange sich die Eingabe außerhalb des Feldes befindet...
System.out.println("Reihenposition befindet sich außerhalb des Spielfeldes. Bitte wiederholen sie ihre Eingabe.");
System.out.println("Bitte geben sie ein, in welche Spalte sie spielen möchten(1-" + b + ").");
o = scanner.nextLine();
if (o.equalsIgnoreCase("beenden")) {
System.exit(0);
}
else {
i = Integer.parseInt(o) - 1;
}
}
System.out.println();
}
return i;
}
/**
* Fragt nach den Koordinaten, in welche der Spieler seinen Stein platzieren
* möchte.
*
* @param farbe
* @throws Exception
*/
public static void gibKoordinaten(char farbe) throws Exception {
r = gibReihenKoordinate(x);
s = gibSpaltenKoordinate(y);
color = farbe;
while (!checkField(board, color, r, s)) { // wenn das Feld besetzt ist.
r = gibReihenKoordinate(x);
s = gibSpaltenKoordinate(y);
color = farbe;
}
}
/**
* Fragt nach der Anzahl der Reihen des Spielfeldes.
* [USER=49078]@Return[/USER]
* @throws Exception
*/
public static int reihenAnzahl() throws Exception {
x = IO.readInt("Wie viele Reihen soll das Spielfeld haben(6-20)?");
while (x < 6 || x > 20) { // solange es sich nicht im Bereich befindet...
System.out.println("Ihre Eingabe befindet sich außerhalb der gueltigen Groeße. Bitte wiederholen sie ihre Eingabe.");
x = IO.readInt("Wie viele Reihen soll das Spielfeld haben(6-20)?");
}
return x;
}
/**
* (Dialogkomponente endet hier.)
* Fragt nach der Anzahl der Spalten des Spielfeldes.
* [USER=49078]@Return[/USER]
* @throws Exception
*/
public static int spaltenAnzahl() throws Exception {
y = IO.readInt("Wie viele Spalten soll das Spielfeld haben(6-20)?");
while (y < 6 || y > 20) { // solange es sich nicht im Bereich befindet...
System.out.println("Ihre Eingabe befindet sich außerhalb der gueltigen Groeße. Bitte wiederholen sie ihre Eingabe.");
y = IO.readInt("Wie viele Spalten soll das Spielfeld haben(6-20)?");
}
return y;
}
/**
* Kontrolliert ob es einen Gewinner gibt.
* Returnt true, wenn eine lückenlose vertikale, horizontale oder diagonale
* Reihe von sechs oder mehr der gleichen Steine gebildet wurde.
* [USER=49078]@Return[/USER]
*/
public static boolean gameWinner() {
if (checkReihe()) { // kontrolliert ob jemand 6 oder mehr Steine in einer Reihe hat.
return true;
}
if (checkSpalte()) { // kontrolliert ob jemand 6 oder mehr Steine in einer Spalte hat.
return true;
}
if (checkDiagonal1()) { // kontrolliert ob jemand 6 oder mehr Steine in einer Diagonalen von links oben nach rechts unten hat.
return true;
}
if (checkDiagonal2()) {
return true;
}
return false;
}
/**
*
* Returnt true, wenn 6 oder mehr der gleichen Steine lückenlos in einer Reihe sind.
* [USER=49078]@Return[/USER]
*/
public static boolean checkReihe() {
int counter = 1; // Anzahl der lückenloses Steine, der gleichen Farbe.
for (int i = s - 1; i >= 0; i--) { // zaehlt wieviele Steine der gleichen Farbe lückenlos links neben dem platzierten Stein liegen.
if (board[r][I] == color) {
counter++;
} else {
break;
}
}
if (counter >= 6) {
return true;
}
for (int i = s + 1 ; i < y; i++) { // zaehlt wieviele Steine der gleichen Farbe lückenlos rechts neben dem platzierten Stein liegen.
if (board[r][I] == color) {
counter++;
} else {
break;
}
}
if (counter >= 6) {
return true;
}
return false;
}
/**
*
* Returnt true, wenn 6 oder mehr der gleichen Steine lückenlos in einer Spalte sind.
* [USER=49078]@Return[/USER]
*/
public static boolean checkSpalte() {
int counter = 1; // Anzahl der lückenloses Steine, der gleichen Farbe.
for (int i = r - 1; i >= 0; i--) { // zaehlt wieviele Steine der gleichen Farbe lückenlos oberhalb des platzierten Steins liegen.
if (board[I][S] == color) {
counter++;
} else {
break;
}
}
if (counter >= 6) {
return true;
}
for (int i = r + 1; i < x; i++) { // zaehlt wieviele Steine der gleichen Farbe lückenlos unterhalb des platzierten Steins liegen.
if (board[I][S] == color) {
counter++;
} else {
break;
}
}
if (counter >= 6) {
return true;
}
return false;
}
/**
* Returnt true, wenn 6 oder mehr Steine lückenlos in einer Diagonalen von
* links oben nach rechts unten sind.
* [USER=49078]@Return[/USER]
*/
public static boolean checkDiagonal1() {
int counter = 1; // Anzahl der lückenloses Steine, der gleichen Farbe.
for(int i = r - 1, j = s - 1; i >= 0 && j >= 0; i--, j--) { // zaehlt wieviele Steine der gleichen Farbe lückenlos links oben des platzierten Steins liegen.
if(board[I][j] == color) {
counter++;
}
else {
break;
}
}
if (counter >= 6) {
return true;
}
for(int i = r + 1, j = s + 1; i < x && j < y; i++, j++){ // zaehlt wieviele Steine der gleichen Farbe lückenlos rechts unten des platzierten Steins liegen.
if(board[I][j] == color) {
counter++;
}
else {
break;
}
}
if (counter >= 6) {
return true;
}
return false;
}
/**
* Returnt true, wenn 6 oder mehr Steine lückenlos in einer Diagonalen von
* rechts oben nach links unten sind.
* [USER=49078]@Return[/USER]
*/
public static boolean checkDiagonal2() {
int counter = 1; // Anzahl der lückenloses Steine, der gleichen Farbe.
for(int i = r - 1, j = s + 1; i >= 0 && j < y; i--, j++) { // zaehlt wieviele Steine der gleichen Farbe lückenlos rechts oben des platzierten Steins liegen.
if(board[I][j] == color) {
counter++;
}
else {
break;
}
}
if (counter >= 6) {
return true;
}
for(int i = r + 1, j = s - 1; i < x && j >= 0; i++, j--){ // zaehlt wieviele Steine der gleichen Farbe lückenlos links unten des platzierten Steins liegen.
if(board[I][j] == color) {
counter++;
}
else {
break;
}
}
if (counter >= 6) {
return true;
}
return false;
}
}
Zuletzt bearbeitet von einem Moderator:
