init: first commit for extension

Author: Androz2091

resources/sounds/gained_points.mp3

@@ -1,5 +1,7 @@
 package ch.epfl.chacun;
 
+import ch.epfl.chacun.audio.SoundManager;
+
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -13,6 +15,7 @@
  * @param board        the board of the game, where the tiles can be placed
  * @param nextAction   the next action to be performed
  * @param messageBoard the message board of the game, containing the messages generated during the game
+ * @param nextSound    the sound to play when the game state is updated
  * @author Valerio De Santis (373247)
  * @author Simon Lefort (371918)
  */
@@ -22,7 +25,8 @@ public record GameState(
         Tile tileToPlace,
         Board board,
         Action nextAction,
-        MessageBoard messageBoard
+        MessageBoard messageBoard,
+        SoundManager.Sound nextSound
 ) {
 
     /**
@@ -52,9 +56,11 @@ public enum Action {
      * @param nextAction   the next action to be performed, must not be null
      * @param messageBoard the message board of the game,
      *                     containing the messages generated during the game, must not be null
+     * @param nextSound    the sound to play when the game state is updated, can be null
      * @throws NullPointerException     if any of the arguments is null, except tileToPlace
      * @throws IllegalArgumentException if there are not enough players or if the tileToPlace is null and
-     *                                  the next action is to place a tile, or if the tileToPlace is not null and the next action is not to place a tile.
+     *                                  the next action is to place a tile, or if the tileToPlace is not null and the
+     *                                  next action is not to place a tile.
      */
     public GameState {
 
@@ -65,11 +71,36 @@ public enum Action {
 
         Objects.requireNonNull(players);
         players = List.copyOf(players);
-        Preconditions.checkArgument(players.size() >= MIN_PLAYER_COUNT);
 
         Preconditions.checkArgument(tileToPlace == null ^ nextAction == Action.PLACE_TILE);
     }
 
+    /**
+     * Constructs a new game state, with no tile to place, an empty board, and the start game action.
+     *
+     * @param players      the ordered list of the game players, must contain at least 2 players and not be null
+     * @param tileDecks    the tile decks of the game, containing the cards to place, must not be null
+     * @param tileToPlace  the tile to place on the board, may be null if no tile is to be placed
+     * @param board        the board of the game, where the tiles can be placed, must not be null
+     * @param nextAction   the next action to be performed, must not be null
+     * @param messageBoard the message board of the game,
+     *                     containing the messages generated during the game, must not be null
+     * @throws NullPointerException     if any of the arguments is null, except tileToPlace
+     * @throws IllegalArgumentException if there are not enough players or if the tileToPlace is null and
+     *                                  the next action is to place a tile, or if the tileToPlace is not null and the
+     *                                  next action is not to place a tile.
+     */
+    public GameState(
+            List<PlayerColor> players,
+            TileDecks tileDecks,
+            Tile tileToPlace,
+            Board board,
+            Action nextAction,
+            MessageBoard messageBoard
+    ) {
+        this(players, tileDecks, tileToPlace, board, nextAction, messageBoard, SoundManager.Sound.SILENT);
+    }
+
     /**
      * Constructs the initial game state, with no tile to place, an empty board, and the start game action.
      *
@@ -301,8 +332,10 @@ public GameState withPlacedTile(PlacedTile tile) {
             }
         }
 
-        return new GameState(players, tileDecks, null, newBoard, Action.OCCUPY_TILE, newMessageBoard)
-                .withTurnFinishedIfOccupationImpossible();
+        return new GameState(
+                players, tileDecks, null, newBoard, Action.OCCUPY_TILE,
+                newMessageBoard, SoundManager.Sound.PLACED_TILE
+        ).withTurnFinishedIfOccupationImpossible();
     }
 
     /**
@@ -334,6 +367,8 @@ private GameState withTurnFinished() {
         Preconditions.checkArgument(board.lastPlacedTile() != null);
 
         MessageBoard newMessageBoard = messageBoard;
+        Map<PlayerColor, Integer> currentPoints = messageBoard.points();
+
         // the tile has already been added to the board previously
         Board newBoard = board;
         TileDecks newTileDecks = tileDecks;
@@ -376,9 +411,13 @@ private GameState withTurnFinished() {
         if (newTileDecks.deckSize(Tile.Kind.NORMAL) > 0) {
             List<PlayerColor> newPlayers = new LinkedList<>(players);
             Collections.rotate(newPlayers, -1);
+
+            SoundManager.Sound nextSound = newMessageBoard.points().equals(currentPoints)
+                    ? nextSound() : SoundManager.Sound.GAINED_POINTS;
+
             return new GameState(newPlayers, newTileDecks.withTopTileDrawn(Tile.Kind.NORMAL),
                     newTileDecks.topTile(Tile.Kind.NORMAL),
-                    newBoard, Action.PLACE_TILE, newMessageBoard
+                    newBoard, Action.PLACE_TILE, newMessageBoard, nextSound
             );
         } else {
             return new GameState(players, newTileDecks, null, newBoard, Action.END_GAME, newMessageBoard)
@@ -444,4 +483,34 @@ private GameState withFinalPointsCounted() {
         return new GameState(players, tileDecks, null, newBoard, Action.END_GAME, newMessageBoard);
     }
 
+    /**
+     * Returns a new game state with the given players list as new players
+     *
+     * @param players the new players list
+     * @return a new game state with the given players list as new players
+     */
+    public GameState withPlayers(List<PlayerColor> players) {
+        return new GameState(players, tileDecks, tileToPlace, board, nextAction, messageBoard);
+    }
+
+    /**
+     * Returns a new game state with the given chat message added to the message board
+     *
+     * @param message the chat message to add
+     * @return a new game state with the given chat message added to the message board
+     */
+    public GameState withGameChatMessage(String message) {
+        return new GameState(players, tileDecks, tileToPlace, board, nextAction, messageBoard.withGameChatMessage(message));
+    }
+
+    /**
+     * Returns a new game state with the given chat message added to the message board
+     *
+     * @param textMaker the text maker to generate the message
+     * @return a new game state with the given chat message added to the message board
+     */
+    public GameState withTextMaker(TextMaker textMaker) {
+        return new GameState(players, tileDecks, tileToPlace, board, nextAction, messageBoard.withTextMaker(textMaker));
+    }
+
 }

resources/sounds/menhir_closed.mp3

@@ -340,6 +340,29 @@ public MessageBoard withWinners(Set<PlayerColor> winners, int points) {
         );
     }
 
