Merge remote-tracking branch 'origin/main' into GUI

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="DuplicatedCode" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
+  </profile>
+</component>

src/main/java/it/polimi/ingsw/gc14/ClientLauncherTUI.java

@@ -5,28 +5,67 @@ import it.polimi.ingsw.gc14.Network.RMI.Client.RMIClient;
 import it.polimi.ingsw.gc14.Network.TCP.Client.TCPClient;
 import it.polimi.ingsw.gc14.View.TUI.TUI;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Scanner;
 
+/**
+ * Entry point for the TUI-based game client.
+ * Handles the initial setup by asking the user for a username, the desired number of players,
+ * and the preferred network protocol (RMI or TCP).
+ * Once connected to the server, it continuously reads and dispatches user input to the controller.
+ */
 public class ClientLauncherTUI {
-    //TODO Javadoc
+
+    List<String> admissibleChar=new ArrayList<>();
+
+    /**
+     * The TUI view associated with this client.
+     */
+    TUI view;
+
+    /**
+     * Starts the TUI client.
+     * Prompts the user for a username, the desired number of players, and the network protocol.
+     * Attempts to connect to the server using either RMI or TCP depending on the selection.
+     * If the connection is successful, enters a loop to continuously read and process user input.
+     *
+     * @throws InterruptedException if the thread is interrupted while waiting.
+     */
     public void main() throws InterruptedException {
-        TUI view=new TUI(null);
+        view = new TUI(null);
+        admissibleChar.add("0");
+        admissibleChar.add("1");
+        admissibleChar.add("2");
+        admissibleChar.add("3");
+        admissibleChar.add("4");
+        admissibleChar.add("5");
+        admissibleChar.add("6");
+        admissibleChar.add("7");
+        admissibleChar.add("8");
+        admissibleChar.add("9");
+        admissibleChar.add("A");
+        admissibleChar.add("B");
+        admissibleChar.add("C");
+        admissibleChar.add("a");
+        admissibleChar.add("b");
+        admissibleChar.add("c");
+
         ClientController controller = new ClientController(view);
-
         Scanner scanner = new Scanner(System.in);
-        System.out.println("Selezionare nome utente: ");
+        System.out.println("Insert username: ");
         String username = scanner.next();
-        System.out.println("Selezionare numero di giocatori desiderato: ");
+        view.setUsername(username);
+        System.out.println("Insert preferred number of players: ");
         int proposedNumPlayers = scanner.nextInt();
-        System.out.println("Selezionare RMI[0] o TCP[1]: ");
+        System.out.println("Select RMI[0] o TCP[1]: ");
         int networkType = scanner.nextInt();
-
+        System.out.println("Insert server IP: ");
-
+        String IP = scanner.next();
-
         // RMI
         if (networkType == 0) {
             // Connect
-            RMIClient client = new RMIClient(controller, "localhost", 1099);
+            RMIClient client = new RMIClient(controller, IP, 1099);
             if (client.connect(username, proposedNumPlayers)) {
                 System.out.println("Succesfully connected to RMI server\n\n");
             } else {
@@ -34,20 +73,13 @@ public class ClientLauncherTUI {
                 return;
             }
             controller.setClient(client);
-
+            while (true) {
-            // Play
-            //while(controller.localController.getModel()==null){
-            //    scanner.nextInt();
-            //}
-            while(true) {
                 getInput(scanner, controller, username);
             }
-
+            // TCP
-
-        // TCP
         } else if (networkType == 1) {
             // Connect
-            TCPClient client = new TCPClient(controller, "localhost", 8080);
+            TCPClient client = new TCPClient(controller, IP, 8080);
             if (client.connect(username, proposedNumPlayers)) {
                 System.out.println("Succesfully connected to TCP server\n\n");
             } else {
@@ -55,31 +87,75 @@ public class ClientLauncherTUI {
                 return;
             }
             controller.setClient(client);
-
             // Play
-            while(true) {
+            while (true) {
                 getInput(scanner, controller, username);
             }
         }
-
         scanner.close();
     }
 
-
+    /**
-
+     * Reads a single action from the user and dispatches it to the controller.
+     * The action is identified by a string code. Most actions also require a position index
+     * (e.g. the index of the card to draw from a list), which is read as a second input.
+     * Actions that do not require a position (7, 8, 9, A, B, C) skip the position prompt.
+     * <p>
+     * Available actions:
+     * <ul>
+     *   <li>{@code 0} - Choose a slot by index.</li>
+     *   <li>{@code 1} - Draw an upper building card by index.</li>
+     *   <li>{@code 2} - Draw an upper tribe card by index.</li>
+     *   <li>{@code 3} - Draw a lower building card by index.</li>
+     *   <li>{@code 4} - Draw a lower tribe card by index.</li>
+     *   <li>{@code 5} - Pick an optional tribe card by index.</li>
+     *   <li>{@code 6} - Pick an optional building card by index.</li>
+     *   <li>{@code 7} - Skip the optional card choice.</li>
+     *   <li>{@code 8} - Skip the upper draw.</li>
+     *   <li>{@code 9} - Skip the lower draw.</li>
+     *   <li>{@code A} - Render the full game view.</li>
+     *   <li>{@code B} - Render the board view.</li>
+     *   <li>{@code C} - Render the player view.</li>
+     * </ul>
+     *
+     * @param scanner    the scanner used to read user input.
+     * @param controller the client controller to which actions are dispatched.
+     * @param username   the username of the current player.
+     */
     private void getInput(Scanner scanner, ClientController controller, String username) {
-        int action = scanner.nextInt();
+        String action = scanner.next();
-        int pos = scanner.nextInt();
+        int pos = -1;
 
-        switch(action) {
+        if(admissibleChar.contains(username))
-            case 1 -> controller.drawLowerBuildingCard(username, pos);
+        {
-            case 2 -> controller.drawLowerTribeCard(username, pos);
+            if (!action.equals("7") && !action.equals("8") && !action.equals("9") && !action.equals("A") && !action.equals("B") && !action.equals("C")) {
-            case 3 -> controller.drawUpperBuildingCard(username, pos);
+                try {
-            case 4 -> controller.drawUpperTribeCard(username, pos);
+                    System.out.println("Insert the required position:");
-            case 5 -> controller.pickOptionalBuildingCard(username, pos);
+                    pos = scanner.nextInt();
-            case 6 -> controller.slotChoice(username, pos);
+                } catch (Exception e) {
+                    System.out.println("ERROR: Invalid input(expected number)");
+                }
+            }
+            switch (action) {
+                case "0" -> controller.slotChoice(username, pos);
+                case "1" -> controller.drawUpperTribeCard(username, pos);
+                case "2" -> controller.drawUpperBuildingCard(username, pos);
+                case "3" -> controller.drawLowerTribeCard(username, pos);
+                case "4" -> controller.drawLowerBuildingCard(username, pos);
+                case "5" -> controller.pickOptionalTribeCard(username, pos);
+                case "6" -> controller.pickOptionalBuildingCard(username, pos);
+                case "7" -> controller.noOptionalCard(username);
+                case "8" -> controller.skipUpper(username);
+                case "9" -> controller.skipLower(username);
+                case "A", "a" -> view.fullRender();
+                case "B", "b" -> view.renderBoard();
+                case "C", "c" -> view.renderPlayer();
+                default -> {}
+            }
+        }
+        else
+        {
+            System.out.println("ERROR: Invalid input(action not valid)");
         }
-
-        return;
     }
 }

src/main/java/it/polimi/ingsw/gc14/Controller/ClientController.java

@@ -1,116 +1,164 @@
 package it.polimi.ingsw.gc14.Controller;
 
 import it.polimi.ingsw.gc14.Model.Game;
-import it.polimi.ingsw.gc14.Model.Player;
 import it.polimi.ingsw.gc14.Network.IClient;
 import it.polimi.ingsw.gc14.Network.NetworkEvents.*;
-import it.polimi.ingsw.gc14.Network.Observer;
 import it.polimi.ingsw.gc14.View.IView;
 
-//TODO Javadoc
+/**
+ * Controller class that holds all the components of the client, such as view, network client and Game Controller.
+ * It provides methods to set the client components and to execute requested actions.
+ */
 public class ClientController {
 
+    /** Game Controller of the client */
     public GameController localController;
 
-    //TODO Javadoc
+    /** View of the client */
-    public IView view=null;
+    public IView view;
+
+    /** Network client (either TCP or RMI) */
     private IClient client;
 
+
+    /**
+     * Constructs the ClientController.
+     * Initializes all attributes.
+     * @param view the client view (either TUI or GUI)
+     */
     public ClientController(IView view) {
         this.view = view;
         this.localController = new GameController();
+        this.client = null;
     }
+
+
+    /**
+     * Sets the network client.
+     * @param client the client to set (either TCP or RMI)
+     */
     public void setClient(IClient client) {
         this.client = client;
     }
+
+
+    /**
+     * Sets the model in the GameController and updates the view.
+     * @param model the model to set
+     */
     public void setModel(Game model) {
         localController.setModel(model);
         view.update(localController.getModel());
     }
 
+
+    /**
+     * Displays an error message in the view.
+     * @param message the error message to display
+     */
     public void onError(String message) {
         view.showError(message);
     }
 
+
     /**
-     * Attempts to draw an upper tribe card for the specified player from the specified position.
+     * Requests to draw a tribe card from the upper list.
-     *
+     * Creates a NetworkEvent and sends it through the network client.
-     * @param playerUsername the username of the player performing the action.
+     * @param playerUsername the name of the player performing the action
-     * @param pos the position of the upper tribe card to draw.
+     * @param pos the index of the card to draw
-     * @return {@code true} if the action succeeds, {@code false} if the player does not exist
-     *         or if the draw operation fails.
      */
-    public void drawUpperTribeCard(String playerUsername,int pos) {
+    public void drawUpperTribeCard(String playerUsername, int pos) {
         client.doEvent(new DrawUpperTribeCard(playerUsername,pos));
     }
 
+
     /**
-     * Attempts to draw a lower tribe card for the specified player from the specified position.
+     * Requests to draw a tribe card from the lower list.
-     *
+     * Creates a NetworkEvent and sends it through the network client.
-     * @param playerUsername the username of the player performing the action.
+     * @param playerUsername the name of the player performing the action
-     * @param pos the position of the lower tribe card to draw.
+     * @param pos the index of the card to draw
-     * @return {@code true} if the action succeeds, {@code false} if the player does not exist
-     *         or if the draw operation fails.
      */
     public void drawLowerTribeCard(String playerUsername,int pos) {
         client.doEvent(new DrawLowerTribeCard(playerUsername,pos));
     }
 
+
     /**
-     * Attempts to draw an upper building card for the specified player from the specified position.
+     * Requests to draw a building card from the upper list.
-     *
+     * Creates a NetworkEvent and sends it through the network client.
-     * @param playerUsername the username of the player performing the action.
+     * @param playerUsername the name of the player performing the action
-     * @param pos the position of the upper building card to draw.
+     * @param pos the index of the card to draw
-     * @return {@code true} if the action succeeds, {@code false} if the player does not exist
-     *         or if the draw operation fails.
      */
     public void drawUpperBuildingCard(String playerUsername,int pos) {
         client.doEvent(new DrawUpperBuildingCard(playerUsername,pos));
     }
 
+
     /**
-     * Attempts to draw a lower building card for the specified player from the specified position.
+     * Requests to draw a building card from the lower list.
-     *
+     * Creates a NetworkEvent and sends it through the network client.
-     * @param playerUsername the username of the player performing the action.
+     * @param playerUsername the name of the player performing the action
-     * @param pos the position of the lower building card to draw.
+     * @param pos the index of the card to draw
-     * @return {@code true} if the action succeeds, {@code false} if the player does not exist
-     *         or if the draw operation fails.
      */
     public void drawLowerBuildingCard(String playerUsername,int pos) {
         client.doEvent(new DrawLowerBuildingCard(playerUsername,pos));
     }
 
+
     /**
-     * Attempts to pick an optional tribe card for the specified player from the specified position.
+     * Requests to skip drawing from the upper list.
-     *
+     * This action is available only when the upper list is empty or the player cannot draw any card.
-     * @param playerUsername the username of the player performing the action.
+     * @param playerUsername the name of the player performing the action
-     * @param pos the position of the optional tribe card to pick.
+     */
-     * @return {@code true} if the action succeeds, {@code false} if the player does not exist
+    public void skipUpper(String playerUsername) {
-     *         or if the pick operation fails.
+        client.doEvent(new SkipUpper(playerUsername));
+    }
+
+
+    /**
+     * Requests to skip drawing from the lower list.
+     * This action is available only when the lower list is empty or the player cannot draw any card.
+     * @param playerUsername the name of the player performing the action
+     */
+    public void skipLower(String playerUsername) { client.doEvent(new SkipLower(playerUsername));}
+
+
+    /**
+     * Used to draw a tribe card from the upper list.
+     * Available only if the player owns the building 12.
+     * @param playerUsername the name of the player performing the action
+     * @param pos the index of the card to draw
      */
     public void pickOptionalTribeCard(String playerUsername,int pos) {
         client.doEvent(new PickOptionalTribeCard(playerUsername,pos));
     }
 
+
     /**
-     * Attempts to pick an optional building card for the specified player from the specified position.
+     * Used to draw a building card from the upper list.
-     *
+     * Available only if the player owns the building 12.
-     * @param playerUsername the username of the player performing the action.
+     * @param playerUsername the name of the player performing the action
-     * @param pos the position of the optional building card to pick.
+     * @param pos the index of the card to draw
-     * @return {@code true} if the action succeeds, {@code false} if the player does not exist
-     *         or if the pick operation fails.
      */
     public void pickOptionalBuildingCard(String playerUsername,int pos) {
         client.doEvent(new PickOptionalBuildingCard(playerUsername,pos));
     }
 
+
     /**
-     * Attempts to perform the slot choice action for the specified player at the specified position.
+     * Used to skip the action of drawing a card from the upper list.
-     *
+     * Available only if the player owns the building 12.
-     * @param playerUsername the username of the player performing the action.
+     * @param playerUsername the name of the player performing the action
-     * @param pos the position of the chosen slot.
+     */
-     * @return {@code true} if the action succeeds, {@code false} if the player does not exist
+    public void noOptionalCard(String playerUsername) {
-     *         or if the slot choice operation fails.
+        client.doEvent(new NoOptionalCard(playerUsername));
+    }
+
+
+    /**
+     * Used to perform the slot choice action for the specified player at the specified position.
+     * @param playerUsername the name of the player performing the action
+     * @param pos the index of the selected slot
      */
     public void slotChoice(String playerUsername,int pos) {
         client.doEvent(new SlotChoice(playerUsername,pos));

src/main/java/it/polimi/ingsw/gc14/Controller/GameController.java

@@ -1,6 +1,7 @@
 package it.polimi.ingsw.gc14.Controller;
 
 import it.polimi.ingsw.gc14.Model.Game;
+import it.polimi.ingsw.gc14.Model.GamePackage.GameStages;
 import it.polimi.ingsw.gc14.Model.Player;
 
 /**
@@ -118,6 +119,20 @@ public class GameController {
         return model.DrawLowerBuildingCardByIndex(model.getPlayerByUsername(playerUsername), pos);
     }
 
+    public boolean SkipUpperDrawing(String playerUsername) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.SkipUpperDrawing(model.getPlayerByUsername(playerUsername));
+    }
+
+    public boolean SkipLowerDrawing(String playerUsername) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.SkipLowerDrawing(model.getPlayerByUsername(playerUsername));
+    }
+
     /**
      * Attempts to pick an optional tribe card for the specified player from the specified position.
      *
@@ -147,6 +162,18 @@ public class GameController {
             return false;
         return model.PickOptionalBuildingCard(model.getPlayerByUsername(playerUsername), pos);
     }
+    /**
+     * Refuse to pick an optional building card for the specified player.
+     * @param playerUsername the username of the player performing the action.
+     * @return {@code true} if the action succeeds, {@code false} if the player does not exist
+     *         or if the pick operation fails.
+     */
+    public boolean noOptionalCard(String playerUsername) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.NoOptionalCard(model.getPlayerByUsername(playerUsername));
+    }
 
     /**
      * Attempts to perform the slot choice action for the specified player at the specified position.

src/main/java/it/polimi/ingsw/gc14/LimitedList.java

@@ -1,22 +1,42 @@
 package it.polimi.ingsw.gc14;
-
 import java.util.ArrayList;
 
-//TODO Javadoc
+/**
+ * An {@link ArrayList} with a configurable size limit and an associated action.
+ * When the number of elements reaches or exceeds the limit, the specified action is automatically triggered.
+ *
+ * @param <T> the type of elements held in this list.
+ */
 public class LimitedList<T> extends ArrayList<T> {
-    //TODO Javadoc
+
+    /**
+     * The maximum number of elements allowed in the list before the action is triggered.
+     */
     private int limit;
 
-    //TODO Javadoc
+    /**
+     * The action to execute when the list size reaches or exceeds the limit.
+     */
     private Runnable action;
 
-    //TODO Javadoc
+    /**
+     * Creates a new {@code LimitedList} with the specified limit and action.
+     *
+     * @param limit  the maximum number of elements before the action is triggered.
+     * @param action the action to execute when the limit is reached.
+     */
     public LimitedList(int limit, Runnable action) {
         this.limit = limit;
         this.action = action;
     }
 
-    //TODO Javadoc
+    /**
+     * Adds the specified element to the list.
+     * If the list size reaches or exceeds the limit after the insertion, the configured action is triggered.
+     *
+     * @param element the element to add.
+     * @return {@code true} if the element was successfully added.
+     */
     @Override
     public boolean add(T element) {
         boolean result = super.add(element);
@@ -26,16 +46,30 @@ public class LimitedList<T> extends ArrayList<T> {
         return result;
     }
 
-    //TODO Javadoc
+    /**
+     * Sets a new size limit for this list.
+     *
+     * @param num the new limit.
+     */
     public void setLimit(int num) {
-        this.limit=num;
+        this.limit = num;
     }
 
-    //TODO Javadoc
+    /**
-    public int getLimit(){return limit;}
+     * Returns the current size limit of this list.
+     *
+     * @return the current limit.
+     */
+    public int getLimit() {
+        return limit;
+    }
 
-    //TODO Javadoc
+    /**
+     * Sets a new action to execute when the list size reaches or exceeds the limit.
+     *
+     * @param action the new action to set.
+     */
     public void setAction(Runnable action) {
-        this.action=action;
+        this.action = action;
     }
 }

src/main/java/it/polimi/ingsw/gc14/Model/Cards/Building/EffectType.java

@@ -1,5 +1,5 @@
 package it.polimi.ingsw.gc14.Model.Cards.Building;
 
 public enum EffectType {
-    FINAL, CARD_SET,INVENTOR_PAIR, ON_EVENT , ON_END_TURN, ON_ROUND_END
+    FINAL, CARD_SET, INVENTOR_PAIR, ON_EVENT, ON_END_TURN, ON_ROUND_END
 }

src/main/java/it/polimi/ingsw/gc14/Model/Cards/Building/Effects/Building8.java

@@ -42,7 +42,7 @@ public class Building8 extends BuildingCard {
         if(!player.buildingCards.contains(this))
             throw new IllegalArgumentException();
         for (Builder builder : player.builders) {
-            player.addPrestige(builder.getPrestigeValue() * 2);
+            player.addPrestige(builder.getPrestigeValue());
         }
     }
 

src/main/java/it/polimi/ingsw/gc14/Model/Cards/BuildingCard.java

@@ -159,8 +159,16 @@ public class BuildingCard extends PlayableCard implements Cloneable , BuildingEf
      * @return {@code true} if the building card is successfully bought,
      *         {@code false} otherwise.
      */
+    // sum reduction value builder=> sconto
     public boolean buy(Player player) {
-        if( bought || !player.removeFood(getPrice()))
+        int discount = 0;
+        discount = player.builders.stream().mapToInt(x -> x.getReductionValue()).sum();
+
+        if(discount > this.price){
+            discount = this.price;
+        }
+
+        if(bought || !player.removeFood(this.price - discount))
             return false;
         player.buildingCards.add(this);
         bought=true;

src/main/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/CharacterType.java

@@ -1,5 +1,5 @@
 package it.polimi.ingsw.gc14.Model.Cards.TribeCards;
 
 public enum CharacterType {
-    INVENTOR,BUILDER, GATHERER,ARTIST,SHAMAN,HUNTER
+    INVENTOR, BUILDER, GATHERER, ARTIST, SHAMAN, HUNTER
 }

src/main/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/Hunter.java

@@ -98,6 +98,9 @@ public class Hunter extends Character {
     @Override
     public void insert(Player player) {
         player.hunters.add(this);
+        if(this.getIcon()){
+            player.addFood(player.hunters.size());
+        }
     }
 
 }

src/main/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/EventCard.java

@@ -62,7 +62,7 @@ public abstract class EventCard extends TribeCard {
      */
     @Override
     public String toString() {
-        return super.toString()+" "+type.toString();
+        return super.toString()+"(Event)"+type.toString();
     }
 
     /**
@@ -77,7 +77,7 @@ public abstract class EventCard extends TribeCard {
      */
     @Override
     public String toStringBoard() {
-        return super.toString()+" "+type.toString();
+        return super.toString()+"(Event)"+type.toString();
     }
 
     /**

src/main/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Events/Sustenance.java

@@ -43,7 +43,7 @@ public class Sustenance extends EventCard {
      * If the resulting Food debt is positive, the player must pay it with available Food.
      * If the player does not have enough Food, all remaining Food is removed and the player
      * loses Prestige equal to the unpaid Food debt multiplied by {@code PrestigeDebt}.
-     * This event is intended to be executed last among event effects.
+     * <b>This event is intended to be executed last among event effects.</b>
      *
      * @param playerList the list of players affected by the event.
      * @throws NullPointerException if {@code playerList} or one of its required elements is {@code null}.

src/main/java/it/polimi/ingsw/gc14/Model/DecksCreator.java

@@ -15,10 +15,19 @@ import java.io.*;
 import java.lang.reflect.Type;
 import java.util.*;
 
-//TODO javadoc
+/**
+ * Utility class responsible for loading and creating decks of cards and slots for the game.
+ * Cards are loaded from JSON resource files and instantiated according to their type and parameters.
+ */
 public class DecksCreator {
 
-    //TODO javadoc
+    /**
+     * Loads the tribe card deck for the specified era from the corresponding JSON resource file.
+     *
+     * @param era the era number (1, 2, or 3).
+     * @return a list of {@link TribeCard} objects for the specified era.
+     * @throws IllegalArgumentException if {@code era} is not 1, 2, or 3.
+     */
     public static List<TribeCard> loadTribeDeckByEra(int era) throws IllegalArgumentException
     {
         return switch (era) {
@@ -29,7 +38,13 @@ public class DecksCreator {
         };
     }
 
-    //TODO javadoc
+    /**
+     * Loads a tribe card deck from the specified JSON resource file path.
+     *
+     * @param resourcePath the path to the JSON resource file.
+     * @return a list of {@link TribeCard} objects defined in the resource file.
+     * @throws RuntimeException if the resource file is not found or an error occurs while reading it.
+     */
     public static List<TribeCard> loadTribeDeck(String resourcePath) {
         Gson gson = new Gson();
         Type listType = new com.google.gson.reflect.TypeToken<List<TribeCardDefinition>>(){}.getType();
@@ -51,14 +66,26 @@ public class DecksCreator {
         }
     }
 
-    //TODO javadoc
+    /**
-    public static  List<BuildingCard> loadBuildingDeckByEra(int era) throws IllegalArgumentException
+     * Loads the building card deck for the specified era, filtering cards from the global building deck.
+     *
+     * @param era the era number (1, 2, or 3).
+     * @return a list of {@link BuildingCard} objects belonging to the specified era.
+     * @throws IllegalArgumentException if {@code era} is not 1, 2, or 3.
+     */
+    public static List<BuildingCard> loadBuildingDeckByEra(int era) throws IllegalArgumentException
     {
         if(era<=0 || era>3) throw new IllegalArgumentException();
         return loadBuildingDeck("/Cards/buildingCards.json").stream().filter(x->x.getEra()==era).toList();
     }
 
-    //TODO javadoc
+    /**
+     * Loads the full building card deck from the specified JSON resource file path.
+     *
+     * @param resourcePath the path to the JSON resource file.
+     * @return a list of {@link BuildingCard} objects defined in the resource file.
+     * @throws RuntimeException if the resource file is not found or an error occurs while reading it.
+     */
     public static List<BuildingCard> loadBuildingDeck(String resourcePath) {
         Gson gson = new Gson();
         Type listType = new com.google.gson.reflect.TypeToken<List<BuildingCardDefinition>>(){}.getType();
@@ -80,7 +107,12 @@ public class DecksCreator {
         }
     }
 
-    //TODO javadoc
+    /**
+     * Creates and returns the list of slots used as the game board.
+     * Slots are labeled with the letters A through G.
+     *
+     * @return a list of {@link Slot} objects representing the game board.
+     */
     public static List<Slot> loadSlotDeck()
     {
         List<Slot> slots = new ArrayList<>();
@@ -90,7 +122,15 @@ public class DecksCreator {
         return slots;
     }
 
-    //TODO javadoc
+    /**
+     * Instantiates a {@link TribeCard} from the given definition.
+     * Depending on whether the card is an event or a character, the appropriate subclass is created
+     * using the type and parameters specified in the definition.
+     *
+     * @param def the {@link TribeCardDefinition} containing the card's type, era, and parameters.
+     * @return the instantiated {@link TribeCard}.
+     * @throws IllegalArgumentException if the card type is unknown or the parameters are invalid.
+     */
     private static TribeCard createCard(TribeCardDefinition def) {
         int era = def.era;
 
@@ -138,7 +178,14 @@ public class DecksCreator {
         };
     }
 
-    //TODO javadoc
+    /**
+     * Instantiates a {@link BuildingCard} from the given definition.
+     * The appropriate subclass is selected based on the effect ID specified in the definition.
+     * If no specific subclass matches the effect ID, a base {@link BuildingCard} is created.
+     *
+     * @param def the {@link BuildingCardDefinition} containing the card's effect ID, era, price, prestige value, and parameters.
+     * @return the instantiated {@link BuildingCard}.
+     */
     private static BuildingCard createCard(BuildingCardDefinition def) {
         return switch (def.effectId) {
             case 0 -> new Building0(def.era, def.price, def.prestigeValue);
@@ -153,7 +200,11 @@ public class DecksCreator {
 
     }
 
-    //TODO javadoc
+    /**
+     * Internal data class representing the raw definition of a tribe card as loaded from a JSON file.
+     * Contains the card type, era, whether it is armed, whether it is an event card,
+     * and a list of additional parameters.
+     */
     private static class TribeCardDefinition {
         String type;
         int era;
@@ -162,7 +213,10 @@ public class DecksCreator {
         List<Object> params; // Object per gestire boolean e int misti
     }
 
-    //TODO javadoc
+    /**
+     * Internal data class representing the raw definition of a building card as loaded from a JSON file.
+     * Contains the effect ID, era, price, prestige value, and a list of additional parameters.
+     */
     private static class BuildingCardDefinition {
         int effectId;
         int era;

src/main/java/it/polimi/ingsw/gc14/Model/Game.java

@@ -4,6 +4,9 @@ import it.polimi.ingsw.gc14.Model.Cards.Building.EffectType;
 import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCard;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Character;
+import it.polimi.ingsw.gc14.Model.Cards.TribeCards.CharacterType;
+import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Builder;
+import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Inventor;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.EventCard;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.EventType;
 import it.polimi.ingsw.gc14.Model.GamePackage.Board;
@@ -17,7 +20,8 @@ import it.polimi.ingsw.gc14.Model.GamePackage.GameStages;
 import java.io.Serializable;
 import java.util.*;
 import java.util.stream.Collectors;
-import it.polimi.ingsw.gc14.Network.Observer;
+import java.util.stream.Stream;
+
 import it.polimi.ingsw.gc14.View.TUI.AsciiTable;
 import it.polimi.ingsw.gc14.View.TUI.BorderStyle;
 
@@ -28,18 +32,6 @@ import it.polimi.ingsw.gc14.View.TUI.BorderStyle;
  */
 public class Game implements Serializable {
 
-    private transient List<Observer> observers = new ArrayList<>(); // transient! non serializzare
-
-    public void addObserver(Observer observer) {
-        observers.add(observer);
-    }
-
-    private void notifyObservers() {
-        for (Observer o : observers) {
-            o.update(this);
-        }
-    }
-
     /**
      * Returns the list of players participating in the game.
      * @return
@@ -49,7 +41,8 @@ public class Game implements Serializable {
     }
 
     /**
-     * The current number of players.
+     * Returns the current number of players participating in the game.
+     * @return the current number of players.
      */
     public int getCurrentPlayerNumber() {
         return playersList.size();
@@ -239,6 +232,16 @@ public class Game implements Serializable {
                 orderLogicCard=new Order5(playersList);
                 break;
         }
+        for(Player player : playersList)
+        {
+            switch(orderLogicCard.getPosition(player.getUserName()))
+            {
+                case 0: player.addFood(2); break;
+                case 1,2: player.addFood(3); break;
+                case 3,4: player.addFood(4); break;
+            }
+
+        }
         currentState.PlayerUpdate(orderLogicCard.pull(),null);
         currentState.GameStageUpdate(GameStages.SLOT_CHOICE);
     }
@@ -271,6 +274,10 @@ public class Game implements Serializable {
         {
             return false;
         }
+        if(slotPlayerEntry.getKey().getSlotId()=='A')
+        {
+            player.addFood(3);
+        }
         slotMap.put(slotPlayerEntry.getKey(),player);
         nextPlayerSetup();
         return true;
@@ -295,7 +302,7 @@ public class Game implements Serializable {
     public boolean DrawUpperTribeCardByIndex(Player player,int cardIndex) {
         if( cardIndex<0 || cardIndex >=board.upperListTribe.size())
             return false;
-        if(currentState.getGameStage()!= GameStages.RESOLVING_ACTIONS)
+        if(currentState.getGameStage()!= GameStages.RES_ACTIONS)
         {
             return false;
         }
@@ -318,6 +325,68 @@ public class Game implements Serializable {
         return true;
     }
 
+    /**
+     * Skips the upper card draw for the specified player when no drawable cards are available.
+     * The operation succeeds only if the current game stage is {@code RESOLVING_ACTIONS},
+     * the specified player is the current player, at least one upper draw is still available,
+     * and there are no drawable upper tribe cards (i.e. all remaining upper tribe cards are event cards)
+     * and no upper building cards that the player can afford.
+     * If successful, the upper draw counter is decremented.
+     * If both upper and lower draws become zero (or no cards remain drawable), the next player setup is triggered.
+     *
+     * @param player the player skipping the upper draw.
+     * @return {@code true} if the skip succeeds, {@code false} otherwise.
+     */
+    public boolean SkipUpperDrawing(Player player) {
+        if(currentState.getGameStage()!= GameStages.RES_ACTIONS)
+        {
+            return false;
+        }
+        if(!player.equals(currentState.getCurrentPlayer()))
+        {
+            return false;
+        }
+        if(currentState.getNUpper() <1)
+            return false;
+        if(hasDrawableUp())
+            return false;
+        currentState.UpperDrawn();
+        if((currentState.getNLower() ==0 ||( !hasDrawableDown() && getLowerListBuilding().isEmpty())) && ((currentState.getNUpper() ==0)||(getUpperListBuilding().isEmpty())))
+            nextPlayerSetup();
+        return true;
+    }
+
+    /**
+     * Skips the lower card draw for the specified player when no drawable cards are available.
+     * The operation succeeds only if the current game stage is {@code RESOLVING_ACTIONS},
+     * the specified player is the current player, at least one lower draw is still available,
+     * and there are no drawable lower tribe cards (i.e. all remaining lower tribe cards are event cards)
+     * and no lower building cards that the player can afford.
+     * If successful, the lower draw counter is decremented.
+     * If both upper and lower draws become zero (or no cards remain drawable), the next player setup is triggered.
+     *
+     * @param player the player skipping the lower draw.
+     * @return {@code true} if the skip succeeds, {@code false} otherwise.
+     */
+    public boolean SkipLowerDrawing(Player player) {
+        if(currentState.getGameStage()!= GameStages.RES_ACTIONS)
+        {
+            return false;
+        }
+        if(!player.equals(currentState.getCurrentPlayer()))
+        {
+            return false;
+        }
+        if(currentState.getNLower() <1)
+            return false;
+        if(hasDrawableDown())
+            return false;
+        currentState.LowerDrawn();
+        if((currentState.getNLower() ==0 ||( getLowerListBuilding().isEmpty())) && ((currentState.getNUpper() ==0)||(!hasDrawableUp()&&getUpperListBuilding().isEmpty())))
+            nextPlayerSetup();
+        return true;
+    }
+
     /**
      * Attempts to draw the lower tribe card at the specified index for the specified player.
      * The operation succeeds only if the index is valid, the game stage is {@code RESOLVING_ACTIONS},
@@ -334,7 +403,7 @@ public class Game implements Serializable {
     public boolean DrawLowerTribeCardByIndex(Player player, int cardIndex) {
         if( cardIndex<0 || cardIndex >=board.lowerListTribe.size())
             return false;
-        if(currentState.getGameStage()!= GameStages.RESOLVING_ACTIONS)
+        if(currentState.getGameStage()!= GameStages.RES_ACTIONS)
         {
             return false;
         }
@@ -375,7 +444,7 @@ public class Game implements Serializable {
     public boolean DrawUpperBuildingCardByIndex(Player player,int cardIndex) {
         if( cardIndex<0 || cardIndex >=board.upperListBuilding.size())
             return false;
-        if(currentState.getGameStage()!= GameStages.RESOLVING_ACTIONS)
+        if(currentState.getGameStage()!= GameStages.RES_ACTIONS)
         {
             return false;
         }
@@ -414,7 +483,7 @@ public class Game implements Serializable {
     public boolean DrawLowerBuildingCardByIndex(Player player,int cardIndex) {
         if( cardIndex<0 || cardIndex >=board.lowerListBuilding.size())
             return false;
-        if(currentState.getGameStage()!= GameStages.RESOLVING_ACTIONS)
+        if(currentState.getGameStage()!= GameStages.RES_ACTIONS)
         {
             return false;
         }
@@ -459,7 +528,7 @@ public class Game implements Serializable {
      * @return {@code true} if the operation succeeds, {@code false} otherwise.
      */
     public boolean PickOptionalTribeCardByIndex(Player player,int cardIndex) {
-        if(currentState.getGameStage() != GameStages.OPTIONAL_CARD_EFFECT){
+        if(currentState.getGameStage() != GameStages.OPT_CARD_E){
             return false;
         }
         if(!player.equals(currentState.getCurrentPlayer())){
@@ -494,7 +563,7 @@ public class Game implements Serializable {
      * @return {@code true} if the operation succeeds, {@code false} otherwise.
      */
     public boolean PickOptionalBuildingCard(Player player, int cardIndex) {
-        if(currentState.getGameStage() != GameStages.OPTIONAL_CARD_EFFECT){
+        if(currentState.getGameStage() != GameStages.OPT_CARD_E){
             return false;
         }
         if(!player.equals(currentState.getCurrentPlayer())){
@@ -526,7 +595,7 @@ public class Game implements Serializable {
      * @return {@code true} if the operation succeeds, {@code false} otherwise.
      */
     public boolean NoOptionalCard(Player player) {
-        if(currentState.getGameStage() != GameStages.OPTIONAL_CARD_EFFECT){
+        if(currentState.getGameStage() != GameStages.OPT_CARD_E){
             return false;
         }
         if(!player.equals(currentState.getCurrentPlayer())){
@@ -565,11 +634,11 @@ public class Game implements Serializable {
                 currentState.PlayerUpdate(tempPlayer, null);
                 return;
             }
-            currentState.GameStageUpdate(GameStages.RESOLVING_ACTIONS);
+            currentState.GameStageUpdate(GameStages.RES_ACTIONS);
             for (Slot s : slotMap.keySet()) {
                 if (slotMap.get(s) != null) {
                     currentState.PlayerUpdate(slotMap.get(s), s);
-                    if(!((currentState.getNLower() ==0 ||( getLowerListTribeCards().size()==0 && getLowerListBuilding().size()==0)) && ((currentState.getNUpper() ==0)||( getUpperListTribeCards().size()==0 && getUpperListBuilding().size()==0))))
+                    if(!((currentState.getNLower() ==0 ||(!hasDrawableDown() && getLowerListBuilding().size()==0)) && ((currentState.getNUpper() ==0)||(!hasDrawableUp() && getUpperListBuilding().size()==0))))
                         break;
                     else
                     {
@@ -581,13 +650,13 @@ public class Game implements Serializable {
             return;
 
         }
-        if(GameStages.RESOLVING_ACTIONS==currentState.getGameStage()) {
+        if(GameStages.RES_ACTIONS ==currentState.getGameStage()) {
             orderLogicCard.push(currentState.getCurrentPlayer());
             slotMap.put(currentState.getSlot(), null);
             for (Slot s : slotMap.keySet()) {
                 if (slotMap.get(s) != null) {
                     currentState.PlayerUpdate(slotMap.get(s), s);
-                    if((currentState.getNLower() ==0 ||( getLowerListTribeCards().size()==0 && getLowerListBuilding().size()==0)) && ((currentState.getNUpper() ==0)||( getUpperListTribeCards().size()==0 && getUpperListBuilding().size()==0))) {
+                    if((currentState.getNLower() ==0 ||(!hasDrawableDown() && getLowerListBuilding().size()==0)) && ((currentState.getNUpper() ==0)||( !hasDrawableUp() && getUpperListBuilding().size()==0))) {
                         orderLogicCard.push(currentState.getCurrentPlayer());
 
                         slotMap.put(currentState.getSlot(), null);
@@ -600,9 +669,9 @@ public class Game implements Serializable {
             }
             if(slotMap.values().stream().allMatch(v -> v == null))
             {
-                currentState.GameStageUpdate(GameStages.OPTIONAL_CARD_EFFECT);
+                currentState.GameStageUpdate(GameStages.OPT_CARD_E);
                 HashMap<Player,Integer> optional=new LinkedHashMap<>();
-                for (Player p : playersList) {
+                for (Player p : orderLogicCard.players) {
                     int tempCount=(int)p.buildingCards.stream().filter(x->x.getEffectId()==12).count();
                     if(tempCount>0)
                     {
@@ -621,14 +690,13 @@ public class Game implements Serializable {
                     return;
                 }
 
-                currentState.GameStageUpdate(GameStages.RESOLVING_EVENT);
+                currentState.GameStageUpdate(GameStages.RES_EVENT);
 
                 if (currentState.getRound() < 10) {
                     nextRound();
                     currentState.PlayerUpdate(orderLogicCard.pull(), null);
                     currentState.GameStageUpdate(GameStages.SLOT_CHOICE);
                 } else {
-                    EventResolution();
                     currentState.GameStageUpdate(GameStages.ENDING);
                     endGame();
                 }
@@ -637,7 +705,7 @@ public class Game implements Serializable {
                 }
             }
 
-        if (GameStages.OPTIONAL_CARD_EFFECT == currentState.getGameStage()) {
+        if (GameStages.OPT_CARD_E == currentState.getGameStage()) {
             Player optionalPlayer = OptionalCardQueue.poll();
 
             if (optionalPlayer != null) {
@@ -645,23 +713,48 @@ public class Game implements Serializable {
                 return;
             }
 
-            currentState.GameStageUpdate(GameStages.RESOLVING_EVENT);
+            currentState.GameStageUpdate(GameStages.RES_EVENT);
 
         if (currentState.getRound() < 10) {
             nextRound();
             currentState.PlayerUpdate(orderLogicCard.pull(), null);
             currentState.GameStageUpdate(GameStages.SLOT_CHOICE);
         } else {
-            EventResolution();
             currentState.GameStageUpdate(GameStages.ENDING);
             endGame();
         }
 
         return;
-
+/**
+ * Checks whether there are any drawable lower tribe cards on the board,
+ * i.e. lower tribe cards that are not event cards.
+ *
+ * @return {@code true} if at least one non-event lower tribe card is available, {@code false} otherwise.
+ */
         }
     }
 
+    /**
+     * Checks whether there are any drawable upper tribe cards on the board,
+     * i.e. upper tribe cards that are not event cards.
+     *
+     * @return {@code true} if at least one non-event upper tribe card is available, {@code false} otherwise.
+     */
+    private boolean hasDrawableUp()
+    {
+        return getUpperListTribeCards().stream().filter(x-> !x.IsEventCard()).count()!=0;
+    }
+
+    /**
+     * Checks whether there are any drawable lower tribe cards on the board,
+     * i.e. lower tribe cards that are not event cards.
+     *
+     * @return {@code true} if at least one non-event lower tribe card is available, {@code false} otherwise.
+     */
+    private boolean hasDrawableDown()
+    {
+        return getLowerListTribeCards().stream().filter(x-> !x.IsEventCard()).count()!=0;
+    }
     /**
      * Resolves all pending event cards if the current game stage is {@code RESOLVING_EVENT}.
      * All pending events are activated on the player list.
@@ -669,7 +762,7 @@ public class Game implements Serializable {
      */
     private void EventResolution() {
 
-        if(currentState.getGameStage()!= GameStages.RESOLVING_EVENT)
+        if(currentState.getGameStage()!= GameStages.RES_EVENT)
         {
             return;
         }
@@ -719,6 +812,28 @@ public class Game implements Serializable {
      * and updating the game stage to {@code ENDED}.
      */
     private void endGame() {
+        Queue<EventCard> events;
+        events=Stream.concat(board.lowerListTribe.stream().filter(TribeCard::IsEventCard),board.upperListTribe.stream().filter(TribeCard::IsEventCard)).map(x->((EventCard)x)).collect(Collectors.toCollection(LinkedList::new));
+        ArrayList<EventCard>sustenance=events.stream().filter(x->x.getType().equals(EventType.SUSTENANCE)).collect(Collectors.toCollection(ArrayList::new));
+        events.removeAll(sustenance);
+        events.forEach(event->event.activateEvent(playersList));
+        sustenance.forEach(event->event.activateEvent(playersList));
+
+        playersList.forEach(p->{
+            int temp= p.builders.stream().mapToInt(Builder::getPrestigeValue).sum();
+            p.addPrestige(temp);
+        });
+        playersList.forEach(p->{
+            int temp=(int) p.inventors.stream().mapToInt(Inventor::Icon).distinct().count();
+            p.addPrestige(temp*p.getNType(CharacterType.INVENTOR));
+        });
+        playersList.forEach(p->{
+            p.addPrestige(10 * (p.getNType(CharacterType.ARTIST)/2));
+        });
+        playersList.forEach(p->{
+            int temp= p.buildingCards.stream().mapToInt(BuildingCard::getPrestigeValue).sum();
+            p.addPrestige(temp);
+        });
         playersList.forEach(
             p -> p.buildingCards.stream().filter(x -> x.getEffectType() == EffectType.FINAL).
             forEach(x -> x.applyEffect(p))
@@ -772,6 +887,14 @@ public class Game implements Serializable {
     public String toString() {
         return PlayersStamp()+"\n"+BoardStamp()+"\n";
     }
+
+    /**
+     * Returns a string representation of all the players currently in the game,
+     * arranged side by side in pairs.
+     * If the number of players is odd, the last player is printed on its own line.
+     *
+     * @return {@code String} - a string representation of all the players.
+     */
     public String PlayersStamp()
     {
         StringBuilder stringBuilder=new StringBuilder();
@@ -787,15 +910,24 @@ public class Game implements Serializable {
         }
         return stringBuilder.toString();
     }
+
+    /**
+     * Returns a string representation of the board, including the current state,
+     * the offer track with slot assignments, the upper and lower tribe card lists,
+     * and the upper and lower building card lists.
+     *
+     * @return {@code String} - a string representation of the board.
+     */
     public String BoardStamp()
     {
         var offerTrack = new AsciiTable(BorderStyle.UNICODE, slotMap.size());
         List<String> stringUpOffer=new ArrayList<>();
         List<String> stringDownOffer=new ArrayList<>();
 
+        int index=0;
         for(Map.Entry<Slot,Player> entry:slotMap.entrySet())
         {
-            stringDownOffer.add(entry.getKey().toStringTUI());
+            stringDownOffer.add((index++)+"."+entry.getKey().toStringTUI());
             if(entry.getValue()!=null)
                 stringUpOffer.add(entry.getValue().getUserName());
             else
@@ -813,11 +945,11 @@ public class Game implements Serializable {
         {
             if(i<getUpperListTribeCards().size())
             {
-                stringUpperListTribe.add(getUpperListTribeCards().get(i).toStringBoard());
+                stringUpperListTribe.add(i+"-"+getUpperListTribeCards().get(i).toStringBoard());
             }
             if(i<getLowerListTribeCards().size())
             {
-                stringLowerListTribe.add(getLowerListTribeCards().get(i).toStringBoard());
+                stringLowerListTribe.add(i+"-"+getLowerListTribeCards().get(i).toStringBoard());
             }
         }
         var BuildTableUpper = new AsciiTable(BorderStyle.UNICODE,1);
@@ -829,11 +961,11 @@ public class Game implements Serializable {
         {
             if(i<getUpperListBuilding().size())
             {
-                BuildTableUpper.addRow(getUpperListBuilding().get(i).toString());
+                BuildTableUpper.addRow(i+"-"+getUpperListBuilding().get(i).toString());
             }
             if(i<getLowerListBuilding().size())
             {
-                BuildTableLower.addRow(getLowerListBuilding().get(i).toString());
+                BuildTableLower.addRow(i+"-"+getLowerListBuilding().get(i).toString());
             }
         }
         stringUpperListTribe.forEach(x->TribeTableUpper.addRow(x));

src/main/java/it/polimi/ingsw/gc14/Model/GamePackage/Board.java

@@ -41,6 +41,8 @@ public class Board implements Serializable {
     /** Contains all the building cards of the upper list. When a new era starts, the old era's buildings are moved from the upper to the lower list */
     public List<BuildingCard> lowerListBuilding;
 
+
+    private final ArrayList<List<BuildingCard>> buildingCardsAllEras;
     /** Number of players */
     private int nTotem;
 
@@ -88,6 +90,7 @@ public class Board implements Serializable {
         tribeDeck=generateTribeDeck(nTotem);
         era=1;
 
+
         for(int i=0;i<nTotem+1;i++)
         {
             TribeCard tempCard = tribeDeck.remove();
@@ -110,10 +113,44 @@ public class Board implements Serializable {
 
         ArrayList<BuildingCard> buildingDeck = new ArrayList<>(DecksCreator.loadBuildingDeckByEra(1));
         Collections.shuffle(buildingDeck);
+        buildingCardsAllEras= new ArrayList<>();
+        buildingCardsAllEras.add(new ArrayList<>());
+        buildingCardsAllEras.add(new ArrayList<>());
+        buildingCardsAllEras.add(new ArrayList<>());
         if(nTotem==2)
+        {
+            buildingCardsAllEras.set(0, new ArrayList<>(buildingDeck.subList(0, 1)));
             upperListBuilding = new ArrayList<>(buildingDeck.subList(0,1));
+        }
         else
+        {
+            buildingCardsAllEras.set(0, new ArrayList<>(buildingDeck.subList(0, 2)));
             upperListBuilding = new ArrayList<>(buildingDeck.subList(0,2));
+        }
+
+        buildingDeck=new ArrayList<>(DecksCreator.loadBuildingDeckByEra(2));
+        Collections.shuffle(buildingDeck);
+        if(nTotem<=3)
+        {
+            buildingCardsAllEras.set(1, new ArrayList<BuildingCard>(buildingDeck.subList(0, 2)));
+        }
+        else
+        {
+            buildingCardsAllEras.set(1, new ArrayList<BuildingCard>(buildingDeck.subList(0, 3)));
+        }
+        buildingDeck=new ArrayList<>(DecksCreator.loadBuildingDeckByEra(3));
+        Collections.shuffle(buildingDeck);
+        if(nTotem==2)
+        {
+            buildingCardsAllEras.set(2, new ArrayList<BuildingCard>(buildingDeck.subList(0, 3)));
+        }else if(nTotem==5)
+        {
+            buildingCardsAllEras.set(2, new ArrayList<BuildingCard>(buildingDeck.subList(0, 5)));
+        }
+        else {
+            buildingCardsAllEras.set(2, new ArrayList<BuildingCard>(buildingDeck.subList(0, 4)));
+        }
+
     }
 
     /**
@@ -230,27 +267,11 @@ public class Board implements Serializable {
         Collections.shuffle(buildingCards);
         if(era==2)
         {
-            if(nTotem<=3)
+            upperListBuilding.addAll(buildingCardsAllEras.get(1));
-            {
-                upperListBuilding.addAll(buildingCards.subList(0,2));
-            }
-            else
-            {
-                upperListBuilding.addAll( buildingCards.subList(0,3));
-            }
         }
-        else    // Era 3
+        else
         {
-            if(nTotem==2)
+            upperListBuilding.addAll(buildingCardsAllEras.get(2));
-            {
-                upperListBuilding.addAll( buildingCards.subList(0,3));
-            }else if(nTotem==5)
-            {
-                upperListBuilding.addAll( buildingCards.subList(0,5));
-            }
-            else {
-                upperListBuilding.addAll(buildingCards.subList(0,4));
-            }
         }
     }
 }

src/main/java/it/polimi/ingsw/gc14/Model/GamePackage/GameStages.java

@@ -1,5 +1,5 @@
 package it.polimi.ingsw.gc14.Model.GamePackage;
 
 public enum GameStages {
-    WAITING,SLOT_CHOICE, RESOLVING_ACTIONS, OPTIONAL_CARD_EFFECT, RESOLVING_EVENT,ENDING,ENDED
+    WAITING, SLOT_CHOICE, RES_ACTIONS, OPT_CARD_E, RES_EVENT, ENDING, ENDED
 }

src/main/java/it/polimi/ingsw/gc14/Model/Orders/Order2.java

@@ -52,30 +52,29 @@ public class Order2 extends OrderLogicCard  {
             }
         }
     }
+
+    /**
+     * Creates the TURN ORDER box of the TUI.
+     * @return the string containing the box
+     */
     @Override
     public String toString()
     {
-
         var table = new AsciiTable(BorderStyle.UNICODE, 2);
         List<String> stringUp=new ArrayList<>();
-        List<String> stringDown=new ArrayList<>();
         for(int i=0;i<2;i++)
         {
             try {
-                playerList.get(i);
-                stringUp.add(i+". "+playerList.get(i).player.getUserName());
                 if(playerList.get(i).played)
-                    stringDown.add("   Placed");
+                    stringUp.add(" ");
                 else
-                    stringDown.add("   Not Placed");
+                    stringUp.add(i+". "+playerList.get(i).player.getUserName());
             }
             catch (IndexOutOfBoundsException e) {
                 stringUp.add("");
-                stringDown.add("");
             }
         }
         table.addRow(stringUp);
-        table.addRow(stringDown);
 
         List<String> stringList=new ArrayList<>();
         stringList.add("+1 Food");

src/main/java/it/polimi/ingsw/gc14/Model/Orders/Order3.java

@@ -53,6 +53,11 @@ public class Order3 extends OrderLogicCard {
             }
         }
     }
+
+    /**
+     * Creates the TURN ORDER box of the TUI.
+     * @return the string containing the box
+     */
     @Override
     public String toString()
     {
@@ -60,24 +65,19 @@ public class Order3 extends OrderLogicCard {
         var table = new AsciiTable(BorderStyle.UNICODE, 3);
 
         List<String> stringUp=new ArrayList<>();
-        List<String> stringDown=new ArrayList<>();
         for(int i=0;i<3;i++)
         {
             try {
-                playerList.get(i);
-                stringUp.add(i+". "+playerList.get(i).player.getUserName());
                 if(playerList.get(i).played)
-                    stringDown.add("   Placed");
+                    stringUp.add(" ");
                 else
-                    stringDown.add("   Not Placed");
+                    stringUp.add(i+". "+playerList.get(i).player.getUserName());
             }
             catch (IndexOutOfBoundsException e) {
                 stringUp.add("");
-                stringDown.add("");
             }
         }
         table.addRow(stringUp);
-        table.addRow(stringDown);
 
         List<String> stringList=new ArrayList<>();
 

src/main/java/it/polimi/ingsw/gc14/Model/Orders/Order4.java

@@ -60,30 +60,30 @@ public class Order4 extends OrderLogicCard {
             }
         }
     }
+
+    /**
+     * Creates the TURN ORDER box of the TUI.
+     * @return the string containing the box
+     */
     @Override
     public String toString()
     {
 
         var table = new AsciiTable(BorderStyle.UNICODE, 4);
         List<String> stringUp=new ArrayList<>();
-        List<String> stringDown=new ArrayList<>();
         for(int i=0;i<4;i++)
         {
             try {
-                playerList.get(i);
-                stringUp.add(i+". "+playerList.get(i).player.getUserName());
                 if(playerList.get(i).played)
-                    stringDown.add("   Placed");
+                    stringUp.add(" ");
                 else
-                    stringDown.add("   Not Placed");
+                    stringUp.add(i+". "+playerList.get(i).player.getUserName());
             }
             catch (IndexOutOfBoundsException e) {
                 stringUp.add("");
-                stringDown.add("");
             }
         }
         table.addRow(stringUp);
-        table.addRow(stringDown);
 
         List<String> stringList=new ArrayList<>();
         stringList.add("+2 Food");

src/main/java/it/polimi/ingsw/gc14/Model/Orders/Order5.java

@@ -61,30 +61,30 @@ public class Order5 extends OrderLogicCard {
             }
         }
     }
+
+    /**
+     * Creates the TURN ORDER box of the TUI.
+     * @return the string containing the box
+     */
     @Override
     public String toString()
     {
 
         var table = new AsciiTable(BorderStyle.UNICODE, 5);
         List<String> stringUp=new ArrayList<>();
-        List<String> stringDown=new ArrayList<>();
         for(int i=0;i<5;i++)
         {
             try {
-                playerList.get(i);
-                stringUp.add(i+". "+playerList.get(i).player.getUserName());
                 if(playerList.get(i).played)
-                    stringDown.add("   Placed");
+                    stringUp.add(" ");
                 else
-                    stringDown.add("   Not Placed");
+                    stringUp.add(i+". "+playerList.get(i).player.getUserName());
             }
             catch (IndexOutOfBoundsException e) {
                 stringUp.add("");
-                stringDown.add("");
             }
         }
         table.addRow(stringUp);
-        table.addRow(stringDown);
 
         List<String> stringList=new ArrayList<>();
         stringList.add("+3 Food");

src/main/java/it/polimi/ingsw/gc14/Model/Orders/OrderPlayer.java

@@ -17,6 +17,10 @@ public class OrderPlayer implements Serializable {
         this.player=player;
         this.played=played;
     }
+
+    /**
+     * @return the string containing the username and whether it played or not.
+     */
     @Override
     public String toString() {
         return player.getUserName()+" "+played;

src/main/java/it/polimi/ingsw/gc14/Model/Slot.java

@@ -172,7 +172,7 @@ public class Slot implements Serializable {
     public String toStringTUI()
     {
         StringBuilder  s = new StringBuilder();
-        s.append(this.getSlotId()+" ");
+        //s.append(this.getSlotId()+" ");
         for(int i=0;i<this.getNUpper();i++)
         {
             s.append("↑");

src/main/java/it/polimi/ingsw/gc14/Network/EventType.java

@@ -8,5 +8,8 @@ public enum EventType {
     DRAW_UPPER_BUILD,
     DRAW_LOWER_BUILD,
     PICK_OPTIONAL_TRIBE,
-    PICK_OPTIONAL_BUILD
+    PICK_OPTIONAL_BUILD,
+    SKIP_UPPER,
+    SKIP_LOWER,
+    NO_OPTIONAL_CARD
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvent.java

@@ -4,39 +4,60 @@ import it.polimi.ingsw.gc14.Controller.GameController;
 
 import java.io.Serializable;
 
-//TODO javadoc
+/**
+ * Represents an event sent over the network
+ */
 public abstract class NetworkEvent implements Serializable {
-    //TODO javadoc
+    /** Username of the player requesting the event */
     protected String username;
 
-    //TODO javadoc
+    /**
+     * @return the username of the player requesting the event
+     */
     public String getUsername() {
         return username;
     }
 
-    //TODO javadoc
+    /** EventType of the event */
     protected EventType eventType;
 
-    //TODO javadoc
+    /**
+     * @return the type of the event
+     */
     public EventType getEventType() {return eventType;}
 
-    //TODO javadoc
+    /** Flag signaling whether the event could not be applied to the server model */
     protected boolean isError;
 
-    //TODO javadoc
+    /**
+     * @return the flag signaling whether the event could be applied to the server model
+     */
     public boolean getIsError() {return isError;}
 
-    //TODO javadoc
+    /**
+     * Set the isError flag.
+     * @param isError the value to set
+     */
     public void setIsError(boolean isError) {this.isError = isError;}
 
-    //TODO javadoc
+
+    /**
+     * Class constructor.
+     * Initializes all attributes.
+     * @param username the username of the player requesting the event
+     * @param eventType the type of the event
+     * @param isError the flag signaling if the event could be applied to the server model
+     */
     protected NetworkEvent(String username, EventType eventType, boolean isError) {
         this.username = username;
         this.eventType = eventType;
         this.isError = isError;
     }
 
-    //TODO javadoc
+
+    /**
+     * @return a string describing the name of the event and whether it is an error or not
+     */
     @Override
     public String toString() {
         if(isError) {
@@ -46,6 +67,10 @@ public abstract class NetworkEvent implements Serializable {
         }
     }
 
-    //TODO javadoc
+    /**
+     * The method to apply the current event to the specified Game Controller.
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the event could be applied; false otherwise
+     */
     public abstract boolean apply(GameController gameController);
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/AddPlayer.java

@@ -7,30 +7,38 @@ import it.polimi.ingsw.gc14.View.IView;
 
 import java.io.Serializable;
 
-//TODO javadoc
+/**
+ * NetworkEvent to add a player.
+ */
 public class AddPlayer extends NetworkEvent implements  Serializable {
-    //TODO javadoc
+    /** Number of proposed players to add to the match */
     private int proposedNPlayer;
 
-    //TODO javadoc
+    /**
+     * @return the number of proposed players to add to the match
+     */
     public int getProposedNPlayer() {
         return proposedNPlayer;
     }
 
-    //TODO javadoc
+    /**
+     * Class constructor.
+     * Initializes all the attributes.
+     * @param username the name of the player requesting the event
+     * @param proposedNPlayer the number of proposed players to add to the match
+     */
     public AddPlayer(String username, int proposedNPlayer) {
         super(username, EventType.ADD_PLAYER, false);
         this.proposedNPlayer = proposedNPlayer;
     }
 
-    //TODO javadoc
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could be added to the match, false otherwise
+     */
     @Override
     public boolean apply(GameController gameController)
     {
         return gameController.addPlayer(username);
     }
-    public String apply(IView gameController)
-    {
-        return gameController.toString();
-    }
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/DrawLowerBuildingCard.java

@@ -7,25 +7,31 @@ import it.polimi.ingsw.gc14.View.IView;
 
 import java.io.Serializable;
 
-//TODO javadoc
+/**
+ * NetworkEvent to draw a building card from the lower card list.
+ */
 public class DrawLowerBuildingCard extends NetworkEvent implements  Serializable{
-    //TODO javadoc
+    /** Index of the card to draw */
     private int pos;
 
-    //TODO javadoc
+    /**
+     * Class constructor.
+     * Initialized all the attributes.
+     * @param username the name of the player requesting the event
+     * @param pos the index of the card to draw
+     */
     public DrawLowerBuildingCard(String username, int pos){
         super(username, EventType.DRAW_LOWER_BUILD, false);
         this.pos = pos;
     }
 
-    //TODO javadoc
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
     @Override
     public boolean apply(GameController gameController){
         return gameController.drawLowerBuildingCard(username, pos);
     }
 
-    //TODO javadoc
-    public String apply(IView gameController){
-        return gameController.toString();
-    }
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/DrawLowerTribeCard.java

@@ -7,24 +7,32 @@ import it.polimi.ingsw.gc14.View.IView;
 
 import java.io.Serializable;
 
+/**
+ * NetworkEvent to draw a tribe card from the lower card list.
+ */
 public class DrawLowerTribeCard extends NetworkEvent implements  Serializable{
-    //TODO javadoc
+
+    /** Index of the card to draw */
     private int pos;
 
-    //TODO javadoc
+    /**
+     * Class constructor.
+     * Initialized all the attributes.
+     * @param username the name of the player requesting the event
+     * @param pos the index of the card to draw
+     */
     public DrawLowerTribeCard(String username, int pos){
         super(username, EventType.DRAW_LOWER_TRIBE, false);
         this.pos = pos;
     }
 
-    //TODO javadoc
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
     @Override
     public boolean apply(GameController gameController){
         return gameController.drawLowerTribeCard(username, pos);
     }
 
-    //TODO javadoc
-    public String apply(IView gameController){
-        return gameController.toString();
-    }
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/DrawUpperBuildingCard.java

@@ -7,25 +7,32 @@ import it.polimi.ingsw.gc14.View.IView;
 
 import java.io.Serializable;
 
-//TODO javadoc
+/**
+ * NetworkEvent to draw a building card from the upper card list.
+ */
 public class DrawUpperBuildingCard extends NetworkEvent implements  Serializable{
-    //TODO javadoc
+
+    /** Index of the card to draw */
     private int pos;
 
-    //TODO javadoc
+    /**
+     * Class constructor.
+     * Initialized all the attributes.
+     * @param username the name of the player requesting the event
+     * @param pos the index of the card to draw
+     */
     public DrawUpperBuildingCard(String username, int pos){
         super(username, EventType.DRAW_UPPER_BUILD, false);
         this.pos = pos;
     }
 
-    //TODO javadoc
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
     @Override
     public boolean apply(GameController gameController){
         return gameController.drawUpperBuildingCard(username, pos);
     }
 
-    //TODO javadoc
-    public String apply(IView gameController){
-        return gameController.toString();
-    }
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/DrawUpperTribeCard.java

@@ -7,25 +7,33 @@ import it.polimi.ingsw.gc14.View.IView;
 
 import java.io.Serializable;
 
-//TODO javadoc
+/**
+ * NetworkEvent to draw a tribe card from the upper card list.
+ */
 public class DrawUpperTribeCard extends NetworkEvent implements  Serializable{
-    //TODO javadoc
+
+    /** Index of the card to draw */
     private int pos;
 
-    //TODO javadoc
+    /**
+     * Class constructor.
+     * Initialized all the attributes.
+     * @param username the name of the player requesting the event
+     * @param pos the index of the card to draw
+     */
     public DrawUpperTribeCard(String username, int pos){
         super(username, EventType.DRAW_UPPER_TRIBE, false);
         this.pos = pos;
     }
 
-    //TODO javadoc
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
     @Override
     public boolean apply(GameController gameController){
         return gameController.drawUpperTribeCard(username, pos);
     }
 
-    //TODO javadoc
+
-    public String apply(IView gameController){
-        return gameController.toString();
-    }
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/NoOptionalCard.java

@@ -0,0 +1,32 @@
+package it.polimi.ingsw.gc14.Network.NetworkEvents;
+
+import it.polimi.ingsw.gc14.Controller.GameController;
+import it.polimi.ingsw.gc14.Network.EventType;
+import it.polimi.ingsw.gc14.Network.NetworkEvent;
+import it.polimi.ingsw.gc14.View.IView;
+
+import java.io.Serializable;
+
+/**
+ * NetworkEvent to avoid drawing a card from the upper list (see the effect of Building 12)
+ */
+public class NoOptionalCard extends NetworkEvent implements  Serializable{
+
+    /**
+     * Class constructor.
+     * Initialized all the attributes.
+     * @param username the name of the player requesting the event
+     */
+    public NoOptionalCard(String username){
+        super(username, EventType.NO_OPTIONAL_CARD, false);
+    }
+
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
+    @Override
+    public boolean apply(GameController gameController){
+        return gameController.noOptionalCard(username);
+    }
+}

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/PickOptionalBuildingCard.java

@@ -7,25 +7,31 @@ import it.polimi.ingsw.gc14.View.IView;
 
 import java.io.Serializable;
 
-//TODO javadoc
+/**
+ * NetworkEvent to draw a building card from the upper list (see the effect of Building 12)
+ */
 public class PickOptionalBuildingCard extends NetworkEvent implements  Serializable{
-    //TODO javadoc
+
+    /** Index of the card to draw */
     private int pos;
 
-    //TODO javadoc
+    /**
+     * Class constructor.
+     * Initialized all the attributes.
+     * @param username the name of the player requesting the event
+     * @param pos the index of the card to draw
+     */
     public PickOptionalBuildingCard(String username, int pos){
         super(username, EventType.PICK_OPTIONAL_BUILD, false);
         this.pos = pos;
     }
 
-    //TODO javadoc
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
     @Override
     public boolean apply(GameController gameController){
         return gameController.pickOptionalBuildingCard(username, pos);
     }
-
-    //TODO javadoc
-    public String apply(IView gameController){
-        return gameController.toString();
-    }
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/PickOptionalTribeCard.java

@@ -7,26 +7,32 @@ import it.polimi.ingsw.gc14.View.IView;
 
 import java.io.Serializable;
 
-//TODO javadoc
+/**
-
+ * NetworkEvent to draw a tribe card from the upper list (see the effect of Building 12)
+ */
 public class PickOptionalTribeCard extends NetworkEvent implements  Serializable{
-    //TODO javadoc
+
+    /** Index of the card to draw */
     private int pos;
 
-    //TODO javadoc
+    /**
+     * Class constructor.
+     * Initialized all the attributes.
+     * @param username the name of the player requesting the event
+     * @param pos the index of the card to draw
+     */
     public PickOptionalTribeCard(String username, int pos){
         super(username, EventType.PICK_OPTIONAL_TRIBE, false);
         this.pos = pos;
     }
 
-    //TODO javadoc
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
     @Override
     public boolean apply(GameController gameController){
         return gameController.pickOptionalTribeCard(username, pos);
     }
 
-    //TODO javadoc
-    public String apply(IView gameController){
-        return gameController.toString();
-    }
 }

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/SkipLower.java

@@ -0,0 +1,33 @@
+package it.polimi.ingsw.gc14.Network.NetworkEvents;
+
+import it.polimi.ingsw.gc14.Controller.GameController;
+import it.polimi.ingsw.gc14.Network.EventType;
+import it.polimi.ingsw.gc14.Network.NetworkEvent;
+import it.polimi.ingsw.gc14.View.IView;
+
+import java.io.Serializable;
+
+/**
+ * NetworkEvent to avoid drawing a card from the lower card list
+ */
+public class SkipLower extends NetworkEvent implements  Serializable{
+
+    /**
+     * Class constructor.
+     * Initializes all the attributes.
+     * @param username the name of the player requesting the event
+     */
+    public SkipLower(String username){
+        super(username, EventType.SKIP_LOWER, false);
+    }
+
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
+    @Override
+    public boolean apply(GameController gameController){
+        return gameController.SkipLowerDrawing(username);
+    }
+
+}

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/SkipUpper.java

@@ -0,0 +1,33 @@
+package it.polimi.ingsw.gc14.Network.NetworkEvents;
+
+import it.polimi.ingsw.gc14.Controller.GameController;
+import it.polimi.ingsw.gc14.Network.EventType;
+import it.polimi.ingsw.gc14.Network.NetworkEvent;
+import it.polimi.ingsw.gc14.View.IView;
+
+import java.io.Serializable;
+
+/**
+ * NetworkEvent to avoid drawing a card from the upper card list
+ */
+public class SkipUpper extends NetworkEvent implements  Serializable{
+
+    /**
+     * Class constructor.
+     * Initializes all the attributes.
+     * @param username the name of the player requesting the event
+     */
+    public SkipUpper(String username){
+        super(username, EventType.SKIP_UPPER, false);
+    }
+
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
+    @Override
+    public boolean apply(GameController gameController){
+        return gameController.SkipUpperDrawing(username);
+    }
+
+}

src/main/java/it/polimi/ingsw/gc14/Network/NetworkEvents/SlotChoice.java

@@ -7,25 +7,32 @@ import it.polimi.ingsw.gc14.View.IView;
 
 import java.io.Serializable;
 
-//TODO javadoc
+/**
+ * NetworkEvent to select a slot where to place the player totem.
+ */
 public class SlotChoice extends NetworkEvent implements  Serializable {
-    //TODO javadoc
+
+    /** Index of the card to draw */
     private int pos;
 
-    //TODO javadoc
+    /**
+     * Class constructor.
+     * Initializes all the attributes.
+     * @param username the name of the player requesting the event
+     * @param pos the index of the card to draw
+     */
     public SlotChoice(String username, int pos) {
         super(username, EventType.SLOT_CHOICE, false);
         this.pos = pos;
     }
 
-    //TODO javadoc
+    /**
+     * @param gameController the Game Controller on which to apply the event
+     * @return true if the player could draw the card, false otherwise
+     */
     @Override
     public boolean apply(GameController gameController) {
         return gameController.slotChoice(username, pos);
     }
 
-    //TODO javadoc
-    public String apply(IView gameController) {
-        return gameController.toString();
-    }
 }

src/main/java/it/polimi/ingsw/gc14/Network/Observer.java

@@ -1,7 +0,0 @@
-package it.polimi.ingsw.gc14.Network;
-
-import it.polimi.ingsw.gc14.Model.Game;
-
-public interface Observer {
-    public void update(Game model);
-}

src/main/java/it/polimi/ingsw/gc14/Network/RMI/Client/RMIClient.java

@@ -8,6 +8,7 @@ import it.polimi.ingsw.gc14.Network.IClient;
 import it.polimi.ingsw.gc14.Network.NetworkEvent;
 import it.polimi.ingsw.gc14.Network.RMI.Common.IClientCallback;
 import it.polimi.ingsw.gc14.Network.RMI.Common.IGameServer;
+import it.polimi.ingsw.gc14.Network.RMI.Server.RMIServer;
 
 /**
  * Client RMI. Uses the methods exposed by the server RMI.
@@ -39,7 +40,7 @@ public class RMIClient  implements IClient {
         this.port = port;
     }
 
-    //TODO Javadoc fix
+
     /**
      * Connects to the RMI server and attempts to join the game.
      * Looks up the RMI registry to retrieve the {@link IGameServer} stub.

src/main/java/it/polimi/ingsw/gc14/Network/RMI/Server/RMIServer.java

@@ -90,6 +90,7 @@ public class RMIServer extends UnicastRemoteObject implements IGameServer {
             if (controller.addPlayer(username)) {
                 clients.put(username, callback);
                 playerList.add(username);
+                System.out.println("Accepted player: " + username);
                 return true;
             }
             return false;

src/main/java/it/polimi/ingsw/gc14/Network/TCP/Client/TCPClient.java

@@ -87,7 +87,14 @@ public class TCPClient implements IClient {
     private void receiveMessage() {
         while (true) {
             try {
-                Object read = socketReceive.readObject();
+                Object read;
+                try {
+                    read = socketReceive.readObject();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    break;
+                }
+
                 if (read instanceof NetworkEvent event) {    //TODO: avoid instanceof
                     if (event.getIsError()) {
                         System.out.println(event);
@@ -99,10 +106,9 @@ public class TCPClient implements IClient {
                     controller.setModel(model);
                     controller.view.render();
                 }
-            } catch (IOException e) {
-                e.printStackTrace();
             } catch (ClassNotFoundException e) {
-                throw new RuntimeException(e);
+                e.printStackTrace();
+                break;
             }
         }
     }

src/main/java/it/polimi/ingsw/gc14/ServerLauncher.java

@@ -7,6 +7,7 @@ import it.polimi.ingsw.gc14.Network.NetworkEvent;
 import it.polimi.ingsw.gc14.Network.NetworkEvents.AddPlayer;
 import it.polimi.ingsw.gc14.Network.RMI.Server.RMIServer;
 import it.polimi.ingsw.gc14.Network.TCP.Server.TCPServer;
+import it.polimi.ingsw.gc14.View.TUI.TUI;
 
 import java.rmi.RemoteException;
 import java.util.concurrent.BlockingQueue;
@@ -56,6 +57,8 @@ public class ServerLauncher {
      */
     static LimitedList<String> playerList;
 
+    TUI view;
+
 
     /**
      * Class constructor that initializes the attributes.
@@ -137,11 +140,14 @@ public class ServerLauncher {
         System.out.println("\n\nNotifying model");
         serverRMI.notifyAll(gameController.getModel());
         serverTCP.notifyAll(gameController.getModel());
+        this.view = new TUI(gameController.getModel());
+        this.view.fullRender();
 
         // Game execution
         while (true) {
             try {
                 this.doFirstEvent();
+                this.view.fullRender();
             } catch (InterruptedException e) {
                 Thread.currentThread().interrupt();
                 break;

src/main/java/it/polimi/ingsw/gc14/View/TUI/AsciiTable.java

@@ -29,7 +29,6 @@ public class AsciiTable {
 
     //TODO javadoc
     public void addHeader(String... cells) { rows.add(0, Arrays.asList(cells)); separators.add(0); }
-    public void addSeparator() { separators.add(rows.size()-1); }
 
     //TODO javadoc
     public void addSeparator() { separators.add(rows.size()-1); }

src/main/java/it/polimi/ingsw/gc14/View/TUI/BorderStyle.java

@@ -1,9 +1,11 @@
 package it.polimi.ingsw.gc14.View.TUI;
 
 public enum BorderStyle {
-    UNICODE("╔","╗","╚","╝","═","║","╠","╣","╦","╩","╬","├","┤","─","┼"),
+
-    ASCII  ("+","+","+","+","-","|","+","+","+","+","+","+","+","-","+"),
+    //UNICODE("╔","╗","╚","╝","═","║","╠","╣","╦","╩","╬","├","┤","─","┼"),
-    ROUNDED("╭","╮","╰","╯","─","│","├","┤","┬","┴","┼","├","┤","─","┼");
+    UNICODE  ("+","+","+","+","-","|","+","+","+","+","+","+","+","-","+"),
+    ROUNDED ("+","+","+","+","-","|","+","+","+","+","+","+","+","-","+");
+    //ROUNDED("╭","╮","╰","╯","─","│","├","┤","┬","┴","┼","├","┤","─","┼");
 
     private final String tl,tr,bl,br,h,v,ml,mr,mt,mb,x,sl,sr,sh,sx;
 

src/main/java/it/polimi/ingsw/gc14/View/TUI/TUI.java

@@ -2,6 +2,8 @@ package it.polimi.ingsw.gc14.View.TUI;
 import it.polimi.ingsw.gc14.Model.Game;
 import it.polimi.ingsw.gc14.View.IView;
 
+import java.util.List;
+
 public class TUI implements IView {
 
     // ── dati di stato ───────────────────────────────────────────
@@ -23,6 +25,10 @@ public class TUI implements IView {
 
     // ── punto di ingresso ───────────────────────────────────────
     public void render()
+    {
+        renderBoard();
+    }
+    public void fullRender()
     {
         try{
             String os = System.getProperty("os.name").toLowerCase();
@@ -36,7 +42,10 @@ public class TUI implements IView {
         }
         catch(Exception e){
         }
-        System.out.println(model.toString());
+
+        List<String>lines=List.of(model.BoardStamp().split("\n"));
+        List<String> lines2=List.of((PrintMenuOptions()+"\n"+model.getPlayerByUsername(username)).split("\n"));
+        System.out.println(model.PlayersStamp()+"\n"+ AsciiTable.sideBySide(lines,lines2,3));
     }
 
     public void renderBoard()
@@ -53,7 +62,9 @@ public class TUI implements IView {
         }
         catch(Exception e){
         }
-        System.out.println(model.BoardStamp());
+        List<String>lines=List.of(model.BoardStamp().split("\n"));
+        List<String> lines2=List.of((PrintMenuOptions()+"\nYOUR HAND\n"+model.getPlayerByUsername(username)).split("\n"));
+        System.out.println(AsciiTable.sideBySide(lines,lines2,3));
     }
     public void renderPlayer()
     {
@@ -69,25 +80,10 @@ public class TUI implements IView {
         }
         catch(Exception e){
         }
-        System.out.println(model.BoardStamp());
+        List<String>lines=List.of(model.PlayersStamp().split("\n"));
+        List<String> lines2=List.of(PrintMenuOptions().split("\n"));
+        System.out.println(AsciiTable.sideBySide(lines,lines2,3));
     }
-    public void renderMyHand()
-    {
-        try{
-            String os = System.getProperty("os.name").toLowerCase();
-            ProcessBuilder pb;
-            if (os.contains("win")) {
-                pb = new ProcessBuilder("cmd", "/c", "cls");
-            } else {
-                pb = new ProcessBuilder("clear");
-            }
-            pb.inheritIO().start().waitFor();
-        }
-        catch(Exception e){
-        }
-        System.out.println(model.getPlayerByUsername(username));
-    }
-    
 
     public void showMessage(String message)
     {
@@ -100,4 +96,21 @@ public class TUI implements IView {
         System.out.println(message);
     }
 
+    private String PrintMenuOptions()
+    {
+        var table=new AsciiTable(BorderStyle.ROUNDED,2);
+        table.addHeader( "Menu Options","Render Options");
+        table.addRow( List.of("0-SlotChoice(pos)","A-Full Render"));
+        table.addRow(List.of("1-DrawUpperTribe(pos)","B-Board Render"));
+        table.addRow(List.of("2-DrawUpperBuilding(pos)","C-Players Render"));
+        table.addRow(List.of("3-DrawLowerTribe(pos)",""));
+        table.addRow(List.of("4-DrawLowerBuilding(pos)",""));
+        table.addRow(List.of("5-PickOptionalTribe(pos)",""));
+        table.addRow(List.of("6-PickOptionalBuilding(pos)",""));
+        table.addRow(List.of("7-NoOptional",""));
+        table.addRow(List.of("8-NoUpperCard",""));
+        table.addRow(List.of("9-NoLowerCard",""));
+        return table.build();
+    }
+
 }

src/test/java/it/polimi/ingsw/gc14/Controller/GameControllerTest.java

@@ -18,10 +18,7 @@ class GameControllerTest {
     private Game createStartedGame() {
         Game game = new Game(3);
         GameController controller = new GameController(game);
-        assertEquals( controller.getModel(),game);
+
-        controller = new GameController();
-        controller.setModel(game);
-        assertEquals( controller.getModel(),game);
         assertTrue(controller.addPlayer("Giorgio"));
         assertTrue(controller.addPlayer("Marco"));
         assertTrue(controller.addPlayer("Luca"));
@@ -32,14 +29,14 @@ class GameControllerTest {
     private Queue<Player> completeSlotChoice(Game game, GameController controller) {
         Queue<Player> order = new LinkedList<>();
 
-        for (int i = 0; i < 3; i++) {
+        for (int i = 0; i < game.getNPlayers(); i++) {
             Player current = game.getCurrentState().getCurrentPlayer();
             order.add(current);
 
             assertTrue(controller.slotChoice(current.getUserName(), i));
         }
 
-        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
 
         return order;
     }
@@ -92,34 +89,74 @@ class GameControllerTest {
     private void resolveActionsUntilOptionalCardEffect(Game game, GameController controller) {
         int guard = 0;
 
-        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 20) {
+        while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS && guard < 100) {
             guard++;
-
+            resolveOneMandatoryAction(game, controller);
-            Player current = game.getCurrentState().getCurrentPlayer();
-            assertNotNull(current);
-
-            if (game.getCurrentState().getNLower() > 0) {
-                int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
-
-                if (index == -1) {
-                    fail("No non-event lower tribe card available.");
-                }
-
-                assertTrue(controller.drawLowerTribeCard(current.getUserName(), index));
-            } else if (game.getCurrentState().getNUpper() > 0) {
-                int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
-
-                if (index == -1) {
-                    fail("No non-event upper tribe card available.");
-                }
-
-                assertTrue(controller.drawUpperTribeCard(current.getUserName(), index));
-            } else {
-                fail("Current player has no remaining upper or lower draws.");
-            }
         }
 
-        assertEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+    }
+
+    private void resolveOneMandatoryAction(Game game, GameController controller) {
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        String username = current.getUserName();
+
+        if (game.getCurrentState().getNLower() > 0) {
+            int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
+
+            if (index != -1) {
+                assertTrue(controller.drawLowerTribeCard(username, index));
+                return;
+            }
+
+            if (!game.getLowerListBuilding().isEmpty()) {
+                current.addFood(100);
+                assertTrue(controller.drawLowerBuildingCard(username, 0));
+                return;
+            }
+
+            assertTrue(controller.SkipLowerDrawing(username));
+            return;
+        }
+
+        if (game.getCurrentState().getNUpper() > 0) {
+            int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
+
+            if (index != -1) {
+                assertTrue(controller.drawUpperTribeCard(username, index));
+                return;
+            }
+
+            if (!game.getUpperListBuilding().isEmpty()) {
+                current.addFood(100);
+                assertTrue(controller.drawUpperBuildingCard(username, 0));
+                return;
+            }
+
+            assertTrue(controller.SkipUpperDrawing(username));
+            return;
+        }
+
+        fail("Current player has no remaining draw actions.");
+    }
+
+    private Queue<Player> completeSlotChoiceWithSlots(Game game, GameController controller, int... slotIndexes) {
+        assertEquals(game.getNPlayers(), slotIndexes.length);
+
+        Queue<Player> order = new LinkedList<>();
+
+        for (int i = 0; i < game.getNPlayers(); i++) {
+            Player current = game.getCurrentState().getCurrentPlayer();
+            order.add(current);
+
+            assertTrue(controller.slotChoice(current.getUserName(), slotIndexes[i]));
+        }
+
+        assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
+
+        return order;
     }
 
 
@@ -150,8 +187,11 @@ class GameControllerTest {
         assertFalse(controller.drawLowerTribeCard("ghost", 0));
         assertFalse(controller.drawUpperBuildingCard("ghost", 0));
         assertFalse(controller.drawLowerBuildingCard("ghost", 0));
+        assertFalse(controller.SkipUpperDrawing("ghost"));
+        assertFalse(controller.SkipLowerDrawing("ghost"));
         assertFalse(controller.pickOptionalTribeCard("ghost", 0));
         assertFalse(controller.pickOptionalBuildingCard("ghost", 0));
+        assertFalse(controller.noOptionalCard("ghost"));
     }
 
     @Test
@@ -166,7 +206,7 @@ class GameControllerTest {
 
         Queue<Player> order = completeSlotChoice(game, controller);
 
-        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
         assertEquals(order.poll(), game.getCurrentState().getCurrentPlayer());
     }
 
@@ -243,7 +283,13 @@ class GameControllerTest {
 
         Player current = game.getCurrentState().getCurrentPlayer();
 
-        assertFalse(controller.drawUpperBuildingCard(current.getUserName(), 0));
+        while (current.getFoodValue() > 0) {
+            assertTrue(current.removeFood(1));
+        }
+
+        if (current.builders.isEmpty()) {
+            assertFalse(controller.drawUpperBuildingCard(current.getUserName(), 0));
+        }
 
         current.addFood(100);
         int foodBefore = current.getFoodValue();
@@ -251,7 +297,7 @@ class GameControllerTest {
 
         assertTrue(controller.drawUpperBuildingCard(current.getUserName(), 0));
 
-        assertTrue(current.getFoodValue() < foodBefore);
+        assertTrue(current.getFoodValue() <= foodBefore);
         assertEquals(buildingsBefore + 1, current.buildingCards.size());
     }
 
@@ -267,14 +313,14 @@ class GameControllerTest {
 
         Queue<Player> players = new LinkedList<>();
 
-        for (int i = 0; i < 3; i++) {
+        for (int i = 0; i < game.getNPlayers(); i++) {
             Player current = game.getCurrentState().getCurrentPlayer();
             players.add(current);
 
             assertTrue(controller.slotChoice(current.getUserName(), i));
         }
 
-        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
 
         Player tempPlayer = players.poll();
         assertNotNull(tempPlayer);
@@ -349,7 +395,7 @@ class GameControllerTest {
 
         completeSlotChoice(game, controller);
 
-        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
 
         String cur = game.getCurrentState().getCurrentPlayer().getUserName();
 
@@ -408,7 +454,7 @@ class GameControllerTest {
 
         assertTrue(controller.pickOptionalBuildingCard(optionalPlayer.getUserName(), 0));
 
-        assertTrue(optionalPlayer.getFoodValue() < foodBefore);
+        assertTrue(optionalPlayer.getFoodValue() <= foodBefore);
         assertEquals(buildingsBefore + 1, optionalPlayer.buildingCards.size());
     }
 
@@ -456,4 +502,133 @@ class GameControllerTest {
 
         assertFalse(controller.slotChoice(second.getUserName(), 0));
     }
+
+    @Test
+    void noOptionalCardShouldWorkDuringOptionalCardEffectState() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        giveOptionalEffectToAllPlayers(game);
+
+        completeSlotChoice(game, controller);
+        resolveActionsUntilOptionalCardEffect(game, controller);
+
+        Player optionalPlayer = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(optionalPlayer);
+
+        assertTrue(optionalPlayer.buildingCards.stream()
+                .anyMatch(building -> building.getEffectId() == 12));
+
+        assertTrue(controller.noOptionalCard(optionalPlayer.getUserName()));
+    }
+
+    @Test
+    void constructorsGetModelAndSetModelShouldWork() {
+        Game game = new Game(3);
+
+        GameController controller = new GameController(game);
+        assertEquals(game, controller.getModel());
+
+        GameController emptyController = new GameController();
+        emptyController.setModel(game);
+        assertEquals(game, emptyController.getModel());
+    }
+
+    @Test
+    void slotChoiceShouldReturnFalseForInvalidIndexes() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+
+        assertFalse(controller.slotChoice(current.getUserName(), -1));
+        assertFalse(controller.slotChoice(current.getUserName(), 999));
+    }
+
+    @Test
+    void optionalCardMethodsShouldReturnFalseForInvalidIndexesDuringOptionalCardEffectState() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        giveOptionalEffectToAllPlayers(game);
+
+        completeSlotChoice(game, controller);
+        resolveActionsUntilOptionalCardEffect(game, controller);
+
+        Player optionalPlayer = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(optionalPlayer);
+
+        String username = optionalPlayer.getUserName();
+
+        assertFalse(controller.pickOptionalTribeCard(username, -1));
+        assertFalse(controller.pickOptionalTribeCard(username, 999));
+
+        assertFalse(controller.pickOptionalBuildingCard(username, -1));
+        assertFalse(controller.pickOptionalBuildingCard(username, 999));
+    }
+
+    @Test
+    void optionalCardMethodsShouldReturnFalseForWrongPlayer() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        giveOptionalEffectToAllPlayers(game);
+
+        completeSlotChoice(game, controller);
+        resolveActionsUntilOptionalCardEffect(game, controller);
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        Player wrongPlayer = game.getPlayers().stream()
+                .filter(player -> !player.equals(current))
+                .findFirst()
+                .orElse(null);
+
+        assertNotNull(wrongPlayer);
+
+        assertFalse(controller.pickOptionalTribeCard(wrongPlayer.getUserName(), 0));
+        assertFalse(controller.pickOptionalBuildingCard(wrongPlayer.getUserName(), 0));
+        assertFalse(controller.noOptionalCard(wrongPlayer.getUserName()));
+    }
+
+    @Test
+    void skipLowerDrawingShouldReturnFalseWhenLowerCharacterIsAvailable() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        completeSlotChoiceWithSlots(game, controller, 0, 1, 2);
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        assertEquals(1, game.getCurrentState().getNLower());
+        assertEquals(0, game.getCurrentState().getNUpper());
+
+        assertFalse(game.getLowerListTribeCards().isEmpty());
+        assertTrue(firstNonEventIndexOrMinusOne(game.getLowerListTribeCards()) != -1);
+
+        assertFalse(controller.SkipLowerDrawing(current.getUserName()));
+    }
+
+    @Test
+    void skipUpperDrawingShouldReturnFalseWhenUpperCharacterIsAvailable() {
+        Game game = createStartedGame();
+        GameController controller = new GameController(game);
+
+        completeSlotChoiceWithSlots(game, controller, 1, 2, 3);
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        assertEquals(0, game.getCurrentState().getNLower());
+        assertEquals(1, game.getCurrentState().getNUpper());
+
+        assertFalse(game.getUpperListTribeCards().isEmpty());
+        assertTrue(firstNonEventIndexOrMinusOne(game.getUpperListTribeCards()) != -1);
+
+        assertFalse(controller.SkipUpperDrawing(current.getUserName()));
+    }
+
+
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/Building/Effects/Building11Test.java

@@ -96,7 +96,7 @@ class Building11Test {
         p3.addFood(b3.getPrice());
         assertTrue(b3.buy(p3));
         p4.addFood(b3.getPrice());
-        assertEquals(false, b3.buy(p4));
+        assertFalse(b3.buy(p4));
     }
 
 
@@ -112,22 +112,34 @@ class Building11Test {
     @Test
     @DisplayName("toString")
     void testToString(){
-        Building11 b11 = new Building11(1,2,3, CharacterType.INVENTOR, 1);
+        int ID = 11;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: INVENTOR",  b11.toString());
+        int era = 1;
+        int price = 1;
+        int prestigeValue = 3;
+        CharacterType ct = CharacterType.ARTIST;
+        int pm = 5;
 
-        b11 = new Building11(1,2,3, CharacterType.BUILDER, 1);
+        Building11 b11 = new Building11(era, price, prestigeValue, ct, pm);
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: BUILDER",  b11.toString());
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0) + " MP: " + pm, b11.toString());
 
-        b11 = new Building11(1,2,3, CharacterType.GATHERER, 1);
+        ct = CharacterType.BUILDER;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: GATHERER",  b11.toString());
+        b11 = new Building11(era, price, prestigeValue, ct, pm);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0) + " MP: " + pm, b11.toString());
 
-        b11 = new Building11(1,2,3, CharacterType.ARTIST, 1);
+        ct = CharacterType.GATHERER;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: ARTIST",  b11.toString());
+        b11 = new Building11(era, price, prestigeValue, ct, pm);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0) + " MP: " + pm, b11.toString());
 
-        b11 = new Building11(1,2,3, CharacterType.SHAMAN, 1);
+        ct = CharacterType.HUNTER;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: SHAMAN",  b11.toString());
+        b11 = new Building11(era, price, prestigeValue, ct, pm);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0) + " MP: " + pm, b11.toString());
 
-        b11 = new Building11(1,2,3, CharacterType.HUNTER, 1);
+        ct = CharacterType.INVENTOR;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: HUNTER",  b11.toString());
+        b11 = new Building11(era, price, prestigeValue, ct, pm);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0) + " MP: " + pm, b11.toString());
+
+        ct = CharacterType.SHAMAN;
+        b11 = new Building11(era, price, prestigeValue, ct, pm);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0) + " MP: " + pm, b11.toString());
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/Building/Effects/Building1Test.java

@@ -70,22 +70,34 @@ class Building1Test {
     @Test
     @DisplayName("toString")
     void testToString(){
-        Building1 b1 = new Building1(1,2,3, CharacterType.INVENTOR);
+        int ID = 1;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: INVENTOR",  b1.toString());
+        int era = 1;
+        int price = 1;
+        int prestigeValue = 3;
+        CharacterType ct = CharacterType.ARTIST;
+        int pm = 5;
 
-        b1 = new Building1(1,2,3, CharacterType.BUILDER);
+        Building1 b1 = new Building1(era, price, prestigeValue, ct);
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: BUILDER",  b1.toString());
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0), b1.toString());
 
-        b1 = new Building1(1,2,3, CharacterType.GATHERER);
+        ct = CharacterType.BUILDER;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: GATHERER",  b1.toString());
+        b1 = new Building1(era, price, prestigeValue, ct);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0), b1.toString());
 
-        b1 = new Building1(1,2,3, CharacterType.ARTIST);
+        ct = CharacterType.GATHERER;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: ARTIST",  b1.toString());
+        b1 = new Building1(era, price, prestigeValue, ct);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0), b1.toString());
 
-        b1 = new Building1(1,2,3, CharacterType.SHAMAN);
+        ct = CharacterType.HUNTER;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: SHAMAN",  b1.toString());
+        b1 = new Building1(era, price, prestigeValue, ct);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0), b1.toString());
 
-        b1 = new Building1(1,2,3, CharacterType.HUNTER);
+        ct = CharacterType.INVENTOR;
-        assertEquals("Era:1 Price:2 Prestige:3 Icon: HUNTER",  b1.toString());
+        b1 = new Building1(era, price, prestigeValue, ct);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0), b1.toString());
+
+        ct = CharacterType.SHAMAN;
+        b1 = new Building1(era, price, prestigeValue, ct);
+        assertEquals("⎕: " + "ID:" + ID + " $:" + price + " PV:" + prestigeValue + " Icon: " + ct.toString().charAt(0), b1.toString());
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/BuildingCardTest.java

@@ -2,6 +2,7 @@ package it.polimi.ingsw.gc14.Model.Cards;
 
 import it.polimi.ingsw.gc14.Model.Cards.Building.EffectType;
 import it.polimi.ingsw.gc14.Model.Cards.Building.Effects.Building13;
+import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Builder;
 import it.polimi.ingsw.gc14.Model.Player;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -149,12 +150,162 @@ class BuildingCardTest {
         assertFalse(bc0.buy(p2));
     }
 
+    @Test
+    @DisplayName("Testing the buy method with discounts")
+    void testBuyDiscount() {
+        int food = 5;
+        int price = 5;
+        int RV = 1;
+
+        Player p = new Player("test");
+        p.addFood(food);
+        p.builders.add(new Builder(1, RV, 1));
+
+
+
+        //Testing that to pay == price - 1
+        for(int ID = 3; ID < 13; ID++){
+            if(ID == 4 || ID == 8 || ID == 10 || ID == 11){
+                continue;
+            }
+            BuildingCard bc = new BuildingCard(ID, 1, price,1);
+            assertEquals(food, p.getFoodValue());
+            assertTrue(bc.buy(p));
+
+            int discount = p.builders.stream().mapToInt(x -> x.getReductionValue()).sum();
+            assertEquals(food - price + discount, p.getFoodValue());
+
+            p.removeFood(p.getFoodValue());
+            p.addFood(food);
+        }
+
+        //Testing that to pay == 0
+        p.removeFood(p.getFoodValue());
+        p.addFood(food);
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+
+        for(int ID = 3; ID < 13; ID++){
+            if(ID == 4 || ID == 8 || ID == 10 || ID == 11){
+                continue;
+            }
+            BuildingCard bc = new BuildingCard(ID, 1, price,1);
+            assertEquals(food, p.getFoodValue());
+            assertTrue(bc.buy(p));
+
+            assertEquals(food, p.getFoodValue());
+
+            p.removeFood(p.getFoodValue());
+            p.addFood(food);
+        }
+
+        //Testing that to pay == 0; discount shouldn't go below 0
+        p.removeFood(p.getFoodValue());
+        p.addFood(food);
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+        p.builders.add(new Builder(1, RV, 1));
+
+        for(int ID = 3; ID < 13; ID++){
+            if(ID == 4 || ID == 8 || ID == 10 || ID == 11){
+                continue;
+            }
+            BuildingCard bc = new BuildingCard(ID, 1, price,1);
+            assertEquals(food, p.getFoodValue());
+            assertTrue(bc.buy(p));
+
+            assertEquals(food, p.getFoodValue());
+
+            p.removeFood(p.getFoodValue());
+            p.addFood(food);
+        }
+
+        //Testing that to pay == 0 if  price < builder b * b.RV
+        food = 6;
+        price = 3;
+        RV = 4;
+
+        Player p2 = new Player("test");
+        p2.addFood(food);
+        p2.builders.add(new Builder(1, RV, 1));
+
+        for(int ID = 3; ID < 13; ID++){
+            if(ID == 4 || ID == 8 || ID == 10 || ID == 11){
+                continue;
+            }
+            BuildingCard bc = new BuildingCard(ID, 1, price,1);
+            assertEquals(food, p2.getFoodValue());
+            assertTrue(bc.buy(p2));
+
+            int discount = p2.builders.stream().mapToInt(x -> x.getReductionValue()).sum();
+            assertEquals(food, p2.getFoodValue());
+
+            p2.removeFood(p2.getFoodValue());
+            p2.addFood(food);
+        }
+
+        p2.removeFood(p2.getFoodValue());
+        p2.addFood(food);
+
+        //Testing discount with staggered values
+        price = 7;
+
+        for(int ID = 3; ID < 13; ID++){
+            if(ID == 4 || ID == 8 || ID == 10 || ID == 11){
+                continue;
+            }
+            BuildingCard bc = new BuildingCard(ID, 1, price,1);
+            assertEquals(food, p2.getFoodValue());
+            assertTrue(bc.buy(p2));
+
+            int discount = p2.builders.stream().mapToInt(x -> x.getReductionValue()).sum();
+            assertEquals(food - price + discount, p2.getFoodValue());
+
+            p2.removeFood(p2.getFoodValue());
+            p2.addFood(food);
+        }
+
+        //Testing discount with staggered values; discount shouldn't go below 0
+        p2.builders.add(new Builder(1, RV, 1));
+
+        for(int ID = 3; ID < 13; ID++){
+            if(ID == 4 || ID == 8 || ID == 10 || ID == 11){
+                continue;
+            }
+            BuildingCard bc = new BuildingCard(ID, 1, price,1);
+            assertEquals(food, p2.getFoodValue());
+            assertTrue(bc.buy(p2));
+
+            assertEquals(food, p2.getFoodValue());
+
+            p2.removeFood(p2.getFoodValue());
+            p2.addFood(food);
+        }
+    }
+
     @Test
     @DisplayName("Testing toString method")
     void testToString() {
-        Building13 b0 = new Building13(1, 2,3);
+        int era = 2;
+        int price = 5;
+        int prestigeValue = 6;
 
-        assertEquals("Era:1 Price:2 Prestige:3", b0.toString());
+        BuildingCard b0 = new BuildingCard(era, price, prestigeValue);
+        assertEquals("⎕:" + " ID:0" + " $:"+ b0.getPrice() + " PV:" + b0.getPrestigeValue(), b0.toString());
+
+        for(int ID = 3; ID < 13; ID++){
+            if(ID == 4 || ID == 8 || ID == 10 || ID == 11){
+                continue;
+            }
+            BuildingCard b = new BuildingCard(ID, era, price, prestigeValue);
+            assertEquals("⎕:" + " ID:" + ID + " $:"+ b.getPrice() + " PV:" + b.getPrestigeValue(), b.toString());
+        }
     }
 
     @Test

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/ArtistTest.java

@@ -14,7 +14,7 @@ class ArtistTest {
         String s = a.toString();
 
         assertNotNull(s);
-        assertTrue(s.contains(CharacterType.ARTIST.toString()));
+        assertTrue(s.contains("⎕:"));
     }
 
     @Test

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/BuilderTest.java

@@ -27,9 +27,8 @@ class BuilderTest {
         String s = b.toString();
 
         assertNotNull(s);
-        assertTrue(s.contains(CharacterType.BUILDER.toString()));
+        assertFalse(s.contains(CharacterType.BUILDER.toString()));
-        assertTrue(s.contains("Reduction Value: 2"));
+        assertEquals("⎕:" + " RV:" + b.getReductionValue() + " PV:" +  b.getPrestigeValue(), s);
-        assertTrue(s.contains("Prestige Value: 3"));
     }
 
     @Test

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/GathererTest.java

@@ -13,8 +13,11 @@ class GathererTest {
         Gatherer g = new Gatherer(1);
         String s = g.toString();
 
+        System.out.println(s);
+
         assertNotNull(s);
-        assertTrue(s.contains(CharacterType.GATHERER.toString()));
+        assertFalse(s.contains(CharacterType.GATHERER.toString()));
+        assertTrue(s.contains("⎕:"));
     }
 
     @Test

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/HunterTest.java

@@ -21,8 +21,10 @@ class HunterTest {
         String s = h.toString();
 
         assertNotNull(s);
-        assertTrue(s.contains(CharacterType.HUNTER.toString()));
+        assertTrue(s.contains(" I"));
-        assertTrue(s.contains("Icon: true"));
+
+        Hunter h2 = new Hunter(3, false);
+        assertTrue(!h2.toString().contains("I"));
     }
 
     @Test
@@ -55,6 +57,20 @@ class HunterTest {
 
         assertEquals(2, p.hunters.size());
         assertTrue(p.hunters.contains(h2));
+
+        Player p2 = new Player("test2");
+        Hunter h3 = new Hunter(1, true);
+
+        assertEquals(0, p2.getFoodValue());
+        h.insert(p2);
+
+        assertEquals(1, p2.getFoodValue());
+        h2.insert(p2);
+
+        assertEquals(1, p2.getFoodValue());
+        h3.insert(p2);
+
+        assertEquals(4, p2.getFoodValue());
     }
 
     @Test

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/InventorTest.java

@@ -24,9 +24,8 @@ class InventorTest {
         String s = i.toString();
 
         assertNotNull(s);
-        assertTrue(s.contains(CharacterType.INVENTOR.toString()));
+        assertFalse(s.contains(CharacterType.INVENTOR.toString()));
-        assertTrue(s.contains("Symbol:"));
+        assertEquals("⎕:" + " I_ID:" + i.Icon(), i.toString());
-        assertTrue(s.contains("5"));
     }
 
     @Test

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Characters/ShamanTest.java

@@ -21,8 +21,8 @@ class ShamanTest {
         String str = s.toString();
 
         assertNotNull(str);
-        assertTrue(str.contains(CharacterType.SHAMAN.toString()));
+        assertFalse(str.contains(CharacterType.SHAMAN.toString()));
-        assertTrue(str.contains("Icon: 4"));
+        assertEquals("⎕: *:" + s.getIcon(), str);
     }
 
     @Test

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Events/CavePaintingsTest.java

@@ -111,6 +111,6 @@ class CavePaintingsTest {
     void toStringTest() {
         CavePaintings cv1 = new CavePaintings(1, 1,1,1);
 
-        assertEquals("Era:1, CAVE_PAINTINGS", cv1.toString());
+        assertEquals("⎕:(Event)CAVE_PAINTINGS", cv1.toString());
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Events/HuntTest.java

@@ -41,8 +41,8 @@ class HuntTest {
         new Hunter(1, false).insert(p2);
 
         h1.activateEvent(players);
-        assertEquals(6, p1.getPrestigeValue());
+        assertEquals(3*2, p1.getPrestigeValue());
-        assertEquals(2, p1.getFoodValue());
+        assertEquals(1+2, p1.getFoodValue());
         assertEquals(3, p2.getPrestigeValue());
         assertEquals(1, p2.getFoodValue());
     }
@@ -73,20 +73,25 @@ class HuntTest {
         ArrayList<Player> players = new ArrayList<>(Arrays.asList(p1, p2, p3));
         Hunt h1 = new Hunt(1, 3);
 
+        assertEquals(0, p1.getFoodValue());
+
         new Hunter(1, true).insert(p1);
         new Hunter(1, false).insert(p1);
         new Hunter(1, false).insert(p2);
 
         BuildingCard bc = new BuildingCard(7, 1, 5, 5);
         p2.addFood(5);
+
         bc.buy(p2);
+        assertEquals(5 - bc.getPrice(), p2.getFoodValue());
+        assertEquals(0, p2.getFoodValue());
 
         new Hunter(1, false).insert(p3);
-
+        assertEquals(0, p3.getFoodValue());
 
         h1.activateEvent(players);
-        assertEquals(6, p1.getPrestigeValue());
+        assertEquals(3*2, p1.getPrestigeValue());
-        assertEquals(2, p1.getFoodValue());
+        assertEquals(1 + 2, p1.getFoodValue());
         assertEquals(4, p2.getPrestigeValue());
         assertEquals(2, p2.getFoodValue());
         assertEquals(3, p3.getPrestigeValue());
@@ -113,6 +118,6 @@ class HuntTest {
     void toStringTest() {
         Hunt h1 = new Hunt(1, 3);
 
-        assertEquals("Era:1, HUNT", h1.toString());
+        assertEquals("⎕:(Event)HUNT", h1.toString());
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Events/ShamanicRitualTest.java

@@ -212,6 +212,6 @@ class ShamanicRitualTest {
     void toStringTest() {
         ShamanicRitual sr1 = new ShamanicRitual(1, 5,2);
 
-        assertEquals("Era:1, SHAMANIC_RITUAL", sr1.toString());
+        assertEquals("⎕:(Event)SHAMANIC_RITUAL", sr1.toString());
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Cards/TribeCards/Events/SustenanceTest.java

@@ -49,13 +49,13 @@ class SustenanceTest {
         new Shaman(1, 5).insert(p1);
         new Builder(1, 5, 5).insert(p1);
         new Artist(1).insert(p1);
-        new Hunter(1, true).insert(p1);
+        new Hunter(1, false).insert(p1);
         new Gatherer(1).insert(p1);
 
         p2.addFood(1);
         new Artist(1).insert(p2);
-        new Hunter(1, true).insert(p2);
+        new Hunter(1, false).insert(p2);
-        new Hunter(1, true).insert(p2);
+        new Hunter(1, false).insert(p2);
 
 
 
@@ -79,7 +79,7 @@ class SustenanceTest {
         new Shaman(1, 5).insert(p1);
         new Builder(1, 5, 5).insert(p1);
         new Artist(1).insert(p1);
-        new Hunter(1, true).insert(p1);
+        new Hunter(1, false).insert(p1);
         new Gatherer(1).insert(p1);
 
         p2.addFood(2);
@@ -96,7 +96,7 @@ class SustenanceTest {
 
         Sustenance s = new Sustenance(1,2);
         s.activateEvent(players);
-        assertEquals(2, p1.getFoodValue());
+        assertEquals(3, p1.getFoodValue());
         assertEquals(1, p2.getFoodValue());
         assertEquals(0, p1.getPrestigeValue());
         assertEquals(0, p2.getPrestigeValue());
@@ -122,7 +122,7 @@ class SustenanceTest {
     void toStringTest() {
         Sustenance s1 = new Sustenance(1, 5);
 
-        assertEquals("Era:1, SUSTENANCE", s1.toString());
+        assertEquals("⎕:(Event)SUSTENANCE", s1.toString());
     }
 }
 

src/test/java/it/polimi/ingsw/gc14/Model/GamePackage/BoardTest.java

@@ -125,11 +125,11 @@ class BoardTest {
     void removeUpperTribeCard() {
         Board bd = new Board(3);
 
-        List<TribeCard> before = bd.upperListTribe;
+        List<TribeCard> before = new ArrayList<>( bd.upperListTribe);
-        TribeCard cardToRemove = before.get(2);
+        TribeCard cardToRemove = before.get(0);
 
-        before.remove(2);
+        assertEquals(cardToRemove, before.remove(0));
-        bd.removeUpperTribeCard(cardToRemove);
+        assertTrue( bd.removeUpperTribeCard(cardToRemove));
 
         assertEquals(before, bd.upperListTribe);
     }
@@ -139,25 +139,25 @@ class BoardTest {
     void removeLowerTribeCard() {
         Board bd = new Board(3);
 
-        List<TribeCard> before = bd.lowerListTribe;
+        List<TribeCard> before = new ArrayList<>(bd.lowerListTribe);
-        TribeCard cardToRemove = before.get(2);
+        TribeCard cardToRemove = before.get(0);
 
-        before.remove(2);
+        assertEquals(cardToRemove, before.remove(0));
-        bd.removeLowerTribeCard(cardToRemove);
+        assertTrue( bd.removeLowerTribeCard(cardToRemove));
 
         assertEquals(before, bd.lowerListTribe);
     }
 
     @Test
-    @DisplayName("RemgetTribeDeckSizeoving a card from upper row of building cards")
+    @DisplayName("Removing a card from upper row of building cards")
     void removeUpperBuildingCard() {
         Board bd = new Board(3);
 
-        List<BuildingCard> before = bd.upperListBuilding;
+        List<BuildingCard> before = new ArrayList<>(bd.upperListBuilding);
         BuildingCard cardToRemove = before.get(0);
 
-        before.remove(0);
+        assertEquals(cardToRemove, before.remove(0));
-        bd.removeUpperBuildingCard(cardToRemove);
+        assertTrue( bd.removeUpperBuildingCard(cardToRemove));
 
         assertEquals(before, bd.upperListBuilding);
     }
@@ -171,12 +171,10 @@ class BoardTest {
             bd.nextRound();    // Skip to era 2
         }
 
-        List<BuildingCard> before = bd.lowerListBuilding;
+        List<BuildingCard> before = new ArrayList<>( bd.lowerListBuilding);
         BuildingCard cardToRemove = before.get(0);
-
+        assertEquals(cardToRemove, before.remove(0));
-        before.remove(0);
+        assertTrue(bd.removeLowerBuildingCard(cardToRemove));
-        bd.removeLowerBuildingCard(cardToRemove);
-
         assertEquals(before, bd.lowerListBuilding);
     }
 
@@ -214,6 +212,8 @@ class BoardTest {
         assertEquals(upperListBefore, bd1.lowerListBuilding);
         assertNotEquals(upperListBefore, bd1.upperListBuilding);
         assertEquals(2, bd1.upperListBuilding.size());
+        assertTrue(bd1.upperListBuilding.stream().allMatch(x->x.getEra()==2));
+        assertTrue(bd1.lowerListBuilding.stream().allMatch(x->x.getEra()==1));
 
 
         // Era 2, nTotem > 3
@@ -227,7 +227,8 @@ class BoardTest {
         assertEquals(upperListBefore, bd2.lowerListBuilding);
         assertNotEquals(upperListBefore, bd2.upperListBuilding);
         assertEquals(3, bd2.upperListBuilding.size());
-
+        assertTrue(bd2.upperListBuilding.stream().allMatch(x->x.getEra()==2));
+        assertTrue(bd2.lowerListBuilding.stream().allMatch(x->x.getEra()==1));
 
         // Era 3, nTotem == 2
         numPlayer = 2;
@@ -243,6 +244,8 @@ class BoardTest {
         assertEquals(upperListBefore, bd3.lowerListBuilding);
         assertNotEquals(upperListBefore, bd3.upperListBuilding);
         assertEquals(3, bd3.upperListBuilding.size());
+        assertTrue(bd3.upperListBuilding.stream().allMatch(x->x.getEra()==3));
+        assertTrue(bd3.lowerListBuilding.stream().allMatch(x->x.getEra()==2));
 
 
         // Era 3, nTotem == 5
@@ -259,6 +262,8 @@ class BoardTest {
         assertEquals(upperListBefore, bd4.lowerListBuilding);
         assertNotEquals(upperListBefore, bd4.upperListBuilding);
         assertEquals(5, bd4.upperListBuilding.size());
+        assertTrue(bd4.upperListBuilding.stream().allMatch(x->x.getEra()==3));
+        assertTrue(bd4.lowerListBuilding.stream().allMatch(x->x.getEra()==2));
 
 
         // Era 3, nTotem != 2, 5
@@ -275,6 +280,8 @@ class BoardTest {
         assertEquals(upperListBefore, bd5.lowerListBuilding);
         assertNotEquals(upperListBefore, bd5.upperListBuilding);
         assertEquals(4, bd5.upperListBuilding.size());
+        assertTrue(bd5.upperListBuilding.stream().allMatch(x->x.getEra()==3));
+        assertTrue(bd5.lowerListBuilding.stream().allMatch(x->x.getEra()==2));
 
 
     }

src/test/java/it/polimi/ingsw/gc14/Model/GamePackage/CurrentStateTest.java

@@ -70,7 +70,7 @@ class CurrentStateTest {
     void getGameStage() {
         Player p = new Player("test");
         Slot s = new Slot('A');
-        GameStages g = GameStages.RESOLVING_ACTIONS;
+        GameStages g = GameStages.RES_ACTIONS;
         CurrentState curr = new CurrentState();
         curr.PlayerUpdate(p, s);
         curr.GameStageUpdate(g);
@@ -122,12 +122,12 @@ class CurrentStateTest {
     void gameStageUpdate() {
         Player p = new Player("test");
         Slot s = new Slot('A');
-        GameStages g = GameStages.RESOLVING_ACTIONS;
+        GameStages g = GameStages.RES_ACTIONS;
         CurrentState curr = new CurrentState();
         assertEquals(GameStages.WAITING, curr.getGameStage());
         curr.PlayerUpdate(p, s);
         curr.GameStageUpdate(g);
-        assertEquals(GameStages.RESOLVING_ACTIONS, curr.getGameStage());
+        assertEquals(GameStages.RES_ACTIONS, curr.getGameStage());
     }
 
     @Test

src/test/java/it/polimi/ingsw/gc14/Model/GameTest.java

@@ -5,10 +5,12 @@ import it.polimi.ingsw.gc14.Model.Cards.TribeCard;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Character;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.CharacterType;
 import it.polimi.ingsw.gc14.Model.GamePackage.GameStages;
+import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Artist;
+import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Builder;
+import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Inventor;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
-import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
 
@@ -28,7 +30,7 @@ class GameTest {
             assertTrue(game.SlotChoiceByIndex(current, i));
         }
 
-        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
 
         return order;
     }
@@ -61,7 +63,7 @@ class GameTest {
     }
 
     private void resolveAllMandatoryActions(Game game) {
-        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS) {
+        while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
             resolveOneMandatoryAction(game);
         }
     }
@@ -70,57 +72,69 @@ class GameTest {
         Player current = game.getCurrentState().getCurrentPlayer();
         assertNotNull(current);
 
-        if (game.getCurrentState().getNLower() > 0 && hasDrawableLower(game)) {
+        if (game.getCurrentState().getNLower() > 0) {
             int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
 
             if (index != -1) {
                 assertTrue(game.DrawLowerTribeCardByIndex(current, index));
-            } else {
+                return;
-                current.addFood(100);
-                assertTrue(game.DrawLowerBuildingCardByIndex(current, 0));
             }
 
-        } else if (game.getCurrentState().getNUpper() > 0 && hasDrawableUpper(game)) {
+            if (!game.getLowerListBuilding().isEmpty()
+                    && game.DrawLowerBuildingCardByIndex(current, 0)) {
+                return;
+            }
+
+            assertTrue(game.SkipLowerDrawing(current));
+            return;
+        }
+
+        if (game.getCurrentState().getNUpper() > 0) {
             int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
 
             if (index != -1) {
                 assertTrue(game.DrawUpperTribeCardByIndex(current, index));
-            } else {
+                return;
-                current.addFood(100);
-                assertTrue(game.DrawUpperBuildingCardByIndex(current, 0));
             }
 
-        } else {
+            if (!game.getUpperListBuilding().isEmpty()
-            fail(
+                    && game.DrawUpperBuildingCardByIndex(current, 0)) {
-                    "Current player has no drawable cards, although the game is still resolving actions.\n" +
+                return;
-                            "Current player: " + current + "\n" +
+            }
-                            "Round: " + game.getCurrentState().getRound() + "\n" +
+
-                            "Stage: " + game.getCurrentState().getGameStage() + "\n" +
+            assertTrue(game.SkipUpperDrawing(current));
-                            "Slot: " + (game.getCurrentState().getSlot() == null
+            return;
-                            ? "null"
-                            : game.getCurrentState().getSlot().getSlotId()) + "\n" +
-                            "NLower: " + game.getCurrentState().getNLower() + "\n" +
-                            "NUpper: " + game.getCurrentState().getNUpper() + "\n" +
-                            "Lower tribe size: " + game.getLowerListTribeCards().size() + "\n" +
-                            "Upper tribe size: " + game.getUpperListTribeCards().size() + "\n" +
-                            "Lower building size: " + game.getLowerListBuilding().size() + "\n" +
-                            "Upper building size: " + game.getUpperListBuilding().size() + "\n" +
-                            "First lower non-event: " + firstNonEventIndexOrMinusOne(game.getLowerListTribeCards()) + "\n" +
-                            "First upper non-event: " + firstNonEventIndexOrMinusOne(game.getUpperListTribeCards())
-            );
         }
+
+        fail(
+                "Current player has no remaining draw actions.\n" +
+                        "Current player: " + current + "\n" +
+                        "Round: " + game.getCurrentState().getRound() + "\n" +
+                        "Stage: " + game.getCurrentState().getGameStage() + "\n" +
+                        "Slot: " + (game.getCurrentState().getSlot() == null
+                        ? "null"
+                        : game.getCurrentState().getSlot().getSlotId()) + "\n" +
+                        "NLower: " + game.getCurrentState().getNLower() + "\n" +
+                        "NUpper: " + game.getCurrentState().getNUpper() + "\n" +
+                        "Lower tribe size: " + game.getLowerListTribeCards().size() + "\n" +
+                        "Upper tribe size: " + game.getUpperListTribeCards().size() + "\n" +
+                        "Lower building size: " + game.getLowerListBuilding().size() + "\n" +
+                        "Upper building size: " + game.getUpperListBuilding().size() + "\n" +
+                        "First lower non-event: " + firstNonEventIndexOrMinusOne(game.getLowerListTribeCards()) + "\n" +
+                        "First upper non-event: " + firstNonEventIndexOrMinusOne(game.getUpperListTribeCards())
+        );
     }
 
     private void resolveActionsUntilOptionalCardEffect(Game game) {
-        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS) {
+        while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
             resolveOneMandatoryAction(game);
         }
 
-        assertEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
     }
 
     private void resolveOptionalPhaseIfPresent(Game game) {
-        while (game.getCurrentState().getGameStage() == GameStages.OPTIONAL_CARD_EFFECT) {
+        while (game.getCurrentState().getGameStage() == GameStages.OPT_CARD_E) {
             Player current = game.getCurrentState().getCurrentPlayer();
             assertNotNull(current);
 
@@ -133,21 +147,20 @@ class GameTest {
 
         completeSlotChoice(game);
 
-        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
 
         resolveAllMandatoryActions(game);
 
         resolveOptionalPhaseIfPresent(game);
     }
 
-    private boolean hasDrawableLower(Game game) {
+    private void resolveCurrentPlayerCompletely(Game game, Player expectedPlayer) {
-        return firstNonEventIndexOrMinusOne(game.getLowerListTribeCards()) != -1
+        assertEquals(expectedPlayer, game.getCurrentState().getCurrentPlayer());
-                || !game.getLowerListBuilding().isEmpty();
-    }
 
-    private boolean hasDrawableUpper(Game game) {
+        while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS
-        return firstNonEventIndexOrMinusOne(game.getUpperListTribeCards()) != -1
+                && expectedPlayer.equals(game.getCurrentState().getCurrentPlayer())) {
-                || !game.getUpperListBuilding().isEmpty();
+            resolveOneMandatoryAction(game);
+        }
     }
 
     @Test
@@ -282,7 +295,7 @@ class GameTest {
         assertTrue(game.addPlayer(p3));
 
         Queue<Player> players = new LinkedList<>();
-        for (int i = 0; i < 3; i++) {
+        for (int i = 0; i < game.getNPlayers(); i++) {
             players.add(game.getCurrentState().getCurrentPlayer());
             assertTrue(game.SlotChoiceByIndex(game.getCurrentState().getCurrentPlayer(), i));
         }
@@ -325,11 +338,14 @@ class GameTest {
             assertFalse(game.DrawUpperTribeCardByIndex(temp_player, eventIndex));
         }
 
-        temp_player.addFood(100);
-
         assertFalse(game.getUpperListBuilding().isEmpty());
 
+        temp_player.builders.clear();
+
         index = 0;
+        BuildingCard selectedBuilding = game.getUpperListBuilding().get(index);
+        temp_player.addFood(selectedBuilding.getPrice());
+
         assertTrue(game.DrawUpperBuildingCardByIndex(temp_player, index));
 
         int remainingTribeIndex = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
@@ -341,15 +357,12 @@ class GameTest {
         assertNotNull(thirdPlayer);
         assertEquals(thirdPlayer, game.getCurrentState().getCurrentPlayer());
 
-        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS
+        while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS
                 && thirdPlayer.equals(game.getCurrentState().getCurrentPlayer())) {
             resolveOneMandatoryAction(game);
         }
 
         assertNotEquals(thirdPlayer, game.getCurrentState().getCurrentPlayer());
-
-        System.out.println(game);
-
     }
 
     private void drawTribeTest(HashMap<CharacterType, Integer> nCardsByType,
@@ -436,15 +449,30 @@ class GameTest {
 
         assertFalse(game.getUpperListBuilding().isEmpty());
 
-        current.addFood(100);
+        current.builders.clear();
+
+        BuildingCard selectedBuilding = game.getUpperListBuilding().get(0);
+        int expectedCost = selectedBuilding.getPrice();
+
+        current.addFood(expectedCost);
 
-        int foodBefore = current.getFoodValue();
         int buildingsBefore = current.buildingCards.size();
+        int upperBuildingsBefore = game.getUpperListBuilding().size();
+        int foodBefore = current.getFoodValue();
 
         assertTrue(game.PickOptionalBuildingCard(current, 0));
 
-        assertTrue(current.getFoodValue() < foodBefore);
         assertEquals(buildingsBefore + 1, current.buildingCards.size());
+        assertEquals(upperBuildingsBefore - 1, game.getUpperListBuilding().size());
+
+        assertTrue(current.buildingCards.stream()
+                .anyMatch(building ->
+                        building.getPrice() == selectedBuilding.getPrice()
+                                && building.getPrestigeValue() == selectedBuilding.getPrestigeValue()
+                                && building.getEffectId() == selectedBuilding.getEffectId()
+                ));
+
+        assertEquals(foodBefore - expectedCost, current.getFoodValue());
     }
 
     @Test
@@ -469,7 +497,7 @@ class GameTest {
 
         assertTrue(game.NoOptionalCard(current));
 
-        assertEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
         assertNotEquals(current, game.getCurrentState().getCurrentPlayer());
     }
 
@@ -634,7 +662,7 @@ class GameTest {
 
         assertDoesNotThrow(() -> resolveAllMandatoryActions(game));
 
-        assertNotEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
+        assertNotEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
     }
 
 
@@ -798,6 +826,8 @@ class GameTest {
             assertTrue(current.removeFood(1));
         }
 
+        current.builders.clear();
+
         assertEquals(0, current.getFoodValue());
 
         assertFalse(
@@ -807,8 +837,9 @@ class GameTest {
 
         assertFalse(game.PickOptionalBuildingCard(current, 0));
     }
+
     @Test
-    void toStringModel() throws IOException, InterruptedException {
+    void toStringModel() {
         Game game=new Game(5);
         Player p1=new Player("p1");
         Player p2=new Player("p2");
@@ -823,11 +854,245 @@ class GameTest {
         assertTrue(game.addPlayer(p5));
 
         Queue<Player>players=new LinkedList<>();
-        for(int i=0;i<3;i++) {
+        for (int i = 0; i < game.getNPlayers(); i++) {
-            players.add( game.getCurrentState().getCurrentPlayer());
+            players.add(game.getCurrentState().getCurrentPlayer());
             assertTrue(game.SlotChoiceByIndex(game.getCurrentState().getCurrentPlayer(), i));
         }
 
-        System.out.println(game.toString());
+        String result = game.toString();
+
+        assertNotNull(result);
+        assertFalse(result.isBlank());
+        assertTrue(result.contains("CURRENT STATE"));
     }
+
+    @Test
+    @Timeout(value = 5, unit = TimeUnit.SECONDS)
+    void shouldDrawLowerBuildingWhenAvailableAndPlayerCanPay() {
+        Game game = new Game(3);
+
+        addPlayers(game, 3, "lower_building_");
+
+        for (int safety = 0; safety < 300; safety++) {
+
+            if (game.getCurrentState().getGameStage() == GameStages.SLOT_CHOICE) {
+                completeSlotChoice(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
+                Player current = game.getCurrentState().getCurrentPlayer();
+                assertNotNull(current);
+
+                if (game.getCurrentState().getNLower() > 0
+                        && !game.getLowerListBuilding().isEmpty()) {
+
+                    current.builders.clear();
+
+                    BuildingCard selectedBuilding = game.getLowerListBuilding().get(0);
+                    int expectedCost = selectedBuilding.getPrice();
+
+                    current.addFood(expectedCost);
+
+                    int buildingsBefore = current.buildingCards.size();
+                    int lowerBuildingsBefore = game.getLowerListBuilding().size();
+                    int foodBefore = current.getFoodValue();
+
+                    assertTrue(
+                            game.DrawLowerBuildingCardByIndex(current, 0),
+                            "DrawLowerBuildingCardByIndex should return true when lower building exists, player can draw lower, and player has food."
+                    );
+
+                    assertEquals(buildingsBefore + 1, current.buildingCards.size());
+                    assertEquals(lowerBuildingsBefore - 1, game.getLowerListBuilding().size());
+                    assertTrue(current.buildingCards.stream()
+                            .anyMatch(building ->
+                                    building.getPrice() == selectedBuilding.getPrice()
+                                            && building.getPrestigeValue() == selectedBuilding.getPrestigeValue()
+                                            && building.getEffectId() == selectedBuilding.getEffectId()
+                            ));
+                    assertTrue(
+                            current.getFoodValue() >= foodBefore - expectedCost,
+                            "After buying the building, food should not be lower than the price paid because later effects may add food."
+                    );
+                    return;
+                }
+
+                resolveOneMandatoryAction(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.OPT_CARD_E) {
+                resolveOptionalPhaseIfPresent(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.ENDED) {
+                break;
+            }
+        }
+
+        fail("The test never reached a state with NLower > 0 and at least one lower building.");
+    }
+
+    @Test
+    void drawBuildingShouldReturnFalseIfPlayerCannotPay() {
+        Game game = new Game(3);
+        addPlayers(game, 3, "no_food_building_");
+
+        completeSlotChoice(game);
+
+        while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
+            Player current = game.getCurrentState().getCurrentPlayer();
+
+            if (game.getCurrentState().getNUpper() > 0
+                    && !game.getUpperListBuilding().isEmpty()) {
+
+                while (current.getFoodValue() > 0) {
+                    assertTrue(current.removeFood(1));
+                }
+
+                current.builders.clear();
+
+                assertEquals(0, current.getFoodValue());
+
+                assertFalse(game.DrawUpperBuildingCardByIndex(current, 0));
+                return;
+            }
+
+            resolveOneMandatoryAction(game);
+        }
+
+        fail("No upper building draw state reached.");
+    }
+
+    @Test
+    void shouldResolvePlayersAccordingToSlotOrder() {
+        Game game = new Game(3);
+        addPlayers(game, 3, "slot_order_");
+
+        Player firstChooser = game.getCurrentState().getCurrentPlayer();
+        assertTrue(game.SlotChoiceByIndex(firstChooser, 2));
+
+        Player secondChooser = game.getCurrentState().getCurrentPlayer();
+        assertTrue(game.SlotChoiceByIndex(secondChooser, 0));
+
+        Player thirdChooser = game.getCurrentState().getCurrentPlayer();
+        assertTrue(game.SlotChoiceByIndex(thirdChooser, 1));
+
+        assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
+
+        assertEquals(secondChooser, game.getCurrentState().getCurrentPlayer());
+
+        resolveCurrentPlayerCompletely(game, secondChooser);
+
+        assertEquals(thirdChooser, game.getCurrentState().getCurrentPlayer());
+
+        resolveCurrentPlayerCompletely(game, thirdChooser);
+
+        assertEquals(firstChooser, game.getCurrentState().getCurrentPlayer());
+    }
+
+    @Test
+    @Timeout(value = 20, unit = TimeUnit.SECONDS)
+    void endGameShouldNotCrashWhenTriggeredAfterRoundTen() {
+        Game game = new Game(3);
+
+        List<Player> players = addPlayers(game, 3, "end_game_");
+
+        giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
+
+        while (game.getCurrentState().getRound() < 10) {
+            playOneFullRound(game);
+        }
+
+        assertEquals(10, game.getCurrentState().getRound());
+        assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
+
+        completeSlotChoice(game);
+        resolveAllMandatoryActions(game);
+
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+
+        assertDoesNotThrow(() -> resolveOptionalPhaseIfPresent(game));
+
+        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
+    }
+
+    @Test
+    @Timeout(value = 20, unit = TimeUnit.SECONDS)
+    void endGameShouldAddBuildingPrestigeValues() {
+        Game game = new Game(3);
+
+        List<Player> players = addPlayers(game, 3, "building_prestige_");
+
+        giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
+
+        while (game.getCurrentState().getRound() < 10) {
+            playOneFullRound(game);
+        }
+
+        completeSlotChoice(game);
+        resolveAllMandatoryActions(game);
+
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+
+        Player player = players.get(0);
+
+        int prestigeBefore = player.getPrestigeValue();
+
+        player.buildingCards.add(new BuildingCard(12, 1, 1, 7));
+        player.buildingCards.add(new BuildingCard(12, 1, 1, 5));
+
+        int expectedMinimumIncrease = 7 + 5;
+
+        resolveOptionalPhaseIfPresent(game);
+
+        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
+
+        assertTrue(
+                player.getPrestigeValue() >= prestigeBefore + expectedMinimumIncrease,
+                "Final scoring should add at least the prestige values of the two added building cards."
+        );
+    }
+
+    @Test
+    @Timeout(value = 20, unit = TimeUnit.SECONDS)
+    void endGameShouldApplyFinalCharacterPrestigeBonuses() {
+        Game game = new Game(3);
+
+        List<Player> players = addPlayers(game, 3, "final_characters_");
+        giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
+
+        while (game.getCurrentState().getRound() < 10) {
+            playOneFullRound(game);
+        }
+
+        completeSlotChoice(game);
+        resolveAllMandatoryActions(game);
+
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+
+        Player player = players.get(0);
+        assertNotNull(player);
+
+        int prestigeBefore = player.getPrestigeValue();
+
+        player.builders.add(new Builder(1, 0, 4));
+
+        player.inventors.add(new Inventor(1, 0));
+        player.inventors.add(new Inventor(1, 1));
+
+        player.artists.add(new Artist(1));
+        player.artists.add(new Artist(1));
+
+        int expectedMinimumIncrease = 4 + 4 + 10;
+
+        resolveOptionalPhaseIfPresent(game);
+
+        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
+
+        assertTrue(
+                player.getPrestigeValue() >= prestigeBefore + expectedMinimumIncrease,
+                "Final scoring should add at least builder prestige, inventor bonus, and artist pair bonus."
+        );
+    }
+
 }

src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order2Test.java

@@ -165,6 +165,5 @@ class Order2Test {
         order.push(p2);
         order.push(p1);
         order.pull().getUserName();
-        System.out.println(order);
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order3Test.java

@@ -195,11 +195,9 @@ class Order3Test {
         userPulled=order.pull().getUserName();
         userPulled=order.pull().getUserName();
 
-        System.out.println(values);
         order.push(p1);
         order.push(p2);
         values =(ArrayList<OrderPlayer>)field.get(order);
-        System.out.println(order);
 //        assertEquals("TURN ORDER\n" +
 //                "╔════════════════════════════════════╦════════════════════════════════════╦════════════════════════════════════╗\n" +
 //                "║ 0.                                 ║ 1. "+values.get(1).getUserName() +"║ 2. "+values.get(2).getUserName()+"║\n" +

src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order4Test.java

@@ -280,7 +280,6 @@ class Order4Test {
         Player p4 = new Player("wPIshOThiOpRRnIBFfM89s2$@q$9FGbz");
         Order4 order = new Order4(new ArrayList<>(Arrays.asList(p1, p2,p3,p4)));
         String userPulled=order.pull().getUserName();
-        System.out.println(order);
 
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/Orders/Order5Test.java

@@ -381,7 +381,6 @@ class Order5Test {
         order.pull();
         order.pull();
         order.push(p1);
-        System.out.println(order);
 
     }
 }

src/test/java/it/polimi/ingsw/gc14/Model/PlayerTest.java

@@ -220,7 +220,6 @@ class PlayerTest {
         p.buildingCards.add(new Building1(2, 5, 5, CharacterType.INVENTOR));
         p.buildingCards.add(new Building1(2, 5, 5, CharacterType.SHAMAN));
         p.buildingCards.add(new Building11(1, 5, 7, CharacterType.ARTIST , 3));
-        System.out.println(p.toString());
         assertEquals(""+
                 "╔═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗\n" +
                 "║ test_usr                                                                                                                            ║\n" +

src/test/java/it/polimi/ingsw/gc14/Model/SlotTest.java

@@ -46,7 +46,6 @@ class SlotTest {
         assertEquals(0, s.getNLower());
         assertEquals(0, s.getNUpper());
         assertEquals(5, s.getNMinPlayer());
-        System.out.println(s);
         assertEquals("SlotID: "+slotID+"\nNUpper: "+s.getNUpper()+"\nNLower: "+s.getNLower()+"\nFood: "+s.getFood()+"\n", s.toString());
     }
 
@@ -60,7 +59,6 @@ class SlotTest {
         assertEquals(1, s.getNLower());
         assertEquals(0, s.getNUpper());
         assertEquals(0, s.getNMinPlayer());
-        System.out.println(s);
         assertEquals("SlotID: "+slotID+"\nNUpper: "+s.getNUpper()+"\nNLower: "+s.getNLower()+"\nFood: "+s.getFood()+"\n", s.toString());
     }
 
@@ -74,7 +72,6 @@ class SlotTest {
         assertEquals(0, s.getNLower());
         assertEquals(1, s.getNUpper());
         assertEquals(0, s.getNMinPlayer());
-        System.out.println(s);
         assertEquals("SlotID: "+slotID+"\nNUpper: "+s.getNUpper()+"\nNLower: "+s.getNLower()+"\nFood: "+s.getFood()+"\n", s.toString());    }
 
     @Test
@@ -87,7 +84,6 @@ class SlotTest {
         assertEquals(2, s.getNLower());
         assertEquals(0, s.getNUpper());
         assertEquals(3, s.getNMinPlayer());
-        System.out.println(s);
         assertEquals("SlotID: "+slotID+"\nNUpper: "+s.getNUpper()+"\nNLower: "+s.getNLower()+"\nFood: "+s.getFood()+"\n", s.toString());
     }
 
@@ -101,7 +97,6 @@ class SlotTest {
         assertEquals(1, s.getNLower());
         assertEquals(1, s.getNUpper());
         assertEquals(0, s.getNMinPlayer());
-        System.out.println(s);
         assertEquals("SlotID: "+slotID+"\nNUpper: "+s.getNUpper()+"\nNLower: "+s.getNLower()+"\nFood: "+s.getFood()+"\n", s.toString());
     }
 
@@ -115,7 +110,6 @@ class SlotTest {
         assertEquals(0, s.getNLower());
         assertEquals(2, s.getNUpper());
         assertEquals(0, s.getNMinPlayer());
-        System.out.println(s);
         assertEquals("SlotID: "+slotID+"\nNUpper: "+s.getNUpper()+"\nNLower: "+s.getNLower()+"\nFood: "+s.getFood()+"\n", s.toString());
     }
 
@@ -129,7 +123,6 @@ class SlotTest {
         assertEquals(1, s.getNLower());
         assertEquals(2, s.getNUpper());
         assertEquals(4, s.getNMinPlayer());
-        System.out.println(s);
         assertEquals("SlotID: "+slotID+"\nNUpper: "+s.getNUpper()+"\nNLower: "+s.getNLower()+"\nFood: "+s.getFood()+"\n", s.toString());
     }
 }