Othello

public class ProThello{


    // 1 c)
        // Variable: Zustand, bzw. Farbe
        // Für jeden Zustand, bzw. Farbe eines Spielsteins definieren
        // Sie eine (ausnahmsweise!) static Variable. Diese können
        // Sie dann in jeder static Prozedur oder static Funktion
        // aufrufen.

    static char schwarz= 's';
    static char weiss  = 'w';
    static char leer   = ' ';

        // Variable: Variable String whos_turn
        // Variable, die angibt wessen Zug es ist. Schwarz fängt
        // bei Spielanfang an, desshalb ist black_turn als "default" definiert

    static char turn = schwarz;


    /**
     * Hauptprozedur, die das Spiel startet,
     * bzw. alle Funktionen und Prozeduren testet.
     * @param args Parameter beim Aufruf durch die Kommandozeile
     * */
    public static void main(String[] args){

        // Array 2D: Definition des Spielfelds
        // Spielfeld als ein 2-dimensionales Array von char

        char field [][] = new char [8][8];  // array mit 8x8 Stellen

        clear_field(field);
        draw_field(field);
        set_validated_stone(field,4,2);
        set_validated_stone(field,3,2);
        set_validated_stone(field,3,5);
        set_validated_stone(field,4,5);
        set_validated_stone(field,1,1);
        set_validated_stone(field,2,2);
        set_validated_stone(field,7,7);
        set_validated_stone(field,3,1);
        set_validated_stone(field,3,0);

        draw_field(field);


    }

    // Fügen Sie hier alle Ihre Prozeduren und Funktionen
    // zur Lösung ein

    // b) brauchbare Infos
    // Spielfeld 8x8: char [0][0] bis char [7][7] Informationen
    // über Zustände: Ist Feld schwarz, weiß, oder leer?
    // Setzten von Steinen: Steine ändern ihre Farbe, wenn
    // sie von 2 Steinen der jeweiligen anderen Farbe eingeschlossen
    // sind.



    // 1 d) Initialisieren Spielfeld in Prozedur

        /** Procedure: Prozedur clear_field
        * In dieser Prozedur wird das Spielfeld initialisiert und die Startbelegung aufgestellt
        * @param  field, der das Spielfeld repräsentiert
        */

        static void clear_field(char field [][]){

            // Alle Felder mit  "  " füllen.

                // For-Loop: for-Schleife 1
                // für int i = 0, i <= field.length, soll i um 1 erhöht
                // werden.

                for (int i = 0; i < field.length; i++){

                    // For-Loop: for-Schleife 2
                    // Für int j = 0; j< field[i].length, soll j um 1 erhöht
                    // werden.

                    for (int j = 0; j < field[i].length; j++){

                        // Feld auf leer setzen
                        // durch field [i][j] wird jedes Feld einzeln mit "leer" (' ')
                        // gefüllt

                        field[i][j] = leer;

                    }
                }


                // Startbelegung
                // für die Startbelegung wird Feld D4 ([3][3]), E4 ([4][3]),
                // D5 ([3][4]) und E5 ([4][4]) jeweils mit schwarz oder
                // weiß, entsprechend des Regelwerts, gefüllt.

                field[3][3] = schwarz;
                field[3][4] = weiss;        // s w
                field[4][4] = schwarz;      // w s
                field[4][3] = weiss;

        }   // ende clear_field


    // 1 e) Spielfeld auf Konsole darstellen

        /** Procedure: Prozedur draw_field
        * In diese Prozedur wird das Spielfeld auf die Konsole
        * ausgegeben
        * @param field, der das Spielfeld im aktuellen Zustand representiert
        */

        static void draw_field(char field [][]){

            // For-Loop: for-Schleife 1
            // für (int i; i < field.length, soll i um 1 erhöht werden

            for (int i = 0; i < field.length; i++){

                // Überschrift ( A - H)
                // 'A' + i wird auf die Konsole ausgeben. So entsteht
                // Eine Überschrift der Spalten A - H des Spielfeldes

                // For-Loop: for-Schleife 2
                // für int j = 0; j < field[i].length, soll j um 1 erhöht
                // werden

                for (int j = 0; j < field[i].length; j++){

                    // Spielfeld ausgeben
                    // Mit field [i][j] wird durch die for-Schleifen, das
                    // Spielfeld ausgegeben.

                    System.out.print("| " + field[i][j] + " ");
                }

                System.out.println("|");    // Nach jeder Zeile, ein Zeilenumbruch
                System.out.println("");
            }



        }   // ende draw_field


    // 1 f)

        /** Procedure: Prozedur set_stone
        * In dieser Prozedur soll ein Stein, an angegebener Stelle, gesetzt
        * werden
        * @param field, der das Spielfeld repräsentiert
        * @param  row, als Zeilen Koordinate
        * @param  col, als Spalten-Koordinate
        */
/*
        static void set_stone(char field[][], int row, int col){


            // If-Else: if-Abfrage: Wessen Zug?
            // Falls die String Variable whos_turn true ist, ist
            // schwarz dran: Es wird ein schwarzer Stein gelegt.
            // Andernfalls wird ein weisser Stein gelegt.

            if (whos_turn){

                // field an der Position row,col auf schwarz

                field[row][col] = schwarz;

                // nach dem Zug wird die String Variable whos_turn
                // auf "white_turn" (weisser Zug) gesetzt

                whos_turn = false;

            }
            else {

                field[row][col] = weiss;
                whos_turn = true;
            }

        }   // ende set_stone


        */




    // 1 g)

        /** Procedure: Prozedur turn_stone
        * Prozedur, die einen vorhandenen Stein umdreht
        * @param field, der das Spielfeld repräsentiert
        * @param row, Koordinate
        * @param col, Koordinate
        */

