diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml
index f0ba76c..de71baa 100644
--- a/.idea/deploymentTargetSelector.xml
+++ b/.idea/deploymentTargetSelector.xml
@@ -4,10 +4,10 @@
     <selectionStates>
       <SelectionState runConfigName="app">
         <option name="selectionMode" value="DROPDOWN" />
-        <DropdownSelection timestamp="2025-08-26T11:06:03.805342749Z">
+        <DropdownSelection timestamp="2025-08-08T10:50:02.571721922Z">
           <Target type="DEFAULT_BOOT">
             <handle>
-              <DeviceId pluginId="LocalEmulator" identifier="path=/home/secondbeam/.config/.android/avd/Virtual_Pixel_3.avd" />
+              <DeviceId pluginId="LocalEmulator" identifier="path=/home/secondbeam/.android/avd/Pixel_3.avd" />
             </handle>
           </Target>
         </DropdownSelection>
diff --git a/app/src/main/java/com/mirenkov/ktheightmap/MainActivity.kt b/app/src/main/java/com/mirenkov/ktheightmap/MainActivity.kt
index 4deea14..e861aae 100644
--- a/app/src/main/java/com/mirenkov/ktheightmap/MainActivity.kt
+++ b/app/src/main/java/com/mirenkov/ktheightmap/MainActivity.kt
@@ -3,47 +3,33 @@ package com.mirenkov.ktheightmap
 import android.app.Application
 import android.content.Intent
 import android.os.Bundle
