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

Merge branch 'Development' into ReversiML

Browse Source 
# Conflicts:
#	game/src/main/java/org/toop/game/games/reversi/ReversiR.java
This commit is contained in:
Ticho Hidding
2025-12-13 15:04:40 +01:00
parent 03dc6130e2 1ae79daef0
commit ffdec38e5d
71 changed files with 1608 additions and 1823 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
app/src/main/java/org/toop/app/App.java
View File

@@ -2,6 +2,7 @@ package org.toop.app;
import javafx.application.Platform;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyCodeCombination;
import javafx.scene.input.KeyEvent;
import org.toop.app.widget.Primitive;
@@ -68,8 +69,8 @@ public final class App extends Application {
scene.getRoot();
stage.setMinWidth(1080);
stage.setMinHeight(720);
stage.setMinWidth(1200);
stage.setMinHeight(800);
stage.setOnCloseRequest(event -> {
event.consume();
quit();
@@ -111,20 +112,19 @@ public final class App extends Application {
Platform.runLater(() -> stage.setOpacity(1.0));
}
Platform.runLater(() -> loading.setMaxAmount(e.isLoadingAmount()));
Platform.runLater(() -> {
loading.setMaxAmount(e.isLoadingAmount());
try {
loading.setAmount(e.hasLoadedAmount());
} catch (Exception ex) {
throw new RuntimeException(ex);
}
if (e.hasLoadedAmount() >= e.isLoadingAmount()-1) {
Platform.runLater(loading::triggerSuccess);
loadingFlow.unsubscribe("init_loading");
}
});
if (e.hasLoadedAmount() >= e.isLoadingAmount()) {
Platform.runLater(loading::triggerSuccess);
loadingFlow.unsubscribe("init_loading");
}
}, false, "init_loading");
@@ -153,6 +153,11 @@ public final class App extends Application {
escapePopup();
}
});
stage.setFullScreenExitKeyCombination(
new KeyCodeCombination(
KeyCode.F11
)
);
}
public void escapePopup() {

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

@@ -2,9 +2,7 @@ package org.toop.app;
import javafx.application.Platform;
import javafx.geometry.Pos;
import org.toop.app.gameControllers.AbstractGameController;
import org.toop.app.gameControllers.ReversiController;
import org.toop.app.gameControllers.TicTacToeController;
import org.toop.app.gameControllers.*;
import org.toop.app.widget.Primitive;
import org.toop.app.widget.WidgetContainer;
import org.toop.app.widget.complex.LoadingWidget;
@@ -13,16 +11,17 @@ 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.gameFramework.controller.GameController;
import org.toop.framework.eventbus.GlobalEventBus;
import org.toop.framework.gameFramework.model.player.Player;
import org.toop.framework.networking.clients.TournamentNetworkingClient;
import org.toop.framework.networking.events.NetworkEvents;
import org.toop.framework.networking.types.NetworkingConnector;
import org.toop.game.games.reversi.BitboardReversi;
import org.toop.game.games.tictactoe.BitboardTicTacToe;
import org.toop.game.players.ArtificialPlayer;
import org.toop.game.players.OnlinePlayer;
import org.toop.game.games.reversi.ReversiAIR;
import org.toop.game.games.reversi.ReversiR;
import org.toop.game.games.tictactoe.TicTacToeAIR;
import org.toop.game.players.ai.RandomAI;
import org.toop.local.AppContext;
import java.util.List;
@@ -33,6 +32,7 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
public final class Server {
// TODO: Keep track of listeners. Remove them on Server connection close so reference is deleted.
private String user = "";
private long clientId = -1;
@@ -42,7 +42,7 @@ public final class Server {
private ServerView primary;
private boolean isPolling = true;
private AbstractGameController<?> gameController;
private GameController gameController;
private final AtomicBoolean isSingleGame = new AtomicBoolean(false);
@@ -201,26 +201,31 @@ public final class Server {
information.players[0].computerThinkTime = 1;
information.players[1].name = response.opponent();
Player[] players = new Player[2];
players[(myTurn + 1) % 2] = new OnlinePlayer<ReversiR>(response.opponent());
switch (type){
/*switch (type){
case TICTACTOE ->{
players[myTurn] = new ArtificialPlayer<>(new TicTacToeAIR(9), user);
}
case REVERSI ->{
players[myTurn] = new ArtificialPlayer<>(new ReversiAIR(), user);
}
}
}*/
switch (type) {
case TICTACTOE ->{
gameController = new TicTacToeController(players, false);
Player<BitboardTicTacToe>[] players = new Player[2];
players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardTicTacToe>(), user);
gameController = new TicTacToeBitController(players);
}
case REVERSI ->
gameController = new ReversiController(players, false);
case REVERSI -> {
Player<BitboardReversi>[] players = new Player[2];
players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), user);
gameController = new ReversiBitController(players);}
default -> new ErrorPopup("Unsupported game type.");
}
if (gameController != null){

247
app/src/main/java/org/toop/app/canvas/BitGameCanvas.java Normal file
View File

@@ -0,0 +1,247 @@
package org.toop.app.canvas;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.input.MouseButton;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
import javafx.util.Duration;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
import org.toop.framework.gameFramework.view.GUIEvents;
import java.util.function.Consumer;
public abstract class BitGameCanvas<T extends TurnBasedGame<T>> implements GameCanvas<T> {
protected record Cell(float x, float y, float width, float height) {
public boolean isInside(double x, double y) {
return x >= this.x && x <= this.x + width &&
y >= this.y && y <= this.y + height;
}
}
protected final Canvas canvas;
protected final GraphicsContext graphics;
protected final Color color;
protected final Color backgroundColor;
protected final int width;
protected final int height;
protected final int rowSize;
protected final int columnSize;
protected final int gapSize;
protected final boolean edges;
protected final Cell[] cells;
private Consumer<Long> onCellCLicked;
public void setOnCellClicked(Consumer<Long> onClick) {
this.onCellCLicked = onClick;
}
protected BitGameCanvas(Color color, Color backgroundColor, int width, int height, int rowSize, int columnSize, int gapSize, boolean edges) {
canvas = new Canvas(width, height);
graphics = canvas.getGraphicsContext2D();
this.onCellCLicked = (c) -> new EventFlow().addPostEvent(GUIEvents.PlayerAttemptedMove.class, c).postEvent();
this.color = color;
this.backgroundColor = backgroundColor;
this.width = width;
this.height = height;
this.rowSize = rowSize;
this.columnSize = columnSize;
this.gapSize = gapSize;
this.edges = edges;
cells = new Cell[rowSize * columnSize];
final float cellWidth = ((float) width - gapSize * rowSize - gapSize) / rowSize;
final float cellHeight = ((float) height - gapSize * columnSize - gapSize) / columnSize;
for (int y = 0; y < columnSize; y++) {
final float startY = y * cellHeight + y * gapSize + gapSize;
for (int x = 0; x < rowSize; x++) {
final float startX = x * cellWidth + x * gapSize + gapSize;
cells[x + y * rowSize] = new Cell(startX, startY, cellWidth, cellHeight);
}
}
canvas.setOnMouseClicked(event -> {
if (event.getButton() != MouseButton.PRIMARY) {
return;
}
final int column = (int) ((event.getX() / this.width) * rowSize);
final int row = (int) ((event.getY() / this.height) * columnSize);
final Cell cell = cells[column + row * rowSize];
if (cell.isInside(event.getX(), event.getY())) {
event.consume();
this.onCellCLicked.accept(1L << (column + row * rowSize));
}
});
render();
}
public void loopOverBoard(long bb, Consumer<Integer> onCell){
while (bb != 0) {
int idx = Long.numberOfTrailingZeros(bb); // index of least-significant 1-bit
onCell.accept(idx);
bb &= bb - 1; // clear LSB 1-bit
}
}
private void render() {
graphics.setFill(backgroundColor);
graphics.fillRect(0, 0, width, height);
graphics.setFill(color);
for (int x = 0; x < rowSize - 1; x++) {
final float start = cells[x].x + cells[x].width;
graphics.fillRect(start, gapSize, gapSize, height - gapSize * 2);
}
for (int y = 0; y < columnSize - 1; y++) {
final float start = cells[y * rowSize].y + cells[y * rowSize].height;
graphics.fillRect(gapSize, start, width - gapSize * 2, gapSize);
}
if (edges) {
graphics.fillRect(0, 0, width, gapSize);
graphics.fillRect(0, 0, gapSize, height);
graphics.fillRect(width - gapSize, 0, gapSize, height);
graphics.fillRect(0, height - gapSize, width, gapSize);
}
}
public void fill(Color color, int cell) {
final float x = cells[cell].x();
final float y = cells[cell].y();
final float width = cells[cell].width();
final float height = cells[cell].height();
graphics.setFill(color);
graphics.fillRect(x, y, width, height);
}
public void clear(int cell) {
final float x = cells[cell].x();
final float y = cells[cell].y();
final float width = cells[cell].width();
final float height = cells[cell].height();
graphics.clearRect(x, y, width, height);
graphics.setFill(backgroundColor);
graphics.fillRect(x, y, width, height);
}
public void clearAll() {
for (int i = 0; i < cells.length; i++) {
clear(i);
}
}
public void drawPlayerMove(int player, int move) {
final float x = cells[move].x() + gapSize;
final float y = cells[move].y() + gapSize;
final float width = cells[move].width() - gapSize * 2;
final float height = cells[move].height() - gapSize * 2;
graphics.setFill(color);
graphics.setFont(Font.font("Arial", 40)); // TODO different font and size
graphics.fillText(String.valueOf(player), x + width, y + height);
}
public void drawDot(Color color, int cell) {
final float x = cells[cell].x() + gapSize;
final float y = cells[cell].y() + gapSize;
final float width = cells[cell].width() - gapSize * 2;
final float height = cells[cell].height() - gapSize * 2;
graphics.setFill(color);
graphics.fillOval(x, y, width, height);
}
public void drawInnerDot(Color color, int cell, boolean slightlyBigger) {
final float x = cells[cell].x() + gapSize;
final float y = cells[cell].y() + gapSize;
float multiplier = slightlyBigger?1.4f:1.5f;
final float width = (cells[cell].width() - gapSize * 2)/multiplier;
final float height = (cells[cell].height() - gapSize * 2)/multiplier;
float offset = slightlyBigger?5f:4f;
graphics.setFill(color);
graphics.fillOval(x + width/offset, y + height/offset, width, height);
}
private void drawDotScaled(Color color, int cell, double scale) {
final float cx = cells[cell].x() + gapSize;
final float cy = cells[cell].y() + gapSize;
final float fullWidth = cells[cell].width() - gapSize * 2;
final float height = cells[cell].height() - gapSize * 2;
final float scaledWidth = (float)(fullWidth * scale);
final float offsetX = (fullWidth - scaledWidth) / 2;
graphics.setFill(color);
graphics.fillOval(cx + offsetX, cy, scaledWidth, height);
}
public Timeline flipDot(Color fromColor, Color toColor, int cell) {
final int steps = 60;
final long duration = 250;
final double interval = duration / (double) steps;
final Timeline timeline = new Timeline();
for (int i = 0; i <= steps; i++) {
final double t = i / (double) steps;
final KeyFrame keyFrame = new KeyFrame(Duration.millis(i * interval),
_ -> {
clear(cell);
final double scale = t <= 0.5 ? 1 - 2 * t : 2 * t - 1;
final Color currentColor = t < 0.5 ? fromColor : toColor;
drawDotScaled(currentColor, cell, scale);
}
);
timeline.getKeyFrames().add(keyFrame);
}
return timeline;
}
public Canvas getCanvas() {
return canvas;
}
}

17
app/src/main/java/org/toop/app/canvas/Connect4Canvas.java
View File

@@ -1,17 +0,0 @@
package org.toop.app.canvas;
import javafx.scene.paint.Color;
import org.toop.framework.gameFramework.model.game.AbstractGame;
import java.util.function.Consumer;
public class Connect4Canvas extends GameCanvas {
public Connect4Canvas(Color color, int width, int height, Consumer<Integer> onCellClicked) {
super(color, Color.TRANSPARENT, width, height, 7, 6, 10, true, onCellClicked,null);
}
@Override
public void drawPlayerHover(int player, int move, AbstractGame game) {
}
}

4
app/src/main/java/org/toop/app/canvas/DrawPlayerHover.java
View File

@@ -1,7 +1,7 @@
package org.toop.app.canvas;
import org.toop.framework.gameFramework.model.game.AbstractGame;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
public interface DrawPlayerHover {
void drawPlayerHover(int player, int move, AbstractGame game);
void drawPlayerHover(int player, int move, TurnBasedGame game);
}

237
app/src/main/java/org/toop/app/canvas/GameCanvas.java
View File

@@ -1,237 +1,8 @@
package org.toop.app.canvas;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.input.MouseButton;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
import javafx.util.Duration;
import org.toop.framework.gameFramework.model.game.AbstractGame;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
import java.util.function.Consumer;
public abstract class GameCanvas<T extends AbstractGame> implements DrawPlayerMove, DrawPlayerHover {
protected record Cell(float x, float y, float width, float height) {
public boolean isInside(double x, double y) {
return x >= this.x && x <= this.x + width &&
y >= this.y && y <= this.y + height;
}
}
protected final Canvas canvas;
protected final GraphicsContext graphics;
protected final Color color;
protected final Color backgroundColor;
protected final int width;
protected final int height;
protected final int rowSize;
protected final int columnSize;
protected final int gapSize;
protected final boolean edges;
protected final Cell[] cells;
private Consumer<Integer> onCellCLicked;
public void setOnCellClicked(Consumer<Integer> onClick) {
this.onCellCLicked = onClick;
}
protected GameCanvas(Color color, Color backgroundColor, int width, int height, int rowSize, int columnSize, int gapSize, boolean edges, Consumer<Integer> onCellClicked, Consumer<Integer> newCellEntered) {
canvas = new Canvas(width, height);
graphics = canvas.getGraphicsContext2D();
this.onCellCLicked = onCellClicked;
this.color = color;
this.backgroundColor = backgroundColor;
this.width = width;
this.height = height;
this.rowSize = rowSize;
this.columnSize = columnSize;
this.gapSize = gapSize;
this.edges = edges;
cells = new Cell[rowSize * columnSize];
final float cellWidth = ((float) width - gapSize * rowSize - gapSize) / rowSize;
final float cellHeight = ((float) height - gapSize * columnSize - gapSize) / columnSize;
for (int y = 0; y < columnSize; y++) {
final float startY = y * cellHeight + y * gapSize + gapSize;
for (int x = 0; x < rowSize; x++) {
final float startX = x * cellWidth + x * gapSize + gapSize;
cells[x + y * rowSize] = new Cell(startX, startY, cellWidth, cellHeight);
}
}
canvas.setOnMouseClicked(event -> {
if (event.getButton() != MouseButton.PRIMARY) {
return;
}
final int column = (int) ((event.getX() / this.width) * rowSize);
final int row = (int) ((event.getY() / this.height) * columnSize);
final Cell cell = cells[column + row * rowSize];
if (cell.isInside(event.getX(), event.getY())) {
event.consume();
this.onCellCLicked.accept(column + row * rowSize);
}
});
render();
}
private void render() {
graphics.setFill(backgroundColor);
graphics.fillRect(0, 0, width, height);
graphics.setFill(color);
for (int x = 0; x < rowSize - 1; x++) {
final float start = cells[x].x + cells[x].width;
graphics.fillRect(start, gapSize, gapSize, height - gapSize * 2);
}
for (int y = 0; y < columnSize - 1; y++) {
final float start = cells[y * rowSize].y + cells[y * rowSize].height;
graphics.fillRect(gapSize, start, width - gapSize * 2, gapSize);
}
if (edges) {
graphics.fillRect(0, 0, width, gapSize);
graphics.fillRect(0, 0, gapSize, height);
graphics.fillRect(width - gapSize, 0, gapSize, height);
graphics.fillRect(0, height - gapSize, width, gapSize);
}
}
public void fill(Color color, int cell) {
final float x = cells[cell].x();
final float y = cells[cell].y();
final float width = cells[cell].width();
final float height = cells[cell].height();
graphics.setFill(color);
graphics.fillRect(x, y, width, height);
}
public void clear(int cell) {
final float x = cells[cell].x();
final float y = cells[cell].y();
final float width = cells[cell].width();
final float height = cells[cell].height();
graphics.clearRect(x, y, width, height);
graphics.setFill(backgroundColor);
graphics.fillRect(x, y, width, height);
}
public void clearAll() {
for (int i = 0; i < cells.length; i++) {
clear(i);
}
}
@Override
public void drawPlayerMove(int player, int move) {
final float x = cells[move].x() + gapSize;
final float y = cells[move].y() + gapSize;
final float width = cells[move].width() - gapSize * 2;
final float height = cells[move].height() - gapSize * 2;
graphics.setFill(color);
graphics.setFont(Font.font("Arial", 40)); // TODO different font and size
graphics.fillText(String.valueOf(player), x + width, y + height);
}
public void drawDot(Color color, int cell) {
final float x = cells[cell].x() + gapSize;
final float y = cells[cell].y() + gapSize;
final float width = cells[cell].width() - gapSize * 2;
final float height = cells[cell].height() - gapSize * 2;
graphics.setFill(color);
graphics.fillOval(x, y, width, height);
}
public void drawInnerDot(Color color, int cell, boolean slightlyBigger) {
final float x = cells[cell].x() + gapSize;
final float y = cells[cell].y() + gapSize;
float multiplier = slightlyBigger?1.4f:1.5f;
final float width = (cells[cell].width() - gapSize * 2)/multiplier;
final float height = (cells[cell].height() - gapSize * 2)/multiplier;
float offset = slightlyBigger?5f:4f;
graphics.setFill(color);
graphics.fillOval(x + width/offset, y + height/offset, width, height);
}
private void drawDotScaled(Color color, int cell, double scale) {
final float cx = cells[cell].x() + gapSize;
final float cy = cells[cell].y() + gapSize;
final float fullWidth = cells[cell].width() - gapSize * 2;
final float height = cells[cell].height() - gapSize * 2;
final float scaledWidth = (float)(fullWidth * scale);
final float offsetX = (fullWidth - scaledWidth) / 2;
graphics.setFill(color);
graphics.fillOval(cx + offsetX, cy, scaledWidth, height);
}
public Timeline flipDot(Color fromColor, Color toColor, int cell) {
final int steps = 60;
final long duration = 250;
final double interval = duration / (double) steps;
final Timeline timeline = new Timeline();
for (int i = 0; i <= steps; i++) {
final double t = i / (double) steps;
final KeyFrame keyFrame = new KeyFrame(Duration.millis(i * interval),
_ -> {
clear(cell);
final double scale = t <= 0.5 ? 1 - 2 * t : 2 * t - 1;
final Color currentColor = t < 0.5 ? fromColor : toColor;
drawDotScaled(currentColor, cell, scale);
}
);
timeline.getKeyFrames().add(keyFrame);
}
return timeline;
}
public Canvas getCanvas() {
return canvas;
}
}
public interface GameCanvas<T extends TurnBasedGame<T>> extends GameDrawer<T>{
Canvas getCanvas();
}

7
app/src/main/java/org/toop/app/canvas/GameDrawer.java Normal file
View File

@@ -0,0 +1,7 @@
package org.toop.app.canvas;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
public interface GameDrawer<T extends TurnBasedGame<T>> {
void redraw(T gameCopy);
}

42
app/src/main/java/org/toop/app/canvas/ReversiBitCanvas.java Normal file
View File

@@ -0,0 +1,42 @@
package org.toop.app.canvas;
import javafx.scene.paint.Color;
import org.toop.app.App;
import org.toop.game.games.reversi.BitboardReversi;
import java.util.Arrays;
import java.util.function.Consumer;
public class ReversiBitCanvas extends BitGameCanvas<BitboardReversi> {
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 -> {
double mouseX = event.getX();
double mouseY = event.getY();
int cellId = -1;
BitGameCanvas.Cell hovered = null;
for (BitGameCanvas.Cell cell : cells) {
if (cell.isInside(mouseX, mouseY)) {
hovered = cell;
cellId = turnCoordsIntoCellId(mouseX, mouseY);
break;
}
}
});
}
private int turnCoordsIntoCellId(double x, double y) {
final int column = (int) ((x / this.width) * rowSize);
final int row = (int) ((y / this.height) * columnSize);
return column + row * rowSize;
}
@Override
public void redraw(BitboardReversi gameCopy) {
clearAll();
long[] board = gameCopy.getBoard();
loopOverBoard(board[0], (i) -> drawDot(Color.WHITE, i));
loopOverBoard(board[1], (i) -> drawDot(Color.BLACK, i));
}
}

96
app/src/main/java/org/toop/app/canvas/ReversiCanvas.java
View File

@@ -1,96 +0,0 @@
package org.toop.app.canvas;
import javafx.scene.paint.Color;
import org.toop.framework.gameFramework.model.game.AbstractGame;
import org.toop.game.Move;
import org.toop.game.games.reversi.ReversiR;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
public final class ReversiCanvas extends GameCanvas<ReversiR> {
private Move[] currentlyHighlightedMoves = null;
public ReversiCanvas(Color color, int width, int height, Consumer<Integer> onCellClicked, Consumer<Integer> newCellEntered) {
super(color, new Color(0f,0.4f,0.2f,1f), width, height, 8, 8, 5, true, onCellClicked, newCellEntered);
drawStartingDots();
final AtomicReference<Cell> lastHoveredCell = new AtomicReference<>(null);
canvas.setOnMouseMoved(event -> {
double mouseX = event.getX();
double mouseY = event.getY();
int cellId = -1;
Cell hovered = null;
for (Cell cell : cells) {
if (cell.isInside(mouseX, mouseY)) {
hovered = cell;
cellId = turnCoordsIntoCellId(mouseX, mouseY);
break;
}
}
Cell previous = lastHoveredCell.get();
if (hovered != previous) {
lastHoveredCell.set(hovered);
newCellEntered.accept(cellId);
}
});
}
public void setCurrentlyHighlightedMovesNull() {
currentlyHighlightedMoves = null;
}
public void drawHighlightDots(Move[] moves){
if (currentlyHighlightedMoves != null){
for (final Move move : currentlyHighlightedMoves){
Color color = move.value() == 'W'? Color.BLACK: Color.WHITE;
drawInnerDot(color, move.position(), true);
}
}
currentlyHighlightedMoves = moves;
if (moves != null) {
for (Move move : moves) {
Color color = move.value() == 'B' ? Color.BLACK : Color.WHITE;
drawInnerDot(color, move.position(), false);
}
}
}
private int turnCoordsIntoCellId(double x, double y) {
final int column = (int) ((x / this.width) * rowSize);
final int row = (int) ((y / this.height) * columnSize);
return column + row * rowSize;
}
public void drawStartingDots() {
drawDot(Color.BLACK, 28);
drawDot(Color.WHITE, 36);
drawDot(Color.BLACK, 35);
drawDot(Color.WHITE, 27);
}
public void drawLegalPosition(int cell, char player) {
Color innerColor;
if (player == 'B') {
innerColor = new Color(0.0f, 0.0f, 0.0f, 0.6f);
}
else {
innerColor = new Color(1.0f, 1.0f, 1.0f, 0.75f);
}
drawInnerDot(innerColor, cell,false);
}
@Override
public void drawPlayerMove(int player ,int move){
super.drawPlayerMove(player, move);
}
@Override
public void drawPlayerHover(int player, int move, AbstractGame game) {
}
}

63
app/src/main/java/org/toop/app/canvas/TicTacToeBitCanvas.java Normal file
View File

@@ -0,0 +1,63 @@
package org.toop.app.canvas;
import javafx.scene.paint.Color;
import org.toop.app.App;
import org.toop.game.games.tictactoe.BitboardTicTacToe;
import java.util.Arrays;
import java.util.function.Consumer;
public class TicTacToeBitCanvas extends BitGameCanvas<BitboardTicTacToe>{
public TicTacToeBitCanvas() {
super(
Color.GRAY,
Color.TRANSPARENT,
(App.getHeight() / 4) * 3,
(App.getHeight() / 4) * 3,
3,
3,
30,
false
);
}
@Override
public void redraw(BitboardTicTacToe gameCopy) {
clearAll();
drawMoves(gameCopy.getBoard());
}
private void drawMoves(long[] gameBoard){
loopOverBoard(gameBoard[0], (i) -> drawX(Color.RED, i));
loopOverBoard(gameBoard[1], (i) -> drawO(Color.BLUE, i));
}
public void drawX(Color color, int cell) {
graphics.setStroke(color);
graphics.setLineWidth(gapSize);
final float x = cells[cell].x() + gapSize;
final float y = cells[cell].y() + gapSize;
final float width = cells[cell].width() - gapSize * 2;
final float height = cells[cell].height() - gapSize * 2;
graphics.strokeLine(x, y, x + width, y + height);
graphics.strokeLine(x + width, y, x, y + height);
}
public void drawO(Color color, int cell) {
graphics.setStroke(color);
graphics.setLineWidth(gapSize);
final float x = cells[cell].x() + gapSize;
final float y = cells[cell].y() + gapSize;
final float width = cells[cell].width() - gapSize * 2;
final float height = cells[cell].height() - gapSize * 2;
graphics.strokeOval(x, y, width, height);
}
}

54
app/src/main/java/org/toop/app/canvas/TicTacToeCanvas.java
View File

@@ -1,54 +0,0 @@
package org.toop.app.canvas;
import javafx.scene.paint.Color;
import org.toop.framework.gameFramework.model.game.AbstractGame;
import org.toop.game.games.tictactoe.TicTacToeR;
import java.util.function.Consumer;
public final class TicTacToeCanvas extends GameCanvas<TicTacToeR> {
public TicTacToeCanvas(Color color, int width, int height, Consumer<Integer> onCellClicked) {
super(color, Color.TRANSPARENT, width, height, 3, 3, 30, false, onCellClicked,null);
}
@Override
public void drawPlayerMove(int player, int move) {
switch (player) {
case 0 -> drawX(Color.RED, move);
case 1 -> drawO(Color.BLUE, move);
default -> super.drawPlayerMove(player, move);
}
}
public void drawX(Color color, int cell) {
graphics.setStroke(color);
graphics.setLineWidth(gapSize);
final float x = cells[cell].x() + gapSize;
final float y = cells[cell].y() + gapSize;
final float width = cells[cell].width() - gapSize * 2;
final float height = cells[cell].height() - gapSize * 2;
graphics.strokeLine(x, y, x + width, y + height);
graphics.strokeLine(x + width, y, x, y + height);
}
public void drawO(Color color, int cell) {
graphics.setStroke(color);
graphics.setLineWidth(gapSize);
final float x = cells[cell].x() + gapSize;
final float y = cells[cell].y() + gapSize;
final float width = cells[cell].width() - gapSize * 2;
final float height = cells[cell].height() - gapSize * 2;
graphics.strokeOval(x, y, width, height);
}
@Override
public void drawPlayerHover(int player, int move, AbstractGame game) {
}
}

127
app/src/main/java/org/toop/app/gameControllers/AbstractGameController.java
View File

@@ -1,127 +0,0 @@
package org.toop.app.gameControllers;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.toop.framework.gameFramework.controller.UpdatesGameUI;
import org.toop.framework.gameFramework.view.GUIEvents;
import org.toop.app.canvas.GameCanvas;
import org.toop.framework.networking.events.NetworkEvents;
import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
import org.toop.app.widget.view.GameView;
import org.toop.framework.eventbus.EventFlow;
import org.toop.game.gameThreads.OnlineThreadBehaviour;
import org.toop.framework.gameFramework.model.game.AbstractGame;
import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
import org.toop.framework.gameFramework.model.player.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
public abstract class AbstractGameController<T extends AbstractGame<T>> implements UpdatesGameUI, ThreadBehaviour<T> {
protected final EventFlow eventFlow = new EventFlow();
protected final List<Consumer<?>> listeners = new ArrayList<>();
// Logger for logging ofcourse
protected final Logger logger = LogManager.getLogger(this.getClass());
// Reference to primary view
protected final GameView primary;
// Reference to game canvas
protected final GameCanvas<T> canvas;
private final Player<T>[] players; // List of players, can't be changed.
protected final T game; // Reference to game instance
private final ThreadBehaviour<T> gameThreadBehaviour;
// TODO: Change gameType to automatically happen with either dependency injection or something else.
// TODO: Make visualisation of moves a behaviour.
protected AbstractGameController(GameCanvas<T> canvas, Player<T>[] players, T game, ThreadBehaviour<T> gameThreadBehaviour, String gameType) {
logger.info("Creating AbstractGameController");
// Make sure player list matches expected size
if (players.length != game.getPlayerCount()){
logger.error("Player count mismatch");
throw new IllegalArgumentException("players and game's players must have same length");
}
this.canvas = canvas;
this.players = players;
this.game = game;
this.gameThreadBehaviour = gameThreadBehaviour;
primary = new GameView(null, null, null, gameType);
addListeners();
}
public void start(){
logger.info("Starting GameManager");
gameThreadBehaviour.start();;
}
public void stop(){
logger.info("Stopping GameManager");
removeListeners();
gameThreadBehaviour.stop();
}
public Player<T> getCurrentPlayer(){
return game.getPlayer(getCurrentPlayerIndex());
};
public int getCurrentPlayerIndex(){
return game.getCurrentTurn();
}
private void addListeners(){
eventFlow
.listen(GUIEvents.RefreshGameCanvas.class, this::onUpdateGameUI, false)
.listen(GUIEvents.GameEnded.class, this::onGameFinish, false);
}
private void removeListeners(){
eventFlow.unsubscribeAll();
}
private void onUpdateGameUI(GUIEvents.RefreshGameCanvas event){
this.updateUI();
}
private void onGameFinish(GUIEvents.GameEnded event){
logger.info("Game Finished");
String name = event.winner() == -1 ? null : getPlayer(event.winner()).getName();
primary.gameOver(event.winOrTie(), name);
stop();
}
public Player<T> getPlayer(int player){
if (player < 0 || player >= players.length){
logger.error("Invalid player index");
throw new IllegalArgumentException("player out of range");
}
return players[player];
}
private boolean isOnline(){
return this.gameThreadBehaviour instanceof SupportsOnlinePlay;
}
public void onYourTurn(NetworkEvents.YourTurnResponse event){
if (isOnline()){
((OnlineThreadBehaviour<T>) this.gameThreadBehaviour).onYourTurn(event);
}
}
public void onMoveReceived(NetworkEvents.GameMoveResponse event){
if (isOnline()){
((OnlineThreadBehaviour<T>) this.gameThreadBehaviour).onMoveReceived(event);
}
}
public void gameFinished(NetworkEvents.GameResultResponse event){
if (isOnline()){
((OnlineThreadBehaviour<T>) this.gameThreadBehaviour).gameFinished(event);
}
}
}

140
app/src/main/java/org/toop/app/gameControllers/GenericGameController.java Normal file
View File

@@ -0,0 +1,140 @@
package org.toop.app.gameControllers;
import javafx.application.Platform;
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.widget.WidgetContainer;
import org.toop.app.widget.view.GameView;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.eventbus.GlobalEventBus;
import org.toop.framework.gameFramework.controller.GameController;
import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
import org.toop.framework.gameFramework.model.game.TurnBasedGame;
import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
import org.toop.framework.gameFramework.model.player.Player;
import org.toop.framework.gameFramework.view.GUIEvents;
import org.toop.framework.networking.events.NetworkEvents;
import org.toop.game.players.LocalPlayer;
public class GenericGameController<T extends TurnBasedGame<T>> implements GameController {
protected final EventFlow eventFlow = new EventFlow();
// Logger for logging
protected final Logger logger = LogManager.getLogger(this.getClass());
// Reference to gameView view
protected final GameView gameView;
// Reference to game canvas
protected final GameCanvas<T> canvas;
protected final TurnBasedGame<T> game; // Reference to game instance
private final ThreadBehaviour gameThreadBehaviour;
// TODO: Change gameType to automatically happen with either dependency injection or something else.
public GenericGameController(GameCanvas<T> canvas, T game, ThreadBehaviour gameThreadBehaviour, String gameType) {
logger.info("Creating: " + this.getClass());
this.canvas = canvas;
this.game = game;
this.gameThreadBehaviour = gameThreadBehaviour;
// Tell thread how to send moves
this.gameThreadBehaviour.setOnSendMove((id, m) -> GlobalEventBus.get().post(new NetworkEvents.SendMove(id, (short)translateMove(m))));
// Tell thread how to update UI
this.gameThreadBehaviour.setOnUpdateUI(() -> Platform.runLater(this::updateUI));
// Change scene to game view
gameView = new GameView(null, null, null, gameType);
gameView.add(Pos.CENTER, canvas.getCanvas());
WidgetContainer.getCurrentView().transitionNext(gameView, true);
// Listen to updates
eventFlow
.listen(GUIEvents.GameEnded.class, this::onGameFinish, false)
.listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer<T> lp){lp.setLastMove(event.move());}}, false);
}
public void start(){
logger.info("Starting GameManager");
updateUI();
gameThreadBehaviour.start();
}
public void stop(){
logger.info("Stopping GameManager");
removeListeners();
gameThreadBehaviour.stop();
}
public Player<T> getCurrentPlayer(){
return game.getPlayer(getCurrentPlayerIndex());
}
public int getCurrentPlayerIndex(){
return game.getCurrentTurn();
}
protected long translateMove(int move){
return 1L << move;
}
protected int translateMove(long move){
return Long.numberOfTrailingZeros(move);
}
private void removeListeners(){
eventFlow.unsubscribeAll();
}
private void onGameFinish(GUIEvents.GameEnded event){
logger.info("Game Finished");
String name = event.winner() == -1 ? null : getPlayer(event.winner()).getName();
gameView.gameOver(event.winOrTie(), name);
stop();
}
public Player<T> getPlayer(int player){
if (player < 0 || player >= 2){ // TODO: Make game turn player count
logger.error("Invalid player index");
throw new IllegalArgumentException("player out of range");
}
return game.getPlayer(player);
}
private boolean isOnline(){
return this.gameThreadBehaviour instanceof SupportsOnlinePlay;
}
public void onYourTurn(NetworkEvents.YourTurnResponse event){
if (isOnline()){
((SupportsOnlinePlay) this.gameThreadBehaviour).onYourTurn(event.clientId());
}
}
public void onMoveReceived(NetworkEvents.GameMoveResponse event){
if (isOnline()){
((SupportsOnlinePlay) this.gameThreadBehaviour).onMoveReceived(
translateMove(Integer.parseInt(event.move())));
}
}
public void gameFinished(NetworkEvents.GameResultResponse event){
if (isOnline()){
((SupportsOnlinePlay) this.gameThreadBehaviour).gameFinished(event.condition());
}
}
@Override
public void sendMove(long clientId, long move) {
new EventFlow().addPostEvent(NetworkEvents.SendMove.class, clientId, (short) Long.numberOfTrailingZeros(move)).asyncPostEvent();
}
@Override
public void updateUI() {
canvas.redraw(game.deepCopy());
}
}