        static void turn_stone(char field [][], int row, int col){

            // If-Else: if-Abfrage
            // Wenn ein Stein an einer angegebenen Stelle schwarz
            // ist, soll er auf weiss gesetzt werden falls nicht,
            // dann umgekehrt

            if (field[row][col] == schwarz){

                field[row][col] = weiss;
            }
            else {

                field[row][col] = schwarz;
            }

        }   // ende turn_stone


    // 2 a + b) Position prüfen

        static boolean in_field(char field[][], int row, int col){


            return(row < field.length && col < field[0].length
                   && row > 0 && col > 0);

        }




        /** Procedure: set_validated_stone
        * Kopie der Setz-Prozedur aus 1 f) mit Prüfung, ob angegebener
        * Stein im Feld liegt.
        * @param field, der das Spielfeld repräsentiert
        * @param row, Koordinate
        * @param col, Koordinate
        */

        static void set_validated_stone(char field[][], int row, int col){

            // If: if-Abfrage: Wessen Zug? + Position
            // turn Variable: wahr -> schwarz ist dran. false
            // -> weiss ist dran + ist angegebener Position im Spielfeld?

            if(in_field(field,row,col)){

                if(is_empty(field,row,col)){

                    if(my_color(field,row,col,turn) == false){

                        if(surrounding_right(field,row,col) || surrounding_left(field,row,col)){

                                if(turn == schwarz){

                                    field[row][col] = schwarz;
                                    turn = weiss;   // weiss ist als nächstes am Zug

                                }
                                else {

                                    field[row][col] = weiss;
                                    turn = schwarz; // schwarz ist als nächstes am Zug

                                }

                        }
                    }
                }
            }

        }   // ende set_validated_stone



    // 2 c) Farbe an Position?

        /** Function: Funktion boolean my_color
        * In dieser Funktion wird die Farbe eines Steins, an
        * angegebener Position ermittelt
        *
        * @param char field[][]:
        * das Spielfeld
        *
        * @param int row: Koordinate @param int
        * col: Koordinate
        *
        */

        static boolean my_color(char field [][], int row, int col, char turn){

            // Variable: String Variable my_color
            // vorsichtshalter auf false, für den Fehlerfall

            boolean my_color = false;

            // If-Else: if-Abfrage:
            // Es wird abgefragt, ob der Stein, an angegebener Stelle,
            // schwarz ist. Je nachdem wessen Zug es ist, wird entschieden,
            // ob der jeweilige Stein self (eigener) oder enemy (gegnerisch) ist


                if (field[row][col] == turn){

                    my_color = true;
                }
                else {

                    my_color = false;
                }


            // Rückgabewert: Farbe
            return my_color;

        }   // ende my_color


    // 2 d)

        /** Function: Funktion is_empty
        * Diese Funktion gibt an, ob an angegebener Stelle kein
        * Stein liegt, d.h. ob dieser Platz frei ist.
        * @param char field [][]: das Spielfeld
        * @param int row: Koordinate
        * @param int col: Koordinate
        */

        static boolean is_empty(char field[][], int row, int col){

            // Variable: String Variable state

            boolean state;

            // If-Else: if-Abfrage: Stelle leer?
            // Wenn der Array, an angegebener Stelle leer (' ') ist,
            // wird der Rückgabestring auf "empty" gesetzt. Andernfalls
            // auf "full"

            if (field[row][col] == leer){

                state = true;
            }
            else {

                state = false;
            }

            // Rückgabewert: state
            return state;

        }   // ende is_empty



    // 2 e) nach rechts prüfen

        /** Funktion: Funktion surrounding_right
        * In dieser Funktion wird geprüft, ob ein neuer Stein
        * rechts in horizontaler Richtung gegnerische (enemy)
        * Steine einschließt.
        * @param char field: das Spielfeld
        * @param int row: Koordinate, des betrachteten Steins
        * @param int col: Koordinate des betrachteten Steins
        * Rückgabewert: boolean surrounding
        */

        static boolean surrounding_right(char field[][], int row, int col){

            // Variable: boolean Variable surrounding für return
            // vorsichtshalber auf false, damit nicht im Fehlerfall
            // fällschlicherweise true geliefert wird

            boolean surrounding = false;

            col = col + 1;

            while (col < field[row].length && my_color(field,row,col,turn) == false){



                if (is_empty(field,row,col)== false){

                    my_color(field,row,col,turn);
                    surrounding = true;

                }
                else {

                    surrounding = false;
                }

                col++;
            }

            System.out.println(surrounding);
            return surrounding;
        }



    // 2 f) nach links prüfen

        /** Funktion: Funktion surrounding_left
        * In dieser Funktion wird geprüft, ob ein neue Stein
        * links in horizontaler Richtung gegnerische (enemy)
        * Steine einschließt.
        * @param field: das Spielfeld
        * @param row: Koordinate, des betrachteten Steins
        * @param col: Koordinate des betrachteten Steins
        * Rückgabewert: surrounding
        */

        static boolean surrounding_left(char field[][], int row, int col){

            // Variable: boolean Variable surrounding für return
            // vorsichtshalber auf false, damit nicht im Fehlerfall
            // fällschlicherweise true geliefert wird

            boolean surrounding = false;

            col = col -1;

            while (col > 0 && my_color(field,row,col,turn)== false){


                if (is_empty(field,row,col)== false){

                    my_color(field,row,col,turn);
                    surrounding = true;
                }
                else {

                    surrounding = false;
                }
                col--;

            }

            System.out.println(surrounding);
            return surrounding;
        }




}