stef_buwalda/pism
1
0
Fork 0
mirror of https://github.com/2OOP/pism.git synced 2026-02-04 19:04:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: stef_buwalda:223-create-a-reversi-ai-using-the-mcts-algorithm
Branches Tags
stef_buwalda:main stef_buwalda:Development stef_buwalda:223-create-a-reversi-ai-using-the-mcts-algorithm stef_buwalda:289-server stef_buwalda:UnitTests stef_buwalda:ReversiML stef_buwalda:297-FixingVisualInformation stef_buwalda:TimerSongDisplay
stef_buwalda:in-development
..
compare: stef_buwalda:96afc9543ad962429671e9a0b768085cb0a39987
Branches Tags
stef_buwalda:main stef_buwalda:Development stef_buwalda:223-create-a-reversi-ai-using-the-mcts-algorithm stef_buwalda:289-server stef_buwalda:UnitTests stef_buwalda:ReversiML stef_buwalda:297-FixingVisualInformation stef_buwalda:TimerSongDisplay
stef_buwalda:in-development

12 Commits
223-create ... 96afc9543a

Author SHA1 Message Date
Bas de Jong
96afc9543a Removed unnecessary imports 2026-01-10 04:29:38 +01:00
Bas de Jong
0c1b106da5 Refactored tournament to use interfaces and builders 2026-01-10 04:28:12 +01:00
Bas de Jong
aca0b2dcc0 Tournament now returns result to clients 2026-01-10 02:44:04 +01:00
Bas de Jong
75963a891b Tournament results are now send back to the clients connected to the server 2026-01-10 02:14:23 +01:00
Bas de Jong
6b644ed8fa Shuffle now changeable, host can now switch tournament gametype 2026-01-10 00:06:52 +01:00
Bas de Jong
6a395cc40b GlobalEventBus is now async instead 2026-01-09 23:34:29 +01:00
Bas de Jong
5e5948d1fe Working tournament 2026-01-09 22:28:15 +01:00
Bas de Jong
9c01aabbe1 Fixed merge mistakes 2026-01-07 23:46:21 +01:00
Bas Antonius de Jong
0cb52b042f Merge branch 'Development' into 289-server 2026-01-07 23:44:13 +01:00
Bas de Jong
56a8d12e46 Logging and fixed user input getting stuck 2026-01-07 23:38:53 +01:00
Stef
65220d9649 Hotfix for stuff 2026-01-07 17:16:45 +01:00
Bas Antonius de Jong
c64a2e2c65 Server update with new dev changes (#305) 
* merge widgets with development

* readd previous game thread code

* Revert "readd previous game thread code"

This reverts commit d24feef73e.

* Revert "Merge remote-tracking branch 'origin/Development' into Development"

This reverts commit 59d46cb73c, reversing
changes made to 38681c5db0.

* Revert "merge widgets with development"

This reverts commit 38681c5db0.

* Merge 292 into development (#293)

Applied template method pattern to abstract player

* Added documentation to player classes and improved method names (#295)

* mcts v1

* bitboard optimization

* bitboard fix & mcts v2 & mcts v3. v3 still in progress and v4 coming soon

* main

---------

Co-authored-by: ramollia <>
Co-authored-by: Stef <stbuwalda@gmail.com>
Co-authored-by: Stef <48526421+StefBuwalda@users.noreply.github.com>
 2026-01-07 16:15:49 +01:00
54 changed files with 1007 additions and 1551 deletions
Expand all files Collapse all files

2
.idea/inspectionProfiles/Project_Default.xml generated
View File

@@ -2,7 +2,7 @@
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="AutoCloseableResource" enabled="true" level="WARNING" enabled_by_default="true">
<option name="METHOD_MATCHER_CONFIG" value="java.util.Formatter,format,java.io.Writer,append,com.google.common.base.Preconditions,checkNotNull,org.hibernate.Session,close,java.io.PrintWriter,printf,java.io.PrintStream,printf,java.lang.foreign.Arena,ofAuto,java.lang.foreign.Arena,global,org.toop.framework.audio.AudioPlayer,play,java.util.Map,remove,java.util.concurrent.Executors,newSingleThreadScheduledExecutor|newFixedThreadPool|newSingleThreadExecutor" />
<option name="METHOD_MATCHER_CONFIG" value="java.util.Formatter,format,java.io.Writer,append,com.google.common.base.Preconditions,checkNotNull,org.hibernate.Session,close,java.io.PrintWriter,printf,java.io.PrintStream,printf,java.lang.foreign.Arena,ofAuto,java.lang.foreign.Arena,global,org.toop.framework.audio.AudioPlayer,play,java.util.Map,remove,java.util.concurrent.Executors,newSingleThreadScheduledExecutor" />
</inspection_tool>
<inspection_tool class="WriteOnlyObject" enabled="false" level="WARNING" enabled_by_default="false" />
</profile>

83
app/src/main/java/org/toop/Main.java
View File

@@ -1,68 +1,53 @@
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);
// final ExecutorService executor = Executors.newFixedThreadPool(1);
// executor.execute(() -> testAIs(25));
// testMCTS(10);
}
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");
// 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");
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[]{ v1, v2 });
// // testAI(games, new Player[]{ v1, v3 });
testAIVSAI(games, new ArtificialPlayer[] { versions[playerIndex1], versions[playerIndex2]});
}
}
}
// // testAI(games, new Player[]{ random, v3 });
// // testAI(games, new Player[]{ v2, v3 });
// testAI(games, new Player[]{ v2, v3 });
// // testAI(games, new Player[]{ v3, v2 });
// }
private static void testAIVSAI(int games, ArtificialPlayer[] ais) {
int wins = 0;
int ties = 0;
// private static void testAI(int games, Player<BitboardReversi>[] ais) {
// int wins = 0;
// int ties = 0;
for (int i = 0; i < games; i++) {
final BitboardReversi match = new BitboardReversi();
match.init(ais);
// for (int i = 0; i < games; i++) {
// final BitboardReversi match = new BitboardReversi(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);
// }
}

9
app/src/main/java/org/toop/app/Server.java
View File

@@ -11,7 +11,6 @@ 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;
@@ -20,7 +19,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.game.players.ai.mcts.MCTSAI3;
import org.toop.framework.game.players.LocalPlayer;
import org.toop.local.AppContext;
import java.util.Arrays;
@@ -209,8 +208,7 @@ public final class Server {
information.players[opponentStartingTurn].name = response.opponent();
Player[] players = new Player[2];
players[userStartingTurn] = new ArtificialPlayer(new MCTSAI3(1000, Runtime.getRuntime().availableProcessors()), user);
players[userStartingTurn] = new LocalPlayer(user);
players[opponentStartingTurn] = new OnlinePlayer(response.opponent());
switch (type) {
@@ -246,8 +244,7 @@ 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.scoreTypes()));
IO.println(Arrays.toString(response.scores().toArray()));
IO.println(Arrays.toString(response.scores()));
}
private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {

29
app/src/main/java/org/toop/app/canvas/ReversiBitCanvas.java
View File

@@ -2,13 +2,9 @@ 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 -> {
@@ -24,9 +20,6 @@ public class ReversiBitCanvas extends BitGameCanvas {
break;
}
}
if (hovered != null) {
checkHoverDots(hovered, cellId);
}
});
}
@@ -38,31 +31,9 @@ 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));
}
}
}
}

