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

refactor

Browse Source
This commit is contained in:
ramollia
2025-09-24 15:52:58 +02:00
parent 9fdd74326a
commit da777f5300
38 changed files with 35 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
game/pom.xml Normal file
View File

@@ -0,0 +1,7 @@
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<groupId>org.toop</groupId>
<artifactId>pism</artifactId>
<version>1.0-SNAPSHOT</version>
</project>

57
game/src/main/java/org/toop/game/GameBase.java Normal file
View File

@@ -0,0 +1,57 @@
package org.toop.game;
// Todo: refactor
public abstract class GameBase {
public enum State {
INVALID,
NORMAL,
DRAW,
WIN,
}
public static char EMPTY = '-';
protected int size;
public char[] grid;
protected Player[] players;
public int currentPlayer;
public GameBase(int size, Player player1, Player player2) {
this.size = size;
grid = new char[size * size];
for (int i = 0; i < grid.length; i++) {
grid[i] = EMPTY;
}
players = new Player[2];
players[0] = player1;
players[1] = player2;
currentPlayer = 0;
}
public boolean isInside(int index) {
return index >= 0 && index < size * size;
}
public int getSize() {
return size;
}
public char[] getGrid() {
return grid;
}
public Player[] getPlayers() {
return players;
}
public Player getCurrentPlayer() {
return players[currentPlayer];
}
public abstract State play(int index);
}

20
game/src/main/java/org/toop/game/Player.java Normal file
View File

@@ -0,0 +1,20 @@
package org.toop.game;
// Todo: refactor
public class Player {
String name;
char symbol;
Player(String name, char symbol) {
this.name = name;
this.symbol = symbol;
}
public String getName() {
return this.name;
}
public char getSymbol() {
return this.symbol;
}
}

225
game/src/main/java/org/toop/tictactoe/TicTacToe.java Normal file
View File

@@ -0,0 +1,225 @@
package org.toop.tictactoe;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.toop.game.GameBase;
import org.toop.game.Player;
import org.toop.backend.tictactoe.ParsedCommand;
import org.toop.backend.tictactoe.TicTacToeServerCommand;
// Todo: refactor
public class TicTacToe extends GameBase implements Runnable {
protected static final Logger logger = LogManager.getLogger(TicTacToe.class);
public Thread gameThread;
public String gameId;
public BlockingQueue<ParsedCommand> commandQueue = new LinkedBlockingQueue<>();
public BlockingQueue<String> sendQueue = new LinkedBlockingQueue<>();
public int movesLeft;
public TicTacToe(String player1, String player2) {
super(3, new Player(player1, 'X'), new Player(player2, 'O'));
movesLeft = size * size;
}
/**
* Used for the server.
*
* @param player1
* @param player2
* @param gameId
*/
public TicTacToe(String player1, String player2, String gameId) {
super(3, new Player(player1, 'X'), new Player(player2, 'O'));
this.gameId = gameId;
movesLeft = size * size;
}
public void addCommandToQueue(ParsedCommand command) {
commandQueue.add(command);
}
private ParsedCommand takeFromCommandQueue() {
try {
return this.commandQueue.take();
} catch (InterruptedException e) {
logger.error("Taking from queue interrupted, in game with id: {}", this.gameId);
return null;
}
}
private void addSendToQueue(String send) {
try {
sendQueue.put(send);
} catch (InterruptedException e) {
logger.error("Sending to queue interrupted, in game with id: {}", this.gameId);
}
}
@Override
public void run() {
this.gameThread = new Thread(this::gameThread);
this.gameThread.start();
}
private void gameThread() {
boolean running = true;
while (running) {
ParsedCommand cmd = takeFromCommandQueue();
// Get next command if there was no command
if (cmd == null) {
continue;
}
// Do something based which command was given
switch (cmd.command) {
case TicTacToeServerCommand.MOVE:
{
// TODO: Check if it is this player's turn, not required for local play (I
// think?).
// Convert given argument to integer
Object arg = cmd.arguments.getFirst();
int index;
try {
index = Integer.parseInt((String) arg);
} catch (Exception e) {
logger.error("Error parsing argument to String or Integer");
continue;
}
// Attempt to play the move
State state = play(index);
if (state != State.INVALID) {
// Tell all players who made a move and what move was made
// TODO: What is the reaction of the game? WIN, DRAW etc?
String player = getCurrentPlayer().getName();
addSendToQueue(
"SVR GAME MOVE {PLAYER: \""
+ player
+ "\", DETAILS: \"<reactie spel op zet>\",MOVE: \""
+ index
+ "\"}\n");
}
// Check move result
switch (state) {
case State.WIN:
{
// Win
running = false;
addSendToQueue(
"SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\","
+ " PLAYERTWOSCORE: \"<score speler2>\", COMMENT:"
+ " \"<commentaar op resultaat>\"}\n");
break;
}
case State.DRAW:
{
// Draw
running = false;
addSendToQueue(
"SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\","
+ " PLAYERTWOSCORE: \"<score speler2>\", COMMENT:"
+ " \"<commentaar op resultaat>\"}\n");
break;
}
case State.NORMAL:
{
// Valid move but not end of game
addSendToQueue("SVR GAME YOURTURN");
break;
}
case State.INVALID:
{
// Invalid move
break;
}
}
}
}
}
}
@Override
public State play(int index) {
if (!validateMove(index)) {
return State.INVALID;
}
grid[index] = getCurrentPlayer().getSymbol();
movesLeft--;
if (checkWin()) {
return State.WIN;
}
if (movesLeft <= 0) {
return State.DRAW;
}
currentPlayer = (currentPlayer + 1) % players.length;
return State.NORMAL;
}
public boolean validateMove(int index) {
return movesLeft > 0 && isInside(index) && grid[index] == EMPTY;
}
public boolean checkWin() {
// Horizontal
for (int i = 0; i < 3; i++) {
final int index = i * 3;
if (grid[index] != EMPTY
&& grid[index] == grid[index + 1]
&& grid[index] == grid[index + 2]) {
return true;
}
}
// Vertical
for (int i = 0; i < 3; i++) {
int index = i;
if (grid[index] != EMPTY
&& grid[index] == grid[index + 3]
&& grid[index] == grid[index + 6]) {
return true;
}
}
// B-Slash
if (grid[0] != EMPTY && grid[0] == grid[4] && grid[0] == grid[8]) {
return true;
}
// F-Slash
if (grid[2] != EMPTY && grid[2] == grid[4] && grid[2] == grid[6]) {
return true;
}
return false;
}
/** For AI use only. */
public void decrementMovesLeft() {
movesLeft--;
}
/** This method copies the board, mainly for AI use. */
public TicTacToe copyBoard() {
TicTacToe clone = new TicTacToe(players[0].getName(), players[1].getName());
System.arraycopy(this.grid, 0, clone.grid, 0, this.grid.length);
clone.movesLeft = this.movesLeft;
clone.currentPlayer = this.currentPlayer;
return clone;
}
}

139
game/src/main/java/org/toop/tictactoe/TicTacToeAI.java Normal file
View File

