MatteoPellegrino05
1789 lines
61 KiB
Java
1789 lines
61 KiB
Java
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 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.util.*;
|
|
import java.util.stream.Stream;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
@Timeout(value = 10, unit = TimeUnit.SECONDS)
|
|
class GameTest {
|
|
|
|
private void completeTotemChoice(Game game) {
|
|
assertEquals(GameStages.TOTEM_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.TOTEM_CHOICE) {
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
List<Totems> availableTotems = game.getAvailableTotems();
|
|
assertFalse(availableTotems.isEmpty());
|
|
|
|
Totems selectedTotem = availableTotems.get(0);
|
|
|
|
assertTrue(game.TotemChoice(current, selectedTotem));
|
|
assertEquals(selectedTotem, current.totem);
|
|
}
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
assertNotNull(game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
private Queue<Player> completeSlotChoice(Game game) {
|
|
if (game.getCurrentState().getGameStage() == GameStages.TOTEM_CHOICE) {
|
|
completeTotemChoice(game);
|
|
}
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
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));
|
|
|
|
assertTrue(
|
|
game.getSlotMap().values().stream()
|
|
.anyMatch(player -> player != null
|
|
&& player.getUserName().equals(current.getUserName())),
|
|
"The selected player should be present in the slot map."
|
|
);
|
|
}
|
|
|
|
assertEquals(GameStages.RES_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, 1));
|
|
}
|
|
}
|
|
|
|
private void resolveAllMandatoryActions(Game game) {
|
|
while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
|
|
resolveOneMandatoryAction(game);
|
|
}
|
|
}
|
|
|
|
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));
|
|
return;
|
|
}
|
|
|
|
if (!game.getLowerListBuilding().isEmpty()
|
|
&& game.DrawLowerBuildingCardByIndex(current, 0)) {
|
|
return;
|
|
}
|
|
|
|
if(game.getCurrentState().getNUpper() == 0 || game.getUpperListTribeCards().stream().allMatch(TribeCard::IsEventCard))
|
|
{
|
|
assertTrue(game.SkipNoDrawable(current));
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
if (game.getCurrentState().getNUpper() > 0) {
|
|
int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
|
|
|
|
if (index != -1) {
|
|
assertTrue(game.DrawUpperTribeCardByIndex(current, index));
|
|
return;
|
|
}
|
|
|
|
if (!game.getUpperListBuilding().isEmpty()
|
|
&& game.DrawUpperBuildingCardByIndex(current, 0)) {
|
|
return;
|
|
}
|
|
|
|
if(game.getCurrentState().getNLower() == 0 || game.getLowerListTribeCards().stream().allMatch(TribeCard::IsEventCard))
|
|
{
|
|
assertTrue(game.SkipNoDrawable(current));
|
|
return;
|
|
}
|
|
}
|
|
|
|
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.RES_ACTIONS) {
|
|
resolveOneMandatoryAction(game);
|
|
}
|
|
|
|
assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
|
|
}
|
|
|
|
private void resolveOptionalPhaseIfPresent(Game game) {
|
|
while (game.getCurrentState().getGameStage() == GameStages.OPT_CARD_E) {
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.NoOptionalCard(current));
|
|
}
|
|
}
|
|
|
|
private void playOneFullRound(Game game) {
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
completeSlotChoice(game);
|
|
|
|
assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
|
|
|
|
resolveAllMandatoryActions(game);
|
|
|
|
resolveOptionalPhaseIfPresent(game);
|
|
}
|
|
|
|
private void resolveCurrentPlayerCompletely(Game game, Player expectedPlayer) {
|
|
assertEquals(expectedPlayer, game.getCurrentState().getCurrentPlayer());
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS
|
|
&& expectedPlayer.equals(game.getCurrentState().getCurrentPlayer())) {
|
|
resolveOneMandatoryAction(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 getBoardShouldReturnBoard() {
|
|
Game game = new Game(3);
|
|
|
|
assertNotNull(game.getBoard());
|
|
}
|
|
|
|
@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 addPlayerShouldRejectDuplicatesAndStartTotemChoiceWhenFull() {
|
|
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.TOTEM_CHOICE, game.getCurrentState().getGameStage());
|
|
assertNotNull(game.getCurrentState().getCurrentPlayer());
|
|
|
|
assertFalse(game.addPlayer(p4));
|
|
}
|
|
|
|
@Test
|
|
void gameShouldEnterTotemChoiceWhenAllPlayersAreAdded() {
|
|
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.TOTEM_CHOICE, game.getCurrentState().getGameStage());
|
|
assertNotNull(game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
@Test
|
|
void totemChoiceShouldAssignDistinctTotemsAndStartSlotChoice() {
|
|
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));
|
|
|
|
completeTotemChoice(game);
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
assertNotNull(p1.totem);
|
|
assertNotNull(p2.totem);
|
|
assertNotNull(p3.totem);
|
|
|
|
assertEquals(
|
|
3,
|
|
Stream.of(p1.totem, p2.totem, p3.totem).distinct().count()
|
|
);
|
|
}
|
|
|
|
@Test
|
|
void totemChoiceShouldRejectAlreadyChosenTotem() {
|
|
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 firstPlayer = game.getCurrentState().getCurrentPlayer();
|
|
Totems chosenTotem = game.getAvailableTotems().get(0);
|
|
|
|
assertTrue(game.TotemChoice(firstPlayer, chosenTotem));
|
|
|
|
Player secondPlayer = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(secondPlayer);
|
|
|
|
assertFalse(game.TotemChoice(secondPlayer, chosenTotem));
|
|
}
|
|
|
|
@Test
|
|
void totemChoiceShouldRejectWrongPlayer() {
|
|
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();
|
|
Player wrongPlayer = current.equals(p1) ? p2 : p1;
|
|
|
|
Totems availableTotem = game.getAvailableTotems().get(0);
|
|
|
|
assertFalse(game.TotemChoice(wrongPlayer, availableTotem));
|
|
}
|
|
|
|
@Test
|
|
void getAvailableTotemsShouldExcludeChosenTotems() {
|
|
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));
|
|
|
|
int initialAvailableTotems = game.getAvailableTotems().size();
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
Totems chosenTotem = game.getAvailableTotems().get(0);
|
|
|
|
assertTrue(game.TotemChoice(current, chosenTotem));
|
|
|
|
assertEquals(initialAvailableTotems - 1, game.getAvailableTotems().size());
|
|
assertFalse(game.getAvailableTotems().contains(chosenTotem));
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
void shouldRejectInvalidSlotChoices() {
|
|
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));
|
|
|
|
completeTotemChoice(game);
|
|
|
|
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));
|
|
|
|
completeTotemChoice(game);
|
|
|
|
Queue<Player> players = new LinkedList<>();
|
|
for (int i = 0; i < game.getNPlayers(); 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));
|
|
}
|
|
|
|
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());
|
|
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.RES_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.builders.clear();
|
|
|
|
BuildingCard selectedBuilding = game.getUpperListBuilding().get(0);
|
|
int expectedCost = selectedBuilding.getPrice();
|
|
|
|
current.addFood(expectedCost);
|
|
|
|
int buildingsBefore = current.buildingCards.size();
|
|
int upperBuildingsBefore = game.getUpperListBuilding().size();
|
|
int foodBefore = current.getFoodValue();
|
|
|
|
assertTrue(game.PickOptionalBuildingCard(current, 0));
|
|
|
|
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
|
|
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.OPT_CARD_E, 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));
|
|
}
|
|
|
|
if (game.getCurrentState().getGameStage() == GameStages.TOTEM_CHOICE) {
|
|
completeTotemChoice(game);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
@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 shouldRejectInvalidDrawRequests() {
|
|
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));
|
|
|
|
/*
|
|
* The game is currently in TOTEM_CHOICE:
|
|
* draw requests must be rejected because the game is not in RES_ACTIONS.
|
|
*/
|
|
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));
|
|
|
|
/*
|
|
* The totem choice phase and the slot choice phase are completed,
|
|
* so the game enters RES_ACTIONS.
|
|
*/
|
|
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 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
|
|
@Timeout(value = 2, unit = TimeUnit.SECONDS)
|
|
void shouldNotCrashWhenNoPlayerHasOptionalEffect() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "no_optional_");
|
|
|
|
completeSlotChoice(game);
|
|
|
|
assertDoesNotThrow(() -> resolveAllMandatoryActions(game));
|
|
|
|
assertNotEquals(GameStages.OPT_CARD_E, 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.TOTEM_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
completeTotemChoice(game);
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.SlotChoiceByIndex(current, 0));
|
|
}
|
|
|
|
@Test
|
|
@Timeout(value = 20, unit = TimeUnit.SECONDS)
|
|
void shouldCompleteFullGameThroughRealFlow() {
|
|
for (int nPlayers : new int[]{2, 3, 4, 5}) {
|
|
Game game = new Game(nPlayers);
|
|
|
|
for (int i = 1; i <= nPlayers; i++) {
|
|
assertTrue(game.addPlayer(new Player("p" + nPlayers + "_" + i)));
|
|
}
|
|
|
|
completeTotemChoice(game);
|
|
|
|
assertEquals(nPlayers, game.getCurrentPlayerNumber());
|
|
assertEquals(nPlayers, game.getPlayers().size());
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
assertEquals(1, game.getCurrentState().getRound());
|
|
assertNotNull(game.getCurrentState().getCurrentPlayer());
|
|
|
|
for (int expectedRound = 1; expectedRound < 10; expectedRound++) {
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
assertEquals(expectedRound, game.getCurrentState().getRound());
|
|
assertEquals(nPlayers, game.getCurrentPlayerNumber());
|
|
|
|
playOneFullRound(game);
|
|
|
|
assertEquals(
|
|
GameStages.SLOT_CHOICE,
|
|
game.getCurrentState().getGameStage(),
|
|
"After round " + expectedRound + ", the game should return to SLOT_CHOICE."
|
|
);
|
|
|
|
assertEquals(
|
|
expectedRound + 1,
|
|
game.getCurrentState().getRound(),
|
|
"The round should increase after completing round " + expectedRound + "."
|
|
);
|
|
|
|
assertEquals(nPlayers, game.getCurrentPlayerNumber());
|
|
assertNotNull(game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
assertEquals(10, game.getCurrentState().getRound());
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
playOneFullRound(game);
|
|
|
|
assertEquals(
|
|
GameStages.ENDED,
|
|
game.getCurrentState().getGameStage(),
|
|
"The game should end after completing round 10 with " + nPlayers + " players."
|
|
);
|
|
|
|
assertEquals(10, game.getCurrentState().getRound());
|
|
assertEquals(nPlayers, game.getPlayers().size());
|
|
}
|
|
}
|
|
|
|
@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
|
|
@Timeout(value = 2, unit = TimeUnit.SECONDS)
|
|
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, 1));
|
|
|
|
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
|
|
@Timeout(value = 2, unit = TimeUnit.SECONDS)
|
|
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);
|
|
|
|
resolveOptionalPhaseIfPresent(game);
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
assertEquals(roundBefore + 1, game.getCurrentState().getRound());
|
|
assertNotNull(game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
@Test
|
|
void pickOptionalBuildingCardShouldReturnFalseIfPlayerCannotPay() {
|
|
Game game = new Game(3);
|
|
List<Player> players = addPlayers(game, 3, "no_food_");
|
|
|
|
giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
while (current.getFoodValue() > 0) {
|
|
assertTrue(current.removeFood(1));
|
|
}
|
|
|
|
current.builders.clear();
|
|
|
|
assertEquals(0, current.getFoodValue());
|
|
|
|
assertFalse(
|
|
game.getUpperListBuilding().isEmpty(),
|
|
"There must be at least one upper building card to test that the player cannot buy it."
|
|
);
|
|
|
|
assertFalse(game.PickOptionalBuildingCard(current, 0));
|
|
}
|
|
|
|
@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
|
|
@Timeout(value = 5, unit = TimeUnit.SECONDS)
|
|
void drawBuildingShouldReturnFalseIfPlayerCannotPay() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "no_food_upper_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().getNUpper() > 0
|
|
&& !game.getUpperListBuilding().isEmpty()) {
|
|
|
|
BuildingCard selectedBuilding = game.getUpperListBuilding().get(0);
|
|
|
|
if (selectedBuilding.getPrice() <= 0) {
|
|
resolveOneMandatoryAction(game);
|
|
continue;
|
|
}
|
|
|
|
while (current.getFoodValue() > 0) {
|
|
assertTrue(current.removeFood(1));
|
|
}
|
|
|
|
current.builders.clear();
|
|
|
|
assertEquals(0, current.getFoodValue());
|
|
|
|
int buildingsBefore = current.buildingCards.size();
|
|
int upperBuildingsBefore = game.getUpperListBuilding().size();
|
|
|
|
assertFalse(game.DrawUpperBuildingCardByIndex(current, 0));
|
|
|
|
assertEquals(buildingsBefore, current.buildingCards.size());
|
|
assertEquals(upperBuildingsBefore, game.getUpperListBuilding().size());
|
|
assertEquals(0, current.getFoodValue());
|
|
|
|
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 NUpper > 0 and at least one payable upper building.");
|
|
}
|
|
|
|
@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());
|
|
}
|
|
|
|
private void preparePlayerForComparableFinalScoring(Player player) {
|
|
player.buildingCards.clear();
|
|
|
|
player.builders.clear();
|
|
player.inventors.clear();
|
|
player.artists.clear();
|
|
player.hunters.clear();
|
|
player.shamans.clear();
|
|
player.gatherers.clear();
|
|
|
|
while (player.getFoodValue() > 0) {
|
|
assertTrue(player.removeFood(1));
|
|
}
|
|
|
|
/*
|
|
* Keeps the optional effect, but with zero final prestige.
|
|
* This preserves the OPT_CARD_E phase while keeping the comparison controlled.
|
|
*/
|
|
player.buildingCards.add(new BuildingCard(12, 1, 1, 0));
|
|
}
|
|
|
|
@Test
|
|
void skipDrawingShouldRejectWrongPlayer() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "skip_wrong_");
|
|
|
|
completeSlotChoice(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
Player wrongPlayer = players.stream()
|
|
.filter(p -> !p.equals(current))
|
|
.findFirst()
|
|
.orElseThrow();
|
|
|
|
assertFalse(game.SkipNoDrawable(wrongPlayer));
|
|
}
|
|
|
|
@Test
|
|
void skipDrawingShouldReturnFalseWhenDrawableCardsExist() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "skip_drawable_");
|
|
|
|
completeSlotChoice(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
boolean hasDrawableLowerTribe =
|
|
game.getCurrentState().getNLower() > 0
|
|
&& firstNonEventIndexOrMinusOne(game.getLowerListTribeCards()) != -1;
|
|
|
|
boolean hasDrawableUpperTribe =
|
|
game.getCurrentState().getNUpper() > 0
|
|
&& firstNonEventIndexOrMinusOne(game.getUpperListTribeCards()) != -1;
|
|
|
|
assertTrue(
|
|
hasDrawableLowerTribe || hasDrawableUpperTribe,
|
|
"The test requires at least one drawable tribe card."
|
|
);
|
|
|
|
assertFalse(game.SkipNoDrawable(current));
|
|
}
|
|
|
|
@Test
|
|
@Timeout(value = 20, unit = TimeUnit.SECONDS)
|
|
void pickOptionalTribeCardShouldRejectEventCardIfPresent() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "optional_event_");
|
|
|
|
giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
|
|
|
|
while (game.getCurrentState().getGameStage() != GameStages.ENDED) {
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
completeSlotChoice(game);
|
|
resolveActionsUntilOptionalCardEffect(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
int eventIndex = firstEventIndexOrMinusOne(game.getUpperListTribeCards());
|
|
|
|
if (eventIndex != -1) {
|
|
int charactersBefore = current.getTotCharacters();
|
|
int upperSizeBefore = game.getUpperListTribeCards().size();
|
|
|
|
assertFalse(game.PickOptionalTribeCardByIndex(current, eventIndex));
|
|
|
|
assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
|
|
assertEquals(current, game.getCurrentState().getCurrentPlayer());
|
|
assertEquals(charactersBefore, current.getTotCharacters());
|
|
assertEquals(upperSizeBefore, game.getUpperListTribeCards().size());
|
|
|
|
return;
|
|
}
|
|
|
|
resolveOptionalPhaseIfPresent(game);
|
|
}
|
|
|
|
org.junit.jupiter.api.Assumptions.assumeTrue(
|
|
false,
|
|
"No optional phase with an event card in the upper tribe list was reached."
|
|
);
|
|
}
|
|
|
|
@Test
|
|
void cardListsShouldReturnCopiesOfLists() {
|
|
Game game = new Game(3);
|
|
|
|
int upperTribeSize = game.getUpperListTribeCards().size();
|
|
int lowerTribeSize = game.getLowerListTribeCards().size();
|
|
int upperBuildingSize = game.getUpperListBuilding().size();
|
|
int lowerBuildingSize = game.getLowerListBuilding().size();
|
|
|
|
List<TribeCard> upperTribe = game.getUpperListTribeCards();
|
|
List<TribeCard> lowerTribe = game.getLowerListTribeCards();
|
|
List<BuildingCard> upperBuilding = game.getUpperListBuilding();
|
|
List<BuildingCard> lowerBuilding = game.getLowerListBuilding();
|
|
|
|
upperTribe.clear();
|
|
lowerTribe.clear();
|
|
upperBuilding.clear();
|
|
lowerBuilding.clear();
|
|
|
|
assertEquals(upperTribeSize, game.getUpperListTribeCards().size());
|
|
assertEquals(lowerTribeSize, game.getLowerListTribeCards().size());
|
|
assertEquals(upperBuildingSize, game.getUpperListBuilding().size());
|
|
assertEquals(lowerBuildingSize, game.getLowerListBuilding().size());
|
|
}
|
|
|
|
@Test
|
|
void getPlayersShouldReturnAddedPlayers() {
|
|
Game game = new Game(3);
|
|
|
|
Player p1 = new Player("gp1");
|
|
Player p2 = new Player("gp2");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
|
|
assertEquals(2, game.getPlayers().size());
|
|
assertTrue(game.getPlayers().contains(p1));
|
|
assertTrue(game.getPlayers().contains(p2));
|
|
}
|
|
|
|
@Test
|
|
void skipDrawingShouldRejectOutsideResolvingActions() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "skip_out_");
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
assertFalse(game.SkipNoDrawable(current));
|
|
}
|
|
|
|
@Test
|
|
void disconnectedCurrentPlayerDuringSlotChoiceShouldAdvanceTurn() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "disconnect_slot_");
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertTrue(game.DisconnectedPlayer(current));
|
|
|
|
assertTrue(game.disconnetedPlayers.containsKey(current));
|
|
assertTrue(game.disconnetedPlayers.get(current));
|
|
assertNotEquals(current, game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
@Test
|
|
void disconnectedPlayerShouldReturnFalseIfAlreadyDisconnected() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "disconnect_twice_");
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
assertTrue(game.DisconnectedPlayer(current));
|
|
assertFalse(game.DisconnectedPlayer(current));
|
|
}
|
|
|
|
@Test
|
|
void reconnectPlayerShouldRemovePlayerFromDisconnectedMapDuringSlotChoice() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "reconnect_");
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
assertTrue(game.DisconnectedPlayer(current));
|
|
assertTrue(game.disconnetedPlayers.containsKey(current));
|
|
|
|
assertTrue(game.ReconnectPlayer(current));
|
|
assertFalse(game.disconnetedPlayers.containsKey(current));
|
|
}
|
|
|
|
@Test
|
|
void clearDisconnectedShouldEmptyDisconnectedPlayersMap() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "clear_disconnect_");
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
assertTrue(game.DisconnectedPlayer(current));
|
|
assertFalse(game.disconnetedPlayers.isEmpty());
|
|
|
|
game.ClearDisconnected();
|
|
|
|
assertTrue(game.disconnetedPlayers.isEmpty());
|
|
}
|
|
|
|
@Test
|
|
@Timeout(value = 5, unit = TimeUnit.SECONDS)
|
|
void drawLowerBuildingShouldReturnFalseIfPlayerCannotPay() {
|
|
Game game = new Game(3);
|
|
|
|
addPlayers(game, 3, "no_food_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()) {
|
|
|
|
BuildingCard selectedBuilding = game.getLowerListBuilding().get(0);
|
|
|
|
if (selectedBuilding.getPrice() <= 0) {
|
|
resolveOneMandatoryAction(game);
|
|
continue;
|
|
}
|
|
|
|
while (current.getFoodValue() > 0) {
|
|
assertTrue(current.removeFood(1));
|
|
}
|
|
|
|
current.builders.clear();
|
|
|
|
assertEquals(0, current.getFoodValue());
|
|
|
|
int buildingsBefore = current.buildingCards.size();
|
|
int lowerBuildingsBefore = game.getLowerListBuilding().size();
|
|
|
|
assertFalse(game.DrawLowerBuildingCardByIndex(current, 0));
|
|
|
|
assertEquals(buildingsBefore, current.buildingCards.size());
|
|
assertEquals(lowerBuildingsBefore, game.getLowerListBuilding().size());
|
|
assertEquals(0, current.getFoodValue());
|
|
|
|
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 payable lower building.");
|
|
}
|
|
|
|
@Test
|
|
@Timeout(value = 5, unit = TimeUnit.SECONDS)
|
|
void drawLowerBuildingShouldRejectWrongPlayer() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "wrong_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()) {
|
|
|
|
Player wrongPlayer = players.stream()
|
|
.filter(p -> !p.equals(current))
|
|
.findFirst()
|
|
.orElseThrow();
|
|
|
|
wrongPlayer.addFood(game.getLowerListBuilding().get(0).getPrice());
|
|
|
|
assertFalse(game.DrawLowerBuildingCardByIndex(wrongPlayer, 0));
|
|
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 lower building draw state.");
|
|
}
|
|
|
|
@Test
|
|
void cardListsShouldReturnClonedCards() {
|
|
Game game = new Game(3);
|
|
|
|
List<TribeCard> firstUpperTribeCall = game.getUpperListTribeCards();
|
|
List<TribeCard> secondUpperTribeCall = game.getUpperListTribeCards();
|
|
|
|
assertFalse(firstUpperTribeCall.isEmpty());
|
|
assertFalse(secondUpperTribeCall.isEmpty());
|
|
|
|
assertNotSame(firstUpperTribeCall.get(0), secondUpperTribeCall.get(0));
|
|
|
|
List<TribeCard> firstLowerTribeCall = game.getLowerListTribeCards();
|
|
List<TribeCard> secondLowerTribeCall = game.getLowerListTribeCards();
|
|
|
|
assertFalse(firstLowerTribeCall.isEmpty());
|
|
assertFalse(secondLowerTribeCall.isEmpty());
|
|
|
|
assertNotSame(firstLowerTribeCall.get(0), secondLowerTribeCall.get(0));
|
|
|
|
List<BuildingCard> firstUpperBuildingCall = game.getUpperListBuilding();
|
|
List<BuildingCard> secondUpperBuildingCall = game.getUpperListBuilding();
|
|
|
|
assertFalse(firstUpperBuildingCall.isEmpty());
|
|
assertFalse(secondUpperBuildingCall.isEmpty());
|
|
|
|
assertNotSame(firstUpperBuildingCall.get(0), secondUpperBuildingCall.get(0));
|
|
}
|
|
|
|
@Test
|
|
void initShouldAssignInitialFoodAccordingToOrderPosition() {
|
|
Game game = new Game(5);
|
|
|
|
Player p1 = new Player("p1");
|
|
Player p2 = new Player("p2");
|
|
Player p3 = new Player("p3");
|
|
Player p4 = new Player("p4");
|
|
Player p5 = new Player("p5");
|
|
|
|
assertTrue(game.addPlayer(p1));
|
|
assertTrue(game.addPlayer(p2));
|
|
assertTrue(game.addPlayer(p3));
|
|
assertTrue(game.addPlayer(p4));
|
|
assertTrue(game.addPlayer(p5));
|
|
|
|
assertEquals(GameStages.TOTEM_CHOICE, game.getCurrentState().getGameStage());
|
|
|
|
List<Integer> foodValues = game.getPlayers().stream()
|
|
.map(Player::getFoodValue)
|
|
.sorted()
|
|
.toList();
|
|
|
|
assertEquals(List.of(2, 3, 3, 4, 4), foodValues);
|
|
}
|
|
|
|
@Test
|
|
void slotChoiceShouldAddFoodWhenChoosingSlotAInFivePlayerGame() {
|
|
Game game = new Game(5);
|
|
|
|
addPlayers(game, 5, "slot_a_");
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
int foodBefore = current.getFoodValue();
|
|
|
|
assertTrue(game.SlotChoiceByIndex(current, 0));
|
|
|
|
assertEquals(foodBefore + 3, current.getFoodValue());
|
|
}
|
|
|
|
@Test
|
|
void slotChoiceShouldNotAddFoodWhenChoosingNonASlot() {
|
|
Game game = new Game(5);
|
|
|
|
addPlayers(game, 5, "slot_non_a_");
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
int foodBefore = current.getFoodValue();
|
|
|
|
assertTrue(game.SlotChoiceByIndex(current, 1));
|
|
|
|
assertEquals(foodBefore, current.getFoodValue());
|
|
}
|
|
|
|
@Test
|
|
@Timeout(value = 20, unit = TimeUnit.SECONDS)
|
|
void endGameShouldAddExactBuildingPrestigeValues() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "final_building_scoring_");
|
|
|
|
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());
|
|
|
|
Player controlPlayer = players.get(0);
|
|
Player testedPlayer = players.get(1);
|
|
|
|
assertNotNull(controlPlayer);
|
|
assertNotNull(testedPlayer);
|
|
|
|
/*
|
|
* The two players are made equivalent with respect to events and final scoring.
|
|
* The game has still reached round 10 through the real flow.
|
|
*/
|
|
preparePlayerForComparableFinalScoring(controlPlayer);
|
|
preparePlayerForComparableFinalScoring(testedPlayer);
|
|
preparePlayerForComparableFinalScoring(players.get(2));
|
|
|
|
BuildingCard firstBuilding = new BuildingCard(12, 1, 1, 7);
|
|
BuildingCard secondBuilding = new BuildingCard(12, 1, 1, 5);
|
|
|
|
testedPlayer.buildingCards.add(firstBuilding);
|
|
testedPlayer.buildingCards.add(secondBuilding);
|
|
|
|
int prestigeDifferenceBefore =
|
|
testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
|
|
|
|
int expectedExtraIncrease =
|
|
firstBuilding.getPrestigeValue()
|
|
+ secondBuilding.getPrestigeValue();
|
|
|
|
resolveOptionalPhaseIfPresent(game);
|
|
|
|
assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
|
|
|
|
int prestigeDifferenceAfter =
|
|
testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
|
|
|
|
assertEquals(
|
|
expectedExtraIncrease,
|
|
prestigeDifferenceAfter - prestigeDifferenceBefore,
|
|
"Final scoring should add exactly the printed prestige values of the added buildings."
|
|
);
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
@Timeout(value = 20, unit = TimeUnit.SECONDS)
|
|
void endGameShouldAddExactBuilderPrestigeValues() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "final_builder_scoring_");
|
|
|
|
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());
|
|
|
|
Player controlPlayer = players.get(0);
|
|
Player testedPlayer = players.get(1);
|
|
|
|
assertNotNull(controlPlayer);
|
|
assertNotNull(testedPlayer);
|
|
|
|
preparePlayerForComparableFinalScoring(controlPlayer);
|
|
preparePlayerForComparableFinalScoring(testedPlayer);
|
|
preparePlayerForComparableFinalScoring(players.get(2));
|
|
|
|
controlPlayer.builders.add(new Builder(1, 0, 0));
|
|
controlPlayer.builders.add(new Builder(1, 0, 0));
|
|
|
|
testedPlayer.builders.add(new Builder(1, 0, 4));
|
|
testedPlayer.builders.add(new Builder(1, 0, 3));
|
|
|
|
int prestigeDifferenceBefore =
|
|
testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
|
|
|
|
int expectedExtraIncrease = 4 + 3;
|
|
|
|
resolveOptionalPhaseIfPresent(game);
|
|
|
|
assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
|
|
|
|
int prestigeDifferenceAfter =
|
|
testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
|
|
|
|
assertEquals(
|
|
expectedExtraIncrease,
|
|
prestigeDifferenceAfter - prestigeDifferenceBefore,
|
|
"Final scoring should add exactly the prestige values of the builders."
|
|
);
|
|
}
|
|
|
|
@Test
|
|
@Timeout(value = 20, unit = TimeUnit.SECONDS)
|
|
void endGameShouldAddExactInventorPrestigeValues() {
|
|
Game game = new Game(3);
|
|
|
|
List<Player> players = addPlayers(game, 3, "final_inventor_scoring_");
|
|
|
|
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());
|
|
|
|
Player controlPlayer = players.get(0);
|
|
Player testedPlayer = players.get(1);
|
|
|
|
assertNotNull(controlPlayer);
|
|
assertNotNull(testedPlayer);
|
|
|
|
preparePlayerForComparableFinalScoring(controlPlayer);
|
|
preparePlayerForComparableFinalScoring(testedPlayer);
|
|
preparePlayerForComparableFinalScoring(players.get(2));
|
|
|
|
controlPlayer.builders.add(new Builder(1, 0, 0));
|
|
controlPlayer.builders.add(new Builder(1, 0, 0));
|
|
controlPlayer.builders.add(new Builder(1, 0, 0));
|
|
|
|
testedPlayer.inventors.add(new Inventor(1, 0));
|
|
testedPlayer.inventors.add(new Inventor(1, 1));
|
|
testedPlayer.inventors.add(new Inventor(1, 1));
|
|
|
|
int prestigeDifferenceBefore =
|
|
testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
|
|
|
|
int expectedExtraIncrease = 3 * 2;
|
|
|
|
resolveOptionalPhaseIfPresent(game);
|
|
|
|
assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
|
|
|
|
int prestigeDifferenceAfter =
|
|
testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
|
|
|
|
assertEquals(
|
|
expectedExtraIncrease,
|
|
prestigeDifferenceAfter - prestigeDifferenceBefore,
|
|
"Final scoring should add exactly inventors times different invention icons."
|
|
);
|
|
}
|
|
} |