Changed code to generate a grid of tiles with borders containing uniform tile.

src/main/java/controller/MainPaneController.java

@@ -6,7 +6,7 @@ import view.GridTileCanvas;
 
 public class MainPaneController {
   @FXML
-  public GridTileCanvas GridTileCanvas;
+  public GridTileCanvas gridTileCanvas;
 
   private MainApp mainApp;
 
@@ -15,8 +15,8 @@ public class MainPaneController {
    *
    * @param mainApp the main app
    */
-  public void setMainApp(MainApp mainApp) {
-    this.mainApp = mainApp;
+  public void initializeGrid() {
+    gridTileCanvas.initializeGrid();
   }
 
 }

src/main/java/main/MainApp.java

@@ -8,6 +8,7 @@ import javafx.scene.Scene;
 import javafx.scene.layout.AnchorPane;
 import javafx.stage.Stage;
 import model.TileGame;
+import view.GridTileCanvas;
 
 import java.io.IOException;
 
@@ -42,7 +43,7 @@ public class MainApp extends Application {
 
       // Give the controller access to the main app.
       MainPaneController controller = loader.getController();
-      controller.setMainApp(this);
+      controller.initializeGrid();
 
       primaryStage.show();
     } catch (IOException e) {

src/main/java/model/BorderSquareIterator.java

+package model;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class BorderSquareIterator implements Iterator<Square> {
+  private int rowIndex;
+  private int columnIndex;
+  private final SquareGrid grid;
+
+  public BorderSquareIterator(SquareGrid grid) {
+    this.rowIndex = 0;
+    this.columnIndex = 1;
+    this.grid = grid;
+  }
+
+  /**
+   * Returns {@code true} if the iteration has more elements.
+   * (In other words, returns {@code true} if {@link #next} would
+   * return an element rather than throwing an exception.)
+   *
+   * @return {@code true} if the iteration has more elements
+   */
+  @Override
+  public boolean hasNext() {
+    return rowIndex < grid.getNumberOfRows();
+  }
+
+  /**
+   * Returns the next element in the iteration.
+   *
+   * @return the next element in the iteration
+   * @throws NoSuchElementException if the iteration has no more elements
+   */
+  @Override
+  public Square next() {
+    Square next = grid.getSquare(rowIndex, columnIndex);
+    if(rowIndex == 0){
+      if(columnIndex == grid.getNumberOfColumns()-2){
+        columnIndex = 0;
+        rowIndex = 1;
+      }
+      else{
+        columnIndex++;
+      }
+    }
+    else if(columnIndex == 0){
+      if(rowIndex == grid.getNumberOfRows()-2){
+        columnIndex = grid.getNumberOfColumns() - 1;
+        rowIndex = 1;
+      }
+      else{
+        rowIndex++;
+      }
+    }
+    else if(columnIndex == grid.getNumberOfColumns() - 1){
+      if(rowIndex == grid.getNumberOfRows()-2){
+        rowIndex = grid.getNumberOfRows() - 1;
+        columnIndex = 1;
+      }
+      else{
+        rowIndex++;
+      }
+    }
+    else {
+      if(columnIndex == grid.getNumberOfColumns()-2){
+        rowIndex = grid.getNumberOfRows();
+      }
+      else{
+        columnIndex++;
+      }
+    }
+    return next;
+  }
+}

src/main/java/model/CardinalDirection.java

 package model;
 
 public enum CardinalDirection {
-  NORTH,
-  EAST,
-  SOUTH,
-  WEST
+  NORTH(-1, 0),
+  EAST(0, 1),
+  SOUTH(1, 0),
+  WEST(0, -1);
+
+  public final int deltaX;
+  public final int deltaY;
+
+  CardinalDirection(int deltaX, int deltaY) {
+    this.deltaX = deltaX;
+    this.deltaY = deltaY;
+  }
+
+  public CardinalDirection oppositeDirection(){
+    return switch (this){
+      case EAST -> WEST;
+      case WEST -> EAST;
+      case NORTH -> SOUTH;
+      case SOUTH -> NORTH;
+    };
+  }
 }

src/main/java/model/InternalSquareIterator.java

+package model;
+
+import java.util.Iterator;
+
+public class InternalSquareIterator implements Iterator<Square> {
+  private int rowIndex;
+  private int columnIndex;
+  private final SquareGrid grid;
+
+  InternalSquareIterator(SquareGrid grid) {
+    this.rowIndex = 1;
+    this.columnIndex = 1;
+    this.grid = grid;
+  }
+
+  @Override
+  public boolean hasNext() {
+    return rowIndex < grid.getNumberOfRows() - 1;
+  }
+
+  @Override
+  public Square next() {
+    final Square result = grid.getSquare(rowIndex, columnIndex);
+    if(columnIndex == grid.getNumberOfColumns() - 2){
+      rowIndex++;
+      columnIndex = 1;
+    }
+    else{
+      columnIndex++;
+    }
+    return result;
+  }
+}

src/main/java/model/RandomTileGenerator.java

@@ -25,4 +25,12 @@ public class RandomTileGenerator {
     return new Tile(colorsOfTile);
   }
 
+  public Tile nextUniformTile(){
+    Color[] colorsOfTile = new Color[4];
+    Color randomColor = randomColor();
+    for(int index = 0; index < 4; index++)
+      colorsOfTile[index] = randomColor;
+    return new Tile(colorsOfTile);
+  }
+
 }

src/main/java/model/Square.java

@@ -4,27 +4,33 @@ import java.util.NoSuchElementException;
 import java.util.Optional;
 
 public class Square {
-  private Optional<Tile> optionalTile;
+  private Tile tile;
+  private Square[] neighboringSquares;
 
-  private Square(Optional<Tile> tile) {
-    this.optionalTile = tile;
+  private Square(Tile tile, Square[] neighboringSquares) {
+    this.tile = tile;
+    this.neighboringSquares = neighboringSquares;
+  }
+  private Square(Square[] neighboringSquares) {
+    this(null, neighboringSquares);
   }
 
   public Square(){
-    this(Optional.empty());
+    this(null, null);
   }
 
-  public Square(Tile tile){
-    this(Optional.of(tile));
-  }
 
   public Tile getTile(){
-    if(!optionalTile.isPresent())
+    if(tile == null)
       throw new NoSuchElementException();
-    return optionalTile.get();
+    return tile;
   }
 
   public void add(Tile tile) {
-    optionalTile = Optional.of(tile);
+    this.tile = tile;
+  }
+
+  public boolean hasTile() {
+    return tile != null;
   }
 }

src/main/java/model/SquareGrid.java

@@ -29,10 +29,17 @@ public class SquareGrid implements Iterable<Square> {
     Square[][] matrix = new Square[getNumberOfRows()][getNumberOfColumns()];
     for(int row = 0; row < getNumberOfRows(); row++)
       for(int column = 0; column < getNumberOfRows(); column++)
+        if(!squareIsInternal(row, column))
           matrix[row][column] = new Square();
+        else {
+          matrix[row][column] = new Square();
+        }
     return matrix;
   }
 
+  private boolean squareIsInternal(int row, int column){
+    return 1 <= row && row < getNumberOfRows()-1 && 1 <= column && column < getNumberOfColumns()-1;
+  }
 
   /**
    * Returns an iterator over elements of type {@code T}.
@@ -41,7 +48,15 @@ public class SquareGrid implements Iterable<Square> {
    */
   @Override
   public Iterator<Square> iterator() {
-    return new GridIterator(this);
+    return new SquareIterator(this);
+  }
+
+  public Iterator<Square> internalSquareIterator() {
+    return new InternalSquareIterator(this);
+  }
+
+  public Iterator<Square> borderSquareIterator() {
+    return new BorderSquareIterator(this);
   }
 
   public Tile getTile(int rowIndex, int columnIndex) {
@@ -61,7 +76,11 @@ public class SquareGrid implements Iterable<Square> {
 
   public void fillWithRandomTiles(List<Color> colors, Random randomGenerator){
     RandomTileGenerator randomTileGenerator = new RandomTileGenerator(colors, randomGenerator);
-    for(Square square : this)
-        square.add(randomTileGenerator.nextTile());
+    internalSquareIterator().forEachRemaining(square -> square.add(randomTileGenerator.nextTile()));
+    borderSquareIterator().forEachRemaining(square -> square.add(randomTileGenerator.nextUniformTile()));
+  }
+
+  public boolean hasTile(int row, int column) {
+    return getSquare(row, column).hasTile();
   }
 }

src/main/java/model/GridIterator.java → src/main/java/model/SquareIterator.java

@@ -2,12 +2,12 @@ package model;
 
 import java.util.Iterator;
 
-public class GridIterator implements Iterator<Square> {
+public class SquareIterator implements Iterator<Square> {
   private int rowIndex;
   private int columnIndex;
   private final SquareGrid grid;
 
-  GridIterator(SquareGrid grid) {
+  SquareIterator(SquareGrid grid) {
     this.rowIndex = 0;
     this.columnIndex = 0;
     this.grid = grid;
@@ -15,7 +15,7 @@ public class GridIterator implements Iterator<Square> {
 
   @Override
   public boolean hasNext() {
-    return columnIndex < grid.getNumberOfColumns() && rowIndex < grid.getNumberOfRows();
+    return rowIndex < grid.getNumberOfRows();
   }
 
   @Override

src/main/java/view/GridTileCanvas.java

@@ -5,7 +5,6 @@ import javafx.scene.canvas.Canvas;
 import javafx.scene.canvas.GraphicsContext;
 import javafx.scene.paint.Color;
 import model.CardinalDirection;
-import model.Square;
 import model.SquareGrid;
 import model.Tile;
 
@@ -16,8 +15,7 @@ public class GridTileCanvas extends Canvas {
 
   public final double tileWidth;
   private final double tileHeight;
-  private final Integer numberOfColumns;
-  private final Integer numberOfRows;
+  private final SquareGrid tileGrid;
 
   public GridTileCanvas(@NamedArg("tileWidth") Double tileWidth,
                         @NamedArg("tileHeight") Double tileHeight,
@@ -25,11 +23,12 @@ public class GridTileCanvas extends Canvas {
                         @NamedArg("numberOfRows") Integer numberOfRows) {
     this.tileWidth = tileWidth;
     this.tileHeight = tileHeight;
-    this.numberOfColumns = numberOfColumns;
-    this.numberOfRows = numberOfRows;
     this.setWidth(tileWidth * numberOfColumns);
     this.setHeight(tileHeight * numberOfRows);
-    SquareGrid tileGrid = new SquareGrid(numberOfRows, numberOfColumns);
+    tileGrid = new SquareGrid(numberOfRows, numberOfColumns);
+  }
+
+  public void initializeGrid(){
     tileGrid.fillWithRandomTiles(List.of(Color.BLUE, Color.GREEN, Color.BLACK, Color.RED), new Random());
     drawGridTile(tileGrid);
   }
@@ -37,6 +36,7 @@ public class GridTileCanvas extends Canvas {
   public void drawGridTile(SquareGrid tileGrid){
     for(int row = 0; row < tileGrid.getNumberOfRows(); row++)
       for(int column = 0; column < tileGrid.getNumberOfColumns(); column++){
+        if(tileGrid.hasTile(row, column))
           drawTile(tileGrid.getTile(row, column), column, row);
       }
   }

src/main/resources/view/GridCanvas.fxml

@@ -12,13 +12,13 @@
             fx:controller="controller.MainPaneController">
         <GridTileCanvas xmlns="http://javafx.com/javafx"
                         xmlns:fx="http://javafx.com/fxml"
-                        fx:id="GridTileCanvas">
-                <tileHeight>
-                        <Double fx:value="10"/>
-                </tileHeight>
+                        fx:id="gridTileCanvas">
                 <tileWidth>
                         <Double fx:value="10"/>
                 </tileWidth>
+                <tileHeight>
+                        <Double fx:value="10"/>
+                </tileHeight>
                 <numberOfColumns>
                         <Integer fx:value="100"/>
                 </numberOfColumns>