2 files changed, 79 insertions, 8 deletions

diff --git a/app/src/main/java/space/jakob/mines/GameActivity.kt b/app/src/main/java/space/jakob/mines/GameActivity.kt
index 5ab1f4b..929c020 100644
--- a/app/src/main/java/space/jakob/mines/GameActivity.kt
+++ b/app/src/main/java/space/jakob/mines/GameActivity.kt
@@ -14,10 +14,25 @@ package space.jakob.mines
 
 import android.support.v7.app.AppCompatActivity
 import android.os.Bundle
+import android.view.MotionEvent
+import android.util.Log
 
 class GameActivity : AppCompatActivity() {
+    lateinit var gameView: GameView
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        val (x, y) = gameView.toGridCoordinates(event.x.toInt(), event.y.toInt())
+        gameView.grid?.let {
+            it.reveal(x, y)
+            gameView.invalidate()
+        }
+        return true
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_game)
+        gameView = findViewById(R.id.view) as GameView
+        gameView.grid = Grid(8, 8, 10)
     }
 }
diff --git a/app/src/main/java/space/jakob/mines/GameView.kt b/app/src/main/java/space/jakob/mines/GameView.kt
index f323403..80218ce 100644
--- a/app/src/main/java/space/jakob/mines/GameView.kt
+++ b/app/src/main/java/space/jakob/mines/GameView.kt
@@ -23,6 +23,7 @@ import android.view.View
 import android.util.Log
 
 const val atlasWidth = 3
+const val tileSpacing = 2.0 / 27.0
 
 enum class AtlasEntry {
     BLANK, MASKED, UNMASKED,
@@ -36,7 +37,7 @@ class GameView(context: Context, attrs: AttributeSet) : View(context, attrs) {
 
     var grid: Grid? = null
 
-    var cameraX = 0.0f
+    var cameraX = 0.5f
     var cameraY = 0.0f
     var sightX = 5.0f
     var sightY = 5.0f
@@ -46,23 +47,78 @@ class GameView(context: Context, attrs: AttributeSet) : View(context, attrs) {
     val scaledHeight: Int
         get() = height / (sightY - cameraY).toInt()
 
-    private fun atlasRect(entry: AtlasEntry, tileWidth: Int): Rect {
+    private fun atlasRect(entry: AtlasEntry): Rect {
         val x = (entry.ordinal % atlasWidth) * tileWidth
         val y = (entry.ordinal / atlasWidth) * tileWidth
         return Rect(x, y, x + tileWidth, y + tileWidth)
     }
 
-    private fun drawTile(canvas: Canvas, entry: AtlasEntry, x: Int, y: Int) {
-        val src = atlasRect(entry, tileWidth)
-        val dst = Rect(x, y, x + scaledWidth, y + scaledHeight)
-        canvas.drawBitmap(atlas, src, dst, null)
+    private fun drawTile(canvas: Canvas, tile: Tile, x: Int, y: Int) {
+        val xSpacing = (scaledWidth * tileSpacing).toInt()
+        val ySpacing = (scaledWidth * tileSpacing).toInt()
+
+        val dst = Rect(
+            x + xSpacing,
+            y + ySpacing,
+            x + scaledWidth - xSpacing,
+            y + scaledHeight - ySpacing
+        )
+
+        if (tile.masked) {
+            canvas.drawBitmap(atlas, atlasRect(AtlasEntry.MASKED), dst, null)
+        } else {
+            canvas.drawBitmap(atlas, atlasRect(AtlasEntry.UNMASKED), dst, null)
+
+            val overlay = when {
+                tile.mine -> AtlasEntry.MINE
+                tile.adjacentMines == 1 -> AtlasEntry.ONE
+                tile.adjacentMines == 2 -> AtlasEntry.TWO
+                tile.adjacentMines == 3 -> AtlasEntry.THREE
+                tile.adjacentMines == 4 -> AtlasEntry.FOUR
+                tile.adjacentMines == 5 -> AtlasEntry.FIVE
+                tile.adjacentMines == 6 -> AtlasEntry.SIX
+                tile.adjacentMines == 7 -> AtlasEntry.SEVEN
+                tile.adjacentMines == 8 -> AtlasEntry.EIGHT
+                else -> AtlasEntry.BLANK
+            }
+
+            canvas.drawBitmap(atlas, atlasRect(overlay), dst, null)
+        }
+    }
+
+    private fun drawGrid(canvas: Canvas, grid: Grid) {
+        val startX = cameraX.toInt() // Truncates the fractional component.
+        val startY = cameraY.toInt()
+        val howManyX = (sightX - cameraX).toInt() + 1
+        val howManyY = (sightY - cameraY).toInt() + 1
+
+        for (i in 0..howManyX) {
+            for (j in 0..howManyY) {
+                val tile = grid[startX + i, startY + j]
+
+                val xOffset = (scaledWidth * (cameraX % 1)).toInt()
+                val yOffset = (scaledHeight * (cameraY % 1)).toInt()
+
+                drawTile(
+                    canvas,
+                    tile,
+                    i * scaledWidth - xOffset,
+                    j * scaledHeight - yOffset
+                )
+            }
+        }
     }
 
+    fun toGridCoordinates(x: Int, y: Int) = Pair(
+        (x + (scaledWidth * (cameraX % 1)).toInt()) / scaledWidth + cameraX.toInt(),
+        (y + (scaledHeight * (cameraY % 1)).toInt()) / scaledHeight + cameraY.toInt()
+    )
+
     override fun onDraw(canvas: Canvas) {
         super.onDraw(canvas)
 
-        for (i in 0..5) {
-            drawTile(canvas, AtlasEntry.MINE, i * scaledWidth - tileWidth / 2, 0)
+        grid?.let {
+            drawGrid(canvas, it)
         }
     }
 }