diff --git a/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java b/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java index eb231422..02384ab3 100644 --- a/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java +++ b/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java @@ -122,6 +122,7 @@ private boolean jumpOver(int stepsInHome, int homeIdx, boolean outside) { //tests if the piece comes from the outside in the home if (outside) { System.out.println("Server: jumpOver: for the homeIndex: " + homeIdx + " ,stepsInHome: " + stepsInHome + " , outside: " + outside + " annd the targetIndex: " + stepsInHome); + if(stepsInHome>3) return true; if (logic.getGame().getActivePlayer().getHomeNodes()[stepsInHome].isOccupied()) return true; for (int i = 0; i <= stepsInHome; i++) { if (logic.getGame().getActivePlayer().getHomeNodes()[i].isOccupied()) return true; @@ -131,6 +132,7 @@ private boolean jumpOver(int stepsInHome, int homeIdx, boolean outside) { else { int targetIndex = stepsInHome + homeIdx; System.out.println("Server: jumpOver: for the homeIndex: " + homeIdx + " ,stepsInHome: " + stepsInHome + " , outside: " + outside + " and the targetIndex: " + targetIndex); + if(targetIndex>3) return true; if (logic.getGame().getActivePlayer().getHomeNodes()[targetIndex].isOccupied()) return true; for (int i = 1 + homeIdx; i <= targetIndex; i++) { if (logic.getGame().getActivePlayer().getHomeNodes()[i].isOccupied()) return true; diff --git a/Projekte/mdga/model/src/test/java/pp/mdga/client/clientState/ClientStateTest.java b/Projekte/mdga/model/src/test/java/pp/mdga/client/clientState/ClientStateTest.java index 875dd611..af236867 100644 --- a/Projekte/mdga/model/src/test/java/pp/mdga/client/clientState/ClientStateTest.java +++ b/Projekte/mdga/model/src/test/java/pp/mdga/client/clientState/ClientStateTest.java @@ -73,6 +73,7 @@ public class ClientStateTest { private WaitingState waiting; private WaitingPieceState waitingPiece; private WaitRankingState waitRanking; + //private todo //declare server-messages here private ActivePlayerMessage activePlayer; @@ -116,9 +117,12 @@ public class ClientStateTest { private PowerCard shieldCard; private PowerCard turboCard; - //declare a player + //initialize ownPlayer private Player player; + //initialize other player + private Player enemy; + //declare own piece private Piece ownPiece= new Piece(Color.ARMY, PieceState.ACTIVE); @@ -167,12 +171,26 @@ public void accept(Visitor visitor) { } }; + //declare ownPlayer + + //declare other player + enemy= new Player(name); + enemy.setColor(Color.CYBER); + + //sets the player in the game + + clientGameLogic.getGame().addPlayer(0,player); + clientGameLogic.getGame().addPlayer(1,enemy); + clientGameLogic.getGame().getBoard().setPieceOnBoard(15,ownPiece); + clientGameLogic.getGame().getBoard().setPieceOnBoard(25,enemyPiece); + + //initialize the messages from the server activePlayer = new ActivePlayerMessage(color); anyPiece = new AnyPieceMessage(); briefing = new BriefingMessage(); ceremonyMessage = new CeremonyMessage(); - die = new DieMessage(6); + die = new DieMessage(3); diceAgain = new DiceAgainMessage(); diceNow = new DiceNowMessage(); endOfTurn = new EndOfTurnMessage(); diff --git a/Projekte/mdga/model/src/test/java/pp/mdga/game/PieceTest.java b/Projekte/mdga/model/src/test/java/pp/mdga/game/PieceTest.java index 30c770c1..801dd302 100644 --- a/Projekte/mdga/model/src/test/java/pp/mdga/game/PieceTest.java +++ b/Projekte/mdga/model/src/test/java/pp/mdga/game/PieceTest.java @@ -2,146 +2,1229 @@ import org.junit.Before; import org.junit.Test; +import pp.mdga.game.card.PowerCard; +import pp.mdga.message.client.AnimationEndMessage; +import pp.mdga.message.client.RequestDieMessage; +import pp.mdga.message.client.RequestMoveMessage; +import pp.mdga.message.client.RequestPlayCardMessage; +import pp.mdga.message.client.SelectCardMessage; +import pp.mdga.message.server.ServerMessage; +import pp.mdga.server.ServerGameLogic; +import pp.mdga.server.ServerSender; +import pp.mdga.server.automaton.GameState; +import pp.mdga.server.automaton.game.TurnState; +import pp.mdga.server.automaton.game.turn.ChoosePieceState; +import pp.mdga.server.automaton.game.turn.PlayPowerCardState; +import pp.mdga.server.automaton.game.turn.PowerCardState; +import pp.mdga.server.automaton.game.turn.RollDiceState; +import pp.mdga.server.automaton.game.turn.choosepiece.SelectPieceState; +import pp.mdga.server.automaton.game.turn.choosepiece.StartPieceState; +import pp.mdga.server.automaton.game.turn.choosepiece.WaitingPieceState; +import pp.mdga.server.automaton.game.turn.rolldice.FirstRollState; +import pp.mdga.visitor.Visitor; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Map; + +import static org.junit.Assert.*; /** * this test-class tests the testcases T035-T058 */ public class PieceTest { + //declare game here + private Game game; + + //declare server here + private ServerGameLogic serverGameLogic; + + //declare player-Client here + private Player playerClient; + private String nameClient = "Client"; + private Color clientColor; + + //declare pieces of client here + private Piece pieceClient0; + private Piece pieceClient1; + private Piece pieceClient2; + private Piece pieceClient3; + + //declare player-host here + private Player playerHost; + private String nameHost = "Host"; + private Color hostColor; + + //declare pieces of host here + private Piece pieceHost0; + private Piece pieceHost1; + private Piece pieceHost2; + private Piece pieceHost3; + + //declare cyberPlayer here + private String nameCyber; + private Player playerCyber; + private Color cyberColor; + + //declare cyberPieces + private Piece pieceCyber0; + private Piece pieceCyber1; + private Piece pieceCyber2; + private Piece pieceCyber3; + + //ID's for player + private int IDHost; + private int IDClient; + private int IDCyber; + + //declare states + GameState gameState; + TurnState turnState; + RollDiceState rollDiceState; + FirstRollState firstRollState; + ChoosePieceState choosePieceState; + SelectPieceState selectPieceState; + PowerCardState powerCardState; + PlayPowerCardState playPowerCardState; + WaitingPieceState waitingPieceState; + StartPieceState startPieceState; + + //declare dies + private Die die1; + private Die die2; + private Die die3; + private Die die4; + private Die die5; + private Die die6; + + //declare PowerCards here + PowerCard swapCard = new PowerCard() { + @Override + public void accept(Visitor visitor) { + + } + }; + + PowerCard shieldCard = new PowerCard() { + @Override + public void accept(Visitor visitor) { + + } + }; + + + //declare messages here + @Before public void Setup() { + //initialize game here + game = new Game(); + + //initialize server here + serverGameLogic = new ServerGameLogic(new ServerSender() { + @Override + public void send(int id, ServerMessage message) { + + } + + @Override + public void broadcast(ServerMessage message) { + + } + + @Override + public void disconnectClient(int id) { + + } + + @Override + public void shutdown() { + + } + }, game); + + IDHost = 1; + IDClient = 2; + IDCyber = 3; + + + //declare player-Client here + playerClient = new Player(nameClient); + clientColor = Color.ARMY; + playerClient.setColor(clientColor); + game.addPlayer(IDClient, playerClient); + + //declare player-host here + playerHost = new Player(nameHost); + hostColor = Color.NAVY; + playerHost.setColor(hostColor); + game.addPlayer(IDHost, playerHost); + + //declare playerCyber here + nameCyber = "Cyber"; + playerCyber = new Player(nameCyber); + cyberColor = Color.CYBER; + playerCyber.setColor(cyberColor); + game.addPlayer(IDCyber, playerCyber); + + //initialize the playerData + for(Map.Entry entry : game.getPlayers().entrySet()){ + game.addPlayer(entry.getKey(), entry.getValue()); + } + + + //declare pieces of client here + pieceClient0 = game.getPlayerByColor(clientColor).getWaitingArea()[0]; + pieceClient1 = game.getPlayerByColor(clientColor).getWaitingArea()[1]; + pieceClient2 = game.getPlayerByColor(clientColor).getWaitingArea()[2]; + pieceClient3 = game.getPlayerByColor(clientColor).getWaitingArea()[3]; + + //clear waiting-area of Client + for (int i = 0; i < 4; i++) { + game.getPlayerByColor(clientColor).getWaitingArea()[i] = null; + } + + + //declare pieces of host here + pieceClient0 = game.getPlayerByColor(hostColor).getWaitingArea()[0]; + pieceClient1 = game.getPlayerByColor(hostColor).getWaitingArea()[1]; + pieceClient2 = game.getPlayerByColor(hostColor).getWaitingArea()[2]; + pieceClient3 = game.getPlayerByColor(hostColor).getWaitingArea()[3]; + + //clear waiting-area of Client + for (int i = 0; i < 4; i++) { + game.getPlayerByColor(hostColor).getWaitingArea()[i] = null; + } + + //declare pieces of cyber here + pieceCyber0 = game.getPlayerByColor(cyberColor).getWaitingArea()[0]; + pieceCyber1 = game.getPlayerByColor(cyberColor).getWaitingArea()[1]; + pieceCyber2 = game.getPlayerByColor(cyberColor).getWaitingArea()[2]; + pieceCyber3 = game.getPlayerByColor(cyberColor).getWaitingArea()[3]; + + //clear waiting-area of cyber + for (int i = 0; i < 4; i++) { + game.getPlayerByColor(cyberColor).getWaitingArea()[i] = null; + } + + //set the Client-pieces here + game.getBoard().setPieceOnBoard(25, pieceClient0); //for UC 02, 03.01, 14,4 + game.getPlayerByColor(clientColor).setPieceInHome(1, pieceClient1);//set piece in Home at 2 slot for UC 18,12,13,11 + game.getBoard().setPieceOnBoard(19, pieceClient2); //for UC 13, 15 + //game.getBoard().setPieceOnBoard(); //todo + + //set the host-pieces here + game.getBoard().setPieceOnBoard(28, pieceHost0); //for UC 02,14 ,15, 03.01,4 + game.getBoard().setPieceOnBoard(18, pieceHost1); //for UC 1, 10, 17, 16 + game.getPlayerByColor(hostColor).addWaitingPiece(pieceClient2);//set in waitingArea fur uc 5 + game.getBoard().setPieceOnBoard(0, pieceHost3); //for uc 9 + + //set the pieces of cyber + + game.getBoard().setPieceOnBoard(10,pieceCyber0); // for UC 6,7,8 + game.getBoard().setPieceOnBoard(12,pieceCyber1); // + game.getPlayerByColor(cyberColor).addWaitingPiece(pieceClient3); //for uc 7 + //game..... todo + + //initializes the states + gameState= serverGameLogic.getGameState(); + turnState= gameState.getTurnState(); + rollDiceState= turnState.getRollDiceState(); + firstRollState= rollDiceState.getFirstRollState(); + choosePieceState= turnState.getChoosePieceState(); + selectPieceState= choosePieceState.getSelectPieceState(); + powerCardState = turnState.getPowerCardState(); + playPowerCardState = turnState.getPlayPowerCardState(); + waitingPieceState =serverGameLogic.getGameState().getTurnState().getChoosePieceState().getWaitingPieceState(); + startPieceState = serverGameLogic.getGameState().getTurnState().getChoosePieceState().getStartPieceState(); + + //initialize dies + die1 = new Die(1); + die2= new Die(2); + die3 = new Die(3); + die4 = new Die(4); + die5 = new Die(5); + die6 = new Die(6); } - // UC-Piece-01 + /** + * Tests the logic for when a piece moves. + *

+ * Use Case UC-Piece-01: Ensure that a piece moves in the right direction + *

+ */ @Test public void testMove() { - // TODO: Implement test logic for moving a piece + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //sets the active Player to host + game.setActiveColor(hostColor); + + //sets the die-class, to roll 4's + Die die = new Die(4); + game.setDie(die4); + + //sends the request-die-message + serverGameLogic.received(new RequestDieMessage(),IDHost); + + //tests if the server is in selectPieceState + assertTrue(game.getBoard().getInfield()[12].isOccupied()); + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),selectPieceState); + + //send wrong message + serverGameLogic.received(new RequestMoveMessage(pieceCyber1),IDHost); + + //tests if there is no change + assertTrue(game.getBoard().getInfield()[12].isOccupied()); + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),selectPieceState); + + //sends the move-message + serverGameLogic.received(new RequestMoveMessage(pieceHost2),IDHost); + + //tests if the piece has moved in the right direction + assertTrue(game.getBoard().getInfield()[4].isOccupied()); + assertEquals(game.getBoard().getInfield()[4].getOccupant(),pieceHost3); } - // UC-Piece-02 + /** + * Tests the logic for when a piece can't move. + *

+ * Use Case UC-Piece-02: Ensure that a piece cannot move if blocked by others. + *

+ */ @Test public void testCantMove() { - // TODO: Implement test logic for when a piece can't move + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set active player to army + game.setActiveColor(clientColor); + + //set die-class + game.setDie(die2); + + //send request Die-message + serverGameLogic.received(new RequestDieMessage(),IDClient); + + //send requestMove-Message + serverGameLogic.received(new RequestMoveMessage(pieceClient2),IDClient); + + //tests if the hostPiece2 is still at idx 19 and the server is still in selectable pieces + assertTrue(game.getBoard().getInfield()[19].isOccupied()); + assertEquals(game.getBoard().getInfield()[19].getOccupant(),pieceClient2); + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),selectPieceState); } - // UC-Piece-03 + /** + * Tests the logic for when no possible moves are available. + *

+ * Use Case UC-Piece-03: Check game behavior when a player has no valid moves. + *

+ */ @Test public void testNoPossibleMove() { // TODO: Implement test logic for when no possible moves are available } + /** + * Tests the logic for throwing a piece off the board. + *

+ * Use Case UC-Piece-03: Verify conditions under which a piece can be thrown off. + *

+ */ @Test public void testThrow() { - // TODO: Implement test logic for throwing a piece off the board + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set active player to host + game.setActiveColor(hostColor); + + //set Dice to 1 + game.setDie(die1); + + //send requestDice + serverGameLogic.received(new RequestDieMessage(),IDHost); + + //send requestMove-message + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDHost); + + //tests if the idx is unoccupied + assertFalse(game.getBoard().getInfield()[19].isOccupied()); + + //tests if the idx 20 is occupied + assertTrue(game.getBoard().getInfield()[20].isOccupied()); + + //tests if the piece on idx 20 is pieceHost1 + assertEquals(game.getBoard().getInfield()[20].getOccupant(),pieceHost1); } - // UC-Piece-04 + /** + * Tests the logic for when a piece gets thrown. + *

+ * Use Case UC-Piece-04: Confirm that a thrown piece is removed from play. + *

+ */ @Test public void testGetThrown() { - // TODO: Implement test logic for when a piece gets thrown + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set active player to host + game.setActiveColor(hostColor); + + //set Dice to 1 + game.setDie(die1); + + //send requestDice + serverGameLogic.received(new RequestDieMessage(),IDHost); + + //send requestMove-message + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDHost); + + //tests if pieceClient2 is waitingArea + assertTrue(Arrays.stream(game.getPlayerByColor(clientColor).getWaitingArea()).toList().contains(pieceClient2)); } - // UC-Piece-05 + /** + * Tests the logic for a piece leaving the waiting area. + *

+ * Use Case UC-Piece-05: Ensure a piece can transition from waiting to active play. + *

+ */ @Test public void testLeaveWaitingArea() { - // TODO: Implement test logic for a piece leaving the waiting area + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set active player to host + game.setActiveColor(hostColor); + + //set Dice to 6 + game.setDie(die6); + + //send requestDice + serverGameLogic.received(new RequestDieMessage(),IDHost); + + //tests if the sever is in selectPiece + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),waitingPieceState); + + //send requestMove-message + serverGameLogic.received(new RequestMoveMessage(pieceHost2),IDHost); + + //tests if the waitingArea does not include the piece anymore + assertFalse(Arrays.stream(game.getPlayerByColor(hostColor).getWaitingArea()).toList().contains(pieceHost2)); + + //tests if the pieceHost3 is at idx 30 + assertTrue(game.getBoard().getInfield()[30].isOccupied()); + assertEquals(game.getBoard().getInfield()[30].getOccupant(),pieceHost2); } - // UC-Piece-06 + /** + * Tests the logic for a piece that must leave the starting field. + *

+ * Use Case UC-Piece-06: Verify conditions requiring a piece to leave its starting position. + *

+ */ @Test public void testMustLeaveStartingField() { - // TODO: Implement test logic for a piece that must leave the starting field + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //sets the activePlayer to cyber + game.setActiveColor(cyberColor); + + //set Dice to 4 + game.setDie(die4); + + //send requestDiceMessage + serverGameLogic.received(new RequestDieMessage(),IDCyber); + + //tests if the sever is in startPiece + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(choosePieceState); + choosePieceState.setCurrentState(startPieceState); + + //send requestMoveMessage + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDCyber); + + //tests if the cyberPiece2 has moved + assertTrue(game.getBoard().getInfield()[12].isOccupied()); + assertEquals(game.getBoard().getInfield()[12].getOccupant(),pieceCyber1); + + //tests if the sever is in startPiece + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(choosePieceState); + choosePieceState.setCurrentState(startPieceState); + + //send requestMoveMessage + serverGameLogic.received(new RequestMoveMessage(pieceHost0),IDCyber); + + //tests if the piece is moved + assertTrue(game.getBoard().getInfield()[14].isOccupied()); + assertEquals(game.getBoard().getInfield()[14].getOccupant(),pieceHost0); + assertFalse(game.getBoard().getInfield()[10].isOccupied()); } - // UC-Piece-07 + /** + * Tests the logic for when a piece doesn't have to leave the starting field. + *

+ * Use Case UC-Piece-07: Check scenarios where a piece can stay on its starting field. + *

+ */ @Test public void testDontHaveToLeaveStartingField() { - // TODO: Implement test logic for when a piece doesn't have to leave the starting field + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set the active player to cyberPlayer + game.setActiveColor(cyberColor); + + //remove piece from cyberPlayer + game.getPlayerByColor(cyberColor).removeWaitingPiece(game.getPlayerByColor(cyberColor).getWaitingPiece()); + + //set dice to 3 + game.setDie(die3); + + //tests if the server is in selectPieceState + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),selectPieceState); + + //send requestDice-Message + serverGameLogic.received(new RequestDieMessage(),IDCyber); + + //send requestMoveMessage for CyberPiece1 + serverGameLogic.received(new RequestMoveMessage(pieceCyber1),IDCyber); + + //tests if the cyberPiece1 is moved + assertTrue(game.getBoard().getInfield()[15].isOccupied()); + assertEquals(game.getBoard().getInfield()[15].getOccupant(), pieceCyber1); + } - // UC-Piece-08 + /** + * Tests the logic for when a piece can't leave the starting field. + *

+ * Use Case UC-Piece-08: Verify conditions preventing a piece from leaving its starting field. + *

+ */ @Test public void testCantLeaveStartingField() { - // TODO: Implement test logic for when a piece can't leave the starting field + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //sets the activePlayer to cyber + game.setActiveColor(cyberColor); + + //set Dice to two + game.setDie(die2); + + //send requestDiceMessage + serverGameLogic.received(new RequestDieMessage(),IDCyber); + + //tests if the sever is in selectPiece + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),selectPieceState); + + //send requestMoveMessage + serverGameLogic.received(new RequestMoveMessage(pieceCyber0),IDCyber); + + //tests if the sever is in selectPiece + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),selectPieceState); + + //tests if the cyberPiece0 is still at its idx + assertTrue(game.getBoard().getInfield()[10].isOccupied()); + assertEquals(game.getBoard().getInfield()[10].getOccupant(),pieceHost0); + + //sets the dice to 2 + game.setDie(die2); + + //send the requestMove-Message + serverGameLogic.received(new RequestMoveMessage(pieceCyber1),IDCyber); + + //tests if the pieceCyber + assertTrue(game.getBoard().getInfield()[14].isOccupied()); + assertEquals(game.getBoard().getInfield()[14].getOccupant(),pieceHost1); + + + } - // UC-Piece-09 + /** + * Tests the logic for when a piece reaches a bonus field. + *

+ * Use Case UC-Piece-09: Verify the benefits applied when landing on a bonus field. + *

+ */ @Test public void testReachBonusField() { - // TODO: Implement test logic for when a piece reaches a bonus field + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //gets the top bonusCard + PowerCard card = game.getDrawPile().get(0); + + //sets the active Player to Host + game.setActiveColor(hostColor); + + //sets the dice-seed to 4 + game.setDie(die4); + + //sends the requestDice-Message + serverGameLogic.received(new RequestDieMessage(),IDHost); + + //requestMove of hostPiece3 + serverGameLogic.received(new RequestMoveMessage(pieceHost3),IDHost); + + //tests the position of hostPiece3 + assertTrue(game.getBoard().getInfield()[4].isOccupied()); + assertEquals(game.getBoard().getInfield()[4].getOccupant(),pieceHost3); + + //tests if the player has received a bonusCard + assertNotEquals(card, game.getDrawPile().get(0)); + assertTrue(game.getPlayers().get(IDHost).getHandCards().stream().toList().contains(card)); } + /** + * Tests the logic for when there are no power cards available. + *

+ * Use Case UC-Piece-09: Ensure the game handles the situation with no available power cards. + *

+ */ @Test public void testNoPowerCards() { - // TODO: Implement test logic for when there are no power cards available + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //sets the active Player to Host + game.setActiveColor(hostColor); + + //sets the dice-seed to 4 + game.setDie(die4); + + //sets the pile empty + game.setDrawPile(new ArrayList<>()); + assertTrue(game.getDrawPile().isEmpty()); + + //sets the discard pile empty + game.setDiscardPile(new ArrayList<>()); + assertTrue(game.getDiscardPile().isEmpty()); + + //sends the requestDice-Message + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDHost); + + // requestMOve of hostPiece3 + serverGameLogic.received(new RequestMoveMessage(pieceHost3),IDHost); + + assertTrue(game.getBoard().getInfield()[4].isOccupied()); + assertEquals(game.getBoard().getInfield()[4].getOccupant(),pieceHost3); + + //tests if the player has received a bonusCard + assertTrue(game.getDrawPile().isEmpty()); + assertTrue(game.getPlayers().get(IDHost).getHandCards().stream().toList().isEmpty()); } + /** + * Tests the logic for shuffling the pile of power cards. + *

+ * Use Case UC-Piece-09: Confirm that the power card deck can be shuffled correctly. + *

+ */ @Test public void testShufflePile() { - // TODO: Implement test logic for shuffling the pile of power cards + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //sets the active Player to Host + game.setActiveColor(hostColor); + + //sets the dice-seed to 4 + game.setDie(die4); + + //sets the discard pile empty + game.setDiscardPile(game.getDrawPile()); + assertFalse(game.getDiscardPile().isEmpty()); + + //sets the pile empty + game.setDrawPile(new ArrayList<>()); + assertTrue(game.getDrawPile().isEmpty()); + + //sends the requestDice-Message + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDHost); + + // requestMOve of hostPiece3 + serverGameLogic.received(new RequestMoveMessage(pieceHost3),IDHost); + + assertTrue(game.getBoard().getInfield()[4].isOccupied()); + assertEquals(game.getBoard().getInfield()[4].getOccupant(),pieceHost3); + + //tests if the player has received a bonusCard + assertFalse(game.getDrawPile().isEmpty()); + + //tests if the drawPile is not Empty + assertFalse(game.getDrawPile().isEmpty()); + assertTrue(game.getDiscardPile().isEmpty()); + } - // UC-Piece-10 + /** + * Tests the logic for entering the house area. + *

+ * Use Case UC-Piece-10: Verify that a piece can enter the house area according to the rules. + *

+ */ @Test public void testEnterHouse() { - // TODO: Implement test logic for entering the house area + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set activePlayer to client + game.setActiveColor(clientColor); + + //set the die in Game to 1 + game.setDie(die1); + + //sends the request-Dice-message + serverGameLogic.received(new RequestDieMessage(),IDClient); + + //sends the requestMove-message for pieceClient1 + serverGameLogic.received(new RequestMoveMessage(pieceClient2),IDClient); + + //tests, if the piece is in the first slot of the home + assertTrue(game.getPlayerByColor(clientColor).getHomeNodes()[0].isOccupied()); + assertEquals(game.getPlayerByColor(clientColor).getHomeNodes()[3].getOccupant(), pieceClient2); + assertFalse(game.getBoard().getInfield()[19].isOccupied()); } + /** + * Tests the logic to ensure a piece can only enter its own house. + *

+ * Use Case UC-Piece-10: Check that a piece can only enter its designated house. + *

+ */ @Test public void testOnlyEnterOwnHouse() { - // TODO: Implement test logic to ensure a piece can only enter its own house + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set activePlayer to host + game.setActiveColor(hostColor); + + //set the die in Game to 3 + game.setDie(die3); + + //sends the request-Dice-message + serverGameLogic.received(new RequestDieMessage(),IDHost); + + //sends the requestMove-message for pieceClient1 + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDHost); + + //tests if hostPiece1 is at idx 20 + assertTrue(game.getBoard().getInfield()[20].isOccupied()); + assertEquals(game.getBoard().getInfield()[20].getOccupant(),pieceHost1); } - // UC-Piece-11 + /** + * Tests the logic for activating a piece in the home area. + *

+ * Use Case UC-Piece-11: Confirm that a piece can be activated correctly in the home area. + *

+ */ @Test public void testActiveHomePiece() { - // TODO: Implement test logic for activating a piece in the home area + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set activePlayer to client + game.setActiveColor(clientColor); + + //set the die in Game to 2 + game.setDie(die2); + + //sends the request-Dice-message + serverGameLogic.received(new RequestDieMessage(),IDClient); + + //sends the requestMove-message for pieceClient1 + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDClient); + + //tests if clientPiece1 is in the home at idx 3 + assertTrue(game.getPlayerByColor(clientColor).getHomeNodes()[3].isOccupied()); + assertEquals(game.getPlayerByColor(clientColor).getHomeNodes()[3].getOccupant(), pieceClient1); } + /** + * Tests the logic to prevent jumping over another piece in the house. + *

+ * Use Case UC-Piece-11: Ensure that a piece cannot jump over another piece in the house area. + *

+ */ @Test public void testCantJumpOverFigureInHouse() { - // TODO: Implement test logic to prevent jumping over another piece in the house + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set activePlayer to client + game.setActiveColor(clientColor); + + //set the die in Game to 4 + game.setDie(die4); + + //send requestDice-Message + serverGameLogic.received(new RequestDieMessage(),IDClient); + + //sends requestMoveMessage with clientPiece 02 + serverGameLogic.received(new RequestMoveMessage(pieceHost2),IDHost); + + //tests, if the clientPiece02 is at idx 19 + assertTrue(game.getBoard().getInfield()[19].isOccupied()); + assertEquals(game.getBoard().getInfield()[20].getOccupant(),pieceClient2); } - // UC-Piece-12 + /** + * Tests the logic for when an active home piece is blocked. + *

+ * Use Case UC-Piece-12: Verify that an active piece cannot move if blocked by another piece. + *

+ */ @Test public void testActiveHomePieceBlocked() { - // TODO: Implement test logic for when an active home piece is blocked + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //set active player to client + game.setActiveColor(clientColor); + + //set Dice to 3 + game.setDie(die3); + + //sends the requestDice-message + serverGameLogic.received(new RequestDieMessage(),IDClient); + + //sends the request MoveMessage + serverGameLogic.received(new RequestMoveMessage(pieceClient1),IDClient); + + //tests if the piece is still at idx 2 in home + assertTrue(game.getPlayerByColor(clientColor).getHomeNodes()[1].isOccupied()); + assertEquals(game.getPlayerByColor(clientColor).getHomeNodes()[1].getOccupant(), pieceClient1); } + /** + * Tests the logic for a piece on the starting field with a shield. + *

+ * Use Case UC-Piece-13: Ensure that a piece with a shield behaves correctly on the starting field. + *

+ */ @Test public void testOnStartingFieldWithShield() { - // TODO: Implement test logic for a piece on the starting field with a shield + //sets the color to host + game.setActiveColor(hostColor); + + //sets the dice to 2 + game.setDie(die2); + + //sets the shield of hostPiece1 true + pieceHost1.setShield(ShieldState.ACTIVE); + + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //sends the requestDice-message + serverGameLogic.received(new RequestDieMessage(),IDHost); + + //sends the moveMessage + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDHost); + + //tests the position of the hostPiece1 and that shield is suppressed + assertTrue(game.getBoard().getInfield()[20].isOccupied()); + assertEquals(game.getBoard().getInfield()[20].getOccupant(),pieceClient1); + + assertEquals(pieceHost1.getShield(),ShieldState.SUPPRESSED); } - // UC-Piece-13 + /** + * Tests the logic for attempting to throw a figure with a shield. + *

+ * Use Case UC-Piece-14: Verify that a piece with a shield cannot be thrown by opponents. + *

+ */ @Test public void testThrowFigureWithShield() { - // TODO: Implement test logic for attempting to throw a figure with a shield + //set clientPiece2 the shield active + pieceClient2.setShield(ShieldState.ACTIVE); + + //set host as active player + game.setActiveColor(hostColor); + + //set die to 1 + game.setDie(die1); + + //sends the server in firstRoll + serverGameLogic.setCurrentState(gameState); + gameState.setCurrentState(turnState); + turnState.setCurrentState(rollDiceState); + rollDiceState.setCurrentState(firstRollState); + + //tests if the server is in firstRoll + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),rollDiceState); + assertEquals(rollDiceState.getCurrentState(),firstRollState); + + //send requestDice + serverGameLogic.received(new RequestDieMessage(),IDHost); + + //send requestMove of hostPiece1 + serverGameLogic.received(new RequestMoveMessage(pieceHost1),IDHost); + + //tests if the clientPiece2 is still at idx 19 and hostPiece1 at idx 18 and clientPiece2 shield is still active + assertTrue(game.getBoard().getInfield()[19].isOccupied()); + assertTrue(game.getBoard().getInfield()[18].isOccupied()); + + assertEquals(game.getBoard().getInfield()[18].getOccupant(),pieceHost1); + assertEquals(game.getBoard().getInfield()[19].getOccupant(),pieceClient2); + + assertEquals(pieceClient2.getShield(),ShieldState.ACTIVE); } - // UC-Piece-14 + /** + * Tests the logic for using a swap power-up. + *

+ * Use Case UC-Piece-15: Confirm that a player can use a swap power-up to exchange positions. + *

+ */ @Test public void testUseSwap() { - // TODO: Implement test logic for using a swap power-up + //send the server in choosePowerCard + serverGameLogic.setCurrentState(gameState); + serverGameLogic.getGameState().setCurrentState(turnState); + serverGameLogic.getGameState().getTurnState().setCurrentState(powerCardState); + + //tests if the server is in selectPieces + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),powerCardState); + + //set activePlayer to Host + game.setActiveColor(hostColor); + + //sends the requestPlayCard + serverGameLogic.received(new SelectCardMessage(swapCard),IDHost); + + //sends the selectedPiece-message + serverGameLogic.received(RequestPlayCardMessage.requestPlaySwap(pieceHost0.getUuid(),pieceClient0.getUuid()),IDHost); + + //tests if the piece at idx 25 is pieceHost0 and at idx 28 is pieceClient0 + assertTrue(game.getBoard().getInfield()[25].isOccupied()); + assertEquals(game.getBoard().getInfield()[25].getOccupant(),pieceHost0); + + assertTrue(game.getBoard().getInfield()[28].isOccupied()); + assertEquals(game.getBoard().getInfield()[28].getOccupant(),pieceClient0); + + + //tests if the server is in playPowerCard + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),playPowerCardState); } - // UC-Piece-15 + /** + * Tests the logic for using a shield power-up. + *

+ * Use Case UC-Piece-16: Ensure that a player can activate a shield power-up correctly. + *

+ */ @Test public void testUseShield() { - // TODO: Implement test logic for using a shield power-up + //send the server in choosePowerCard + serverGameLogic.setCurrentState(gameState); + serverGameLogic.getGameState().setCurrentState(turnState); + serverGameLogic.getGameState().getTurnState().setCurrentState(powerCardState); + + //tests if the server is in selectPieces + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),powerCardState); + + //set activePlayer to Host + game.setActiveColor(hostColor); + + //sends the requestPlayCard + serverGameLogic.received(new SelectCardMessage(shieldCard),IDHost); + + //sends the selectedPiece-message + serverGameLogic.received(RequestPlayCardMessage.requestPlayShield(pieceHost0.getUuid()),IDHost); + + //tests if the piece at idx 28 has a shield + assertEquals(pieceHost0.getShield(),ShieldState.ACTIVE); + + //tests if the server is in playPowerCard + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),playPowerCardState); } - // UC-Piece-16 + /** + * Tests the logic for when a piece loses its shield. + *

+ * Use Case UC-Piece-17: Verify that the game correctly updates the status when a piece loses its shield. + *

+ */ @Test public void testLoseShield() { - // TODO: Implement test logic for when a piece loses its shield + //sets activePlayer to client + game.setActiveColor(clientColor); + + //set shieldState.ACTIVE im pieceHost1 + pieceHost1.setShield(ShieldState.ACTIVE); + + //set die to 5 + game.setDie(die5); + + //sends the server in selectPiece + serverGameLogic.setCurrentState(gameState); + serverGameLogic.getGameState().setCurrentState(turnState); + serverGameLogic.getGameState().getTurnState().setCurrentState(choosePieceState); + serverGameLogic.getGameState().getTurnState().getChoosePieceState().setCurrentState(selectPieceState); + + //tests if the server is in selectPieces + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),selectPieceState); + + //send requestDice-message + serverGameLogic.received(new RequestDieMessage(),IDClient); + + //send requestMove-message for clientPiece0 + serverGameLogic.received(new RequestMoveMessage(pieceClient0),IDClient); + + //tests if the server is in animation-state + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), gameState.getAnimationState()); + + //send 3 animationEndMessage + serverGameLogic.received(new AnimationEndMessage(),IDClient); + serverGameLogic.received(new AnimationEndMessage(),IDHost); + serverGameLogic.received(new AnimationEndMessage(),IDCyber); + + //test for new Player + assertEquals(serverGameLogic.getGame().getActiveColor(),hostColor); + + //tests, if the shieldState is NONE + assertEquals(pieceHost1.getShield(),ShieldState.NONE); } - // UC-Piece-17 + /** + * Tests the logic for a piece that has finished the game. + *

+ * Use Case UC-Piece-18: Confirm that the game recognizes a piece that has completed its journey. + *

+ */ @Test public void testFinishedPiece() { - // TODO: Implement test logic for a piece that has finished the game + //sends the server in selectPiece + serverGameLogic.setCurrentState(gameState); + serverGameLogic.getGameState().setCurrentState(turnState); + serverGameLogic.getGameState().getTurnState().setCurrentState(choosePieceState); + serverGameLogic.getGameState().getTurnState().getChoosePieceState().setCurrentState(selectPieceState); + + //tests if the server is in selectPieces + assertEquals(serverGameLogic.getCurrentState(),gameState); + assertEquals(gameState.getCurrentState(), turnState); + assertEquals(turnState.getCurrentState(),choosePieceState); + assertEquals(choosePieceState.getCurrentState(),selectPieceState); + + //sets the active color to client + game.setActiveColor(clientColor); + + //set the dice to 2 + game.setDie(die2); + //sends the requestDie-Message + serverGameLogic.received(new RequestDieMessage(),IDClient); + + //sends the requestMove-Message + serverGameLogic.received(new RequestMoveMessage(pieceClient1),IDClient); + + //tests if the Piece is in the final position and is marked as home-finished + assertTrue(game.getPlayerByColor(clientColor).getHomeNodes()[3].isOccupied()); + assertEquals(game.getPlayerByColor(clientColor).getHomeNodes()[3].getOccupant(), pieceClient1); + assertEquals(pieceClient1.getState(),PieceState.HOMEFINISHED); } }