Merge branch 'master' of https://github.com/inf112-v20/Fiasko

docs/team/referater/referat_16_03_2020.md

@@ -0,0 +1,15 @@
+## Oppmøte
+Tilstede: Steinar, Gabriel, Kristian, Torbjørn, Petter
+Ikke tilstede:
+
+## Agenda
+- Design valg 
+
+- Brukerhistorier
+
+- Fordele Oppgaver
+
+## Møte
+- Diskuterte håndtering av framtidinge møter med tanke på korona situasjonen.
+- Gikk igjennom prosjekt tavlen og gikk igjennom hver oppgave der.
+- Avsluttet møte ved å dele oss opp i par-programmeringsgrupper. 

src/main/java/inf112/fiasko/roborally/objects/Board.java

@@ -1,9 +1,6 @@
 package inf112.fiasko.roborally.objects;
 
 import inf112.fiasko.roborally.element_properties.*;
-import inf112.fiasko.roborally.utility.TextureConverterUtil;
-
-import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -178,6 +175,19 @@ public class Board {
         return robots.containsKey(robot);
     }
 
+    /**
+     * Updates the flag of the robot if it stands on the correct flag.
+     * @param robotID The RobotID of a robot
+     * @param flagID TileType of the flag we check
+     */
+    public void updateFlagOnRobot(RobotID robotID, TileType flagID) {
+        Robot robot = robots.get(robotID);
+        int flagNr = flagID.getTileTypeID() % 16;
+        if (flagNr - 1 == robot.getLastFlagVisited()) {
+            robot.setLastFlagVisitedAndUpdateBackupPosition(flagNr);
+        }
+    }
+
     /**
      * Checks if a potential robot move would be blocked by a wall
      * @param robotPosition The current position of the robot
@@ -296,7 +306,7 @@ public class Board {
      * @param direction The direction to move the element
      * @return The new position of the element
      */
