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

docs/team/referater/referat_17_03_2020.md

@@ -0,0 +1,17 @@
+## Oppmøte
+Tilstede: Steinar, Gabriel, Kristian, Torbjørn, Petter
+Ikke tilstede:
+
+## Agenda
+- Design valg 
+
+- Brukerhistorier
+
+- Fordele Oppgaver
+
+## Møte
+- Diskuterer spørmsål vi vil sende inn the "kunden" angående innlevering/vurdering.
+
+- Sett på og reflektert rundt multiplayer finksjonaliteten.
+
+- Prøvd å få gruppen på samme nivå abgående forståelse rundt utfordringer med nettverk.

src/main/java/inf112/fiasko/roborally/game_wrapper/CardChoiceScreen.java

@@ -6,6 +6,9 @@ import com.badlogic.gdx.Screen;
 import com.badlogic.gdx.graphics.GL20;
 import com.badlogic.gdx.graphics.OrthographicCamera;
 import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
+import com.badlogic.gdx.math.Vector3;
+import com.badlogic.gdx.utils.viewport.FitViewport;
+import com.badlogic.gdx.utils.viewport.Viewport;
 
 import java.awt.*;
 
@@ -18,14 +21,18 @@ public class CardChoiceScreen extends InputAdapter implements Screen {
     private final OrthographicCamera camera;
     private final CardRectangle cardRectangle;
     private final ShapeRenderer shapeRenderer;
+    private final Viewport viewport;
 
     public CardChoiceScreen(final RoboRallyWrapper roboRallyWrapper) {
         this.roboRallyWrapper = roboRallyWrapper;
         camera = new OrthographicCamera();
-        camera.setToOrtho(true, 1200, 1200);
+        int applicationWidth = 600;
+        int applicationHeight = 800;
+        camera.setToOrtho(true, applicationWidth, applicationHeight);
+        viewport = new FitViewport(applicationWidth, applicationHeight, camera);
         Rectangle card1 = new Rectangle();
-        card1.x = 1200/2;
+        card1.x = 10;
-        card1.y = 1200/2;
+        card1.y = 10;
         card1.width = 100;
         card1.height = 100;
         cardRectangle = new CardRectangle(card1);
@@ -60,8 +67,8 @@ public class CardChoiceScreen extends InputAdapter implements Screen {
     }
 
     @Override
-    public void resize(int i, int i1) {
+    public void resize(int width, int height) {
-        //Nothing to do
+        viewport.update(width, height);
     }
 
     @Override
@@ -86,12 +93,9 @@ public class CardChoiceScreen extends InputAdapter implements Screen {
 
     @Override
     public boolean touchUp(int screenX, int screenY, int pointer, int button) {
-        System.out.println(screenX + " " + screenY);
+        Vector3 transformed = viewport.unproject(new Vector3(screenX, screenY, 0));
-        System.out.println(cardRectangle.rectangle.x + " " + cardRectangle.rectangle.y + " " +
+        if (cardRectangle.rectangle.contains(transformed.x, transformed.y)) {
-                cardRectangle.rectangle.width + " " + cardRectangle.rectangle.height);
+            cardRectangle.selected = !cardRectangle.selected;
-        if (cardRectangle.rectangle.contains(screenX, screenY)) {
-            cardRectangle.selected = true;
-            System.out.println("Card touched");
             return true;
         }
         return false;

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

@@ -150,7 +150,7 @@ public class Board {
         Position robotPosition = robot.getPosition();
         Position newPosition = getNewPosition(robotPosition, direction);
         //There is a wall blocking the robot. It can't proceed.
-        if (robotMoveIsStoppedByWall(robotPosition, newPosition, direction)) {
+        if (moveIsStoppedByWall(robotPosition, newPosition, direction)) {
             return false;
         }
         //Robot tried to go outside of the map. Kill it.
@@ -224,13 +224,72 @@ public class Board {
     }
 
     /**
-     * Checks if a potential robot move would be blocked by a wall
+     * Gets the position 1 unit in a specific direction from another position
-     * @param robotPosition The current position of the robot
+     * @param oldPosition The old/current position of the element
-     * @param newPosition The position the robot is trying to move to
+     * @param direction The direction to move the element
-     * @param direction The direction the robot is going
+     * @return The new position of the element
+     */
+    public Position getNewPosition(Position oldPosition, Direction direction) {
+        switch (direction) {
+            case NORTH:
+                return new Position(oldPosition.getXCoordinate(), oldPosition.getYCoordinate() - 1);
+            case SOUTH:
+                return new Position(oldPosition.getXCoordinate(), oldPosition.getYCoordinate() + 1);
+            case EAST:
+                return new Position(oldPosition.getXCoordinate() + 1, oldPosition.getYCoordinate());
+            case WEST:
+                return new Position(oldPosition.getXCoordinate() - 1, oldPosition.getYCoordinate());
+            default:
+                throw new IllegalArgumentException("It's not possible to move in that direction.");
+        }
+    }
+
+    /**
+     * Gets the tile on a specific position
+     * @param position The position to get a tile from
+     * @return The tile on the given position
+     */
+    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
+     * @return A list of BoardElementContainers
+     */
+    public List<BoardElementContainer<Tile>> getPositionsOfTileOnBoard(TileType ... tiles) {
+        List<BoardElementContainer<Tile>> combinedList = new ArrayList<>();
+        for (TileType tile : tiles) {
+            combinedList.addAll(makeTileList(tile, this.tiles));
+        }
+        return combinedList;
+    }
+
+    /**
+     * Gets a list of BoardElementContainers, containing all tiles and positions of given wall types
+     * @param walls The walls you want all positions for
+     * @return A list of BoardElementContainers
+     */
+    public List<BoardElementContainer<Wall>> getPositionsOfWallOnBoard(WallType... walls) {
+        List<BoardElementContainer<Wall>> combinedList = new ArrayList<>();
+        for (WallType wall : walls) {
+            combinedList.addAll(makeTileList(wall, this.walls));
+        }
+        return combinedList;
+    }
+
+    /**
+     * Checks if a potential move would be blocked by a wall
+     * @param robotPosition The current position of whatever is trying to move
+     * @param newPosition The position something is trying to move to
+     * @param direction The direction something is going
      * @return True if a wall would stop its path
      */
-    private boolean robotMoveIsStoppedByWall(Position robotPosition, Position newPosition, Direction direction) {
+    public boolean moveIsStoppedByWall(Position robotPosition, Position newPosition, Direction direction) {
             return hasWallFacing(robotPosition, direction) || (isValidPosition(newPosition) &&
                     hasWallFacing(newPosition, Direction.getReverseDirection(direction)));
     }
@@ -320,27 +379,6 @@ public class Board {
         }
     }
 
-    /**
-     * Gets the position 1 unit in a specific direction from another position
-     * @param oldPosition The old/current position of the element
-     * @param direction The direction to move the element
-     * @return The new position of the element
-     */
-    public Position getNewPosition(Position oldPosition, Direction direction) {
-        switch (direction) {
-            case NORTH:
-                return new Position(oldPosition.getXCoordinate(), oldPosition.getYCoordinate() - 1);
-            case SOUTH:
-                return new Position(oldPosition.getXCoordinate(), oldPosition.getYCoordinate() + 1);
-            case EAST:
-                return new Position(oldPosition.getXCoordinate() + 1, oldPosition.getYCoordinate());
-            case WEST:
-                return new Position(oldPosition.getXCoordinate() - 1, oldPosition.getYCoordinate());
-            default:
-                throw new IllegalArgumentException("It's not possible to move in that direction.");
-        }
-    }
-
     /**
      * Gets all elements on a grid
      * @param grid The grid to get elements from
@@ -357,39 +395,6 @@ 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
-     * @return A list of BoardElementContainers
-     */
-    public List<BoardElementContainer<Tile>> getPositionsOfTileOnBoard(TileType ... tiles) {
-        List<BoardElementContainer<Tile>> combinedList = new ArrayList<>();
-        for (TileType tile : tiles) {
-            combinedList.addAll(makeTileList(tile, this.tiles));
-        }
-        return combinedList;
-    }
-
-    /**
-     * Gets a list of BoardElementContainers, containing all tiles and positions of given wall types
-     * @param walls The walls you want all positions for
-     * @return A list of BoardElementContainers
-     */
-    public List<BoardElementContainer<Wall>> getPositionsOfWallOnBoard(WallType... walls) {
-        List<BoardElementContainer<Wall>> combinedList = new ArrayList<>();
-        for (WallType wall : walls) {
-            combinedList.addAll(makeTileList(wall, this.walls));
-        }
-        return combinedList;
-    }
-
     /**
      * Finds all position of an obj and makes a list of BoardElementContainers
      * @param type Type of obj

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

@@ -252,22 +252,68 @@ public class RoboRallyGame implements IDrawableGame {
      * @throws InterruptedException If disturbed during sleep
      */
     private void moveConveyorBelts(List<BoardElementContainer<Tile>> conveyorBelts) throws InterruptedException {
-        for (BoardElementContainer<Tile> conveyorBelt : conveyorBelts) {
+        List<BoardElementContainer<Tile>> conveyorBeltsWithRobotsThatShouldMove =
-            if (!gameBoard.hasRobotOnPosition(conveyorBelt.getPosition())) {
+                conveyorBeltsThatCanMoveWithoutConflict(conveyorBelts);
-                continue;
+        for (BoardElementContainer<Tile> conveyorBelt : conveyorBeltsWithRobotsThatShouldMove) {
+            Direction currentDirection = conveyorBelt.getElement().getDirection();
+            RobotID robot = gameBoard.getRobotOnPosition(conveyorBelt.getPosition());
+            Position newPosition = gameBoard.getNewPosition(conveyorBelt.getPosition(), currentDirection);
+            Tile nextTile = gameBoard.getTileOnPosition(newPosition);
+
+            doConveyorBeltMovement(robot, currentDirection, nextTile);
         }
-            Position conveyorBeltPosition = conveyorBelt.getPosition();
+    }
-            Tile conveyorBeltTile = conveyorBelt.getElement();
+
+    private List<BoardElementContainer<Tile>> conveyorBeltsThatCanMoveWithoutConflict(
+            List<BoardElementContainer<Tile>> conveyorBelts) {
+
+        List<BoardElementContainer<Tile>> nonConflictConveyorBelts = new ArrayList<>();
+        for (BoardElementContainer<Tile> conveyorBelt : conveyorBelts) {
+            if (gameBoard.hasRobotOnPosition(conveyorBelt.getPosition())) {
+                nonConflictConveyorBelts.add(conveyorBelt);
+            }
+        }
+        for (BoardElementContainer<Tile> conveyorBeltWithRobot : nonConflictConveyorBelts) {
+            Position conveyorBeltPosition = conveyorBeltWithRobot.getPosition();
+            Tile conveyorBeltTile = conveyorBeltWithRobot.getElement();
+
             Position newPosition = gameBoard.getNewPosition(conveyorBeltPosition, conveyorBeltTile.getDirection());
             Tile nextTile = gameBoard.getTileOnPosition(newPosition);
 
-            Direction currentDirection = conveyorBeltTile.getDirection();
+            Position beyondNextPositionStraight = gameBoard.getNewPosition(newPosition, conveyorBeltTile.getDirection());
-            RobotID robot = gameBoard.getRobotOnPosition(conveyorBeltPosition);
+            Tile beyondNextTileStraight = gameBoard.getTileOnPosition(beyondNextPositionStraight);
 
-            //TODO: Check whether the robot is able to move before moving. Alternatively: Save position and direction
+            Position beyondNextPositionLeft = gameBoard.getNewPosition(newPosition,
-            // of each robot and revert if a collision is found.
+                    Direction.getLeftRotatedDirection(conveyorBeltTile.getDirection()));
-            doConveyorBeltMovement(robot, currentDirection, nextTile);
+            Tile beyondNextTileLeft = gameBoard.getTileOnPosition(beyondNextPositionLeft);
+
+            Position beyondNextPositionRight = gameBoard.getNewPosition(newPosition,
+                    Direction.getRightRotatedDirection(conveyorBeltTile.getDirection()));
+            Tile beyondNextTileRight = gameBoard.getTileOnPosition(beyondNextPositionRight);
+
+
+
+            if (conveyorBeltTile.getDirection() == Direction.getReverseDirection(nextTile.getDirection()) &&
+                nonConflictConveyorBelts.contains(new BoardElementContainer<>(nextTile, newPosition))) {
+                nonConflictConveyorBelts.remove(conveyorBeltWithRobot);
             }
+            else if (conveyorBeltTile.getDirection() == Direction.getReverseDirection(
+                    beyondNextTileStraight.getDirection()) && nonConflictConveyorBelts.contains(
+                            new BoardElementContainer<>(beyondNextTileStraight, beyondNextPositionStraight))) {
+                nonConflictConveyorBelts.remove(conveyorBeltWithRobot);
+            }
+            else if (conveyorBeltTile.getDirection() == Direction.getLeftRotatedDirection(
+                    beyondNextTileLeft.getDirection()) && nonConflictConveyorBelts.contains(
+                    new BoardElementContainer<>(beyondNextTileLeft, beyondNextPositionLeft))) {
+                nonConflictConveyorBelts.remove(conveyorBeltWithRobot);
+            }
+            else if (conveyorBeltTile.getDirection() == Direction.getRightRotatedDirection(
+                    beyondNextTileRight.getDirection()) && nonConflictConveyorBelts.contains(
+                    new BoardElementContainer<>(beyondNextTileRight, beyondNextPositionRight))) {
+                nonConflictConveyorBelts.remove(conveyorBeltWithRobot);
+            }
+        }
+        return nonConflictConveyorBelts;
     }
 
     /**

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

@@ -283,10 +283,7 @@ public class BoardTest {
     @Test
     public void getPositionsOfTileOnBoardHasTypeCogwheelLeft() {
         List<BoardElementContainer<Tile>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfTileOnBoard(TileType.COGWHEEL_LEFT);
-
+        assertTrue(checkIfAllElementsAreOfSpecificTileType(boardElemList, TileType.COGWHEEL_LEFT));
-        for (BoardElementContainer<Tile> elem : boardElemList) {
-            assertEquals(elem.getElement().getTileType(), TileType.COGWHEEL_LEFT);
-        }
     }
 
     @Test
@@ -298,10 +295,7 @@ public class BoardTest {
     @Test
     public void getPositionsOfTileOnBoardHasTypeTile() {
         List<BoardElementContainer<Tile>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfTileOnBoard(TileType.TILE);
-
+        assertTrue(checkIfAllElementsAreOfSpecificTileType(boardElemList, TileType.TILE));
-        for (BoardElementContainer<Tile> elem : boardElemList) {
-            assertEquals(elem.getElement().getTileType(), TileType.TILE);
-        }
     }
 
     @Test
@@ -313,10 +307,7 @@ public class BoardTest {
     @Test
     public void getPositionsOfWallOnBoardHasTypeWallNormal() {
         List<BoardElementContainer<Wall>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfWallOnBoard(WallType.WALL_NORMAL);
-
+        assertTrue(checkIfAllElementsAreOfSpecificWallType(boardElemList, WallType.WALL_NORMAL));
-        for (BoardElementContainer<Wall> elem : boardElemList) {
-            assertEquals(elem.getElement().getWallType(), WallType.WALL_NORMAL);
-        }
     }
 
     @Test
@@ -328,17 +319,32 @@ public class BoardTest {
     @Test
     public void getPositionsOfWallOnBoardHasTypeWallCorner() {
         List<BoardElementContainer<Wall>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfWallOnBoard(WallType.WALL_CORNER);
-
+        assertTrue(checkIfAllElementsAreOfSpecificWallType(boardElemList, WallType.WALL_CORNER));
-        for (BoardElementContainer<Wall> elem : boardElemList) {
-            assertEquals(elem.getElement().getWallType(), WallType.WALL_CORNER);
-        }
     }
 
     @Test
-    public void getPositionsOfWallOnBoardHasCorrect() {
+    public void getPositionsOfWallOnBoardHasCorrectTypesWithMultipleParameters() {
-        List<BoardElementContainer<Wall>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfWallOnBoard(WallType.WALL_CORNER);
+        List<BoardElementContainer<Tile>> boardElemList = boardWithDifferentAmountOfAllTypes.getPositionsOfTileOnBoard(TileType.COGWHEEL_LEFT, TileType.COGWHEEL_RIGHT);
-        Predicate<BoardElementContainer<Wall>> pred = (element) -> element.getElement().getWallType() == WallType.WALL_CORNER;
+        List<TileType> tileTypeList = new ArrayList<>();
-        boardElemList.removeIf(pred);
+        List<TileType> tileTypeListResult = new ArrayList<>();
-        assertEquals(0, boardElemList.size());
+        tileTypeList.add(TileType.COGWHEEL_LEFT);
+        tileTypeList.add(TileType.COGWHEEL_RIGHT);
+
+        for (BoardElementContainer<Tile> elem : boardElemList) {
+            tileTypeListResult.add(elem.getElement().getTileType());
+        }
+
+        assertTrue(tileTypeList.containsAll(tileTypeListResult) && tileTypeListResult.containsAll(tileTypeList));
+    }
+
+    public <K> boolean checkIfAllElementsAreOfSpecificWallType(List<BoardElementContainer<Wall>> elemList, K WallType) {
+        Predicate<BoardElementContainer<Wall>> pred = (element) -> element.getElement().getWallType() == WallType;
+        elemList.removeIf(pred);
+        return 0 == elemList.size();
+    }
+    public <K> boolean checkIfAllElementsAreOfSpecificTileType(List<BoardElementContainer<Tile>> elemList, K TileType) {
+        Predicate<BoardElementContainer<Tile>> pred = (element) -> element.getElement().getTileType() == TileType;
+        elemList.removeIf(pred);
+        return 0 == elemList.size();
     }
 }