Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von mvenus
Thema: Vier gewinnt auswertung
Am im Forum: Code-Reviews

Hallo zusammen,

ich habe heute mein erstes kleines C#-Programm geschrieben.
Da ich noch sehr neu in der OOP im allgemeinen bin, wollte ich mal fragen, was ihr für Verbesserungsvorschläge habt :)

Es handelt sich um die Auswertung eines "Vier Gewinnt" Spielfelds. Hier soll geprüft werden, ob es einen Gewinner gibt und wenn ja, welcher Spieler es ist.

Ich würde mich über konstruktive Kritik freuen :) Vielen Dank!

LG


 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace VierGewinnt
 {
     class Program
     {
         static void Main()
         {
             // Beispiel
             int[,] board = new int[6, 7] {
                 { 0, 0, 0, 0, 0, 0, 0 },
                 { 0, 0, 0, 0, 0, 0, 0 },
                 { 0, 2, 0, 0, 1, 0, 0 },
                 { 1, 2, 1, 1, 2, 1, 1 },
                 { 1, 2, 1, 2, 2, 1, 2 },
                 { 1, 1, 2, 1, 1, 1, 2 }
               };
 
             VierGewinnt game = new VierGewinnt(board);
 
             if (game.GameEnded)
             {
                 Console.WriteLine("Gewinner ist Spieler " + game.Winner + ".");
             }
             else
             {
                 Console.WriteLine("Es gibt (noch) keinen Gewinner.");
             }            
 
             Console.ReadKey();
         }
     }
 
     class VierGewinnt
     {
         // Board kann mit einem beliebig großem Array befüllt werden. 0 steht für nicht belegte Felder. 1 bzw. 2 symbolisiert die belegten Felder durch die einzelnen Spieler.
         public int[,] Board { get; set; }
         public int Winner { get; set; }
         public bool GameEnded { get; set; }
 
         public VierGewinnt(int[,] _board)
         {
             Board = _board;
             CheckForWinner();
         }
 
        
         // Ermittelt den Gewinner des Spiels (falls vorhanden)    
         private void CheckForWinner()
         {
             int boardWidth = Board.GetLength(0);
             int boardHeight = Board.GetLength(1);
 
             // Prüfung der Horizontalen 
             for (int y = 0; y < boardHeight - 3; y++)
             {
                 for (int x = 0; x < boardWidth; x++)
                 {
                     int currPlayer = Board[x, y];
                     if (Board[x, y] != 0 && Board[x, y + 1] == currPlayer && Board[x, y + 2] == currPlayer && Board[x, y + 3] == currPlayer)
                     {
                         GameEnded = true;
                         Winner = currPlayer;
                     }
                 }
             }
 
             // Prüfung der Vertikalen
             for (int x = 0; x < boardWidth - 3; x++)
             {
                 for (int y = 0; y < boardHeight; y++)
                 {
                     int currPlayer = Board[x, y];
                     if (Board[x, y] != 0 && Board[x + 1, y] == currPlayer && Board[x + 2, y] == currPlayer && Board[x + 3, y] == currPlayer)
                     {
                         GameEnded = true;
                         Winner = currPlayer;
                     }
                 }
             }
 
             // Pfrüfung der Diagonalen (aufsteigend)
             for (int x = 3; x < boardWidth; x++)
             {
                 for (int y = 0; y < boardHeight - 3; y++)
                 {
                     int currPlayer = Board[x, y];
                     if (Board[x, y] != 0 && Board[x - 1, y + 1] == currPlayer && Board[x - 2, y + 2] == currPlayer && Board[x - 3, y + 3] == currPlayer)
                     {
                         GameEnded = true;
                         Winner = currPlayer;
                     }
                 }
             }
 
             // Prüfung der Diagonalen (absteigend)
             for (int x = 3; x < boardWidth; x++)
             {
                 for (int y = 3; y < boardHeight; y++)
                 {
                     int currPlayer = Board[x, y];
                     if (Board[x, y] != 0 && Board[x - 1, y - 1] == currPlayer && Board[x - 2, y - 2] == currPlayer && Board[x - 3, y - 3] == currPlayer)
                     {
                         GameEnded = true;
                         Winner = currPlayer;
                     }
                 }
             }
         }
     }
 }