Einfachen Testfall hinzugefügt.

4Gewinnt/src/VierGewinnt.java

@@ -1,112 +1,121 @@
 import java.util.Scanner;
 
 public class VierGewinnt {
+	static Scanner kb = new Scanner(System.in);		// sog. Klassenvariable
 	
 	public static void main(String[] args) {
-		System.out.println("Willkommen zu 4 Gewinnt!");
-		
 		// Game Loop
-		Scanner kb = new Scanner(System.in);
-		
-		boolean weiter = false;
+		String weiter;
 		char spieler = 'x';
 		do {
+			System.out.println("Willkommen zu 4 Gewinnt!");
 			char[][] spielfeld = spielfeldInitialisieren();
-			int steineZähler = 0;
-			
 			spielfeldAusgeben(spielfeld);
 			
+			int steineZähler = 0;
+
 			// Gewinner Loop
 			boolean gewonnen = false;
 			do {
-				if (spieler == 'o')
-					spieler = 'x';
-				else
-					spieler = 'o';
+				spieler = spielerWechseln(spieler);
 				
-				// Spielstein einwerfen
-				int spalte, zeile;
-				do {
-					System.out.print("Spieler " + spieler + ", bitte wählen Sie eine Spalte aus: ");
-					spalte = kb.nextInt() - 1; 	// da Spalte eins verschoben
-				
-					if ((zeile = einwurfVerarbeiten(spielfeld, spalte, spieler)) == -1)
-						System.err.println("Ungültige Auswahl!");
-					else
-						break;
-				} while(true);
-				steineZähler++;
-						
-				spielfeldAusgeben(spielfeld);
-
-				gewonnen = gewinnerPrüfung(spielfeld, zeile, spalte);
-			} while(!gewonnen && steineZähler < 42);
+				int[] koordinate = spielsteinEinwerfen(spielfeld, spieler);
+				gewonnen = gewinnerPrüfung(spielfeld, koordinate[0], koordinate[1]);
 			
+				spielfeldAusgeben(spielfeld);
+			} while(!gewonnen && ++steineZähler < 42);
+
 			if (!gewonnen && steineZähler == 42) {
 				System.out.println("Das Spiel endet unentschieden.");
 			} else {
 				System.out.println("Es gewinnt Spieler " + spieler);
 			}
 			
-		} while (weiter);
-		
+			System.out.println();
+			System.out.print("Möchten Sie noch eine Runde spielen (j/n)? ");
+			weiter = kb.next();
+		} while (weiter.equalsIgnoreCase("j"));
+
 		System.out.println("Auf Wiedersehen!");
 	} // main
 
 	public static char[][] spielfeldInitialisieren() {
 		char[][] spielfeld = new char[6][7];
-		
+
 		for (int z = 0; z < spielfeld.length; z++) {
 			for (int s = 0; s < spielfeld[z].length; s++) {
 				spielfeld[z][s] = '_';
 			}
 		}
-		
+
 		return spielfeld;
 	}
 	
 	public static void spielfeldAusgeben(char[][] spielfeld) {
 		System.out.println();
-		
+
 		// Alle Zeilen ausgeben
 		for (int z = 0; z < spielfeld.length; z++) {
-			
+
 			// Alle Spalten der z-ten Zeile ausgeben
 			for (int s = 0; s < spielfeld[z].length; s++) {
 				System.out.print("| " + spielfeld[z][s] + " " );
 			}
 			System.out.println("|");
 		}
-		
+
 		System.out.println();
-		
+
 		for (int s = 0; s < spielfeld[0].length; s++) {
 			System.out.print("| " + (s+1) + " " );
 		}
-		
+
 		System.out.println("|");
 		System.out.println();
 	}
 