@@ -0,0 +1,139 @@
package org.toop.tictactoe;
import org.toop.game.GameBase;
// Todo: refactor
public class TicTacToeAI {
/**
* This method tries to find the best move by seeing if it can set a winning move, if not, it
* will do a minimax.
*/
public int findBestMove(TicTacToe game) {
int bestVal = -100; // set bestVal to something impossible
int bestMove = 10; // set bestMove to something impossible
int winningMove = -5;
boolean empty = true;
for (char cell : game.grid) {
if (!(cell == GameBase.EMPTY)) {
empty = false;
break;
}
}
if (empty) { // start in a random corner
return switch ((int) (Math.random() * 4)) {
case 1 -> 2;
case 2 -> 6;
case 3 -> 8;
default -> 0;
};
}
// simulate all possible moves on the field
for (int i = 0; i < game.grid.length; i++) {
if (game.validateMove(i)) { // check if the move is legal here
TicTacToe copyGame = game.copyBoard(); // make a copy of the game
GameBase.State result = copyGame.play(i); // play a move on the copy board
int thisMoveValue;
if (result == GameBase.State.WIN) {
return i; // just return right away if you can win on the next move
}
for (int index = 0; index < game.grid.length; index++) {
if (game.validateMove(index)) {
TicTacToe opponentCopy = copyGame.copyBoard();
GameBase.State opponentResult = opponentCopy.play(index);
if (opponentResult == GameBase.State.WIN) {
winningMove = index;
}
}
}
thisMoveValue =
doMinimax(copyGame, game.movesLeft, false); // else look at other moves
if (thisMoveValue
> bestVal) { // if better move than the current best, change the move
bestVal = thisMoveValue;
bestMove = i;
}
}
}
if (winningMove > -5) {
return winningMove;
}
return bestMove; // return the best move when we've done everything
}
/**
* This method simulates all the possible future moves in the game through a copy in search of
* the best move.
*/
public int doMinimax(TicTacToe game, int depth, boolean maximizing) {
boolean state = game.checkWin(); // check for a win (base case stuff)
if (state) {
if (maximizing) {
// it's the maximizing players turn and someone has won. this is not good, so return
// a negative value
return -10 + depth;
} else {
// it is the turn of the AI and it has won! this is good for us, so return a
// positive value above 0
return 10 - depth;
}
} else {
boolean empty = false;
for (char cell :
game.grid) { // else, look at draw conditions. we check per cell if it's empty
// or not
if (cell == GameBase.EMPTY) {
empty = true; // if a thing is empty, set to true
break; // break the loop
}
}
if (!empty
|| depth == 0) { // if the grid is full or the depth is 0 (both meaning game is
// over) return 0 for draw
return 0;
}
}
int bestVal; // set the value to the highest possible
if (maximizing) { // it's the maximizing players turn, the AI
bestVal = -100;
for (int i = 0; i < game.grid.length; i++) { // loop through the grid
if (game.validateMove(i)) {
TicTacToe copyGame = game.copyBoard();
copyGame.play(i); // play the move on a copy board
int value =
doMinimax(copyGame, depth - 1, false); // keep going with the minimax
bestVal =
Math.max(
bestVal,
value); // select the best value for the maximizing player (the
// AI)
}
}
} else { // it's the minimizing players turn, the player
bestVal = 100;
for (int i = 0; i < game.grid.length; i++) { // loop through the grid
if (game.validateMove(i)) {
TicTacToe copyGame = game.copyBoard();
copyGame.play(i); // play the move on a copy board
int value = doMinimax(copyGame, depth - 1, true); // keep miniMaxing
bestVal =
Math.min(
bestVal,
value); // select the lowest score for the minimizing player,
// they want to make it hard for us
}
}
}
return bestVal;
}
}

13
game/src/main/resources/log4j2.xml Normal file
View File

@@ -0,0 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="debug" name="AppConfig">
<Appenders>
<Console name="Console" target="SYSTEM_OUT">
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%17.17t] %-5level %logger{36} - %msg%n"/>
</Console>
</Appenders>
<Loggers>
<Root level="info">
<AppenderRef ref="Console"/>
</Root>
</Loggers>
</Configuration>

82
game/src/test/tictactoe/GameBaseTest.java Normal file
View File

@@ -0,0 +1,82 @@
package org.toop.game.tictactoe;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.toop.game.GameBase;
import org.toop.game.Player;
class GameBaseTest {
private static class TestGame extends GameBase {
public TestGame(int size, Player p1, Player p2) {
super(size, p1, p2);
}
@Override
public State play(int index) {
if (!isInside(index)) return State.INVALID;
grid[index] = getCurrentPlayer().getSymbol();
// Just alternate players for testing
currentPlayer = (currentPlayer + 1) % 2;
return State.NORMAL;
}
}
private GameBase game;
private Player player1;
private Player player2;
@BeforeEach
void setUp() {
player1 = new Player("A", 'X');
player2 = new Player("B", 'O');
game = new TestGame(3, player1, player2);
}
@Test
void testConstructor_initializesGridAndPlayers() {
assertEquals(3, game.getSize());
assertEquals(9, game.getGrid().length);
for (char c : game.getGrid()) {
assertEquals(GameBase.EMPTY, c);
}
assertEquals(player1, game.getPlayers()[0]);
assertEquals(player2, game.getPlayers()[1]);
assertEquals(player1, game.getCurrentPlayer());
}
@Test
void testIsInside_returnsTrueForValidIndices() {
for (int i = 0; i < 9; i++) {
assertTrue(game.isInside(i));
}
}
@Test
void testIsInside_returnsFalseForInvalidIndices() {
assertFalse(game.isInside(-1));
assertFalse(game.isInside(9));
assertFalse(game.isInside(100));
}
@Test
void testPlay_alternatesPlayersAndMarksGrid() {
// First move
assertEquals(GameBase.State.NORMAL, game.play(0));
assertEquals('X', game.getGrid()[0]);
assertEquals(player2, game.getCurrentPlayer());
// Second move
assertEquals(GameBase.State.NORMAL, game.play(1));
assertEquals('O', game.getGrid()[1]);
assertEquals(player1, game.getCurrentPlayer());
}
@Test
void testPlay_invalidIndexReturnsInvalid() {
assertEquals(GameBase.State.INVALID, game.play(-1));
assertEquals(GameBase.State.INVALID, game.play(9));
}
}

