private Set<Pos> possiblesMovesAroundASpecificPosition(Pos pos) {
    HashSet<Pos> listOfCellAroundASpecificPosition = new HashSet<Pos>();
    int x = pos.getXCoord(), y = pos.getYCoord();

    // We must check if positions around the first one aren't out of the
    // grid and are navigable.
    if (x + 1 < this.gridWidth
        && getCellAtSpecificsCoords(x + 1, y).getCellSurface().canWalkOnSurface()
        && !listOfCellAroundASpecificPosition.contains(pos.newPos(1, 0))) {
      listOfCellAroundASpecificPosition.add(pos.newPos(1, 0));
    }

    if (x - 1 >= 0
        && getCellAtSpecificsCoords(x - 1, y).getCellSurface().canWalkOnSurface()
        && !listOfCellAroundASpecificPosition.contains(pos.newPos(-1, 0))) {
      listOfCellAroundASpecificPosition.add(pos.newPos(-1, 0));
    }

    if (y + 1 < this.gridHeight
        && getCellAtSpecificsCoords(x, y + 1).getCellSurface().canWalkOnSurface()
        && !listOfCellAroundASpecificPosition.contains(pos.newPos(0, 1))) {
      listOfCellAroundASpecificPosition.add(pos.newPos(0, 1));
    }

    if (y - 1 >= 0
        && getCellAtSpecificsCoords(x, y - 1).getCellSurface().canWalkOnSurface()
        && !listOfCellAroundASpecificPosition.contains(pos.newPos(0, -1))) {
      listOfCellAroundASpecificPosition.add(pos.newPos(0, -1));
    }

    return listOfCellAroundASpecificPosition;
  }
  private List<Pos> cellsAroundACell(Pos unitPosition) {
    List<Pos> list = new LinkedList<Pos>();
    if (unitPosition.getXCoord() + 1 <= this.gridWidth
        && getCellAtASpecificPos(unitPosition.newPos(1, 0)).getCellSurface().canWalkOnSurface()) {
      list.add(unitPosition.newPos(1, 0));
    }

    if (unitPosition.getXCoord() - 1 >= 0
        && getCellAtASpecificPos(unitPosition.newPos(-1, 0)).getCellSurface().canWalkOnSurface()) {
      list.add(unitPosition.newPos(-1, 0));
    }

    if (unitPosition.getYCoord() + 1 <= this.gridHeight
        && getCellAtASpecificPos(unitPosition.newPos(0, 1)).getCellSurface().canWalkOnSurface()) {
      list.add(unitPosition.newPos(0, 1));
    }

    if (unitPosition.getYCoord() - 1 >= 0
        && getCellAtASpecificPos(unitPosition.newPos(0, -1)).getCellSurface().canWalkOnSurface()) {
      list.add(unitPosition.newPos(0, -1));
    }
    return list;
  }
 public Cell getCellAtASpecificPos(Pos pos) {
   return grid[pos.getXCoord()][pos.getYCoord()];
 }
  private List<Pos> possiblesAttackCellsAroundASpecificPosition(Pos unitPosition) {
    List<Pos> listOfPos = new LinkedList<Pos>();
    List<Pos> listOfPosInRange = new LinkedList<Pos>();
    int coordXErrorValue, coordYErrorValue, errorValue, counter = 0;

    listOfPosInRange = cellInRangeOfAttack(unitPosition);
    for (int index = 0; index < listOfPosInRange.size(); index++) {
      for (int index2 = index + 1; index2 < listOfPosInRange.size(); index2++) {
        if (listOfPosInRange.get(index2).equals(listOfPosInRange.get(index)))
          listOfPosInRange.remove(index2);
      }
    }
    // The following algorithm is pretty hard to understand and to explain.
    // If you want understand it :
    // http://fr.wikipedia.org/wiki/Algorithme_de_trac%C3%A9_de_segment_de_Bresenham
    // I had to set it, because it wasn't able to work for every situation.
    while (counter < listOfPosInRange.size()) {
      int unitXCoord = unitPosition.getXCoord(), unitYCoord = unitPosition.getYCoord();
      int cellXCoord = listOfPosInRange.get(counter).getXCoord(),
          cellYCoord = listOfPosInRange.get(counter).getYCoord();
      // Searching for case according to the X coordinates if
      // |unitXCoord-cellXCoord|>|unitYCorod-cellY|.
      if (Math.abs(unitXCoord - cellXCoord) > Math.abs(unitYCoord - cellYCoord)) {
        errorValue = Math.abs(unitXCoord - cellXCoord);
        coordXErrorValue = errorValue * 2;
        coordYErrorValue = Math.abs(unitYCoord - cellYCoord) * 2;
        // To avoid sign problems, we check if x2>=x1
        if (cellXCoord >= unitXCoord) {
          while (unitXCoord <= cellXCoord
              && getCellAtSpecificsCoords(unitXCoord, unitYCoord)
                  .getCellSurface()
                  .canFireThrough()) {
            listOfPos.add(new Pos(unitXCoord, unitYCoord));
            unitXCoord++;
            errorValue -= coordYErrorValue;
            if (errorValue <= 0 && unitXCoord <= this.gridHeight) {
              if (errorValue == 0
                  && getCellAtSpecificsCoords(cellXCoord, cellYCoord)
                      .getCellSurface()
                      .canFireThrough()) listOfPos.add(new Pos(unitXCoord, unitYCoord));
              unitYCoord++;
              errorValue += coordXErrorValue;
            }
            if (unitYCoord > this.gridWidth || unitXCoord > this.gridHeight) break;
          }
        } else {
          while (cellXCoord <= unitXCoord
              && getCellAtSpecificsCoords(unitXCoord, unitYCoord)
                  .getCellSurface()
                  .canFireThrough()) {
            listOfPos.add(new Pos(unitXCoord, unitYCoord));
            unitXCoord--;
            errorValue -= coordYErrorValue;
            if (errorValue <= 0 && unitXCoord >= 0) {
              if (errorValue == 0
                  && getCellAtSpecificsCoords(unitXCoord, unitYCoord)
                      .getCellSurface()
                      .canFireThrough()) listOfPos.add(new Pos(unitXCoord, unitYCoord));
              unitYCoord--;
              errorValue += coordXErrorValue;
            }
            if (unitYCoord < 0 || unitXCoord < 0) break;
          }
        }
      }

      // Else, do according to the Y coordinate
      else {

        errorValue = Math.abs(unitYCoord - cellYCoord);
        coordXErrorValue = errorValue * 2;
        coordYErrorValue = Math.abs(unitXCoord - cellXCoord) * 2;
        // To avoid sign problems we check if y2>=y1
        if (cellYCoord >= unitYCoord) {
          while (unitYCoord <= cellYCoord
              && getCellAtSpecificsCoords(unitXCoord, unitYCoord)
                  .getCellSurface()
                  .canFireThrough()) {
            listOfPos.add(new Pos(unitXCoord, unitYCoord));

            unitYCoord++;
            errorValue -= coordYErrorValue;
            if (errorValue <= 0 && unitYCoord <= this.gridWidth) {
              if (errorValue == 0
                  && getCellAtSpecificsCoords(cellXCoord, cellYCoord)
                      .getCellSurface()
                      .canFireThrough()) listOfPos.add(new Pos(unitXCoord, unitYCoord));
              unitXCoord++;
              errorValue += coordXErrorValue;
            }
            if (unitXCoord > this.gridHeight || unitYCoord > this.gridWidth) break;
          }
        } else {
          while (cellYCoord <= unitYCoord
              && getCellAtSpecificsCoords(unitXCoord, unitYCoord)
                  .getCellSurface()
                  .canFireThrough()) {
            listOfPos.add(new Pos(unitXCoord, unitYCoord));
            unitYCoord--;
            errorValue -= coordYErrorValue;
            if (errorValue <= 0 && unitYCoord >= 0) {
              if (errorValue == 0
                  && getCellAtSpecificsCoords(unitXCoord, unitYCoord)
                      .getCellSurface()
                      .canFireThrough()) {
                listOfPos.add(new Pos(unitXCoord, unitYCoord));
              }
              unitXCoord--;
              errorValue += coordXErrorValue;
            }
            if (unitXCoord < 0 || unitYCoord < 0) break;
          }
        }
      }
      counter++;
    }
    return listOfPos;
  }