+	public static char spielerWechseln(char spieler) {
+		if (spieler == 'o')
+			return 'x';
+
+		return 'o';
+	}
+
+	public static int[] spielsteinEinwerfen(char[][] spielfeld, char spieler) {
+		int zeile, spalte;
+		
+		do {
+			System.out.print("Spieler " + spieler + ", bitte wählen Sie eine Spalte aus: ");
+			spalte = kb.nextInt() - 1; 	// da Spalte eins verschoben
+
+			if ((zeile = einwurfVerarbeiten(spielfeld, spalte, spieler)) == -1)
+				System.err.println("Ungültige Auswahl!");
+			else
+				break;
+		} while(true);
+		
+		return new int[] {zeile, spalte};
+	}
+
 	public static int einwurfVerarbeiten(char[][] spielfeld, int spalte, char stein) {
 		if (spalte < 0 || spalte > 6)
 			return -1;
-		
+
 		for (int z = spielfeld.length - 1; z >= 0 ; z--) {
 			if (spielfeld[z][spalte] != '_' && z == 0)	// Spalte voll?
 				return -1;
-				
+
 			if (spielfeld[z][spalte] == '_') {
 				spielfeld[z][spalte] = stein;
 				return z;
 			}
 		}
-		
+
 		return -1;
 	}
 
 	public static boolean gewinnerPrüfung(char[][] spielfeld, int zeile, int spalte) {
-		
+
 		// vertikale Prüfung
 		for (int i = 0; i < 3; i++) {
 			if (spielfeld[0 + i][spalte] == spielfeld[1 + i][spalte]
@@ -115,7 +124,7 @@ public class VierGewinnt {
 					&& spielfeld[0 + i][spalte] != '_') 
 				return true;
 		}
-		
+
 		// horizontale Prüfung
 		for (int i = 0; i < 4; i++) {
 			if (spielfeld[zeile][0 + i] == spielfeld[zeile][1 + i]
@@ -124,7 +133,30 @@ public class VierGewinnt {
 					&& spielfeld[zeile][0 + i] != '_') 
 				return true;
 		}
-		
+
+		// diagonale Prüfung 1: "Plusplus-Fall", z.B. spielfeld[z+1][s+1]
+		for (int z = 0; z < 3; z++) {
+			for (int s = 0; s < 4; s++) {
+				if (spielfeld[z][s] == spielfeld[z+1][s+1]
+						&& spielfeld[z][s] == spielfeld[z+2][s+2]
+						&& spielfeld[z][s] == spielfeld[z+3][s+3]
+						&& spielfeld[z][s] != '_') 
+					return true;
+			}
+		}
+
+		// diagonale Prüfung 2: "Minusplus-Fall", z.B. spielfeld[z-1][s+1]
+		for (int z = spielfeld.length-1; z > spielfeld.length-4; z--) {
+			for (int s = 0; s < 4; s++) {
+				if (spielfeld[z][s] == spielfeld[z-1][s+1]
+						&& spielfeld[z][s] == spielfeld[z-2][s+2]
+						&& spielfeld[z][s] == spielfeld[z-3][s+3]
+						&& spielfeld[z][s] != '_') 
+					return true;
+			}
+		}
+
 		return false;
 	}
-}
+
+} // eof

4Gewinnt/src/VierGewinntTest.java

@@ -0,0 +1,25 @@
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+class VierGewinntTest {
+
+	@Test		// sog. Annotation, damit JUnit erkennt, wo es testen soll
+	void testSpielerWechseln() {
+		assertEquals('x', VierGewinnt.spielerWechseln('o'));
+		assertEquals('o', VierGewinnt.spielerWechseln('x'));
+	}
+	
+	@Test
+	void testEinwurfVerarbeiten() {
+		char[][] expectedSpielfeld = VierGewinnt.spielfeldInitialisieren();
+		expectedSpielfeld[5][3] = 'o';
+		
+		char[][] testSpielfeld = VierGewinnt.spielfeldInitialisieren();
+		assertEquals(5, VierGewinnt.einwurfVerarbeiten(testSpielfeld, 3, 'o'));
+		
+		assertArrayEquals(expectedSpielfeld, testSpielfeld);
+	}
+	
+}