public Cell[] findFarthestPosition(Cell cell, Cell vector) {
Cell previous;
Cell nextCell = new Cell(cell.getX(), cell.getY());
do {
previous = nextCell;
nextCell = new Cell(previous.getX() + vector.getX(), previous.getY() + vector.getY());
} while (grid.isCellWithinBounds(nextCell) && grid.isCellAvailable(nextCell));
Cell[] answer = {previous, nextCell};
return answer;
}
// Сортирует палубы
private void sortDecks() {
Cell icell, jcell;
for (int i = 0; i < decks.size() - 1; i++)
for (int j = i + 1; j < decks.size(); j++) {
icell = decks.get(i).getCell();
jcell = decks.get(j).getCell();
if (icell.getX() < jcell.getX()
|| icell.getX() == jcell.getX() && icell.getY() < jcell.getY()) {
Deck d = decks.get(i);
decks.set(i, decks.get(j));
decks.set(j, d);
}
}
}
public Tile getCellContent(Cell cell) {
if (cell != null && isCellWithinBounds(cell)) {
return field[cell.getX()][cell.getY()];
} else {
return null;
}
}
public void createCircularField(Map map, Vector2D centerPosition, int terrainType, int size) {
if (size < 1) return;
int TILE_SIZE = 32;
float halfATile = TILE_SIZE / 2;
// convert to absolute pixel coordinates
Vector2D asPixelsCentered =
map.getCellCoordinatesInAbsolutePixels(
centerPosition.getXAsInt(), centerPosition.getYAsInt())
.add(Vector2D.create(halfATile, halfATile));
double centerX = asPixelsCentered.getX();
double centerY = asPixelsCentered.getY();
for (int rangeStep = 0; rangeStep < size; rangeStep++) { // range 'steps'
for (int degrees = 0; degrees < 360; degrees++) {
// calculate as if we would draw a circle and remember the coordinates
float rangeInPixels = (rangeStep * TILE_SIZE);
double circleX = (centerX + (Trigonometry.cos[degrees] * rangeInPixels));
double circleY = (centerY + (Trigonometry.sin[degrees] * rangeInPixels));
// convert back the pixel coordinates back to a cell
Cell cell =
map.getCellByAbsoluteMapCoordinates(
Coordinate.create((int) Math.ceil(circleX), (int) Math.ceil(circleY)));
putTerrainOnCell(map, cell.getX(), cell.getY(), terrainType);
}
}
}
public void draw(List<Cell> cells) {
gc.clearRect(0, 0, primaryStage.getWidth(), primaryStage.getHeight());
gc.setFill(COLOR_GREEN_GOSSIP);
for (Cell cell : cells) {
gc.fillOval(CELL_SIZE * cell.getX(), CELL_SIZE * cell.getY(), CELL_SIZE, CELL_SIZE);
}
gc.restore();
}
@Override
public String toString() {
StringBuilder s = new StringBuilder();
s.append("|IBLOCK|");
s.append(" Direction: " + direction);
s.append(" Cells: [");
for (Cell cell : cells) {
s.append("(" + cell.getX() + ", " + cell.getY() + ")");
}
s.append("]");
return s.toString();
}
@Override
public List<Cell> tryToRotate(RotateDirection rd) {
Direction newDirection = getNewOrientation(rd);
List<Cell> result = new ArrayList<Cell>(cells.size());
Cell leftTopCorner = findLeftTopCorner(cells);
switch (newDirection) {
case UP:
buildUp(result, leftTopCorner.getX(), leftTopCorner.getY());
break;
case DOWN:
buildDown(result, leftTopCorner.getX(), leftTopCorner.getY());
break;
case LEFT:
buildLeft(result, leftTopCorner.getX(), leftTopCorner.getY());
break;
case RIGHT:
buildRight(result, leftTopCorner.getX(), leftTopCorner.getY());
break;
}
return result;
}
public List<Integer> buildTraversalsY(Cell vector) {
List<Integer> traversals = new ArrayList<Integer>();
for (int xx = 0; xx < numSquaresY; xx++) {
traversals.add(xx);
}
if (vector.getY() == 1) {
Collections.reverse(traversals);
}
return traversals;
}
public boolean tileMatchesAvailable() {
Tile tile;
for (int xx = 0; xx < numSquaresX; xx++) {
for (int yy = 0; yy < numSquaresY; yy++) {
tile = grid.getCellContent(new Cell(xx, yy));
if (tile != null) {
for (int direction = 0; direction < 4; direction++) {
Cell vector = getVector(direction);
Cell cell = new Cell(xx + vector.getX(), yy + vector.getY());
Tile other = grid.getCellContent(cell);
if (other != null && other.getValue() == tile.getValue()) {
return true;
}
}
}
}
}
return false;
}
public boolean isCellWithinBounds(Cell cell) {
return 0 <= cell.getX()
&& cell.getX() < field.length
&& 0 <= cell.getY()
&& cell.getY() < field[0].length;
}
@Override
public void moveDown() {
for (Cell cell : cells) {
cell.setY(cell.getY() + 1);
}
}
public boolean positionsEqual(Cell first, Cell second) {
return first.getX() == second.getX() && first.getY() == second.getY();
}
public void moveTile(Tile tile, Cell cell) {
grid.field[tile.getX()][tile.getY()] = null;
grid.field[cell.getX()][cell.getY()] = tile;
tile.updatePosition(cell);
}
public void updatePosition(Cell cell) {
this.setX(cell.getX());
this.setY(cell.getY());
}
public Tile(Cell cell, int value) {
super(cell.getX(), cell.getY());
this.value = value;
}
private Cell createNeighbourCell(Cell cell, int neighbourPosition) {
return new Cell(
cell.getX() + neighboursPositionTable[neighbourPosition][0],
cell.getY() + neighboursPositionTable[neighbourPosition][1]);
}
