Merge pull request #26

GameTest
2026-04-12 19:52:42 +02:00
parent 30c07eff83 6763f7e630
commit 5f2903e03c
3 changed files with 208 additions and 30 deletions
@@ -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);
+    }
+}
@@ -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())
-            throw new IndexOutOfBoundsException("Player index out of bounds");
-        return playersList.get(playerIndex);
+
+    public Player getPlayerByUsername(String Username) throws IndexOutOfBoundsException {
+        return playersList.stream().filter(x->x.getUserName().equals(Username)).findFirst().orElse(null);
    }


@@ -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;
-        }
-        if(tribeCard.IsEventCard()){
+        TribeCard tribeCard = board.upperListTribe.get(cardIndex);
+
+        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))
@@ -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() {
    }