mirror of
https://github.com/inf112-v20/Fiasko.git
synced 2025-03-03 16:49:45 +01:00
Merge branch 'master' of https://github.com/inf112-v20/Fiasko
This commit is contained in:
commit
10e31033e0
15
docs/team/referater/referat_16_03_2020.md
Normal file
15
docs/team/referater/referat_16_03_2020.md
Normal file
@ -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.
|
||||
@ -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)) {
|
||||
Tile tile = (Tile) gridElement;
|
||||
if (tile.getTileType() == type) {
|
||||
objList.add(new BoardElementContainer<>(gridElement, new Position(x,y)));
|
||||
if (gridElement != null) {
|
||||
if (gridElement.getClass().isAssignableFrom(Tile.class)) {
|
||||
Tile tile = (Tile) gridElement;
|
||||
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.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
* @param card the card that is placed in to the player program
|
||||
* Gets the program from the player
|
||||
* @return List of programing cards
|
||||
*/
|
||||
public void setCardInProgram(ProgrammingCard card) {
|
||||
for (int i = 0; i < 5; i++) {
|
||||
if (program.get(i) == null) {
|
||||
program.add(i, card);
|
||||
return;
|
||||
}
|
||||
}
|
||||
throw new IllegalArgumentException("Program deck is full,tried to add to many cards");
|
||||
public List <ProgrammingCard> getProgramFromPlayer(){
|
||||
return program;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a card by the given index from the player program and returns it.
|
||||
* @param cardNr the index of the card that is being removed
|
||||
* @return the card that was removed from the program
|
||||
* Sets the Players program to the given list of programing cards
|
||||
* @param cardList list the size of 5 with programing cards
|
||||
*/
|
||||
public ProgrammingCard removeProgramCard(int cardNr) {
|
||||
if(cardNr<5 && cardNr>-1) {
|
||||
program.add(cardNr, null);
|
||||
return program.remove(cardNr + 1);
|
||||
public void setInProgram(List <ProgrammingCard> cardList){
|
||||
if(cardList.size() != 5){
|
||||
throw new IllegalArgumentException("list must contain 5 programing cards");
|
||||
}
|
||||
else{
|
||||
throw new IllegalArgumentException("cant remove more then index 4 or remove negatives");
|
||||
|
||||
else {
|
||||
program = new ArrayList<>(cardList);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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.RobotID;
|
||||
import inf112.fiasko.roborally.element_properties.TileType;
|
||||
|
||||
import inf112.fiasko.roborally.element_properties.*;
|
||||
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());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
@ -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() {
|
||||
playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
|
||||
assertEquals(Action.MOVE_1,playerTest.getProgram().get(0).getAction());
|
||||
}
|
||||
@Test
|
||||
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));
|
||||
public void testSetInDeck(){
|
||||
cards.add(new ProgrammingCard(10,Action.ROTATE_LEFT));
|
||||
ProgrammingCardDeck playerDeck = new ProgrammingCardDeck(cards);
|
||||
playerTest.setPlayerDeck(playerDeck);
|
||||
assertEquals(playerDeck , playerTest.getPlayerDeck());
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void getErrorIfYouRemoveMoreThenIndexFive(){
|
||||
playerTest.setCardInProgram(new ProgrammingCard(10,Action.MOVE_1));
|
||||
playerTest.removeProgramCard(5);
|
||||
|
||||
@Test
|
||||
public void GetPlayerRobotId(){
|
||||
assertEquals(RobotID.ROBOT_1, playerTest.getRobotID());
|
||||
}
|
||||
@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());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user