Skip to content
Snippets Groups Projects
Commit e8bb5347 authored by LABOUREL Arnaud's avatar LABOUREL Arnaud
Browse files

Added MapSquare

parent 289d27f5
Branches
No related tags found
No related merge requests found
package model;
import java.util.ArrayList;
import java.util.List;
public abstract class AbstractSquare implements Square {
private Tile tile = EmptyTile.EMPTY_TILE;
public Tile getTile(){
return tile;
}
@Override
public List<Tile> compatibleTiles(List<Tile> tiles) {
List<Tile> compatibleTiles = new ArrayList<>();
for(Tile tile : tiles)
if(accept(tile))
compatibleTiles.add(tile);
return compatibleTiles;
}
@Override
public void put(Tile tile) {
this.tile = tile;
}
@Override
public abstract void setNeighbor(Square neighbor, CardinalDirection direction);
@Override
public abstract Square getNeighbor(CardinalDirection direction);
private boolean accept(Tile tile) {
for(CardinalDirection direction : CardinalDirection.values()){
if(!accept(tile, direction))
return false;
}
return true;
}
private boolean accept(Tile tile, CardinalDirection direction) {
return getIncidentNeighboringSide(direction).accept(tile.side(direction));
}
private Side getIncidentNeighboringSide(CardinalDirection direction) {
return getNeighbor(direction).getTile().side(direction.oppositeDirection());
}
@Override
public List<Side> compatibleSides(List<Side> sides, CardinalDirection direction) {
return getIncidentNeighboringSide(direction).compatibleSides(sides);
}
}
package model; package model;
import java.util.ArrayList; public class ArraySquare extends AbstractSquare {
import java.util.List;
public class ArraySquare implements Square {
private Tile tile = EmptyTile.EMPTY_TILE;
private final Square[] neighbors = new Square[CardinalDirection.NUMBER_OF_DIRECTIONS]; private final Square[] neighbors = new Square[CardinalDirection.NUMBER_OF_DIRECTIONS];
public ArraySquare() { public ArraySquare() {
...@@ -16,24 +12,6 @@ public class ArraySquare implements Square { ...@@ -16,24 +12,6 @@ public class ArraySquare implements Square {
setNeighbor(EmptySquare.EMPTY_SQUARE, direction); setNeighbor(EmptySquare.EMPTY_SQUARE, direction);
} }
public Tile getTile(){
return tile;
}
@Override
public List<Tile> compatibleTiles(List<Tile> tiles) {
List<Tile> compatibleTiles = new ArrayList<>();
for(Tile tile : tiles)
if(accept(tile))
compatibleTiles.add(tile);
return compatibleTiles;
}
@Override
public void put(Tile tile) {
this.tile = tile;
}
@Override @Override
public void setNeighbor(Square neighbor, CardinalDirection direction) { public void setNeighbor(Square neighbor, CardinalDirection direction) {
this.neighbors[direction.ordinal()] = neighbor; this.neighbors[direction.ordinal()] = neighbor;
...@@ -44,24 +22,4 @@ public class ArraySquare implements Square { ...@@ -44,24 +22,4 @@ public class ArraySquare implements Square {
return this.neighbors[direction.ordinal()]; return this.neighbors[direction.ordinal()];
} }
private boolean accept(Tile tile) {
for(CardinalDirection direction : CardinalDirection.values()){
if(!accept(tile, direction))
return false;
}
return true;
}
private boolean accept(Tile tile, CardinalDirection direction) {
return getIncidentNeighboringSide(direction).accept(tile.side(direction));
}
private Side getIncidentNeighboringSide(CardinalDirection direction) {
return getNeighbor(direction).getTile().side(direction.oppositeDirection());
}
@Override
public List<Side> compatibleSides(List<Side> sides, CardinalDirection direction) {
return getIncidentNeighboringSide(direction).compatibleSides(sides);
}
} }
...@@ -17,7 +17,7 @@ public class ListGrid extends AbstractGrid{ ...@@ -17,7 +17,7 @@ public class ListGrid extends AbstractGrid{
for(int row = 0; row < getNumberOfRows(); row++){ for(int row = 0; row < getNumberOfRows(); row++){
List<Square> squareRow = new ArrayList<>(); List<Square> squareRow = new ArrayList<>();
for(int column = 0; column < getNumberOfColumns(); column++) for(int column = 0; column < getNumberOfColumns(); column++)
squareRow.add(new ArraySquare()); squareRow.add(new MapSquare());
squares.add(squareRow); squares.add(squareRow);
} }
} }
......
package model;
import java.util.HashMap;
import java.util.Map;
public class MapSquare extends AbstractSquare{
private final Map<CardinalDirection,Square> neighbors = new HashMap<>();
@Override
public void setNeighbor(Square neighbor, CardinalDirection direction) {
neighbors.put(direction, neighbor);
}
@Override
public Square getNeighbor(CardinalDirection direction) {
return neighbors.getOrDefault(direction, EmptySquare.EMPTY_SQUARE);
}
}
package model;
import javafx.scene.paint.Color;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
public class MapSquareTest {
Square arraySquare1;
Square arraySquare2;
ColoredSide redSide;
ColoredSide blueSide;
Tile redTile;
Tile blueTile;
@BeforeEach
void initialize(){
arraySquare1 = new MapSquare();
arraySquare2 = new MapSquare();
redTile = new UniformTile(new ColoredSide(Color.RED));
blueTile = new UniformTile(new ColoredSide(Color.BLUE));
redSide = new ColoredSide(Color.RED);
blueSide = new ColoredSide(Color.BLUE);
}
@Test
void testGetNeighbors_afterConstruction(){
for(CardinalDirection direction : CardinalDirection.values())
assertThat(arraySquare1.getNeighbor(direction)).isEqualTo(EmptySquare.EMPTY_SQUARE);
}
@Test
void testEmptyTile_afterConstruction(){
assertThat(arraySquare1.getTile()).isEqualTo(EmptyTile.EMPTY_TILE);
}
@Test
void testPut(){
arraySquare1.put(redTile);
arraySquare2.put(blueTile);
assertThat(arraySquare1.getTile()).isEqualTo(redTile);
assertThat(arraySquare2.getTile()).isEqualTo(blueTile);
}
@Test
void testGetNeighbors_afterSetNeighbor(){
arraySquare1.setNeighbor(arraySquare2, CardinalDirection.NORTH);
arraySquare2.setNeighbor(arraySquare1, CardinalDirection.SOUTH);
assertThat(arraySquare1.getNeighbor(CardinalDirection.NORTH)).isEqualTo(arraySquare2);
assertThat(arraySquare2.getNeighbor(CardinalDirection.SOUTH)).isEqualTo(arraySquare1);
}
@Test
void testCompatibleSides(){
arraySquare1.put(redTile);
arraySquare2.put(blueTile);
arraySquare1.setNeighbor(arraySquare2, CardinalDirection.NORTH);
arraySquare2.setNeighbor(arraySquare1, CardinalDirection.SOUTH);
List<Side> sides = List.of(blueSide, redSide);
assertThat(arraySquare1.compatibleSides(sides, CardinalDirection.NORTH))
.containsExactly(blueSide);
assertThat(arraySquare2.compatibleSides(sides, CardinalDirection.SOUTH))
.containsExactly(redSide);
assertThat(arraySquare1.compatibleSides(sides, CardinalDirection.SOUTH))
.containsExactly(blueSide, redSide);
}
@Test
void testCompatibleTiles(){
List<Tile> tiles = List.of(blueTile, redTile);
assertThat(arraySquare1.compatibleTiles(tiles))
.containsExactly(blueTile, redTile);
arraySquare1.put(redTile);
arraySquare2.put(blueTile);
arraySquare1.setNeighbor(arraySquare2, CardinalDirection.NORTH);
arraySquare2.setNeighbor(arraySquare1, CardinalDirection.SOUTH);
assertThat(arraySquare1.compatibleTiles(tiles))
.containsExactly(blueTile);
assertThat(arraySquare2.compatibleTiles(tiles))
.containsExactly(redTile);
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment