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

refactored game

Browse Source
This commit is contained in:
ramollia
2025-09-25 15:50:10 +02:00
parent 7431d1b03f
commit 27e7166ac7
20 changed files with 429 additions and 725 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
game/src/main/java/org/toop/game/AI.java Normal file
View File

@@ -0,0 +1,5 @@
package org.toop.game;
public abstract class AI<T extends Game> {
public abstract Game.Move findBestMove(T game, int depth);
}

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

@@ -0,0 +1,57 @@
package org.toop.game;
import java.util.Arrays;
public abstract class Game {
public enum State {
NORMAL, LOSE, DRAW, WIN,
}
public record Move(int position, char value) {}
public static final char EMPTY = (char)0;
protected final int rowSize;
protected final int columnSize;
protected final char[] board;
protected final Player[] players;
protected int currentPlayer;
protected Game(int rowSize, int columnSize, Player... players) {
assert rowSize > 0 && columnSize > 0;
assert players.length >= 1;
this.rowSize = rowSize;
this.columnSize = columnSize;
board = new char[rowSize * columnSize];
Arrays.fill(board, EMPTY);
this.players = players;
currentPlayer = 0;
}
protected Game(Game other) {
rowSize = other.rowSize;
columnSize = other.columnSize;
board = Arrays.copyOf(other.board, other.board.length);
players = Arrays.copyOf(other.players, other.players.length);
currentPlayer = other.currentPlayer;
}
public int getRowSize() { return rowSize; }
public int getColumnSize() { return columnSize; }
public char[] getBoard() { return board; }
public Player[] getPlayers() { return players; }
public Player getCurrentPlayer() { return players[currentPlayer]; }
protected void nextPlayer() {
currentPlayer = (currentPlayer + 1) % players.length;
}
public abstract Move[] getLegalMoves();
public abstract State play(Move move);
}

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

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

19
game/src/main/java/org/toop/game/Player.java
View File

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

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

@@ -0,0 +1,84 @@
package org.toop.game.tictactoe;
import org.toop.game.Game;
import org.toop.game.Player;
import java.util.ArrayList;
public final class TicTacToe extends Game {
private int movesLeft;
public TicTacToe(String player1, String player2) {
super(3, 3, new Player(player1, 'X'), new Player(player2, 'O'));
movesLeft = board.length;
}
public TicTacToe(TicTacToe other) {
super(other);
movesLeft = other.movesLeft;
}
@Override
public Move[] getLegalMoves() {
final ArrayList<Move> legalMoves = new ArrayList<>();
for (int i = 0; i < board.length; i++) {
if (board[i] == EMPTY) {
legalMoves.add(new Move(i, getCurrentPlayer().values()[0]));
}
}
return legalMoves.toArray(new Move[0]);
}
@Override
public State play(Move move) {
assert move != null;
assert move.position() >= 0 && move.position() < board.length;
assert move.value() == getCurrentPlayer().values()[0];
board[move.position()] = move.value();
movesLeft--;
if (checkForWin()) {
return State.WIN;
}
if (movesLeft <= 0) {
return State.DRAW;
}
nextPlayer();
return State.NORMAL;
}
private boolean checkForWin() {
// Horizontal
for (int i = 0; i < 3; i++) {
final int index = i * 3;
if (board[index] != EMPTY
&& board[index] == board[index + 1]
&& board[index] == board[index + 2]) {
return true;
}
}
// Vertical
for (int i = 0; i < 3; i++) {
if (board[i] != EMPTY
&& board[i] == board[i + 3]
&& board[i] == board[i + 6]) {
return true;
}
}
// B-Slash
if (board[0] != EMPTY && board[0] == board[4] && board[0] == board[8]) {
return true;
}
// F-Slash
return board[2] != EMPTY && board[2] == board[4] && board[2] == board[6];
}
}

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

@@ -0,0 +1,68 @@
package org.toop.game.tictactoe;
import org.toop.game.AI;
import org.toop.game.Game;
public final class TicTacToeAI extends AI<TicTacToe> {
@Override
public Game.Move findBestMove(TicTacToe game, int depth) {
assert game != null;
assert depth >= 0;
final Game.Move[] legalMoves = game.getLegalMoves();
if (legalMoves.length <= 0) {
return null;
}
if (legalMoves.length == 9) {
return switch ((int)(Math.random() * 4)) {
case 1 -> legalMoves[2];
case 2 -> legalMoves[6];
case 3 -> legalMoves[8];
default -> legalMoves[0];
};
}
int bestScore = -depth;
Game.Move bestMove = null;
for (final Game.Move move : legalMoves) {
final int score = getMoveScore(game, depth, move, true);
if (score > bestScore) {
bestMove = move;
bestScore = score;
}
}
return bestMove != null? bestMove : legalMoves[(int)(Math.random() * legalMoves.length)];
}
private int getMoveScore(TicTacToe game, int depth, Game.Move move, boolean maximizing) {
final TicTacToe copy = new TicTacToe(game);
final Game.State state = copy.play(move);
switch (state) {
case Game.State.DRAW: return 0;
case Game.State.WIN: return maximizing? depth + 1 : -depth - 1;
}
if (depth <= 0) {
return 0;
}
final Game.Move[] legalMoves = copy.getLegalMoves();
int score = maximizing? depth + 1 : -depth - 1;
for (final Game.Move next : legalMoves) {
if (maximizing) {
score = Math.min(score, getMoveScore(copy, depth - 1, next, false));
} else {
score = Math.max(score, getMoveScore(copy, depth - 1, next, true));
}
}
return score;
}
}

112
game/src/main/java/org/toop/tictactoe/TicTacToe.java
View File

@@ -1,112 +0,0 @@
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;
// Todo: refactor
public class TicTacToe extends GameBase {
protected static final Logger logger = LogManager.getLogger(TicTacToe.class);
public Thread gameThread;
public String gameId;
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;
}
@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
View File

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