MatteoPellegrino05
1061 lines
34 KiB
Java
1061 lines
34 KiB
Java
package it.polimi.ingsw.gc14.Model;
|
|
|
|
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.GamePackage.GameStages;
|
|
import org.junit.jupiter.api.Test;
|
|
|
|
import java.util.*;
|
|
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
class GameTest {
|
|
|
|
|
|
private Queue<Player> completeSlotChoice(Game game) {
|
|
Queue<Player> order = new LinkedList<>();
|
|
|
|
for (int i = 0; i < game.getNPlayers(); i++) {
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
order.add(current);
|
|
|
|
assertTrue(game.SlotChoiceByIndex(current, i));
|
|
}
|
|
|
|
assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
|
|
|
|
return order;
|
|
}
|
|
|
|
private int firstNonEventIndex(List<TribeCard> cards) {
|
|
for (int i = 0; i < cards.size(); i++) {
|
|
if (!cards.get(i).IsEventCard()) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
fail("No non-event tribe card available.");
|
|
return -1;
|
|
}
|
|
|
|
private int firstNonEventIndexOrMinusOne(List<TribeCard> cards) {
|
|
for (int i = 0; i < cards.size(); i++) {
|
|
if (!cards.get(i).IsEventCard()) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private void giveOptionalEffectToAllPlayers(Player... players) {
|
|
for (Player player : players) {
|
|
player.buildingCards.add(new BuildingCard(12, 1, 1, 0));
|
|
}
|
|
}
|
|
|
|
private void resolveAllMandatoryActions(Game game) {
|
|
int guard = 0;
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 50) {
|
|
guard++;
|
|
resolveOneMandatoryAction(game);
|
|
}
|
|
|
|
assertTrue(guard < 50, "Possible infinite loop while resolving mandatory actions.");
|
|
}
|
|
|
|
private void resolveOneMandatoryAction(Game game) {
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
if (game.getCurrentState().getNLower() > 0) {
|
|
int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
|
|
|
|
if (index != -1) {
|
|
assertTrue(game.DrawLowerTribeCardByIndex(current, index));
|
|
} else if (!game.getLowerListBuilding().isEmpty()) {
|
|
current.addFood(100);
|
|
assertTrue(game.DrawLowerBuildingCardByIndex(current, 0));
|
|
} else {
|
|
fail("No valid lower card available.");
|
|
}
|
|
|
|
} else if (game.getCurrentState().getNUpper() > 0) {
|
|
int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
|
|
|
|
if (index != -1) {
|
|
assertTrue(game.DrawUpperTribeCardByIndex(current, index));
|
|
} else if (!game.getUpperListBuilding().isEmpty()) {
|
|
current.addFood(100);
|
|
assertTrue(game.DrawUpperBuildingCardByIndex(current, 0));
|
|
} else {
|
|
fail("No valid upper card available.");
|
|
}
|
|
|
|
} else {
|
|
fail("Current player has no remaining draws.");
|
|
}
|
|
}
|
|
|
|
private void resolveActionsUntilOptionalCardEffect(Game game) {
|
|
int guard = 0;
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 50) {
|
|
guard++;
|
|
resolveOneMandatoryAction(game);
|
|
}
|
|
|
|
assertTrue(guard < 50, "Possible infinite loop while resolving mandatory actions.");
|
|
assertEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
|
|
}
|
|
|
|
|
|
private void setCurrentStateEra(Game game, int era) {
|
|
try {
|
|
java.lang.reflect.Field field = game.getCurrentState().getClass().getDeclaredField("Era");
|
|
field.setAccessible(true);
|
|
field.set(game.getCurrentState(), era);
|
|
} catch (Exception e) {
|
|
fail("Failed to set CurrentState era: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
private static class FinalTestBuildingCard extends BuildingCard {
|
|
|
|
FinalTestBuildingCard() {
|
|
super(12, 1, 1, 0);
|
|
}
|
|
|
|
@Override
|
|
public EffectType getEffectType() {
|
|
return EffectType.FINAL;
|
|
}
|
|
|
|
@Override
|
|
public void applyEffect(Player player) {
|
|
player.addPrestige(10);
|
|
}
|
|
}
|
|
|
|
private int slotIndexById(Game game, char slotId) {
|
|
it.polimi.ingsw.gc14.Model.GamePackage.Board board = getBoard(game);
|
|
List<Slot> slots = board.getSlotList();
|
|
|
|
for (int i = 0; i < slots.size(); i++) {
|
|
if (slots.get(i).getSlotId() == slotId) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
fail("No slot found with id: " + slotId);
|
|
return -1;
|
|
}
|
|
|
|
private Player completeSlotChoiceAndAdvanceToPlayerOnSlot(Game game, char slotId) {
|
|
Player targetPlayer = game.getCurrentState().getCurrentPlayer();
|
|
int targetSlotIndex = slotIndexById(game, slotId);
|
|
|
|
assertTrue(game.SlotChoiceByIndex(targetPlayer, targetSlotIndex));
|
|
|
|
Set<Integer> usedSlots = new HashSet<>();
|
|
usedSlots.add(targetSlotIndex);
|
|
|
|
int nextSlotIndex = 0;
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.SLOT_CHOICE) {
|
|
while (usedSlots.contains(nextSlotIndex)) {
|
|
nextSlotIndex++;
|
|
}
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.SlotChoiceByIndex(current, nextSlotIndex));
|
|
usedSlots.add(nextSlotIndex);
|
|
}
|
|
|
|
assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
|
|
|
|
int guard = 0;
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS
|
|
&& !targetPlayer.equals(game.getCurrentState().getCurrentPlayer())
|
|
&& guard < 20) {
|
|
guard++;
|
|
resolveOneMandatoryAction(game);
|
|
}
|
|
|
|
assertTrue(guard < 20, "Possible infinite loop while reaching target player's slot.");
|
|
assertEquals(targetPlayer, game.getCurrentState().getCurrentPlayer());
|
|
|
|
return targetPlayer;
|
|
}
|
|
|
|
private void resolveOptionalPhaseIfPresent(Game game) {
|
|
int guard = 0;
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.OPTIONAL_CARD_EFFECT && guard < 10) {
|
|
guard++;
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.NoOptionalCard(current));
|
|
}
|
|
|
|
assertTrue(guard < 10, "Possible infinite loop during optional phase.");
|
|
}
|
|
|
|
private void playOneFullRound(Game game) {
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
completeSlotChoice(game);
|
|
|
|
assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
|
|
|
|
resolveAllMandatoryActions(game);
|
|
|
|
resolveOptionalPhaseIfPresent(game);
|
|
}
|
|
|
|
@Test
|
|
void constructorShouldInitializeGameCorrectly() {
|
|
int nPlayers = 3;
|
|
Game game = new Game(nPlayers);
|
|
|
|
assertEquals(nPlayers, game.getNPlayers());
|
|
assertEquals(GameStages.WAITING, game.getCurrentState().getGameStage());
|
|
|
|
assertThrows(IllegalArgumentException.class, () -> new Game(6));
|
|
assertThrows(IllegalArgumentException.class, () -> new Game(-1));
|
|
|
|
game = new Game();
|
|
|
|
assertFalse(game.addPlayer(new Player("p1")));
|
|
|
|
|
|
assertTrue(game.setNPlayer(nPlayers));
|
|
assertTrue(game.addPlayer(new Player("p1")));
|
|
|
|
assertEquals(nPlayers, game.getNPlayers());
|
|
assertEquals(GameStages.WAITING, game.getCurrentState().getGameStage());
|
|
}
|
|
|
|
@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 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 getPlayerByUsernameShouldReturnPlayerOrNull() {
|
|
Game game = new Game(3);
|
|
|
|
Player p1 = new Player("p1");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
|
|
assertEquals(p1, game.getPlayerByUsername("p1"));
|
|
assertNull(game.getPlayerByUsername("ghost"));
|
|
}
|
|
|
|
@Test
|
|
void setNPlayerShouldWorkOnlyIfGameWasCreatedWithZeroPlayers() {
|
|
Game game = new Game();
|
|
|
|
assertTrue(game.setNPlayer(3));
|
|
assertEquals(3, game.getNPlayers());
|
|
|
|
assertFalse(game.setNPlayer(4));
|
|
}
|
|
|
|
@Test
|
|
void addPlayerShouldRejectDuplicatesAndStartSlotChoiceWhenFull() {
|
|
Game game = new Game(3);
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
Player p4 = new Player("p4");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertFalse(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
assertFalse(game.addPlayer(p4));
|
|
}
|
|
|
|
@Test
|
|
void slotChoiceByIndexShouldRejectInvalidWrongAndOccupiedSlot() {
|
|
Game game = new Game(3);
|
|
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
assertFalse(game.SlotChoiceByIndex(current, -1));
|
|
assertFalse(game.SlotChoiceByIndex(current, 999));
|
|
|
|
Player wrongPlayer = current.equals(p1) ? p2 : p1;
|
|
assertFalse(game.SlotChoiceByIndex(wrongPlayer, 0));
|
|
|
|
assertTrue(game.SlotChoiceByIndex(current, 0));
|
|
|
|
Player next = game.getCurrentState().getCurrentPlayer();
|
|
assertFalse(game.SlotChoiceByIndex(next, 0));
|
|
}
|
|
|
|
@Test
|
|
void drawingByIndex() {
|
|
Game game = new Game(3);
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = 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 = firstNonEventIndex(cards);
|
|
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();
|
|
index = firstNonEventIndexOrMinusOne(cards);
|
|
|
|
if (index == -1) {
|
|
break;
|
|
}
|
|
|
|
TribeCard temp_card = cards.get(index);
|
|
assertEquals(nCards - countCards, game.getUpperListTribeCards().size());
|
|
assertTrue(game.DrawUpperTribeCardByIndex(temp_player, index));
|
|
drawTribeTest(nCardsByType, temp_card, temp_player);
|
|
countCards++;
|
|
}
|
|
cards = game.getUpperListTribeCards();
|
|
|
|
int eventIndex = firstEventIndexOrMinusOne(cards);
|
|
if (eventIndex != -1) {
|
|
assertFalse(game.DrawUpperTribeCardByIndex(temp_player, eventIndex));
|
|
}
|
|
|
|
temp_player.addFood(100);
|
|
|
|
assertFalse(game.getUpperListBuilding().isEmpty());
|
|
|
|
index = 0;
|
|
assertTrue(game.DrawUpperBuildingCardByIndex(temp_player, index));
|
|
|
|
int remainingTribeIndex = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
|
|
if (remainingTribeIndex != -1) {
|
|
assertFalse(game.DrawUpperTribeCardByIndex(temp_player, remainingTribeIndex));
|
|
}
|
|
|
|
Player thirdPlayer = players.poll();
|
|
assertNotNull(thirdPlayer);
|
|
assertEquals(thirdPlayer, game.getCurrentState().getCurrentPlayer());
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS
|
|
&& thirdPlayer.equals(game.getCurrentState().getCurrentPlayer())) {
|
|
resolveOneMandatoryAction(game);
|
|
}
|
|
|
|
assertNotEquals(thirdPlayer, game.getCurrentState().getCurrentPlayer());
|
|
|
|
|
|
}
|
|
|
|
private void drawTribeTest(HashMap<CharacterType, Integer> nCardsByType,
|
|
TribeCard temp_card,
|
|
Player temp_player) {
|
|
|
|
switch (((Character) temp_card).getType()) {
|
|
case ARTIST:
|
|
assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.artists.size());
|
|
nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
|
|
break;
|
|
case INVENTOR:
|
|
assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.inventors.size());
|
|
nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
|
|
break;
|
|
case HUNTER:
|
|
assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.hunters.size());
|
|
nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
|
|
break;
|
|
case SHAMAN:
|
|
assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.shamans.size());
|
|
nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
|
|
break;
|
|
case BUILDER:
|
|
assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.builders.size());
|
|
nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
|
|
break;
|
|
case 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 pickOptionalTribeCard() {
|
|
Game game = new Game(3);
|
|
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
|
|
giveOptionalEffectToAllPlayers(p1, p2, p3);
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
int index = firstNonEventIndex(game.getUpperListTribeCards());
|
|
|
|
int charactersBefore = current.getTotCharacters();
|
|
|
|
assertTrue(game.PickOptionalTribeCardByIndex(current, index));
|
|
|
|
assertEquals(charactersBefore + 1, current.getTotCharacters());
|
|
}
|
|
|
|
@Test
|
|
void pickOptionalBuildingCard() {
|
|
Game game = new Game(3);
|
|
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
|
|
giveOptionalEffectToAllPlayers(p1, p2, p3);
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertFalse(game.getUpperListBuilding().isEmpty());
|
|
|
|
current.addFood(100);
|
|
|
|
int foodBefore = current.getFoodValue();
|
|
int buildingsBefore = current.buildingCards.size();
|
|
|
|
assertTrue(game.PickOptionalBuildingCard(current, 0));
|
|
|
|
assertTrue(current.getFoodValue() < foodBefore);
|
|
assertEquals(buildingsBefore + 1, current.buildingCards.size());
|
|
}
|
|
|
|
@Test
|
|
void noOptionalCard() {
|
|
Game game = new Game(3);
|
|
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
|
|
giveOptionalEffectToAllPlayers(p1, p2, p3);
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.NoOptionalCard(current));
|
|
|
|
assertEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
|
|
assertNotEquals(current, game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
private List<Player> addPlayers(Game game, int nPlayers, String prefix) {
|
|
List<Player> players = new ArrayList<>();
|
|
|
|
for (int i = 1; i <= nPlayers; i++) {
|
|
Player player = new Player(prefix + i);
|
|
players.add(player);
|
|
assertTrue(game.addPlayer(player));
|
|
}
|
|
|
|
return players;
|
|
}
|
|
|
|
private int firstEventIndexOrMinusOne(List<TribeCard> cards) {
|
|
for (int i = 0; i < cards.size(); i++) {
|
|
if (cards.get(i).IsEventCard()) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private it.polimi.ingsw.gc14.Model.GamePackage.Board getBoard(Game game) {
|
|
try {
|
|
java.lang.reflect.Field field = Game.class.getDeclaredField("board");
|
|
field.setAccessible(true);
|
|
return (it.polimi.ingsw.gc14.Model.GamePackage.Board) field.get(game);
|
|
} catch (Exception e) {
|
|
fail("Failed to access board field: " + e.getMessage());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private void invokePrivateMethod(Game game, String methodName) {
|
|
try {
|
|
java.lang.reflect.Method method = Game.class.getDeclaredMethod(methodName);
|
|
method.setAccessible(true);
|
|
method.invoke(game);
|
|
} catch (Exception e) {
|
|
fail("Failed to invoke private method " + methodName + ": " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Test
|
|
void getCurrentPlayerNumberShouldTrackAddedPlayers() {
|
|
Game game = new Game(3);
|
|
|
|
assertEquals(0, game.getCurrentPlayerNumber());
|
|
|
|
assertTrue(game.addPlayer(new Player("a")));
|
|
assertEquals(1, game.getCurrentPlayerNumber());
|
|
|
|
assertTrue(game.addPlayer(new Player("b")));
|
|
assertEquals(2, game.getCurrentPlayerNumber());
|
|
|
|
assertTrue(game.addPlayer(new Player("c")));
|
|
assertEquals(3, game.getCurrentPlayerNumber());
|
|
}
|
|
|
|
|
|
@Test
|
|
void slotChoiceByIndexShouldReturnFalseOutsideSlotChoiceStage() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "slot_out_");
|
|
|
|
completeSlotChoice(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertFalse(game.SlotChoiceByIndex(current, 0));
|
|
}
|
|
|
|
@Test
|
|
void drawMethodsShouldRejectWrongStateInvalidIndexesAndWrongPlayer() {
|
|
Game game = new Game(3);
|
|
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertFalse(game.DrawLowerTribeCardByIndex(current, 0));
|
|
assertFalse(game.DrawUpperTribeCardByIndex(current, 0));
|
|
assertFalse(game.DrawUpperBuildingCardByIndex(current, 0));
|
|
assertFalse(game.DrawLowerBuildingCardByIndex(current, 0));
|
|
|
|
completeSlotChoice(game);
|
|
|
|
current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
Player wrongPlayer = current.equals(p1) ? p2 : p1;
|
|
|
|
assertFalse(game.DrawLowerTribeCardByIndex(current, -1));
|
|
assertFalse(game.DrawLowerTribeCardByIndex(current, 999));
|
|
|
|
assertFalse(game.DrawUpperTribeCardByIndex(current, -1));
|
|
assertFalse(game.DrawUpperTribeCardByIndex(current, 999));
|
|
|
|
assertFalse(game.DrawUpperBuildingCardByIndex(current, -1));
|
|
assertFalse(game.DrawUpperBuildingCardByIndex(current, 999));
|
|
|
|
assertFalse(game.DrawLowerBuildingCardByIndex(current, -1));
|
|
assertFalse(game.DrawLowerBuildingCardByIndex(current, 999));
|
|
|
|
int lowerIndex = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
|
|
if (lowerIndex != -1) {
|
|
assertFalse(game.DrawLowerTribeCardByIndex(wrongPlayer, lowerIndex));
|
|
}
|
|
|
|
int upperIndex = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
|
|
if (upperIndex != -1) {
|
|
assertFalse(game.DrawUpperTribeCardByIndex(wrongPlayer, upperIndex));
|
|
}
|
|
|
|
if (!game.getUpperListBuilding().isEmpty()) {
|
|
assertFalse(game.DrawUpperBuildingCardByIndex(wrongPlayer, 0));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
void drawLowerBuildingCardShouldWorkWhenLowerBuildingExists() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "lower_building_");
|
|
|
|
Player current = completeSlotChoiceAndAdvanceToPlayerOnSlot(game, 'D');
|
|
assertNotNull(current);
|
|
|
|
it.polimi.ingsw.gc14.Model.GamePackage.Board board = getBoard(game);
|
|
assertNotNull(board);
|
|
|
|
board.lowerListBuilding.clear();
|
|
board.lowerListBuilding.add(new BuildingCard(12, 1, 1, 0));
|
|
|
|
current.addFood(100);
|
|
|
|
int foodBefore = current.getFoodValue();
|
|
int buildingsBefore = current.buildingCards.size();
|
|
|
|
assertTrue(game.DrawLowerBuildingCardByIndex(current, 0));
|
|
|
|
assertTrue(current.getFoodValue() < foodBefore);
|
|
assertEquals(buildingsBefore + 1, current.buildingCards.size());
|
|
assertEquals(1, game.getCurrentState().getNLower());
|
|
}
|
|
|
|
@Test
|
|
void optionalMethodsShouldReturnFalseOutsideOptionalState() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "optional_out_");
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertFalse(game.PickOptionalTribeCardByIndex(current, 0));
|
|
assertFalse(game.PickOptionalBuildingCard(current, 0));
|
|
assertFalse(game.NoOptionalCard(current));
|
|
}
|
|
|
|
@Test
|
|
void optionalMethodsShouldRejectWrongPlayerAndInvalidIndexes() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "optional_invalid_");
|
|
|
|
giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
Player wrongPlayer = current.equals(players.get(0)) ? players.get(1) : players.get(0);
|
|
|
|
assertFalse(game.PickOptionalTribeCardByIndex(wrongPlayer, 0));
|
|
assertFalse(game.PickOptionalBuildingCard(wrongPlayer, 0));
|
|
assertFalse(game.NoOptionalCard(wrongPlayer));
|
|
|
|
assertFalse(game.PickOptionalTribeCardByIndex(current, -1));
|
|
assertFalse(game.PickOptionalTribeCardByIndex(current, 999));
|
|
|
|
assertFalse(game.PickOptionalBuildingCard(current, -1));
|
|
assertFalse(game.PickOptionalBuildingCard(current, 999));
|
|
|
|
}
|
|
|
|
@Test
|
|
void pickOptionalBuildingCardShouldReturnFalseIfPlayerCannotPay() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "optional_no_food_");
|
|
|
|
giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
if (!game.getUpperListBuilding().isEmpty()) {
|
|
assertFalse(game.PickOptionalBuildingCard(current, 0));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
void eventResolutionShouldDoNothingOutsideResolvingEventStage() {
|
|
Game game = new Game(3);
|
|
|
|
assertEquals(GameStages.WAITING, game.getCurrentState().getGameStage());
|
|
|
|
invokePrivateMethod(game, "EventResolution");
|
|
|
|
assertEquals(GameStages.WAITING, game.getCurrentState().getGameStage());
|
|
}
|
|
|
|
|
|
@Test
|
|
void nextRoundShouldIncreaseRound() {
|
|
Game game = new Game(3);
|
|
|
|
int roundBefore = game.getCurrentState().getRound();
|
|
|
|
invokePrivateMethod(game, "nextRound");
|
|
|
|
assertEquals(roundBefore + 1, game.getCurrentState().getRound());
|
|
}
|
|
|
|
@Test
|
|
void addObserverAndNotifyObserversShouldCallObserver() {
|
|
Game game = new Game(3);
|
|
|
|
final boolean[] notified = {false};
|
|
|
|
game.addObserver(updatedGame -> {
|
|
assertSame(game, updatedGame);
|
|
notified[0] = true;
|
|
});
|
|
|
|
invokePrivateMethod(game, "notifyObservers");
|
|
|
|
assertTrue(notified[0]);
|
|
}
|
|
|
|
@Test
|
|
void drawLowerTribeCardShouldReturnFalseWhenNoLowerDrawsAreAvailable() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "no_lower_");
|
|
|
|
Player current = completeSlotChoiceAndAdvanceToPlayerOnSlot(game, 'C');
|
|
assertNotNull(current);
|
|
|
|
int index = firstNonEventIndex(game.getLowerListTribeCards());
|
|
|
|
assertEquals(0, game.getCurrentState().getNLower());
|
|
assertFalse(game.DrawLowerTribeCardByIndex(current, index));
|
|
}
|
|
|
|
@Test
|
|
void drawLowerTribeCardShouldReturnFalseForEventCard() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "lower_event_");
|
|
|
|
Player current = completeSlotChoiceAndAdvanceToPlayerOnSlot(game, 'B');
|
|
assertNotNull(current);
|
|
|
|
it.polimi.ingsw.gc14.Model.GamePackage.Board board = getBoard(game);
|
|
assertNotNull(board);
|
|
|
|
board.lowerListTribe.add(0,
|
|
new it.polimi.ingsw.gc14.Model.Cards.TribeCards.Events.Sustenance(1, 3));
|
|
|
|
assertTrue(board.lowerListTribe.get(0).IsEventCard());
|
|
assertFalse(game.DrawLowerTribeCardByIndex(current, 0));
|
|
}
|
|
|
|
@Test
|
|
void drawUpperBuildingCardShouldReturnFalseWhenNoUpperDrawsAreAvailable() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "no_upper_building_");
|
|
|
|
Player current = completeSlotChoiceAndAdvanceToPlayerOnSlot(game, 'B');
|
|
assertNotNull(current);
|
|
|
|
it.polimi.ingsw.gc14.Model.GamePackage.Board board = getBoard(game);
|
|
assertNotNull(board);
|
|
|
|
board.upperListBuilding.clear();
|
|
board.upperListBuilding.add(new BuildingCard(12, 1, 1, 0));
|
|
|
|
current.addFood(100);
|
|
|
|
assertEquals(0, game.getCurrentState().getNUpper());
|
|
assertFalse(game.DrawUpperBuildingCardByIndex(current, 0));
|
|
}
|
|
|
|
@Test
|
|
void drawUpperBuildingCardShouldBuyBuildingAndDecreaseUpperDraws() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "upper_buy_true_");
|
|
|
|
Player current = completeSlotChoiceAndAdvanceToPlayerOnSlot(game, 'F');
|
|
assertNotNull(current);
|
|
|
|
it.polimi.ingsw.gc14.Model.GamePackage.Board board = getBoard(game);
|
|
assertNotNull(board);
|
|
|
|
board.upperListBuilding.clear();
|
|
board.upperListBuilding.add(new BuildingCard(12, 1, 1, 0));
|
|
|
|
current.addFood(100);
|
|
|
|
int foodBefore = current.getFoodValue();
|
|
int buildingsBefore = current.buildingCards.size();
|
|
|
|
assertTrue(game.DrawUpperBuildingCardByIndex(current, 0));
|
|
|
|
assertTrue(current.getFoodValue() < foodBefore);
|
|
assertEquals(buildingsBefore + 1, current.buildingCards.size());
|
|
assertEquals(1, game.getCurrentState().getNUpper());
|
|
}
|
|
|
|
@Test
|
|
void nextRoundShouldUpdateEraWhenBoardEraDiffersFromCurrentStateEra() {
|
|
Game game = new Game(3);
|
|
|
|
setCurrentStateEra(game, 0);
|
|
|
|
assertEquals(0, game.getCurrentState().getEra());
|
|
|
|
invokePrivateMethod(game, "nextRound");
|
|
|
|
assertEquals(1, game.getCurrentState().getEra());
|
|
}
|
|
|
|
@Test
|
|
void endGameShouldApplyFinalBuildingEffectsAndSetEndedStage() {
|
|
Game game = new Game(3);
|
|
|
|
Player player = new Player("final_player");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
|
|
assertTrue(game.addPlayer(player));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
|
|
player.buildingCards.add(new FinalTestBuildingCard());
|
|
|
|
int prestigeBefore = player.getPrestigeValue();
|
|
|
|
invokePrivateMethod(game, "endGame");
|
|
|
|
assertEquals(prestigeBefore + 10, player.getPrestigeValue());
|
|
assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
|
|
}
|
|
|
|
@Test
|
|
void shouldNotCrashWhenNoPlayerHasOptionalEffect() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "no_optional_");
|
|
|
|
completeSlotChoice(game);
|
|
|
|
assertDoesNotThrow(() -> resolveAllMandatoryActions(game));
|
|
|
|
assertNotEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
|
|
}
|
|
|
|
|
|
@Test
|
|
void constructorShouldRejectOnePlayerGame() {
|
|
assertThrows(IllegalArgumentException.class, () -> new Game(1));
|
|
}
|
|
|
|
@Test
|
|
void setNPlayerShouldAllowCompleteGameSetup() {
|
|
Game game = new Game();
|
|
|
|
assertTrue(game.setNPlayer(3));
|
|
|
|
assertTrue(game.addPlayer(new Player("p1")));
|
|
assertTrue(game.addPlayer(new Player("p2")));
|
|
assertTrue(game.addPlayer(new Player("p3")));
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.SlotChoiceByIndex(current, 0));
|
|
}
|
|
|
|
@Test
|
|
void fullGameShouldEndAfterTenRoundsUsingOnlyPublicGameFlow() {
|
|
Game game = new Game(3);
|
|
|
|
assertTrue(game.addPlayer(new Player("p1")));
|
|
assertTrue(game.addPlayer(new Player("p2")));
|
|
assertTrue(game.addPlayer(new Player("p3")));
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
int guard = 0;
|
|
|
|
while (game.getCurrentState().getGameStage() != GameStages.ENDED && guard < 20) {
|
|
guard++;
|
|
|
|
playOneFullRound(game);
|
|
|
|
assertTrue(
|
|
game.getCurrentState().getGameStage() == GameStages.SLOT_CHOICE
|
|
|| game.getCurrentState().getGameStage() == GameStages.ENDED,
|
|
"After a full round, the game should either start the next slot choice phase or end."
|
|
);
|
|
}
|
|
|
|
assertTrue(guard < 20, "Possible infinite loop while playing the full game.");
|
|
assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
|
|
assertEquals(10, game.getCurrentState().getRound());
|
|
}
|
|
|
|
@Test
|
|
void setNPlayerShouldRejectInvalidPlayerCounts() {
|
|
assertFalse(new Game().setNPlayer(-1));
|
|
assertFalse(new Game().setNPlayer(1));
|
|
assertFalse(new Game().setNPlayer(6));
|
|
}
|
|
|
|
@Test
|
|
void addPlayerShouldRejectDifferentPlayerWithSameUsername() {
|
|
Game game = new Game(3);
|
|
|
|
assertTrue(game.addPlayer(new Player("same_name")));
|
|
assertFalse(game.addPlayer(new Player("same_name")));
|
|
}
|
|
|
|
@Test
|
|
void roundShouldAdvanceAfterOnlyOptionalPlayerSkipsOptionalCard() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "single_optional_");
|
|
|
|
players.get(0).buildingCards.add(new BuildingCard(12, 1, 1, 0));
|
|
|
|
int roundBefore = game.getCurrentState().getRound();
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.NoOptionalCard(current));
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
assertEquals(roundBefore + 1, game.getCurrentState().getRound());
|
|
assertNotNull(game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
@Test
|
|
void roundShouldAdvanceAfterAllOptionalPlayersSkipOptionalCard() {
|
|
Game game = new Game(3);
|
|
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
|
|
giveOptionalEffectToAllPlayers(p1, p2, p3);
|
|
|
|
int roundBefore = game.getCurrentState().getRound();
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
int guard = 0;
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.OPTIONAL_CARD_EFFECT && guard < 10) {
|
|
guard++;
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.NoOptionalCard(current));
|
|
}
|
|
|
|
assertTrue(guard < 10, "Possible infinite loop during optional phase.");
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
assertEquals(roundBefore + 1, game.getCurrentState().getRound());
|
|
assertNotNull(game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
|
|
} |