417 lines
10 KiB
Java
417 lines
10 KiB
Java
package pp.mdga.game;
|
|
|
|
import java.util.*;
|
|
|
|
import pp.mdga.server.Observer;
|
|
|
|
/**
|
|
* The Game class represents the game state of the Ludo game.
|
|
* It contains all the information needed to play the game.
|
|
* The game state is updated by the game logic.
|
|
*/
|
|
public class Game {
|
|
private int diceModifier = 1;
|
|
private int diceEyes;
|
|
private Map<Color, Player> players = new EnumMap<>(Color.class);
|
|
private Statistic gameStatistics;
|
|
private List<BonusCard> drawPile;
|
|
private List<BonusCard> discardPile = new ArrayList<>();
|
|
private Board board;
|
|
private Color activeColor;
|
|
private List<Color> order;
|
|
private final ArrayList<Player> playerList = new ArrayList<>(4);
|
|
|
|
private final ArrayList<Observer> observers = new ArrayList<>();
|
|
private Player startPlayer;
|
|
private Boolean gameHasStarted = false;
|
|
private Boolean playerHasDisconnected = false;
|
|
private Boolean gameIsInterrupted = false;
|
|
private Boolean allRanked = false;
|
|
private Boolean movablePieces = false;
|
|
|
|
private Boolean allReady = false;
|
|
|
|
private static final int AMOUNT_OF_TURBO_CARDS = 16;
|
|
private static final int AMOUNT_OF_SHIELD_AND_SWAP_CARDS = 12;
|
|
|
|
/**
|
|
* This constructor creates a new Game object.
|
|
*/
|
|
public Game() {
|
|
gameStatistics = new Statistic();
|
|
drawPile = new ArrayList<>();
|
|
for (int i = 0; i < AMOUNT_OF_TURBO_CARDS; i++) {
|
|
drawPile.add(BonusCard.TURBO);
|
|
}
|
|
for (int i = 0; i < AMOUNT_OF_SHIELD_AND_SWAP_CARDS; i++) {
|
|
drawPile.add(BonusCard.SWAP);
|
|
drawPile.add(BonusCard.SHIELD);
|
|
}
|
|
board = new Board();
|
|
}
|
|
|
|
/**
|
|
* This method returns the dice modifier.
|
|
*
|
|
* @return the dice modifier
|
|
*/
|
|
public int getDiceModifier() {
|
|
return diceModifier;
|
|
}
|
|
|
|
/**
|
|
* This method sets the dice modifier.
|
|
*
|
|
* @param diceModifier the new dice modifier
|
|
*/
|
|
public void setDiceModifier(int diceModifier) {
|
|
this.diceModifier = diceModifier;
|
|
}
|
|
|
|
/**
|
|
* This method returns the dice eyes.
|
|
*
|
|
* @return the dice eyes
|
|
*/
|
|
public int getDiceEyes() {
|
|
return diceEyes;
|
|
}
|
|
|
|
/**
|
|
* This method sets the dice eyes.
|
|
*
|
|
* @param diceEyes the new dice eyes
|
|
*/
|
|
public void setDiceEyes(int diceEyes) {
|
|
this.diceEyes = diceEyes;
|
|
}
|
|
|
|
/**
|
|
* This method returns the players.
|
|
*
|
|
* @return the players
|
|
*/
|
|
public Map<Color, Player> getPlayers() {
|
|
return players;
|
|
}
|
|
|
|
/**
|
|
* This method sets the players.
|
|
*
|
|
* @param players the new players
|
|
*/
|
|
public void setPlayers(Map<Color, Player> players) {
|
|
this.players = players;
|
|
}
|
|
|
|
/**
|
|
* This method returns the game statistics.
|
|
*
|
|
* @return the game statistics
|
|
*/
|
|
public Statistic getGameStatistics() {
|
|
return gameStatistics;
|
|
}
|
|
|
|
/**
|
|
* This method sets the game statistics.
|
|
*
|
|
* @param gameStatistics the new game statistics
|
|
*/
|
|
public void setGameStatistics(Statistic gameStatistics) {
|
|
this.gameStatistics = gameStatistics;
|
|
}
|
|
|
|
/**
|
|
* This method returns the draw pile.
|
|
*
|
|
* @return the draw pile
|
|
*/
|
|
public List<BonusCard> getDrawPile() {
|
|
return drawPile;
|
|
}
|
|
|
|
/**
|
|
* This method sets the draw pile.
|
|
*
|
|
* @param drawPile the new draw pile
|
|
*/
|
|
public void setDrawPile(List<BonusCard> drawPile) {
|
|
this.drawPile = drawPile;
|
|
}
|
|
|
|
/**
|
|
* This method returns the discard pile.
|
|
*
|
|
* @return the discard pile
|
|
*/
|
|
public List<BonusCard> getDiscardPile() {
|
|
return discardPile;
|
|
}
|
|
|
|
/**
|
|
* This method sets the discard pile.
|
|
*
|
|
* @param discardPile the new discard pile
|
|
*/
|
|
public void setDiscardPile(List<BonusCard> discardPile) {
|
|
this.discardPile = discardPile;
|
|
}
|
|
|
|
/**
|
|
* This method returns the board.
|
|
*
|
|
* @return the board
|
|
*/
|
|
public Board getBoard() {
|
|
return board;
|
|
}
|
|
|
|
/**
|
|
* This method sets the board.
|
|
*
|
|
* @param board the new board
|
|
*/
|
|
public void setBoard(Board board) {
|
|
this.board = board;
|
|
}
|
|
|
|
/**
|
|
* This method returns the active color.
|
|
*
|
|
* @return the active color
|
|
*/
|
|
public Color getActiveColor() {
|
|
return activeColor;
|
|
}
|
|
|
|
/**
|
|
* This method sets the active color.
|
|
*
|
|
* @param activeColor the new active color
|
|
*/
|
|
public void setActiveColor(Color activeColor) {
|
|
this.activeColor = activeColor;
|
|
}
|
|
|
|
/**
|
|
* This method returns the order of the players.
|
|
*
|
|
* @return the order of the players
|
|
*/
|
|
public List<Color> getOrder() {
|
|
return order;
|
|
}
|
|
|
|
/**
|
|
* This method sets the order of the players.
|
|
*
|
|
* @param order the new order of the players
|
|
*/
|
|
public void setOrder(List<Color> order) {
|
|
this.order = order;
|
|
}
|
|
|
|
/**
|
|
* This method adds a player to the game.
|
|
*
|
|
* @param color the color of the player
|
|
* @param player the player to be added
|
|
*/
|
|
public void addPlayer(Color color, Player player) {
|
|
players.put(color, player);
|
|
}
|
|
|
|
/**
|
|
* This method removes a player from the game.
|
|
*
|
|
* @param color the color of the player
|
|
*/
|
|
public void removePlayer(Color color) {
|
|
players.remove(color);
|
|
}
|
|
|
|
/**
|
|
* This method adds an observer to the game.
|
|
*
|
|
* @param observer the observer to be added
|
|
*/
|
|
public void addObserver(Observer observer) {
|
|
observers.add(observer);
|
|
}
|
|
|
|
/**
|
|
* This method removes an observer from the game.
|
|
*
|
|
* @param observer the observer to be removed
|
|
*/
|
|
public void removeObserver(Observer observer) {
|
|
observers.remove(observer);
|
|
}
|
|
|
|
/**
|
|
* This method returns the game has started.
|
|
*
|
|
* @return the game has started
|
|
*/
|
|
public Boolean getGameHasStarted() {
|
|
return gameHasStarted;
|
|
}
|
|
|
|
/**
|
|
* This method sets the game has started.
|
|
*
|
|
* @param gameHasStarted the new game has started
|
|
*/
|
|
public void setGameHasStarted(Boolean gameHasStarted) {
|
|
this.gameHasStarted = gameHasStarted;
|
|
}
|
|
|
|
/**
|
|
* This method returns the player has disconnected.
|
|
*
|
|
* @return the player has disconnected
|
|
*/
|
|
public Boolean playerHasDisconnected() {
|
|
return playerHasDisconnected;
|
|
}
|
|
|
|
/**
|
|
* This method sets the game interruption state.
|
|
*
|
|
* @param gameIsInterrupted the new game interruption state
|
|
*/
|
|
public void setGameIsInterrupted(Boolean gameIsInterrupted) {
|
|
this.gameIsInterrupted = gameIsInterrupted;
|
|
if (Boolean.FALSE.equals(gameIsInterrupted)) notifyObservers();
|
|
}
|
|
|
|
/**
|
|
* This method returns whether the game is interrupted.
|
|
*
|
|
* @return true if the game is interrupted, false otherwise
|
|
*/
|
|
public Boolean gameIsInterrupted() {
|
|
return gameIsInterrupted;
|
|
}
|
|
|
|
/**
|
|
* This method returns whether the game is interrupted.
|
|
*
|
|
* @return true if the game is interrupted, false otherwise
|
|
*/
|
|
public Boolean getMovablePieces() {
|
|
return movablePieces;
|
|
}
|
|
|
|
/**
|
|
* This method sets the game interruption state.
|
|
*
|
|
* @param movablePieces the new game interruption state
|
|
*/
|
|
public void setMovablePieces(Boolean movablePieces) {
|
|
this.movablePieces = movablePieces;
|
|
if (Boolean.FALSE.equals(movablePieces)) notifyObservers();
|
|
}
|
|
|
|
/**
|
|
* This method sets the player has disconnected.
|
|
*
|
|
* @param playerHasDisconnected the new player has disconnected
|
|
*/
|
|
public void setPlayerHasDisconnected(Boolean playerHasDisconnected) {
|
|
this.playerHasDisconnected = playerHasDisconnected;
|
|
if (Boolean.TRUE.equals(playerHasDisconnected)) notifyObservers();
|
|
}
|
|
|
|
/**
|
|
* This method returns whether all players have ranked.
|
|
*
|
|
* @return true if all players have ranked, false otherwise
|
|
*/
|
|
public Boolean allRanked() {
|
|
return allRanked;
|
|
}
|
|
|
|
/**
|
|
* This method sets whether all players have ranked.
|
|
*
|
|
* @param allRanked the new all ranked state
|
|
*/
|
|
public void setAllRanked(Boolean allRanked) {
|
|
this.allRanked = allRanked;
|
|
if (Boolean.TRUE.equals(allRanked)) notifyObservers();
|
|
}
|
|
|
|
/**
|
|
* This method returns the start player.
|
|
*
|
|
* @return the start player
|
|
*/
|
|
public Player getStartPlayer() {
|
|
return startPlayer;
|
|
}
|
|
|
|
/**
|
|
* This method sets the start player.
|
|
*
|
|
* @param startPlayer the new start player
|
|
*/
|
|
public void setStartPlayer(Player startPlayer) {
|
|
this.startPlayer = startPlayer;
|
|
}
|
|
|
|
/**
|
|
* This method returns the all ready state.
|
|
*
|
|
* @return the all ready state
|
|
*/
|
|
public Boolean allReady() {
|
|
return allReady;
|
|
}
|
|
|
|
/**
|
|
* This method sets the all ready state.
|
|
*
|
|
* @param allReady the new all ready state
|
|
*/
|
|
public void setAllReady(Boolean allReady) {
|
|
this.allReady = allReady;
|
|
if (Boolean.TRUE.equals(allReady)) notifyObservers();
|
|
}
|
|
|
|
/**
|
|
* This method notifies the observers.
|
|
*/
|
|
public void notifyObservers() {
|
|
for (Observer observer : new ArrayList<>(observers)) {
|
|
observer.update();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method returns the piece through its identifier.
|
|
*
|
|
* @param identifier the identifier of the piece
|
|
* @return the piece
|
|
*/
|
|
public Piece getPieceThroughIdentifier(String identifier) {
|
|
String[] parts = identifier.split("-");
|
|
Color color = Color.valueOf(parts[0]);
|
|
int index = Integer.parseInt(parts[1]);
|
|
return board.getPlayerData().get(color).getPieces()[index];
|
|
}
|
|
|
|
public ArrayList<Player> getPlayerList() {
|
|
return playerList;
|
|
}
|
|
|
|
public void addPlayerToList(Player player) {
|
|
playerList.add(player);
|
|
}
|
|
|
|
public void removePlayerFromList(Player player) {
|
|
playerList.remove(player);
|
|
}
|
|
}
|