9
app/src/main/java/org/toop/app/gameControllers/GenericGameController.java
View File

@@ -5,7 +5,6 @@ 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;
@@ -154,12 +153,6 @@ public class GenericGameController implements GameController {
@Override
public void updateUI() {
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);
}
canvas.redraw(game.deepCopy());
}
}

14
app/src/main/java/org/toop/app/widget/view/GameView.java
View File

@@ -6,8 +6,6 @@ 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;
@@ -96,7 +94,7 @@ public final class GameView extends ViewWidget {
}
}
public void nextPlayer(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
public void nextPlayer(boolean isMe, String currentPlayer, String currentMove, String nextPlayer, char GameType) {
Platform.runLater(() -> {
if (!(hasSet)) {
playerHeader.setText(currentPlayer + " vs. " + nextPlayer);
@@ -114,8 +112,8 @@ public final class GameView extends ViewWidget {
new GameOverPopup(iWon, winner).show(Pos.CENTER);
}
private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
if (Objects.equals(GameType, "TicTacToe")) {
private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, char GameType) {
if (GameType == 'T') {
if (isMe) {
player1Header.setText("X: " + currentPlayer);
player2Header.setText("O: " + nextPlayer);
@@ -126,7 +124,7 @@ public final class GameView extends ViewWidget {
}
setPlayerInfoTTT();
}
else if (Objects.equals(GameType, "Reversi")) {
else if (GameType == 'R') {
if (isMe) {
player1Header.setText(currentPlayer);
player2Header.setText(nextPlayer);
@@ -174,8 +172,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.WHITE);
player2Icon.setFill(Color.BLACK);
player1Icon.setFill(Color.BLACK);
player2Icon.setFill(Color.WHITE);
add(Pos.TOP_RIGHT, playerInfo);
}
}

14
app/src/main/java/org/toop/app/widget/view/LocalMultiplayerView.java
View File

@@ -4,7 +4,6 @@ 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;
@@ -13,10 +12,11 @@ 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 MCTSAI1(100), "MCTS AI");
players[0] = new ArtificialPlayer(new MCTSAI(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 MCTSAI4(500, 4), "MCTS V4 AI");
players[0] = new ArtificialPlayer(new MCTSAI3(50), "MCTS V3 AI");
}
if (information.players[1].isHuman) {
players[1] = new LocalPlayer(information.players[1].name);
} else {
players[1] = new ArtificialPlayer(new MCTSAI1(500), "MCTS V1 AI");
players[1] = new ArtificialPlayer(new MCTSAI2(50), "MCTS V2 AI");
}
if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
new ShowEnableTutorialWidget(

51
app/src/main/java/org/toop/app/widget/view/ServerView.java
View File

@@ -45,7 +45,25 @@ public final class ServerView extends ViewWidget {
private void setupLayout(String userName) {
var playerHeader = Primitive.header(user, false);
if (userName.equals("host")) { // TODO is fragile
subscribeButton = Primitive.button(
"subscribe",
() -> new EventFlow().addPostEvent(new NetworkEvents.SendSubscribe(clientId, gameListSub.getValue())).postEvent(),
false,
true
); // TODO localize
var subscribe = Primitive.hbox(gameListSub, subscribeButton);
var playerListSection = Primitive.vbox(
playerHeader,
Primitive.separator(),
subscribe,
listView
);
add(Pos.CENTER, playerListSection);
if (userName.equals("host")) {
var tournamentButton = Primitive.hbox(
gameListTour,
Primitive.button(
@@ -57,33 +75,12 @@ public final class ServerView extends ViewWidget {
);
add(Pos.BOTTOM_CENTER, tournamentButton);
} else {
subscribeButton = Primitive.button(
"subscribe",
() -> new EventFlow().addPostEvent(new NetworkEvents.SendSubscribe(clientId, gameListSub.getValue())).postEvent(),
false,
true
); // TODO localize
var subscribe = Primitive.hbox(gameListSub, subscribeButton);
var playerListSection = Primitive.vbox(
playerHeader,
Primitive.separator(),
subscribe,
listView
);
add(Pos.CENTER, playerListSection);
var disconnectButton = Primitive.button(
"disconnect",
this::transitionPrevious,
false
);
add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
}
var disconnectButton = Primitive.button(
"disconnect", () -> transitionPrevious(), false);
add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
}
public void update(List<String> players) {

1
framework/src/main/java/org/toop/framework/game/BitboardGame.java
View File

@@ -6,7 +6,6 @@ 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 {

67
framework/src/main/java/org/toop/framework/game/gameThreads/ServerThreadBehaviour.java
View File

@@ -1,39 +1,31 @@
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,
Duration timeOut
) {
public ServerThreadBehaviour(TurnBasedGame game, Consumer<ImmutablePair<String, Integer>> onPlayerMove, Consumer<Pair<GameState, Integer>> onGameEnd) {
this.onPlayerMove = onPlayerMove;
this.onGameEnd = onGameEnd;
this.timeOut = timeOut;
super(game);
}
@@ -67,42 +59,23 @@ 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);
Future<Long> move = moveExecutor.submit(() -> currentPlayer.getMove(game.deepCopy()));
GameState state = result.state();
notifyPlayerMove(new ImmutablePair<>(currentPlayer.getName(), Long.numberOfTrailingZeros(move)));
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);
}
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);
}
} 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;
}
}
}

45
framework/src/main/java/org/toop/framework/game/games/reversi/BitboardReversi.java
View File

@@ -321,51 +321,8 @@ 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;
}
}

10
framework/src/main/java/org/toop/framework/game/games/tictactoe/BitboardTicTacToe.java
View File

@@ -110,14 +110,4 @@ 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;
}
}

