C# :: Aufgabe #40
4 Lösungen
4 Gewinnt für die Konsole
Anfänger - C#
von Gustl
- 05.01.2013 um 16:57 Uhr
Es soll 4 Gewinnt für die Konsole programmiert werden.
2 Spieler spielen gegeneinander, ohne Computergegner (ohne künstliche Intelligenz), spielen können.
Optional mit Computergegner, aber bitte in der Beschreibung dann angeben.
2 Spieler spielen gegeneinander, ohne Computergegner (ohne künstliche Intelligenz), spielen können.
Optional mit Computergegner, aber bitte in der Beschreibung dann angeben.
Lösungen:
C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace _4Gewinnt {
class Program {
struct Spielfeld {
// Das eigentliche Spielfeld
public int[,] Feld;
// Verbleibende Züge
public int Züge;
// Spieler, welcher am Zug ist
public int Spieler;
public bool GameOver;
}
static Spielfeld NeuesSpiel() {
Spielfeld Spielfeld = new Spielfeld();
Spielfeld.GameOver = false;
// 0 = frei, 1 = Spieler 1, 2 = Spieler 2
Spielfeld.Feld = new int[6,7];
for(int i = 0; i<6; i++)
{
for (int j = 0; j < 7; j++) {
Spielfeld.Feld[i, j] = 0;
} // for End
} // for End
Spielfeld.Züge = 22;
Spielfeld.Spieler = 1;
return Spielfeld;
}
static Spielfeld Zug(Spielfeld Spielfeld) {
// Spiefeld ausgeben
Ausgabe(Spielfeld);
while (true) {
ConsoleKeyInfo k = Console.ReadKey();
// Falls Eingabe Zahl ist
if (char.IsDigit(k.KeyChar) && Convert.ToInt32(k.KeyChar) - 49 < 7 &&
Spielfeld.Feld[0,Convert.ToInt32(k.KeyChar) - 49] == 0) {
Spielfeld = SetzeStein(Spielfeld, Convert.ToInt32(k.KeyChar) - 49);
Spielfeld = GewinnBerechnung(Spielfeld, Convert.ToInt32(k.KeyChar) - 49);
Ausgabe(Spielfeld);
break;
} else {
Ausgabe(Spielfeld);
} // else End
} // while End
return Spielfeld;
}
static Spielfeld SetzeStein(Spielfeld Spielfeld, int spalte) {
for (int i = 0; i < 5; i++) {
if (Spielfeld.Feld[i + 1, spalte] != 0) {
Spielfeld.Feld[i, spalte] = Spielfeld.Spieler;
// Nächster Spieler
if (Spielfeld.Spieler == 1) {
Spielfeld.Spieler = 2;
} else {
Spielfeld.Spieler = 1;
} // else End
return Spielfeld;
} // if End
} // for End
Spielfeld.Feld[5, spalte] = Spielfeld.Spieler;
// Nächster Spieler
if (Spielfeld.Spieler == 1) {
Spielfeld.Spieler = 2;
} else {
Spielfeld.Spieler = 1;
} // else End
return Spielfeld;
}
static void Ausgabe(Spielfeld Spielfeld) {
Console.Clear();
if (Spielfeld.Spieler == 1)
Console.WriteLine("Spieler 1 ist an der Reihe!\n");
else
Console.WriteLine("Spieler 2 ist an der Reihe!\n");
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 7; j++) {
Console.Write( Spielfeld.Feld[i, j]);
} // for End
Console.WriteLine();
} // for End
Console.WriteLine("\n\nWähle eine Spalte durch eingeben der Nummer(1-7) aus.");
Console.SetCursorPosition(0, 8);
}
static Spielfeld GewinnBerechnung(Spielfeld Spielfeld, int spalte) {
int zeile = 0;
// Zeile ermitteln
for (int i = 0; i < 6; i++) {
if (Spielfeld.Feld[i, spalte] != 0) {
zeile = i;
break;
} // if End
} // for End
int e = spalte + 1;
// Erster Stein von Links
for (int i = spalte; Spielfeld.Feld[zeile, i] == Spielfeld.Feld[zeile, spalte] &&
i > 0; i--) {
e--;
} // for End
// Gewinn in einer Zeile?
for (int i = e+1; i < e+4 && i < 7; i++) {
if (Spielfeld.Feld[zeile, i] != Spielfeld.Feld[zeile, spalte]) {
break;
} else if (i == e + 3) {
Spielfeld.GameOver = true;
return Spielfeld;
} // else if End
} // for End
// Gewinn in einer Spalte?
for (int i = 1; i < 5 && i+zeile < 6; i++) {
if (Spielfeld.Feld[i+zeile, spalte] != Spielfeld.Feld[zeile, spalte]) {
break;
} else if (i == 3) {
Spielfeld.GameOver = true;
return Spielfeld;
} // else if End
} // for End
// Gewinn Diagonal?
int diagonal = 1;
for (int i = 1; i < 5 && spalte - i > 0 && zeile - i > 0; i++) {
if (Spielfeld.Feld[zeile - i, spalte - i] == Spielfeld.Feld[zeile, spalte]) {
diagonal++;
} else {
break;
} // else End
} // for End
for (int i = 1; i < 5 && spalte + i < 7 && zeile + i < 6; i++) {
if (Spielfeld.Feld[zeile + i, spalte + i] == Spielfeld.Feld[zeile, spalte]) {
diagonal++;
} else {
break;
} // else End
} // for End
if (diagonal >= 4) {
Spielfeld.GameOver = true;
return Spielfeld;
} // if End
diagonal = 1;
for (int i = 1; i < 5 && spalte - i > 0 && zeile + i < 6; i++) {
if (Spielfeld.Feld[zeile + i, spalte - i] == Spielfeld.Feld[zeile, spalte]) {
diagonal++;
} else {
break;
} // else End
} // for End
for (int i = 1; i < 5 && spalte + i < 7 && zeile - i > 0; i++) {
if (Spielfeld.Feld[zeile - i, spalte + i] == Spielfeld.Feld[zeile, spalte]) {
diagonal++;
} else {
break;
} // else End
} // for End
if (diagonal >= 4) {
Spielfeld.GameOver = true;
return Spielfeld;
} // if End
return Spielfeld;
}
static void Main(string[] args) {
// Neues Spielfeld
Spielfeld Spielfeld = NeuesSpiel();
// Ausgabe
Console.WriteLine("Willkommen bei 4 Gewinnt!\n\n"+
"Um ein neues Spiel zu starten drücke eine beliebige Taste...");
while (!Console.KeyAvailable) { }
while (true) {
Spielfeld = NeuesSpiel();
while (!Spielfeld.GameOver) {
// 1 Zug setzen
Spielfeld = Zug(Spielfeld);
} // while End
Console.Clear();
if (Spielfeld.Spieler == 1)
Console.Write("Spieler 2 hat gewonnen!");
else
Console.Write("Spieler 1 hat gewonnen!");
Spielfeld.GameOver = false;
Console.Write("\n\n\nDrücke eine beliebige Taste um ein neues Spiel zu starten!");
while (!Console.KeyAvailable) { }
} // while End
}
}
}
straightforward hingeklatscht :D, sollte aber gegen Falscheingaben geschützt sein. AI Integration würde sich schwierig gestalten
C#-Code
C#-Code
public static int[][] grid = new int[3][];
public static Dictionary<int, string> drawingCharacters = new Dictionary<int, string>();
public static int currentPlayer;
public static int turn;
public static bool[] feldBesetzt;
static void Main(string[] args)
{
Initiate();
DrawGrid();
while (WhoIsTheWinner() == "nobody" && turn < 9)
{
MakeTurn();
if (currentPlayer == 1)
currentPlayer = 2;
else
currentPlayer = 1;
}
Console.WriteLine(WhoIsTheWinner() + " Wins!");
Console.ReadLine();
}
private static string WhoIsTheWinner()
{
if ((grid[0][0] == 1 && grid[0][1] == 1 && grid[0][2] == 1) || (grid[1][0] == 1 && grid[1][1] == 1 && grid[1][2] == 1) || (grid[2][0] == 1 && grid[2][1] == 1 && grid[2][2] == 1) || (grid[0][0] == 1 && grid[1][0] == 1 && grid[2][0] == 1) || (grid[0][1] == 1 && grid[1][1] == 1 && grid[2][1] == 1) || (grid[0][2] == 1 && grid[1][2] == 1 && grid[2][2] == 1) || (grid[0][0] == 1 && grid[1][1] == 1 && grid[2][2] == 1) || (grid[0][2] == 1 && grid[1][1] == 1 && grid[2][0] == 1))
{
return "Player 1";
}
else if ((grid[0][0] == 2 && grid[0][1] == 2 && grid[0][2] == 2) || (grid[1][0] == 2 && grid[1][1] == 2 && grid[1][2] == 2) || (grid[2][0] == 2 && grid[2][1] == 2 && grid[2][2] == 2) || (grid[0][0] == 2 && grid[1][0] == 2 && grid[2][0] == 2) || (grid[0][1] == 2 && grid[1][1] == 2 && grid[2][1] == 2) || (grid[0][2] == 2 && grid[1][2] == 2 && grid[2][2] == 2) || (grid[0][0] == 2 && grid[1][1] == 2 && grid[2][2] == 2) || (grid[0][2] == 2 && grid[1][1] == 2 && grid[2][0] == 2))
{
return "Player 2";
}
return "nobody";
}
private static void MakeTurn()
{
bool inputOk = false;
string input;
int chosenField = 0;
while (!inputOk)
{
Console.Write("Player " + currentPlayer + ": ");
input = Console.ReadLine();
if ((input == "1" || input == "2" || input == "3" || input == "4" || input == "5" || input == "6" || input == "7" || input == "8" || input == "9"))
{
chosenField = Int32.Parse(input);
if (!feldBesetzt[chosenField-1])
inputOk = true;
else
Console.WriteLine("Falsche Eingabe\n");
}
else
{
Console.WriteLine("Falsche Eingabe\n");
}
}
AddTurnToGrid(chosenField);
DrawGrid();
turn++;
}
private static void AddTurnToGrid(int chosenField)
{
feldBesetzt[chosenField - 1] = true;
switch (chosenField)
{
case 1:
grid[0][0] = currentPlayer;
break;
case 2:
grid[0][1] = currentPlayer;
break;
case 3:
grid[0][2] = currentPlayer;
break;
case 4:
grid[1][0] = currentPlayer;
break;
case 5:
grid[1][1] = currentPlayer;
break;
case 6:
grid[1][2] = currentPlayer;
break;
case 7:
grid[2][0] = currentPlayer;
break;
case 8:
grid[2][1] = currentPlayer;
break;
case 9:
grid[2][2] = currentPlayer;
break;
default:
break;
}
}
private static void Initiate()
{
grid[0] = new int[] { 0, 0, 0 };
grid[1] = new int[] { 0, 0, 0 };
grid[2] = new int[] { 0, 0, 0 };
drawingCharacters.Add(1, "X");
drawingCharacters.Add(2, "O");
currentPlayer = 1;
turn = 0;
feldBesetzt = new bool[9]{false, false, false, false, false, false, false, false, false};
}
private static void DrawGrid()
{
Console.Clear();
Console.WriteLine("\n " + GetString(0, 0) + " | " + GetString(0, 1) + " | " + GetString(0, 2) + " ");
Console.WriteLine(" ---|---|---");
Console.WriteLine(" " + GetString(1, 0) + " | " + GetString(1, 1) + " | " + GetString(1, 2) + " ");
Console.WriteLine(" ---|---|---");
Console.WriteLine(" " + GetString(2, 0) + " | " + GetString(2, 1) + " | " + GetString(2, 2) + " \n\n");
}
private static string GetString(int row, int column)
{
if (grid[row][column] == 0)
{
return (row * 3 + column + 1).ToString();
}
else
{
return drawingCharacters[grid[row][column]];
}
} C#-Codeusing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace VierGewinnt
{
class Program
{
static void Main(string[] args)
{
//Standardwerte
bool RandomStart = true, GameEnd = false;
int Spieler = 0;
Spieler = Berechnungen.Spieler(ref RandomStart);
//HauptArray
int[,] FelderArray = new int[8, 8];
while (!GameEnd)
{
//Eingabe Für Abwurf
Oberflaeche.Anzeige(FelderArray, Spieler);
Console.WriteLine("Waehle deinen Spielzug!", Spieler);
string Eingabe = Console.ReadLine();
if (Berechnungen.ZahlValid(Eingabe))
{
Oberflaeche.Anzeige(FelderArray, Spieler);
//Spielerwahl und Abwurfaufruf
int xPos = Convert.ToInt32(Eingabe) - 1;
int yPos = 0;
while (!Berechnungen.Abwurf(FelderArray, ref Spieler, ref xPos, ref yPos, ref GameEnd))
{
Oberflaeche.Anzeige(FelderArray, Spieler);
System.Threading.Thread.Sleep(20);
}
}
}
}
class Oberflaeche
{
public static void Anzeige(int[,] FelderArray, int Spieler)
{
Console.Clear();
Console.WriteLine("- 1 - - 2 - - 3 - - 4 - - 5 - - 6 - - 7 - - 8 - [[Spieler {0}]]\n", Spieler);
for (int x1 = 0; x1 < 8; x1++)
{
Console.WriteLine("----- ----- ----- ----- ----- ----- ----- ----- ");
PrintZeile(FelderArray, x1);
Console.WriteLine("\n----- ----- ----- ----- ----- ----- ----- ----- ");
}
}
private static void PrintZeile(int[,] FelderArray, int Spaltennummer)
{
for (int x2 = 0; x2 < 8; x2++)
{
PrintZelle(FelderArray[x2, Spaltennummer]);
}
}
private static void PrintZelle(int Value)
{
if (Value == Convert.ToInt32(Berechnungen.FeldFarbe.Leer))
{
Console.Write("| | ");
}
else if (Value == Convert.ToInt32(Berechnungen.FeldFarbe.Weiss))
{
PrintStein(Value, ConsoleColor.White);
}
else if (Value == Convert.ToInt32(Berechnungen.FeldFarbe.Gelb))
{
PrintStein(Value, ConsoleColor.DarkYellow);
}
else if (Value == Convert.ToInt32(Berechnungen.FeldFarbe.Rot))
{
PrintStein(Value, ConsoleColor.Red);
}
}
private static void PrintStein(int Value, ConsoleColor Color)
{
Console.Write("- ");
Console.BackgroundColor = Color;
Console.ForegroundColor = Color;
Console.Write(Value);
Console.ResetColor();
Console.Write(" - ");
}
public static void TurnRed(int xPos, int yPos, int[,] WinningArray, int[,] FelderArray, int Spieler)
{
int xPosNew = 0;
int yPosNew = 0;
FelderArray[xPos, yPos] = (int)Berechnungen.FeldFarbe.Rot;
for (int Schleife = 0; Schleife < 8; Schleife++)
{
xPosNew = WinningArray[Schleife, 0];
yPosNew = WinningArray[Schleife, 1];
FelderArray[xPosNew, yPosNew] = (int)Berechnungen.FeldFarbe.Rot;
if (WinningArray[Schleife + 1, 0] == 0 || WinningArray[Schleife + 1, 1] == 0)
{
break;
}
}
Oberflaeche.Anzeige(FelderArray, Spieler);
Console.WriteLine("Spieler {0} hat gewonnen", Spieler);
Console.ReadLine();
}
class GameOver
{
public static bool GameOverNeu(int[,] FelderArray, int Spieler, int xPos, int yPos)
{
int[,] WinningArray = new int[8, 8];
if (SuedWestundNordOst(FelderArray, Spieler, xPos, yPos)
|| NordundSued(FelderArray, Spieler, xPos, yPos)
|| NordWestundSuedOst(FelderArray, Spieler, xPos, yPos)
|| WestundOst(FelderArray, Spieler, xPos, yPos))
{
Oberflaeche.Anzeige(FelderArray, Spieler);
return true;
}
return false; ;
}
public static bool SuedWestundNordOst(int[,] FelderArray, int Spieler, int xPos, int yPos)
{
int[,] WinningArray = new int[8, 8];
int xPosPruefen = xPos;
int yPosPruefen = yPos;
int counter = 0;
//SuedWest
for (int SW = 0; SW < 8; SW++)
{
xPosPruefen--;
yPosPruefen++;
if (ExceptionIncoming(xPosPruefen, yPosPruefen)) { break; }
if (FelderArray[xPos, yPos] == Spieler && CheckFeldGesetzt(FelderArray, xPosPruefen, yPosPruefen, Spieler))
{
WinningArray[counter, 0] = xPosPruefen;
WinningArray[counter, 1] = yPosPruefen;
counter++;
if (counter >= 3)
{
Oberflaeche.TurnRed(xPos, yPos, WinningArray, FelderArray, Spieler);
return true;
}
}
else
{
break;
}
}
xPosPruefen = xPos;
yPosPruefen = yPos;
//NordOst
for (int NO = 0; NO < 8; NO++)
{
yPosPruefen--;
xPosPruefen++;
if (ExceptionIncoming(xPosPruefen, yPosPruefen)) { break; }
if (FelderArray[xPos, yPos] == Spieler && CheckFeldGesetzt(FelderArray, xPosPruefen, yPosPruefen, Spieler))
{
WinningArray[counter, 0] = xPosPruefen;
WinningArray[counter, 1] = yPosPruefen;
counter++;
if (counter >= 3)
{
Oberflaeche.TurnRed(xPos, yPos, WinningArray, FelderArray, Spieler);
return true;
}
}
else
{
break;
}
}
return false;
}
public static bool NordundSued(int[,] FelderArray, int Spieler, int xPos, int yPos)
{
int[,] WinningArray = new int[8, 8];
int xPosPruefen = xPos;
int yPosPruefen = yPos;
int counter = 0;
//Nord
for (int N = 0; N < 8; N++)
{
yPosPruefen--;
if (ExceptionIncoming(xPosPruefen, yPosPruefen)) { break; }
if (FelderArray[xPos, yPos] == Spieler && CheckFeldGesetzt(FelderArray, xPosPruefen, yPosPruefen, Spieler))
{
WinningArray[counter, 0] = xPosPruefen;
WinningArray[counter, 1] = yPosPruefen;
counter++;
if (counter >= 3)
{
Oberflaeche.TurnRed(xPos, yPos, WinningArray, FelderArray, Spieler);
return true;
}
}
else
{
break;
}
}
xPosPruefen = xPos;
yPosPruefen = yPos;
//Sued
for (int S = 0; S < 8; S++)
{
yPosPruefen++;
if (ExceptionIncoming(xPosPruefen, yPosPruefen)) { break; }
if (FelderArray[xPos, yPos] == Spieler && CheckFeldGesetzt(FelderArray, xPosPruefen, yPosPruefen, Spieler))
{
WinningArray[counter, 0] = xPosPruefen;
WinningArray[counter, 1] = yPosPruefen;
counter++;
if (counter >= 3)
{
Oberflaeche.TurnRed(xPos, yPos, WinningArray, FelderArray, Spieler);
return true;
}
}
else
{
break;
}
}
return false;
}
public static bool NordWestundSuedOst(int[,] FelderArray, int Spieler, int xPos, int yPos)
{
int[,] WinningArray = new int[8, 8];
int xPosPruefen = xPos;
int yPosPruefen = yPos;
int counter = 0;
//NordWest
for (int NW = 0; NW < 8; NW++)
{
yPosPruefen--;
xPosPruefen--;
if (ExceptionIncoming(xPosPruefen, yPosPruefen)) { break; }
if (FelderArray[xPos, yPos] == Spieler && CheckFeldGesetzt(FelderArray, xPosPruefen, yPosPruefen, Spieler))
{
WinningArray[counter, 0] = xPosPruefen;
WinningArray[counter, 1] = yPosPruefen;
counter++;
if (counter >= 3)
{
Oberflaeche.TurnRed(xPos, yPos, WinningArray, FelderArray, Spieler);
return true;
}
}
else
{
break;
}
}
xPosPruefen = xPos;
yPosPruefen = yPos;
//SuedOst
for (int SO = 0; SO < 8; SO++)
{
yPosPruefen++;
xPosPruefen++;
if (ExceptionIncoming(xPosPruefen++, yPosPruefen)) { break; }
if (FelderArray[xPos, yPos] == Spieler && CheckFeldGesetzt(FelderArray, xPosPruefen++, yPosPruefen, Spieler))
{
WinningArray[counter, 0] = xPosPruefen++;
WinningArray[counter, 1] = yPosPruefen;
counter++;
if (counter >= 3)
{
Oberflaeche.TurnRed(xPos, yPos, WinningArray, FelderArray, Spieler);
return true;
}
}
else
{
break;
}
}
return false;
}
public static bool WestundOst(int[,] FelderArray, int Spieler, int xPos, int yPos)
{
int[,] WinningArray = new int[8, 8];
int xPosPruefen = xPos;
int yPosPruefen = yPos;
int counter = 0;
//West
for (int W = 0; W < 8; W++)
{
xPosPruefen--;
if (ExceptionIncoming(xPosPruefen, yPosPruefen)) { break; }
if (FelderArray[xPos, yPos] == Spieler && CheckFeldGesetzt(FelderArray, xPosPruefen, yPosPruefen, Spieler))
{
WinningArray[counter, 0] = xPosPruefen;
WinningArray[counter, 1] = yPosPruefen;
counter++;
if (counter >= 3)
{
Oberflaeche.TurnRed(xPos, yPos, WinningArray, FelderArray, Spieler);
return true;
}
}
else
{
break;
}
}
xPosPruefen = xPos;
yPosPruefen = yPos;
//Ost
for (int O = 0; O < 8; O++)
{
xPosPruefen++;
if (ExceptionIncoming(xPosPruefen, yPosPruefen)) { break; }
if (FelderArray[xPos, yPos] == Spieler && CheckFeldGesetzt(FelderArray, xPosPruefen, yPosPruefen, Spieler))
{
WinningArray[counter, 0] = xPosPruefen;
WinningArray[counter, 1] = yPosPruefen;
counter++;
if (counter >= 3)
{
Oberflaeche.TurnRed(xPos, yPos, WinningArray, FelderArray, Spieler);
return true;
}
}
else
{
break;
}
}
return false;
}
public static bool ExceptionIncoming(int x, int y)
{
if (x <= -1 || y <= -1 || x >= 8 || y >= 8) { return true; }
return false;
}
public static bool CheckFeldGesetzt(int[,] Felderarray, int x, int y, int Spieler)
{
if (Felderarray[x, y] == Spieler)
return true;
return false;
}
class Berechnungen
{
public enum FeldFarbe { Leer, Weiss, Gelb, Rot }
public static bool ZahlValid(string Eingabe)
{
if (Eingabe.All(char.IsDigit) && Eingabe != "" && Convert.ToInt32(Eingabe) <= 8 && Convert.ToInt32(Eingabe) >= 1)
{
return true;
}
else
{
Console.WriteLine("Falsche Eingabe");
return false;
}
}
public static bool Abwurf(int[,] FelderArray, ref int Spieler, ref int xPos, ref int yPos, ref bool GameEnd)
{
{
if (FelderArray[xPos, 0] == (int)FeldFarbe.Leer)
{
FelderArray[xPos, yPos] = Spieler;
if (yPos <= 6 && FelderArray[xPos, yPos + 1] == (int)FeldFarbe.Leer)
{
FelderArray[xPos, yPos] = (int)FeldFarbe.Leer;
FelderArray[xPos, yPos + 1] = Spieler;
yPos++;
}
else
{
GameEnd = GameOver.GameOverNeu(FelderArray, Spieler, xPos, yPos);
Spieler = SpieleWechsel(Spieler);
return true;
}
}
else
{
Oberflaeche.Anzeige(FelderArray, Spieler);
Console.WriteLine("Zuviele Chips in der Reihe!");
Spieler = SpieleWechsel(Spieler);
return true;
}
return false;
}
}
public static int Spieler(ref bool RandomStart)
{
int Spieler = Convert.ToInt32(FeldFarbe.Weiss);
if (RandomStart)
{
Random rand = new Random();
Spieler = rand.Next(1, 3);
RandomStart = false;
}
return Spieler;
}
public static int SpieleWechsel(int Spieler)
{
if (Spieler == Convert.ToInt32(FeldFarbe.Gelb))
{
Spieler = Convert.ToInt32(FeldFarbe.Weiss);
}
else if (Spieler == Convert.ToInt32(FeldFarbe.Weiss))
{
Spieler = Convert.ToInt32(FeldFarbe.Gelb);
}
return Spieler;
}
}
}
C#-Code
using System;
class Spiel
{
class Feld
{
public string[,] Spielfeld = new string[10, 18];
public Feld()
{
for (int j = 0; j < 10; j++)
{
for (int i = 0; i < 18; i += 1)
{
if (i % 2 == 0) Spielfeld[j, i] = "|";
else Spielfeld[j, i] = " ";
}
}
for (int j = 0; j < 10; j++)
{
for (int i = 0; i < 18; i += 1)
{
Console.Write(Spielfeld[j, i]);
}
Console.Write("\n");
}
Console.WriteLine(" 1 2 3 4 5 6 7 8");
}
public void ausgabe()
{
for (int j = 0; j < 10; j++)
{
for (int i = 0; i < 18; i += 1)
{
Console.Write(Spielfeld[j, i]);
}
Console.Write("\n");
}
Console.WriteLine(" 1 2 3 4 5 6 7 8");
}
public bool auswerten(string[,] Spiel)
{
//prüfen ob 4 gleiche nebeneinander
//array waagerecht
string[] wg = new string[80];
int k = 0;
for (int j = 0; j < 10; j++)
{
for (int i = 1; i < 16; i += 2)
{
wg[k] = Spiel[j, i];
k += 1;
}
}
//array senkrecht
string[] sk = new string[80];
k = 0;
for (int j = 1; j < 16; j+=2)
{
for (int i = 0; i < 10; i ++)
{
sk[k] = Spiel[i, j];
k += 1;
}
}
//array diagonal links nach rechts
string [] dl = new string[160];
k = 0;
for (int h = 0; h<9; h++)
{
int i = h;
int j = 1;
do
{
dl[k] = Spiel[i, j];
k++;
i++;
j+=2;
}
while (i<9);
dl [k] = " ";
k++;
}
for (int h = 3; h<=16; h+=2)
{
int j = h;
int i = 0;
do
{
dl[k] = Spiel[i, j];
k++;
i++;
j+=2;
}
while (j<=16);
dl [k] = " ";
k++;
}
//rechts nach links
for (int h = 0; h<9; h++)
{
int i = h;
int j = 17;
do
{
dl[k] = Spiel[i, j];
k++;
i++;
j-=2;
}
while (i<9);
dl [k] = " ";
k++;
}
for (int h = 15; h<=16; h+=2)
{
int j = h;
int i = 0;
do
{
dl[k] = Spiel[i, j];
k++;
i++;
j+=2;
}
while (j<=16);
dl [k] = " ";
k++;
}
//prüfen ob vier gleiche nebeneinander
int Reihewaagerecht = 1;
int Reihesenkrecht = 1;
int Reihediagonal = 1;
Console.WriteLine(wg.Length + " " + sk.Length + " " + dl.Length);
int s = 0;
while (s < wg.Length)
{
if ((wg[s] == "O" || wg[s] == "X") && (wg[s] == wg[s + 1])) Reihewaagerecht += 1;
else Reihewaagerecht = 1;
if ((sk[s] == "O" || sk[s] == "X") && (sk[s] == sk[s + 1])) Reihesenkrecht += 1;
else enkrecht = 1;
if (Reihewaagerecht == 4 || Reihesenkrecht == 4 )
{
Console.WriteLine("GEWONNEN");
return true;
}
s++;
}
s = 0;
while (s < dl.Length)
{
if (dl[s] == "O" || dl[s] == "X") Reihediagonal += 1;
else Reihediagonal = 1;
if (Reihediagonal == 4 )
{
Console.WriteLine("GEWONNEN");
return true;
}
s++;
}
return false;
}
}
class Spieler
{
string Name;
public string Sign;
public Spieler(string Name, string Sign)
{
this.Name = Name;
this.Sign = Sign;
}
public int amZug()
{
Console.WriteLine("Spieler {0}: Spalte?", Name);
int spal = Int32.Parse(Console.ReadLine());
return spal;
}
}
static void Main()
{
Spieler AA = new Spieler("A", "X");
Spieler BB = new Spieler("B", "O");
Feld A = new Feld();
int spalte;
bool Ende = false;
while (!Ende)
{
spalte = AA.amZug()*2-1;
for (int j = 9; j >= 0; j--)
{
if (A.Spielfeld[j, spalte] == "|")
{
Console.WriteLine("ungültig");
break;
}
else if (A.Spielfeld[j, spalte] == " ")
{
A.Spielfeld[j, spalte] = AA.Sign;
break;
}
else if (A.Spielfeld[j, spalte] == "X" || A.Spielfeld[j, spalte] == "O")
{
continue;
}
}
A.ausgabe();
Ende = A.auswerten(A.Spielfeld);
if(!Ende)
{
spalte = BB.amZug()*2-1;
for (int j = 9; j >= 0; j--)
{
if (A.Spielfeld[j, spalte] == "|")
{
Console.WriteLine("ungültig");
break;
}
if (A.Spielfeld[j, spalte] == " ")
{
A.Spielfeld[j, spalte] = BB.Sign;
break;
}
else if (A.Spielfeld[j, spalte] == "X" || A.Spielfeld[j, spalte] == "O")
{
continue;
}
}
A.ausgabe();
Ende = A.auswerten(A.Spielfeld);
}
else break;
}
}
}