Merge branch 'master' into player-and-zoom

Deliverables/Oblig2.md

@@ -26,3 +26,42 @@
 #### Tile
 *Brukerhistorie*
 *   Som brett trenger jeg noe på meg som gir meg funksjonalitet
+
+#### Robot
+*Krav*
+*   Må kunne dø
+*   Må kunne gjennopstå
+*   Må kunne ta skade
+*   Må peke i en gyldig retning
+*   Må bevege seg i pekende retning
+
+
+*Brukerhistorie*
+*   Som robot må jeg kunne dytte en annen robot hvis det er lovlig å dytte roboten, for å kunne gjøre et gyldig trekk
+*   Som robot må jeg peke i en ortogonal retning for å ha en gyldig bevegelses retning
+*   Som robot må jeg kunne bevege meg i pekende retning, for å kunne gjøre et gyldig trekk
+
+#### Vegg
+*Krav*
+*   Må kunne stoppe en robot
+
+*Brukerhistorie*
+*   Som vegg må jeg stoppe en robot fra å gå gjennom meg for hindre dem å gjøre et ugyldig trekk
+*   Som vegg må jeg kunne bli plassert i forskjellige retninger for å kunne bestemme den funksjonelle retningen til veggen
+
+#### Brett
+*Krav*
+*   Må kunne ha forskjellige tiles
+
+*Brukerhistorie*
+*   Som brett må jeg kunne ha forskjellige tiles for å kunne vise alle aspektene av spillet
+
+#### Hull
+*Krav*
+*   Må kunne drepe en robot
+
+#### Spiller
+*Brukerhistorie*
+*   Som spiller må roboten min kunne gjennopstå om den har flere liv, for å kunne spille videre
+*   Som spiller må roboten min kunne dø, for å håntere om roboten tar for mye skade eller går i et hull/av kartet
+*   Som spiller må roboten min kunne ta skade, for å håntere påvirkning fra objekter som avgir skade til roboter

docs/team/referater/referat_25_02_2020.md

@@ -0,0 +1,81 @@
+## Oppmøte
+Tilstede: Steinar, Gabriel, Kristian, Torbjørn, Petter
+Ikke tilstede:
+
+## Agenda
+- Planlegge brukerhistorier
+
+
+## Møte
+Det har blitt diskutert hvilke brukerhistorier det er vi trenger, og hvorfor. Hvilke krav de forskjellige brukerhistoriene har og hvordan vi kan løse dem.
+Snakket om funksjonalitet på enkelte aspekter med spillet, og hvordad disse skal bli håndtert. 
+
+
+#### Idemyldring til krav/brukerhistorie: 
+- Stoppe robot fra å gå igjennom vegger
+
+- Kunne gjør et gyldig trekk
+
+- Kunne dytte en robot
+
+- Vegger må ha forskjellige retningsorienteringer
+
+- brett må kunne ha forskjellige tiles
+
+- Robot må kunne gjennoppstå
+
+- Robot må kunne ta skade
+
+- Robot må kunne dø
+
+- Hull må drepe robot
+
+- Må kunne dytte en robot dersom det er gydig å dytte den
+
+#### Brukerhistorie/notater
+
+"Stoppe robot fra å gå gjennom vegg"
+
+- Hvem: Vegg
+
+- Hva: Stoppe robot fra å gå gjennom meg
+
+- Hvorfor: For å hindre roboten i å gjøre et ugyldig trekk
+
+"Kunne dytte en robot hvis det er lovlig å dytte den"
+
+- Hvem: Robot
+
+- Hvorfor: For å kunne gjøre gyldige trekk
+
+"Vegger må kunne vøre i fordskjellige retninger"
+
+- Hvem: Vegg
+
+- Hva: Som vegg må jeg kunne bli plassert i forskjellige retninger
+
+- Hvorfor: For å kunne bestemme den funksjonelle retningen til veggen
+
+"Brett må kunne ha forskjellige tiles"
+
+- Hvem: Brett
+
+- Hva: Som brett må jeg kunne ha forskjellige tiles
+
+- Hvorfor: For å kunne vise alle de forskjellige aspektene av spillets tiles.
+
+"Robot må kunne gjennoppstå, dersom den har enda har flere liv"
+
+- Hvem: Spiller
+
+- Hva: Respawne roboten, dersom den ikke er tom for liv
+
+- Hvorfor: Som spiller vil jeg at roboten min skal kunne gjennoppstå for å være i stand til å spille en runde til
+
+"Robot må kunne ta skade"
+
+- Hvem: Spiller
+
+- Hva: Robot må kunne ta imot skade
+
+- Hvorfor: For å håndtere andre objekters påvirkning på roboten

