stef_buwalda/pism
1
0
Fork 0
mirror of https://github.com/2OOP/pism.git synced 2026-02-04 10:54:51 +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:9c01aabbe1051fc397ba253bdd417b8922ee3114
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

5 Commits
223-create ... 9c01aabbe1

Author SHA1 Message Date
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
53 changed files with 727 additions and 1730 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);
// }
}

23
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,10 +19,9 @@ 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;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executors;
@@ -119,8 +117,7 @@ public final class Server {
return;
}
primary = new ServerView(user, this::sendChallenge, user, clientId);
primary = new ServerView(user, this::sendChallenge, clientId);
WidgetContainer.getCurrentView().transitionNextCustom(primary, "disconnect", this::disconnect);
a.unsubscribe("connecting");
@@ -162,8 +159,7 @@ public final class Server {
.listen(NetworkEvents.GameResultResponse.class, this::handleGameResult, false, "game-result")
.listen(NetworkEvents.GameMoveResponse.class, this::handleReceivedMove, false, "game-move")
.listen(NetworkEvents.YourTurnResponse.class, this::handleYourTurn, false, "your-turn")
.listen(NetworkEvents.ClosedConnection.class, this::closedConnection, false, "closed-connection")
.listen(NetworkEvents.TournamentResultResponse.class, this::handleTournamentResult, false, "tournament-result");
.listen(NetworkEvents.ClosedConnection.class, this::closedConnection, false, "closed-connection");
connectFlow = a;
}
@@ -209,8 +205,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) {
@@ -243,13 +238,6 @@ public final class Server {
gameController.gameFinished(response);
}
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()));
}
private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {
if (gameController == null) {
return;
@@ -349,8 +337,7 @@ public final class Server {
private void gamesListFromServerHandler(NetworkEvents.GamelistResponse event) {
gameList.clear();
var gl = new java.util.ArrayList<>(List.of(event.gamelist()));
gl.sort(String::compareTo);
var gl = List.of(event.gamelist());
gameList.addAll(gl);
primary.updateGameList(gl);
}

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(

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

@@ -6,8 +6,6 @@ import javafx.scene.control.ComboBox;
import org.toop.app.widget.Primitive;
import org.toop.app.widget.complex.ViewWidget;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.function.Consumer;
@@ -17,7 +15,6 @@ import javafx.geometry.Pos;
import javafx.scene.control.Button;
import javafx.scene.control.ListView;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.eventbus.GlobalEventBus;
import org.toop.framework.networking.connection.events.NetworkEvents;
public final class ServerView extends ViewWidget {
@@ -25,47 +22,32 @@ public final class ServerView extends ViewWidget {
private final Consumer<String> onPlayerClicked;
private final long clientId;
private final ComboBox<String> gameListSub;
private final ComboBox<String> gameListTour;
private final ComboBox<String> gameList;
private final ListView<Button> listView;
private Button subscribeButton;
public ServerView(String user, Consumer<String> onPlayerClicked, String userName, long clientId) {
public ServerView(String user, Consumer<String> onPlayerClicked, long clientId) {
this.user = user;
this.onPlayerClicked = onPlayerClicked;
this.clientId = clientId;
this.gameListSub = new ComboBox<>();
this.gameListTour = new ComboBox<>();
this.gameList = new ComboBox<>();
this.listView = new ListView<>();
setupLayout(userName);
setupLayout();
}
private void setupLayout(String userName) {
private void setupLayout() {
var playerHeader = Primitive.header(user, false);
if (userName.equals("host")) { // TODO is fragile
var tournamentButton = Primitive.hbox(
gameListTour,
Primitive.button(
"tournament",
() -> GlobalEventBus.get().post(new NetworkEvents.SendCommand(clientId, "tournament", "start", gameListTour.getValue())),
false,
false
)
);
add(Pos.BOTTOM_CENTER, tournamentButton);
} else {
subscribeButton = Primitive.button(
"subscribe",
() -> new EventFlow().addPostEvent(new NetworkEvents.SendSubscribe(clientId, gameListSub.getValue())).postEvent(),
() -> new EventFlow().addPostEvent(new NetworkEvents.SendSubscribe(clientId, gameList.getValue())).postEvent(),
false,
true
); // TODO localize
var subscribe = Primitive.hbox(gameListSub, subscribeButton);
var subscribe = Primitive.hbox(gameList, subscribeButton);
var playerListSection = Primitive.vbox(
playerHeader,
@@ -77,14 +59,10 @@ public final class ServerView extends ViewWidget {
add(Pos.CENTER, playerListSection);
var disconnectButton = Primitive.button(
"disconnect",
this::transitionPrevious,
false
);
"disconnect", () -> transitionPrevious(), false);
add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
}
}
public void update(List<String> players) {
Platform.runLater(() -> {
@@ -99,13 +77,9 @@ public final class ServerView extends ViewWidget {
public void updateGameList(List<String> games) {
Platform.runLater(() -> {
gameListSub.getItems().clear();
gameListSub.setItems(FXCollections.observableArrayList(games));
gameListSub.getSelectionModel().select(0);
gameListTour.getItems().clear();
gameListTour.setItems(FXCollections.observableArrayList(games));
gameListTour.getSelectionModel().select(0);
gameList.getItems().clear();
gameList.setItems(FXCollections.observableArrayList(games));
gameList.getSelectionModel().select(0);
});
}

4
framework/src/main/java/org/toop/framework/eventbus/EventFlow.java
View File

@@ -415,9 +415,11 @@ public class EventFlow {
/**
* Posts the event added through {@link #addPostEvent} asynchronously.
*
* @deprecated use {@link #postEvent()} instead.
*/
@Deprecated
public EventFlow asyncPostEvent() {
GlobalEventBus.get().post(this.event);
eventBus.post(this.event);
return this;
}

17
framework/src/main/java/org/toop/framework/eventbus/GlobalEventBus.java
View File

@@ -1,20 +1,15 @@
package org.toop.framework.eventbus;
import org.apache.logging.log4j.LogManager;
import org.toop.framework.eventbus.bus.AsyncEventBus;
import org.toop.framework.eventbus.bus.DefaultEventBus;
import org.toop.framework.eventbus.bus.DisruptorEventBus;
import org.toop.framework.eventbus.bus.EventBus;
import org.toop.framework.eventbus.events.EventType;
import org.toop.framework.eventbus.store.DefaultSubscriberStore;
import org.toop.framework.eventbus.subscriber.Subscriber;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class GlobalEventBus implements AsyncEventBus {
private static final AsyncEventBus INSTANCE = new DefaultEventBus(
LogManager.getLogger(DefaultEventBus.class),
public class GlobalEventBus implements EventBus {
private static final EventBus INSTANCE = new DisruptorEventBus(
LogManager.getLogger(DisruptorEventBus.class),
new DefaultSubscriberStore()
);
@@ -39,11 +34,6 @@ public class GlobalEventBus implements AsyncEventBus {
INSTANCE.post(event);
}
@Override
public <T extends EventType> void asyncPost(T event) {
INSTANCE.asyncPost(event);
}
@Override
public void shutdown() {
INSTANCE.shutdown();
@@ -53,5 +43,4 @@ public class GlobalEventBus implements AsyncEventBus {
public void reset() {
INSTANCE.reset();
}
}

7
framework/src/main/java/org/toop/framework/eventbus/bus/AsyncEventBus.java
View File

@@ -1,7 +0,0 @@
package org.toop.framework.eventbus.bus;
import org.toop.framework.eventbus.events.EventType;
public interface AsyncEventBus extends EventBus {
<T extends EventType> void asyncPost(T event);
}

14
framework/src/main/java/org/toop/framework/eventbus/bus/DefaultEventBus.java
View File

@@ -5,16 +5,12 @@ import org.toop.framework.eventbus.events.EventType;
import org.toop.framework.eventbus.store.SubscriberStore;
import org.toop.framework.eventbus.subscriber.Subscriber;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Consumer;
public class DefaultEventBus implements AsyncEventBus {
public class DefaultEventBus implements EventBus {
private final Logger logger;
private final SubscriberStore eventsHolder;
private final ExecutorService asyncExecutor = Executors.newCachedThreadPool();
public DefaultEventBus(Logger logger, SubscriberStore eventsHolder) {
this.logger = logger;
this.eventsHolder = eventsHolder;
@@ -40,16 +36,11 @@ public class DefaultEventBus implements AsyncEventBus {
Class<T> eventClass = (Class<T>) subscriber.event();
Consumer<EventType> action = (Consumer<EventType>) subscriber.handler();
action.accept(eventClass.cast(event));
action.accept((EventType) eventClass.cast(event));
}
}
}
@Override
public <T extends EventType> void asyncPost(T event) {
asyncExecutor.submit(() -> post(event));
}
@Override
public void shutdown() {
eventsHolder.reset();
@@ -59,5 +50,4 @@ public class DefaultEventBus implements AsyncEventBus {
public void reset() {
eventsHolder.reset();
}
}

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 {

2
framework/src/main/java/org/toop/framework/game/gameThreads/OnlineThreadBehaviour.java
View File

@@ -77,11 +77,13 @@ public class OnlineThreadBehaviour extends AbstractThreadBehaviour implements Su
}
logger.info("Successfully collected current turn's player");
moveExecutor.submit(() -> {
long move = player.getMove(gameCopy);
logger.info("Move set: {}", move);
logger.info("Completed onYourTurn");
sendMove(clientId, move);
});
}
/**

45
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,43 +59,24 @@ public class ServerThreadBehaviour extends AbstractThreadBehaviour implements Ru
public void run() {
while (isRunning.get()) {
Player currentPlayer = game.getPlayer(game.getCurrentTurn());
Future<Long> move = moveExecutor.submit(() -> currentPlayer.getMove(game.deepCopy()));
PlayResult result;
try {
long moveResult = move.get(timeOut.toMillis(), TimeUnit.MILLISECONDS);
result = game.play(moveResult);
long move = currentPlayer.getMove(game.deepCopy());
PlayResult result = game.play(move);
GameState state = result.state();
notifyPlayerMove(new ImmutablePair<>(currentPlayer.getName(), Long.numberOfTrailingZeros(moveResult)));
notifyPlayerMove(new ImmutablePair<>(currentPlayer.getName(), Long.numberOfTrailingZeros(move)));
switch (state) {
case WIN, DRAW -> {
isRunning.set(false);
moveExecutor.shutdown();
notifyGameEnd(new ImmutablePair<>(state, game.getWinner()));
}
case NORMAL, TURN_SKIPPED -> { /* continue normally */ }
default -> {
logger.error("Unexpected state {}", state);
isRunning.set(false);
moveExecutor.shutdown();
throw new RuntimeException("Unknown state: " + state);
}
}
} catch (InterruptedException | ExecutionException e) {
isRunning.set(false);
notifyGameEnd(new ImmutablePair<>(GameState.DRAW, 0));
moveExecutor.shutdown();
return;
} catch (TimeoutException e) {
isRunning.set(false);
notifyGameEnd(new ImmutablePair<>(GameState.WIN, 1+game.getWinner()%2));
moveExecutor.shutdown();
return;
}
}
}
}

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);
}

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

@@ -65,9 +65,6 @@ 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)
implements GenericEvent {}
/** Indicates that a game move has been processed or received. */
public record GameMoveResponse(long clientId, String player, String move, String details)
implements GenericEvent {}
@@ -222,5 +219,4 @@ public class NetworkEvents extends EventsBase {
/** Response to a {@link ChangeAddress} event, carrying the success result. */
public record ChangeAddressResponse(boolean successful, long identifier)
implements ResponseToUniqueEvent {}
}

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

@@ -3,9 +3,6 @@ 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;
@@ -97,9 +94,6 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
case "HELP":
helpHandler(recSrvRemoved);
return;
case "RESULTS":
resultsHandler(recSrvRemoved);
return;
default:
// return
}
@@ -109,66 +103,6 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
}
}
private static String extract(String input, String key) {
Pattern p = Pattern.compile(
key + "\\s*:\\s*(\\[[^]]*]|\"[^\"]*\")",
Pattern.CASE_INSENSITIVE
);
Matcher m = p.matcher(input);
return m.find() ? m.group(1) : null;
}
private void resultsHandler(String rec) {
// TODO all of this
IO.println(rec);
String gameTypeRaw = extract(rec, "GAMETYPE");
String usersRaw = extract(rec, "USERS");
String scoreTypesRaw = extract(rec, "SCORETYPES");
String scoresRaw = extract(rec, "SCORES");
if (usersRaw == null) return;
String[] users;
if (usersRaw.length() > 2) {
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<>()));
}
}
private void gameMoveHandler(String rec) {
String[] msg =
Pattern.compile(

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) {}

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

@@ -1,13 +1,9 @@
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);
void startGame(String gameType, 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);
}

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

@@ -5,65 +5,44 @@ 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;
public OnlineTurnBasedGame(NettyClient[] admins, TurnBasedGame game, CompletableFuture<Integer> resultFuture, Duration timeOut, NettyClient... 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()),
timeOut
(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
}
}
@Override
@@ -82,7 +61,7 @@ public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
}
@Override
public void start() {
public void start(){
this.gameThread.start();
}
}

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

@@ -1,6 +1,5 @@
package org.toop.framework.networking.server;
import com.google.gson.Gson;
import org.toop.framework.game.players.ServerPlayer;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
import org.toop.framework.networking.server.challenges.gamechallenge.GameChallenge;
@@ -10,9 +9,6 @@ import org.toop.framework.networking.server.stores.ClientStore;
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,14 +27,13 @@ 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,
ClientStore<Long, NettyClient> clientStore,
TurnBasedGameStore gameStore,
SubscriptionStore subStore
) {
this.gameTypesStore = turnBasedGameTypeStore;
this.challengeDuration = challengeDuration;
@@ -51,13 +46,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 +103,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(), challenge.getUsers());
break;
}
}
@@ -132,24 +125,12 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
}
@Override
public GameResultFuture startGame(String gameType, Duration turnTime, NettyClient... clients) {
if (!gameTypesStore.all().containsKey(gameType)) return null;
public void startGame(String gameType, NettyClient... clients) {
if (!gameTypesStore.all().containsKey(gameType)) return;
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), clients);
for (int i = 0; i < clients.length; i++) {
players[i] = new ServerPlayer(clients[i]);
@@ -167,14 +148,11 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
clients[0].name(),
gameType,
clients[0].name()));
game.start();
return grfReturn;
} catch (Exception e) {
IO.println("ERROR: Failed to start OnlineTurnBasedGame");
e.printStackTrace();
}
return null;
}
@Override
@@ -182,10 +160,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();
@@ -244,6 +218,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
}
if (userInGame) { continue; }
//
int first = Math.max(left, right);
int second = Math.min(left, right);
@@ -251,7 +226,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, getUser(userLeft), getUser(userRight));
}
}
}
@@ -285,74 +260,4 @@ 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;
}
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;
Map<String, List<ImmutablePair<String, Integer>>> combined = new HashMap<>();
for (var system : systems) {
for (var player : system.getScore().keySet()) {
combined.putIfAbsent(player.name(), new ArrayList<>());
combined.get(player.name()).addLast(new ImmutablePair<>(system.scoreName(), system.getScore().get(player)));
}
}
List<String> names = new ArrayList<>();
List<String> systemNames = new ArrayList<>();
List<List<Integer>> scores = new ArrayList<>();
for (var player : combined.entrySet()) {
names.addLast(player.getKey());
scores.addLast(new ArrayList<>());
for (var system : player.getValue()) {
if (!systemNames.contains(system.getLeft())) systemNames.addLast(system.getLeft());
scores.getLast().addLast(system.getRight());
}
}
Gson gson = new Gson();
String namesJson = gson.toJson(names);
String systemNamesJson = gson.toJson(systemNames);
String scoresJson = gson.toJson(scores);
String msg = String.format(
"SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORETYPES: %s, SCORES: %s, TOURNAMENT: 1}",
"none", // TODO gametype
namesJson,
systemNamesJson,
scoresJson
);
for (var user : onlineUsers()) {
user.send(msg);
}
}
}

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");
}

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

