Viergewinnt Bewertungsfunktion

[Java xyrse123]

Für meine Viergewinnt Ki benutze ich folgende Bewertungsfunktion:

Bei allen möglichen 4 er Reihen (parallel ,waagerecht, diagonal)werden X(Spieler 1) und O(Spieler2) gezählt.
- 4 mal X und 0 mal O gibt einen Wert von -1000
- 3 mal X und 0 mal O gibt einen Wert von -50
- 2 mal X und 0 mal O gibt einen Wert von -10
- 1 mal X und 0 mal O gibt einen Wert von -1
und umgekehrt für Spieler O.

Nur werden so manchmal eindeutige(einzügige) Gewinnmöglichkeiten nicht genutzt oder gegnerische Gewinn wird nicht verhindert. Weiß wer woran das liegt?

Spoiler

/*
Zählt Xs und Os in einer 4er Reihe
*/
private int evaluateSegment(int[] s) {

    int countX = 0, countO = 0;

    for(int i = 0; i < s.length; i++) {
        if(s[i] == playerX) countX++;
        if(s[i] == playerO) countO++;
    }

    if(countX == 0) {
        if(countO == 4) return -1000;
        if(countO == 3) return -50;
        if(countO == 2) return -10;
        if(countO == 1) return -1;
    }

    if(countO == 0) {
        if(countX == 4) return 1000;
        if(countX == 3) return 50;
        if(countX == 2) return 10;
        if(countX == 1) return 1;
    }

    return 0;
}

/*
Von jedem Feld werden alle von dort ausgehenden Reihen bewertet.
*/

private int evaluate(int board[][], int row, int col) {

    int rows = board.length;
    int cols = board[0].length;
    int score = 0;

/// rechts, links , hoch, runter
    if(col >= cols - 4) {
       score += evaluateSegment(new int[] {board[row][col], board[row][col-1], board[row][col-2], board[row][col-3]});
    }

    if(col <= cols - 4) {
        score += evaluateSegment(new int[] {board[row][col], board[row][col+1], board[row][col+2], board[row][col+3]});
    }

    if(row <= rows - 4) {
        score += evaluateSegment(new int[] {board[row][col], board[row+1][col], board[row+2][col], board[row+3][col]});
    }

    if(row >= rows - 3) {
        score += evaluateSegment(new int[] {board[row][col], board[row-1][col], board[row-2][col], board[row-3][col]});
    }
// diagonal
    if(col >= cols - 4 && row >= rows - 3) {
        score += evaluateSegment(new int[]{board[row][col], board[row-1][col-1], board[row-2][col-2], board[row-3][col-3]});
    }

    if(col <= cols - 4 && row <= rows - 4) {
        score += evaluateSegment(new int[]{board[row][col], board[row+1][col+1], board[row+2][col+2], board[row+3][col+3]});
    }

    if(col <= cols - 4 && row >= rows - 3) {
        score += evaluateSegment(new int[]{board[row][col], board[row-1][col+1], board[row-2][col+2], board[row-3][col+3]});
    }

    if(col >= cols - 4 && row <= rows - 4) {
        score += evaluateSegment(new int[]{board[row][col], board[row+1][col-1], board[row+2][col-2], board[row+3][col-3]});
    }

    return score;
}

private int evaluate(int board[][]) {


    int score = 0;

    for(int r = 0; r < board.length; r++) {
        for(int c = 0; c < board[r].length; c++) {

            score += evaluate(board, r, c);

        }
    }

    return score;
}

Danke im Vorraus.

 

[krgewb]

Wieso muss man bei row -3 rechnen aber bei cols -4?

 

[mihe7]

Gute Frage Ich hätte auch noch eine: warum soll man in den Fällenl col == cols - 4 bzw. row == rows-3 zweimal die Score berechnen (bzw. wenn man die Diagonale dazunimmt, sogar noch öfter)?