+    /**
+     * Returns a new message board with the given text maker
+     * @param textMaker the text maker to use
+     * @return a new message board with the given text maker
+     */
+    public MessageBoard withTextMaker(TextMaker textMaker) {
+        return new MessageBoard(textMaker, messages);
+    }
+
+    /**
+     * Returns a new message board with the given message added
+     * @param message the message to add
+     * @return a new message board with the given message added
+     */
+    public MessageBoard withGameChatMessage(String message) {
+        return withNewMessage(
+                message,
+                0,
+                Set.of(),
+                Set.of()
+        );
+    }
+
     /**
      * Represents a message on the message board.
      *

resources/sounds/placed_tile.mp3

@@ -147,4 +147,11 @@ public interface TextMaker {
      * @return le texte en question
      */
     String clickToUnoccupy();
+
+    /**
+     * Retourne un texte demandant au joueur actuel de rentrer un message dans le chat.
+     *
+     * @return le texte en question
+     */
+    String enterChatMessage();
 }

src/ch/epfl/chacun/GameState.java

@@ -294,4 +294,9 @@ public String clickToOccupy() {
     public String clickToUnoccupy() {
         return "Cliquez sur le pion que vous désirez reprendre, ou ici pour ne pas en reprendre.";
     }
+
+    @Override
+    public String enterChatMessage() {
+        return "Entrez un message...";
+    }
 }

src/ch/epfl/chacun/MessageBoard.java

