mirror of
https://github.com/yacy/yacy_search_server.git
synced 2024-09-21 00:00:13 +02:00
333 lines
11 KiB
Java
333 lines
11 KiB
Java
/**
|
|
* ConnectFour.java
|
|
* Copyright 2009 by Michael Peter Christen, Frankfurt a. M., Germany
|
|
* First published 03.12.2009 at http://yacy.net
|
|
*
|
|
* $LastChangedDate$
|
|
* $LastChangedRevision$
|
|
* $LastChangedBy$
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program in the file lgpl21.txt
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package net.yacy.ai.example;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import net.yacy.ai.greedy.AbstractFinding;
|
|
import net.yacy.ai.greedy.AbstractModel;
|
|
import net.yacy.ai.greedy.Battle;
|
|
import net.yacy.ai.greedy.ContextFactory;
|
|
import net.yacy.ai.greedy.Finding;
|
|
import net.yacy.ai.greedy.Goal;
|
|
import net.yacy.ai.greedy.Model;
|
|
import net.yacy.ai.greedy.Role;
|
|
|
|
public class ConnectFour {
|
|
|
|
static final int width = 7;
|
|
static final int height = 6;
|
|
|
|
public static enum Coin implements Role {
|
|
red('*'),
|
|
blue('#');
|
|
private final String c;
|
|
Coin(char c) {this.c = String.valueOf(c);}
|
|
@Override
|
|
public Coin nextRole() {
|
|
return (this == red) ? blue : red;
|
|
}
|
|
@Override
|
|
public String toString() {return this.c;}
|
|
public final static Coin[] allCoins = {red, blue};
|
|
}
|
|
|
|
public static class Move extends AbstractFinding<Coin> implements Finding<Coin> {
|
|
protected final int column;
|
|
public Move(Coin role, int column) {
|
|
super(role, (column > (width / 2)) ? (width - column - 1) : column);
|
|
this.column = column;
|
|
}
|
|
@Override
|
|
public Object clone() {
|
|
return new Move(this.getRole(), this.column);
|
|
}
|
|
public int getColumn() {
|
|
return this.column;
|
|
}
|
|
@Override
|
|
public boolean equals(Object other) {
|
|
if (!(other instanceof Move)) return false;
|
|
Move m = (Move) other;
|
|
return this.column == m.column;
|
|
}
|
|
@Override
|
|
public int hashCode() {
|
|
return this.column;
|
|
}
|
|
@Override
|
|
public String toString() {
|
|
return super.getRole().toString() + ":" + Integer.toString(this.column);
|
|
}
|
|
}
|
|
|
|
public static class Board extends AbstractModel<Coin, Move> implements Model<Coin, Move>, Cloneable {
|
|
|
|
Coin[] b; // 2 dimensions folded: array starts in the bottom left and first position in second row is at index position <width>
|
|
|
|
/**
|
|
* create a board with start configuration: empty board
|
|
* @param nextRole
|
|
*/
|
|
public Board(Coin startPlayer) {
|
|
super(startPlayer);
|
|
this.b = new Coin[height * width];
|
|
for (int i = 0; i < this.b.length; i++) this.b[i] = null;
|
|
}
|
|
|
|
/**
|
|
* clone a board and return a new board
|
|
* @param board
|
|
*/
|
|
public Board(Board board) {
|
|
super(board.currentRole());
|
|
this.b = new Coin[board.b.length];
|
|
System.arraycopy(board.b, 0, this.b, 0, this.b.length);
|
|
}
|
|
|
|
@Override
|
|
public Object clone() {
|
|
return new Board(this);
|
|
}
|
|
|
|
public boolean columnFull(int column) {
|
|
return this.b[(height - 1) * width + column] != null;
|
|
}
|
|
|
|
public Coin getCell(int column, int row) {
|
|
return this.b[row * width + column];
|
|
}
|
|
|
|
@Override
|
|
public void applyFinding(Move nextStep) {
|
|
int column = nextStep.getColumn();
|
|
int row = 0;
|
|
while (row < height && this.b[row * width + column] != null) row++;
|
|
if (row == height) throw new RuntimeException("column " + column + " is full");
|
|
this.b[row * width + column] = nextStep.getRole();
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
int c = 0;
|
|
Coin x;
|
|
for (int i = 0; i < this.b.length; i++) {
|
|
x = this.b[i];
|
|
if (x != null) c += (i + 1) * (x.ordinal() + 1);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (!(o instanceof Board)) return false;
|
|
Board om = (Board) o;
|
|
Coin c0, c1;
|
|
for (int i = 0; i < this.b.length; i++) {
|
|
c0 = this.b[i];
|
|
c1 = om.b[i];
|
|
if (!(c0 == null ? c1 == null : c0.equals(c1))) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private boolean count4(int x, int y, int xi, int yi, Coin c) {
|
|
int steps = 4;
|
|
Coin cell;
|
|
while (steps-- > 0) {
|
|
cell = this.b[y * width + x];
|
|
if (cell == null || !cell.equals(c)) return false;
|
|
x += xi;
|
|
y += yi;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private int countSame(int x, int y, int xi, int yi, Coin c) {
|
|
int rb = 0;
|
|
int steps = 4;
|
|
Coin cell;
|
|
while (steps-- > 0) {
|
|
cell = this.b[y * width + x];
|
|
if (cell != null) {
|
|
if (cell.equals(c)) rb++; else return rb;
|
|
}
|
|
x += xi;
|
|
y += yi;
|
|
}
|
|
return rb;
|
|
}
|
|
|
|
@Override
|
|
public Coin isTermination() {
|
|
for (Coin coin: Coin.allCoins) if (isTermination(coin)) return coin;
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public boolean isTermination(Coin coin) {
|
|
// waagerecht
|
|
for (int x = 0; x < width - 3; x++)
|
|
for (int y = 0; y < height; y++)
|
|
if (count4(x, y, 1, 0, coin)) return true;
|
|
// senkrecht
|
|
for (int x = 0; x < width; x++)
|
|
for (int y = 0; y < height - 3; y++)
|
|
if (count4(x, y, 0, 1, coin)) return true;
|
|
// slash-schraeg
|
|
for (int x = 0; x < width - 3; x++)
|
|
for (int y = 0; y < height - 3; y++)
|
|
if (count4(x, y, 1, 1, coin)) return true;
|
|
// backslash-schraeg
|
|
for (int x = 0; x < width - 3; x++)
|
|
for (int y = 3; y < height; y++)
|
|
if (count4(x, y, 1, -1, coin)) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int getRanking(int findings, Coin coin) {
|
|
return 2 * getRankingSingle(coin) - getRankingSingle(coin.nextRole()) - 3 * findings;
|
|
}
|
|
|
|
private int getRankingSingle(Coin coin) {
|
|
int r = 0;
|
|
// waagerecht
|
|
for (int x = 0; x < width - 3; x++)
|
|
for (int y = 0; y < height; y++)
|
|
r += countSame(x, y, 1, 0, coin);
|
|
// senkrecht
|
|
for (int x = 0; x < width; x++)
|
|
for (int y = 0; y < height - 3; y++)
|
|
r += countSame(x, y, 0, 1, coin);
|
|
// slash-schraeg
|
|
for (int x = 0; x < width - 3; x++)
|
|
for (int y = 0; y < height - 3; y++)
|
|
r += countSame(x, y, 1, 1, coin);
|
|
// backslash-schraeg
|
|
for (int x = 0; x < width - 3; x++)
|
|
for (int y = 3; y < height; y++)
|
|
r += countSame(x, y, 1, -1, coin);
|
|
return r;
|
|
}
|
|
|
|
private int getPriority(Move finding) {
|
|
if (finding.column <= width / 2) return finding.column;
|
|
return width - 1 - finding.column;
|
|
}
|
|
|
|
@Override
|
|
public List<Move> explore() {
|
|
ArrayList<Move> moves = new ArrayList<Move>();
|
|
for (int i = 0; i < width; i++) {
|
|
Move move = new Move(this.currentRole(), i);
|
|
move.setPriority(getPriority(move));
|
|
if (!columnFull(i)) moves.add(move);
|
|
}
|
|
return moves;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
StringBuilder s = new StringBuilder((width + 1) * height);
|
|
Coin coin;
|
|
for (int row = height - 1; row >= 0; row--) {
|
|
s.append('\"');
|
|
for (int column = 0; column < width; column++) {
|
|
coin = this.b[row * width + column];
|
|
s.append((coin == null) ? " " : coin.toString());
|
|
}
|
|
if (row == 0) s.append('\"'); else s.append("\"+\n");
|
|
}
|
|
return s.toString();
|
|
}
|
|
}
|
|
|
|
public static class Strategy implements Goal<Coin, Move, Board> {
|
|
|
|
public Strategy() {
|
|
}
|
|
|
|
@Override
|
|
public boolean isFulfilled(Board model) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean isSnapshot(Board model) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean pruning(Board model) {
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public static void battle() {
|
|
Map<Coin, ContextFactory<Coin, Move, Board>> strategies = new HashMap<Coin, ContextFactory<Coin, Move, Board>>();
|
|
ContextFactory<Coin, Move, Board> redFactroy = new ContextFactory<Coin, Move, Board>(new Strategy(), 3000, false, false);
|
|
ContextFactory<Coin, Move, Board> blueFactroy = new ContextFactory<Coin, Move, Board>(new Strategy(), 50, false, false);
|
|
strategies.put(Coin.red, redFactroy);
|
|
strategies.put(Coin.blue, blueFactroy);
|
|
/*Battle<Coin, Move, Board> battle =*/ new Battle<Coin, Move, Board>(new Board(Coin.red), strategies, 2000);
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
|
|
battle();
|
|
/*
|
|
int cores = Runtime.getRuntime().availableProcessors();
|
|
Engine<Coin, Move, Board> engine = new Engine<Coin, Move, Board>(cores);
|
|
Agent<Coin, Move, Board> agent;
|
|
engine.start();
|
|
long comptime = 60;
|
|
long relaxtime = 20;
|
|
|
|
agent = new Agent<Coin, Move, Board>(new Board(Coin.red), new Strategy(comptime, false, false)); // red begins
|
|
engine.inject(agent);
|
|
agent.getTeorem().getGoal().awaitTermination(relaxtime);
|
|
System.out.println("=========== terminated ==========");
|
|
agent.getTeorem().printReport(100);
|
|
*/
|
|
/*
|
|
agent = new Agent<Coin, Move, Board>(new Board(), Coin.red, new Strategy(comptime, false, true)); // red begins
|
|
engine.inject(agent);
|
|
agent.getGoal().awaitTermination(relaxtime);
|
|
System.out.println("=========== terminated ==========");
|
|
agent.printReport(10);
|
|
*/
|
|
|
|
//engine.stop();
|
|
}
|
|
|
|
}
|