mirror of
https://github.com/2OOP/pism.git
synced 2026-02-04 10:54:51 +00:00
Compare commits
14 Commits
5caf6900d1
...
223-create
| Author | SHA1 | Date | |
|---|---|---|---|
|
3e4a343c4e | ||
|
|
c4b9378128 | ||
|
|
95e96583ec | ||
|
|
d02c7bd095 | ||
|
|
4e22c01bde | ||
|
|
d078a70950 | ||
|
|
c54b2a19e2 | ||
|
|
a6f5f2c854 | ||
|
|
94e3fc71b8 | ||
|
|
9fcbe7d298 | ||
|
|
35f7a4fd13 | ||
|
|
e2132b549d | ||
|
|
9aefcb9b7b | ||
|
|
8146be16ed |
@@ -1,53 +1,68 @@
|
||||
package org.toop;
|
||||
|
||||
import org.toop.app.App;
|
||||
import org.toop.framework.game.games.reversi.BitboardReversi;
|
||||
import org.toop.framework.game.players.ArtificialPlayer;
|
||||
import org.toop.game.players.ai.MCTSAI;
|
||||
import org.toop.game.players.ai.RandomAI;
|
||||
import org.toop.game.players.ai.mcts.MCTSAI1;
|
||||
import org.toop.game.players.ai.mcts.MCTSAI2;
|
||||
import org.toop.game.players.ai.mcts.MCTSAI3;
|
||||
import org.toop.game.players.ai.mcts.MCTSAI4;
|
||||
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
|
||||
public final class Main {
|
||||
static void main(String[] args) {
|
||||
App.run(args);
|
||||
// testMCTS(10);
|
||||
|
||||
// final ExecutorService executor = Executors.newFixedThreadPool(1);
|
||||
// executor.execute(() -> testAIs(25));
|
||||
}
|
||||
|
||||
// Voor onderzoek
|
||||
// private static void testMCTS(int games) {
|
||||
// var random = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), "Random AI");
|
||||
// var v1 = new ArtificialPlayer<>(new MCTSAI<BitboardTicTacToe>(10), "MCTS V1 AI");
|
||||
// var v2 = new ArtificialPlayer<>(new MCTSAI2<BitboardTicTacToe>(10), "MCTS V2 AI");
|
||||
// var v2_2 = new ArtificialPlayer<>(new MCTSAI2<BitboardTicTacToe>(100), "MCTS V2_2 AI");
|
||||
// var v3 = new ArtificialPlayer<>(new MCTSAI3<BitboardTicTacToe>(10), "MCTS V3 AI");
|
||||
private static void testAIs(int games) {
|
||||
var versions = new ArtificialPlayer[5];
|
||||
versions[0] = new ArtificialPlayer(new RandomAI(), "Random AI");
|
||||
versions[1] = new ArtificialPlayer(new MCTSAI1(1000), "MCTS V1 AI");
|
||||
versions[2] = new ArtificialPlayer(new MCTSAI2(1000), "MCTS V2 AI");
|
||||
versions[3] = new ArtificialPlayer(new MCTSAI3(10, 10), "MCTS V3 AI");
|
||||
versions[4] = new ArtificialPlayer(new MCTSAI4(10, 10), "MCTS V4 AI");
|
||||
|
||||
// testAI(games, new Player[]{ v1, v2 });
|
||||
// // testAI(games, new Player[]{ v1, v3 });
|
||||
for (int i = 0; i < versions.length; i++) {
|
||||
for (int j = i + 1; j < versions.length; j++) {
|
||||
final int playerIndex1 = i % versions.length;
|
||||
final int playerIndex2 = j % versions.length;
|
||||
|
||||
// // testAI(games, new Player[]{ random, v3 });
|
||||
// // testAI(games, new Player[]{ v2, v3 });
|
||||
// testAI(games, new Player[]{ v2, v3 });
|
||||
// // testAI(games, new Player[]{ v3, v2 });
|
||||
// }
|
||||
testAIVSAI(games, new ArtificialPlayer[] { versions[playerIndex1], versions[playerIndex2]});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// private static void testAI(int games, Player<BitboardReversi>[] ais) {
|
||||
// int wins = 0;
|
||||
// int ties = 0;
|
||||
private static void testAIVSAI(int games, ArtificialPlayer[] ais) {
|
||||
int wins = 0;
|
||||
int ties = 0;
|
||||
|
||||
// for (int i = 0; i < games; i++) {
|
||||
// final BitboardReversi match = new BitboardReversi(ais);
|
||||
for (int i = 0; i < games; i++) {
|
||||
final BitboardReversi match = new BitboardReversi();
|
||||
match.init(ais);
|
||||
|
||||
// while (!match.isTerminal()) {
|
||||
// final int currentAI = match.getCurrentTurn();
|
||||
// final long move = ais[currentAI].getMove(match);
|
||||
while (!match.isTerminal()) {
|
||||
final int currentAI = match.getCurrentTurn();
|
||||
final long move = ais[currentAI].getMove(match);
|
||||
|
||||
// match.play(move);
|
||||
// }
|
||||
match.play(move);
|
||||
}
|
||||
|
||||
// if (match.getWinner() < 0) {
|
||||
// ties++;
|
||||
// continue;
|
||||
// }
|
||||
if (match.getWinner() < 0) {
|
||||
ties++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// wins += match.getWinner() == 0? 1 : 0;
|
||||
// }
|
||||
wins += match.getWinner() == 0? 1 : 0;
|
||||
}
|
||||
|
||||
// System.out.printf("Out of %d games, %s won %d -- tied %d -- lost %d, games against %s\n", games, ais[0].getName(), wins, ties, games - wins - ties, ais[1].getName());
|
||||
// System.out.printf("Average win rate was: %.2f\n\n", wins / (float)games);
|
||||
// }
|
||||
System.out.printf("Out of %d games, %s won %d -- tied %d -- lost %d, games against %s\n", games, ais[0].getName(), wins, ties, games - wins - ties, ais[1].getName());
|
||||
System.out.printf("Average win rate was: %.2f\n\n", wins / (float)games);
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,7 @@ import org.toop.app.widget.popup.ErrorPopup;
|
||||
import org.toop.app.widget.popup.SendChallengePopup;
|
||||
import org.toop.app.widget.view.ServerView;
|
||||
import org.toop.framework.eventbus.EventFlow;
|
||||
import org.toop.framework.game.players.ArtificialPlayer;
|
||||
import org.toop.framework.game.players.OnlinePlayer;
|
||||
import org.toop.framework.gameFramework.controller.GameController;
|
||||
import org.toop.framework.eventbus.GlobalEventBus;
|
||||
@@ -19,7 +20,7 @@ import org.toop.framework.networking.connection.clients.TournamentNetworkingClie
|
||||
import org.toop.framework.networking.connection.events.NetworkEvents;
|
||||
import org.toop.framework.networking.connection.types.NetworkingConnector;
|
||||
import org.toop.framework.networking.server.gateway.NettyGatewayServer;
|
||||
import org.toop.framework.game.players.LocalPlayer;
|
||||
import org.toop.game.players.ai.mcts.MCTSAI3;
|
||||
import org.toop.local.AppContext;
|
||||
|
||||
import java.util.Arrays;
|
||||
@@ -208,7 +209,8 @@ public final class Server {
|
||||
information.players[opponentStartingTurn].name = response.opponent();
|
||||
|
||||
Player[] players = new Player[2];
|
||||
players[userStartingTurn] = new LocalPlayer(user);
|
||||
|
||||
players[userStartingTurn] = new ArtificialPlayer(new MCTSAI3(1000, Runtime.getRuntime().availableProcessors()), user);
|
||||
players[opponentStartingTurn] = new OnlinePlayer(response.opponent());
|
||||
|
||||
switch (type) {
|
||||
@@ -244,7 +246,8 @@ public final class Server {
|
||||
private void handleTournamentResult(NetworkEvents.TournamentResultResponse response) {
|
||||
IO.println(response.gameType());
|
||||
IO.println(Arrays.toString(response.names()));
|
||||
IO.println(Arrays.toString(response.scores()));
|
||||
IO.println(Arrays.toString(response.scoreTypes()));
|
||||
IO.println(Arrays.toString(response.scores().toArray()));
|
||||
}
|
||||
|
||||
private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {
|
||||
|
||||
@@ -2,9 +2,13 @@ package org.toop.app.canvas;
|
||||
|
||||
import javafx.scene.paint.Color;
|
||||
import org.toop.app.App;
|
||||
import org.toop.framework.game.games.reversi.BitboardReversi;
|
||||
import org.toop.framework.game.players.LocalPlayer;
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
|
||||
public class ReversiBitCanvas extends BitGameCanvas {
|
||||
private TurnBasedGame gameCopy;
|
||||
private int previousCell;
|
||||
public ReversiBitCanvas() {
|
||||
super(Color.GRAY, new Color(0f, 0.4f, 0.2f, 1f), (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3, 8, 8, 5, true);
|
||||
canvas.setOnMouseMoved(event -> {
|
||||
@@ -20,6 +24,9 @@ public class ReversiBitCanvas extends BitGameCanvas {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (hovered != null) {
|
||||
checkHoverDots(hovered, cellId);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@@ -31,9 +38,31 @@ public class ReversiBitCanvas extends BitGameCanvas {
|
||||
|
||||
@Override
|
||||
public void redraw(TurnBasedGame gameCopy) {
|
||||
this.gameCopy = gameCopy;
|
||||
clearAll();
|
||||
long[] board = gameCopy.getBoard();
|
||||
loopOverBoard(board[0], (i) -> drawDot(Color.WHITE, i));
|
||||
loopOverBoard(board[1], (i) -> drawDot(Color.BLACK, i));
|
||||
}
|
||||
|
||||
public void drawLegalDots(TurnBasedGame gameCopy){
|
||||
long legal = gameCopy.getLegalMoves();
|
||||
loopOverBoard(legal, (i) -> drawInnerDot(gameCopy.getCurrentTurn()==0?new Color(1f,1f,1f,0.65f) :new Color(0f,0f,0f,0.65f), i,false));
|
||||
}
|
||||
|
||||
private void checkHoverDots(BitGameCanvas.Cell hovered, int cellId){
|
||||
if (previousCell == cellId){
|
||||
return;
|
||||
}
|
||||
long backflips = ((BitboardReversi)gameCopy).getFlips(1L << previousCell);
|
||||
loopOverBoard(backflips, (i) -> drawInnerDot(gameCopy.getCurrentTurn()==1?Color.WHITE:Color.BLACK, i,true));
|
||||
previousCell = cellId;
|
||||
if (gameCopy.getPlayer(gameCopy.getCurrentTurn()) instanceof LocalPlayer) {
|
||||
long legal = gameCopy.getLegalMoves();
|
||||
if ((legal & (1L << cellId)) != 0) {
|
||||
long flips = ((BitboardReversi) gameCopy).getFlips(1L << cellId);
|
||||
loopOverBoard(flips, (i) -> drawInnerDot(gameCopy.getCurrentTurn() == 0 ? Color.WHITE : Color.BLACK, i, false));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,6 +5,7 @@ import javafx.geometry.Pos;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.toop.app.canvas.GameCanvas;
|
||||
import org.toop.app.canvas.ReversiBitCanvas;
|
||||
import org.toop.app.widget.WidgetContainer;
|
||||
import org.toop.app.widget.view.GameView;
|
||||
import org.toop.framework.eventbus.EventFlow;
|
||||
@@ -153,6 +154,12 @@ public class GenericGameController implements GameController {
|
||||
|
||||
@Override
|
||||
public void updateUI() {
|
||||
canvas.redraw(game.deepCopy());
|
||||
TurnBasedGame gameCopy = game.deepCopy();
|
||||
canvas.redraw(gameCopy);
|
||||
String gameType = game.getClass().getSimpleName().replace("Bitboard","");
|
||||
gameView.nextPlayer(true, getCurrentPlayer().getName(), game.getPlayer(1-getCurrentPlayerIndex()).getName(),gameType);
|
||||
if (getCurrentPlayer() instanceof LocalPlayer && gameType.equals("Reversi")){
|
||||
((ReversiBitCanvas)canvas).drawLegalDots(gameCopy);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,6 +6,8 @@ import javafx.scene.text.Font;
|
||||
import org.toop.app.widget.Primitive;
|
||||
import org.toop.app.widget.complex.ViewWidget;
|
||||
import org.toop.app.widget.popup.GameOverPopup;
|
||||
|
||||
import java.util.Objects;
|
||||
import java.util.function.Consumer;
|
||||
import javafx.application.Platform;
|
||||
import javafx.geometry.Pos;
|
||||
@@ -94,7 +96,7 @@ public final class GameView extends ViewWidget {
|
||||
}
|
||||
}
|
||||
|
||||
public void nextPlayer(boolean isMe, String currentPlayer, String currentMove, String nextPlayer, char GameType) {
|
||||
public void nextPlayer(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
|
||||
Platform.runLater(() -> {
|
||||
if (!(hasSet)) {
|
||||
playerHeader.setText(currentPlayer + " vs. " + nextPlayer);
|
||||
@@ -112,8 +114,8 @@ public final class GameView extends ViewWidget {
|
||||
new GameOverPopup(iWon, winner).show(Pos.CENTER);
|
||||
}
|
||||
|
||||
private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, char GameType) {
|
||||
if (GameType == 'T') {
|
||||
private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
|
||||
if (Objects.equals(GameType, "TicTacToe")) {
|
||||
if (isMe) {
|
||||
player1Header.setText("X: " + currentPlayer);
|
||||
player2Header.setText("O: " + nextPlayer);
|
||||
@@ -124,7 +126,7 @@ public final class GameView extends ViewWidget {
|
||||
}
|
||||
setPlayerInfoTTT();
|
||||
}
|
||||
else if (GameType == 'R') {
|
||||
else if (Objects.equals(GameType, "Reversi")) {
|
||||
if (isMe) {
|
||||
player1Header.setText(currentPlayer);
|
||||
player2Header.setText(nextPlayer);
|
||||
@@ -172,8 +174,8 @@ public final class GameView extends ViewWidget {
|
||||
|
||||
player1Icon.setRadius(player1Header.fontProperty().map(Font::getSize).getValue());
|
||||
player2Icon.setRadius(player2Header.fontProperty().map(Font::getSize).getValue());
|
||||
player1Icon.setFill(Color.BLACK);
|
||||
player2Icon.setFill(Color.WHITE);
|
||||
player1Icon.setFill(Color.WHITE);
|
||||
player2Icon.setFill(Color.BLACK);
|
||||
add(Pos.TOP_RIGHT, playerInfo);
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,7 @@ import javafx.application.Platform;
|
||||
import org.toop.app.GameInformation;
|
||||
import org.toop.app.gameControllers.ReversiBitController;
|
||||
import org.toop.app.gameControllers.TicTacToeBitController;
|
||||
import org.toop.framework.game.players.LocalPlayer;
|
||||
import org.toop.framework.gameFramework.controller.GameController;
|
||||
import org.toop.framework.gameFramework.model.player.Player;
|
||||
import org.toop.framework.game.players.ArtificialPlayer;
|
||||
@@ -12,11 +13,10 @@ import org.toop.app.widget.complex.PlayerInfoWidget;
|
||||
import org.toop.app.widget.complex.ViewWidget;
|
||||
import org.toop.app.widget.popup.ErrorPopup;
|
||||
import org.toop.app.widget.tutorial.*;
|
||||
import org.toop.framework.game.players.LocalPlayer;
|
||||
import org.toop.game.players.ai.MCTSAI;
|
||||
import org.toop.game.players.ai.MCTSAI2;
|
||||
import org.toop.game.players.ai.MCTSAI3;
|
||||
import org.toop.game.players.ai.MiniMaxAI;
|
||||
import org.toop.game.players.ai.mcts.MCTSAI1;
|
||||
import org.toop.game.players.ai.mcts.MCTSAI3;
|
||||
import org.toop.game.players.ai.mcts.MCTSAI4;
|
||||
import org.toop.local.AppContext;
|
||||
|
||||
import javafx.geometry.Pos;
|
||||
@@ -54,7 +54,7 @@ public class LocalMultiplayerView extends ViewWidget {
|
||||
if (information.players[0].isHuman) {
|
||||
players[0] = new LocalPlayer(information.players[0].name);
|
||||
} else {
|
||||
players[0] = new ArtificialPlayer(new MCTSAI(100), "MCTS AI");
|
||||
players[0] = new ArtificialPlayer(new MCTSAI1(100), "MCTS AI");
|
||||
}
|
||||
if (information.players[1].isHuman) {
|
||||
players[1] = new LocalPlayer(information.players[1].name);
|
||||
@@ -83,12 +83,12 @@ public class LocalMultiplayerView extends ViewWidget {
|
||||
players[0] = new LocalPlayer(information.players[0].name);
|
||||
} else {
|
||||
// players[0] = new ArtificialPlayer(new RandomAI<BitboardReversi>(), "Random AI");
|
||||
players[0] = new ArtificialPlayer(new MCTSAI3(50), "MCTS V3 AI");
|
||||
players[0] = new ArtificialPlayer(new MCTSAI4(500, 4), "MCTS V4 AI");
|
||||
}
|
||||
if (information.players[1].isHuman) {
|
||||
players[1] = new LocalPlayer(information.players[1].name);
|
||||
} else {
|
||||
players[1] = new ArtificialPlayer(new MCTSAI2(50), "MCTS V2 AI");
|
||||
players[1] = new ArtificialPlayer(new MCTSAI1(500), "MCTS V1 AI");
|
||||
}
|
||||
if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
|
||||
new ShowEnableTutorialWidget(
|
||||
|
||||
@@ -6,6 +6,7 @@ import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.framework.gameFramework.model.player.Player;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
// There is AI performance to be gained by getting rid of non-primitives and thus speeding up deepCopy
|
||||
public abstract class BitboardGame implements TurnBasedGame {
|
||||
|
||||
@@ -1,31 +1,39 @@
|
||||
package org.toop.framework.game.gameThreads;
|
||||
|
||||
import org.toop.framework.eventbus.EventFlow;
|
||||
import org.toop.framework.gameFramework.GameState;
|
||||
import org.toop.framework.gameFramework.model.game.PlayResult;
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.framework.gameFramework.model.game.threadBehaviour.AbstractThreadBehaviour;
|
||||
import org.toop.framework.gameFramework.model.player.Player;
|
||||
import org.toop.framework.gameFramework.view.GUIEvents;
|
||||
import org.toop.framework.utils.ImmutablePair;
|
||||
import org.toop.framework.utils.Pair;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.concurrent.*;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import static org.toop.framework.gameFramework.GameState.TURN_SKIPPED;
|
||||
import static org.toop.framework.gameFramework.GameState.WIN;
|
||||
|
||||
public class ServerThreadBehaviour extends AbstractThreadBehaviour implements Runnable {
|
||||
private final Consumer<ImmutablePair<String, Integer>> onPlayerMove;
|
||||
private final Consumer<Pair<GameState, Integer>> onGameEnd;
|
||||
|
||||
private final ExecutorService moveExecutor = Executors.newSingleThreadExecutor();
|
||||
|
||||
private final Duration timeOut;
|
||||
/**
|
||||
* Creates a new base behaviour for the specified game.
|
||||
*
|
||||
* @param game the turn-based game to control
|
||||
*/
|
||||
public ServerThreadBehaviour(TurnBasedGame game, Consumer<ImmutablePair<String, Integer>> onPlayerMove, Consumer<Pair<GameState, Integer>> onGameEnd) {
|
||||
public ServerThreadBehaviour(
|
||||
TurnBasedGame game,
|
||||
Consumer<ImmutablePair<String,
|
||||
Integer>> onPlayerMove,
|
||||
Consumer<Pair<GameState, Integer>> onGameEnd,
|
||||
Duration timeOut
|
||||
) {
|
||||
this.onPlayerMove = onPlayerMove;
|
||||
this.onGameEnd = onGameEnd;
|
||||
this.timeOut = timeOut;
|
||||
super(game);
|
||||
}
|
||||
|
||||
@@ -59,23 +67,42 @@ public class ServerThreadBehaviour extends AbstractThreadBehaviour implements Ru
|
||||
public void run() {
|
||||
while (isRunning.get()) {
|
||||
Player currentPlayer = game.getPlayer(game.getCurrentTurn());
|
||||
long move = currentPlayer.getMove(game.deepCopy());
|
||||
PlayResult result = game.play(move);
|
||||
|
||||
GameState state = result.state();
|
||||
notifyPlayerMove(new ImmutablePair<>(currentPlayer.getName(), Long.numberOfTrailingZeros(move)));
|
||||
Future<Long> move = moveExecutor.submit(() -> currentPlayer.getMove(game.deepCopy()));
|
||||
|
||||
switch (state) {
|
||||
case WIN, DRAW -> {
|
||||
isRunning.set(false);
|
||||
notifyGameEnd(new ImmutablePair<>(state, game.getWinner()));
|
||||
}
|
||||
case NORMAL, TURN_SKIPPED -> { /* continue normally */ }
|
||||
default -> {
|
||||
logger.error("Unexpected state {}", state);
|
||||
isRunning.set(false);
|
||||
throw new RuntimeException("Unknown state: " + state);
|
||||
PlayResult result;
|
||||
try {
|
||||
long moveResult = move.get(timeOut.toMillis(), TimeUnit.MILLISECONDS);
|
||||
result = game.play(moveResult);
|
||||
|
||||
GameState state = result.state();
|
||||
notifyPlayerMove(new ImmutablePair<>(currentPlayer.getName(), Long.numberOfTrailingZeros(moveResult)));
|
||||
|
||||
switch (state) {
|
||||
case WIN, DRAW -> {
|
||||
isRunning.set(false);
|
||||
moveExecutor.shutdown();
|
||||
notifyGameEnd(new ImmutablePair<>(state, game.getWinner()));
|
||||
}
|
||||
case NORMAL, TURN_SKIPPED -> { /* continue normally */ }
|
||||
default -> {
|
||||
logger.error("Unexpected state {}", state);
|
||||
isRunning.set(false);
|
||||
moveExecutor.shutdown();
|
||||
throw new RuntimeException("Unknown state: " + state);
|
||||
}
|
||||
}
|
||||
|
||||
} catch (InterruptedException | ExecutionException e) {
|
||||
isRunning.set(false);
|
||||
notifyGameEnd(new ImmutablePair<>(GameState.DRAW, 0));
|
||||
moveExecutor.shutdown();
|
||||
return;
|
||||
} catch (TimeoutException e) {
|
||||
isRunning.set(false);
|
||||
notifyGameEnd(new ImmutablePair<>(GameState.WIN, 1+game.getWinner()%2));
|
||||
moveExecutor.shutdown();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -321,8 +321,51 @@ public class BitboardReversi extends BitboardGame {
|
||||
else if (blackCount > whiteCount){
|
||||
return 0;
|
||||
}
|
||||
else{
|
||||
else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public float rateMove(long move) {
|
||||
final long corners = 0x8100000000000081L;
|
||||
|
||||
if ((move & corners) != 0L) {
|
||||
return 0.4f;
|
||||
}
|
||||
|
||||
final long xSquares = 0x0042000000004200L;
|
||||
|
||||
if ((move & xSquares) != 0) {
|
||||
return -0.4f;
|
||||
}
|
||||
|
||||
final long cSquares = 0x4281000000008142L;
|
||||
|
||||
if ((move & cSquares) != 0) {
|
||||
return -0.1f;
|
||||
}
|
||||
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long heuristicMove(long legalMoves) {
|
||||
long bestMove = 0L;
|
||||
float bestMoveRate = Float.NEGATIVE_INFINITY;
|
||||
|
||||
while (legalMoves != 0L) {
|
||||
final long move = legalMoves & -legalMoves;
|
||||
final float moveRate = rateMove(move);
|
||||
|
||||
if (moveRate > bestMoveRate) {
|
||||
bestMove = move;
|
||||
bestMoveRate = moveRate;
|
||||
}
|
||||
|
||||
legalMoves &= ~move;
|
||||
}
|
||||
|
||||
return bestMove;
|
||||
}
|
||||
}
|
||||
@@ -110,4 +110,14 @@ public class BitboardTicTacToe extends BitboardGame {
|
||||
public BitboardTicTacToe deepCopy() {
|
||||
return new BitboardTicTacToe(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public float rateMove(long move) {
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long heuristicMove(long legalMoves) {
|
||||
return legalMoves;
|
||||
}
|
||||
}
|
||||
@@ -57,4 +57,8 @@ public class ArtificialPlayer extends AbstractPlayer {
|
||||
public ArtificialPlayer deepCopy() {
|
||||
return new ArtificialPlayer(this);
|
||||
}
|
||||
|
||||
public AI getAi() {
|
||||
return ai;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -29,13 +29,8 @@ public class ServerPlayer extends AbstractPlayer {
|
||||
@Override
|
||||
public long determineMove(TurnBasedGame game) {
|
||||
lastMove = new CompletableFuture<>();
|
||||
System.out.println("Sending yourturn");
|
||||
client.send("SVR GAME YOURTURN {TURNMESSAGE: \"<bericht voor deze beurt>\"}\n");
|
||||
try {
|
||||
return lastMove.get();
|
||||
} catch (InterruptedException | ExecutionException e) {
|
||||
e.printStackTrace();
|
||||
return 0;
|
||||
}
|
||||
|
||||
client.send("SVR GAME YOURTURN {TURNMESSAGE: \"<bericht voor deze beurt>\"}");
|
||||
return lastMove.join();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,4 +13,7 @@ public interface TurnBasedGame extends DeepCopyable<TurnBasedGame> {
|
||||
PlayResult play(long move);
|
||||
PlayResult getState();
|
||||
boolean isTerminal();
|
||||
|
||||
float rateMove(long move);
|
||||
long heuristicMove(long legalMoves);
|
||||
}
|
||||
|
||||
@@ -65,7 +65,7 @@ public class NetworkEvents extends EventsBase {
|
||||
public record GameResultResponse(long clientId, String condition)
|
||||
implements GenericEvent {}
|
||||
|
||||
public record TournamentResultResponse(long clientId, String gameType, String[] names, Integer[] scores)
|
||||
public record TournamentResultResponse(long clientId, String gameType, String[] names, String[] scoreTypes, List<Integer[]> scores)
|
||||
implements GenericEvent {}
|
||||
|
||||
/** Indicates that a game move has been processed or received. */
|
||||
|
||||
@@ -3,7 +3,9 @@ package org.toop.framework.networking.connection.handlers;
|
||||
import io.netty.channel.ChannelHandlerContext;
|
||||
import io.netty.channel.ChannelInboundHandlerAdapter;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.regex.MatchResult;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
@@ -117,10 +119,13 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
|
||||
}
|
||||
|
||||
private void resultsHandler(String rec) {
|
||||
// TODO all of this
|
||||
|
||||
IO.println(rec);
|
||||
|
||||
String gameTypeRaw = extract(rec, "GAMETYPE");
|
||||
String usersRaw = extract(rec, "USERS");
|
||||
String scoreTypesRaw = extract(rec, "SCORETYPES");
|
||||
String scoresRaw = extract(rec, "SCORES");
|
||||
|
||||
if (usersRaw == null) return;
|
||||
@@ -134,16 +139,32 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
|
||||
users = new String[]{};
|
||||
}
|
||||
|
||||
String[] scoreTypes;
|
||||
if (scoreTypesRaw.length() > 2) {
|
||||
scoreTypes = Arrays.stream(scoreTypesRaw.substring(1, usersRaw.length() - 1).split(","))
|
||||
.map(s -> s.trim().replace("\"", ""))
|
||||
.toArray(String[]::new);
|
||||
} else {
|
||||
scoreTypes = new String[]{};
|
||||
}
|
||||
|
||||
if (scoresRaw == null) return;
|
||||
if (scoresRaw.length() > 2) {
|
||||
Integer[] scores = Arrays.stream(scoresRaw.substring(1, scoresRaw.length() - 1).split(","))
|
||||
.map(String::trim)
|
||||
.map(Integer::parseInt)
|
||||
.toArray(Integer[]::new);
|
||||
List<Integer[]> scores = Arrays.stream(
|
||||
scoresRaw.substring(1, scoresRaw.length() - 1) // remove outer []
|
||||
.split("\\],\\[")
|
||||
)
|
||||
.map(part -> part.replace("[", "").replace("]", ""))
|
||||
.map(part -> Arrays.stream(part.split(","))
|
||||
.map(String::trim)
|
||||
.map(Integer::parseInt)
|
||||
.toArray(Integer[]::new)
|
||||
)
|
||||
.toList();
|
||||
|
||||
eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scores));
|
||||
eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scoreTypes, scores));
|
||||
} else {
|
||||
eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, new Integer[]{}));
|
||||
eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scoreTypes, new ArrayList<>()));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -2,11 +2,12 @@ package org.toop.framework.networking.server;
|
||||
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
public interface GameServer<GAMETYPE, CLIENT, CHALLENGEIDTYPE> {
|
||||
GameResultFuture startGame(String gameType, CLIENT... clients);
|
||||
GameResultFuture startGame(String gameType, Duration turnTime, CLIENT... clients);
|
||||
|
||||
void addClient(CLIENT client);
|
||||
void removeClient(CLIENT client);
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
package org.toop.framework.networking.server;
|
||||
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
|
||||
import java.time.Duration;
|
||||
|
||||
@FunctionalInterface
|
||||
public interface MatchExecutor {
|
||||
GameResultFuture submit(String gameType, Duration turnTime, NettyClient... clients);
|
||||
}
|
||||
@@ -5,7 +5,7 @@ import org.toop.framework.gameFramework.GameState;
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.time.Duration;
|
||||
import java.util.Arrays;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
@@ -19,12 +19,13 @@ public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
|
||||
|
||||
private final CompletableFuture<Integer> resultFuture;
|
||||
|
||||
public OnlineTurnBasedGame(NettyClient[] admins, TurnBasedGame game, CompletableFuture<Integer> resultFuture, NettyClient... clients) {
|
||||
public OnlineTurnBasedGame(NettyClient[] admins, TurnBasedGame game, CompletableFuture<Integer> resultFuture, Duration timeOut, NettyClient... clients) {
|
||||
this.game = game;
|
||||
this.gameThread = new ServerThreadBehaviour(
|
||||
game,
|
||||
(pair) -> notifyMoveMade(pair.getLeft(), pair.getRight()),
|
||||
(pair) -> notifyGameEnd(pair.getLeft(), pair.getRight())
|
||||
(pair) -> notifyGameEnd(pair.getLeft(), pair.getRight()),
|
||||
timeOut
|
||||
);
|
||||
this.resultFuture = resultFuture;
|
||||
this.clients = clients;
|
||||
@@ -42,17 +43,15 @@ public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
|
||||
|
||||
private void notifyGameEnd(GameState state, int winner) {
|
||||
if (state == GameState.DRAW) {
|
||||
Arrays.stream(admins).forEach(a -> a.send(
|
||||
String.format("SVR GAME END")
|
||||
));
|
||||
Arrays.stream(admins).forEach(a -> a.send("SVR GAME END"));
|
||||
|
||||
for (NettyClient client : clients) {
|
||||
client.send(String.format("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}"));
|
||||
client.send("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}");
|
||||
}
|
||||
} else {
|
||||
Arrays.stream(admins).forEach(a -> a.send("SVR GAME END"));
|
||||
clients[winner].send(String.format("SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}"));
|
||||
clients[(winner+1)%2].send(String.format("SVR GAME LOSS {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}"));
|
||||
clients[winner].send("SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}");
|
||||
clients[(winner+1)%2].send("SVR GAME LOSS {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}");
|
||||
}
|
||||
|
||||
// Remove game from clients
|
||||
|
||||
@@ -11,9 +11,8 @@ import org.toop.framework.networking.server.stores.SubscriptionStore;
|
||||
import org.toop.framework.networking.server.stores.TurnBasedGameStore;
|
||||
import org.toop.framework.networking.server.stores.TurnBasedGameTypeStore;
|
||||
import org.toop.framework.networking.server.tournaments.*;
|
||||
import org.toop.framework.networking.server.tournaments.matchmakers.RoundRobinMatchMaker;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.BasicScoreSystem;
|
||||
import org.toop.framework.networking.server.tournaments.shufflers.RandomShuffle;
|
||||
import org.toop.framework.networking.server.tournaments.matchmakers.DoubleRoundRobinMatchMaker;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.*;
|
||||
import org.toop.framework.utils.ImmutablePair;
|
||||
|
||||
import java.util.*;
|
||||
@@ -111,7 +110,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
|
||||
public void acceptChallenge(Long challengeId) {
|
||||
for (var challenge : gameChallenges) {
|
||||
if (challenge.id() == challengeId) {
|
||||
startGame(challenge.acceptChallenge(), challenge.getUsers());
|
||||
startGame(challenge.acceptChallenge(), Duration.ofSeconds(10), challenge.getUsers());
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -133,7 +132,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
|
||||
}
|
||||
|
||||
@Override
|
||||
public GameResultFuture startGame(String gameType, NettyClient... clients) {
|
||||
public GameResultFuture startGame(String gameType, Duration turnTime, NettyClient... clients) {
|
||||
if (!gameTypesStore.all().containsKey(gameType)) return null;
|
||||
|
||||
try {
|
||||
@@ -146,6 +145,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
|
||||
getAdmins().toArray(NettyClient[]::new),
|
||||
gameTypesStore.create(gameType),
|
||||
gameResult,
|
||||
turnTime,
|
||||
clients
|
||||
);
|
||||
|
||||
@@ -167,6 +167,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
|
||||
clients[0].name(),
|
||||
gameType,
|
||||
clients[0].name()));
|
||||
|
||||
game.start();
|
||||
return grfReturn;
|
||||
} catch (Exception e) {
|
||||
@@ -250,7 +251,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
|
||||
userNames.remove(first);
|
||||
userNames.remove(second);
|
||||
|
||||
startGame(key, getUser(userLeft), getUser(userRight));
|
||||
startGame(key, Duration.ofSeconds(10), getUser(userLeft), getUser(userRight));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -294,47 +295,60 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
|
||||
var tournamentUsers = new ArrayList<>(onlineUsers());
|
||||
tournamentUsers.removeIf(admins::contains);
|
||||
|
||||
var matchMaker = new RoundRobinMatchMaker(tournamentUsers);
|
||||
if (shuffle) {
|
||||
matchMaker.shuffle(new RandomShuffle()); // Remove if not wanting to shuffle
|
||||
}
|
||||
|
||||
Tournament tournament = new Tournament.Builder()
|
||||
.server(this)
|
||||
.matchExecutor(this::startGame)
|
||||
.tournamentRunner(new AsyncTournamentRunner())
|
||||
.matchMaker(matchMaker)
|
||||
.scoreSystem(new BasicScoreSystem(tournamentUsers))
|
||||
.matchMaker(new DoubleRoundRobinMatchMaker())
|
||||
.addScoreSystem(new MatchCountScoreSystem())
|
||||
.addScoreSystem(new WinCountScoreSystem())
|
||||
.addScoreSystem(new DrawCountScoreSystem())
|
||||
.addScoreSystem(new LoseCountScoreSystem())
|
||||
.resultBroadcaster(this::endTournament)
|
||||
.turnTimeout(Duration.ofSeconds(10))
|
||||
.addPlayers(tournamentUsers.toArray(NettyClient[]::new))
|
||||
.addAdmins(admins.toArray(NettyClient[]::new))
|
||||
.build();
|
||||
|
||||
try {
|
||||
new Thread(() -> tournament.run(gameType)).start();
|
||||
} catch (IllegalArgumentException e) {
|
||||
admins.forEach(c -> c.send("ERR not enough clients to start a tournament"));
|
||||
} catch (RuntimeException e) {
|
||||
admins.forEach(c -> c.send("ERR no matches could be created to start a tournament with"));
|
||||
}
|
||||
new Thread(() -> tournament.run(gameType)).start();
|
||||
}
|
||||
|
||||
public void endTournament(Map<NettyClient, Integer> score, String gameType) {
|
||||
public void endTournament(List<IntegerScoreSystem> systems) {
|
||||
if (systems.isEmpty()) return;
|
||||
|
||||
List<String> u = new ArrayList<>();
|
||||
List<Integer> s = new ArrayList<>();
|
||||
Map<String, List<ImmutablePair<String, Integer>>> combined = new HashMap<>();
|
||||
|
||||
for (var entry : score.entrySet()) {
|
||||
u.add(entry.getKey().name());
|
||||
s.add(entry.getValue());
|
||||
for (var system : systems) {
|
||||
for (var player : system.getScore().keySet()) {
|
||||
combined.putIfAbsent(player.name(), new ArrayList<>());
|
||||
combined.get(player.name()).addLast(new ImmutablePair<>(system.scoreName(), system.getScore().get(player)));
|
||||
}
|
||||
}
|
||||
|
||||
List<String> names = new ArrayList<>();
|
||||
List<String> systemNames = new ArrayList<>();
|
||||
List<List<Integer>> scores = new ArrayList<>();
|
||||
|
||||
for (var player : combined.entrySet()) {
|
||||
names.addLast(player.getKey());
|
||||
scores.addLast(new ArrayList<>());
|
||||
for (var system : player.getValue()) {
|
||||
if (!systemNames.contains(system.getLeft())) systemNames.addLast(system.getLeft());
|
||||
scores.getLast().addLast(system.getRight());
|
||||
}
|
||||
}
|
||||
|
||||
Gson gson = new Gson();
|
||||
|
||||
String users = gson.toJson(u);
|
||||
String scores = gson.toJson(s);
|
||||
String namesJson = gson.toJson(names);
|
||||
String systemNamesJson = gson.toJson(systemNames);
|
||||
String scoresJson = gson.toJson(scores);
|
||||
|
||||
String msg = String.format(
|
||||
"SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORES: %s, TOURNAMENT: 1}",
|
||||
gameType,
|
||||
users,
|
||||
scores
|
||||
"SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORETYPES: %s, SCORES: %s, TOURNAMENT: 1}",
|
||||
"none", // TODO gametype
|
||||
namesJson,
|
||||
systemNamesJson,
|
||||
scoresJson
|
||||
);
|
||||
|
||||
for (var user : onlineUsers()) {
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
package org.toop.framework.networking.server.tournaments;
|
||||
|
||||
import org.toop.framework.networking.server.GameResultFuture;
|
||||
import org.toop.framework.networking.server.Server;
|
||||
import org.toop.framework.networking.server.MatchExecutor;
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.*;
|
||||
|
||||
@@ -13,16 +14,16 @@ public class AsyncTournamentRunner implements TournamentRunner {
|
||||
|
||||
@Override
|
||||
public void run(
|
||||
Server server,
|
||||
MatchExecutor matchRunner,
|
||||
MatchMaker matchMaker,
|
||||
ScoreSystem scoreSystem,
|
||||
List<IntegerScoreSystem> scoreSystems,
|
||||
ResultBroadcaster<IntegerScoreSystem> broadcaster,
|
||||
Duration turnTime,
|
||||
String gameType
|
||||
) {
|
||||
|
||||
ExecutorService matchExecutor =
|
||||
Executors.newFixedThreadPool(
|
||||
Runtime.getRuntime().availableProcessors()
|
||||
);
|
||||
ExecutorService matchExecutor = Executors.newVirtualThreadPerTaskExecutor();
|
||||
ExecutorService scoringExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
|
||||
|
||||
Queue<TournamentMatch> pendingMatches = new ConcurrentLinkedQueue<>();
|
||||
matchMaker.forEach(pendingMatches::add);
|
||||
@@ -52,8 +53,12 @@ public class AsyncTournamentRunner implements TournamentRunner {
|
||||
CompletableFuture<Void> f =
|
||||
CompletableFuture.runAsync(() -> {
|
||||
try {
|
||||
GameResultFuture game = server.startGame(gameType, a, b);
|
||||
scoreSystem.matchEndAwait(game);
|
||||
GameResultFuture game = matchRunner.submit(gameType, turnTime, a, b);
|
||||
|
||||
CompletableFuture.runAsync(
|
||||
() -> scoreSystems.forEach(s -> s.result(match, game.result().join())),
|
||||
scoringExecutor
|
||||
).join();
|
||||
} finally {
|
||||
a.clearGame();
|
||||
b.clearGame();
|
||||
@@ -70,7 +75,7 @@ public class AsyncTournamentRunner implements TournamentRunner {
|
||||
Thread.sleep(10); // Safety
|
||||
}
|
||||
|
||||
server.endTournament(scoreSystem.getScore(), gameType);
|
||||
broadcaster.broadcast(scoreSystems);
|
||||
|
||||
} catch (InterruptedException e) {
|
||||
Thread.currentThread().interrupt();
|
||||
|
||||
@@ -1,28 +1,37 @@
|
||||
package org.toop.framework.networking.server.tournaments;
|
||||
|
||||
import org.toop.framework.networking.server.GameResultFuture;
|
||||
import org.toop.framework.networking.server.Server;
|
||||
import org.toop.framework.networking.server.MatchExecutor;
|
||||
import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.*;
|
||||
|
||||
public class BasicTournamentRunner implements TournamentRunner {
|
||||
@Override
|
||||
public void run(Server server, MatchMaker matchMaker, ScoreSystem scoreSystem, String gameType) {
|
||||
public void run(
|
||||
MatchExecutor matchExecutor,
|
||||
MatchMaker matchMaker,
|
||||
List<IntegerScoreSystem> scoreSystems,
|
||||
ResultBroadcaster<IntegerScoreSystem> broadcaster,
|
||||
Duration turnTime,
|
||||
String gameType
|
||||
) {
|
||||
ExecutorService threadPool = Executors.newSingleThreadExecutor();
|
||||
try {
|
||||
threadPool.execute(() -> {
|
||||
for (TournamentMatch match : matchMaker) {
|
||||
// Play game and await the results
|
||||
GameResultFuture game = server.startGame(gameType, match.getClient0(), match.getClient1());
|
||||
scoreSystem.matchEndAwait(game);
|
||||
GameResultFuture game = matchExecutor.submit(gameType, turnTime, match.getClient0(), match.getClient1());
|
||||
scoreSystems.forEach(e -> e.result(match, game.result().join()));
|
||||
|
||||
match.getClient0().clearGame();
|
||||
match.getClient1().clearGame();
|
||||
}
|
||||
|
||||
server.endTournament(scoreSystem.getScore(), gameType);
|
||||
broadcaster.broadcast(scoreSystems);
|
||||
});
|
||||
} finally {
|
||||
threadPool.shutdown();
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
package org.toop.framework.networking.server.tournaments;
|
||||
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
@FunctionalInterface
|
||||
public interface ResultBroadcaster<T extends ScoreSystem<?, ?, ?>> {
|
||||
void broadcast(List<T> scoreSystem);
|
||||
}
|
||||
@@ -1,45 +1,71 @@
|
||||
package org.toop.framework.networking.server.tournaments;
|
||||
|
||||
import org.toop.framework.networking.server.Server;
|
||||
import org.toop.framework.networking.server.MatchExecutor;
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
|
||||
import org.toop.framework.networking.server.tournaments.shufflers.Shuffler;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
|
||||
public class Tournament {
|
||||
private final Server server;
|
||||
|
||||
private final ScoreSystem scoreSystem;
|
||||
private final MatchExecutor matchExecutor;
|
||||
private final List<IntegerScoreSystem> scoreSystems;
|
||||
private final TournamentRunner tournamentRunner;
|
||||
private final MatchMaker matchMaker;
|
||||
private final ResultBroadcaster<IntegerScoreSystem> broadcaster;
|
||||
private final NettyClient[] players;
|
||||
private final Duration turnTime;
|
||||
private final Shuffler shuffler;
|
||||
|
||||
private Tournament(Tournament.Builder builder) {
|
||||
server = builder.server;
|
||||
scoreSystem = builder.scoreSystem;
|
||||
matchExecutor = builder.matchExecutor;
|
||||
scoreSystems = builder.scoreSystems;
|
||||
tournamentRunner = builder.tournamentRunner;
|
||||
matchMaker = builder.matchMaker;
|
||||
broadcaster = builder.broadcaster;
|
||||
players = builder.players;
|
||||
turnTime = builder.turnTime;
|
||||
shuffler = builder.shuffler;
|
||||
}
|
||||
|
||||
public void run(String gameType) throws IllegalArgumentException {
|
||||
if (server.gameTypes().stream().noneMatch(e -> e.equalsIgnoreCase(gameType)))
|
||||
throw new IllegalArgumentException("Invalid game type");
|
||||
public void run(String gameType) {
|
||||
|
||||
Arrays.stream(players).forEach(e -> {
|
||||
matchMaker.addPlayer(e);
|
||||
scoreSystems.forEach(k -> k.addPlayer(e));
|
||||
});
|
||||
|
||||
if (shuffler != null) matchMaker.shuffle(shuffler);
|
||||
|
||||
tournamentRunner.run(matchExecutor, matchMaker, scoreSystems, broadcaster, turnTime, gameType);
|
||||
|
||||
tournamentRunner.run(server, matchMaker, scoreSystem, gameType);
|
||||
}
|
||||
|
||||
public static class Builder {
|
||||
private Server server;
|
||||
private ScoreSystem scoreSystem;
|
||||
private MatchExecutor matchExecutor;
|
||||
private List<IntegerScoreSystem> scoreSystems = new ArrayList<>();
|
||||
private TournamentRunner tournamentRunner;
|
||||
private MatchMaker matchMaker;
|
||||
private ResultBroadcaster<IntegerScoreSystem> broadcaster;
|
||||
private NettyClient[] players;
|
||||
private NettyClient[] observors;
|
||||
private NettyClient[] admins;
|
||||
private Duration turnTime = Duration.ofSeconds(10);
|
||||
private Shuffler shuffler;
|
||||
|
||||
public Builder server(Server server) {
|
||||
this.server = server;
|
||||
public Builder matchExecutor(MatchExecutor matchExecutor) {
|
||||
this.matchExecutor = matchExecutor;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder scoreSystem(ScoreSystem scoreSystem) {
|
||||
this.scoreSystem = scoreSystem;
|
||||
public Builder addScoreSystem(IntegerScoreSystem scoreSystem) {
|
||||
this.scoreSystems.addLast(scoreSystem);
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -53,11 +79,42 @@ public class Tournament {
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder resultBroadcaster(ResultBroadcaster<IntegerScoreSystem> broadcaster) {
|
||||
this.broadcaster = broadcaster;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder addPlayers(NettyClient[] players) {
|
||||
this.players = players;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder addObservers(NettyClient[] observors) { // TODO
|
||||
this.observors = observors;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder addAdmins(NettyClient[] admins) { // TODO
|
||||
this.admins = admins;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder turnTimeout(Duration turnTime) {
|
||||
this.turnTime = turnTime;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder addMatchShuffler(Shuffler shuffler) {
|
||||
this.shuffler = shuffler;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Tournament build() {
|
||||
Objects.requireNonNull(server, "server");
|
||||
Objects.requireNonNull(scoreSystem, "scoreSystem");
|
||||
Objects.requireNonNull(matchExecutor, "matchExecutor");
|
||||
Objects.requireNonNull(tournamentRunner, "tournamentRunner");
|
||||
Objects.requireNonNull(matchMaker, "matchMaker");
|
||||
Objects.requireNonNull(broadcaster, "resultBroadcaster"); // TODO is not always necessary and needs to be more generic, not just at the end
|
||||
Objects.requireNonNull(players, "players");
|
||||
return new Tournament(this);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,11 +8,11 @@ public class TournamentMatch extends ImmutablePair<NettyClient, NettyClient> {
|
||||
super(a, b);
|
||||
}
|
||||
|
||||
NettyClient getClient0() {
|
||||
public NettyClient getClient0() {
|
||||
return getLeft();
|
||||
}
|
||||
|
||||
NettyClient getClient1() {
|
||||
public NettyClient getClient1() {
|
||||
return getRight();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,13 @@
|
||||
package org.toop.framework.networking.server.tournaments;
|
||||
|
||||
import org.toop.framework.networking.server.Server;
|
||||
import org.toop.framework.networking.server.MatchExecutor;
|
||||
import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
|
||||
import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.util.List;
|
||||
|
||||
public interface TournamentRunner {
|
||||
void run(Server server, MatchMaker matchMaker, ScoreSystem scoreSystem, String gameType);
|
||||
void run(MatchExecutor matchExecutor, MatchMaker matchMaker, List<IntegerScoreSystem> scoreSystems,
|
||||
ResultBroadcaster<IntegerScoreSystem> broadcaster, Duration turnTime, String gameType);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
package org.toop.framework.networking.server.tournaments.matchmakers;
|
||||
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.TournamentMatch;
|
||||
import org.toop.framework.networking.server.tournaments.shufflers.Shuffler;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.NoSuchElementException;
|
||||
|
||||
public class DoubleRoundRobinMatchMaker implements MatchMaker {
|
||||
|
||||
private final List<NettyClient> players = new ArrayList<>();
|
||||
|
||||
public DoubleRoundRobinMatchMaker() {} // TODO let user decide store type
|
||||
|
||||
@Override
|
||||
public void addPlayer(NettyClient player) {
|
||||
players.addLast(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void shuffle(Shuffler shuffler) {
|
||||
if (players.size() < 2) return;
|
||||
shuffler.shuffle(players);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<NettyClient> getPlayers() {
|
||||
return players;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Iterator<TournamentMatch> iterator() {
|
||||
return new Iterator<>() {
|
||||
|
||||
private int i = 0;
|
||||
private int j = 1;
|
||||
private boolean reverse = false;
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return players.size() > 1
|
||||
&& i < players.size() - 1
|
||||
&& j < players.size();
|
||||
}
|
||||
|
||||
@Override
|
||||
public TournamentMatch next() {
|
||||
if (!hasNext()) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
|
||||
NettyClient home = players.get(i);
|
||||
NettyClient away = players.get(j);
|
||||
|
||||
TournamentMatch match = reverse ? new TournamentMatch(away, home) : new TournamentMatch(home, away);
|
||||
|
||||
advance();
|
||||
return match;
|
||||
}
|
||||
|
||||
private void advance() {
|
||||
j++;
|
||||
if (j >= players.size()) {
|
||||
i++;
|
||||
j = i + 1;
|
||||
|
||||
if (i >= players.size() - 1) {
|
||||
if (!reverse) {
|
||||
reverse = true;
|
||||
i = 0;
|
||||
j = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -7,6 +7,7 @@ import org.toop.framework.networking.server.tournaments.shufflers.Shuffler;
|
||||
import java.util.List;
|
||||
|
||||
public interface MatchMaker extends Iterable<TournamentMatch> {
|
||||
void addPlayer(NettyClient player);
|
||||
List<NettyClient> getPlayers();
|
||||
void shuffle(Shuffler shuffler);
|
||||
}
|
||||
|
||||
@@ -4,20 +4,25 @@ import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.TournamentMatch;
|
||||
import org.toop.framework.networking.server.tournaments.shufflers.Shuffler;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.NoSuchElementException;
|
||||
|
||||
public class RoundRobinMatchMaker implements MatchMaker {
|
||||
|
||||
private final List<NettyClient> players;
|
||||
private final List<NettyClient> players = new ArrayList<>();
|
||||
|
||||
public RoundRobinMatchMaker(List<NettyClient> players) {
|
||||
this.players = players;
|
||||
public RoundRobinMatchMaker() {} // TODO let user decide store type
|
||||
|
||||
@Override
|
||||
public void addPlayer(NettyClient player) {
|
||||
players.addLast(player);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void shuffle(Shuffler shuffler) {
|
||||
if (players.size() < 2) return;
|
||||
shuffler.shuffle(players);
|
||||
}
|
||||
|
||||
@@ -32,7 +37,6 @@ public class RoundRobinMatchMaker implements MatchMaker {
|
||||
|
||||
private int i = 0;
|
||||
private int j = 1;
|
||||
private boolean reverse = false;
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
@@ -50,26 +54,13 @@ public class RoundRobinMatchMaker implements MatchMaker {
|
||||
NettyClient home = players.get(i);
|
||||
NettyClient away = players.get(j);
|
||||
|
||||
TournamentMatch match = reverse ? new TournamentMatch(away, home) : new TournamentMatch(home, away);
|
||||
|
||||
advance();
|
||||
return match;
|
||||
}
|
||||
|
||||
private void advance() {
|
||||
j++;
|
||||
if (j >= players.size()) {
|
||||
i++;
|
||||
j = i + 1;
|
||||
|
||||
if (i >= players.size() - 1) {
|
||||
if (!reverse) {
|
||||
reverse = true;
|
||||
i = 0;
|
||||
j = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return new TournamentMatch(home, away);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
package org.toop.framework.networking.server.tournaments.scoresystems;
|
||||
|
||||
import org.toop.framework.networking.server.GameResultFuture;
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
public class BasicScoreSystem implements ScoreSystem {
|
||||
|
||||
private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
|
||||
|
||||
public BasicScoreSystem(List<NettyClient> store) {
|
||||
for (NettyClient c : store) {
|
||||
scores.putIfAbsent(c, getInitScore());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void matchEndAwait(GameResultFuture result) {
|
||||
|
||||
if (result.game().users().length < 2) return;
|
||||
|
||||
switch (result.result().join()) {
|
||||
case 0 -> givePoints(result.game().users()[0]);
|
||||
case 1 -> givePoints(result.game().users()[1]);
|
||||
case -1 -> {} // Draw
|
||||
default -> {}
|
||||
}
|
||||
}
|
||||
|
||||
private void givePoints(NettyClient client) {
|
||||
int clientScore = scores.get(client);
|
||||
scores.put(client, clientScore + getWinPointAmount());
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<NettyClient, Integer> getScore() {
|
||||
return scores;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
package org.toop.framework.networking.server.tournaments.scoresystems;
|
||||
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.TournamentMatch;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
public class DrawCountScoreSystem implements IntegerScoreSystem {
|
||||
|
||||
private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
|
||||
private final int INIT_SCORE = 0;
|
||||
private final int WIN_POINTS = 1;
|
||||
|
||||
public DrawCountScoreSystem() {} // TODO let user decide store type
|
||||
|
||||
@Override
|
||||
public String scoreName() {
|
||||
return "draws";
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addPlayer(NettyClient user) {
|
||||
scores.putIfAbsent(user, INIT_SCORE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void result(TournamentMatch match, Integer result) {
|
||||
switch (result) {
|
||||
case 0, 1 -> {}
|
||||
case -1 -> {
|
||||
scores.merge(match.getClient0(), WIN_POINTS, Integer::sum);
|
||||
scores.merge(match.getClient1(), WIN_POINTS, Integer::sum);
|
||||
}
|
||||
default -> throw new IllegalArgumentException("Unknown result: " + result);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<NettyClient, Integer> getScore() {
|
||||
return scores;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
package org.toop.framework.networking.server.tournaments.scoresystems;
|
||||
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.TournamentMatch;
|
||||
|
||||
public interface IntegerScoreSystem extends ScoreSystem<TournamentMatch, Integer, NettyClient> {}
|
||||
@@ -0,0 +1,41 @@
|
||||
package org.toop.framework.networking.server.tournaments.scoresystems;
|
||||
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.TournamentMatch;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
public class LoseCountScoreSystem implements IntegerScoreSystem {
|
||||
|
||||
private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
|
||||
private final int INIT_SCORE = 0;
|
||||
private final int WIN_POINTS = 1;
|
||||
|
||||
public LoseCountScoreSystem() {} // TODO let user decide store type
|
||||
|
||||
@Override
|
||||
public String scoreName() {
|
||||
return "loses";
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addPlayer(NettyClient user) {
|
||||
scores.putIfAbsent(user, INIT_SCORE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void result(TournamentMatch match, Integer result) {
|
||||
switch (result) {
|
||||
case 0 -> scores.merge(match.getClient1(), WIN_POINTS, Integer::sum);
|
||||
case 1 -> scores.merge(match.getClient0(), WIN_POINTS, Integer::sum);
|
||||
case -1 -> {} // Draw
|
||||
default -> throw new IllegalArgumentException("Unknown result: " + result);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<NettyClient, Integer> getScore() {
|
||||
return scores;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
package org.toop.framework.networking.server.tournaments.scoresystems;
|
||||
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.TournamentMatch;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
public class MatchCountScoreSystem implements IntegerScoreSystem {
|
||||
|
||||
private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
|
||||
private final int INIT_SCORE = 0;
|
||||
private final int WIN_POINTS = 1;
|
||||
|
||||
public MatchCountScoreSystem() {} // TODO let user decide store type
|
||||
|
||||
@Override
|
||||
public String scoreName() {
|
||||
return "matches";
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addPlayer(NettyClient user) {
|
||||
scores.putIfAbsent(user, INIT_SCORE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void result(TournamentMatch match, Integer result) {
|
||||
scores.merge(match.getClient0(), WIN_POINTS, Integer::sum);
|
||||
scores.merge(match.getClient1(), WIN_POINTS, Integer::sum);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<NettyClient, Integer> getScore() {
|
||||
return scores;
|
||||
}
|
||||
}
|
||||
@@ -1,19 +1,10 @@
|
||||
package org.toop.framework.networking.server.tournaments.scoresystems;
|
||||
|
||||
import org.toop.framework.networking.server.GameResultFuture;
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.TournamentMatch;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
public interface ScoreSystem {
|
||||
void matchEndAwait(GameResultFuture result);
|
||||
Map<NettyClient, Integer> getScore();
|
||||
|
||||
default int getWinPointAmount() {
|
||||
return 1;
|
||||
}
|
||||
default int getInitScore() {
|
||||
return 0;
|
||||
}
|
||||
public interface ScoreSystem<MATCHTYPE, SCORETYPE, USERTYPE> {
|
||||
String scoreName();
|
||||
void addPlayer(USERTYPE user);
|
||||
void result(MATCHTYPE match, SCORETYPE result);
|
||||
Map<USERTYPE, SCORETYPE> getScore();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
package org.toop.framework.networking.server.tournaments.scoresystems;
|
||||
|
||||
import org.toop.framework.networking.server.client.NettyClient;
|
||||
import org.toop.framework.networking.server.tournaments.TournamentMatch;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
public class WinCountScoreSystem implements IntegerScoreSystem {
|
||||
|
||||
private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
|
||||
private final int INIT_SCORE = 0;
|
||||
private final int WIN_POINTS = 1;
|
||||
|
||||
public WinCountScoreSystem() {} // TODO let user decide store type
|
||||
|
||||
@Override
|
||||
public String scoreName() {
|
||||
return "wins";
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addPlayer(NettyClient user) {
|
||||
scores.putIfAbsent(user, INIT_SCORE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void result(TournamentMatch match, Integer result) {
|
||||
switch (result) {
|
||||
case 0 -> scores.merge(match.getClient0(), WIN_POINTS, Integer::sum);
|
||||
case 1 -> scores.merge(match.getClient1(), WIN_POINTS, Integer::sum);
|
||||
case -1 -> {} // Draw
|
||||
default -> throw new IllegalArgumentException("Unknown result: " + result);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Map<NettyClient, Integer> getScore() {
|
||||
return scores;
|
||||
}
|
||||
}
|
||||
@@ -1,193 +1,288 @@
|
||||
package org.toop.game.players.ai;
|
||||
|
||||
import org.toop.framework.gameFramework.GameState;
|
||||
import org.toop.framework.gameFramework.model.game.PlayResult;
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.framework.gameFramework.model.player.AbstractAI;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
public class MCTSAI extends AbstractAI {
|
||||
private static class Node {
|
||||
public abstract class MCTSAI extends AbstractAI {
|
||||
protected static class Node {
|
||||
public TurnBasedGame state;
|
||||
|
||||
public long move;
|
||||
public long unexpandedMoves;
|
||||
|
||||
public Node parent;
|
||||
|
||||
public int expanded;
|
||||
public Node[] children;
|
||||
|
||||
public int visits;
|
||||
public float value;
|
||||
public int visits;
|
||||
|
||||
public float heuristic;
|
||||
|
||||
public float solved;
|
||||
|
||||
public Node(TurnBasedGame state, Node parent, long move) {
|
||||
final long legalMoves = state.getLegalMoves();
|
||||
|
||||
public Node(TurnBasedGame state, long move, Node parent) {
|
||||
this.state = state;
|
||||
|
||||
this.move = move;
|
||||
this.unexpandedMoves = legalMoves;
|
||||
|
||||
this.parent = parent;
|
||||
this.children = new Node[Long.bitCount(legalMoves)];
|
||||
|
||||
this.expanded = 0;
|
||||
this.children = new Node[Long.bitCount(state.getLegalMoves())];
|
||||
|
||||
this.visits = 0;
|
||||
this.value = 0.0f;
|
||||
this.visits = 0;
|
||||
|
||||
this.heuristic = state.rateMove(move);
|
||||
|
||||
this.solved = Float.NaN;
|
||||
}
|
||||
|
||||
public Node(TurnBasedGame state) {
|
||||
this(state, 0L, null);
|
||||
this(state, null, 0L);
|
||||
}
|
||||
|
||||
public int getExpanded() {
|
||||
return children.length - Long.bitCount(unexpandedMoves);
|
||||
}
|
||||
|
||||
public boolean isFullyExpanded() {
|
||||
return expanded >= children.length;
|
||||
return unexpandedMoves == 0L;
|
||||
}
|
||||
|
||||
float calculateUCT() {
|
||||
float exploitation = visits <= 0? 0 : value / visits;
|
||||
float exploration = 1.41f * (float)(Math.sqrt(Math.log(visits) / visits));
|
||||
public float calculateUCT(int parentVisits) {
|
||||
if (visits == 0) {
|
||||
return Float.POSITIVE_INFINITY;
|
||||
}
|
||||
|
||||
return exploitation + exploration;
|
||||
final float exploitation = value / visits;
|
||||
final float exploration = (float)(Math.sqrt(Math.log(parentVisits) / visits));
|
||||
final float bias = heuristic * 10.0f / (visits + 1);
|
||||
|
||||
return exploitation + exploration + bias;
|
||||
}
|
||||
|
||||
public Node bestUCTChild() {
|
||||
int bestChildIndex = -1;
|
||||
float bestScore = Float.NEGATIVE_INFINITY;
|
||||
final int expanded = getExpanded();
|
||||
|
||||
Node highestUCTChild = null;
|
||||
float highestUCT = Float.NEGATIVE_INFINITY;
|
||||
|
||||
for (int i = 0; i < expanded; i++) {
|
||||
final float score = calculateUCT();
|
||||
final float childUCT = children[i].calculateUCT(visits);
|
||||
|
||||
if (score > bestScore) {
|
||||
bestChildIndex = i;
|
||||
bestScore = score;
|
||||
if (childUCT > highestUCT) {
|
||||
highestUCTChild = children[i];
|
||||
highestUCT = childUCT;
|
||||
}
|
||||
}
|
||||
|
||||
return bestChildIndex >= 0? children[bestChildIndex] : this;
|
||||
return highestUCTChild;
|
||||
}
|
||||
}
|
||||
|
||||
private final int milliseconds;
|
||||
protected static final ThreadLocal<Random> random = ThreadLocal.withInitial(Random::new);
|
||||
|
||||
protected final int milliseconds;
|
||||
|
||||
protected int lastIterations;
|
||||
|
||||
public MCTSAI(int milliseconds) {
|
||||
this.milliseconds = milliseconds;
|
||||
|
||||
this.lastIterations = 0;
|
||||
}
|
||||
|
||||
public MCTSAI(MCTSAI other) {
|
||||
this.milliseconds = other.milliseconds;
|
||||
|
||||
this.lastIterations = other.lastIterations;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MCTSAI deepCopy() {
|
||||
return new MCTSAI(this);
|
||||
public int getLastIterations() {
|
||||
return lastIterations;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getMove(TurnBasedGame game) {
|
||||
Node root = new Node(game.deepCopy());
|
||||
|
||||
long endTime = System.currentTimeMillis() + milliseconds;
|
||||
|
||||
while (System.currentTimeMillis() <= endTime) {
|
||||
Node node = selection(root);
|
||||
long legalMoves = node.state.getLegalMoves();
|
||||
|
||||
if (legalMoves != 0) {
|
||||
node = expansion(node, legalMoves);
|
||||
}
|
||||
|
||||
float result = 0.0f;
|
||||
|
||||
if (node.state.getLegalMoves() != 0) {
|
||||
result = simulation(node.state, game.getCurrentTurn());
|
||||
}
|
||||
|
||||
backPropagation(node, result);
|
||||
protected Node selection(Node root) {
|
||||
// while (Float.isNaN(root.solved) && root.isFullyExpanded() && !root.state.isTerminal()) {
|
||||
while (root.isFullyExpanded() && !root.state.isTerminal()) {
|
||||
root = root.bestUCTChild();
|
||||
}
|
||||
|
||||
int mostVisitedIndex = -1;
|
||||
int mostVisits = -1;
|
||||
|
||||
for (int i = 0; i < root.expanded; i++) {
|
||||
if (root.children[i].visits > mostVisits) {
|
||||
mostVisitedIndex = i;
|
||||
mostVisits = root.children[i].visits;
|
||||
}
|
||||
}
|
||||
|
||||
return mostVisitedIndex != -1? root.children[mostVisitedIndex].move : randomSetBit(game.getLegalMoves());
|
||||
return root;
|
||||
}
|
||||
|
||||
private Node selection(Node node) {
|
||||
while (node.state.getLegalMoves() != 0L && node.isFullyExpanded()) {
|
||||
node = node.bestUCTChild();
|
||||
protected Node expansion(Node leaf) {
|
||||
if (leaf.unexpandedMoves == 0L) {
|
||||
return leaf;
|
||||
}
|
||||
|
||||
return node;
|
||||
final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
|
||||
|
||||
final TurnBasedGame copiedState = leaf.state.deepCopy();
|
||||
copiedState.play(unexpandedMove);
|
||||
|
||||
final Node expandedChild = new Node(copiedState, leaf, unexpandedMove);
|
||||
|
||||
leaf.children[leaf.getExpanded()] = expandedChild;
|
||||
leaf.unexpandedMoves &= ~unexpandedMove;
|
||||
|
||||
return expandedChild;
|
||||
}
|
||||
|
||||
private Node expansion(Node node, long legalMoves) {
|
||||
for (int i = 0; i < node.expanded; i++) {
|
||||
legalMoves &= ~node.children[i].move;
|
||||
protected float simulation(Node leaf) {
|
||||
final TurnBasedGame copiedState = leaf.state.deepCopy();
|
||||
final int playerIndex = 1 - copiedState.getCurrentTurn();
|
||||
|
||||
while (!copiedState.isTerminal()) {
|
||||
final long legalMoves = copiedState.getLegalMoves();
|
||||
final long randomMove = randomSetBit(legalMoves);
|
||||
|
||||
copiedState.play(randomMove);
|
||||
}
|
||||
|
||||
if (legalMoves == 0L) {
|
||||
return node;
|
||||
if (copiedState.getWinner() == playerIndex) {
|
||||
return 1.0f;
|
||||
}
|
||||
|
||||
long move = randomSetBit(legalMoves);
|
||||
|
||||
TurnBasedGame copy = node.state.deepCopy();
|
||||
copy.play(move);
|
||||
|
||||
Node newlyExpanded = new Node(copy, move, node);
|
||||
|
||||
node.children[node.expanded] = newlyExpanded;
|
||||
node.expanded++;
|
||||
|
||||
return newlyExpanded;
|
||||
}
|
||||
|
||||
private float simulation(TurnBasedGame state, int playerIndex) {
|
||||
TurnBasedGame copy = state.deepCopy();
|
||||
long legalMoves = copy.getLegalMoves();
|
||||
PlayResult result = null;
|
||||
|
||||
while (legalMoves != 0) {
|
||||
result = copy.play(randomSetBit(legalMoves));
|
||||
legalMoves = copy.getLegalMoves();
|
||||
}
|
||||
|
||||
if (result.state() == GameState.WIN) {
|
||||
if (result.player() == playerIndex) {
|
||||
return 1.0f;
|
||||
}
|
||||
|
||||
if (copiedState.getWinner() >= 0) {
|
||||
return -1.0f;
|
||||
}
|
||||
|
||||
return -0.2f;
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
private void backPropagation(Node node, float value) {
|
||||
while (node != null) {
|
||||
node.visits++;
|
||||
node.value += value;
|
||||
node = node.parent;
|
||||
protected void backPropagation(Node leaf, float value) {
|
||||
while (leaf != null) {
|
||||
leaf.value += value;
|
||||
leaf.visits++;
|
||||
|
||||
if (Float.isNaN(leaf.solved)) {
|
||||
updateSolvedStatus(leaf);
|
||||
}
|
||||
|
||||
value = -value;
|
||||
leaf = leaf.parent;
|
||||
}
|
||||
}
|
||||
|
||||
public static long randomSetBit(long value) {
|
||||
Random random = new Random();
|
||||
protected Node mostVisitedChild(Node root) {
|
||||
final int expanded = root.getExpanded();
|
||||
|
||||
int count = Long.bitCount(value);
|
||||
int target = random.nextInt(count);
|
||||
Node mostVisitedChild = null;
|
||||
int mostVisited = -1;
|
||||
|
||||
while (true) {
|
||||
int bit = Long.numberOfTrailingZeros(value);
|
||||
if (target == 0) {
|
||||
return 1L << bit;
|
||||
for (int i = 0; i < expanded; i++) {
|
||||
if (root.children[i].visits > mostVisited) {
|
||||
mostVisitedChild = root.children[i];
|
||||
mostVisited = root.children[i].visits;
|
||||
}
|
||||
}
|
||||
|
||||
return mostVisitedChild;
|
||||
}
|
||||
|
||||
protected Node findOrResetRoot(Node root, TurnBasedGame game) {
|
||||
if (root == null) {
|
||||
return new Node(game.deepCopy());
|
||||
}
|
||||
|
||||
if (areStatesEqual(root.state.getBoard(), game.getBoard())) {
|
||||
return root;
|
||||
}
|
||||
|
||||
final int expanded = root.getExpanded();
|
||||
|
||||
for (int i = 0; i < expanded; i++) {
|
||||
if (areStatesEqual(root.children[i].state.getBoard(), game.getBoard())) {
|
||||
root.children[i].parent = null;
|
||||
return root.children[i];
|
||||
}
|
||||
}
|
||||
|
||||
return new Node(game.deepCopy());
|
||||
}
|
||||
|
||||
protected Node findChildByMove(Node root, long move) {
|
||||
final int expanded = root.getExpanded();
|
||||
|
||||
for (int i = 0; i < expanded; i++) {
|
||||
if (root.children[i].move == move) {
|
||||
root.children[i].parent = null;
|
||||
return root.children[i];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
protected boolean areStatesEqual(long[] state1, long[] state2) {
|
||||
if (state1.length != state2.length) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (int i = 0; i < state1.length; i++) {
|
||||
if (state1[i] != state2[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
protected long randomSetBit(long value) {
|
||||
if (0L == value) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
final int bitCount = Long.bitCount(value);
|
||||
final int randomBitCount = random.get().nextInt(bitCount);
|
||||
|
||||
for (int i = 0; i < randomBitCount; i++) {
|
||||
value &= value - 1;
|
||||
target--;
|
||||
}
|
||||
|
||||
return value & -value;
|
||||
}
|
||||
|
||||
private void updateSolvedStatus(Node node) {
|
||||
if (node.state.isTerminal()) {
|
||||
final int winner = node.state.getWinner();
|
||||
final int mover = 1 - node.state.getCurrentTurn();
|
||||
|
||||
node.solved = winner == mover? 1.0f : winner == -1? 0.0f : -1.0f;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (node.isFullyExpanded()) {
|
||||
boolean allChildrenSolved = true;
|
||||
boolean foundWinningMove = false;
|
||||
boolean foundDrawMove = false;
|
||||
|
||||
for (final Node child : node.children) {
|
||||
if (!Float.isNaN(child.solved)) {
|
||||
if (child.solved == -1.0f) {
|
||||
foundWinningMove = true;
|
||||
break;
|
||||
}
|
||||
|
||||
if (child.solved == 0.0f) {
|
||||
foundDrawMove = true;
|
||||
}
|
||||
} else {
|
||||
allChildrenSolved = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (foundWinningMove) {
|
||||
node.solved = 1.0f;
|
||||
} else if (allChildrenSolved) {
|
||||
node.solved = foundDrawMove? 0.0f : -1.0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,195 +0,0 @@
|
||||
package org.toop.game.players.ai;
|
||||
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.framework.gameFramework.model.player.AbstractAI;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
public class MCTSAI2 extends AbstractAI {
|
||||
private static class Node {
|
||||
public TurnBasedGame state;
|
||||
|
||||
public long move;
|
||||
public long unexpandedMoves;
|
||||
|
||||
public Node parent;
|
||||
|
||||
public Node[] children;
|
||||
public int expanded;
|
||||
|
||||
public float value;
|
||||
public int visits;
|
||||
|
||||
public Node(TurnBasedGame state, Node parent, long move) {
|
||||
final long legalMoves = state.getLegalMoves();
|
||||
|
||||
this.state = state;
|
||||
|
||||
this.move = move;
|
||||
this.unexpandedMoves = legalMoves;
|
||||
|
||||
this.parent = parent;
|
||||
|
||||
this.children = new Node[Long.bitCount(legalMoves)];
|
||||
this.expanded = 0;
|
||||
|
||||
this.value = 0.0f;
|
||||
this.visits = 0;
|
||||
}
|
||||
|
||||
public Node(TurnBasedGame state) {
|
||||
this(state, null, 0L);
|
||||
}
|
||||
|
||||
public boolean isFullyExpanded() {
|
||||
return expanded == children.length;
|
||||
}
|
||||
|
||||
public float calculateUCT(int parentVisits) {
|
||||
final float exploitation = value / visits;
|
||||
final float exploration = 1.41f * (float)(Math.sqrt(Math.log(parentVisits) / visits));
|
||||
|
||||
return exploitation + exploration;
|
||||
}
|
||||
|
||||
public Node bestUCTChild() {
|
||||
Node highestUCTChild = null;
|
||||
float highestUCT = Float.NEGATIVE_INFINITY;
|
||||
|
||||
for (int i = 0; i < expanded; i++) {
|
||||
final float childUCT = children[i].calculateUCT(visits);
|
||||
|
||||
if (childUCT > highestUCT) {
|
||||
highestUCTChild = children[i];
|
||||
highestUCT = childUCT;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return highestUCTChild;
|
||||
}
|
||||
}
|
||||
|
||||
private final Random random;
|
||||
private final int milliseconds;
|
||||
|
||||
public MCTSAI2(int milliseconds) {
|
||||
this.random = new Random();
|
||||
this.milliseconds = milliseconds;
|
||||
}
|
||||
|
||||
public MCTSAI2(MCTSAI2 other) {
|
||||
this.random = other.random;
|
||||
this.milliseconds = other.milliseconds;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MCTSAI2 deepCopy() {
|
||||
return new MCTSAI2(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getMove(TurnBasedGame game) {
|
||||
final Node root = new Node(game, null, 0L);
|
||||
|
||||
final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
|
||||
|
||||
while (System.nanoTime() < endTime) {
|
||||
Node leaf = selection(root);
|
||||
leaf = expansion(leaf);
|
||||
final float value = simulation(leaf);
|
||||
backPropagation(leaf, value);
|
||||
}
|
||||
|
||||
final Node mostVisitedChild = mostVisitedChild(root);
|
||||
|
||||
return mostVisitedChild != null? mostVisitedChild.move : 0L;
|
||||
}
|
||||
|
||||
private Node mostVisitedChild(Node root) {
|
||||
Node mostVisitedChild = null;
|
||||
int mostVisited = -1;
|
||||
|
||||
for (int i = 0; i < root.expanded; i++) {
|
||||
if (root.children[i].visits > mostVisited) {
|
||||
mostVisitedChild = root.children[i];
|
||||
mostVisited = root.children[i].visits;
|
||||
}
|
||||
}
|
||||
|
||||
return mostVisitedChild;
|
||||
}
|
||||
|
||||
private Node selection(Node root) {
|
||||
while (root.isFullyExpanded() && !root.state.isTerminal()) {
|
||||
root = root.bestUCTChild();
|
||||
}
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
private Node expansion(Node leaf) {
|
||||
if (leaf.unexpandedMoves == 0L) {
|
||||
return leaf;
|
||||
}
|
||||
|
||||
final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
|
||||
|
||||
final TurnBasedGame copiedState = leaf.state.deepCopy();
|
||||
copiedState.play(unexpandedMove);
|
||||
|
||||
final Node expandedChild = new Node(copiedState, leaf, unexpandedMove);
|
||||
|
||||
leaf.children[leaf.expanded] = expandedChild;
|
||||
leaf.expanded++;
|
||||
|
||||
leaf.unexpandedMoves &= ~unexpandedMove;
|
||||
|
||||
return expandedChild;
|
||||
}
|
||||
|
||||
private float simulation(Node leaf) {
|
||||
final TurnBasedGame copiedState = leaf.state.deepCopy();
|
||||
final int playerIndex = 1 - copiedState.getCurrentTurn();
|
||||
|
||||
while (!copiedState.isTerminal()) {
|
||||
final long legalMoves = copiedState.getLegalMoves();
|
||||
final long randomMove = randomSetBit(legalMoves);
|
||||
|
||||
copiedState.play(randomMove);
|
||||
}
|
||||
|
||||
if (copiedState.getWinner() == playerIndex) {
|
||||
return 1.0f;
|
||||
} else if (copiedState.getWinner() >= 0) {
|
||||
return -1.0f;
|
||||
}
|
||||
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
private void backPropagation(Node leaf, float value) {
|
||||
while (leaf != null) {
|
||||
leaf.value += value;
|
||||
leaf.visits++;
|
||||
|
||||
value = -value;
|
||||
leaf = leaf.parent;
|
||||
}
|
||||
}
|
||||
|
||||
private long randomSetBit(long value) {
|
||||
if (0L == value) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
final int bitCount = Long.bitCount(value);
|
||||
final int randomBitCount = random.nextInt(bitCount);
|
||||
|
||||
for (int i = 0; i < randomBitCount; i++) {
|
||||
value &= value - 1;
|
||||
}
|
||||
|
||||
return value & -value;
|
||||
}
|
||||
}
|
||||
@@ -1,258 +0,0 @@
|
||||
package org.toop.game.players.ai;
|
||||
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.framework.gameFramework.model.player.AbstractAI;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
public class MCTSAI3 extends AbstractAI {
|
||||
private static class Node {
|
||||
public TurnBasedGame state;
|
||||
|
||||
public long move;
|
||||
public long unexpandedMoves;
|
||||
|
||||
public Node parent;
|
||||
|
||||
public Node[] children;
|
||||
public int expanded;
|
||||
|
||||
public float value;
|
||||
public int visits;
|
||||
|
||||
public Node(TurnBasedGame state, Node parent, long move) {
|
||||
final long legalMoves = state.getLegalMoves();
|
||||
|
||||
this.state = state;
|
||||
|
||||
this.move = move;
|
||||
this.unexpandedMoves = legalMoves;
|
||||
|
||||
this.parent = parent;
|
||||
|
||||
this.children = new Node[Long.bitCount(legalMoves)];
|
||||
this.expanded = 0;
|
||||
|
||||
this.value = 0.0f;
|
||||
this.visits = 0;
|
||||
}
|
||||
|
||||
public Node(TurnBasedGame state) {
|
||||
this(state, null, 0L);
|
||||
}
|
||||
|
||||
public boolean isFullyExpanded() {
|
||||
return expanded == children.length;
|
||||
}
|
||||
|
||||
public float calculateUCT(int parentVisits) {
|
||||
final float exploitation = value / visits;
|
||||
final float exploration = 1.41f * (float)(Math.sqrt(Math.log(parentVisits) / visits));
|
||||
|
||||
return exploitation + exploration;
|
||||
}
|
||||
|
||||
public Node bestUCTChild() {
|
||||
Node highestUCTChild = null;
|
||||
float highestUCT = Float.NEGATIVE_INFINITY;
|
||||
|
||||
for (int i = 0; i < expanded; i++) {
|
||||
final float childUCT = children[i].calculateUCT(visits);
|
||||
|
||||
if (childUCT > highestUCT) {
|
||||
highestUCTChild = children[i];
|
||||
highestUCT = childUCT;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return highestUCTChild;
|
||||
}
|
||||
}
|
||||
|
||||
private final Random random;
|
||||
|
||||
private Node root;
|
||||
private final int milliseconds;
|
||||
|
||||
public MCTSAI3(int milliseconds) {
|
||||
this.random = new Random();
|
||||
|
||||
this.root = null;
|
||||
this.milliseconds = milliseconds;
|
||||
}
|
||||
|
||||
public MCTSAI3(MCTSAI3 other) {
|
||||
this.random = other.random;
|
||||
|
||||
this.root = other.root;
|
||||
this.milliseconds = other.milliseconds;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MCTSAI3 deepCopy() {
|
||||
return new MCTSAI3(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getMove(TurnBasedGame game) {
|
||||
detectRoot(game);
|
||||
|
||||
final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
|
||||
|
||||
while (System.nanoTime() < endTime) {
|
||||
Node leaf = selection(root);
|
||||
leaf = expansion(leaf);
|
||||
final float value = simulation(leaf);
|
||||
backPropagation(leaf, value);
|
||||
}
|
||||
|
||||
final Node mostVisitedChild = mostVisitedChild(root);
|
||||
final long move = mostVisitedChild != null? mostVisitedChild.move : 0L;
|
||||
|
||||
newRoot(move);
|
||||
|
||||
return move;
|
||||
}
|
||||
|
||||
private Node mostVisitedChild(Node root) {
|
||||
Node mostVisitedChild = null;
|
||||
int mostVisited = -1;
|
||||
|
||||
for (int i = 0; i < root.expanded; i++) {
|
||||
if (root.children[i].visits > mostVisited) {
|
||||
mostVisitedChild = root.children[i];
|
||||
mostVisited = root.children[i].visits;
|
||||
}
|
||||
}
|
||||
|
||||
return mostVisitedChild;
|
||||
}
|
||||
|
||||
private void detectRoot(TurnBasedGame game) {
|
||||
if (root == null) {
|
||||
root = new Node(game.deepCopy());
|
||||
return;
|
||||
}
|
||||
|
||||
final long[] currentBoards = game.getBoard();
|
||||
final long[] rootBoards = root.state.getBoard();
|
||||
|
||||
boolean detected = true;
|
||||
|
||||
for (int i = 0; i < rootBoards.length; i++) {
|
||||
if (rootBoards[i] != currentBoards[i]) {
|
||||
detected = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (detected) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = 0; i < root.expanded; i++) {
|
||||
final Node child = root.children[i];
|
||||
|
||||
final long[] childBoards = child.state.getBoard();
|
||||
|
||||
detected = true;
|
||||
|
||||
for (int j = 0; j < childBoards.length; j++) {
|
||||
if (childBoards[j] != currentBoards[j]) {
|
||||
detected = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (detected) {
|
||||
root = child;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
root = new Node(game.deepCopy());
|
||||
}
|
||||
|
||||
private void newRoot(long move) {
|
||||
for (final Node child : root.children) {
|
||||
if (child.move == move) {
|
||||
root = child;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private Node selection(Node root) {
|
||||
while (root.isFullyExpanded() && !root.state.isTerminal()) {
|
||||
root = root.bestUCTChild();
|
||||
}
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
private Node expansion(Node leaf) {
|
||||
if (leaf.unexpandedMoves == 0L) {
|
||||
return leaf;
|
||||
}
|
||||
|
||||
final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
|
||||
|
||||
final TurnBasedGame copiedState = leaf.state.deepCopy();
|
||||
copiedState.play(unexpandedMove);
|
||||
|
||||
final Node expandedChild = new Node(copiedState, leaf, unexpandedMove);
|
||||
|
||||
leaf.children[leaf.expanded] = expandedChild;
|
||||
leaf.expanded++;
|
||||
|
||||
leaf.unexpandedMoves &= ~unexpandedMove;
|
||||
|
||||
return expandedChild;
|
||||
}
|
||||
|
||||
private float simulation(Node leaf) {
|
||||
final TurnBasedGame copiedState = leaf.state.deepCopy();
|
||||
final int playerIndex = 1 - copiedState.getCurrentTurn();
|
||||
|
||||
while (!copiedState.isTerminal()) {
|
||||
final long legalMoves = copiedState.getLegalMoves();
|
||||
final long randomMove = randomSetBit(legalMoves);
|
||||
|
||||
copiedState.play(randomMove);
|
||||
}
|
||||
|
||||
if (copiedState.getWinner() == playerIndex) {
|
||||
return 1.0f;
|
||||
} else if (copiedState.getWinner() >= 0) {
|
||||
return -1.0f;
|
||||
}
|
||||
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
private void backPropagation(Node leaf, float value) {
|
||||
while (leaf != null) {
|
||||
leaf.value += value;
|
||||
leaf.visits++;
|
||||
|
||||
value = -value;
|
||||
leaf = leaf.parent;
|
||||
}
|
||||
}
|
||||
|
||||
private long randomSetBit(long value) {
|
||||
if (0L == value) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
final int bitCount = Long.bitCount(value);
|
||||
final int randomBitCount = random.nextInt(bitCount);
|
||||
|
||||
for (int i = 0; i < randomBitCount; i++) {
|
||||
value &= value - 1;
|
||||
}
|
||||
|
||||
return value & -value;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package org.toop.game.players.ai.mcts;
|
||||
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.game.players.ai.MCTSAI;
|
||||
|
||||
public class MCTSAI1 extends MCTSAI {
|
||||
public MCTSAI1(int milliseconds) {
|
||||
super(milliseconds);
|
||||
}
|
||||
|
||||
public MCTSAI1(MCTSAI1 other) {
|
||||
super(other);
|
||||
}
|
||||
|
||||
@Override
|
||||
public MCTSAI1 deepCopy() {
|
||||
return new MCTSAI1(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getMove(TurnBasedGame game) {
|
||||
final Node root = new Node(game, null, 0L);
|
||||
|
||||
final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
|
||||
|
||||
// while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
|
||||
while (System.nanoTime() < endTime) {
|
||||
Node leaf = selection(root);
|
||||
leaf = expansion(leaf);
|
||||
final float value = simulation(leaf);
|
||||
backPropagation(leaf, value);
|
||||
}
|
||||
|
||||
lastIterations = root.visits;
|
||||
|
||||
final Node mostVisitedChild = mostVisitedChild(root);
|
||||
return mostVisitedChild.move;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
package org.toop.game.players.ai.mcts;
|
||||
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.game.players.ai.MCTSAI;
|
||||
|
||||
public class MCTSAI2 extends MCTSAI {
|
||||
private Node root;
|
||||
|
||||
public MCTSAI2(int milliseconds) {
|
||||
super(milliseconds);
|
||||
|
||||
this.root = null;
|
||||
}
|
||||
|
||||
public MCTSAI2(MCTSAI2 other) {
|
||||
super(other);
|
||||
|
||||
this.root = other.root;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MCTSAI2 deepCopy() {
|
||||
return new MCTSAI2(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getMove(TurnBasedGame game) {
|
||||
root = findOrResetRoot(root, game);
|
||||
|
||||
final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
|
||||
|
||||
// while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
|
||||
while (System.nanoTime() < endTime) {
|
||||
Node leaf = selection(root);
|
||||
leaf = expansion(leaf);
|
||||
final float value = simulation(leaf);
|
||||
backPropagation(leaf, value);
|
||||
}
|
||||
|
||||
lastIterations = root.visits;
|
||||
|
||||
final Node mostVisitedChild = mostVisitedChild(root);
|
||||
final long move = mostVisitedChild.move;
|
||||
|
||||
root = findChildByMove(root, move);
|
||||
|
||||
return move;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
package org.toop.game.players.ai.mcts;
|
||||
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.game.players.ai.MCTSAI;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.Future;
|
||||
|
||||
public class MCTSAI3 extends MCTSAI {
|
||||
private final int threads;
|
||||
|
||||
public MCTSAI3(int milliseconds, int threads) {
|
||||
super(milliseconds);
|
||||
|
||||
this.threads = threads;
|
||||
}
|
||||
|
||||
public MCTSAI3(MCTSAI3 other) {
|
||||
super(other);
|
||||
|
||||
this.threads = other.threads;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MCTSAI3 deepCopy() {
|
||||
return new MCTSAI3(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getMove(TurnBasedGame game) {
|
||||
final ExecutorService pool = Executors.newFixedThreadPool(threads);
|
||||
final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
|
||||
|
||||
final List<Callable<Node>> tasks = new ArrayList<>();
|
||||
|
||||
for (int i = 0; i < threads; i++) {
|
||||
tasks.add(() -> {
|
||||
final Node localRoot = new Node(game.deepCopy());
|
||||
|
||||
// while (Float.isNaN(localRoot.solved) && System.nanoTime() < endTime) {
|
||||
while (System.nanoTime() < endTime) {
|
||||
Node leaf = selection(localRoot);
|
||||
leaf = expansion(leaf);
|
||||
final float value = simulation(leaf);
|
||||
backPropagation(leaf, value);
|
||||
}
|
||||
|
||||
return localRoot;
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
final List<Future<Node>> results = pool.invokeAll(tasks);
|
||||
|
||||
pool.shutdown();
|
||||
|
||||
final Node root = new Node(game.deepCopy());
|
||||
|
||||
for (int i = 0; i < root.children.length; i++) {
|
||||
expansion(root);
|
||||
}
|
||||
|
||||
for (final Future<Node> result : results) {
|
||||
final Node localRoot = result.get();
|
||||
|
||||
for (final Node localChild : localRoot.children) {
|
||||
for (int i = 0; i < root.children.length; i++) {
|
||||
if (localChild.move == root.children[i].move) {
|
||||
root.children[i].visits += localChild.visits;
|
||||
root.visits += localChild.visits;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lastIterations = root.visits;
|
||||
|
||||
final Node mostVisitedChild = mostVisitedChild(root);
|
||||
return mostVisitedChild.move;
|
||||
} catch (Exception _) {
|
||||
lastIterations = 0;
|
||||
|
||||
final long legalMoves = game.getLegalMoves();
|
||||
return randomSetBit(legalMoves);
|
||||
}
|
||||
}
|
||||
}
|
||||
107
game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI4.java
Normal file
107
game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI4.java
Normal file
@@ -0,0 +1,107 @@
|
||||
package org.toop.game.players.ai.mcts;
|
||||
|
||||
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
|
||||
import org.toop.game.players.ai.MCTSAI;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.Future;
|
||||
|
||||
public class MCTSAI4 extends MCTSAI {
|
||||
private final int threads;
|
||||
private final Node[] threadRoots;
|
||||
|
||||
public MCTSAI4(int milliseconds, int threads) {
|
||||
super(milliseconds);
|
||||
|
||||
this.threads = threads;
|
||||
this.threadRoots = new Node[threads];
|
||||
}
|
||||
|
||||
public MCTSAI4(MCTSAI4 other) {
|
||||
super(other);
|
||||
|
||||
this.threads = other.threads;
|
||||
this.threadRoots = other.threadRoots;
|
||||
}
|
||||
|
||||
@Override
|
||||
public MCTSAI4 deepCopy() {
|
||||
return new MCTSAI4(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getMove(TurnBasedGame game) {
|
||||
for (int i = 0; i < threads; i++) {
|
||||
threadRoots[i] = findOrResetRoot(threadRoots[i], game);
|
||||
}
|
||||
|
||||
final ExecutorService pool = Executors.newFixedThreadPool(threads);
|
||||
final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
|
||||
|
||||
final List<Callable<Node>> tasks = new ArrayList<>();
|
||||
|
||||
for (int i = 0; i < threads; i++) {
|
||||
final int threadIndex = i;
|
||||
|
||||
tasks.add(() -> {
|
||||
final Node localRoot = threadRoots[threadIndex];
|
||||
|
||||
// while (Float.isNaN(localRoot.solved) && System.nanoTime() < endTime) {
|
||||
while (System.nanoTime() < endTime) {
|
||||
Node leaf = selection(localRoot);
|
||||
leaf = expansion(leaf);
|
||||
final float value = simulation(leaf);
|
||||
backPropagation(leaf, value);
|
||||
}
|
||||
|
||||
return localRoot;
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
final List<Future<Node>> results = pool.invokeAll(tasks);
|
||||
|
||||
pool.shutdown();
|
||||
|
||||
final Node root = new Node(game.deepCopy());
|
||||
|
||||
for (int i = 0; i < root.children.length; i++) {
|
||||
expansion(root);
|
||||
}
|
||||
|
||||
for (final Future<Node> result : results) {
|
||||
final Node localRoot = result.get();
|
||||
|
||||
for (final Node localChild : localRoot.children) {
|
||||
for (int i = 0; i < root.children.length; i++) {
|
||||
if (localChild.move == root.children[i].move) {
|
||||
root.children[i].visits += localChild.visits;
|
||||
root.visits += localChild.visits;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lastIterations = root.visits;
|
||||
|
||||
final Node mostVisitedChild = mostVisitedChild(root);
|
||||
final long move = mostVisitedChild.move;
|
||||
|
||||
for (int i = 0; i < threads; i++) {
|
||||
threadRoots[i] = findChildByMove(threadRoots[i], move);
|
||||
}
|
||||
|
||||
return move;
|
||||
} catch (Exception _) {
|
||||
lastIterations = 0;
|
||||
|
||||
final long legalMoves = game.getLegalMoves();
|
||||
return randomSetBit(legalMoves);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user