4 Gewinnt KI macht nicht, was sie soll..

MrXeth

Aktives Mitglied
Moin, ich versuche gerade eine 4 Gewinnt KI mittels Alpha-Beta Suchalogiruthmus zu erstellen, diese funktioniert aber nicht wirklich...

Hier der Code:
Java:
public class Field {

    /**
     * main method
     *
     * @param args - arguments for executing the class
     */
    public static void main(String[] args) {
        Field f = new Field(4, 4);
        f.test();
    }

    private int[][] fields;

    /**
     * constructor
     *
     * @param rows - number of rows
     * @param columns - number of columns
     */
    public Field(int rows, int columns) {
        this.fields = new int[rows][columns];
    }

    /**
     * method, which returns the more dimensional array illustrating the fields
     *
     * @return - more dimensional array of fields
     */
    public int[][] getFields() {
        return fields;
    }

    /**
     * method, which evaluates, if four chips are in a row
     *
     * @param row - row at the field
     * @param column - column at the field
     * @param rowMove - distance between chips in a row, value 0, if the argument is not needed
     * @param columnMove - distance between chips in a column, value 0, if the argument is not needed
     * @return if four chips are in a row
     */
    public int row(int row, int rowMove, int columnMove) {
        int column = fields[row].length;
        try {
            for(int i = column; i > 0; i--) {
                if(fields[row][i] == 0 ) {
                    fields[row][i+1] = 0;
                    column = i;
                }
            }
        } catch(Exception e) {
            column = 0;
        }
        int kind = fields[row][column];
        int count = 0;
        for (int i = 0; i < 4; i++) {
            try {
                if (fields[row + i * rowMove][column + i * columnMove] == kind) {
                    if (i > 0 && fields[row + i * rowMove - rowMove][column + i * columnMove - columnMove] != kind)
                        break;
                    count++;
                }
                if (i > 0 && fields[row - i * rowMove][column - i * columnMove] == kind) {
                    if (fields[row + i * rowMove + rowMove][column + i * columnMove + columnMove] != kind)
                        break;
                    count++;
                }

            } catch (Exception e) {

            }
        }
        return count;
    }

    /**
     * method, which lets a player set
     *
     * @param kind - kind of chips
     * @param row - row where to set
     */
    public void set(int kind, int row) {
        int column = 0;
        if(!isFilled(row)) {
            for (int i = column; i < fields[row].length; i++) {
                if (fields[row][i] == 0) {
                    fields[row][i] = kind;
                    column = i;
                    break;
                }
            }
            System.out.println("ROW 1 " + fields[row][0]);
            System.out.println(win(0));
        }
    }

    /**
     * method for tests
     */
    public void test() {
        set(1, 0);
        set(1, 0);
        set(1, 0);
        set(1, 0);
    }

    /**
     * method, which returns, if a kind won
     *
     * @param row - row, where the source chip is
     * @param column - column, where the source chip is
     * @return if a kind won the game
     */
    private boolean win(int row) {
        if (row(row, 1, 0) >= 4 || row(row,0, 1) >= 4 || row(row, 1, 1) >= 4)
            return true;
        return false;
    }
  
    public void cancel(int row) {
            for(int i = 0; i < fields[row].length-1; i++) {
                if(fields[row][i] != 1 || fields[row][i] != 2 ) {
                    fields[row][i+1] = 0;
                }
            }
    }
  
    public boolean isFilled(int row) {
        return fields[row][fields[row].length-1] != 0;
    }
}

Und für die KI:

Problem ist bislang, dass die for schleife nach der 0 mehr weitermacht
Code:
import java.util.Arrays;

public class Artificial_Intelligence {

    private Field field;
    private int kind;
    private Difficulty difficulty;
    private int currentActionRow;
  
    public enum Difficulty {
        HARD(42), MEDIUM(21), EASY(5);
      
        private final int deep;
      
