public double[] bayesExpand2(Pelilauta lauta, int max) {
this.children = new NodenLapset();
double[] values = new double[Pelilauta.getKoko() * Pelilauta.getKoko()];
double[] negatives = new double[values.length];
double sum;
Node node;
children.setMaxKoko(max);
int pattern;
int location;
for (int i = 0; i < values.length; i++) {
values[i] = 0;
}
for (int i = 0; i < Pelilauta.getKoko() * Pelilauta.getKoko(); i++) {
if (!PlacementHandler.onkoLaillinenSiirto(lauta, Pelilauta.toX(i), Pelilauta.toY(i))) {
continue;
}
pattern = Pattern.match(lauta, Pelilauta.toX(i), Pelilauta.toY(i));
if (lauta.getTurn() == Pelilauta.VALKEA) {
pattern = Pattern.swapColors(pattern);
}
for (int k = -1; k < 2; k++) {
for (int l = -1; l < 2; l++) {
if (Pelilauta.onLaudalla(Pelilauta.toX(i) + k, Pelilauta.toY(i) + l)) {
location = Pelilauta.toSimple(Pelilauta.toX(i) + k, Pelilauta.toY(i) + l);
// values[location] += Math.log(Pattern.patternMovePredictions(pattern, k, l)) -
// Math.log(Pattern.patternMovePredictions(pattern, k, l));
values[location] += Pattern.patternMovePredictions(pattern, k, l);
}
}
}
}
sum = 0;
for (int i = 0; i < Pelilauta.getKoko() * Pelilauta.getKoko(); i++) {
if (!PlacementHandler.onkoLaillinenSiirto(lauta, Pelilauta.toX(i), Pelilauta.toY(i))) {
continue;
}
sum += values[i];
}
for (int i = 0; i < values.length; i++) {
if (!PlacementHandler.onkoLaillinenSiirto(lauta, Pelilauta.toX(i), Pelilauta.toY(i))) {
continue;
}
values[i] = values[i] / (sum);
node = new Node(lauta, Pelilauta.toX(i), Pelilauta.toY(i));
node.raveVierailut += 5000 * values[i];
node.raveVoitot += (node.raveVierailut * 56) / 100;
this.children.addNode(node);
}
children.sort();
return values;
}
public static Pelilauta bayesSimulate(Pelilauta lauta, int[] amafTaulu) {
double probability;
double maxProbability;
int maxSimple;
while (lauta.getMoveNumber() < 700) {
maxSimple = -1;
maxProbability = -1;
for (int i = 0; i < Pelilauta.getKoko() * Pelilauta.getKoko(); i++) {
if (!PlacementHandler.onkoLaillinenSiirto(lauta, Pelilauta.toX(i), Pelilauta.toY(i))
|| PlacementHandler.tuhoaakoSiirtoOmanSilman(
lauta, Pelilauta.toX(i), Pelilauta.toY(i))) {
continue;
}
probability = 0;
for (int k = -1; k < 2; k++) {
for (int l = -1; l < 2; l++) {
if (Pelilauta.onLaudalla(Pelilauta.toX(i) + k, Pelilauta.toY(i) + l)) {
if (lauta.getTurn() == Pelilauta.MUSTA) {
probability +=
Pattern.patternMovePredictions(
Pattern.match(lauta, Pelilauta.toX(i) + k, Pelilauta.toY(i) + l), -k, -l);
} else {
probability +=
Pattern.patternMovePredictions(
Pattern.swapColors(
Pattern.match(lauta, Pelilauta.toX(i) + k, Pelilauta.toY(i) + l)),
-k,
-l);
}
}
}
}
if (probability > maxProbability) {
maxSimple = i;
}
}
if (maxSimple == -1) {
if (lauta.isPassedOnLastMove()) {
break;
}
PlacementHandler.pass(lauta);
continue;
}
PlacementHandler.pelaaSiirto(lauta, Pelilauta.toX(maxSimple), Pelilauta.toY(maxSimple));
if (amafTaulu[maxSimple] == 0) {
amafTaulu[maxSimple] = lauta.getTurn();
}
}
// System.err.println("Siirtoja: " + lauta.getMoveNumber());
return lauta;
}
/**
* Päättää mitä siirtoja tästä nodesta eteenpäin ylipäätään tullaan harkitsemaan. Tämänhetkinen
* versio ottaa satunnaisesti 20 pistettä.
*/
public void expand(Pelilauta lauta) {
boolean[] visited = new boolean[Pelilauta.getKoko() * Pelilauta.getKoko()];
int pisteita;
Pino<Node> lapsiJono = new Pino<>();
for (int i = 0; i < visited.length; i++) {
visited[i] = true;
}
int offset = r.nextInt(visited.length);
int indeksi = 0;
int uusiX, uusiY;
pisteita = CriticalPointObserver.getCapturePoints(lauta, lapsiJono, visited);
while ((indeksi < visited.length) && (pisteita < branchingFactor)) {
uusiX = Pelilauta.toX((indeksi + offset) % visited.length);
uusiY = Pelilauta.toY((indeksi + offset) % visited.length);
if (visited[(indeksi + offset) % visited.length]) {
visited[(indeksi + offset) % visited.length] =
false; // Varmistetaan että samaa siirtoa ei lasketa moneen kertaan
if (PlacementHandler.onkoLaillinenSiirto(lauta, uusiX, uusiY)) {
lapsiJono.add(new Node(lauta, uusiX, uusiY));
pisteita++;
indeksi = 0;
offset = r.nextInt(visited.length);
continue;
}
}
indeksi++;
}
Node passaus = new Node(lauta, -1, -1);
lapsiJono.add(passaus);
pisteita++;
Node[] pisteet = new Node[pisteita];
for (int i = 0; i < pisteita; i++) {
pisteet[i] = lapsiJono.pop();
}
this.children = new NodenLapset(pisteet);
}
/**
* simuloi pelin. Pelaa sarjan siirtoja.
*
* @return Pelilauta, kun simulaatio on päättynyt. Laudalla ei pitäisi olla yhtäkään kuollutta
* ryhmää, ja silmien tulisi olla yhden pisteen kokoisia.
*/
public static Pelilauta simulate(Pelilauta lauta, int[] amafTaulu) {
int[] vapaatpisteet;
int offset;
int x, y;
boolean noSensibleMovesLeft = false;
boolean loytyiSiirto;
while (!noSensibleMovesLeft && lauta.getMoveNumber() < 700) {
vapaatpisteet = lauta.getMahdollisetPisteet();
loytyiSiirto = false;
if (lauta.isPassedOnLastMove()) {
noSensibleMovesLeft = true;
}
if (vapaatpisteet != null) {
if (CriticalPointObserver.getSelfAtariMove() != -1) {
x = Pelilauta.toX(CriticalPointObserver.getSelfAtariMove());
y = Pelilauta.toY(CriticalPointObserver.getSelfAtariMove());
if (!PlacementHandler.tuhoaakoSiirtoOmanSilman(lauta, x, y)) {
if (amafTaulu[Pelilauta.toSimple(x, y)] == 0) {
amafTaulu[Pelilauta.toSimple(x, y)] = lauta.getTurn();
}
PlacementHandler.pelaaSiirto(lauta, x, y);
noSensibleMovesLeft = false;
loytyiSiirto = true;
continue;
}
}
offset = r.nextInt(vapaatpisteet.length);
for (int i = 0; i < vapaatpisteet.length; i++) {
x = Pelilauta.toX(vapaatpisteet[(i + offset) % vapaatpisteet.length]);
y = Pelilauta.toY(vapaatpisteet[(i + offset) % vapaatpisteet.length]);
if (!PlacementHandler.tuhoaakoSiirtoOmanSilman(lauta, x, y)) {
if (amafTaulu[Pelilauta.toSimple(x, y)] == 0) {
amafTaulu[Pelilauta.toSimple(x, y)] = lauta.getTurn();
}
PlacementHandler.pelaaSiirto(lauta, x, y);
noSensibleMovesLeft = false;
loytyiSiirto = true;
break;
}
}
}
if (!loytyiSiirto) {
PlacementHandler.pass(lauta);
}
}
// GoAI.piirraLauta(lauta);
/*String debug = "\n";
for (int j = Pelilauta.getKoko() - 1; j >= 0; j--) {
debug += " ";
for (int i = 0; i < Pelilauta.getKoko(); i++) {
if (lauta.getRisteys(i, j) == Pelilauta.MUSTA) {
debug += " " + "X" + " ";
}
else if (lauta.getRisteys(i, j) == Pelilauta.VALKEA) {
debug += " " + "O" + " ";
}
else {
debug += " " + "." + " ";
}
}
debug += "\n";
}
GTP.logger.info(debug);*/
return lauta;
}
public void bayesExpand(Pelilauta lauta) {
double[] values = new double[Pelilauta.getKoko() * Pelilauta.getKoko()];
int[] strengths = new int[values.length];
children = new NodenLapset();
double boardSum = 0.0;
int strengthOfPrediction = 0;
Node newNode;
for (int i = 0; i < values.length; i++) {
values[i] = Pattern.valueOf(Pattern.match(lauta, Pelilauta.toX(i), Pelilauta.toY(i)));
strengths[i] = Pattern.getSeenTotal(Pattern.match(lauta, Pelilauta.toX(i), Pelilauta.toY(i)));
boardSum += values[i];
strengthOfPrediction +=
Pattern.getSeenTotal(Pattern.match(lauta, Pelilauta.toX(i), Pelilauta.toY(i)));
}
Pelilauta testiLauta;
double difference;
int differenceInStrength;
for (int i = 0; i < values.length; i++) {
if (!PlacementHandler.onkoLaillinenSiirto(lauta, Pelilauta.toX(i), Pelilauta.toY(i))) {
continue;
}
difference = 0.0;
differenceInStrength = 0;
testiLauta = lauta.kopioi();
PlacementHandler.pelaaSiirto(testiLauta, Pelilauta.toX(i), Pelilauta.toY(i));
for (int x = -1; x < 2; x++) {
for (int y = -1; y < 2; y++) {
if (Pelilauta.onLaudalla(Pelilauta.toX(i) + x, Pelilauta.toY(i) + y)) {
difference +=
values[i]
- Pattern.valueOf(
Pattern.match(testiLauta, Pelilauta.toX(i) + x, Pelilauta.toY(i) + y));
differenceInStrength +=
strengths[i]
- Pattern.getSeenTotal(
Pattern.match(testiLauta, Pelilauta.toX(i), Pelilauta.toY(i)));
}
}
}
newNode = new Node(lauta, Pelilauta.toX(i), Pelilauta.toY(i));
newNode.raveVierailut =
(int) Math.round(Math.log(strengthOfPrediction - differenceInStrength) * 1000);
if (lauta.getTurn() == Pelilauta.MUSTA) {
newNode.raveVoitot =
(int)
Math.round(
newNode.raveVierailut * (1 / (1 + Math.pow(Math.E, boardSum - difference))));
} else {
newNode.raveVoitot =
(int)
Math.round(
newNode.raveVierailut
* (1 - (1 / (1 + Math.pow(Math.E, boardSum - difference)))));
}
if (1.0 * newNode.raveVoitot / newNode.raveVierailut > 0.44) {
children.addNode(newNode);
}
}
children.setMaxKoko(branchingFactor);
Node passaus = new Node(lauta, -1, -1);
children.addNode(passaus);
children.sort();
}
/**
* Yrittää parhaalta vaikuttavaa siirtoa, simuloi siitä edespäin pelin loppuun saakka, ja
* päivittää jokaisen MC-puun solmun matkan varrella tällä tuloksella.
*/
public void selectAction(Pelilauta lauta) {
Pelilauta currentLauta = lauta.kopioi();
int[] amafTaulu = new int[Pelilauta.getKoko() * Pelilauta.getKoko()];
if (isNoLegalMovesAvailable()) {
return;
}
Pino<Node> visited = new Pino<>();
visited.add(this);
Node currentNode = this;
int tulos;
while (!currentNode.isLeaf()) {
if (raveSuoritukset == 0) {
currentNode = currentNode.select();
PlacementHandler.pelaaSiirto(currentLauta, currentNode.getX(), currentNode.getY());
} else {
currentNode = currentNode.selectRAVE(currentNode.vierailut);
if ((Pelilauta.toSimple(currentNode.getX(), currentNode.getY()) > -1)
&& (amafTaulu[Pelilauta.toSimple(currentNode.getX(), currentNode.getY())] == 0)) {
amafTaulu[Pelilauta.toSimple(currentNode.getX(), currentNode.getY())] =
currentNode.getTurn();
}
PlacementHandler.pelaaSiirto(currentLauta, currentNode.getX(), currentNode.getY());
}
visited.add(currentNode);
}
// currentNode.bayesExpand2(currentLauta, branchingFactor);
currentNode.expand(currentLauta);
if (raveSuoritukset == 0) {
currentNode = currentNode.select();
PlacementHandler.pelaaSiirto(currentLauta, currentNode.getX(), currentNode.getY());
} else {
currentNode = currentNode.selectRAVE(currentNode.vierailut);
if (currentNode.getX() == -1
&& currentNode.getY() == -1
&& currentLauta.isPassedOnLastMove()) {
tulos = -1;
if (GTP.score(currentLauta) > 0) {
tulos = 1;
}
updateRAVE(visited, tulos, amafTaulu);
currentNode.children = null;
return;
}
if ((Pelilauta.toSimple(currentNode.getX(), currentNode.getY()) > -1)
&& (amafTaulu[Pelilauta.toSimple(currentNode.getX(), currentNode.getY())] == 0)) {
amafTaulu[Pelilauta.toSimple(currentNode.getX(), currentNode.getY())] =
currentNode.getTurn();
}
PlacementHandler.pelaaSiirto(currentLauta, currentNode.getX(), currentNode.getY());
}
visited.add(currentNode);
currentLauta = currentNode.simulate(currentLauta, amafTaulu);
tulos = simulScore(currentLauta);
if (raveSuoritukset == 0) {
update(visited, tulos);
} else {
updateRAVE(visited, tulos, amafTaulu);
}
return;
}