4
framework/src/main/java/org/toop/framework/game/players/ArtificialPlayer.java
View File

@@ -57,8 +57,4 @@ public class ArtificialPlayer extends AbstractPlayer {
public ArtificialPlayer deepCopy() {
return new ArtificialPlayer(this);
}
public AI getAi() {
return ai;
}
}

11
framework/src/main/java/org/toop/framework/game/players/ServerPlayer.java
View File

@@ -29,8 +29,13 @@ public class ServerPlayer extends AbstractPlayer {
@Override
public long determineMove(TurnBasedGame game) {
lastMove = new CompletableFuture<>();
client.send("SVR GAME YOURTURN {TURNMESSAGE: \"<bericht voor deze beurt>\"}");
return lastMove.join();
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;
}
}
}

3
framework/src/main/java/org/toop/framework/gameFramework/model/game/TurnBasedGame.java
View File

@@ -13,7 +13,4 @@ public interface TurnBasedGame extends DeepCopyable<TurnBasedGame> {
PlayResult play(long move);
PlayResult getState();
boolean isTerminal();
float rateMove(long move);
long heuristicMove(long legalMoves);
}

2
framework/src/main/java/org/toop/framework/networking/connection/events/NetworkEvents.java
View File

@@ -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, String[] scoreTypes, List<Integer[]> scores)
public record TournamentResultResponse(long clientId, String gameType, String[] names, Integer[] scores)
implements GenericEvent {}
/** Indicates that a game move has been processed or received. */

50
framework/src/main/java/org/toop/framework/networking/connection/handlers/NetworkingGameClientHandler.java
View File

@@ -3,9 +3,7 @@ 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;
@@ -119,54 +117,22 @@ 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");
String usersRaw = extract(rec, "USERS");
String scoresRaw = extract(rec, "SCORES");
if (usersRaw == null) return;
String[] users;
if (usersRaw.length() > 2) {
users = Arrays.stream(usersRaw.substring(1, usersRaw.length() - 1).split(","))
String[] users = Arrays.stream(usersRaw.substring(1, usersRaw.length() - 1).split(","))
.map(s -> s.trim().replace("\"", ""))
.toArray(String[]::new);
} else {
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) {
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, scoreTypes, scores));
} else {
eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scoreTypes, new ArrayList<>()));
}
Integer[] scores = Arrays.stream(scoresRaw.substring(1, scoresRaw.length() - 1).split(","))
.map(String::trim)
.map(Integer::parseInt)
.toArray(Integer[]::new);
eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scores));
}
private void gameMoveHandler(String rec) {

7
framework/src/main/java/org/toop/framework/networking/server/GameResultFuture.java
View File

@@ -1,7 +0,0 @@
package org.toop.framework.networking.server;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
import java.util.concurrent.CompletableFuture;
public record GameResultFuture(OnlineGame<TurnBasedGame> game, CompletableFuture<Integer> result) {}

3
framework/src/main/java/org/toop/framework/networking/server/GameServer.java
View File

@@ -2,12 +2,11 @@ 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, Duration turnTime, CLIENT... clients);
OnlineGame<TurnBasedGame> startGame(String gameType, CompletableFuture<Void> futureOrNull, CLIENT... clients);
void addClient(CLIENT client);
void removeClient(CLIENT client);

10
framework/src/main/java/org/toop/framework/networking/server/MatchExecutor.java
View File

@@ -1,10 +0,0 @@
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);
}

56
framework/src/main/java/org/toop/framework/networking/server/OnlineTurnBasedGame.java
View File