-import android.util.Log
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.safeDrawingPadding
 import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Build
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.DropdownMenu
-import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.FloatingActionButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme.colorScheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Slider
 import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.material3.TextField
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.text.input.KeyboardType
-import androidx.compose.ui.text.toUpperCase
+import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
@@ -86,7 +72,7 @@ class MainActivity : ComponentActivity() {
 
 @Composable
 fun Main(vm: TileViewModel = viewModel()) {
-    var scale by rememberSaveable { vm.scale }
+    val sliderValue = rememberSaveable { mutableFloatStateOf(1F) }
     val coroutineScope = rememberCoroutineScope()
     val tileContainer = TileContainer(vm, coroutineScope)
     KtHeightMapTheme {
@@ -95,14 +81,14 @@ fun Main(vm: TileViewModel = viewModel()) {
                 modifier = Modifier.fillMaxSize()
                     .safeDrawingPadding()
                     .align(Alignment.Center),
-                floatingActionButton = { ToolButton(vm) }
+                floatingActionButton = { ToolButton() }
             ) { innerPadding ->
                 MapCanvas(
-                    viewModel = vm,
                     gridColor = colorScheme.primary,
                     backColor = colorScheme.background,
+                    scale = sliderValue,
                     tileContainer = tileContainer,
-                    modifier = Modifier.padding(innerPadding)
+                    modifier = Modifier.padding(innerPadding),
                 )
             }
             Box(modifier = Modifier.safeDrawingPadding()
@@ -112,8 +98,8 @@ fun Main(vm: TileViewModel = viewModel()) {
                 .offset(0.dp, 60.dp)
             ) {
                 Slider(
-                    value = scale,
-                    onValueChange = { scale = it },
+                    value = sliderValue.floatValue,
+                    onValueChange = { sliderValue.floatValue = it },
                     valueRange = 1F..14F,
                     modifier = Modifier.align(Alignment.CenterStart)
                 )
@@ -123,97 +109,33 @@ fun Main(vm: TileViewModel = viewModel()) {
 }
 
 @Composable
-fun ToolButton(viewModel: TileViewModel) {
+fun ToolButton() {
     val context = LocalContext.current
-    var expanded by rememberSaveable{ mutableStateOf(false) }
-    var debug by rememberSaveable{ viewModel.debug }
-    var logRequested by remember{ viewModel.logRequested }
-    val dialogShown = rememberSaveable{ mutableStateOf(false) }
     FloatingActionButton(
         onClick = {
-            expanded = !expanded
+            val intent = Intent(context, SettingsActivity::class.java)
+            context.startActivity(intent)
         }
-    ) {
-        Icon(Icons.Filled.Build, contentDescription = "Tools")
-        DropdownMenu(
-            expanded = expanded,
-            onDismissRequest = { expanded = false }
-        ) {
-            DropdownMenuItem(
-                text = { Text("Toggle debug") },
-                onClick = {
-                    debug = !debug
-                    expanded = false
-                }
-            )
-            DropdownMenuItem(
-                text = { Text("Log") },
-                onClick = {
-                    logRequested = true
-                    expanded = false
-                }
-            )
-            DropdownMenuItem(
-                text = { Text("Set location") },
-                onClick = {
-                    dialogShown.value = true
-                }
-            )
-            DropdownMenuItem(
-                text = { Text("Settings") },
-                onClick = {
-                    expanded = false
-                    val intent = Intent(context, SettingsActivity::class.java)
-                    context.startActivity(intent)
-                }
-            )
-            SetLocationDialog(viewModel, dialogShown)
-        }
-    }
+    ) { Icon(Icons.Filled.Build, contentDescription = "Tools") }
 }
 
+@Preview(showBackground = true)
 @Composable
-fun SetLocationDialog(vm: TileViewModel, dialogShown: MutableState<Boolean>) {
-    var showLocationDialog by dialogShown
-    if (showLocationDialog) {
-        var latitudeText by remember { vm.latitudeText }
-        var longitudeText by remember { vm.longitudeText }
-        AlertDialog (
-            onDismissRequest = { showLocationDialog = false },
-            title = { Text("Input coordinates") },
-            text = {
-                Column {
-                    TextField(
-                        value = latitudeText,
-                        onValueChange = { newValue ->
-                            latitudeText = newValue
-                        },
-                        label = { Text("Latitude") },
-                        placeholder = { Text("60.086763") },
-                        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number)
-                    )
-                    TextField(
-                        value = longitudeText,
-                        onValueChange = { newValue ->
-                            longitudeText = newValue
-                        },
-                        label = { Text("Longitude") },
-                        placeholder = { Text("30.014658") },
-                        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number)
-                    )
-                }
-            },
-            confirmButton = { TextButton(onClick = {
-                val latitude = latitudeText.text.toDoubleOrNull() ?: 0.0
-                val longitude = longitudeText.text.toDoubleOrNull() ?: 0.0
-                Log.i(TAG, "Lat: %.6f, Lon: %.6f".format(latitude, longitude))
-                Log.i(TAG, "X = %.6f".format(SphereMercator.mercateLon(longitude, vm.scale.floatValue.toInt(), -TILE_SIZE.toDouble())))
-            }) {
-                    Text("Confirm".uppercase())
-                } },
-            dismissButton = { TextButton(onClick = { showLocationDialog = false }) {
-                Text("Cancel".uppercase())
-            } }
-        )
+fun MainPreview() {
+    KtHeightMapTheme {
+        Scaffold(
+            modifier = Modifier.safeDrawingPadding(),
+            floatingActionButton = { ToolButton() }
+        ) { innerPadding ->
+            Box(
+                modifier = Modifier.padding(innerPadding)
+                    .fillMaxSize(),
+                contentAlignment = Alignment.Center
+            ) {
+                Text(
+                    text = "Gryadki"
+                )
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/mirenkov/ktheightmap/MapCanvas.kt b/app/src/main/java/com/mirenkov/ktheightmap/MapCanvas.kt
index 8aa8619..9e73d6d 100644
--- a/app/src/main/java/com/mirenkov/ktheightmap/MapCanvas.kt
+++ b/app/src/main/java/com/mirenkov/ktheightmap/MapCanvas.kt
@@ -1,21 +1,16 @@
 package com.mirenkov.ktheightmap
 
-import android.util.Log
 import androidx.compose.foundation.Canvas
-import androidx.compose.foundation.clickable
 import androidx.compose.foundation.gestures.detectDragGestures
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.MutableFloatState
-import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.Path
 import androidx.compose.ui.graphics.asImageBitmap
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.input.pointer.pointerInput
@@ -30,71 +25,52 @@ import kotlin.math.absoluteValue
 
 @Composable
 fun MapCanvas(
-    viewModel: TileViewModel,
     backColor: Color,
     gridColor: Color,
+    scale: MutableFloatState,
     tileContainer: TileContainer,
     modifier: Modifier = Modifier
 ) {
-    var offsetX by rememberSaveable { viewModel.mapOffsetX }
-    var offsetY by rememberSaveable { viewModel.mapOffsetY }
-    val scale by rememberSaveable { viewModel.scale }
+    val offsetX = rememberSaveable { mutableFloatStateOf(-TILE_SIZE) }
+    val offsetY = rememberSaveable { mutableFloatStateOf(-TILE_SIZE) }
     val textMeasurer = rememberTextMeasurer()
-    val debug by rememberSaveable { viewModel.debug }
-    var logRequested by rememberSaveable { viewModel.logRequested }
     Canvas(
         modifier = modifier.fillMaxSize()
             .pointerInput(Unit) {
                 detectDragGestures { _, distance ->
-                    offsetX -= distance.x
-                    offsetY -= distance.y
+                    offsetX.floatValue -= distance.x
+                    offsetY.floatValue -= distance.y
                 }
             }
     ) {
-        if (viewModel.halvedOffsetX == null) {
-            viewModel.halvedOffsetX = size.width / 2
-            viewModel.halvedOffsetY = size.height / 2
-        }
-        val halvedX = viewModel.halvedOffsetX!!
-        val halvedY = viewModel.halvedOffsetY!!
-
         drawRect(
             color = backColor,
             size = size
         )
-
-        if (logRequested) {
-            Log.i(TAG, "Offset: %.6f, %.6f".format(offsetX, offsetY))
-            logRequested = false
-        }
-
         val oldLevel = tileContainer.getLevel()
-        val level = scale.toInt()
+        val level = scale.floatValue.toInt()
         val levelDiff = level - oldLevel
 
         if (levelDiff < 0) {
             repeat (levelDiff.absoluteValue) {
-                offsetX -= halvedX + TILE_SIZE
-                offsetY -= halvedY + TILE_SIZE
-                offsetX /= 2F
-                offsetY /= 2F
+                offsetX.floatValue -= size.width / 2F + TILE_SIZE
+                offsetY.floatValue -= size.height / 2F + TILE_SIZE
+                offsetX.floatValue /= 2F
+                offsetY.floatValue /= 2F
             }
         } else if (levelDiff > 0) {
             repeat (levelDiff) {
-                offsetX *= 2F
-                offsetY *= 2F
-                offsetX += halvedX + TILE_SIZE
-                offsetY += halvedY + TILE_SIZE
+                offsetX.floatValue *= 2F
+                offsetY.floatValue *= 2F
+                offsetX.floatValue += size.width / 2F + TILE_SIZE
+                offsetY.floatValue += size.height / 2F + TILE_SIZE
             }
         }
-        val tileOffsetX = (offsetX / TILE_SIZE).toInt()
-        val tileOffsetY = (offsetY / TILE_SIZE).toInt()
+        val tileOffsetX = (offsetX.floatValue / TILE_SIZE).toInt()
+        val tileOffsetY = (offsetY.floatValue / TILE_SIZE).toInt()
 
-        val centerTileX = (1 + (offsetX + halvedX) / TILE_SIZE).toDouble()
-        val centerTileY = (1 + (offsetY + halvedY) / TILE_SIZE).toDouble()
-
-        val strippedOffsetX = offsetX % TILE_SIZE
-        val strippedOffsetY = offsetY % TILE_SIZE
+        val strippedOffsetX = offsetX.floatValue % TILE_SIZE
+        val strippedOffsetY = offsetY.floatValue % TILE_SIZE
 
         val offset = Offset(strippedOffsetX, strippedOffsetY)
 
@@ -105,12 +81,6 @@ fun MapCanvas(
 
         val tiles = tileContainer.getTiles(tileOffsetX, tileOffsetY, tileOffsetX + gridWidth + 2, tileOffsetY + gridHeight + 2, level)
 
-        val crossRadius = 24F
-
-        val additionalSize = if (debug) 96F else 0F
-        val latLonSize = Size(216F, 96F + additionalSize)
-        val latLonOffset = Offset(16F, 16F)
-
         for (cellX in 0 .. gridWidth + 2) {
             val tileX = tileOffsetX + cellX
             val localOffsetX = TILE_SIZE * (cellX - 1)
@@ -118,59 +88,21 @@ fun MapCanvas(
                 val tileY = tileOffsetY + cellY
                 val localOffsetY = TILE_SIZE * (cellY - 1)
 
-                val tile = tiles.find { it.x == tileX && it.y == tileY && it.level == level }!!
-                val bitmap = tile.toBitmap()
-                val totalOffset = Offset(localOffsetX, localOffsetY) - offset
+                val bitmap = tiles.find { it.x == tileX && it.y == tileY && it.level == level }?.toBitmap()
 
                 bitmap?.let {
                     val imageBitmap = bitmap.asImageBitmap()
                     drawImage(
                         image = imageBitmap,
-                        topLeft = totalOffset
+                        topLeft = Offset(localOffsetX, localOffsetY) - offset
                     )
                 }
-
-                if (debug) {
-                    drawRect(
-                        color = gridColor,
-                        size = Size(TILE_SIZE, TILE_SIZE),
-                        topLeft = totalOffset,
-                        style = Stroke(width = 4F)
-                    )
-
-                    drawText(
-                        textMeasurer = textMeasurer,
-                        text = buildAnnotatedString {
-                            withStyle(ParagraphStyle(textAlign = TextAlign.Center)) {
-                                withStyle(SpanStyle(color = gridColor)) {
-                                    val mercX = tile.mercateX()
-                                    val mercY = tile.mercateY()
-                                    append("%.6f, %.6f,\n%d, %d".format(mercX, mercY, tileX, tileY))
-                                }
-                            }
-                        },
-                        topLeft = totalOffset,
-                        size = Size(TILE_SIZE, TILE_SIZE)
-                    )
-                }
-
-                val path = Path()
-                path.moveTo(halvedX - crossRadius, halvedY)
-                path.lineTo(halvedX + crossRadius, halvedY)
-                path.moveTo(halvedX, halvedY - crossRadius)
-                path.lineTo(halvedX, halvedY + crossRadius)
-                path.close()
-
-                drawPath(
-                    path,
-                    Color.White,
-                    style = Stroke(width = 6F)
-                )
-
+                /*
                 drawRect(
-                    color = backColor,
-                    size = latLonSize,
-                    topLeft = latLonOffset
+                    color = gridColor,
+                    size = Size(TILE_SIZE, TILE_SIZE),
+                    topLeft = Offset(localOffsetX, localOffsetY) - offset,
+                    style = Stroke(width = 4F)
                 )
 
                 drawText(
@@ -178,18 +110,14 @@ fun MapCanvas(
                     text = buildAnnotatedString {
                         withStyle(ParagraphStyle(textAlign = TextAlign.Center)) {
                             withStyle(SpanStyle(color = gridColor)) {
-                                val lon = SphereMercator.mercateX(centerTileX, level)
-                                val lat = SphereMercator.mercateY(centerTileY, level)
-                                append("%.6f\n%.6f".format(lon, lat))
-                                if (debug) {
-                                    append("\n%.0f\n%.0f".format(offsetX, offsetY))
-                                }
+                                append("x:%d, y:%d".format(tileX, tileY))
                             }
                         }
                     },
-                    size = latLonSize,
-                    topLeft = latLonOffset
+                    topLeft = Offset(localOffsetX, localOffsetY) - offset,
+                    size = Size(TILE_SIZE, TILE_SIZE)
                 )
+                */
             }
         }
     }
diff --git a/app/src/main/java/com/mirenkov/ktheightmap/SphereMercator.kt b/app/src/main/java/com/mirenkov/ktheightmap/SphereMercator.kt
deleted file mode 100644
index 4d44954..0000000
--- a/app/src/main/java/com/mirenkov/ktheightmap/SphereMercator.kt
+++ /dev/null
@@ -1,58 +0,0 @@
-package com.mirenkov.ktheightmap
-
-import java.lang.Math.toRadians
-import java.lang.Math.toDegrees
-import kotlin.math.atan
-import kotlin.math.exp
-import kotlin.math.ln
-import kotlin.math.tan
-import kotlin.math.PI
-
-class SphereMercator {
-    companion object {
-        const val RADIUS = 6378137
-        const val METERS_PER_PIXEL = 156543.0339
-
-        fun x2lon(x: Double): Double {
-            return toDegrees(x / RADIUS)
-        }
-
-        fun y2lat(y: Double): Double {
-            return toDegrees(atan(exp(y / RADIUS / 2)) * 2 - PI / 2)
-        }
-
-        fun lon2x(longitude: Double): Double {
-            return toRadians(longitude) * RADIUS
-        }
-
-        fun lat2y(latitude: Double): Double {
-            return ln(tan(PI / 4 + toRadians(latitude) / 2)) * RADIUS
-        }
-
-        fun scaledMetersPerPixel(level: Int): Double {
-            return METERS_PER_PIXEL / ( 1 shl (level - 1) )
-        }
-
-        fun sx2lon(x: Double, level: Int): Double {
-            return x2lon(x * scaledMetersPerPixel(level))
-        }
-
-        fun sy2lat(y: Double, level: Int): Double {
-            return y2lat( y * scaledMetersPerPixel(level))
-        }
-
-        fun lon2sx(longitude: Double, level: Int) : Double {
-            return lon2x(longitude) / scaledMetersPerPixel(level)
-        }
-
-        fun lat2sy(latitude: Double, level: Int): Double {
-            return lat2y(latitude) / scaledMetersPerPixel(level)
-        }
-
-        fun mercateX(x: Double, level: Int): Double = sx2lon((x * TILE_SIZE), level) - 180.0
-
-        fun mercateY(y: Double, level: Int): Double = -sy2lat((y - ((1 shl (level - 1)).toDouble() / 2.0)) * TILE_SIZE, level - 1)
-
-        fun mercateLon(longitude: Double, level: Int, offset: Double): Double = lon2sx(longitude + 180.0, level) + offset
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/com/mirenkov/ktheightmap/Tile.kt b/app/src/main/java/com/mirenkov/ktheightmap/Tile.kt
index da409bd..fefd2f9 100644
--- a/app/src/main/java/com/mirenkov/ktheightmap/Tile.kt
+++ b/app/src/main/java/com/mirenkov/ktheightmap/Tile.kt
@@ -46,8 +46,4 @@ class Tile {
         bitmap = BitmapFactory.decodeByteArray(ba, 0, ba.size)
         return bitmap
     }
-
-    fun mercateX(): Double = SphereMercator.mercateX(x.toDouble(), level)
-
-    fun mercateY(): Double = SphereMercator.mercateY(y.toDouble(), level)
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/mirenkov/ktheightmap/TileRepository.kt b/app/src/main/java/com/mirenkov/ktheightmap/TileRepository.kt
index 5b07937..8ada061 100644
--- a/app/src/main/java/com/mirenkov/ktheightmap/TileRepository.kt
+++ b/app/src/main/java/com/mirenkov/ktheightmap/TileRepository.kt
@@ -12,12 +12,14 @@ class TileRepository(private val tileDao: TileDao) {
     fun pushTile(tile: Tile) {
         coroutineScope.launch(Dispatchers.IO) { tileDao.pushTile(tile) }
     }
+
     fun getTile(x: Int, y: Int, level: Int): Tile? {
         val tileFuture = coroutineScope.future(Dispatchers.IO) {
             tileDao.getTile(x, y, level)
         }
         return tileFuture.join()
     }
+
     fun clearTiles() {
         coroutineScope.launch(Dispatchers.IO) { tileDao.clearTiles() }
     }
diff --git a/app/src/main/java/com/mirenkov/ktheightmap/TileViewModel.kt b/app/src/main/java/com/mirenkov/ktheightmap/TileViewModel.kt
index 06e829d..bd2d9bf 100644
--- a/app/src/main/java/com/mirenkov/ktheightmap/TileViewModel.kt
+++ b/app/src/main/java/com/mirenkov/ktheightmap/TileViewModel.kt
@@ -1,27 +1,12 @@
 package com.mirenkov.ktheightmap
 
 import android.app.Application
-import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableStateOf
-import androidx.compose.ui.text.input.TextFieldValue
 import androidx.lifecycle.ViewModel
 
 class TileViewModel(application: Application): ViewModel() {
     val repository: TileRepository
 
-    var debug = mutableStateOf(false)
-    var logRequested = mutableStateOf(false)
-
-    var latitudeText = mutableStateOf(TextFieldValue(""))
-    var longitudeText = mutableStateOf(TextFieldValue(""))
-
-    val mapOffsetX = mutableFloatStateOf(-646.65625F)
-    val mapOffsetY = mutableFloatStateOf(-1157.2814F)
-    val scale = mutableFloatStateOf(1F)
-
-    var halvedOffsetX: Float? = null
-    var halvedOffsetY: Float? = null
-
     init {
         val tileDb = TileDB.getInstance(application)
         val tileDao = tileDb.tileDao()