@@ -0,0 +1,50 @@
+package ch.epfl.chacun.audio;
+
+import javafx.scene.media.Media;
+import javafx.scene.media.MediaPlayer;
+
+import java.net.URL;
+
+/**
+ * This class is responsible for playing sounds in the game
+ *
+ * @author Valerio De Santis (373247)
+ * @author Simon Lefort (371918)
+ */
+public final class SoundManager {
+
+    private static MediaPlayer mediaPlayer;
+
+    /**
+     * Plays a sound (high priority, stops the current sound if any)
+     *
+     * @param sound the sound to play
+     */
+    public void play(Sound sound) {
+
+        if (sound == Sound.SILENT) {
+            mediaPlayer.stop();
+            return;
+        }
+
+        String name = STR."/sounds/\{sound.toString().toLowerCase()}.mp3";
+        URL url = getClass().getResource(name);
+        assert url != null;
+        Media media = new Media(url.toString());
+
+        mediaPlayer = new MediaPlayer(media);
+        mediaPlayer.setAutoPlay(true);
+    }
+
+    /**
+     * The sounds of our game, ordered by priority in concurrent occasions
+     */
+    public enum Sound {
+        PLACED_TILE,
+        GAINED_POINTS,
+        MENHIR_CLOSED,
+        SILENT
+    }
+
+
+}

src/ch/epfl/chacun/TextMaker.java

@@ -42,9 +42,14 @@ private ActionsUI() {
      * @param actionsO the observable list of all actions since the start of the game
      * @param handler  an event handler whose method has to be applied when the player
      *                 inserts a new action in the field
+     * @param isLocalPlayerCurrentPlayerO the observable value of a boolean that is true if the local player is the current player
      * @return a node containing the last actions of the game state and a field where one may insert a new action
      */
-    public static Node create(ObservableValue<List<String>> actionsO, Consumer<String> handler) {
+    public static Node create(
+            ObservableValue<List<String>> actionsO,
+            Consumer<String> handler,
+            ObservableValue<Boolean> isLocalPlayerCurrentPlayerO
+    ) {
 
         Text text = new Text();
         text.textProperty().bind(actionsO.map(ActionsUI::actionsTextRepresentation));
@@ -59,6 +64,7 @@ public static Node create(ObservableValue<List<String>> actionsO, Consumer<Strin
             handler.accept(textField.getText());
             textField.clear();
         });
+        textField.disableProperty().bind(isLocalPlayerCurrentPlayerO.map(b -> !b));
 
         HBox hbox = new HBox(text, textField);
         hbox.setId("actions");

src/ch/epfl/chacun/TextMakerFr.java

@@ -55,15 +55,16 @@ private BoardUI() {
      * for a certain message when the player hovers over it. It also handles some graphical effects to
      * render the positions where a tile can be placed in the next turn and the mouse interactions.
      *
-     * @param reach             the reach of the board (the distance from the center to the borders),
-     *                          the board will be a square of size (2*range+1)²
-     * @param gameStateO        the observable value of the current game state
-     * @param rotationO         the observable value of the current rotation of the tile to be placed
-     * @param occupantsO        the observable value of the set containing the occupants on the board to show
-     * @param highlightedTilesO the observable value of the set containing the tiles to highlight
-     * @param rotationConsumer  the consumer that will be called when the player rotates the tile to be placed (right click)
-     * @param posConsumer       the consumer that will be called when the player places the tile (left click)
-     * @param occupantConsumer  the consumer that will be called when the player clicks on an occupant
+     * @param reach                       the reach of the board (the distance from the center to the borders),
+     *                                    the board will be a square of size (2*range+1)²
+     * @param gameStateO                  the observable value of the current game state
+     * @param rotationO                   the observable value of the current rotation of the tile to be placed
+     * @param occupantsO                  the observable value of the set containing the occupants on the board to show
+     * @param highlightedTilesO           the observable value of the set containing the tiles to highlight
+     * @param isLocalPlayerCurrentPlayerO the observable value of the boolean that is true if the local player is the current player
+     * @param rotationConsumer            the consumer that will be called when the player rotates the tile to be placed (right click)
+     * @param posConsumer                 the consumer that will be called when the player places the tile (left click)
+     * @param occupantConsumer            the consumer that will be called when the player clicks on an occupant
      * @return a graphical node representing the board of the game
      */
     public static Node create(
@@ -72,6 +73,7 @@ public static Node create(
             ObservableValue<Rotation> rotationO,
             ObservableValue<Set<Occupant>> occupantsO,
             ObservableValue<Set<Integer>> highlightedTilesO,
+            ObservableValue<Boolean> isLocalPlayerCurrentPlayerO,
 
             Consumer<Rotation> rotationConsumer,
             Consumer<Pos> posConsumer,
@@ -151,7 +153,10 @@ public static Node create(
                     if (isAlreadyPlaced) return new CellData(placedTile,
                             darkVeilEnabledO.getValue() ? Color.BLACK : Color.TRANSPARENT);
                     // else, if the tile is not placed yet, nor in the fringe, display it as an empty image
-                    if (!isInFringeO.getValue()) return new CellData(Color.TRANSPARENT);
+                    if (
+                            !isInFringeO.getValue()
+                                    || !isLocalPlayerCurrentPlayerO.getValue()
+                    ) return new CellData(Color.TRANSPARENT);
 
                     GameState currentGameState = gameStateO.getValue();
                     PlayerColor currentPlayer = currentGameState.currentPlayer();
@@ -168,10 +173,11 @@ public static Node create(
                     }
                     // finally, if the tile is in the fringe but the mouse is not on it,
                     // we display it with a veil of the current player's color
+                    assert currentPlayer != null;
                     return new CellData(ColorMap.fillColor(currentPlayer));
                     // these arguments are the sensibility of the code,
                     // every time one of them changes, the code is re-executed
-                }, isInFringeO, group.hoverProperty(), rotationO, darkVeilEnabledO, placedTileO);
+                }, isInFringeO, group.hoverProperty(), rotationO, darkVeilEnabledO, placedTileO, isLocalPlayerCurrentPlayerO);
 
                 // we bind the graphical properties of the group to the cell data's values
                 group.rotateProperty().bind(cellDataO.map(cellData -> cellData.tileRotation().degreesCW()));
@@ -184,27 +190,30 @@ public static Node create(
                 // when a tile is placed, we add the animals and the occupants on it
                 placedTileO.addListener((_, oldPlacedTile, placedTile) -> {
                     // if the tile is already placed or is not yet, we do not have to add the animals and the occupants
-                    if (oldPlacedTile != null || placedTile == null) return;
-
-                    double negatedTileRotation = placedTile.rotation().negated().degreesCW();
-
-                    // handle "jeton d'annulation", a marker that signals that an animal is cancelled
-                    List<Node> cancelledAnimalsNodes =
-                            placedTile.meadowZones().stream()
-                                    .flatMap(meadow -> meadow.animals().stream())
-                                    .map(animal -> getCancelledAnimalNode(animal, cancelledAnimalsO, negatedTileRotation))
-                                    .toList();
-                    group.getChildren().addAll(cancelledAnimalsNodes);
-                    // here we handle the graphical representation of the occupants
-                    List<Node> potentialOccupantsNodes = placedTile.potentialOccupants()
-                            .stream()
-                            .map(occupant -> getOccupantNode(
-                                    placedTile.placer(), occupant,
-                                    occupantsO, occupantConsumer, negatedTileRotation
-                            ))
-                            .toList();
-
-                    group.getChildren().addAll(potentialOccupantsNodes);
+                    if (oldPlacedTile == null && placedTile != null) {
+                        double negatedTileRotation = placedTile.rotation().negated().degreesCW();
+
+                        // handle "jeton d'annulation", a marker that signals that an animal is cancelled
+                        List<Node> cancelledAnimalsNodes =
+                                placedTile.meadowZones().stream()
+                                        .flatMap(meadow -> meadow.animals().stream())
+                                        .map(animal -> getCancelledAnimalNode(animal, cancelledAnimalsO, negatedTileRotation))
+                                        .toList();
+                        group.getChildren().addAll(cancelledAnimalsNodes);
+                        // here we handle the graphical representation of the occupants
+                        List<Node> potentialOccupantsNodes = placedTile.potentialOccupants()
+                                .stream()
+                                .map(occupant -> getOccupantNode(
+                                        placedTile.placer(), occupant,
+                                        occupantsO, occupantConsumer, negatedTileRotation
+                                ))
+                                .toList();
+
+                        group.getChildren().addAll(potentialOccupantsNodes);
+                    } else if (oldPlacedTile != null && placedTile == null) { // rollback!
+                        group.getChildren().stream().skip(1).forEach(group.getChildren()::remove);
+                    }
+
                 });
             }
         }