@@ -5,64 +5,62 @@ import org.toop.framework.gameFramework.GameState;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
import org.toop.framework.networking.server.client.NettyClient;
import java.time.Duration;
import java.util.Arrays;
import java.util.concurrent.CompletableFuture;
public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
private long id;
private NettyClient[] clients;
private NettyClient[] admins;
private TurnBasedGame game;
private ServerThreadBehaviour gameThread;
private final CompletableFuture<Integer> resultFuture;
private CompletableFuture<Void> futureOrNull = null;
public OnlineTurnBasedGame(NettyClient[] admins, TurnBasedGame game, CompletableFuture<Integer> resultFuture, Duration timeOut, NettyClient... clients) {
public OnlineTurnBasedGame(TurnBasedGame game, CompletableFuture<Void> futureOrNull, NettyClient... clients) {
this.game = game;
this.gameThread = new ServerThreadBehaviour(
game,
(pair) -> notifyMoveMade(pair.getLeft(), pair.getRight()),
(pair) -> notifyGameEnd(pair.getLeft(), pair.getRight()),
timeOut
(pair) -> notifyGameEnd(pair.getLeft(), pair.getRight())
);
this.futureOrNull = futureOrNull;
this.clients = clients;
}
public OnlineTurnBasedGame(TurnBasedGame game, NettyClient... clients) {
this.game = game;
this.gameThread = new ServerThreadBehaviour(
game,
(pair) -> notifyMoveMade(pair.getLeft(), pair.getRight()),
(pair) -> notifyGameEnd(pair.getLeft(), pair.getRight())
);
this.resultFuture = resultFuture;
this.clients = clients;
this.admins = admins;
}
private void notifyMoveMade(String speler, int move){
for (NettyClient admin : admins) {
admin.send(String.format("SVR GAME MOVE {PLAYER: \"%s\", MOVE: \"%s\", DETAILS: \"<reactie spel op zet>\"}", speler, move));
}
for (NettyClient client : clients) {
client.send(String.format("SVR GAME MOVE {PLAYER: \"%s\", MOVE: \"%s\", DETAILS: \"<reactie spel op zet>\"}", speler, move));
client.send(String.format("SVR GAME MOVE {PLAYER: \"%s\", MOVE: \"%s\", DETAILS: \"<reactie spel op zet>\"}\n", speler, move));
}
}
private void notifyGameEnd(GameState state, int winner) {
if (state == GameState.DRAW) {
Arrays.stream(admins).forEach(a -> a.send("SVR GAME END"));
private void notifyGameEnd(GameState state, int winner){
if (state == GameState.DRAW){
for (NettyClient client : clients) {
client.send("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}");
client.send(String.format("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}\n"));
}
} else {
Arrays.stream(admins).forEach(a -> a.send("SVR GAME END"));
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>\"}");
}
else{
clients[winner].send(String.format("SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}\n"));
clients[(winner + 1)%2].send(String.format("SVR GAME LOSS {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}\n"));
}
// Remove game from clients
for (NettyClient client : clients) {
admins = null;
// Remove game fromt clients
for(NettyClient client : clients) {
client.clearGame();
}
if (resultFuture != null) {
if (state.equals(GameState.DRAW)) resultFuture.complete(-1); // Return -1 if draw
else resultFuture.complete(winner); // Return number for winner's index
if (futureOrNull != null) {
futureOrNull.complete(null);
}
}
@@ -82,7 +80,7 @@ public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
}
@Override
public void start() {
public void start(){
this.gameThread.start();
}
}

113
framework/src/main/java/org/toop/framework/networking/server/Server.java
View File

@@ -11,8 +11,6 @@ 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.DoubleRoundRobinMatchMaker;
import org.toop.framework.networking.server.tournaments.scoresystems.*;
import org.toop.framework.utils.ImmutablePair;
import java.util.*;
@@ -31,8 +29,6 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
final private Duration challengeDuration;
final private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
private final List<NettyClient> admins = new ArrayList<>();
public Server(
Duration challengeDuration,
TurnBasedGameTypeStore turnBasedGameTypeStore,
@@ -51,13 +47,11 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
@Override
public void addClient(NettyClient client) {
if (admins.isEmpty()) admins.addLast(client);
clientStore.add(client);
}
@Override
public void removeClient(NettyClient client) {
admins.remove(client);
clientStore.remove(client.id());
}
@@ -110,7 +104,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(), Duration.ofSeconds(10), challenge.getUsers());
startGame(challenge.acceptChallenge(), null, challenge.getUsers());
break;
}
}
@@ -132,24 +126,12 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
}
@Override
public GameResultFuture startGame(String gameType, Duration turnTime, NettyClient... clients) {
public OnlineGame<TurnBasedGame> startGame(String gameType, CompletableFuture<Void> futureOrNull, NettyClient... clients) {
if (!gameTypesStore.all().containsKey(gameType)) return null;
try {
ServerPlayer[] players = new ServerPlayer[clients.length];
var gameResult = new CompletableFuture<Integer>();
var game = new OnlineTurnBasedGame(
getAdmins().toArray(NettyClient[]::new),
gameTypesStore.create(gameType),
gameResult,
turnTime,
clients
);
var grfReturn = new GameResultFuture(game, gameResult);
var game = new OnlineTurnBasedGame(gameTypesStore.create(gameType), futureOrNull, clients);
for (int i = 0; i < clients.length; i++) {
players[i] = new ServerPlayer(clients[i]);
@@ -167,9 +149,8 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
clients[0].name(),
gameType,
clients[0].name()));
game.start();
return grfReturn;
return game;
} catch (Exception e) {
IO.println("ERROR: Failed to start OnlineTurnBasedGame");
e.printStackTrace();
@@ -182,10 +163,6 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
return clientStore.all().stream().toList();
}
public List<NettyClient> getAdmins() {
return new ArrayList<>(admins); // Clone so the list can't be edited.
}
@Override
public void shutdown() {
scheduler.shutdown();
@@ -251,7 +228,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
userNames.remove(first);
userNames.remove(second);
startGame(key, Duration.ofSeconds(10), getUser(userLeft), getUser(userRight));
startGame(key, null, getUser(userLeft), getUser(userRight));
}
}
}
@@ -286,69 +263,45 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
return true;
}
public void startTournament(String gameType, NettyClient requestor, boolean shuffle) {
if (!admins.contains(requestor)) {
requestor.send("ERR you do not have the privileges to start a tournament");
return;
public void startTournament(Tournament tournament, String gameType) {
try {
var tb = new TournamentBuilder();
var cTournament = tb.create(
tournament,
onlineUsers(),
this,
new BasicScoreManager(new HashMap<>()),
new BasicMatchManager(),
new RandomShuffle()
);
new Thread(() -> cTournament.run(gameType)).start();
} catch (IllegalArgumentException e) {
getUser("host").send("ERR not enough clients to start a tournament");
} catch (RuntimeException e) {
getUser("host").send("ERR no matches could be created to start a tournament with");
}
var tournamentUsers = new ArrayList<>(onlineUsers());
tournamentUsers.removeIf(admins::contains);
Tournament tournament = new Tournament.Builder()
.matchExecutor(this::startGame)
.tournamentRunner(new AsyncTournamentRunner())
.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();
new Thread(() -> tournament.run(gameType)).start();
}
public void endTournament(List<IntegerScoreSystem> systems) {
if (systems.isEmpty()) return;
public void endTournament(Map<NettyClient, Integer> score, String gameType) {
Map<String, List<ImmutablePair<String, Integer>>> combined = new HashMap<>();
List<String> u = new ArrayList<>();
List<Integer> s = new ArrayList<>();
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());
}
for (var entry : score.entrySet()) {
u.add(entry.getKey().name());
s.add(entry.getValue());
}
Gson gson = new Gson();
String namesJson = gson.toJson(names);
String systemNamesJson = gson.toJson(systemNames);
String scoresJson = gson.toJson(scores);
String users = gson.toJson(u);
String scores = gson.toJson(s);
String msg = String.format(
"SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORETYPES: %s, SCORES: %s, TOURNAMENT: 1}",
"none", // TODO gametype
namesJson,
systemNamesJson,
scoresJson
"SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORES: %s, TOURNAMENT: 1}",
gameType,
users,
scores
);
for (var user : onlineUsers()) {

1
framework/src/main/java/org/toop/framework/networking/server/client/NettyClient.java
View File

@@ -56,6 +56,7 @@ public class NettyClient implements Client<OnlineTurnBasedGame, ServerPlayer> {
@Override
public void send(String message) {
IO.println(message);
ctx.channel().writeAndFlush(message + "\r\n");
}

37
framework/src/main/java/org/toop/framework/networking/server/handlers/MessageHandler.java
View File

@@ -1,17 +1,19 @@
package org.toop.framework.networking.server.handlers;
import org.toop.framework.game.players.ServerPlayer;
import org.toop.framework.networking.server.OnlineTurnBasedGame;
import org.toop.framework.networking.server.Server;
import org.toop.framework.networking.server.client.Client;
import org.toop.framework.networking.server.client.NettyClient;
import org.toop.framework.networking.server.parsing.ParsedMessage;
import org.toop.framework.networking.server.tournaments.BasicTournament;
import org.toop.framework.utils.Utils;
public class MessageHandler implements Handler<ParsedMessage> {
private final Server server;
private final NettyClient client;
private final Client<OnlineTurnBasedGame, ServerPlayer> client;
public MessageHandler(Server server, NettyClient client) {
public MessageHandler(Server server, Client<OnlineTurnBasedGame, ServerPlayer> client) {
this.server = server;
this.client = client;
}
@@ -41,27 +43,27 @@ public class MessageHandler implements Handler<ParsedMessage> {
return true;
}
private void handleLogin(ParsedMessage p, NettyClient client) {
private void handleLogin(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
if (!hasArgs(p.args())) return;
client.setName(p.args()[0]);
}
private void handleSubscribe(ParsedMessage p, NettyClient client) {
private void handleSubscribe(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
if (!hasArgs(p.args())) return;
server.subscribeClient(client.name(), p.args()[0]);
}
private void handleHelp(ParsedMessage p, NettyClient client) {
private void handleHelp(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
// TODO
}
private void handleMessage(ParsedMessage p, NettyClient client) {
private void handleMessage(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
// TODO
}
private void handleGet(ParsedMessage p, NettyClient client) {
private void handleGet(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
if (!hasArgs(p.args())) return;
switch (p.args()[0]) {
@@ -73,14 +75,10 @@ public class MessageHandler implements Handler<ParsedMessage> {
var names = server.gameTypes().stream().iterator();
client.send("SVR GAMELIST " + Utils.returnQuotedString(names));
}
case "admins" -> {
var names = server.getAdmins().stream().map(Client::name).iterator();
client.send("SVR ADMINS " + Utils.returnQuotedString(names));
}
}
}
private void handleChallenge(ParsedMessage p, NettyClient client) {
private void handleChallenge(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
if (!hasArgs(p.args())) return;
if (p.args().length < 2) return;
@@ -105,21 +103,20 @@ public class MessageHandler implements Handler<ParsedMessage> {
server.challengeClient(client.name(), p.args()[0], p.args()[1]);
}
private void handleMove(ParsedMessage p, NettyClient client) {
private void handleMove(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
if(!hasArgs(p.args())) return;
var player = client.player();
if (player == null) return;
// TODO check if not number
player.setMove(1L << Integer.parseInt(p.args()[0]));
client.player().setMove(1L << Integer.parseInt(p.args()[0]));
}
private void handleTournament(ParsedMessage p, NettyClient client) {
private void handleTournament(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
if(!hasArgs(p.args())) return;
if (!client.name().equalsIgnoreCase("host")) return;
if (p.args()[0].equalsIgnoreCase("start") && p.args().length > 1) {
server.startTournament(p.args()[1], client, false); // TODO add shuffle to msg
server.startTournament(new BasicTournament(), p.args()[1]);
}
}
}

86
framework/src/main/java/org/toop/framework/networking/server/tournaments/AsyncTournamentRunner.java
View File

@@ -1,86 +0,0 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.GameResultFuture;
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.IntegerScoreSystem;
import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;
public class AsyncTournamentRunner implements TournamentRunner {
@Override
public void run(
MatchExecutor matchRunner,
MatchMaker matchMaker,
List<IntegerScoreSystem> scoreSystems,
ResultBroadcaster<IntegerScoreSystem> broadcaster,
Duration turnTime,
String gameType
) {
ExecutorService matchExecutor = Executors.newVirtualThreadPerTaskExecutor();
ExecutorService scoringExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
Queue<TournamentMatch> pendingMatches = new ConcurrentLinkedQueue<>();
matchMaker.forEach(pendingMatches::add);
Set<NettyClient> busyPlayers = ConcurrentHashMap.newKeySet();
List<CompletableFuture<Void>> runningMatches = new CopyOnWriteArrayList<>();
try {
while (!pendingMatches.isEmpty() || !runningMatches.isEmpty()) {
Iterator<TournamentMatch> it = pendingMatches.iterator();
while (it.hasNext()) {
TournamentMatch match = it.next();
NettyClient a = match.getClient0();
NettyClient b = match.getClient1();
// TODO game != null doesn't work here, fix later
if (busyPlayers.contains(a) || busyPlayers.contains(b)) {
continue;
}
busyPlayers.add(a);
busyPlayers.add(b);
it.remove();
CompletableFuture<Void> f =
CompletableFuture.runAsync(() -> {
try {
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();
busyPlayers.remove(a);
busyPlayers.remove(b);
}
}, matchExecutor);
runningMatches.add(f);
f.whenComplete((_, _) -> runningMatches.remove(f));
}
Thread.sleep(10); // Safety
}
broadcaster.broadcast(scoreSystems);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
matchExecutor.shutdown();
}
}
}

85
framework/src/main/java/org/toop/framework/networking/server/tournaments/BasicMatchManager.java Normal file
View File

@@ -0,0 +1,85 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
import org.toop.framework.networking.server.OnlineGame;
import org.toop.framework.networking.server.Server;
import org.toop.framework.networking.server.client.NettyClient;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicReference;
public class BasicMatchManager implements MatchManager {
private final HashMap<NettyClient, List<NettyClient>> matches = new HashMap<>(); // TODO store
private final ArrayList<TournamentMatch> matchOrder = new ArrayList<>(); // TODO store
private int matchIndex = 0;
public BasicMatchManager() {}
@Override
public void addClient(NettyClient client) {
matches.putIfAbsent(client, new ArrayList<>());
}
@Override
public List<NettyClient> getClients() {
return matches.keySet().stream().toList();
}
@Override
public void createMatches() {
for (var match : matches.entrySet()) {
for (var matchNoSelf : matches.keySet()) {
if (match.getKey() == matchNoSelf) continue;
match.getValue().addLast(matchNoSelf);
}
}
for (var client : matches.entrySet()) {
for (var opponent : client.getValue()) {
matchOrder.addLast(new TournamentMatch(client.getKey(), opponent));
}
}
}
@Override
public TournamentMatch next() {
matchIndex++;
if (matchIndex >= matchOrder.size()) return null;
return matchOrder.get(matchIndex);
}
@Override
public void run(Server server, ScoreManager scoreManager, String gameType) {
new Thread(() -> {
for (var match : matchOrder) {
final CompletableFuture<Void> finished = new CompletableFuture<>();
AtomicReference<OnlineGame<TurnBasedGame>> game = new AtomicReference<>();
new Thread(() -> game.set(server.startGame(gameType, finished, match.getLeft(), match.getRight()))).start(); // TODO can possibly create a race condition
finished.join();
switch (game.get().game().getWinner()) {
case 0 -> scoreManager.addScore(match.getLeft());
case 1 -> scoreManager.addScore(match.getRight());
default -> {}
}
match.getLeft().clearGame();
match.getRight().clearGame();
}
server.endTournament(scoreManager.getScore(), gameType);
}).start();
}
@Override
public void shuffle(Shuffler shuffler) {
shuffler.shuffle(matchOrder);
}
}

30
framework/src/main/java/org/toop/framework/networking/server/tournaments/BasicScoreManager.java Normal file
View File

@@ -0,0 +1,30 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.client.NettyClient;
import java.util.Map;
public class BasicScoreManager implements ScoreManager {
private final Map<NettyClient, Integer> scores;
public BasicScoreManager(Map<NettyClient, Integer> store) {
scores = store;
}
@Override
public void addClient(NettyClient client) {
scores.putIfAbsent(client, getInitScore());
}
@Override
public void addScore(NettyClient client) {
int clientScore = scores.get(client);
scores.put(client, clientScore + getWinPointAmount());
}
@Override
public Map<NettyClient, Integer> getScore() {
return scores;
}
}

48
framework/src/main/java/org/toop/framework/networking/server/tournaments/BasicTournament.java Normal file
View File

@@ -0,0 +1,48 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.Server;
public class BasicTournament implements Tournament {
private Server server;
private ScoreManager scoreManager;
private MatchManager matchManager;
public BasicTournament() {}
public void init(TournamentBuilder builder) {
server = builder.server;
scoreManager = builder.scoreManager;
matchManager = builder.matchManager;
}
@Override
public boolean run(String gameType) throws RuntimeException {
if (server.gameTypes().stream().noneMatch(e -> e.equalsIgnoreCase(gameType))) return false;
matchManager.run(server, scoreManager, gameType);
return true;
}
// @Override
// public HashMap<NettyClient, Integer> end() {
//
// for (var match : matchList) {
// match.getLeft().clearGame(); // TODO send msg to client
// match.getRight().clearGame(); // TODO send msg to client
// }
//
// gameType = null;
// matchList = null;
// matches.clear();
//
// HashMap<NettyClient, Integer> retScore = new HashMap<>(score);
//
// score.clear();
//
// clients = null;
//
// return retScore;
// }
}

40
framework/src/main/java/org/toop/framework/networking/server/tournaments/BasicTournamentRunner.java
View File

@@ -1,40 +0,0 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.GameResultFuture;
import org.toop.framework.networking.server.MatchExecutor;
import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
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(
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 = matchExecutor.submit(gameType, turnTime, match.getClient0(), match.getClient1());
scoreSystems.forEach(e -> e.result(match, game.result().join()));
match.getClient0().clearGame();
match.getClient1().clearGame();
}
broadcaster.broadcast(scoreSystems);
});
} finally {
threadPool.shutdown();
}
}
}

15
framework/src/main/java/org/toop/framework/networking/server/tournaments/MatchManager.java Normal file
View File

@@ -0,0 +1,15 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.Server;
import org.toop.framework.networking.server.client.NettyClient;
import java.util.List;
public interface MatchManager {
void addClient(NettyClient client);
List<NettyClient> getClients();
void createMatches();
TournamentMatch next();
void run(Server server, ScoreManager scoreManager, String gameType);
void shuffle(Shuffler shuffler);
}

2
framework/src/main/java/org/toop/framework/networking/server/tournaments/shufflers/RandomShuffle.java → framework/src/main/java/org/toop/framework/networking/server/tournaments/RandomShuffle.java
View File

@@ -1,4 +1,4 @@
package org.toop.framework.networking.server.tournaments.shufflers;
package org.toop.framework.networking.server.tournaments;
import java.util.List;
import java.util.Random;

10
framework/src/main/java/org/toop/framework/networking/server/tournaments/ResultBroadcaster.java
View File

@@ -1,10 +0,0 @@
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);
}

19
framework/src/main/java/org/toop/framework/networking/server/tournaments/ScoreManager.java Normal file
View File

@@ -0,0 +1,19 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.client.NettyClient;
import java.util.Map;
public interface ScoreManager {
void addClient(NettyClient client);
void addScore(NettyClient client);
Map<NettyClient, Integer> getScore();
default int getWinPointAmount() {
return 1;
}
default int getInitScore() {
return 0;
}
}

2
framework/src/main/java/org/toop/framework/networking/server/tournaments/shufflers/Shuffler.java → framework/src/main/java/org/toop/framework/networking/server/tournaments/Shuffler.java
View File

@@ -1,4 +1,4 @@
package org.toop.framework.networking.server.tournaments.shufflers;
package org.toop.framework.networking.server.tournaments;
import java.util.List;

120
framework/src/main/java/org/toop/framework/networking/server/tournaments/Tournament.java
View File

@@ -1,121 +1,11 @@
package org.toop.framework.networking.server.tournaments;
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.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;
import java.util.HashMap;
public class Tournament {
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) {
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) {
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);
}
public static class Builder {
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 matchExecutor(MatchExecutor matchExecutor) {
this.matchExecutor = matchExecutor;
return this;
}
public Builder addScoreSystem(IntegerScoreSystem scoreSystem) {
this.scoreSystems.addLast(scoreSystem);
return this;
}
public Builder tournamentRunner(TournamentRunner tournamentRunner) {
this.tournamentRunner = tournamentRunner;
return this;
}
public Builder matchMaker(MatchMaker matchMaker) {
this.matchMaker = matchMaker;
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(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);
}
}
public interface Tournament {
void init(TournamentBuilder builder);
boolean run(String gameType);
// HashMap<NettyClient, Integer> end();
}

39
framework/src/main/java/org/toop/framework/networking/server/tournaments/TournamentBuilder.java Normal file
View File

@@ -0,0 +1,39 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.Server;
import org.toop.framework.networking.server.client.NettyClient;
import java.util.List;
public class TournamentBuilder {
public Server server;
public ScoreManager scoreManager;
public MatchManager matchManager;
public TournamentBuilder() {}
public Tournament create(
Tournament tournament,
List<NettyClient> clients,
Server server,
ScoreManager scoreManager,
MatchManager matchManager,
Shuffler shuffler
) {
this.server = server;
this.scoreManager = scoreManager;
this.matchManager = matchManager;
for (var client : clients) {
matchManager.addClient(client);
scoreManager.addClient(client);
}
matchManager.createMatches();
matchManager.shuffle(shuffler);
tournament.init(this);
return tournament;
}
}

8
framework/src/main/java/org/toop/framework/networking/server/tournaments/TournamentMatch.java
View File

@@ -7,12 +7,4 @@ public class TournamentMatch extends ImmutablePair<NettyClient, NettyClient> {
public TournamentMatch(NettyClient a, NettyClient b) {
super(a, b);
}
public NettyClient getClient0() {
return getLeft();
}
public NettyClient getClient1() {
return getRight();
}
}

13
framework/src/main/java/org/toop/framework/networking/server/tournaments/TournamentRunner.java
View File

@@ -1,13 +0,0 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.MatchExecutor;
import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
import java.time.Duration;
import java.util.List;
public interface TournamentRunner {
void run(MatchExecutor matchExecutor, MatchMaker matchMaker, List<IntegerScoreSystem> scoreSystems,
ResultBroadcaster<IntegerScoreSystem> broadcaster, Duration turnTime, String gameType);
}

81
framework/src/main/java/org/toop/framework/networking/server/tournaments/matchmakers/DoubleRoundRobinMatchMaker.java
View File

@@ -1,81 +0,0 @@
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;
}
}
}
}
};
}
}