@@ -1,17 +1,18 @@
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.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;
}
@@ -27,7 +28,6 @@ public class MessageHandler implements Handler<ParsedMessage> {
case "challenge" -> handleChallenge(message, client);
case "message" -> handleMessage(message, client);
case "help" -> handleHelp(message, client);
case "tournament" -> handleTournament(message, client);
default -> client.send("ERROR Unknown command");
}
}
@@ -41,27 +41,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 +73,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 +101,10 @@ 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]));
}
private void handleTournament(ParsedMessage p, NettyClient client) {
if(!hasArgs(p.args())) return;
if (p.args()[0].equalsIgnoreCase("start") && p.args().length > 1) {
server.startTournament(p.args()[1], client, false); // TODO add shuffle to msg
}
client.player().setMove(1L << Integer.parseInt(p.args()[0]));
}
}

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();
}
}
}

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();
}
}
}

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);
}

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

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

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

@@ -1,18 +0,0 @@
package org.toop.framework.networking.server.tournaments;
import org.toop.framework.networking.server.client.NettyClient;
import org.toop.framework.utils.ImmutablePair;
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;
}
}

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

@@ -1,20 +0,0 @@
package org.toop.framework.networking.server.tournaments.shufflers;
import java.util.List;
import java.util.Random;
public class RandomShuffle implements Shuffler {
@Override
public <T> void shuffle(List<T> listToShuffle) {
final int SHUFFLE_AMOUNT = listToShuffle.size() * 2;
Random rand = new Random();
for (int i = 0; i <= SHUFFLE_AMOUNT; i++) {
int index = rand.nextInt(listToShuffle.size());
T match = listToShuffle.get(index);
listToShuffle.remove(index);
listToShuffle.addLast(match);
}
}
}

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