29
game/src/test/tictactoe/PlayerTest.java Normal file
View File

@@ -0,0 +1,29 @@
package org.toop.game.tictactoe;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.toop.game.Player;
class PlayerTest {
private Player playerA;
private Player playerB;
@BeforeEach
void setup() {
playerA = new Player("testA", 'X');
playerB = new Player("testB", 'O');
}
@Test
void testNameGetter_returnsTrueForValidName() {
assertEquals("testA", playerA.getName());
assertEquals("testB", playerB.getName());
}
@Test
void testSymbolGetter_returnsTrueForValidSymbol() {
assertEquals('X', playerA.getSymbol());
assertEquals('O', playerB.getSymbol());
}
}

142
game/src/test/tictactoe/ai/MinMaxTicTacToeTest.java Normal file
View File

@@ -0,0 +1,142 @@
package org.toop.game.tictactoe.ai;
import static org.junit.jupiter.api.Assertions.*;
import java.util.Set;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.toop.game.GameBase;
import org.toop.tictactoe.TicTacToe;
/** Unit tests for MinMaxTicTacToe AI. */
public class MinMaxTicTacToeTest {
private MinMaxTicTacToe ai;
private TicTacToe game;
@BeforeEach // called before every test is done to make it work
void setUp() {
ai = new MinMaxTicTacToe();
game = new TicTacToe("AI", "Human");
}
@Test
void testBestMoveWinningMoveAvailable() {
// Setup board where AI can win immediately
// X = AI, O = player
// X | X | .
// O | O | .
// . | . | .
game.grid =
new char[] {
'X',
'X',
GameBase.EMPTY,
'O',
'O',
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY
};
game.movesLeft = 4;
int bestMove = ai.findBestMove(game);
// Ai is expected to place at index 2 to win
assertEquals(2, bestMove);
}
@Test
void testBestMoveBlocksOpponentWin() {
// Setup board where player could win next turn
// O | O | .
// X | . | .
// . | . | .
game.grid =
new char[] {
'O',
'O',
GameBase.EMPTY,
'X',
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY
};
int bestMove = ai.findBestMove(game);
// AI block at index 2 to continue the game
assertEquals(2, bestMove);
}
@Test
void testBestMoveCornerPreferredOnEmptyBoard() {
// On empty board, center (index 4) is strongest
int bestMove = ai.findBestMove(game);
assertTrue(Set.of(0, 2, 6, 8).contains(bestMove));
}
@Test
void testDoMinimaxScoresWinPositive() {
// Simulate a game state where AI has already won
TicTacToe copy = game.copyBoard();
copy.grid =
new char[] {
'X',
'X',
'X',
'O',
'O',
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY
};
int score = ai.doMinimax(copy, 5, false);
assertTrue(score > 0, "AI win should yield positive score");
}
@Test
void testDoMinimaxScoresLossNegative() {
// Simulate a game state where human has already won
TicTacToe copy = game.copyBoard();
copy.grid =
new char[] {
'O',
'O',
'O',
'X',
'X',
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY,
GameBase.EMPTY
};
int score = ai.doMinimax(copy, 5, true);
assertTrue(score < 0, "Human win should yield negative score");
}
@Test
void testDoMinimaxDrawReturnsZero() {
// Simulate a draw position
TicTacToe copy = game.copyBoard();
copy.grid =
new char[] {
'X', 'O', 'X',
'X', 'O', 'O',
'O', 'X', 'X'
};
int score = ai.doMinimax(copy, 0, true);
assertEquals(0, score, "Draw should return 0 score");
}
}