13
framework/src/main/java/org/toop/framework/networking/server/tournaments/matchmakers/MatchMaker.java
View File

@@ -1,13 +0,0 @@
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.List;
public interface MatchMaker extends Iterable<TournamentMatch> {
void addPlayer(NettyClient player);
List<NettyClient> getPlayers();
void shuffle(Shuffler shuffler);
}

67
framework/src/main/java/org/toop/framework/networking/server/tournaments/matchmakers/RoundRobinMatchMaker.java
View File

@@ -1,67 +0,0 @@
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 RoundRobinMatchMaker implements MatchMaker {
private final List<NettyClient> players = new ArrayList<>();
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);
}
@Override
public List<NettyClient> getPlayers() {
return players;
}
@Override
public Iterator<TournamentMatch> iterator() {
return new Iterator<>() {
private int i = 0;
private int j = 1;
@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);
j++;
if (j >= players.size()) {
i++;
j = i + 1;
}
return new TournamentMatch(home, away);
}
};
}
}

43
framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/DrawCountScoreSystem.java
View File

@@ -1,43 +0,0 @@
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;
}
}

6
framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/IntegerScoreSystem.java
View File

@@ -1,6 +0,0 @@
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> {}

41
framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/LoseCountScoreSystem.java
View File

@@ -1,41 +0,0 @@
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;
}
}