22
app/src/main/java/org/toop/app/gameControllers/ReversiBitController.java Normal file
View File

@@ -0,0 +1,22 @@
package org.toop.app.gameControllers;
import org.toop.app.canvas.ReversiBitCanvas;
import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
import org.toop.framework.gameFramework.model.player.Player;
import org.toop.game.gameThreads.LocalThreadBehaviour;
import org.toop.game.gameThreads.OnlineThreadBehaviour;
import org.toop.game.games.reversi.BitboardReversi;
import org.toop.game.players.OnlinePlayer;
public class ReversiBitController extends GenericGameController<BitboardReversi> {
public ReversiBitController(Player<BitboardReversi>[] players) {
BitboardReversi game = new BitboardReversi(players);
ThreadBehaviour thread = new LocalThreadBehaviour<>(game);
for (Player<BitboardReversi> player : players) {
if (player instanceof OnlinePlayer<BitboardReversi>){
thread = new OnlineThreadBehaviour<>(game);
}
}
super(new ReversiBitCanvas(), game, thread, "Reversi");
}
}

138
app/src/main/java/org/toop/app/gameControllers/ReversiController.java
View File

@@ -1,138 +0,0 @@
package org.toop.app.gameControllers;
import javafx.animation.SequentialTransition;
import javafx.geometry.Pos;
import javafx.scene.paint.Color;
import org.toop.app.App;
import org.toop.app.canvas.ReversiCanvas;
import org.toop.app.widget.WidgetContainer;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.gameFramework.model.game.AbstractGame;
import org.toop.framework.gameFramework.view.GUIEvents;
import org.toop.game.gameThreads.LocalFixedRateThreadBehaviour;
import org.toop.game.gameThreads.OnlineThreadBehaviour;
import org.toop.game.players.LocalPlayer;
import org.toop.framework.gameFramework.model.player.Player;
import org.toop.game.games.reversi.ReversiR;
public class ReversiController extends AbstractGameController<ReversiR> {
// TODO: Refactor GUI update methods to follow designed system
public ReversiController(Player<ReversiR>[] players, boolean local) {
ReversiR ReversiR = new ReversiR(players);
super(
new ReversiCanvas(Color.GRAY, (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3,(c) -> {new EventFlow().addPostEvent(GUIEvents.PlayerAttemptedMove.class, c).postEvent();}, (c) -> {new EventFlow().addPostEvent(GUIEvents.PlayerMoveHovered.class, c).postEvent();}),
players,
ReversiR,
local ? new LocalFixedRateThreadBehaviour<>(ReversiR, players) : new OnlineThreadBehaviour<>(ReversiR, players), // TODO: Player order matters here, this won't work atm
"Reversi");
eventFlow.listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}}, false);
eventFlow.listen(GUIEvents.PlayerMoveHovered.class, this::onHoverMove, false);
initUI();
}
private void onHoverMove(GUIEvents.PlayerMoveHovered event){
int cellEntered = event.move();
canvas.drawPlayerHover(-1, cellEntered, game);
/*// (information.players[game.getCurrentTurn()].isHuman) {
int[] legalMoves = game.getLegalMoves();
boolean isLegalMove = false;
for (int move : legalMoves) {
if (move == cellEntered){
isLegalMove = true;
break;
}
}
if (cellEntered >= 0){
int[] moves = null;
if (isLegalMove) {
moves = game.getFlipsForPotentialMove(
new Point(cellEntered%game.getColumnSize(),cellEntered/game.getRowSize()),
game.getCurrentPlayer());
}
canvas.drawHighlightDots(moves);
}
//}*/
}
public ReversiController(Player<ReversiR>[] players) {
this(players, true);
}
private void updateCanvas(boolean animate) {
// Todo: this is very inefficient. still very fast but if the grid is bigger it might cause issues. improve.
canvas.clearAll();
for (int i = 0; i < game.getBoard().length; i++) {
if (game.getBoard()[i] == 0) {
canvas.drawDot(Color.WHITE, i);
} else if (game.getBoard()[i] == 1) {
canvas.drawDot(Color.BLACK, i);
}
}
final int[] flipped = game.getMostRecentlyFlippedPieces();
final SequentialTransition animation = new SequentialTransition();
final Color fromColor = getCurrentPlayerIndex() == 0? Color.WHITE : Color.BLACK;
final Color toColor = getCurrentPlayerIndex() == 0? Color.BLACK : Color.WHITE;
if (animate && flipped != null) {
for (final int flip : flipped) {
canvas.clear(flip);
canvas.drawDot(fromColor, flip);
animation.getChildren().addFirst(canvas.flipDot(fromColor, toColor, flip));
}
}
animation.setOnFinished(_ -> {
if (getCurrentPlayer() instanceof LocalPlayer) {
final int[] legalMoves = game.getLegalMoves();
for (final int legalMove : legalMoves) {
drawLegalPosition(legalMove, getCurrentPlayerIndex());
}
}
});
animation.play();
primary.nextPlayer(true, getCurrentPlayer().getName(), game.getCurrentTurn() == 0 ? "X" : "O", getPlayer((game.getCurrentTurn() + 1) % 2).getName(), 'R');
}
@Override
public void updateUI() {
updateCanvas(false);
}
public void drawLegalPosition(int cell, int player) {
Color innerColor;
if (player == 1) {
innerColor = new Color(0.0f, 0.0f, 0.0f, 0.6f);
}
else {
innerColor = new Color(1.0f, 1.0f, 1.0f, 0.75f);
}
canvas.drawInnerDot(innerColor, cell,false);
}
private void initUI(){
primary.add(Pos.CENTER, canvas.getCanvas());
WidgetContainer.getCurrentView().transitionNext(primary, true);
updateCanvas(false);
}
private void drawMoves(){
int[] board = game.getBoard();
// Draw each square
for (int i = 0; i < board.length; i++){
// If square isn't empty, draw player move
if (board[i] != AbstractGame.EMPTY){
canvas.drawPlayerMove(board[i], i);
}
}
}
}