@@ -1,7 +0,0 @@
package org.toop.framework.networking.server.tournaments.shufflers;
import java.util.List;
public interface Shuffler {
<T> void shuffle(List<T> listToShuffle);
}

317
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);
}
return root;
float result = 0.0f;
if (node.state.getLegalMoves() != 0) {
result = simulation(node.state, game.getCurrentTurn());
}
protected Node expansion(Node leaf) {
if (leaf.unexpandedMoves == 0L) {
return leaf;
backPropagation(node, result);
}
final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
int mostVisitedIndex = -1;
int mostVisits = -1;
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;
for (int i = 0; i < root.expanded; i++) {
if (root.children[i].visits > mostVisits) {
mostVisitedIndex = i;
mostVisits = root.children[i].visits;
}
}
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);
return mostVisitedIndex != -1? root.children[mostVisitedIndex].move : randomSetBit(game.getLegalMoves());
}
if (copiedState.getWinner() == playerIndex) {
private Node selection(Node node) {
while (node.state.getLegalMoves() != 0L && node.isFullyExpanded()) {
node = node.bestUCTChild();
}
return node;
}
private Node expansion(Node node, long legalMoves) {
for (int i = 0; i < node.expanded; i++) {
legalMoves &= ~node.children[i].move;
}
if (legalMoves == 0L) {
return node;
}
long move = randomSetBit(legalMoves);
TurnBasedGame copy = node.state.deepCopy();
copy.play(move);
Node newlyExpanded = new Node(copy, move, node);
node.children[node.expanded] = newlyExpanded;
node.expanded++;
return newlyExpanded;
}
private float simulation(TurnBasedGame state, int playerIndex) {
TurnBasedGame copy = state.deepCopy();
long legalMoves = copy.getLegalMoves();
PlayResult result = null;
while (legalMoves != 0) {
result = copy.play(randomSetBit(legalMoves));
legalMoves = copy.getLegalMoves();
}
if (result.state() == GameState.WIN) {
if (result.player() == playerIndex) {
return 1.0f;
}
if (copiedState.getWinner() >= 0) {
return -1.0f;
}
return 0.0f;
return -0.2f;
}
protected void backPropagation(Node leaf, float value) {
while (leaf != null) {
leaf.value += value;
leaf.visits++;
if (Float.isNaN(leaf.solved)) {
updateSolvedStatus(leaf);
}
value = -value;
leaf = leaf.parent;
private void backPropagation(Node node, float value) {
while (node != null) {
node.visits++;
node.value += value;
node = node.parent;
}
}
protected Node mostVisitedChild(Node root) {
final int expanded = root.getExpanded();
public static long randomSetBit(long value) {
Random random = new Random();
Node mostVisitedChild = null;
int mostVisited = -1;
int count = Long.bitCount(value);
int target = random.nextInt(count);
for (int i = 0; i < expanded; i++) {
if (root.children[i].visits > mostVisited) {
mostVisitedChild = root.children[i];
mostVisited = root.children[i].visits;
while (true) {
int bit = Long.numberOfTrailingZeros(value);
if (target == 0) {
return 1L << bit;
}
}
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);
}
}
}