Moin, ich versuche gerade eine 4 Gewinnt KI mittels Alpha-Beta Suchalogiruthmus zu erstellen, diese funktioniert aber nicht wirklich...
Hier der Code:
Und für die KI:
Problem ist bislang, dass die for schleife nach der 0 mehr weitermacht
Selbstverständlich ist das ganze noch nicht so super programmiert.
Danke für eure Hilfe^^
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^^