Browse Source

Merge branch 'completeGameservice' into 'main'

Complete GameService

See merge request fdai7736/onses!20
main
fdai7793 11 months ago
parent
commit
94a5ed55e2
  1. 140
      src/main/java/de/hsfulda/onses/services/GameService.java
  2. 34
      src/main/java/de/hsfulda/onses/services/PlayerService.java
  3. 274
      src/test/java/de/hsfulda/onses/GameServiceTest.java
  4. 64
      src/test/java/de/hsfulda/onses/PlayerServiceTest.java

140
src/main/java/de/hsfulda/onses/services/GameService.java

@ -5,15 +5,30 @@ import de.hsfulda.onses.models.Game;
import de.hsfulda.onses.models.Player; import de.hsfulda.onses.models.Player;
import java.util.Collections; import java.util.Collections;
import java.util.Random;
public class GameService { public class GameService {
private final Game game; private final Game game;
private boolean test = false;
public GameService setTest(boolean test) {
this.test = test;
return this;
}
public boolean getTest() {
return this.test;
}
public GameService(Game game) { public GameService(Game game) {
this.game = game; this.game = game;
this.game.setGameService(this); this.game.setGameService(this);
fillDrawDeck(); fillDrawDeck();
shuffleDeck(); shuffleDeck();
setFirstCard();
fillPlayerDecks();
} }
public GameService() { public GameService() {
this(new Game()); this(new Game());
} }
@ -25,7 +40,9 @@ public class GameService {
public void nextPlayer() { public void nextPlayer() {
game.getPlayerService().nextTurn(); game.getPlayerService().nextTurn();
} }
public void drawCard(int amount) { public void drawCard(int amount) {
if (!game.getDrawCardDeck().isEmpty()) {
Player player = null; Player player = null;
if (game.getPlayerService().getCurrentTurn()) { if (game.getPlayerService().getCurrentTurn()) {
player = game.getPlayerService().getPlayerList().getFirst(); player = game.getPlayerService().getPlayerList().getFirst();
@ -36,49 +53,106 @@ public class GameService {
player.getPlayerDeck().add(game.getDrawCardDeck().getFirst()); player.getPlayerDeck().add(game.getDrawCardDeck().getFirst());
game.getDrawCardDeck().removeFirst(); game.getDrawCardDeck().removeFirst();
} }
if (amount == 1 && !player.getPlayerDeck().isEmpty()) {
Card drawnCard = player.getPlayerDeck().getLast();
if (legalMove(drawnCard)) {
player.getPlayerService().removeCardFromPlayerDeck(drawnCard);
playCard(drawnCard);
}
else nextPlayer();
}
}
if (amount != 1) { if (amount != 1) {
nextPlayer(); nextPlayer();
} }
} }
public void playCard(Card card)
{
public void addLastPlayedCardToDrawCardDeck() {
Card lastCard = game.getLastPlayedCard();
if (lastCard.getValue() == Card.Value.CHOOSE || lastCard.getValue() == Card.Value.CHOOSEDRAW) {
lastCard.setColor(Card.Color.BLACK);
}
game.addCardToDrawCardDeck(lastCard);
}
public void chooseColor() {
// Abfrage Farbe
Card.Color color = Card.Color.BLUE; //Vorübergehend Blau
game.changeLastPlayedCardColor(color);
if (!game.getPlayerService().getCurrentTurn()){
int min = 0;
int max = 3;
Random rand = new Random();
int randomNum = rand.nextInt((max - min) + 1) + min;
switch (randomNum){
case 0:
color = Card.Color.BLUE;
game.changeLastPlayedCardColor(color);
break;
case 1:
color = Card.Color.RED;
game.changeLastPlayedCardColor(color);
break;
case 2:
color = Card.Color.YELLOW;
game.changeLastPlayedCardColor(color);
break;
case 3:
color = Card.Color.GREEN;
game.changeLastPlayedCardColor(color);
break;
}
}
}
public void checkForWin() {
if (this.game.getPlayerService().getPlayerList().getFirst().getPlayerDeck().isEmpty()) {
System.out.println("Player wins");
} else if (this.game.getPlayerService().getPlayerList().getLast().getPlayerDeck().isEmpty()) {
System.out.println("Bot wins");
}
}
public void playCard(Card card) {
// add lastPlayedCard back to drawCardDeck // add lastPlayedCard back to drawCardDeck
this.addLastPlayedCardToDrawCardDeck();
game.setLastPlayedCard(card); game.setLastPlayedCard(card);
// check for special rules (draw, colorchoose, skip,...) // check for special rules (draw, colorchoose, skip,...)
// Skip // Skip
if (card.getValue() == Card.Value.SKIP) {
switch (card.getValue()) {
case SKIP, REVERSE:
nextPlayer(); nextPlayer();
nextPlayer(); nextPlayer();
}
// Reverse
if (card.getValue() == Card.Value.REVERSE) {
break;
case CHOOSE:
chooseColor();
nextPlayer(); nextPlayer();
break;
case CHOOSEDRAW:
chooseColor();
nextPlayer(); nextPlayer();
}
// Choose
if (card.getValue() == Card.Value.CHOOSE) {
// Abfrage Farbe
Card.Color color = Card.Color.BLUE; //Vorübergehend Blau
game.changeLastPlayedCardColor(color);
nextPlayer();
}
// Draw
if (card.getValue() == Card.Value.DRAWTWO) {
drawCard(4);
break;
case DRAWTWO:
nextPlayer(); nextPlayer();
drawCard(2); drawCard(2);
}
// ChooseDraw
if (card.getValue() == Card.Value.CHOOSEDRAW) {
// Abfrage Farbe
Card.Color color = Card.Color.BLUE; //Vorübergehend Blau
game.changeLastPlayedCardColor(color);
break;
default:
nextPlayer(); nextPlayer();
drawCard(4);
break;
}
checkForWin();
if (!this.test) {
if (!game.getPlayerService().getCurrentTurn()) {
game.getPlayerService().botMove();
}
} }
} }
public boolean legalMove(Card card)
{
public boolean legalMove(Card card) {
boolean legalMoveFound = false; boolean legalMoveFound = false;
Card lastCard = game.getLastPlayedCard(); Card lastCard = game.getLastPlayedCard();
// rules: // rules:
@ -111,4 +185,20 @@ public class GameService {
Collections.shuffle(game.getDrawCardDeck()); Collections.shuffle(game.getDrawCardDeck());
} }
public void setFirstCard() {
for (int i = 0; i < this.game.getDrawCardDeck().size(); i++) {
Card card = this.game.getDrawCardDeck().get(i);
if (card.getColor() != Card.Color.BLACK) {
this.game.setLastPlayedCard(card);
this.game.getDrawCardDeck().remove(card);
break;
}
}
}
public void fillPlayerDecks() {
this.drawCard(7);
this.drawCard(7);
}
} }

34
src/main/java/de/hsfulda/onses/services/PlayerService.java

@ -2,6 +2,8 @@ package de.hsfulda.onses.services;
import de.hsfulda.onses.models.Game; import de.hsfulda.onses.models.Game;
import de.hsfulda.onses.models.Player; import de.hsfulda.onses.models.Player;
import de.hsfulda.onses.models.Card;
import de.hsfulda.onses.services.GameService;
import java.util.ArrayList; import java.util.ArrayList;
@ -15,12 +17,12 @@ public class PlayerService {
public ArrayList<Player> getPlayerList() { public ArrayList<Player> getPlayerList() {
return playerList; return playerList;
} }
public void addPlayerToList(Player player) { public void addPlayerToList(Player player) {
playerList.add(player); playerList.add(player);
} }
public void nextTurn()
{
public void nextTurn() {
currentTurn = !currentTurn; currentTurn = !currentTurn;
} }
@ -43,9 +45,33 @@ public class PlayerService {
return this; return this;
} }
public PlayerService()
{
public PlayerService() {
addPlayerToList(new Player().setPlayerService(this)); addPlayerToList(new Player().setPlayerService(this));
addPlayerToList(new Player().setPlayerService(this)); addPlayerToList(new Player().setPlayerService(this));
} }
public void removeCardFromPlayerDeck(Card card) {
Player player;
if (this.currentTurn) {
player = playerList.getFirst();
} else {
player = playerList.getLast();
}
player.getPlayerDeck().remove(card);
}
public void botMove() {
Card lastPlayedCard = game.getLastPlayedCard();
for (int i = 0; i < this.playerList.getLast().getPlayerDeck().size(); i++) {
if (getGame().getGameService().legalMove(this.playerList.getLast().getPlayerDeck().get(i))) {
Card playCard = this.playerList.getLast().getPlayerDeck().get(i);
this.removeCardFromPlayerDeck(playCard);
getGame().getGameService().playCard(playCard);
break;
}
}
if (lastPlayedCard == game.getLastPlayedCard()) {
game.getGameService().drawCard(1);
}
}
} }

274
src/test/java/de/hsfulda/onses/GameServiceTest.java

@ -1,8 +1,10 @@
package de.hsfulda.onses; package de.hsfulda.onses;
import de.hsfulda.onses.models.Game;
import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.Assertions.*;
import de.hsfulda.onses.models.Card; import de.hsfulda.onses.models.Card;
@ -17,11 +19,13 @@ public class GameServiceTest {
Card input = new Card().setColor(Card.Color.RED).setValue(Card.Value.EIGHT); Card input = new Card().setColor(Card.Color.RED).setValue(Card.Value.EIGHT);
// act // act
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
gameService.playCard(input); gameService.playCard(input);
Card answer = gameService.getGame().getLastPlayedCard(); Card answer = gameService.getGame().getLastPlayedCard();
// assert // assert
assertEquals(input, answer); assertEquals(input, answer);
} }
@Test @Test
@DisplayName("playCardBlackChoose") @DisplayName("playCardBlackChoose")
public void playCardBlackChoose() { public void playCardBlackChoose() {
@ -29,6 +33,7 @@ public class GameServiceTest {
Card input = new Card().setColor(Card.Color.BLACK).setValue(Card.Value.CHOOSE); Card input = new Card().setColor(Card.Color.BLACK).setValue(Card.Value.CHOOSE);
// act // act
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
gameService.playCard(input); gameService.playCard(input);
Card answer = gameService.getGame().getLastPlayedCard(); Card answer = gameService.getGame().getLastPlayedCard();
// assert // assert
@ -43,12 +48,14 @@ public class GameServiceTest {
boolean expected = true; boolean expected = true;
// act // act
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.RED).setValue(Card.Value.FIVE)); gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.RED).setValue(Card.Value.FIVE));
boolean answer = gameService.legalMove(input); boolean answer = gameService.legalMove(input);
// assert // assert
assertEquals(expected, answer); assertEquals(expected, answer);
} }
@Test @Test
@DisplayName("legalMoveSameColorBlue") @DisplayName("legalMoveSameColorBlue")
public void legalMoveSameColorBlue() { public void legalMoveSameColorBlue() {
@ -57,16 +64,19 @@ public class GameServiceTest {
boolean expected = true; boolean expected = true;
// act // act
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.BLUE).setValue(Card.Value.ONE)); gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.BLUE).setValue(Card.Value.ONE));
boolean answer = gameService.legalMove(input); boolean answer = gameService.legalMove(input);
// assert // assert
assertEquals(expected, answer); assertEquals(expected, answer);
} }
@Test @Test
@DisplayName("FillDrawCardDeck") @DisplayName("FillDrawCardDeck")
public void FillDrawCardDeck() { public void FillDrawCardDeck() {
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
int expected = gameService.getGame().getDrawCardDeck().size() + 112; int expected = gameService.getGame().getDrawCardDeck().size() + 112;
gameService.fillDrawDeck(); gameService.fillDrawDeck();
@ -83,6 +93,7 @@ public class GameServiceTest {
boolean expected = true; boolean expected = true;
// act // act
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.ONE)); gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.ONE));
boolean answer = gameService.legalMove(input); boolean answer = gameService.legalMove(input);
@ -98,6 +109,7 @@ public class GameServiceTest {
boolean expected = true; boolean expected = true;
// act // act
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.THREE)); gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.THREE));
boolean answer = gameService.legalMove(input); boolean answer = gameService.legalMove(input);
@ -113,6 +125,7 @@ public class GameServiceTest {
boolean expected = true; boolean expected = true;
// act // act
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.THREE)); gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.THREE));
boolean answer = gameService.legalMove(input); boolean answer = gameService.legalMove(input);
@ -128,12 +141,14 @@ public class GameServiceTest {
boolean expected = true; boolean expected = true;
// act // act
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.GREEN).setValue(Card.Value.FIVE)); gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.GREEN).setValue(Card.Value.FIVE));
boolean answer = gameService.legalMove(input); boolean answer = gameService.legalMove(input);
// assert // assert
assertEquals(expected, answer); assertEquals(expected, answer);
} }
@Test @Test
@DisplayName("ShuffelDeck") @DisplayName("ShuffelDeck")
public void ShuffelDeck() { public void ShuffelDeck() {
@ -159,8 +174,7 @@ public class GameServiceTest {
@Test @Test
@DisplayName("RelationshipGameService_Game") @DisplayName("RelationshipGameService_Game")
public void RelationshipGameService_Game()
{
public void RelationshipGameService_Game() {
// arrange // arrange
GameService expected = new GameService(); GameService expected = new GameService();
//act //act
@ -168,10 +182,10 @@ public class GameServiceTest {
// assert // assert
assertEquals(expected, answer); assertEquals(expected, answer);
} }
@Test @Test
@DisplayName("allRelationsTest") @DisplayName("allRelationsTest")
public void allRelationsTest ()
{
public void allRelationsTest() {
// arrange // arrange
GameService expected = new GameService(); GameService expected = new GameService();
//act //act
@ -186,39 +200,39 @@ public class GameServiceTest {
@Test @Test
@DisplayName("SkipTest") @DisplayName("SkipTest")
public void SkipTest ()
{
GameService gameservice = new GameService();
boolean expected = gameservice.getGame().getPlayerService().getCurrentTurn();
public void SkipTest() {
GameService gameService = new GameService();
gameService.setTest(true);
boolean expected = gameService.getGame().getPlayerService().getCurrentTurn();
gameservice.playCard(new Card().setValue(Card.Value.SKIP).setColor(Card.Color.BLACK));
gameService.playCard(new Card().setValue(Card.Value.SKIP).setColor(Card.Color.BLACK));
assertEquals(expected, gameservice.getGame().getPlayerService().getCurrentTurn());
assertEquals(expected, gameService.getGame().getPlayerService().getCurrentTurn());
} }
@Test @Test
@DisplayName("ReverseTest") @DisplayName("ReverseTest")
public void ReverseTest ()
{
GameService gameservice = new GameService();
boolean expected = gameservice.getGame().getPlayerService().getCurrentTurn();
public void ReverseTest() {
GameService gameService = new GameService();
gameService.setTest(true);
boolean expected = gameService.getGame().getPlayerService().getCurrentTurn();
gameservice.playCard(new Card().setValue(Card.Value.REVERSE).setColor(Card.Color.BLACK));
gameService.playCard(new Card().setValue(Card.Value.REVERSE).setColor(Card.Color.BLACK));
assertEquals(expected, gameservice.getGame().getPlayerService().getCurrentTurn());
assertEquals(expected, gameService.getGame().getPlayerService().getCurrentTurn());
} }
@Test @Test
@DisplayName("ChooseTest") @DisplayName("ChooseTest")
public void ChooseTest ()
{
GameService gameservice = new GameService();
public void ChooseTest() {
GameService gameService = new GameService();
gameService.setTest(true);
boolean expected = true; boolean expected = true;
boolean answer = false; boolean answer = false;
gameservice.playCard(new Card().setValue(Card.Value.CHOOSE).setColor(Card.Color.BLACK));
gameService.playCard(new Card().setValue(Card.Value.CHOOSE).setColor(Card.Color.BLACK));
if (gameservice.getGame().getLastPlayedCard().getColor() != Card.Color.BLACK) {
if (gameService.getGame().getLastPlayedCard().getColor() != Card.Color.BLACK) {
answer = true; answer = true;
} }
@ -228,27 +242,61 @@ public class GameServiceTest {
@Test @Test
@DisplayName("ChooseDrawTest") @DisplayName("ChooseDrawTest")
public void ChooseDrawTest ()
{
GameService gameservice = new GameService();
public void ChooseDrawTest() {
GameService gameService = new GameService();
gameService.setTest(true);
boolean expected = true; boolean expected = true;
boolean answer = false; boolean answer = false;
gameservice.playCard(new Card().setValue(Card.Value.CHOOSEDRAW).setColor(Card.Color.BLACK));
gameService.playCard(new Card().setValue(Card.Value.CHOOSEDRAW).setColor(Card.Color.BLACK));
if (gameservice.getGame().getLastPlayedCard().getColor() != Card.Color.BLACK) {
if (gameService.getGame().getLastPlayedCard().getColor() != Card.Color.BLACK) {
answer = true; answer = true;
} }
assertEquals(expected, answer); assertEquals(expected, answer);
} }
@Test
@DisplayName("DrawByChoiceForceKeep")
public void DrawByChoiceForceKeep() {
GameService gameService = new GameService();
gameService.setTest(true);
Card input = new Card().setColor(Card.Color.RED).setValue(Card.Value.ONE);
gameService.getGame().getDrawCardDeck().clear();
gameService.getGame().getPlayerService().setCurrentTurn(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.GREEN).setValue(Card.Value.SEVEN));
gameService.getGame().addCardToDrawCardDeck(input);
gameService.getGame().getPlayerService().getPlayerList().getFirst().addCardToPlayerDeck(new Card().setColor(Card.Color.BLUE).setValue(Card.Value.TWO));
gameService.drawCard(1);
Card answer = gameService.getGame().getPlayerService().getPlayerList().getFirst().getPlayerDeck().getLast();
assertEquals(input, answer);
}
@Test
@DisplayName("DrawCardPlayerDeckBot")
public void DrawCardPlayerDeckBot() {
GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().getPlayerService().setCurrentTurn(false);
int before = gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().size();
gameService.drawCard(2);
int after = gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().size();
int expected = 2;
int answer = after - before;
assertEquals(expected, answer);
}
@Test @Test
@DisplayName("DrawCardDeckTest") @DisplayName("DrawCardDeckTest")
public void DrawCardDeckTest ()
{
public void DrawCardDeckTest() {
GameService gameService = new GameService(); GameService gameService = new GameService();
gameService.setTest(true);
int before = gameService.getGame().getDrawCardDeck().size(); int before = gameService.getGame().getDrawCardDeck().size();
gameService.drawCard(4); gameService.drawCard(4);
int after = gameService.getGame().getDrawCardDeck().size(); int after = gameService.getGame().getDrawCardDeck().size();
@ -257,23 +305,173 @@ public class GameServiceTest {
int answer = before - after; int answer = before - after;
assertEquals(expected, answer); assertEquals(expected, answer);
} }
@Test
@DisplayName("DrawCardPlayerDeck")
public void DrawCardPlayerDeck() {
GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().getPlayerService().setCurrentTurn(true);
int before = gameService.getGame().getPlayerService().getPlayerList().getFirst().getPlayerDeck().size();
gameService.drawCard(4);
int after = gameService.getGame().getPlayerService().getPlayerList().getFirst().getPlayerDeck().size();
int expected = 4;
int answer = after - before;
assertEquals(expected, answer);
}
@Test @Test
@DisplayName("DrawCardDeckRemoveTest")
public void DrawCardDeckRemoveTest ()
{
@DisplayName("DrawByChoiceForcePlay")
public void DrawByChoiceForcePlay() {
GameService gameService = new GameService(); GameService gameService = new GameService();
Card card = gameService.getGame().getDrawCardDeck().getFirst();
gameService.setTest(true);
Card input = new Card().setColor(Card.Color.RED).setValue(Card.Value.ONE);
gameService.getGame().getDrawCardDeck().clear();
gameService.getGame().getPlayerService().setCurrentTurn(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.RED).setValue(Card.Value.SEVEN));
gameService.getGame().addCardToDrawCardDeck(input);
gameService.getGame().getPlayerService().getPlayerList().getFirst().addCardToPlayerDeck(new Card().setColor(Card.Color.BLUE).setValue(Card.Value.TWO));
gameService.drawCard(1); gameService.drawCard(1);
int counter = 0;
int expected = 0;
Card answer = gameService.getGame().getPlayerService().getPlayerList().getFirst().getPlayerDeck().getLast();
assertNotEquals(input, answer);
}
@Test
@DisplayName("CheckThatBotDeckHasSevenCardsAfterGameStart")
public void CheckThatBotDeckHasSevenCardsAfterGameStart() {
GameService gameService = new GameService();
gameService.setTest(true);
int expected = 7;
int actual = gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().size();
assertEquals(expected, actual);
}
@Test
@DisplayName("CheckFirstCardIsSet")
public void CheckFirstCardIsSet() {
GameService gameService = new GameService();
gameService.setTest(true);
Card card = gameService.getGame().getLastPlayedCard();
boolean answer = card != null;
assertTrue(answer);
}
@Test
@DisplayName("CheckFirstCardIsNotBlack")
public void CheckFirstCardIsNotBlack() {
GameService gameService = new GameService();
gameService.setTest(true);
Card card = gameService.getGame().getLastPlayedCard();
boolean answer = card.getColor() != Card.Color.BLACK;
assertTrue(answer);
}
@Test
@DisplayName("CheckResetOnBlackCards")
public void CheckResetOnBlackCards() {
GameService gameService = new GameService();
gameService.setTest(true);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.RED).setValue(Card.Value.FIVE));
gameService.playCard(new Card().setColor(Card.Color.BLACK).setValue(Card.Value.CHOOSE));
gameService.playCard(new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.FIVE));
Card card = gameService.getGame().getDrawCardDeck().getLast();
assertEquals(Card.Color.BLACK, card.getColor());
}
@Test
@DisplayName("CheckThatPlayerReceivedSevenCards")
public void CheckThatPlayerReceivedSevenCards() {
GameService gameService = new GameService();
gameService.setTest(true);
int numberOfCards = gameService.getGame().getPlayerService().getPlayerList().getFirst().getPlayerDeck().size();
assertEquals(7, numberOfCards);
}
@Test
@DisplayName("CheckThatFirstCardGetsRemovedFromDrawCardDeck")
public void CheckThatFirstCardGetsRemovedFromDrawCardDeck() {
GameService gameService = new GameService();
gameService.setTest(true);
Card lastPlayedCard = gameService.getGame().getLastPlayedCard();
boolean lastPlayedCardDoesNotExistInDrawCardDeck = true;
for (int i = 0; i < gameService.getGame().getDrawCardDeck().size(); i++) { for (int i = 0; i < gameService.getGame().getDrawCardDeck().size(); i++) {
if (gameService.getGame().getDrawCardDeck().get(i).getColor() == card.getColor() && gameService.getGame().getDrawCardDeck().get(i).getValue() == card.getValue()) counter++;
if (gameService.getGame().getDrawCardDeck().get(i) == lastPlayedCard) {
lastPlayedCardDoesNotExistInDrawCardDeck = false;
break;
}
} }
if (card.getColor() == Card.Color.BLACK) expected = 3;
else expected = 1;
assertEquals(expected, counter);
assertTrue(lastPlayedCardDoesNotExistInDrawCardDeck);
} }
@Test
@DisplayName("ChooseColorBotTest")
public void ChooseColorBotTest() {
GameService gameService = new GameService();
gameService.setTest(true);
Card card = new Card().setColor(Card.Color.BLACK).setValue(Card.Value.CHOOSE);
boolean answer = false;
gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().clear();
gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().add(card);
gameService.getGame().getPlayerService().setCurrentTurn(false);
gameService.playCard(card);
if (gameService.getGame().getLastPlayedCard().getColor() != Card.Color.BLACK){
answer = true;
}
assertTrue(answer);
}
@Test
@DisplayName("CheckIfTestWasInitializedWithFalse")
public void CheckIfTestWasInitializedWithFalse() {
GameService gameService = new GameService();
assertFalse(gameService.getTest());
}
@Test
@DisplayName("CheckIfTestCanBeSetToTrue")
public void CheckIfTestCanBeSetToTrue() {
GameService gameService = new GameService();
gameService.setTest(true);
assertTrue(gameService.getTest());
}
@Test
@DisplayName("CheckIfBotMovesAutomaticallyAfterPlayer")
public void CheckIfBotMovesAutomaticallyAfterPlayer() {
GameService gameService = new GameService();
Card card = new Card().setColor(Card.Color.BLUE).setValue(Card.Value.ONE);
gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().add(new Card().setColor(Card.Color.BLUE).setValue(Card.Value.FIVE));
gameService.playCard(card);
boolean answer = gameService.getGame().getLastPlayedCard() != card;
assertTrue(answer);
}
} }

64
src/test/java/de/hsfulda/onses/PlayerServiceTest.java

@ -1,6 +1,9 @@
package de.hsfulda.onses; package de.hsfulda.onses;
import com.sun.tools.jconsole.JConsoleContext;
import de.hsfulda.onses.models.Card;
import de.hsfulda.onses.services.GameService;
import de.hsfulda.onses.services.PlayerService; import de.hsfulda.onses.services.PlayerService;
import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
@ -90,4 +93,65 @@ public class PlayerServiceTest {
assertEquals(expected, answer1); assertEquals(expected, answer1);
assertEquals(expected, answer2); assertEquals(expected, answer2);
} }
@Test
@DisplayName("CheckForCardRemoval")
void CheckForCardRemoval() {
GameService gameService = new GameService();
Card card1 = new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.TWO);
Card card2 = new Card().setColor(Card.Color.RED).setValue(Card.Value.ONE);
gameService.getGame().getPlayerService().setCurrentTurn(true);
gameService.getGame().getPlayerService().getPlayerList().getFirst().addCardToPlayerDeck(card1);
gameService.getGame().getPlayerService().getPlayerList().getFirst().addCardToPlayerDeck(card2);
int before = gameService.getGame().getPlayerService().getPlayerList().getFirst().getPlayerDeck().size();
gameService.getGame().getPlayerService().removeCardFromPlayerDeck(card1);
int after = gameService.getGame().getPlayerService().getPlayerList().getFirst().getPlayerDeck().size();
assertEquals(before - 1, after);
}
@Test
@DisplayName("CheckCardRemovalFromBotDeck")
void CheckCardRemovalFromBotDeck() {
GameService gameService = new GameService();
Card card1 = new Card().setColor(Card.Color.YELLOW).setValue(Card.Value.TWO);
Card card2 = new Card().setColor(Card.Color.RED).setValue(Card.Value.ONE);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.RED).setValue(Card.Value.FIVE));
gameService.setTest(true);
gameService.getGame().getPlayerService().setCurrentTurn(false);
gameService.getGame().getPlayerService().getPlayerList().getLast().addCardToPlayerDeck(card1);
gameService.getGame().getPlayerService().getPlayerList().getLast().addCardToPlayerDeck(card2);
int before = gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().size();
gameService.getGame().getPlayerService().botMove();
int after = gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().size();
assertEquals(before - 1, after);
}
@Test
@DisplayName("CheckThatLastPlayedCardWasPlayedByBot")
void CheckThatLastPlayedCardWasPlayedByBot() {
GameService gameService = new GameService();
Card card1 = new Card().setColor(Card.Color.RED).setValue(Card.Value.ONE);
gameService.getGame().setLastPlayedCard(new Card().setColor(Card.Color.RED).setValue(Card.Value.FIVE));
gameService.getGame().getPlayerService().setCurrentTurn(false);
gameService.getGame().getPlayerService().getPlayerList().getLast().getPlayerDeck().clear();
gameService.getGame().getPlayerService().getPlayerList().getLast().addCardToPlayerDeck(card1);
gameService.getGame().getPlayerService().botMove();
Card lastPlayedCard = gameService.getGame().getLastPlayedCard();
assertEquals(card1, lastPlayedCard);
}
} }
Loading…
Cancel
Save