diff --git a/src/main/java/controller/MainPaneController.java b/src/main/java/controller/MainPaneController.java
index 6e5f3b1938146e8de774a2d32d0a1262cedb3407..e59c215b8c8729c4cf4fd290c94de0b34e3b6374 100644
--- a/src/main/java/controller/MainPaneController.java
+++ b/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();
   }
 
 }
diff --git a/src/main/java/main/MainApp.java b/src/main/java/main/MainApp.java
index 7c512e2f42fd7c12d2189b8337c32724d39d43c2..4a725ba2a47bbfa6121965e21acd933c710fc21c 100644
--- a/src/main/java/main/MainApp.java
+++ b/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) {
diff --git a/src/main/java/model/BorderSquareIterator.java b/src/main/java/model/BorderSquareIterator.java
new file mode 100644
index 0000000000000000000000000000000000000000..93f0fc9eab40ef81156f97bf8c51e45174a77b55
--- /dev/null
+++ b/src/main/java/model/BorderSquareIterator.java
@@ -0,0 +1,75 @@
+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;
+  }
+}
diff --git a/src/main/java/model/CardinalDirection.java b/src/main/java/model/CardinalDirection.java
index ca4278ab5f93712bd8a39458f127b3cac03c90c4..78d7d061b971f856f5e56a367e8aa54c89a83ab5 100644
--- a/src/main/java/model/CardinalDirection.java
+++ b/src/main/java/model/CardinalDirection.java
@@ -1,8 +1,25 @@
 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;
+    };
+  }
 }
diff --git a/src/main/java/model/InternalSquareIterator.java b/src/main/java/model/InternalSquareIterator.java
new file mode 100644
index 0000000000000000000000000000000000000000..627777b545cb11de82b28e3bf76c7e11a68bcf70
--- /dev/null
+++ b/src/main/java/model/InternalSquareIterator.java
@@ -0,0 +1,33 @@
+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;
+  }
+}
diff --git a/src/main/java/model/RandomTileGenerator.java b/src/main/java/model/RandomTileGenerator.java
index 318f658d54ba03984641988496da9bf49a0ade3f..92ffa8dc6906ad739008b3153395f99974e83544 100644
--- a/src/main/java/model/RandomTileGenerator.java
+++ b/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);
+  }
+
 }
diff --git a/src/main/java/model/Square.java b/src/main/java/model/Square.java
index dffd14701b816c475276ac6fac95a103ef2df95d..61f9488b971c06e645464a40b2e13b0c94c421a4 100644
--- a/src/main/java/model/Square.java
+++ b/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;
   }
 }
diff --git a/src/main/java/model/SquareGrid.java b/src/main/java/model/SquareGrid.java
index 2dcc25467beac882e3e68163e0e696497097c501..f224952497982c8cb837b16b4e746c927f17bf62 100644
--- a/src/main/java/model/SquareGrid.java
+++ b/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++)
-        matrix[row][column] = new Square();
+        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,11 +48,19 @@ 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) {
-    return getSquare(rowIndex,columnIndex).getTile();
+    return getSquare(rowIndex, columnIndex).getTile();
   }
 
   public Square getSquare(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();
   }
 }
diff --git a/src/main/java/model/GridIterator.java b/src/main/java/model/SquareIterator.java
similarity index 73%
rename from src/main/java/model/GridIterator.java
rename to src/main/java/model/SquareIterator.java
index 6cee9e4a8c9a85051f43eda0b2fcdc5db3951466..9581faebfbca92e4f24d03b015c04cc576b586f8 100644
--- a/src/main/java/model/GridIterator.java
+++ b/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
diff --git a/src/main/java/view/GridTileCanvas.java b/src/main/java/view/GridTileCanvas.java
index cfc9b8c1636a4009cbc61329e73b1b354daa33cc..36a1995d43e135fcfba8f3e3d18946637cb66057 100644
--- a/src/main/java/view/GridTileCanvas.java
+++ b/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,7 +36,8 @@ 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++){
-        drawTile(tileGrid.getTile(row, column), column, row);
+        if(tileGrid.hasTile(row, column))
+          drawTile(tileGrid.getTile(row, column), column, row);
       }
   }
 
diff --git a/src/main/resources/view/GridCanvas.fxml b/src/main/resources/view/GridCanvas.fxml
index 8e97434a7547f677fe53d3f1460f6033a35d2cbe..a9a9b261d39d6c3786a8a9ded222d9e61403ed04 100644
--- a/src/main/resources/view/GridCanvas.fxml
+++ b/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>