Changed grid drawing algorithm once more, and reimplemented camera movement.

1 files changed, 20 insertions, 26 deletions

diff --git a/app/src/main/java/space/jakob/mines/GameView.kt b/app/src/main/java/space/jakob/mines/GameView.kt
index 52a8283..5acc94d 100644
--- a/app/src/main/java/space/jakob/mines/GameView.kt
+++ b/app/src/main/java/space/jakob/mines/GameView.kt
@@ -35,7 +35,6 @@ class GameView(context: Context, attrs: AttributeSet) : View(context, attrs) {
     val atlas = BitmapFactory.decodeResource(context.resources, R.drawable.atlas);
     val tileWidth = atlas.width / 3
 
-    // FIXME: Is this correct? `breadth` tiles, excluding halfsies and such?
     val scaledTileWidth: Int
         get() = (minOf(width, height) / cameraBreadth).toInt()
 
@@ -56,6 +55,14 @@ class GameView(context: Context, attrs: AttributeSet) : View(context, attrs) {
         (y + (scaledTileWidth * (cameraY % 1)).toInt()) / scaledTileWidth + cameraY.toInt()
     )
 
+    // TODO: Document this
+    fun moveCamera(dx: Double, dy: Double) {
+        grid?.let {
+            cameraX = (cameraX + dx / 100.0).coerceIn(0.0, (it.width  - 1).toDouble())
+            cameraY = (cameraY + dy / 100.0).coerceIn(0.0, (it.height - 1).toDouble())
+        }
+    }
+
     private fun atlasRect(entry: AtlasEntry): Rect {
         val atlasWidth = 3
 
@@ -130,33 +137,20 @@ class GameView(context: Context, attrs: AttributeSet) : View(context, attrs) {
             cameraBreadth
         }
 
-        // This is where the fractional component comes into play -- drawing
-        // tiles that are partially obscured by the limited reaches of the
-        // camera view.
-        val offsetX = (scaledTileWidth * ((cameraX + (cameraBreadthX / 2)) % 1)).toInt()
-        val offsetY = (scaledTileWidth * ((cameraY + (cameraBreadthY / 2)) % 1) / 2).toInt()
-
-        val howManyX = ceil(cameraBreadthX).toInt()
-        val howManyY = ceil(cameraBreadthY).toInt()
-
-        val startX = cameraX - (cameraBreadthX / 2)
-        val startY = cameraY - (cameraBreadthY / 2)
+        for (x in 0 until grid.width) {
+            for (y in 0 until grid.height) {
+                val minX = floor(cameraX - cameraBreadthX / 2).toInt()
+                val minY = floor(cameraY - cameraBreadthY / 2).toInt()
 
-        for (i in 0..howManyX) {
-            for (j in 0..howManyY) {
-                // The fractional components here are truncated, giving a
-                // equivalent indices into `grid`. Of course, these indices
-                // aren't necessarily within the bounds of the grid. If a tile
-                // doesn't exist, we'll just draw blank space.
-                val x = (startX + i.toDouble()).toInt()
-                val y = (startY + j.toDouble()).toInt()
+                val offsetX = (cameraX - cameraBreadthX / 2) % 1 * scaledTileWidth
+                val offsetY = (cameraY - cameraBreadthY / 2) % 1 * scaledTileWidth
 
-                if (grid.valid(x, y)) {
-                    val tile = grid[x, y]
-                    val screenX = i * scaledTileWidth
-                    val screenY = j * scaledTileWidth
-                    drawTile(canvas, tile, screenX + offsetX, screenY + offsetY)
-                }
+                drawTile(
+                    canvas,
+                    grid[x, y],
+                    (x - minX - 1) * scaledTileWidth - offsetX.toInt(),
+                    (y - minY - 1) * scaledTileWidth - offsetY.toInt()
+                )
             }
         }
     }