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

Merge new framework into development (#269)

Browse Source 
* Created a somewhat generic TurnBasedGame thread. Temporary UI that only works for TicTacToe rn. Added a LocalPlayer with the intent to add more players

* (RANDOM COMMIT) Hope it works

* Changes by bas

* Fixed dependency issues

* Fixed major issue in game deepcopy

* Merge conflict fix

* Removed unused import

* Update GTBGT branch from dev branch (#263)

* started a basis for the tutorials, tic tac toe is almost done with some general stuff still to do.

* rest van de tutorials toegevoegd

* Removed views

* Merge conflict fix

* Removed unused import

---------

Co-authored-by: michiel301b <m.brands.3@st.hanze.nl>
Co-authored-by: ramollia <>
Co-authored-by: Bas Antonius de Jong <49651652+BAFGdeJong@users.noreply.github.com>

* Revert "Update GTBGT branch from dev branch (#263)"

This reverts commit 9134d7e343.

* Fixed frontend not using GameController because of spaghetti code.

* Removed unused imports

* GameCanvas not implements a DrawPlayerMove that can be overridden for specific implementations

* Created an event that will request the controller to refresh the UI.

* ADDED DEPENDENCY. Renamed GameControllers to GameManagers, gameThread is not game controller.

* Attempt at adding an online player. I think it doesn't work because of unsubscriben after success not working

* Multiplayer is functional through OnlineThreadBehaviour. Empty slots are currently represented by -1 in the GUI.

* Removed sout spam, added logger than I can't get to work.

* Idek what these changes are

* Te lang geen commit, sorry

* Multiplayer seems to work pretty well now, hopefully I can add the other games soon.

* Added unsubscribe to EventFlow. ListenerHandler now functional. GlobalEventbus now user listenerHandler

* getAllListeners

* Removed nulls

* Inbetween commit of adding Reversi. This is a lot of spaghetti.

* Fixed stress tests

* Fixed typo in NetworkingGameClientHandler that prevented losses from being received

* Missed 2nd typo. Fixed

* Added docs, no more list creation when adding events to the bus.

* Fixed unsubscribe not working.

* Moved away from deprecated functions

* moved from wildcard to typed

* Moved away from deprecated function

* Added debugging to GlobalEventBus

* Fixed cleaning flow

* Fixed unsubscribe all

* Fixed unsubscribe all

* Removed unused import

* Works now with updated EventFlow(). Unsubscribing works. ReversiAIR has an issue where a forced move returns -1 and local play back button doesn't work properly. To be fixed

* Fixed ReversiR issue that caused skip turn desync

* Fixed color mismatch with server and online main player is now correct.

* Added a bunch of java doc and small changes

* Small changes

* Added a new Thread Behaviour to test framework.

* Fixed human error I made in TicTacToeR logic...

* Fixed broken event and wrong player being presented as winner.

* Idk changes

* Fixed PR conflicts

---------

Co-authored-by: michiel301b <m.brands.3@st.hanze.nl>
Co-authored-by: Bas Antonius de Jong <49651652+BAFGdeJong@users.noreply.github.com>
This commit is contained in:
Stef
2025-12-02 11:25:22 +01:00
committed by GitHub
parent d9437c1b8a
commit 9f55f8e1c7
54 changed files with 2121 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,6 +13,7 @@ public final class Main {
static void main(String[] args) {
initSystems();
App.run(args);
}
private static void initSystems() {

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

@@ -1,23 +1,24 @@
package org.toop.app;
import javafx.application.Platform;
import javafx.geometry.Pos;
import org.toop.app.game.Connect4Game;
import org.toop.app.game.ReversiGame;
import org.toop.app.game.TicTacToeGame;
import org.toop.app.game.gameControllers.AbstractGameController;
import org.toop.app.game.gameControllers.ReversiController;
import org.toop.app.game.gameControllers.TicTacToeController;
import org.toop.app.widget.WidgetContainer;
import org.toop.app.widget.complex.LoadingWidget;
import org.toop.app.widget.popup.ChallengePopup;
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.eventbus.ListenerHandler;
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.players.ArtificialPlayer;
import org.toop.game.players.OnlinePlayer;
import org.toop.game.players.AbstractPlayer;
import org.toop.game.reversi.ReversiAIR;
import org.toop.game.tictactoe.TicTacToeAIR;
import org.toop.local.AppContext;
import java.util.function.Consumer;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
@@ -27,6 +28,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;
@@ -36,10 +38,14 @@ public final class Server {
private ServerView primary;
private boolean isPolling = true;
private AbstractGameController<?> gameController;
private final AtomicBoolean isSingleGame = new AtomicBoolean(false);
private ScheduledExecutorService scheduler;
private EventFlow eventFlow = new EventFlow();
public static GameInformation.Type gameToType(String game) {
if (game.equalsIgnoreCase("tic-tac-toe")) {
return GameInformation.Type.TICTACTOE;
@@ -54,6 +60,9 @@ public final class Server {
return null;
}
// Server has to deal with ALL network related listen events. This "server" can then interact with the manager to make stuff happen.
// This prevents data races where events get sent to the game manager but the manager isn't ready yet.
public Server(String ip, String port, String user) {
if (ip.split("\\.").length < 4) {
new ErrorPopup("\"" + ip + "\" " + AppContext.getString("is-not-a-valid-ip-address"));
@@ -98,10 +107,14 @@ public final class Server {
populateGameList();
}).postEvent();
new EventFlow().listen(NetworkEvents.ChallengeResponse.class, this::handleReceivedChallenge, false)
.listen(NetworkEvents.GameMatchResponse.class, this::handleMatchResponse, false);
startPopulateScheduler();
populateGameList();
eventFlow.listen(NetworkEvents.ChallengeResponse.class, this::handleReceivedChallenge, false)
.listen(NetworkEvents.GameMatchResponse.class, this::handleMatchResponse, false)
.listen(NetworkEvents.GameResultResponse.class, this::handleGameResult, false)
.listen(NetworkEvents.GameMoveResponse.class, this::handleReceivedMove, false)
.listen(NetworkEvents.YourTurnResponse.class, this::handleYourTurn, false);
startPopulateScheduler();
populateGameList();
}
private void sendChallenge(String opponent) {
@@ -114,10 +127,16 @@ public final class Server {
}
private void handleMatchResponse(NetworkEvents.GameMatchResponse response) {
if (!isPolling) return;
// TODO: Redo all of this mess
if (gameController != null) {
gameController.stop();
}
gameController = null;
//if (!isPolling) return;
String gameType = extractQuotedValue(response.gameType());
if (response.clientId() == clientId) {
isPolling = false;
onlinePlayers.clear();
@@ -138,21 +157,58 @@ public final class Server {
information.players[0].computerThinkTime = 1;
information.players[1].name = response.opponent();
AbstractPlayer[] players = new AbstractPlayer[2];
players[(myTurn + 1) % 2] = new OnlinePlayer(response.opponent());
switch (type){
case TICTACTOE ->{
players[myTurn] = new ArtificialPlayer<>(new TicTacToeAIR(), user);
}
case REVERSI ->{
players[myTurn] = new ArtificialPlayer<>(new ReversiAIR(), user);
}
}
Runnable onGameOverRunnable = isSingleGame.get()? null: this::gameOver;
switch (type) {
case TICTACTOE ->
new TicTacToeGame(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
case TICTACTOE ->{
gameController = new TicTacToeController(players, false);
}
case REVERSI ->
new ReversiGame(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
gameController = new ReversiController(players, false);
case CONNECT4 ->
new Connect4Game(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
default -> new ErrorPopup("Unsupported game type.");
}
if (gameController != null){
gameController.start();
}
}
}
private void handleYourTurn(NetworkEvents.YourTurnResponse response) {
if (gameController == null) {
return;
}
gameController.yourTurn(response);
}
private void handleGameResult(NetworkEvents.GameResultResponse response) {
if (gameController == null) {
return;
}
gameController.gameFinished(response);
}
private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {
if (gameController == null) {
return;
}
gameController.moveReceived(response);
}
private void handleReceivedChallenge(NetworkEvents.ChallengeResponse response) {
if (!isPolling) return;

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

@@ -1,6 +1,7 @@
package org.toop.app.canvas;
import javafx.scene.paint.Color;
import org.toop.framework.gameFramework.abstractClasses.TurnBasedGameR;
import java.util.function.Consumer;
@@ -8,4 +9,9 @@ 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, TurnBasedGameR game) {
}
}

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

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

5
app/src/main/java/org/toop/app/canvas/DrawPlayerMove.java Normal file
View File

@@ -0,0 +1,5 @@
package org.toop.app.canvas;
public interface DrawPlayerMove {
void drawPlayerMove(int player, int move);
}

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

@@ -6,12 +6,13 @@ 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.abstractClasses.TurnBasedGameR;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
public abstract class GameCanvas {
public abstract class GameCanvas<T extends TurnBasedGameR> 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 &&
@@ -36,10 +37,18 @@ public abstract class GameCanvas {
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;
@@ -78,7 +87,7 @@ public abstract class GameCanvas {
if (cell.isInside(event.getX(), event.getY())) {
event.consume();
onCellClicked.accept(column + row * rowSize);
this.onCellCLicked.accept(column + row * rowSize);
}
});
@@ -143,6 +152,19 @@ public abstract class GameCanvas {
}
}
@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;

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

@@ -1,12 +1,14 @@
package org.toop.app.canvas;
import javafx.scene.paint.Color;
import org.toop.framework.gameFramework.abstractClasses.TurnBasedGameR;
import org.toop.game.records.Move;
import org.toop.game.reversi.ReversiR;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
public final class ReversiCanvas extends GameCanvas {
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);
@@ -81,4 +83,14 @@ public final class ReversiCanvas extends GameCanvas {
}
drawInnerDot(innerColor, cell,false);
}
@Override
public void drawPlayerMove(int player ,int move){
super.drawPlayerMove(player, move);
}
@Override
public void drawPlayerHover(int player, int move, TurnBasedGameR game) {
}
}

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

@@ -1,14 +1,25 @@
package org.toop.app.canvas;
import javafx.scene.paint.Color;
import org.toop.framework.gameFramework.abstractClasses.TurnBasedGameR;
import org.toop.game.tictactoe.TicTacToeR;
import java.util.function.Consumer;
public final class TicTacToeCanvas extends GameCanvas {
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);
@@ -35,4 +46,9 @@ public final class TicTacToeCanvas extends GameCanvas {
graphics.strokeOval(x, y, width, height);
}
@Override
public void drawPlayerHover(int player, int move, TurnBasedGameR game) {
}
}

2
app/src/main/java/org/toop/app/game/Connect4Game.java
View File

@@ -11,7 +11,7 @@ import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.networking.events.NetworkEvents;
import org.toop.game.Connect4.Connect4;
import org.toop.game.Connect4.Connect4AI;
import org.toop.game.enumerators.GameState;
import org.toop.framework.gameFramework.GameState;
import org.toop.game.records.Move;
import java.util.concurrent.BlockingQueue;

2
app/src/main/java/org/toop/app/game/ReversiGame.java
View File

@@ -8,7 +8,7 @@ import org.toop.app.widget.WidgetContainer;
import org.toop.app.widget.view.GameView;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.networking.events.NetworkEvents;
import org.toop.game.enumerators.GameState;
import org.toop.framework.gameFramework.GameState;
import org.toop.game.records.Move;
import org.toop.game.reversi.Reversi;
import org.toop.game.reversi.ReversiAI;

10
app/src/main/java/org/toop/app/game/TicTacToeGame.java
View File

@@ -7,7 +7,7 @@ import org.toop.app.widget.WidgetContainer;
import org.toop.app.widget.view.GameView;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.networking.events.NetworkEvents;
import org.toop.game.enumerators.GameState;
import org.toop.framework.gameFramework.GameState;
import org.toop.game.records.Move;
import org.toop.game.tictactoe.TicTacToe;
import org.toop.game.tictactoe.TicTacToeAI;
@@ -147,9 +147,9 @@ public final class TicTacToeGame {
final GameState state = game.play(move);
if (move.value() == 'X') {
canvas.drawX(Color.INDIANRED, move.position());
//canvas.drawPlayer('X', Color.INDIANRED, move.position());
} else if (move.value() == 'O') {
canvas.drawO(Color.ROYALBLUE, move.position());
//canvas.drawPlayer('O', Color.ROYALBLUE, move.position());
}
if (state != GameState.NORMAL) {
@@ -198,9 +198,9 @@ public final class TicTacToeGame {
}
if (move.value() == 'X') {
canvas.drawX(Color.RED, move.position());
//canvas.drawPlayer('X', Color.RED, move.position());
} else if (move.value() == 'O') {
canvas.drawO(Color.BLUE, move.position());
//canvas.drawPlayer('O', Color.BLUE, move.position());
}
setGameLabels(game.getCurrentTurn() == myTurn);

6
app/src/main/java/org/toop/app/game/TicTacToeGameThread.java
View File

@@ -5,7 +5,7 @@ import org.toop.app.GameInformation;
import org.toop.app.canvas.TicTacToeCanvas;
import org.toop.framework.eventbus.EventFlow;
import org.toop.framework.networking.events.NetworkEvents;
import org.toop.game.enumerators.GameState;
import org.toop.framework.gameFramework.GameState;
import org.toop.game.records.Move;
import org.toop.game.tictactoe.TicTacToe;
import org.toop.game.tictactoe.TicTacToeAI;
@@ -47,8 +47,8 @@ public final class TicTacToeGameThread extends BaseGameThread<TicTacToe, TicTacT
}
private void drawMove(Move move) {
if (move.value() == 'X') canvas.drawX(Color.RED, move.position());
else canvas.drawO(Color.BLUE, move.position());
//if (move.value() == 'X') canvas.drawPlayer('X', Color.RED, move.position());
//else canvas.drawPlayer('O', Color.BLUE, move.position());
}
@Override

135
app/src/main/java/org/toop/app/game/gameControllers/AbstractGameController.java Normal file
View File

@@ -0,0 +1,135 @@
package org.toop.app.game.gameControllers;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.toop.framework.gameFramework.interfaces.UpdatesGameUI;
import org.toop.framework.gameFramework.GUIEvents;
import org.toop.app.canvas.GameCanvas;
import org.toop.framework.networking.events.NetworkEvents;
import org.toop.game.GameThreadBehaviour.GameThreadStrategy;
import org.toop.app.widget.view.GameView;
import org.toop.framework.eventbus.EventFlow;
import org.toop.game.GameThreadBehaviour.OnlineThreadBehaviour;
import org.toop.framework.gameFramework.abstractClasses.TurnBasedGameR;
import org.toop.framework.gameFramework.interfaces.SupportsOnlinePlay;
import org.toop.game.players.AbstractPlayer;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
public abstract class AbstractGameController<T extends TurnBasedGameR> implements UpdatesGameUI, GameThreadStrategy, SupportsOnlinePlay {
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 AbstractPlayer[] players; // List of players, can't be changed.
protected final T game; // Reference to game instance
private final GameThreadStrategy 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, AbstractPlayer[] players, T game, GameThreadStrategy 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;
// Let players know who they are
for(int i = 0; i < players.length; i++){
players[i].setPlayerIndex(i);
}
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 AbstractPlayer getCurrentPlayer(){
return gameThreadBehaviour.getCurrentPlayer();
};
public int getCurrentPlayerIndex(){
return getCurrentPlayer().getPlayerIndex();
}
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 AbstractPlayer 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;
}
@Override
public void yourTurn(NetworkEvents.YourTurnResponse event){
if (isOnline()){
((OnlineThreadBehaviour) this.gameThreadBehaviour).yourTurn(event);
}
}
@Override
public void moveReceived(NetworkEvents.GameMoveResponse event){
if (isOnline()){
((OnlineThreadBehaviour) this.gameThreadBehaviour).moveReceived(event);
}
}
@Override
public void gameFinished(NetworkEvents.GameResultResponse event){
if (isOnline()){
((OnlineThreadBehaviour) this.gameThreadBehaviour).gameFinished(event);
}
}
}

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

@@ -0,0 +1,138 @@
package org.toop.app.game.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.abstractClasses.GameR;
import org.toop.framework.gameFramework.GUIEvents;
import org.toop.game.GameThreadBehaviour.LocalFixedRateThreadBehaviour;
import org.toop.game.GameThreadBehaviour.OnlineThreadBehaviour;
import org.toop.game.players.AbstractPlayer;
import org.toop.game.players.LocalPlayer;
import org.toop.game.reversi.ReversiR;
public class ReversiController extends AbstractGameController<ReversiR> {
// TODO: Refactor GUI update methods to follow designed system
public ReversiController(AbstractPlayer[] players, boolean local) {
ReversiR ReversiR = new ReversiR();
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(AbstractPlayer[] 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());
}
@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] != GameR.EMPTY){
canvas.drawPlayerMove(board[i], i);
}
}
}
}

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

@@ -0,0 +1,63 @@
package org.toop.app.game.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.GUIEvents;
import org.toop.framework.gameFramework.abstractClasses.GameR;
import org.toop.game.GameThreadBehaviour.LocalThreadBehaviour;
import org.toop.game.GameThreadBehaviour.OnlineThreadBehaviour;
import org.toop.game.players.LocalPlayer;
import org.toop.game.players.AbstractPlayer;
import org.toop.app.widget.WidgetContainer;
import org.toop.game.tictactoe.TicTacToeR;
public class TicTacToeController extends AbstractGameController<TicTacToeR> {
public TicTacToeController(AbstractPlayer[] players, boolean local) {
TicTacToeR ticTacToeR = new TicTacToeR();
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(AbstractPlayer[] 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());
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] != GameR.EMPTY){
canvas.drawPlayerMove(board[i], i);
}
}
}
}

14
app/src/main/java/org/toop/app/widget/complex/ViewWidget.java
View File

@@ -16,8 +16,18 @@ public abstract class ViewWidget extends StackWidget {
replace(Pos.CENTER, view);
}
public void transitionNext(ViewWidget view) {
view.previous = this;
public void transitionNext(ViewWidget view) {
transitionNext(view, false);
}
public void transitionNext(ViewWidget view, boolean aware) {
if (aware && this.getClass().equals(view.getClass())) {
view.previous = this.previous;
}
else{
view.previous = this;
}
replace(Pos.CENTER, view);
var backButton = Primitive.button("back", () -> {

17
app/src/main/java/org/toop/app/widget/popup/GameOverPopup.java
View File

@@ -7,18 +7,17 @@ import org.toop.local.AppContext;
import javafx.geometry.Pos;
public final class GameOverPopup extends PopupWidget {
public GameOverPopup(boolean iWon, String winner) {
public GameOverPopup(boolean winOrTie, String winner) {
var confirmWidget = new ConfirmWidget("game-over");
if (winner.isEmpty()) {
confirmWidget.setMessage(AppContext.getString("the-game-ended-in-a-draw"));
} else if (iWon) {
confirmWidget.setMessage(AppContext.getString("you-win"));
} else {
confirmWidget.setMessage(AppContext.getString("you-lost-against") + ": " + winner);
}
if (winOrTie) {
confirmWidget.setMessage(winner + " won the game!");
}
else{
confirmWidget.setMessage("It was a tie!");
}
confirmWidget.addButton("ok", () -> hide());
confirmWidget.addButton("ok", this::hide);
add(Pos.CENTER, confirmWidget);
}

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

@@ -2,14 +2,22 @@ package org.toop.app.widget.view;
import javafx.application.Platform;
import org.toop.app.GameInformation;
import org.toop.app.game.Connect4Game;
import org.toop.app.game.ReversiGame;
import org.toop.app.game.TicTacToeGameThread;
import org.toop.app.game.*;
import org.toop.app.game.gameControllers.AbstractGameController;
import org.toop.app.game.gameControllers.ReversiController;
import org.toop.app.game.gameControllers.TicTacToeController;
import org.toop.game.players.ArtificialPlayer;
import org.toop.game.players.LocalPlayer;
import org.toop.game.players.AbstractPlayer;
import org.toop.app.game.gameControllers.ReversiController;
import org.toop.app.game.gameControllers.TicTacToeController;
import org.toop.app.widget.Primitive;
import org.toop.app.widget.WidgetContainer;
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.reversi.ReversiAIR;
import org.toop.game.tictactoe.TicTacToeAIR;
import org.toop.app.widget.tutorial.*;
import org.toop.local.AppContext;
@@ -17,9 +25,12 @@ import javafx.geometry.Pos;
import javafx.scene.control.ScrollPane;
import javafx.scene.layout.VBox;
import org.toop.local.AppSettings;
public class LocalMultiplayerView extends ViewWidget {
private final GameInformation information;
private AbstractGameController gameController;
public LocalMultiplayerView(GameInformation.Type type) {
this(new GameInformation(type));
}
@@ -27,6 +38,9 @@ public class LocalMultiplayerView extends ViewWidget {
public LocalMultiplayerView(GameInformation information) {
this.information = information;
var playButton = Primitive.button("play", () -> {
if (gameController != null) {
gameController.stop();
}
for (var player : information.players) {
if (player.isHuman && player.name.isEmpty()) {
new ErrorPopup(AppContext.getString("please-enter-your-name")).show(Pos.CENTER);
@@ -34,27 +48,64 @@ public class LocalMultiplayerView extends ViewWidget {
}
}
// TODO: Fix this temporary ass way of setting the players (Only works for TicTacToe)
AbstractPlayer[] players = new AbstractPlayer[2];
switch (information.type) {
case TICTACTOE:
if (information.players[0].isHuman){
players[0] = new LocalPlayer(information.players[0].name);
}
else {
players[0] = new ArtificialPlayer<>(new TicTacToeAIR(), information.players[0].name);
}
if (information.players[1].isHuman){
players[1] = new LocalPlayer(information.players[1].name);
}
else {
players[1] = new ArtificialPlayer<>(new TicTacToeAIR(), information.players[1].name);
}
if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstTTT()) {
new ShowEnableTutorialWidget(
() -> new TicTacToeTutorialWidget(() -> new TicTacToeGameThread(information)),
() -> Platform.runLater(() -> new TicTacToeGameThread(information)),
() -> new TicTacToeTutorialWidget(() -> {gameController = new TicTacToeController(players);
gameController.start();}),
() -> Platform.runLater(() -> {gameController = new TicTacToeController(players);
gameController.start();}),
() -> AppSettings.getSettings().setFirstTTT(false)
);
} else {
new TicTacToeGameThread(information);
gameController = new TicTacToeController(players);
gameController.start();
}
break;
case REVERSI:
if (information.players[0].isHuman){
players[0] = new LocalPlayer(information.players[0].name);
}
else {
players[0] = new ArtificialPlayer<>(new ReversiAIR(), information.players[0].name);
}
if (information.players[1].isHuman){
players[1] = new LocalPlayer(information.players[1].name);
}
else {
players[1] = new ArtificialPlayer<>(new ReversiAIR(), information.players[1].name);
}
if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
new ShowEnableTutorialWidget(
() -> new ReversiTutorialWidget(() -> new ReversiGame(information)),
() -> Platform.runLater(() -> new ReversiGame(information)),
() -> new ReversiTutorialWidget(() -> {
gameController = new ReversiController(players);
gameController.start();
}),
() -> Platform.runLater(() -> {
gameController = new ReversiController(players);
gameController.start();
}),
() -> AppSettings.getSettings().setFirstReversi(false)
);
} else {
new ReversiGame(information);
gameController = new ReversiController(players);
gameController.start();
}
break;
case CONNECT4: