Merge pull request #26

GameTest

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

@@ -0,0 +1,57 @@
+package it.polimi.ingsw.gc14.Controller;
+
+import it.polimi.ingsw.gc14.Model.Game;
+import it.polimi.ingsw.gc14.Model.Player;
+
+public class GameController {
+    private Game model;
+    public GameController(Game model) {
+        this.model = model;
+    }
+    public void addPlayer(String username) {
+        model.addPlayer(new Player(username));
+    }
+    public boolean drawUpperTribeCard(String playerUsername,int pos) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.DrawUpperTribeCardByIndex(model.getPlayerByUsername(playerUsername),pos);
+    }
+    public boolean drawLowerTribeCard(String playerUsername,int pos) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.DrawLowerTribeCardByIndex(model.getPlayerByUsername(playerUsername), pos);
+    }
+    public boolean drawUpperBuildingCard(String playerUsername,int pos) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.DrawUpperBuildingCardByIndex(model.getPlayerByUsername(playerUsername), pos);
+    }
+    public boolean drawLowerBuildingCard(String playerUsername,int pos) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.DrawLowerBuildingCardByIndex(model.getPlayerByUsername(playerUsername), pos);
+    }
+
+    public boolean pickOptionalTribeCard(String playerUsername,int pos) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.PickOptionalTribeCardByIndex(model.getPlayerByUsername(playerUsername), pos);
+    }
+    public boolean pickOptionalBuildingCard(String playerUsername,int pos) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)
+            return false;
+        return model.PickOptionalBuildingCard(model.getPlayerByUsername(playerUsername), pos);
+    }
+    public boolean slotChoice(String playerUsername,int pos) {
+        Player player= model.getPlayerByUsername(playerUsername);
+        if(player==null)//playerIndex>=model.)
+            return false;
+        return model.SlotChoiceByIndex(model.getPlayerByUsername(playerUsername),pos);
+    }
+}

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

@@ -33,13 +33,27 @@ public class Game {
         board.upperListTribe.forEach(x->cards.add(x.clone()));
         return cards;
     }
+    public List<TribeCard>getLowerListTribeCards() {
+        List<TribeCard> cards = new ArrayList<>();
+        board.lowerListTribe.forEach(x->cards.add(x.clone()));
+        return cards;
+    }
+    public List<BuildingCard>getUpperListBuilding() {
+        List<BuildingCard> cards = new ArrayList<>();
+        board.upperListBuilding.forEach(x->cards.add(x.clone()));
+        return cards;
+    }
+    public List<BuildingCard>getLowerListBuilding() {
+        List<BuildingCard> cards = new ArrayList<>();
+        board.lowerListBuilding.forEach(x->cards.add(x.clone()));
+        return cards;
+    }
     public CurrentState getCurrentState() {
         return currentState;
     };
