Convert code to using Processing

build.gradle

@@ -0,0 +1,12 @@
+plugins {
+    id 'org.jetbrains.kotlin.jvm' version '1.3.50'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    compile "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.50"
+    compile 'org.processing:core:3.3.6'
+}

gradle.properties

@@ -0,0 +1,2 @@
+kotlin.code.style=official
+kotlin.import.noCommonSourceSets=true

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Tue Sep 24 11:55:32 CEST 2019
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStorePath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME

settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'Knights Tour'
+

src/main/kotlin/algorithms/Warnsdorff.kt

@@ -0,0 +1,29 @@
+package algorithms
+
+import grid.Cell
+import grid.Grid
+
+class Warnsdorff(private val grid: Grid) {
+
+    fun run(): Cell? {
+        val startCell = grid.randomCell()
+        var currentCell = startCell
+        (0 until grid.size()).forEach { moveCount ->
+            val groupedNeighbours = currentCell
+                                    ?.neighbours()
+                                    ?.groupBy { it.neighbours().size }
+
+            val lowestAmountOfNeighbours = groupedNeighbours?.keys?.min()
+
+            val nextCell = groupedNeighbours
+                            ?.get(lowestAmountOfNeighbours)
+                            ?.random()
+
+            currentCell?.link(nextCell)
+            currentCell?.moveCount = moveCount
+            currentCell = nextCell
+        }
+
+        return startCell
+    }
+}

src/grid/Cell.kt → src/main/kotlin/grid/Cell.kt

@@ -27,6 +27,7 @@ open class Cell(
     var eastNorth: Cell? = null
     var eastSouth: Cell? = null
     var linkedCell: Cell? = null
+    var moveCount: Int = -1
 
     private var visited: Boolean = false
 
@@ -46,17 +47,34 @@ open class Cell(
     fun link(nextCell: Cell?) {
         visited = true
         linkedCell = nextCell
+        nextCell?.markAsVisited(this)
     }
 
-    fun getPngCoords(cellSize: Int) : PngCoords {
+    private fun markAsVisited(cell: Cell) {
+        neighbours().forEach { neighbour ->
+            if (neighbour == cell) neighbour.visited = true
+        }
+    }
+
+    fun getCoords(cellSize: Float) : Coords {
         val halfDimen = cellSize / 2
-        return PngCoords(
+        return Coords(
             column * cellSize,
-            (column + 1) * cellSize,
             row * cellSize,
-            (row + 1) * cellSize,
             (column * cellSize) + halfDimen,
             (row * cellSize) + halfDimen
         )
     }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is Cell)
+            return false
+        else {
+            if (other.row == this.row
+                && other.column == this.column)
+                return true
+        }
+        return false
+    }
 }

src/main/kotlin/grid/Coords.kt

@@ -0,0 +1,18 @@
+package grid
+
+data class Coords(
+    val x1: Float,
+    val y1: Float,
+    val xC: Float,
+    val yC: Float
+)
+
+/*
+x1/y1  _______
+      |       |
+      |       |
+      | xC/yC |
+      |       |
+      |_______|
+
+ */

src/main/kotlin/grid/Grid.kt

@@ -0,0 +1,62 @@
+package grid
+
+open class Grid(private val numRows: Int, private val numColumns: Int) {
+
+    private val grid by lazy { generateGrid() }
+
+    private fun generateGrid(): Array<Array<Cell?>> {
+        val emptyGrid = prepareGrid()
+        return configureCells(emptyGrid)
+    }
+
+    open fun prepareGrid(): Array<Array<Cell?>> {
+        return Array(numRows) {
+                row -> Array<Cell?>(numColumns) {
+                column ->
+            Cell(row, column)
+        }}
+    }
+
+    open fun configureCells(emptyGrid: Array<Array<Cell?>>): Array<Array<Cell?>> {
+        emptyGrid.forEachIndexed { row, columns ->
+            columns.forEachIndexed { column, cell ->
+                cell?.northWest = emptyGrid[row - 2, column - 1]
+                cell?.northEast = emptyGrid[row - 2, column + 1]
+                cell?.southWest = emptyGrid[row + 2, column - 1]
+                cell?.southEast = emptyGrid[row + 2, column + 1]
+                cell?.westNorth = emptyGrid[row - 1, column - 2]
+                cell?.westSouth = emptyGrid[row + 1, column - 2]
+                cell?.eastNorth = emptyGrid[row - 1, column + 2]
+                cell?.eastSouth = emptyGrid[row + 1, column + 2]
+            }
+        }
+
+        return emptyGrid
+    }
+
+    fun randomCell(): Cell? {
+        val r = (0 until numRows).random()
+        val c = (0 until numColumns).random()
+        return this[r, c]
+    }
+
+    fun size() = numRows * numColumns
+
+    fun forEachCell(action: (Cell) -> Unit) {
+        grid.forEach { row ->
+            row.forEach { cell ->
+                if (cell != null) {
+                    action(cell)
+                }
+            }
+        }
+    }
+
+    private operator fun get(row: Int, column: Int) = grid[row, column]
+
+    private operator fun Array<Array<Cell?>>.get(row: Int, column: Int): Cell? {
+        if (row !in 0 until numRows) return null
+        if (column !in 0 until numColumns) return null
+        return this[row][column]
+    }
+}

src/main/kotlin/main.kt

@@ -0,0 +1,5 @@
+import processing.core.PApplet
+
+fun main(args: Array<String>) {
+    PApplet.main("output.KnightsTour")
+}