-    private Position getNewPosition(Position oldPosition, Direction direction) {
+    Position getNewPosition(Position oldPosition, Direction direction) {
         switch (direction) {
             case NORTH:
                 return new Position(oldPosition.getXCoordinate(), oldPosition.getYCoordinate() - 1);
@@ -327,6 +337,13 @@ public class Board {
         return elements;
     }
 
+    public Tile getTileOnPosition(Position position) {
+        if (!isValidPosition(position)) {
+            throw new IllegalArgumentException("Position is not on the board!");
+        }
+        return tiles.getElement(position.getXCoordinate(), position.getYCoordinate());
+    }
+
     /**
      * Gets a list of BoardElementContainers, containing all tiles and positions of given tile types
      * @param tiles The tiles you want all positions for
@@ -345,7 +362,7 @@ public class Board {
      * @param walls The walls you want all positions for
      * @return A list of BoardElementContainers
      */
-    public List<BoardElementContainer<Wall>> getPositionsOfTileOnBoard(WallType ... walls) {
+    public List<BoardElementContainer<Wall>> getPositionsOfWallOnBoard(WallType ... walls) {
         List<BoardElementContainer<Wall>> combinedList = new ArrayList<>();
         for (WallType wall : walls) {
             combinedList.addAll(makeTileList(wall, this.walls));
@@ -367,18 +384,20 @@ public class Board {
         for (int y = grid.getHeight() - 1; y >= 0; y--) {
             for (int x = 0; x < grid.getWidth(); x++) {
                 T gridElement = grid.getElement(x, y);
-                if (gridElement.getClass().isAssignableFrom(Tile.class)) {
+                if (gridElement != null) {
-                    Tile tile = (Tile) gridElement;
+                    if (gridElement.getClass().isAssignableFrom(Tile.class)) {
-                    if (tile.getTileType() == type) {
+                        Tile tile = (Tile) gridElement;
-                        objList.add(new BoardElementContainer<>(gridElement, new Position(x,y)));
+                        if (tile.getTileType() == type) {
+                            objList.add(new BoardElementContainer<>(gridElement, new Position(x,y)));
+                        }
+                    } else if (gridElement.getClass().isAssignableFrom(Wall.class)) {
+                        Wall wall = (Wall) gridElement;
+                        if (wall.getWallType() == type) {
+                            objList.add(new BoardElementContainer<>(gridElement, new Position(x,y)));
+                        }
+                    } else {
+                        throw new IllegalArgumentException("Grid has unknown type.");
                     }
-                } else if (gridElement.getClass().isAssignableFrom(Wall.class)) {
-                    Wall wall = (Wall) gridElement;
-                    if (wall.getWallType() == type) {
-                        objList.add(new BoardElementContainer<>(gridElement, new Position(x,y)));
-                    }
-                } else {
-                    throw new IllegalArgumentException("Grid has unknown type.");
                 }
             }
         }

src/main/java/inf112/fiasko/roborally/objects/BoardElementContainer.java

@@ -8,7 +8,7 @@ import inf112.fiasko.roborally.element_properties.Position;
  */
 public class BoardElementContainer <K>{
     K obj;
-    Position pos;
+    private Position pos;
 
     /**
      * Initializes the BoardElementContainer

src/main/java/inf112/fiasko/roborally/objects/Player.java

@@ -14,23 +14,16 @@ public class Player {
     private final String name;
     private boolean powerDownNextRound = false;
     private ProgrammingCardDeck playerDeck;
-    private List <ProgrammingCard> program = new ArrayList();
+    private List <ProgrammingCard> program;
 
     /**
      * Instantiates a new player
      * @param robotID the global identifier of the robot
      * @param name the unique name of the player
-     * @param playerDeck the hand of cards dealt to the player
      */
-    public Player(RobotID robotID, String name, ProgrammingCardDeck playerDeck) {
+    public Player(RobotID robotID, String name) {
         this.robotID = robotID;
         this.name = name;
-        this.playerDeck = playerDeck;
-        program.add(0, null); //sets the initial values in program to null
-        program.add(1, null);
-        program.add(2, null);
-        program.add(3, null);
-        program.add(4, null);
     }
 
     /**
@@ -39,6 +32,14 @@ public class Player {
      */
     public RobotID getRobotID(){return robotID;}
 
+    /**
+     * Set the players deck to the given deck
+     * @param playerDeck a deck of cards given to the player
+     */
+    public void setPlayerDeck(ProgrammingCardDeck playerDeck){
+        this.playerDeck=playerDeck;
+    }
+
     /**
      * Gives you the Name of the player
      * @return a player Name
@@ -70,32 +71,23 @@ public class Player {
     public void setPowerDownNextRound(boolean powerDownStatus) { this.powerDownNextRound = powerDownStatus;}
 
     /**
-     * Places a card in to the player program
+     * Gets the program from the player
-     * @param card the card that is placed in to the player program
+     * @return List of programing cards
      */
-    public void setCardInProgram(ProgrammingCard card) {
+    public List <ProgrammingCard> getProgramFromPlayer(){
-        for (int i = 0; i < 5; i++) {
+        return program;
-            if (program.get(i) == null) {
-                program.add(i, card);
-                return;
-            }
-        }
-        throw new IllegalArgumentException("Program deck is full,tried to add to many cards");
     }
 
     /**
-     * Removes a card by the given index from the player program and returns it.
+     * Sets the Players program to the given list of programing cards
-     * @param cardNr the index of the card that is being removed
+     * @param cardList list the size of 5 with programing cards
-     * @return the card that was removed from the program
      */
-    public ProgrammingCard removeProgramCard(int cardNr) {
+    public void setInProgram(List <ProgrammingCard> cardList){
-        if(cardNr<5 && cardNr>-1) {
+        if(cardList.size() != 5){
-            program.add(cardNr, null);
+            throw new IllegalArgumentException("list must contain 5 programing cards");
-            return program.remove(cardNr + 1);
         }
-        else{
+        else {
-            throw new IllegalArgumentException("cant remove more then index 4 or remove negatives");
+            program = new ArrayList<>(cardList);
-
         }
     }
 

src/main/java/inf112/fiasko/roborally/objects/RoboRallyGame.java

@@ -1,9 +1,7 @@
 package inf112.fiasko.roborally.objects;
 
-import inf112.fiasko.roborally.element_properties.Action;
+
-import inf112.fiasko.roborally.element_properties.Position;
+import inf112.fiasko.roborally.element_properties.*;
-import inf112.fiasko.roborally.element_properties.RobotID;
-import inf112.fiasko.roborally.element_properties.TileType;
 import inf112.fiasko.roborally.utility.BoardLoaderUtil;
 
 import java.io.IOException;
@@ -16,7 +14,8 @@ import java.util.concurrent.TimeUnit;
  */
 public class RoboRallyGame implements IDrawableGame {
     private Board gameBoard;
-    List<BoardElementContainer<Tile>> cogwheels;
+    private List<BoardElementContainer<Tile>> cogwheels;
+    private List<BoardElementContainer<Tile>> conveyorBelts;
 
     public RoboRallyGame(boolean debug) {
         if (debug) {
@@ -90,6 +89,13 @@ public class RoboRallyGame implements IDrawableGame {
             gameBoard = BoardLoaderUtil.loadBoard("boards/Checkmate.txt", robots);
             cogwheels = gameBoard.getPositionsOfTileOnBoard(TileType.COGWHEEL_RIGHT,
                     TileType.COGWHEEL_LEFT);
+            conveyorBelts = gameBoard.getPositionsOfTileOnBoard(TileType.TRANSPORT_BAND_FAST,
+                    TileType.TRANSPORT_BAND_SLOW, TileType.TRANSPORT_BAND_FAST_SIDE_ENTRANCE_RIGHT,
+                    TileType.TRANSPORT_BAND_FAST_RIGHT, TileType.TRANSPORT_BAND_SLOW_RIGHT,
+                    TileType.TRANSPORT_BAND_SLOW_SIDE_ENTRANCE_RIGHT, TileType.TRANSPORT_BAND_FAST_SIDE_ENTRANCE_LEFT,
+                    TileType.TRANSPORT_BAND_FAST_LEFT, TileType.TRANSPORT_BAND_SLOW_LEFT,
+                    TileType.TRANSPORT_BAND_SLOW_SIDE_ENTRANCE_LEFT);
+
             new Thread(() -> {
                 try {
                     runGameLoop();
@@ -204,4 +210,104 @@ public class RoboRallyGame implements IDrawableGame {
             }
         }
     }
+
+    private Boolean listContainsTile(Tile tile) {
+        boolean containsTile = false;
+        for (BoardElementContainer<Tile> conveyorBelt : conveyorBelts) {
+            if (conveyorBelt.getObject() == tile) {
+                containsTile = true;
+                break;
+            }
+        }
+        return containsTile;
+    }
+
+    /**
+     * Moves robots standing on conveyor belts in the direction of the conveyor belt.
+     * Rotates robots being moved to a turn on the conveyor belt.
+     * @throws InterruptedException If disturbed during sleep.
+     */
+    private void moveConveyorBelts() throws InterruptedException {
+        for (BoardElementContainer<Tile> conveyorBelt : conveyorBelts) {
+            if (!gameBoard.hasRobotOnPosition(conveyorBelt.getPosition())) {
+                continue;
+            }
+            Position newPosition = gameBoard.getNewPosition(conveyorBelt.getPosition(),
+                    conveyorBelt.getObject().getDirection());
+            Tile nextTile = gameBoard.getTileOnPosition(newPosition);
+            Direction currentDirection = conveyorBelt.getObject().getDirection();
+            Direction nextDirection = nextTile.getDirection();
+            RobotID robot = gameBoard.getRobotOnPosition(conveyorBelt.getPosition());
+            if (listContainsTile(nextTile) && currentDirection != nextDirection) {
+                if (currentDirection.equals(Direction.NORTH)) {
+                    if (nextDirection.equals(Direction.WEST)) {
+                        sleep();
+                        gameBoard.moveRobot(robot, currentDirection);
+                        sleep();
+                        gameBoard.rotateRobotLeft(robot);
+                    } else {
+                        sleep();
+                        gameBoard.moveRobot(robot, currentDirection);
+                        sleep();
+                        gameBoard.rotateRobotRight(robot);
+                    }
+                } else if (currentDirection.equals(Direction.WEST)) {
+                    if (nextDirection.equals(Direction.SOUTH)) {
+                        sleep();
+                        gameBoard.moveRobot(robot, currentDirection);
+                        sleep();
+                        gameBoard.rotateRobotLeft(robot);
+                    } else {
+                        sleep();
+                        gameBoard.moveRobot(robot, currentDirection);
+                        sleep();
+                        gameBoard.rotateRobotLeft(robot);
+                    }
+                } else if (currentDirection.equals(Direction.SOUTH)) {
+                    if (nextDirection.equals(Direction.EAST)) {
+                        sleep();
+                        gameBoard.moveRobot(robot, currentDirection);
+                        sleep();
+                        gameBoard.rotateRobotLeft(robot);
+                    } else {
+                        sleep();
+                        gameBoard.moveRobot(robot, currentDirection);
+                        sleep();
+                        gameBoard.rotateRobotRight(robot);
+                    }
+                } else if (currentDirection.equals(Direction.EAST)) {
+                    if (nextDirection.equals(Direction.NORTH)) {
+                        sleep();
+                        gameBoard.moveRobot(robot, currentDirection);
+                        sleep();
+                        gameBoard.rotateRobotLeft(robot);
+                    } else {
+                        sleep();
+                        gameBoard.moveRobot(robot, currentDirection);
+                        sleep();
+                        gameBoard.rotateRobotRight(robot);
+                    }
+                }
+            } else {
+                sleep();
+                gameBoard.moveRobot(gameBoard.getRobotOnPosition(conveyorBelt.getPosition()),
+                        conveyorBelt.getObject().getDirection());
+            }
+        }
+    }
+
+    /**
+     * Checks all flags for robots. Tries to update the flag of the robot.
+     */
+    private void checkAllFlags() {
+        List<BoardElementContainer<Tile>> listOfFlags = gameBoard.getPositionsOfTileOnBoard(TileType.FLAG_1,
+                TileType.FLAG_2, TileType.FLAG_3, TileType.FLAG_4);
+        for (BoardElementContainer<Tile> flag:listOfFlags) {
+            Position flagPosition = flag.getPosition();
+            if (gameBoard.hasRobotOnPosition(flagPosition)) {
+                RobotID robot = gameBoard.getRobotOnPosition(flagPosition);
+                gameBoard.updateFlagOnRobot(robot, flag.getObject().getTileType());
+            }
+        }
+    }
 }

src/test/java/inf112/fiasko/roborally/objects/BoardTest.java

@@ -10,7 +10,10 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
 import java.util.List;
+import java.util.function.Predicate;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -31,6 +34,9 @@ public class BoardTest {
     private static Position someValidPosition8;
     private List<Robot> robotList;
     private Board board;
+    private Board boardWithDifferentAmountOfAllTypes;
+    private Map<WallType,Integer> wallTypeNumberMap = new HashMap<>();
+    private Map<TileType,Integer> tileTypeNumberMap = new HashMap<>();
 
     @BeforeClass
     public static void globalSetUp() {
@@ -61,7 +67,51 @@ public class BoardTest {
         wallGrid.setElement(2, 1, new Wall(WallType.WALL_NORMAL, Direction.SOUTH));
         wallGrid.setElement(2, 2, new Wall(WallType.WALL_NORMAL, Direction.EAST));
         wallGrid.setElement(1, 2, new Wall(WallType.WALL_CORNER, Direction.NORTH_EAST));
+        tileGrid.setElement(3,3, new Tile(TileType.FLAG_1, Direction.NORTH));
+        tileGrid.setElement(2,2, new Tile(TileType.FLAG_2, Direction.NORTH));
         board = new Board(tileGrid, wallGrid, robotList);
+
+        Grid<Tile> tileGridAllTypes = new Grid<>(6,6);
+        Grid<Wall> wallGridAllTypes = new Grid<>(6,6);
+        List<Robot> emptyRobotList = new ArrayList<>();
+        wallGridAllTypes.setElement(1, 1, new Wall(WallType.WALL_NORMAL, Direction.SOUTH));
+        wallGridAllTypes.setElement(1, 2, new Wall(WallType.WALL_NORMAL, Direction.SOUTH));
+        wallGridAllTypes.setElement(1, 3, new Wall(WallType.WALL_NORMAL, Direction.SOUTH));
+        wallGridAllTypes.setElement(2, 1, new Wall(WallType.WALL_CORNER, Direction.EAST));
+        wallGridAllTypes.setElement(2, 2, new Wall(WallType.WALL_CORNER, Direction.EAST));
+        tileGridAllTypes.setElement(1, 1, new Tile(TileType.COGWHEEL_LEFT, Direction.NORTH));
+        tileGridAllTypes.setElement(3, 1, new Tile(TileType.COGWHEEL_RIGHT, Direction.NORTH));
+        tileGridAllTypes.setElement(3, 2, new Tile(TileType.COGWHEEL_RIGHT, Direction.NORTH));
+        tileGridAllTypes.setElement(3, 3, new Tile(TileType.COGWHEEL_RIGHT, Direction.NORTH));
+        tileGridAllTypes.setElement(3, 4, new Tile(TileType.COGWHEEL_RIGHT, Direction.NORTH));
+        tileGridAllTypes.setElement(2, 1, new Tile(TileType.TILE, Direction.WEST));
+        tileGridAllTypes.setElement(2, 2, new Tile(TileType.TILE, Direction.WEST));
+        tileGridAllTypes.setElement(2, 3, new Tile(TileType.TILE, Direction.WEST));
+        tileGridAllTypes.setElement(2, 4, new Tile(TileType.TILE, Direction.WEST));
+        tileGridAllTypes.setElement(2, 5, new Tile(TileType.TILE, Direction.WEST));
+        wallTypeNumberMap.put(WallType.WALL_NORMAL, 3);
+        wallTypeNumberMap.put(WallType.WALL_CORNER, 2);
+        tileTypeNumberMap.put(TileType.COGWHEEL_RIGHT, 4);
+        tileTypeNumberMap.put(TileType.COGWHEEL_LEFT, 1);
+        tileTypeNumberMap.put(TileType.TILE, 5);
+        boardWithDifferentAmountOfAllTypes = new Board(tileGridAllTypes,wallGridAllTypes,emptyRobotList);
+
+    }
+
+    @Test
+    public void flagGetsUpdatedOnRobotWithCorrectLastVisitedFlag() {
+        Robot testRobot = robotList.get(6);
+        assertEquals(0,testRobot.getLastFlagVisited());
+        board.updateFlagOnRobot(RobotID.ROBOT_7, TileType.FLAG_1);
+        assertEquals(1,testRobot.getLastFlagVisited());
+    }
+
+    @Test
+    public void flagDoesNotUpdatedOnRobotWithWringLastVisitedFlag() {
+        Robot testRobot = robotList.get(6);
+        assertEquals(0,testRobot.getLastFlagVisited());
+        board.updateFlagOnRobot(RobotID.ROBOT_7, TileType.FLAG_2);
+        assertEquals(0,testRobot.getLastFlagVisited());
     }
 
     @Test
@@ -161,4 +211,72 @@ public class BoardTest {
         board.respawnRobots();
         assertFalse(board.isRobotAlive(robot.getRobotId()));
     }
+
+    @Test
+    public void getPositionsOfTileOnBoardGivesCorrectAmountOfCogwheelLeftTiles() {
+        assertEquals((int)tileTypeNumberMap.get(TileType.COGWHEEL_LEFT),
+                boardWithDifferentAmountOfAllTypes.getPositionsOfTileOnBoard(TileType.COGWHEEL_LEFT).size());
+    }
+
+    @Test
+    public void getPositionsOfTileOnBoardHasTypeCogwheelLeft() {
+        List<BoardElementContainer<Tile>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfTileOnBoard(TileType.COGWHEEL_LEFT);
+
+        for (BoardElementContainer<Tile> elem : boardElemList) {
+            assertEquals(elem.getObject().getTileType(), TileType.COGWHEEL_LEFT);
+        }
+    }
+
+    @Test
+    public void getPositionsOfTileOnBoardGivesCorrectAmountOfTileTiles() {
+        assertEquals((int)tileTypeNumberMap.get(TileType.TILE),
+                boardWithDifferentAmountOfAllTypes.getPositionsOfTileOnBoard(TileType.TILE).size());
+    }
+
+    @Test
+    public void getPositionsOfTileOnBoardHasTypeTile() {
+        List<BoardElementContainer<Tile>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfTileOnBoard(TileType.TILE);
+
+        for (BoardElementContainer<Tile> elem : boardElemList) {
+            assertEquals(elem.getObject().getTileType(), TileType.TILE);
+        }
+    }
+
+    @Test
+    public void getPositionsOfWallOnBoardGivesCorrectAmountOfWallNormalWalls() {
+        assertEquals((int)wallTypeNumberMap.get(WallType.WALL_NORMAL),
+                boardWithDifferentAmountOfAllTypes.getPositionsOfWallOnBoard(WallType.WALL_NORMAL).size());
+    }
+
+    @Test
+    public void getPositionsOfWallOnBoardHasTypeWallNormal() {
+        List<BoardElementContainer<Wall>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfWallOnBoard(WallType.WALL_NORMAL);
+
+        for (BoardElementContainer<Wall> elem : boardElemList) {
+            assertEquals(elem.getObject().getWallType(), WallType.WALL_NORMAL);
+        }
+    }
+
+    @Test
+    public void getPositionsOfWallOnBoardGivesCorrectAmountOfWallCornerWalls() {
+        assertEquals((int)wallTypeNumberMap.get(WallType.WALL_CORNER),
+                boardWithDifferentAmountOfAllTypes.getPositionsOfWallOnBoard(WallType.WALL_CORNER).size());
+    }
+
+    @Test
+    public void getPositionsOfWallOnBoardHasTypeWallCorner() {
+        List<BoardElementContainer<Wall>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfWallOnBoard(WallType.WALL_CORNER);
+
+        for (BoardElementContainer<Wall> elem : boardElemList) {
+            assertEquals(elem.getObject().getWallType(), WallType.WALL_CORNER);
+        }
+    }
+
+    @Test
+    public void getPositionsOfWallOnBoardHasCorrect() {
+        List<BoardElementContainer<Wall>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfWallOnBoard(WallType.WALL_CORNER);
+        Predicate<BoardElementContainer<Wall>> pred = (element) -> element.getObject().getWallType() == WallType.WALL_CORNER;
+        boardElemList.removeIf(pred);
+        assertEquals(0, boardElemList.size());
+    }
 }

src/test/java/inf112/fiasko/roborally/objects/PlayerTest.java

@@ -4,106 +4,76 @@ import inf112.fiasko.roborally.element_properties.Action;
 import inf112.fiasko.roborally.element_properties.RobotID;
 import org.junit.Before;
 import org.junit.Test;
-import static org.junit.Assert.assertEquals;
+
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.junit.Assert.*;
+
 
 public class PlayerTest {
     private Player playerTest;
+    private List<ProgrammingCard> cards = new ArrayList();
+
     @Before
     public void setUp() {
-        List<ProgrammingCard> cards = new ArrayList();
         cards.add(new ProgrammingCard(10, Action.MOVE_1));
         cards.add(new ProgrammingCard(20, Action.MOVE_2));
         cards.add(new ProgrammingCard(30, Action.MOVE_3));
         cards.add(new ProgrammingCard(40, Action.BACK_UP));
         cards.add(new ProgrammingCard(50, Action.ROTATE_LEFT));
         ProgrammingCardDeck playerDeck = new ProgrammingCardDeck(cards);
-        playerTest = new Player(RobotID.ROBOT_1, "TestPlayer" ,playerDeck);
+        playerTest = new Player(RobotID.ROBOT_1, "TestPlayer" );
     }
 
     @Test
     public void setPowerDownStatusToTrue() {
         playerTest.setPowerDownNextRound(true);
-        assertEquals(true, playerTest.getPowerDownNextRound());
+        assertTrue(playerTest.getPowerDownNextRound());
     }
 
     @Test
     public void setPowerDownStatusToFalse() {
         playerTest.setPowerDownNextRound(false);
-        assertEquals(false, playerTest.getPowerDownNextRound());
+        assertFalse(playerTest.getPowerDownNextRound());
+    }
+    @Test
+    public void testSetInProgram(){
+        playerTest.setInProgram(cards);
+        assertEquals(Action.MOVE_1, playerTest.getProgramFromPlayer().get(0).getAction());
+        assertEquals(Action.MOVE_2, playerTest.getProgramFromPlayer().get(1).getAction());
+        assertEquals(Action.MOVE_3, playerTest.getProgramFromPlayer().get(2).getAction());
+        assertEquals(Action.BACK_UP, playerTest.getProgramFromPlayer().get(3).getAction());
+    }
+
+    @Test (expected = IllegalArgumentException.class)
+    public void testSetInProgramWithToManyCards(){
+        cards.add(new ProgrammingCard(10,Action.ROTATE_LEFT));
+        playerTest.setInProgram(cards);
     }
 
     @Test
-    public void cardGetsInsertedIntoProgram() {
+    public void testSetInDeck(){
-        playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
+        cards.add(new ProgrammingCard(10,Action.ROTATE_LEFT));
-        assertEquals(Action.MOVE_1,playerTest.getProgram().get(0).getAction());
+        ProgrammingCardDeck playerDeck = new ProgrammingCardDeck(cards);
-    }
+        playerTest.setPlayerDeck(playerDeck);
-    @Test
+        assertEquals(playerDeck , playerTest.getPlayerDeck());
-    public void addMultipuleCards(){
-        playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
-        playerTest.setCardInProgram(new ProgrammingCard(30,Action.MOVE_2));
-        playerTest.setCardInProgram(new ProgrammingCard(23452342,Action.MOVE_3));
-        assertEquals(Action.MOVE_1,playerTest.getProgram().get(0).getAction());
-        assertEquals(Action.MOVE_2,playerTest.getProgram().get(1).getAction());
-        assertEquals(Action.MOVE_3,playerTest.getProgram().get(2).getAction());
-    }
-    @Test(expected = IllegalArgumentException.class)
-    public void addTooManyCardsGetsAError() {
-        playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
-        playerTest.setCardInProgram(new ProgrammingCard(30,Action.MOVE_2));
-        playerTest.setCardInProgram(new ProgrammingCard(234523423,Action.MOVE_3));
-        playerTest.setCardInProgram(new ProgrammingCard(2342342,Action.MOVE_3));
-        playerTest.setCardInProgram(new ProgrammingCard(23432342,Action.MOVE_3));
-        playerTest.setCardInProgram(new ProgrammingCard(234523242,Action.MOVE_3));
-    }
-    @Test
-    public void removeCardsFromPlayerProgram() {
-        playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
-        playerTest.setCardInProgram(new ProgrammingCard(30,Action.MOVE_2));
-        playerTest.setCardInProgram(new ProgrammingCard(234523423,Action.MOVE_3));
-        playerTest.setCardInProgram(new ProgrammingCard(2342342,Action.MOVE_3));
-        playerTest.setCardInProgram(new ProgrammingCard(23432342,Action.MOVE_3));
-        assertEquals(Action.MOVE_3,playerTest.getProgram().get(4).getAction());
-        playerTest.removeProgramCard(4);
-        assertEquals(null,playerTest.getProgram().get(4));
-    }
-    @Test
-    public void removeAllCardsFromPlayerProgram() {
-        playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
-        playerTest.setCardInProgram(new ProgrammingCard(30,Action.MOVE_2));
-        playerTest.setCardInProgram(new ProgrammingCard(234523423,Action.MOVE_3));
-        playerTest.setCardInProgram(new ProgrammingCard(2342342,Action.MOVE_3));
-        playerTest.setCardInProgram(new ProgrammingCard(23432342,Action.MOVE_3));
-        assertEquals(Action.MOVE_3,playerTest.getProgram().get(4).getAction());
-        assertEquals(Action.MOVE_3,playerTest.getProgram().get(3).getAction());
-        assertEquals(Action.MOVE_3,playerTest.getProgram().get(2).getAction());
-        assertEquals(Action.MOVE_2,playerTest.getProgram().get(1).getAction());
-        assertEquals(Action.MOVE_1,playerTest.getProgram().get(0).getAction());
-        playerTest.removeProgramCard(4);
-        playerTest.removeProgramCard(3);
-        playerTest.removeProgramCard(2);
-        playerTest.removeProgramCard(1);
-        playerTest.removeProgramCard(0);
-        assertEquals(null,playerTest.getProgram().get(4));
-        assertEquals(null,playerTest.getProgram().get(3));
-        assertEquals(null,playerTest.getProgram().get(2));
-        assertEquals(null,playerTest.getProgram().get(1));
-        assertEquals(null,playerTest.getProgram().get(0));
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
-    public void getErrorIfYouRemoveMoreThenIndexFive(){
+    public void GetPlayerRobotId(){
-        playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
+        assertEquals(RobotID.ROBOT_1, playerTest.getRobotID());
-        playerTest.removeProgramCard(5);
-
     }
-    @Test(expected = IllegalArgumentException.class)
-    public void getErrorIfYouRemoveANegativIndex(){
-        playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
-        playerTest.removeProgramCard(-1);
 
+    @Test
+    public void GetPlayerName(){
+        assertEquals("TestPlayer", playerTest.getName());
+    }
+
+    @Test
+    public void GetProgramFromPlayer(){
+        playerTest.setInProgram(cards);
+        assertEquals(cards,playerTest.getProgram());
     }
 
 }