-    public Player getPlayerByIndex(int playerIndex) throws IndexOutOfBoundsException {
+
-        if(playerIndex >= playersList.size())
+    public Player getPlayerByUsername(String Username) throws IndexOutOfBoundsException {
-            throw new IndexOutOfBoundsException("Player index out of bounds");
+        return playersList.stream().filter(x->x.getUserName().equals(Username)).findFirst().orElse(null);
-        return playersList.get(playerIndex);
     }
 
 
@@ -157,7 +171,7 @@ public class Game {
         if(currentState.getNLower() <1)
             return false;
         TribeCard tribeCard = board.lowerListTribe.get(cardIndex);
-        if(!tribeCard.IsEventCard())
+        if(tribeCard.IsEventCard())
             return false;
 
         Character tempCard = (Character) tribeCard;
@@ -228,36 +242,38 @@ public class Game {
     //endregion
 
     //region Optional Card Methods
-    public boolean PickOptionalTribeCard(Player player,TribeCard tribeCard) {
+    public boolean PickOptionalTribeCardByIndex(Player player,int cardIndex) {
         if(currentState.getGameStage() != GameStages.OPTIONAL_CARD_EFFECT){
             return false;
         }
         if(!player.equals(currentState.getCurrentPlayer())){
             return false;
         }
-        if(!board.upperListTribe.contains(tribeCard)){
+
+        if( cardIndex<0 || cardIndex >=board.upperListTribe.size())
             return false;
-        }
+        TribeCard tribeCard = board.upperListTribe.get(cardIndex);
-        if(tribeCard.IsEventCard()){
+
+        if(tribeCard.IsEventCard())
             return false;
-        }
+
         Character tempCard = (Character) tribeCard;
         tempCard.insert(player);
         board.removeUpperTribeCard(tempCard);
+        OptionalCardQueue.removeIf(x->x.equals(player));
         nextPlayerSetup();
-
         return true;
     }
-    public boolean PickOptionalBuildingCard(Player player, BuildingCard buildingCard) {
+    public boolean PickOptionalBuildingCard(Player player, int cardIndex) {
         if(currentState.getGameStage() != GameStages.OPTIONAL_CARD_EFFECT){
             return false;
         }
         if(!player.equals(currentState.getCurrentPlayer())){
             return false;
         }
-        if(!board.upperListBuilding.contains(buildingCard)){
+        if( cardIndex<0 || cardIndex >=board.upperListBuilding.size())
             return false;
-        }
+        BuildingCard buildingCard = board.upperListBuilding.get(cardIndex);
         if(buildingCard.buy(player)) {
             board.removeUpperBuildingCard(buildingCard);
         }
@@ -265,7 +281,7 @@ public class Game {
             return false;
         }
         nextPlayerSetup();
-
+        OptionalCardQueue.removeIf(x->x.equals(player));
         return true;
     }
 
@@ -305,9 +321,10 @@ public class Game {
         if(GameStages.RESOLVING_ACTIONS==currentState.getGameStage()) {
             orderLogicCard.push(currentState.getCurrentPlayer());
             slotMap.put(currentState.getSlot(), null);
-            for (Slot s : board.getSlotList()) {
+            for (Slot s : slotMap.keySet()) {
                 if (slotMap.get(s) != null) {
                     currentState.PlayerUpdate(slotMap.get(s), s);
+                    break;
                 }
             }
             if(slotMap.values().stream().allMatch(v -> v == null))

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

@@ -1,7 +1,15 @@
 package it.polimi.ingsw.gc14.Model;
 
+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.GamePackage.GameStages;
+import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.Test;
+import org.junit.platform.commons.annotation.Testable;
+
+import java.util.*;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -16,18 +24,40 @@ class GameTest {
 
     @Test
     void getUpperListTribeCards() {
+        int nPlayers = 3;
+        Game game=new Game(nPlayers);
+        assertEquals(nPlayers+4 ,game.getUpperListTribeCards().size());
+    }
+    @Test
+    void getUpperListBuildingCards() {
+        int nPlayers = 3;
+        Game game=new Game(nPlayers);
+        assertEquals(2 ,game.getUpperListBuilding().size());
     }
 
     @Test
-    void getCurrentState() {
+    void getLowerListBuildingCards() {
+        int nPlayers = 3;
+        Game game=new Game(nPlayers);
+        assertEquals(0 ,game.getLowerListBuilding().size());
     }
 
+
+    @Test
+    void getLowerListTribeCards() {
+        int nPlayers = 3;
+        Game game=new Game(nPlayers);
+        assertEquals(nPlayers+1 ,game.getLowerListTribeCards().size());
+    }
+
+
     @Test
     void getPlayerByIndex() {
     }
 
     @Test
     void getNPlayers() {
+
     }
 
     @Test
@@ -43,7 +73,6 @@ class GameTest {
         assertFalse(game.addPlayer(p2));
         assertTrue(game.addPlayer(p3));
 
-
         assertEquals(GameStages.SLOT_CHOICE,game.getCurrentState().getGameStage());
         assertFalse(game.addPlayer(p4));
 
@@ -60,20 +89,95 @@ class GameTest {
     }
 
     @Test
-    void drawUpperTribeCardByIndex() {
+    void drawingByIndex() {
+        Game game=new Game(3);
+        Player p1=new Player("p1");
+        Player p2=new Player("p2");
+        Player p3=new Player("p3");
+        Player p4=new Player("p3");
+
+        assertTrue(game.addPlayer(p1));
+        assertTrue(game.addPlayer(p2));
+        assertFalse(game.addPlayer(p2));
+        assertTrue(game.addPlayer(p3));
+
+        Queue<Player>players=new LinkedList<>();
+        for(int i=0;i<3;i++) {
+            players.add( game.getCurrentState().getCurrentPlayer());
+            assertTrue(game.SlotChoiceByIndex(game.getCurrentState().getCurrentPlayer(), i));
+        }
+        Player temp_player;
+
+        temp_player=players.poll();
+        assertEquals(temp_player,game.getCurrentState().getCurrentPlayer());
+
+        int index;
+        List<TribeCard> cards=game.getLowerListTribeCards();
+
+        index=cards.indexOf(cards.stream().filter(x->!x.IsEventCard()).findFirst().get());
+        assertTrue(game.DrawLowerTribeCardByIndex(temp_player,index));
+
+        temp_player=players.poll();
+        assertEquals(temp_player,game.getCurrentState().getCurrentPlayer());
+        int nCards=game.getUpperListTribeCards().size();
+        int countCards=0;
+        HashMap<CharacterType,Integer>nCardsByType=new HashMap<CharacterType, Integer>();
+        Arrays.stream(CharacterType.values()).forEach(type->nCardsByType.put(type,0));
+        while(game.getCurrentState().getNUpper()>1) {
+            cards=game.getUpperListTribeCards();
+            TribeCard temp_card=cards.stream().filter(x->!x.IsEventCard()).findFirst().get();
+            index=cards.indexOf(temp_card);
+            assertEquals(nCards-countCards,game.getUpperListTribeCards().size()-countCards);
+            drawTribeTest(nCardsByType,nCards,countCards,temp_card,temp_player,game);
+            assertTrue(game.DrawUpperTribeCardByIndex(temp_player,index));
+            countCards++;
+        }
+        cards=game.getUpperListTribeCards();
+
+        index=cards.indexOf(cards.stream().filter(TribeCard::IsEventCard).findFirst().get());
+        assertFalse(game.DrawUpperTribeCardByIndex(temp_player,index));
+        //index=cards.indexOf(cards.stream().filter(x->!x.IsEventCard()).findFirst().get());
+        //assertTrue(game.DrawUpperTribeCardByIndex(temp_player,index));
+        List<BuildingCard> buildings=game.getUpperListBuilding();
+        temp_player.addFood(10);
+        index=0;
+        assertTrue(game.DrawUpperBuildingCardByIndex(temp_player,index));
+        index=cards.indexOf(cards.stream().filter(x->!x.IsEventCard()).findFirst().get());
+        assertFalse(game.DrawUpperTribeCardByIndex(temp_player,index));
+
+
+    }
+    private void drawTribeTest(HashMap<CharacterType,Integer>nCardsByType,int nCards,int countCards,TribeCard temp_card,Player temp_player,Game game) {
+
+        switch (((Character)temp_card).getType()) {
+            case CharacterType.ARTIST:
+                assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.artists.size());
+                nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
+                break;
+            case CharacterType.INVENTOR:
+                assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.inventors.size());
+                nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
+                break;
+            case CharacterType.HUNTER:
+                assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.hunters.size());
+                nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
+                break;
+            case CharacterType.SHAMAN:
+                assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.shamans.size());
+                nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
+                break;
+            case CharacterType.BUILDER:
+                assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.builders.size());
+                nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
+                break;
+            case CharacterType.GATHERER:
+                assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.gatherers.size());
+                nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
+                break;
+
+        }
     }
 
-    @Test
-    void drawLowerTribeCardByIndex() {
-    }
-
-    @Test
-    void drawUpperBuildingCardByIndex() {
-    }
-
-    @Test
-    void drawLowerBuildingCardByIndex() {
-    }
     @Test
     void pickOptionalTribeCard() {
     }