23
app/src/main/java/org/toop/app/gameControllers/TicTacToeBitController.java Normal file
View File

@@ -0,0 +1,23 @@
package org.toop.app.gameControllers;
import org.toop.app.canvas.TicTacToeBitCanvas;
import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
import org.toop.framework.gameFramework.model.player.Player;
import org.toop.game.gameThreads.LocalFixedRateThreadBehaviour;
import org.toop.game.gameThreads.LocalThreadBehaviour;
import org.toop.game.gameThreads.OnlineThreadBehaviour;
import org.toop.game.games.tictactoe.BitboardTicTacToe;
import org.toop.game.players.OnlinePlayer;
public class TicTacToeBitController extends GenericGameController<BitboardTicTacToe> {
public TicTacToeBitController(Player<BitboardTicTacToe>[] players) {
BitboardTicTacToe game = new BitboardTicTacToe(players);
ThreadBehaviour thread = new LocalThreadBehaviour<>(game);
for (Player<BitboardTicTacToe> player : players) {
if (player instanceof OnlinePlayer<BitboardTicTacToe>){
thread = new OnlineThreadBehaviour<>(game);
}
}
super(new TicTacToeBitCanvas(), game, thread , "TicTacToe");
}
}

63
app/src/main/java/org/toop/app/gameControllers/TicTacToeController.java
View File