src/main/java/inf112/fiasko/roborally/GameLauncher.java

@@ -42,8 +42,6 @@ public class GameLauncher extends ApplicationAdapter {
         camera.setToOrtho(false, game.getWidth() * tileDimensions,
                 game.getHeight() * tileDimensions);
         batch = new SpriteBatch();
-        /*MyTextInputListener listener = new MyTextInputListener();
-        Gdx.input.getTextInput(listener, "Input name", "", "Name");*/
     }
 
     /**
@@ -86,15 +84,4 @@ public class GameLauncher extends ApplicationAdapter {
         textureSheet.dispose();
         batch.dispose();
     }
-
-    /*public static class MyTextInputListener implements Input.TextInputListener {
-        @Override
-        public void input (String text) {
-            System.out.println(text);
-        }
-
-        @Override
-        public void canceled () {
-        }
-    }*/
 }

src/main/java/inf112/fiasko/roborally/Main.java

@@ -8,8 +8,8 @@ public class Main {
     public static void main(String[] args) {
         LwjglApplicationConfiguration cfg = new LwjglApplicationConfiguration();
         cfg.title = "Game Board";
-        cfg.width = 768;
+        cfg.width = 900;
-        cfg.height = 769;
+        cfg.height = 900;
 
         new LwjglApplication(new GameLauncher(), cfg);
     }

src/main/java/inf112/fiasko/roborally/element_properties/Action.java

@@ -1,14 +0,0 @@
-package inf112.fiasko.roborally.element_properties;
-
-/**
- * This enum represents an action on a programming card
- */
-public enum Action {
-    ROTATE_RIGHT,
-    ROTATE_LEFT,
-    U_TURN,
-    MOVE_1,
-    MOVE_2,
-    MOVE_3,
-    BACK_UP
-}

src/main/java/inf112/fiasko/roborally/game/Game.java

@@ -1,6 +1,5 @@
 package inf112.fiasko.roborally.game;
 
-import inf112.fiasko.roborally.element_properties.Direction;
 import inf112.fiasko.roborally.element_properties.Position;
 import inf112.fiasko.roborally.element_properties.RobotID;
 import inf112.fiasko.roborally.objects.Board;
@@ -30,7 +29,7 @@ public class Game implements IDrawableGame {
                 try {
                     runGameLoop();
                 } catch (InterruptedException e) {
-                    e.printStackTrace();
+                    Thread.currentThread().interrupt();
                 }
             }).start();
         } catch (IOException e) {
@@ -43,29 +42,49 @@ public class Game implements IDrawableGame {
      * @throws InterruptedException If interrupted while trying to sleep
      */
     private void runGameLoop() throws InterruptedException {
+        long cycleDelay = 600;
         TimeUnit.SECONDS.sleep(3);
         gameBoard.rotateRobotRight(RobotID.ROBOT_1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
         gameBoard.rotateRobotRight(RobotID.ROBOT_1);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
-        gameBoard.moveRobot(RobotID.ROBOT_1, Direction.SOUTH);
+        gameBoard.moveRobotForward(RobotID.ROBOT_1);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
         gameBoard.rotateRobotLeft(RobotID.ROBOT_1);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
-        gameBoard.moveRobot(RobotID.ROBOT_1, Direction.EAST);
+        gameBoard.moveRobotForward(RobotID.ROBOT_1);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
-        gameBoard.moveRobot(RobotID.ROBOT_1, Direction.EAST);
+        gameBoard.moveRobotForward(RobotID.ROBOT_1);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
         gameBoard.rotateRobotRight(RobotID.ROBOT_1);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
-        gameBoard.moveRobot(RobotID.ROBOT_1, Direction.SOUTH);
+        gameBoard.moveRobotForward(RobotID.ROBOT_1);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
-        gameBoard.moveRobot(RobotID.ROBOT_2, Direction.EAST);
+        gameBoard.rotateRobotRight(RobotID.ROBOT_2);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
-        gameBoard.moveRobot(RobotID.ROBOT_2, Direction.WEST);
+        gameBoard.moveRobotForward(RobotID.ROBOT_2);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
-        gameBoard.moveRobot(RobotID.ROBOT_2, Direction.EAST);
+        gameBoard.rotateRobotRight(RobotID.ROBOT_2);
-        TimeUnit.SECONDS.sleep(1);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
-        gameBoard.moveRobot(RobotID.ROBOT_2, Direction.EAST);
+        gameBoard.rotateRobotRight(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.moveRobotForward(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.rotateRobotRight(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.rotateRobotRight(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.moveRobotForward(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.moveRobotForward(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.rotateRobotRight(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.rotateRobotRight(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.moveRobotForward(RobotID.ROBOT_2);
+        TimeUnit.MILLISECONDS.sleep(cycleDelay);
+        gameBoard.moveRobotForward(RobotID.ROBOT_2);
     }
 
     @Override

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

@@ -19,7 +19,6 @@ public class Board {
     private IGrid<Wall> walls;
     private IGrid<Tile> tiles;
     private Map<RobotID, Robot> robots;
-    private List<Robot> deadRobots;
 
     /**
      * Initializes the board
@@ -38,7 +37,6 @@ public class Board {
             }
             this.robots.put(robot.getRobotId(), robot);
         }
-        this.deadRobots = new ArrayList<>();
         this.boardWidth = tiles.getWidth();
         this.boardHeight = tiles.getHeight();
         this.walls = walls;
@@ -61,18 +59,6 @@ public class Board {
         return boardWidth;
     }
 
-    /**
-     * Moves all dead robots to their backups and makes them part of the board again
-     */
-    public void respawnRobots() {
-        //TODO: Account for several robots re-spawning at same backup
-        for (Robot robot : deadRobots) {
-            robot.setPosition(robot.getBackupPosition());
-            robots.put(robot.getRobotId(), robot);
-        }
-        deadRobots = new ArrayList<>();
-    }
-
     /**
      * Gets all alive robots from the board
      * @return A list of alive robots
@@ -103,7 +89,6 @@ public class Board {
      */
     public void removeDeadRobotFromBoard(Robot robot) {
         robots.remove(robot.getRobotId());
-        deadRobots.add(robot);
     }
 
     /**
@@ -126,6 +111,14 @@ public class Board {
         robot.setFacingDirection(newDirection);
     }
 
+    /**
+     * Moves a robot one unit forward according to the direction it's currently facing
+     * @param robotID The robot to move
+     */
+    public void moveRobotForward(RobotID robotID) {
+        moveRobot(robotID, robots.get(robotID).getFacingDirection());
+    }
+
     /**
      * Moves a robot one unit in a specified direction
      * @param robotID ID of the robot to move
@@ -212,7 +205,7 @@ public class Board {
      * @param robot The robot to kill
      */
     private void killRobot(Robot robot) {
-        //TODO: Must remove a life from the robot/player
+        robot.setAmountOfLives(robot.getAmountOfLives() - 1);
         removeDeadRobotFromBoard(robot);
     }
 

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

@@ -1,20 +0,0 @@
-package inf112.fiasko.roborally.objects;
-
-/**
- * This Interface describes a card without a card suit
- * @param <S> The value type
- * @param <T> The symbol type
- */
-public interface ICardWithoutSuit<S,T> {
-    /**
-     * Gets the value of the card
-     * @return The card value
-     */
-    S getValue();
-
-    /**
-     * Gets the symbol of the card
-     * @return The card symbol
-     */
-    T getSymbol();
-}

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

@@ -8,6 +8,7 @@ import inf112.fiasko.roborally.element_properties.RobotID;
  * This class represents a robot
  */
 public class Robot {
+    private int amountOfLives = 3;
     private int robotDamageTaken = 0;
     private final RobotID robotId;
     private boolean inPowerDown = false;
@@ -18,8 +19,8 @@ public class Robot {
 
     /**
      * Instantiates a new robot
-     * @param robotId gives the robot a identifier that links it too the correct player
+     * @param robotId The global identifier of the robot
-     * @param spawnPosition gives the robot its starting position on the map
+     * @param spawnPosition The starting position of the robot
      */
     public Robot (RobotID robotId, Position spawnPosition) {
         this.robotId = robotId;
@@ -30,65 +31,67 @@ public class Robot {
 
     /**
      * Gets the damage the robot has taken
-     * @return the amount of damage the robot has received
+     * @return The amount of damage the robot has received
      */
-    public int getDamage(){
+    public int getDamageTaken() {
         return robotDamageTaken;
     }
 
     /**
-     * Sets the robot's damage to a given amount
+     * Sets the robot's taken damage to a given amount
-     * @param damage the amount of damage the robot has received
+     * @param damage The amount of damage the robot has received
      */
-    public void setDamage (int damage){
+    public void setDamageTaken(int damage) {
         this.robotDamageTaken = damage;
     }
 
     /**
-     * Gets the robot's current position on the map
+     * Gets the robot's current position on the board
-     * @return the robot's current position
+     * @return The robot's current position
      */
     public Position getPosition() {
         return currentPosition;
     }
 
     /**
-     * places the robot on a new position
+     * Sets the robot's current position on the board
-     * @param newPosition the new position for the robot
+     * @param newPosition The new position of the robot
      */
     public void setPosition( Position newPosition ) {
         this.currentPosition = newPosition;
     }
 
     /**
-     * Places the status of the powerdown field
+     * Sets power-down status
-     * @param powerDownStatus True if robot is going to go to powerdown. False otherwise
+     * @param powerDownStatus Whether the robot is currently in power-down
      */
     public void setPowerDown(Boolean powerDownStatus) {
         this.inPowerDown = powerDownStatus;
     }
 
     /**
-     * Gets the status of the robot's powerdown field
+     * Gets the robot's power-down status
-     * @return robot's powerdown status
+     * @return Whether the robot is currently in power-down
      */
     public Boolean isInPowerDown(){
         return inPowerDown;
     }
 
     /**
-     * Set the robot's last visited flag too the new flag and places its backup on the flags position
+     * Set the robot's last visited flag to the new flag and places its backup on the flag's position
-     * @param currentFlag the flag the robot is standing on
+     * @param currentFlag The flag the robot is standing on
-     * @param newBackupPosition the position of the flag
      */
-    public void setLastFlagVisitedAndBackupPosition(int currentFlag, Position newBackupPosition){
+    public void setLastFlagVisitedAndUpdateBackupPosition(int currentFlag) {
+        if (currentFlag - 1 != this.lastFlagVisited) {
+            throw new IllegalArgumentException("The robot has not yet visited the previous flag!");
+        }
         this.lastFlagVisited = currentFlag;
-        this.backupPosition = newBackupPosition;
+        this.backupPosition = currentPosition;
     }
 
     /**
-     * Gets the correct flag the robot visited
+     * Gets the last flag the robot visited
-     * @return last visited flag
+     * @return Last visited flag
      */
     public int getLastFlagVisited() {
         return lastFlagVisited;
@@ -103,8 +106,8 @@ public class Robot {
     }
 
     /**
-     * Gets the identifier of the players controlling the robot
+     * Gets the robot ID
-     * @return player identifier
+     * @return Robot ID
      */
     public RobotID getRobotId() {
         return robotId;
@@ -128,4 +131,18 @@ public class Robot {
         }
         this.facingDirection = newFacingDirection;
     }
+
+    /**
+     * Sets the amount if life the robot has left
+     * @param amountOfLives the new amount if lives the robot has left
+     */
+    public void setAmountOfLives(int amountOfLives) {
+        this.amountOfLives = amountOfLives;
+    }
+
+    /**
+     * Gets the amount of life a robot has left.
+     * @return amount of life left
+     */
+    public int getAmountOfLives() { return this.amountOfLives; }
 }

src/main/java/inf112/fiasko/roborally/utility/IOUtil.java

@@ -13,7 +13,7 @@ import inf112.fiasko.roborally.objects.Wall;
 import java.util.ArrayList;
 import java.util.List;
 
-public class IOUtil {
+public final class IOUtil {
     private IOUtil() {}
 
     /**
@@ -108,7 +108,7 @@ public class IOUtil {
         Direction direction;
         if (element.getClass().isAssignableFrom(Robot.class)) {
             Robot robot = (Robot) element;
-            hasRotatedTexture = TextureConverterUtil.hasRotatedTexture(robot);
+            hasRotatedTexture = false;
             direction = robot.getFacingDirection();
         } else if (element.getClass().isAssignableFrom(Tile.class)) {
             Tile tile = (Tile) element;
@@ -116,7 +116,7 @@ public class IOUtil {
             direction = tile.getDirection();
         } else if (element.getClass().isAssignableFrom(Wall.class)) {
             Wall wall = (Wall) element;
-            hasRotatedTexture = TextureConverterUtil.hasRotatedTexture(wall);
+            hasRotatedTexture = true;
             direction = wall.getDirection();
         } else {
             throw new IllegalArgumentException("Unknown element type passed to function.");

src/main/java/inf112/fiasko/roborally/utility/ResourceUtil.java

@@ -2,7 +2,7 @@ package inf112.fiasko.roborally.utility;
 
 import java.io.InputStream;
 
-public class ResourceUtil {
+public final class ResourceUtil {
     private ResourceUtil() {}
 
     /**

src/main/java/inf112/fiasko/roborally/utility/TextureConverterUtil.java

@@ -110,24 +110,6 @@ public final class TextureConverterUtil {
         return tileSheetTileHasRotatedTextureMappings.get(tile.getTileType());
     }
 
-    /**
-     * Checks whether a wall has textures for different rotations
-     * @param wall The wall to check
-     * @return True if rotated versions of the texture exists. False otherwise
-     */
-    public static boolean hasRotatedTexture(Wall wall) {
-        return true;
-    }
-
-    /**
-     * Checks whether a robot has textures for different rotations
-     * @param robot The robot to check
-     * @return True if rotated versions of the texture exists. False otherwise
-     */
-    public static boolean hasRotatedTexture(Robot robot) {
-        return false;
-    }
-
     /**
      * Loads mappings between a tile and texture
      *

src/main/resources/boards/Checkmate.txt

@@ -1,4 +1,4 @@
-12 13
+12 12
 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 21;1
 01;1 12;3 11;3 11;3 11;3 11;3 11;3 11;3 11;3 11;3 12;5 01;1
 01;1 11;1 05;3 01;1 05;3 01;1 05;7 17;1 05;7 01;1 11;5 01;1
@@ -11,7 +11,6 @@
 01;1 11;1 01;1 05;3 01;1 05;3 01;1 05;7 01;1 05;7 11;5 01;1
 01;1 12;1 11;7 11;7 11;7 11;7 11;7 11;7 11;7 11;7 12;7 01;1
 21;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1
-01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1 01;1
 0 0 1;1 0 1;1 0 0 1;1 0 1;1 0 0
 0 0 0 1;5 0 1;5 1;5 0 1;5 0 0 0
 1;7 0 0 0 0 0 0 0 0 0 0 1;3
@@ -24,4 +23,3 @@
 1;7 0 0 0 0 0 0 0 0 0 0 1;3
 0 0 0 1;1 0 1;1 1;1 0 1;1 0 0 0
 0 0 1;5 0 1;5 0 0 1;5 0 1;5 0 0
-0 0 0 0 0 0 0 0 0 0 0 0

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

@@ -13,12 +13,16 @@ import java.util.List;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
 public class BoardTest {
     private Grid<Tile> tileGrid;
     private Grid<Wall> wallGrid;
-    private Position someValidPosition;
+    private Position someValidPosition1;
+    private Position someValidPosition5;
+    private Position someValidPosition6;
+    private Position someValidPosition7;
     private List<Robot> robotList;
     private Board board;
 
@@ -26,16 +30,38 @@ public class BoardTest {
     public void setUp() {
         tileGrid = new Grid<>(5, 5, new Tile(TileType.TILE, Direction.NORTH));
         wallGrid = new Grid<>(5, 5);
-        someValidPosition = new Position(2, 2);
+        someValidPosition1 = new Position(2, 2);
+        Position someValidPosition2 = new Position(2, 1);
+        Position someValidPosition3 = new Position(2, 3);
+        Position someValidPosition4 = new Position(2, 4);
+        someValidPosition5 = new Position(3, 1);
+        someValidPosition6 = new Position(3, 2);
+        someValidPosition7 = new Position(3, 3);
+        Position someValidPosition8 = new Position(3, 4);
         robotList = new ArrayList<>();
-        robotList.add(new Robot(RobotID.ROBOT_1, someValidPosition));
+        robotList.add(new Robot(RobotID.ROBOT_1, someValidPosition1));
-        robotList.add(new Robot(RobotID.ROBOT_2, someValidPosition));
+        robotList.add(new Robot(RobotID.ROBOT_2, someValidPosition2));
+        robotList.add(new Robot(RobotID.ROBOT_3, someValidPosition3));
+        robotList.add(new Robot(RobotID.ROBOT_4, someValidPosition4));
+        robotList.add(new Robot(RobotID.ROBOT_5, someValidPosition5));
+        robotList.add(new Robot(RobotID.ROBOT_6, someValidPosition6));
+        robotList.add(new Robot(RobotID.ROBOT_7, someValidPosition7));
+        robotList.add(new Robot(RobotID.ROBOT_8, someValidPosition8));
         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));
         board = new Board(tileGrid, wallGrid, robotList);
     }
 
+    @Test
+    public void robotCanPushRobots() {
+        board.moveRobot(RobotID.ROBOT_5, Direction.SOUTH);
+        assertNotEquals(someValidPosition5, robotList.get(4).getPosition());
+        assertNotEquals(someValidPosition6, robotList.get(5).getPosition());
+        assertNotEquals(someValidPosition7, robotList.get(6).getPosition());
+        assertFalse(board.getAliveRobots().contains(robotList.get(7)));
+    }
+
     @Test
     public void robotCanMove() {
         assertTrue(board.moveRobot(RobotID.ROBOT_1, Direction.SOUTH));
@@ -71,15 +97,15 @@ public class BoardTest {
 
     @Test
     public void robotCanBeRotatedRight() {
-        assertEquals(Direction.NORTH, robotList.get(1).getFacingDirection());
+        assertEquals(Direction.NORTH, robotList.get(0).getFacingDirection());
-        board.rotateRobotRight(RobotID.ROBOT_2);
+        board.rotateRobotRight(RobotID.ROBOT_1);
-        assertEquals(Direction.EAST, robotList.get(1).getFacingDirection());
+        assertEquals(Direction.EAST, robotList.get(0).getFacingDirection());
-        board.rotateRobotRight(RobotID.ROBOT_2);
+        board.rotateRobotRight(RobotID.ROBOT_1);
-        assertEquals(Direction.SOUTH, robotList.get(1).getFacingDirection());
+        assertEquals(Direction.SOUTH, robotList.get(0).getFacingDirection());
-        board.rotateRobotRight(RobotID.ROBOT_2);
+        board.rotateRobotRight(RobotID.ROBOT_1);
-        assertEquals(Direction.WEST, robotList.get(1).getFacingDirection());
+        assertEquals(Direction.WEST, robotList.get(0).getFacingDirection());
-        board.rotateRobotRight(RobotID.ROBOT_2);
+        board.rotateRobotRight(RobotID.ROBOT_1);
-        assertEquals(Direction.NORTH, robotList.get(1).getFacingDirection());
+        assertEquals(Direction.NORTH, robotList.get(0).getFacingDirection());
     }
 
     @Test (expected = IllegalArgumentException.class)
@@ -90,8 +116,17 @@ public class BoardTest {
 
     @Test (expected = IllegalArgumentException.class)
     public void multipleRobotsWithSameIDThrowsError() {
-        Robot robot = new Robot(RobotID.ROBOT_1, someValidPosition);
+        Robot robot = new Robot(RobotID.ROBOT_1, someValidPosition1);
         robotList.add(robot);
         new Board(tileGrid, wallGrid, robotList);
     }
+
+    @Test
+    public void killRobotReducesAmountOfLivesByOne() {
+        Robot robot = board.getAliveRobots().get(1);
+        assertEquals(3, robot.getAmountOfLives());
+        robot.setPosition(new Position(0, 0));
+        board.moveRobot(robot.getRobotId(), Direction.NORTH);
+        assertEquals(2, robot.getAmountOfLives());
+    }
 }

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

@@ -10,61 +10,69 @@ import org.junit.Test;
 public class RobotTest {
     private Position robotPosition;
     private Robot testRobot;
+    private final int nextFlag = 1;
+
     @Before
     public void setUp() {
         robotPosition = new Position(3,6);
         testRobot = new Robot(RobotID.ROBOT_6, robotPosition);
     }
+
     @Test
     public void testRobotGetDamageOnInitializedRobot(){
-        assertEquals(0, testRobot.getDamage());
+        assertEquals(0, testRobot.getDamageTaken());
     }
+
     @Test
     public void testRobotGetPlayerId(){
         assertEquals(RobotID.ROBOT_6, testRobot.getRobotId());
     }
+
     @Test
     public void testRobotGetBackupOnInitializedRobot(){
         assertEquals(robotPosition, testRobot.getBackupPosition());
     }
+
     @Test
     public void testRobotSetDamage() {
-        testRobot.setDamage(2);
+        testRobot.setDamageTaken(2);
-        assertEquals(2, testRobot.getDamage());
+        assertEquals(2, testRobot.getDamageTaken());
     }
+
     @Test
     public void testRobotGetPositionOnInitializedRobot(){
         assertEquals(robotPosition, testRobot.getPosition());
     }
+
     @Test
     public void testRobotGetPositionOnRobotWithNewPosition() {
         Position newRobotPosition = new Position(8,12);
         testRobot.setPosition(newRobotPosition);
         assertEquals(newRobotPosition, testRobot.getPosition());
     }
+
     @Test
     public void testRobotIsInPowerDownOnInitializedRobot(){
         assertEquals(false, testRobot.isInPowerDown());
     }
+
     @Test
     public void testRobotSetPowerDown() {
         testRobot.setPowerDown(true);
         assertEquals(true, testRobot.isInPowerDown());
     }
+
     @Test
     public void testRobotGetNewFlag() {
-        int nextFlag = 2;
+        testRobot.setLastFlagVisitedAndUpdateBackupPosition(nextFlag);
-        Position nextFlagPosition = new Position(3,4);
+        assertEquals(1, testRobot.getLastFlagVisited());
-        testRobot.setLastFlagVisitedAndBackupPosition(nextFlag,nextFlagPosition);
-        assertEquals(2, testRobot.getLastFlagVisited());
     }
+
     @Test
     public void testRobotGetNewBackup() {
-        int nextFlag = 2;
         Position nextFlagPosition = new Position(3,4);
-        testRobot.setLastFlagVisitedAndBackupPosition(nextFlag,nextFlagPosition);
+        testRobot.setPosition(nextFlagPosition);
+        testRobot.setLastFlagVisitedAndUpdateBackupPosition(nextFlag);
         assertEquals(nextFlagPosition, testRobot.getBackupPosition());
     }
-
-
 }