Examples of hexenschach.board.TurnPossibility

hexenschach.board.TurnPossibility
Über Objekte dieser Klasse werden dem Gameplay mögliche Ausgangs- situationen angeboten mit denen dieses weiterarbeiten kann @author ulbr6596

     * @param protect, die Punkte aus den beschützenden Figuren
     * @return selectedMove, der n&auml;chste druchzuführende Spielzug
     */
    public TurnPossibility evaluate(TurnPossibilityList pTurnPossibilities, int pCurrentPlayer, Player pPlayer, Board pCurrentBoard, boolean pCheckStatus){


        TurnPossibility selectedMove = algorithm.evaluate(pTurnPossibilities, pCurrentPlayer, pPlayer, pCurrentBoard, pCheckStatus);


        return selectedMove;
    }

View Full Code Here

     * @param protect, die Punkte aus den besch&uuml;tzenden Figuren
     * @return selectedMove, der n&auml;chste druchzuf&uuml;hrende Spielzug
     */
    public TurnPossibility evaluate(TurnPossibilityList pTurnPossibilities, int pCurrentPlayer, Player pPlayer, Board pCurrentBoard, boolean pCheckStatus){
        
        TurnPossibility selectedMove = algorithm.evaluate(pTurnPossibilities, pCurrentPlayer, pPlayer, pCurrentBoard, pCheckStatus);


        return selectedMove;
    }

View Full Code Here

 
        // Wird nach Schwierigkeitsgrad ausgewählt
        int playerDifficulty = pPlayer.difficulty;              // Schwierigkeit des aktuellen Spielers
        int highestCount = analyzedBoards.lastKey();            // Höchste Punktzahl ausgeben (ohne Board)
        
        TurnPossibility selectedMove = null;                    // Der ausgewählte Spielzug, der an's Gameplay übermittelt wird


        if(playerDifficulty == 3)                               // Spieler ist "Schwer"
            selectedMove = analyzedBoards.get(highestCount);    // Bester Zug wird ausgewählt
        else if(playerDifficulty == 2)                          // Spieler ist "Mittel"
            selectedMove = Util.intermediatePlayer(highestCount, analyzedBoards);

View Full Code Here

        pPoints = pPoints + cThrByEnemy;
        pPoints = pPoints + cProtecting;




        // Anfang zweite Prüfebene
        TurnPossibility possibleFigureMove[] = pCurrentBoard.calculateTurnPossibility(currentTP.to);
        System.out.println("------------- TPs generieren. -------------");


        if(possibleFigureMove != null){
            System.out.println("LÄNGE: "+possibleFigureMove.length);

View Full Code Here

                  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")){

View Full Code Here


        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

View Full Code Here

                    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...
                                    points = points + Ballancing.valueOf(ownFigure.getType());// Punkte addieren.
                                }
                            }
                        }

View Full Code Here


        playerKings = findAllKings(pBoard);           // Koordinaten aller Könige speichern


        // Spieler durchlaufen und Prüfungen durchführen
        for(int player = 1; player <= 3; player++){
            TurnPossibility kingTP[] = pBoard.calculateTurnPossibility(playerKings[player-1]);


            if(kingTP != null){                                     // Wenn Züge möglich sind
                for(int i = 0; i <  kingTP.length; i++){            // Solange noch Zugvorschläge bestehen
                    int checked[] = checked(kingTP[i].boardafter);  // Schach-Status des Königs abfragen

View Full Code Here


                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
                            String currentMoveCoord = currentMove.to;                           // Koordinate, zu der die Figur hingezogen ist


                            // Spieler durchlaufen
                            for(int player = 1; player <= 3; player++){
                                if(currentMoveCoord.equals(Util.kingOf(player, analyzedBoard))){     // Figur steht auf Koordinate vom König des aktuellen Spielers

View Full Code Here

                                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:

View Full Code Here

TOP

Related Classes of hexenschach.board.TurnPossibility

hexenschach.player.AiAlgorithm

hexenschach.player.Computer

hexenschach.player.Human

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.