@@ -1,63 +0,0 @@
package org.toop.app.gameControllers;
import javafx.geometry.Pos;
import javafx.scene.paint.Color;
import org.toop.app.App;
import org.toop.app.canvas.TicTacToeCanvas;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.gameFramework.model.player.Player;
import org.toop.framework.gameFramework.view.GUIEvents;
import org.toop.framework.gameFramework.model.game.AbstractGame;
import org.toop.game.gameThreads.LocalThreadBehaviour;
import org.toop.game.gameThreads.OnlineThreadBehaviour;
import org.toop.game.players.LocalPlayer;
import org.toop.app.widget.WidgetContainer;
import org.toop.game.games.tictactoe.TicTacToeR;
public class TicTacToeController extends AbstractGameController<TicTacToeR> {
public TicTacToeController(Player<TicTacToeR>[] players, boolean local) {
TicTacToeR ticTacToeR = new TicTacToeR(players);
super(
new TicTacToeCanvas(Color.GRAY, (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3,(c) -> {new EventFlow().addPostEvent(GUIEvents.PlayerAttemptedMove.class, c).postEvent();}),
players,
ticTacToeR,
local ? new LocalThreadBehaviour(ticTacToeR, players) : new OnlineThreadBehaviour<>(ticTacToeR, players), // TODO: Player order matters here, this won't work atm
"TicTacToe");
initUI();
eventFlow.listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}}, false);
//addListener(GlobalEventBus.subscribe(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}}));
//new EventFlow().listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}});
}
public TicTacToeController(Player<TicTacToeR>[] players) {
this(players, true);
}
@Override
public void updateUI() {
canvas.clearAll();
// TODO: wtf is even this pile of poop temp fix
primary.nextPlayer(true, getCurrentPlayer().getName(), game.getCurrentTurn() == 0 ? "X" : "O", getPlayer((game.getCurrentTurn() + 1) % 2).getName(), 'T');
drawMoves();
}
private void initUI(){
primary.add(Pos.CENTER, canvas.getCanvas());
WidgetContainer.getCurrentView().transitionNext(primary, true);
updateUI();
}
private void drawMoves(){
int[] board = game.getBoard();
// Draw each square
for (int i = 0; i < board.length; i++){
// If square isn't empty, draw player move
if (board[i] != AbstractGame.EMPTY){
canvas.drawPlayerMove(board[i], i);
}
}
}
}