37
framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/MatchCountScoreSystem.java
View File

@@ -1,37 +0,0 @@
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;
}
}

10
framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/ScoreSystem.java
View File

@@ -1,10 +0,0 @@
package org.toop.framework.networking.server.tournaments.scoresystems;
import java.util.Map;
public interface ScoreSystem<MATCHTYPE, SCORETYPE, USERTYPE> {
String scoreName();
void addPlayer(USERTYPE user);
void result(MATCHTYPE match, SCORETYPE result);
Map<USERTYPE, SCORETYPE> getScore();
}

41
framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/WinCountScoreSystem.java
View File

@@ -1,41 +0,0 @@
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;
}
}

329
game/src/main/java/org/toop/game/players/ai/MCTSAI.java
View File

@@ -1,288 +1,193 @@
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 abstract class MCTSAI extends AbstractAI {
protected static class Node {
public class MCTSAI extends AbstractAI {
private static class Node {
public TurnBasedGame state;
public long move;
public long unexpandedMoves;
public Node parent;
public int expanded;
public Node[] children;
public float value;
public int visits;
public float value;
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.value = 0.0f;
this.expanded = 0;
this.children = new Node[Long.bitCount(state.getLegalMoves())];
this.visits = 0;
this.heuristic = state.rateMove(move);
this.solved = Float.NaN;
this.value = 0.0f;
}
public Node(TurnBasedGame state) {
this(state, null, 0L);
}
public int getExpanded() {
return children.length - Long.bitCount(unexpandedMoves);
this(state, 0L, null);
}
public boolean isFullyExpanded() {
return unexpandedMoves == 0L;
return expanded >= children.length;
}
public float calculateUCT(int parentVisits) {
if (visits == 0) {
return Float.POSITIVE_INFINITY;
}
float calculateUCT() {
float exploitation = visits <= 0? 0 : value / visits;
float exploration = 1.41f * (float)(Math.sqrt(Math.log(visits) / visits));
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;
return exploitation + exploration;
}
public Node bestUCTChild() {
final int expanded = getExpanded();
Node highestUCTChild = null;
float highestUCT = Float.NEGATIVE_INFINITY;
int bestChildIndex = -1;
float bestScore = Float.NEGATIVE_INFINITY;
for (int i = 0; i < expanded; i++) {
final float childUCT = children[i].calculateUCT(visits);
final float score = calculateUCT();
if (childUCT > highestUCT) {
highestUCTChild = children[i];
highestUCT = childUCT;
if (score > bestScore) {
bestChildIndex = i;
bestScore = score;
}
}
return highestUCTChild;
return bestChildIndex >= 0? children[bestChildIndex] : this;
}
}
protected static final ThreadLocal<Random> random = ThreadLocal.withInitial(Random::new);
protected final int milliseconds;
protected int lastIterations;
private final int milliseconds;
public MCTSAI(int milliseconds) {
this.milliseconds = milliseconds;
this.lastIterations = 0;
}
public MCTSAI(MCTSAI other) {
this.milliseconds = other.milliseconds;
this.lastIterations = other.lastIterations;
}
public int getLastIterations() {
return lastIterations;
@Override
public MCTSAI deepCopy() {
return new MCTSAI(this);
}
protected Node selection(Node root) {
// while (Float.isNaN(root.solved) && root.isFullyExpanded() && !root.state.isTerminal()) {
while (root.isFullyExpanded() && !root.state.isTerminal()) {
root = root.bestUCTChild();
@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);
}
return root;
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());
}
protected Node expansion(Node leaf) {
if (leaf.unexpandedMoves == 0L) {
return leaf;
private Node selection(Node node) {
while (node.state.getLegalMoves() != 0L && node.isFullyExpanded()) {
node = node.bestUCTChild();
}
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;
return node;
}
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);
private Node expansion(Node node, long legalMoves) {
for (int i = 0; i < node.expanded; i++) {
legalMoves &= ~node.children[i].move;
}
if (copiedState.getWinner() == playerIndex) {
return 1.0f;
if (legalMoves == 0L) {
return node;
}
if (copiedState.getWinner() >= 0) {
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;
}
return -1.0f;
}
return 0.0f;
return -0.2f;
}
protected void backPropagation(Node leaf, float value) {
while (leaf != null) {
leaf.value += value;
leaf.visits++;
private void backPropagation(Node node, float value) {
while (node != null) {
node.visits++;
node.value += value;
node = node.parent;
}
}
if (Float.isNaN(leaf.solved)) {
updateSolvedStatus(leaf);
public static long randomSetBit(long value) {
Random random = new Random();
int count = Long.bitCount(value);
int target = random.nextInt(count);
while (true) {
int bit = Long.numberOfTrailingZeros(value);
if (target == 0) {
return 1L << bit;
}
value = -value;
leaf = leaf.parent;
}
}
protected Node mostVisitedChild(Node root) {
final int expanded = root.getExpanded();
Node mostVisitedChild = null;
int mostVisited = -1;
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;
}
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;
}
target--;
}
}
}

195
game/src/main/java/org/toop/game/players/ai/MCTSAI2.java Normal file
View File

@@ -0,0 +1,195 @@
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;
}
}

258
game/src/main/java/org/toop/game/players/ai/MCTSAI3.java Normal file
View File

@@ -0,0 +1,258 @@
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;
}
}

39
game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI1.java
View File

@@ -1,39 +0,0 @@
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;
}
}

49
game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI2.java
View File

@@ -1,49 +0,0 @@
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;
}
}

92
game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI3.java
View File

@@ -1,92 +0,0 @@
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
View File

@@ -1,107 +0,0 @@
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);
}
}
}