EpicKnarvik97/Fiasko
EpicKnarvik97/Fiasko
1
0
Fork 0
mirror of https://github.com/inf112-v20/Fiasko.git synced 2025-02-01 07:39:35 +01:00
Code Issues Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Tobydrama 2020-03-17 17:24:05 +01:00
commit dfefe49aa0
5 changed files with 179 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
docs/team/referater/referat_17_03_2020.md Normal file
View File

@ -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.

26
src/main/java/inf112/fiasko/roborally/game_wrapper/CardChoiceScreen.java
View File

@ -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.y = 1200/2;
card1.x = 10;
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) {
//Nothing to do
public void resize(int width, int height) {
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);
System.out.println(cardRectangle.rectangle.x + " " + cardRectangle.rectangle.y + " " +
cardRectangle.rectangle.width + " " + cardRectangle.rectangle.height);
if (cardRectangle.rectangle.contains(screenX, screenY)) {
cardRectangle.selected = true;
System.out.println("Card touched");
Vector3 transformed = viewport.unproject(new Vector3(screenX, screenY, 0));
if (cardRectangle.rectangle.contains(transformed.x, transformed.y)) {
cardRectangle.selected = !cardRectangle.selected;
return true;
}
return false;

125
src/main/java/inf112/fiasko/roborally/objects/Board.java
View File

@ -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
* @param robotPosition The current position of the robot
* @param newPosition The position the robot is trying to move to
* @param direction The direction the robot is going
* 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 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

64
src/main/java/inf112/fiasko/roborally/objects/RoboRallyGame.java
View File

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

48
src/test/java/inf112/fiasko/roborally/objects/BoardTest.java
View File

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