11
app/src/main/java/org/toop/app/widget/complex/PlayerInfoWidget.java
View File

@@ -23,7 +23,7 @@ public class PlayerInfoWidget {
}
private ToggleWidget buildToggle() {
return new ToggleWidget(
return new ToggleWidget(
"computer", "player",
information.isHuman,
isHuman -> {
@@ -37,7 +37,14 @@ public class PlayerInfoWidget {
}
private Node buildContent() {
if (information.isHuman) {
var spacer = Primitive.vbox(
makeAIButton(0, 0, "zwartepiet"),
makeAIButton(0, 0, "sinterklaas"),
makeAIButton(0, 0, "santa")
); //todo make a better solution
spacer.setVisible(false);
var nameInput = new LabeledInputWidget(
"name",
"enter-your-name",
@@ -45,7 +52,7 @@ public class PlayerInfoWidget {
newName -> information.name = newName
);
return nameInput.getNode();
return Primitive.vbox(spacer,nameInput.getNode());
} else {
var AIBox = Primitive.vbox(
makeAIButton(0, 1, "zwartepiet"),

1
app/src/main/java/org/toop/app/widget/popup/ChallengePopup.java
View File

@@ -8,6 +8,7 @@ import org.toop.app.widget.complex.PopupWidget;
import java.util.function.Consumer;
import javafx.geometry.Pos;
import org.toop.local.AppContext;
public final class ChallengePopup extends PopupWidget {
private final GameInformation.Player playerInformation;

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

@@ -2,19 +2,21 @@ package org.toop.app.widget.view;
import javafx.application.Platform;
import org.toop.app.GameInformation;
import org.toop.app.gameControllers.AbstractGameController;
import org.toop.app.gameControllers.ReversiController;
import org.toop.app.gameControllers.TicTacToeController;
import org.toop.app.gameControllers.ReversiBitController;
import org.toop.app.gameControllers.TicTacToeBitController;
import org.toop.framework.gameFramework.controller.GameController;
import org.toop.framework.gameFramework.model.player.Player;
import org.toop.game.games.tictactoe.TicTacToeAIRSleep;
import org.toop.game.games.reversi.BitboardReversi;
import org.toop.game.games.tictactoe.BitboardTicTacToe;
import org.toop.game.players.ArtificialPlayer;
import org.toop.game.players.LocalPlayer;
import org.toop.app.widget.Primitive;
import org.toop.app.widget.complex.PlayerInfoWidget;
import org.toop.app.widget.complex.ViewWidget;
import org.toop.app.widget.popup.ErrorPopup;
import org.toop.game.games.reversi.ReversiAIR;
import org.toop.app.widget.tutorial.*;
import org.toop.game.players.ai.MiniMaxAI;
import org.toop.game.players.ai.RandomAI;
import org.toop.local.AppContext;
import javafx.geometry.Pos;
@@ -25,7 +27,7 @@ import org.toop.local.AppSettings;
public class LocalMultiplayerView extends ViewWidget {
private final GameInformation information;
private AbstractGameController<?> gameController;
private GameController gameController;
public LocalMultiplayerView(GameInformation.Type type) {
this(new GameInformation(type));
@@ -44,7 +46,7 @@ public class LocalMultiplayerView extends ViewWidget {
}
}
// TODO: Fix this temporary ass way of setting the players (Only works for TicTacToe)
// TODO: Fix this temporary ass way of setting the players
Player[] players = new Player[2];
switch (information.type) {
@@ -52,27 +54,27 @@ public class LocalMultiplayerView extends ViewWidget {
if (information.players[0].isHuman) {
players[0] = new LocalPlayer<>(information.players[0].name);
} else {
players[0] = new ArtificialPlayer<>(new TicTacToeAIRSleep(information.players[0].computerDifficulty, information.players[1].computerThinkTime), information.players[0].name);
players[0] = new ArtificialPlayer<>(new RandomAI<BitboardTicTacToe>(), "Random AI");
}
if (information.players[1].isHuman) {
players[1] = new LocalPlayer<>(information.players[1].name);
} else {
players[1] = new ArtificialPlayer<>(new TicTacToeAIRSleep(information.players[1].computerDifficulty, information.players[1].computerThinkTime), information.players[1].name);
players[1] = new ArtificialPlayer<>(new MiniMaxAI<BitboardTicTacToe>(9), "MiniMax AI");
}
if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstTTT()) {
new ShowEnableTutorialWidget(
() -> new TicTacToeTutorialWidget(() -> {
gameController = new TicTacToeController(players);
gameController = new TicTacToeBitController(players);
gameController.start();
}),
() -> Platform.runLater(() -> {
gameController = new TicTacToeController(players);
gameController = new TicTacToeBitController(players);
gameController.start();
}),
() -> AppSettings.getSettings().setFirstTTT(false)
);
} else {
gameController = new TicTacToeController(players);
gameController = new TicTacToeBitController(players);
gameController.start();
}
break;
@@ -80,27 +82,27 @@ public class LocalMultiplayerView extends ViewWidget {
if (information.players[0].isHuman) {
players[0] = new LocalPlayer<>(information.players[0].name);
} else {
players[0] = new ArtificialPlayer<>(new ReversiAIR(), information.players[0].name);
players[0] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), "Random AI");
}
if (information.players[1].isHuman) {
players[1] = new LocalPlayer<>(information.players[1].name);
} else {
players[1] = new ArtificialPlayer<>(new ReversiAIR(), information.players[1].name);
players[1] = new ArtificialPlayer<>(new MiniMaxAI<BitboardReversi>(6), "MiniMax");
}
if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
new ShowEnableTutorialWidget(
() -> new ReversiTutorialWidget(() -> {
gameController = new ReversiController(players);
gameController = new ReversiBitController(players);
gameController.start();
}),
() -> Platform.runLater(() -> {
gameController = new ReversiController(players);
gameController = new ReversiBitController(players);
gameController.start();
}),
() -> AppSettings.getSettings().setFirstReversi(false)
);
} else {
gameController = new ReversiController(players);
gameController = new ReversiBitController(players);
gameController.start();
}
break;