Examples of hexenschach.board.Board

hexenschach.board.Board
Diese Klasse verwaltet das Spielbrett und benutzt dafür die Klasse TweLi um das Spielbrett aufzubauen. Einzelfelder werden über eine Hash Map direkt mit den TweLi-Objekten verknüpft um nicht alle Felder durchlaufen zu müssen. Außerdem: Test für SVN @author ulbr6596

        Player player3;
        // Das Gameplay das später zurück gegeben wird
        Gameplay gameplay;


        // Brett wird erzeugt
        board = new Board();


      pref = Preferences.userNodeForPackage(getClass());
        // Der Eintrag wird zwischengespeichert. Wird keiner gefunden wird "nix gefunden" zurück gegeben
        String loadedGameString = pref.get(gameName, "nix gefunden");
        //System.out.println(loadedGameString);

View Full Code Here

        
        // Default: first currentPlayer = player1
        currentPlayer = 1;
        
        // Am Anfang eines Spieles wird ein neues Board erzeugt
        board = new Board();
        
        // setzen des ersten GameContextes
        currentContext = new GameContext (board, player1, player2, player3, currentPlayer);


        // Neue UndoRedo Liste wird erzeugt

View Full Code Here

        // Durchläuft alle Spielsituationen.
        for(int i = 0; i < pTurnPossibilities.getLength(); i++){


            currentTP = pTurnPossibilities.getTP(i);
            fieldCoord = currentTP.to;                   // Koordinate der gezogenen Figur setzen.
            Board currentBoard = currentTP.boardafter;   // Board-Objekt des TPs


            System.out.println("CurrentTP: "+currentTP);


            int points = 0;                              // Variable, die Punkte speichert.

View Full Code Here

            System.out.println("LÄNGE: "+possibleFigureMove.length);


            // Solange, wie Zugmöglichkeiten bestehen:
            for(int i = 0; i < possibleFigureMove.length; i++){
                fieldCoord = currentTP.to;                               // Koordinate der gezogenen Figur setzen.
                Board currentBoard = possibleFigureMove[i].boardafter;   // Board-Objekt des TPs
                System.out.println("------------- Evaluate 2 -------------");
                System.out.println("AKTUELLER TP: "+currentTP);
                System.out.println("ZÄHLER: "+i);


                // Prüfvariable für bestimmte Situationen

View Full Code Here

         * gewertet.
         */


        int points = 0;                     // Gesamtpunktzahl, Startwert: 0
        int checkedPoints[] = new int[3];   // Schachpunktzahl, Indexe: 0 - Punkte, 1-2-3 - geschachte Spieler
        Board analyzedBoard;                // Das zu analysierende Spielbrett


        // Prüfen, ob ein Zugvorschlag oder das aktuelle Spielbrett überprüft werden soll.
        // Es wird beiden eine einheitliche Variable zugewiesen.
        if(pCurrentBoard == null)
            analyzedBoard = currentTP.boardafter;
        else
            analyzedBoard = pCurrentBoard;


        
        // Feldkoordinaten der Hashmap durchlaufen
        for(int coord = 0; coord < HexenschachPanel.FIELD_NAMES.length; coord++){
            // Zu analysierende Koordinate anfordern
            String analyzedCoord = HexenschachPanel.FIELD_NAMES[coord];


            // Prüfen, ob die Koordinate existiert
            if(analyzedBoard.boardHM.get(analyzedCoord) != null){


                // Prüfalgorithmus
                  if(analyzedBoard.getPlayer(analyzedCoord) != pCurrentPlayer){                             // Prüfe: Figur nicht vom aktiven Spieler?
                    Figure enemyFigure = analyzedBoard.getFigure(analyzedCoord);                            // Zu ziehende Gegnerfigur bestimmen
                    if(enemyFigure != null){                                                                // Wenn Figur auf dem Feld steht...


                        // Alle möglichen Züge der Figur anfordern und prüfen, ob Züge bestehen
                        TurnPossibility possibleFigureMove[] = analyzedBoard.calculateTurnPossibility(analyzedCoord);
                        if(possibleFigureMove != null){


                            for(int i = 0; i < possibleFigureMove.length; i++){                             //Zugmöglichkeiten Gegnerfigur durchlaufen


                                TurnPossibility currentMove = possibleFigureMove[i];                        // Aktueller Zug der zu analysierenden Figur
                                String currentMoveCoord = currentMove.to;                                   // Koordinate, zu der die Figur hingezogen ist


                                if(currentMoveCoord.equals(pField)){                                        // Kommt Gegnerfigur auf die Koordinate der gezogenen Figur im Zugvorschlag?
                                    points = points - Ballancing.valueOf(enemyFigure.getType())*2;          // Figurwert von Gesamtwertung abzeihen.
                                    if(analyzedBoard.getFigureType(pField).equals("king")){
                                        ThreateningFigures.add(currentMoveCoord);                           // Koordinate der Gegnerfigur für Schachmatterkennung speichern
                                    }
                                }


                                // Auf Schach prüfen
                                String enemyFigureStr = analyzedBoard.getFigureType(analyzedCoord);         // Gegnerfigur-Typ herausfinden
                                if(enemyFigureStr.equals("king")){                                          // prüfen, ob Figur ein König ist.
                                    checkedPoints = checked(analyzedBoard);                                 // Schach setzen
                                    points = points + checkedPoints[0];                                     // Punkte für Schach anrechnen.
                                }
                            }

View Full Code Here

         * Schach-Status in das Array situation[] geschrieben wird.
         */


        int points = 0;                                            // Gesamtpunktzahl, Startwert: 0
        int checkedPoints[] = new int[3];                          // Schachpunktzahl
        Board analyzedBoard = null;                                // Das zu analysierende Spielbrett


        if(pCurrentBoard == null)
            analyzedBoard = currentTP.boardafter;
        else
            analyzedBoard = pCurrentBoard;


        thisFigure = analyzedBoard.getFigure(fieldCoord);   // zu analysierende eigene Figur
        String enemyFigure;                                        // Typ der Gegnerfigur


        // Alle möglichen Züge der Figur anfordern
        TurnPossibility possibleFigureMove[] = analyzedBoard.calculateTurnPossibility(fieldCoord);
        if(possibleFigureMove != null){                                                             // Prüfen, ob Zugmöglichkeiten bestheen
            for(int i = 0; i < possibleFigureMove.length; i++){                                     // Solange die Figur eine Zugmöglichkeit hat...


                TurnPossibility currentMove = possibleFigureMove[i];                                // Aktueller Zug der zu analysierenden Figur
                String currentMoveCoord = currentMove.to;                                           // Koordinate, zu der die Figur hingezogen ist


                if(currentMove.wasHit == true){                                                     // Wurde bei dem Zug eine Figur geschlagen?
                                                                                                    // Was für eine?
                    // Schachprüfung durchführen
                    enemyFigure = analyzedBoard.getFigureType(currentMoveCoord);                    // Auslesen des Figurtyps vom Gegner.
                    if(enemyFigure.equals("king")){                                                 // prüfen, ob Figur ein König ist.
                        checkedPoints = checked(null);                                              // Schach setzen
                        points = points + checkedPoints[0];                                         // Punkte für Schach anrechnen.
                    }
                    else{

View Full Code Here

         * Fall sollten die Figuren, je höher ihr Wert ist, umso niedriger bewertet werden.
         */


        int points = 0;                                            // Gesamtpunktzahl, Startwert: 0


        Board boardWithout = pCurrentBoard.without(fieldCoord);    // Zu analysierende Figur löschen, um Zug auf die Koordinate zu ermöglichen


        // Feldkoordinaten der Hashmap durchlaufen
        for(int coord = 0; coord < HexenschachPanel.FIELD_NAMES.length; coord++){
            // Zu analysierende Koordinate anfordern
            String analyzedCoord = HexenschachPanel.FIELD_NAMES[coord];


            // Prüfen, ob die Koordinate existiert
            if(pCurrentBoard.boardHM.get(analyzedCoord) != null){


                // Prüfalgorithmus
                if(pCurrentBoard.boardHM.get(analyzedCoord) != null){                       // Wenn Figur auf dem Feld steht...
                    if(pCurrentBoard.getPlayer(analyzedCoord) == pCurrentPlayer){           // Prüfe: Figur vom aktiven Spieler?


                        Figure ownFigure = pCurrentBoard.getFigure(analyzedCoord);          // Zu ziehende eigene Figur bestimmen


                        // Alle möglichen Züge der Figur anfordern
                        TurnPossibility possibleFigureMove[] = boardWithout.calculateTurnPossibility(fieldCoord);
                        if(possibleFigureMove != null){
                            for(int i = 0; i <  possibleFigureMove.length; i++){            // Solange die Figur eine Zugmöglichkeit hat...


                                TurnPossibility currentMove = possibleFigureMove[i];        // Aktueller Zug der zu analysierenden Figur
                                if(currentMove.to.equals(analyzedCoord)){                   // Wenn die Figur auf die zu analysierende Koordinate gelangt...

View Full Code Here


        int situation[] = new int[4];   // Indexe: 0 - Punkte, 1 - Spieler1, 2 - Spieler2, 3 - Spieler3
        int points = 0;                 // Gesamtpunktzahl, Startwert: 0


        int currentPlayer;              // Spieler, zu dem die Figur gehört.
        Board analyzedBoard = null;


        // Prüfen, ob ein Zugvorschlag oder das aktuelle Spielbrett überprüft werden soll.
        // Es wird beiden eine einheitliche Variable zugewiesen.
        if(pCurrentBoard == null)
            analyzedBoard = currentTP.boardafter;
        else
            analyzedBoard = pCurrentBoard;


        // Feldkoordinaten der Hashmap durchlaufen
        for(int coord = 0; coord < HexenschachPanel.FIELD_NAMES.length; coord++){
            // Zu analysierende Koordinate anfordern
            String analyzedCoord = HexenschachPanel.FIELD_NAMES[coord];


            // Prüfen, ob die Koordinate existiert
            if(analyzedBoard.boardHM.get(analyzedCoord) != null){
                Figure currentFigure = null;


                // Figur auf der aktuellen Koordinate erfahren
                currentFigure = analyzedBoard.getFigure(analyzedCoord);


                if(currentFigure != null){                                                  // Prüfen, ob Figur auf dem Feld steht
                    currentPlayer = analyzedBoard.getPlayer(analyzedCoord);                 // Spieler, dem die Figur gehört.


                    // Alle möglichen Züge der Figur anfordern
                    TurnPossibility possibleFigureMove[] = analyzedBoard.calculateTurnPossibility(analyzedCoord);


                    if(possibleFigureMove != null){                                             // Prüfen, ob Zugmöglichkeiten zurückgegeben worden sind
                        for(int i = 0; i < possibleFigureMove.length; i++){                     // Solange die Figur eine Zugmöglichkeit hat...


                            TurnPossibility currentMove = possibleFigureMove[i];                // Aktueller Zug der zu analysierenden Figur

View Full Code Here

         * Führen die Punkte 1-3 zu keinem Erfolg, so ist der Spieler matt.
         */


        // Situationsvariable
        int situationOf[] = new int[4];       // 0 - Punkte, 1 - Spieler1, 2 - Spieler2, 3 - Spieler3
        Board analyzedBoard = null;


        // Prüfen, ob ein Zugvorschlag oder das aktuelle Spielbrett überprüft werden soll.
        // Es wird beiden eine einheitliche Variable zugewiesen.
        if(pCurrentBoard == null)
            analyzedBoard = currentTP.boardafter;
        else
            analyzedBoard = pCurrentBoard;
        
        //*** Geschachte Spieler anfordern und deren Könige anfordern
        int checkedPlayer[] = checked(analyzedBoard);
        String kingCoord[] = findAllKings(analyzedBoard);


        // Spieler durchlaufen
        for(int player = 1; player <= 3; player++){
            if(checkedPlayer[player] == 1){                              // Ist aktueller Spieler im Schach?
                this.threatenedByEnemy(pCurrentPlayer, pCurrentBoard, kingCoord[player-1]); // Liste bilden


                int blockedKing[] = kingMovePossible(analyzedBoard);     // Bewegugnsmöglichkeiten vom König anfordern
                if(blockedKing[player-1] == 1){                          // Kann sich der König nicht bewegen?
                    
                    // Feldkoordinaten der Hashmap durchlaufen
                    for(int coord = 0; coord < HexenschachPanel.FIELD_NAMES.length; coord++){
                        // Zu analysierende Koordinate anfordern
                        String analyzedCoord = HexenschachPanel.FIELD_NAMES[coord];


                        // Prüfen, ob die Koordinate existiert
                        if(analyzedBoard.boardHM.get(analyzedCoord) != null){


                            // Sachprüfung durchführen
                            String currentFigurePlayer = analyzedBoard.getFigureType(analyzedCoord);
                            if(currentFigurePlayer != null){                                                // Wenn Figur auf dem Feld ist:
                                int playerOfFigure = analyzedBoard.getPlayer(analyzedCoord);                // Spieler, dem die Figur gehört, anfordern
                                if(playerOfFigure == pCurrentPlayer                                         // Wenn Spieler gleich dem aktiven Spieler...
                                || playerOfFigure == pCurrentPlayer++){                                     // ...oder gleich dem folgenden Spieler:


                                    // Zugmöglichkeiten der Figur anfordern und prüfen, ob welche existieren
                                    TurnPossibility possibleFigureMove[] = analyzedBoard.calculateTurnPossibility(analyzedCoord); // Alle möglichen Züge der Figur anfordern
                                    if(possibleFigureMove != null){
                                        for(int i = 0; i < possibleFigureMove.length; i++){
                                            //Figuren-Koordinaten, die König bedrohen anfordern
                                            int index = 0;
                                            Iterator <String> TFItr = ThreateningFigures.iterator();


                                            while(TFItr.hasNext()){                                             // Pro Figur, die den König bedroht
                                                String currentCoord = TFItr.next();
                                                playerOfFigure = analyzedBoard.getPlayer(currentCoord);         // Spieler anfordern, dem die Figur gehört
                                                if(playerOfFigure != pCurrentPlayer){                           // Wenn Figur nicht vom aktiven Spieler ist:
                                                    TurnPossibility possibleFigureMove2[] = analyzedBoard.calculateTurnPossibility(currentCoord); // Zugmöglichkeiten der Figur anfordern


                                                    if(possibleFigureMove2 != null){
                                                        for(int j = 0; j < possibleFigureMove2.length; j++){        // Zugmöglichkeiten durchgehen
                                                            Board analyzedBoard2 = possibleFigureMove2[j].boardafter;
                                                            if(analyzedBoard2.getPlayer(currentCoord) != player){   // Wenn Figur nicht vom aktuellen Spieler:
                                                                int checkCheck[] = checked(analyzedBoard2);         // Schach-Status des aktuellen Spielers anfordern
                                                                if(checkCheck[player] == 1)                         // Wenn Spieler im Schach ist
                                                                    situationOf[player] = 1;                        // Spieler Schachmatt setzen
                                                                else{                                               // Sonst:
                                                                    situationOf[player] = 0;                        // Spieler ist nicht matt

View Full Code Here

TOP

Related Classes of hexenschach.board.Board

hexenschach.gameplay.Gameplay

hexenschach.gameplay.Persistence

hexenschach.player.AiAlgorithm

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.