        private Difficulty(int deep) {
            this.deep = deep;
        }
      
        public int getDeep() {
            return this.deep;
        }
    }
  
    public Artificial_Intelligence(int kind, Field field, Difficulty difficulty) {
        this.kind = kind;
        this.field = field;
        this.difficulty = difficulty;
    }

    public static void main(String[] args) {
        Artificial_Intelligence t = new Artificial_Intelligence(1, new Field(7,6), Artificial_Intelligence.Difficulty.HARD );
        t.test();

    }
  
    public void test() {
        field.set(2, 1);
        field.set(2, 1);
        field.set(2, 1);
        field.set(2, 1);
        field.set(2, 1);
        field.set(2, 1);
        field.set(2, 1);
        field.set(2, 1);
        field.set(2, 1);
        System.out.println("A");
        intelligent();
    }
  
    public void intelligent() {
        alphaBeta(difficulty.getDeep(), 2147483647, -2147483647, 1 );
        System.out.println("RealSet");
        field.set(kind, currentActionRow);
    }
  
    private int alphaBeta(int depth, int alpha, int beta, int row) {
        if(field.isFilled(row) || depth == 0)
            return evaluate(row);
        int[] actions = generateActions();
        for(int i = 0; i < actions.length; i++) {
            System.out.println("I "+i);
            System.out.println("depth "+depth);
            field.set(kind, actions[i]);
            int value = -alphaBeta(depth-1, -beta, -alpha, i);
            field.cancel(actions[i]);
            if(value >= beta)
                return beta;
            if(value > alpha)
                alpha = value;
        }
        return alpha;
      
    }
  
    private int[] generateActions() {
        int[] temp = new int[field.getFields().length];
        int count = 0;
        for(int i = 0; i < temp.length-1; i++) {
            if(!field.isFilled(i)) {
                temp[count] = i;
            }
            count++;
        }
        temp = Arrays.copyOf(temp, count);
        return temp;
    }
  
    private int evaluate(int row) {
        int[] temp = new int[3];
        temp[0] = field.row(row, 1, 0);
        temp[1] = field.row(row, 0, 1);
        temp[2] = field.row(row, 1, 1);

        temp = quickSort(temp);
        System.out.println("t "+temp[2]);
        return temp[2];
    }

    private static int[] quickSort(int[] values) {
        // Prüfen, ob das Array leer ist oder eine oder weniger Stellen hat
        if(values != null | values.length > 1)
        {
            quicksort(values,0, values.length-1);
        }
        return values;
    }
  
    private static void quicksort(int[] Array,int links, int rechts) {
        int l = links, r = rechts;
        int temp;
        // mittleres Element bekommen
        int pivot = Array[links + (rechts-links)/2];
        // in Liste links und rechts von Pivotelement unterteilen
        while (l <= r)
        {
            // nach Elementen suchen, die kleiner/größer sind, als das pivotelement
            while (Array[l] < pivot)
            {
                l++;
            }
            while (Array[r] > pivot) {
                r--;
            }
            // Wenn in der linken Liste einen Wert gefunden wurde, der größer ist als
            // das Pivot-Element und wenn ein Wert in der rechten Liste gefunden wurde
            // welcher kleiner ist als das Pivot-Element, dann werden die
            // Werte getauscht
            // dann wird l hochgezählt und r runtergezählt
            if (l <= r)
            {
                temp = Array[l];
                Array[l] = Array[r];
                Array[r] = temp;
                l++;
                r--;
            }
        }
        // damit bei unterschiedl. großen Seiten keine Nullpointer / Array out of Bounds auftreten
        if (links < r)
        {
            quicksort(Array, links, r);
        }
        if (l < rechts)
        {
            quicksort(Array, l, rechts);
        }
    }
}

Selbstverständlich ist das ganze noch nicht so super programmiert.

Danke für eure Hilfe^^
 

Neue Themen


Zurück
Oben