diff --git a/src/net/torvald/terrarum/mapdrawer/LightmapRenderer.kt b/src/net/torvald/terrarum/mapdrawer/LightmapRenderer.kt
index ccd416ce5..2c4a64394 100644
--- a/src/net/torvald/terrarum/mapdrawer/LightmapRenderer.kt
+++ b/src/net/torvald/terrarum/mapdrawer/LightmapRenderer.kt
@@ -421,6 +421,8 @@ object LightmapRenderer {
 
     }
 
+    val lightScalingMagic = 8f
+
     /**
      * Subtract each channel's RGB value.
      *
@@ -432,12 +434,12 @@ object LightmapRenderer {
         if (darken < 0 || darken >= COLOUR_RANGE_SIZE)
             throw IllegalArgumentException("darken: out of range ($darken)")
 
-        // use equation with magic number 9.0
-        // smooooooth
+        // use equation with magic number 8.0
+        // should draw somewhat exponential curve when you plot the propagation of light in-game
 
-        val r = data.r() * (1f - darken.r() * 9.0f)
-        val g = data.g() * (1f - darken.g() * 9.0f)
-        val b = data.b() * (1f - darken.b() * 9.0f)
+        val r = data.r() * (1f - darken.r() * lightScalingMagic)
+        val g = data.g() * (1f - darken.g() * lightScalingMagic)
+        val b = data.b() * (1f - darken.b() * lightScalingMagic)
 
         return constructRGBFromFloat(r.clampZero(), g.clampZero(), b.clampZero())
     }
@@ -461,12 +463,9 @@ object LightmapRenderer {
         if (brighten < 0 || brighten >= COLOUR_RANGE_SIZE)
             throw IllegalArgumentException("brighten: out of range ($brighten)")
 
-        val r = data.r() * (1f + brighten.r() * 6.5f)
-        val g = data.g() * (1f + brighten.g() * 6.5f)
-        val b = data.b() * (1f + brighten.b() * 6.5f)
-        //val r = data.r() + brighten.r()
-        //val g = data.g() + brighten.g()
-        //val b = data.b() + brighten.b()
+        val r = data.r() * (1f + brighten.r() * lightScalingMagic)
+        val g = data.g() * (1f + brighten.g() * lightScalingMagic)
+        val b = data.b() * (1f + brighten.b() * lightScalingMagic)
 
         return constructRGBFromFloat(r.clampChannel(), g.clampChannel(), b.clampChannel())
     }
@@ -498,6 +497,7 @@ object LightmapRenderer {
             constructRGBFromFloat(-brighten, -brighten, -brighten)
         else
             constructRGBFromFloat(brighten, brighten, brighten)
+
         return if (brighten < 0)
             darkenColoured(data, modifier)
         else
@@ -624,12 +624,12 @@ object LightmapRenderer {
     private fun Float.clampChannel() = if (this > CHANNEL_MAX_DECIMAL) CHANNEL_MAX_DECIMAL else this
 
     fun getValueFromMap(x: Int, y: Int): Int? = getLight(x, y)
-    fun getLowestRGB(x: Int, y: Int): Int? {
+    fun getHighestRGB(x: Int, y: Int): Int? {
         val value = getLight(x, y)
         if (value == null)
             return null
         else
-            return FastMath.min(value.rawR(), value.rawG(), value.rawB())
+            return FastMath.max(value.rawR(), value.rawG(), value.rawB())
     }
 
     private fun purgeLightmap() {
diff --git a/src/net/torvald/terrarum/mapdrawer/TilesDrawer.kt b/src/net/torvald/terrarum/mapdrawer/TilesDrawer.kt
index 0ef3a6ae6..74e3ec7b3 100644
--- a/src/net/torvald/terrarum/mapdrawer/TilesDrawer.kt
+++ b/src/net/torvald/terrarum/mapdrawer/TilesDrawer.kt
@@ -25,6 +25,7 @@ import java.util.*
 object TilesDrawer {
     private val world: GameWorld = Terrarum.ingame.world
     private val TILE_SIZE = FeaturesDrawer.TILE_SIZE
+    private val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
 
     var tilesTerrain: SpriteSheet = SpriteSheet("./assets/graphics/terrain/terrain.tga", TILE_SIZE, TILE_SIZE)
         private set // Slick has some weird quirks with PNG's transparency. I'm using 32-bit targa here.
@@ -310,25 +311,21 @@ object TilesDrawer {
                     if ((mode == WALL || mode == TERRAIN) &&  // not an air tile
                         (thisTile ?: 0) != Tile.AIR) {
                     // check if light level of nearby or this tile is illuminated
-                        if ( LightmapRenderer.getLowestRGB(x, y) ?: 0 >= tileDrawLightThreshold ||
-                             LightmapRenderer.getLowestRGB(x - 1, y) ?: 0 >= tileDrawLightThreshold ||
-                             LightmapRenderer.getLowestRGB(x + 1, y) ?: 0 >= tileDrawLightThreshold ||
-                             LightmapRenderer.getLowestRGB(x, y - 1) ?: 0 >= tileDrawLightThreshold ||
-                             LightmapRenderer.getLowestRGB(x, y + 1) ?: 0 >= tileDrawLightThreshold ||
-                             LightmapRenderer.getLowestRGB(x - 1, y - 1) ?: 0 >= tileDrawLightThreshold ||
-                             LightmapRenderer.getLowestRGB(x + 1, y + 1) ?: 0 >= tileDrawLightThreshold ||
-                             LightmapRenderer.getLowestRGB(x + 1, y - 1) ?: 0 >= tileDrawLightThreshold ||
-                             LightmapRenderer.getLowestRGB(x - 1, y + 1) ?: 0 >= tileDrawLightThreshold) {
+                        if ( LightmapRenderer.getHighestRGB(x, y) ?: 0 >= tileDrawLightThreshold ||
+                             LightmapRenderer.getHighestRGB(x - 1, y) ?: 0 >= tileDrawLightThreshold ||
+                             LightmapRenderer.getHighestRGB(x + 1, y) ?: 0 >= tileDrawLightThreshold ||
+                             LightmapRenderer.getHighestRGB(x, y - 1) ?: 0 >= tileDrawLightThreshold ||
+                             LightmapRenderer.getHighestRGB(x, y + 1) ?: 0 >= tileDrawLightThreshold ||
+                             LightmapRenderer.getHighestRGB(x - 1, y - 1) ?: 0 >= tileDrawLightThreshold ||
+                             LightmapRenderer.getHighestRGB(x + 1, y + 1) ?: 0 >= tileDrawLightThreshold ||
+                             LightmapRenderer.getHighestRGB(x + 1, y - 1) ?: 0 >= tileDrawLightThreshold ||
+                             LightmapRenderer.getHighestRGB(x - 1, y + 1) ?: 0 >= tileDrawLightThreshold) {
                                 // blackness
-                                /*if (zeroTileCounter > 0) {
-                                    g.color = Color.black
-                                    g.fillRect(
-                                        (x - zeroTileCounter) * TILE_SIZE.toFloat(), y * TILE_SIZE.toFloat(),
-                                        zeroTileCounter * TILE_SIZE.toFloat(), TILE_SIZE.toFloat()
-                                    )
-                                    g.color = Color.white
+                                if (zeroTileCounter > 0) {
+                                    /* unable to do anything */
+
                                     zeroTileCounter = 0
-                                }*/
+                                }
 
 
                                 val nearbyTilesInfo: Int
@@ -370,7 +367,19 @@ object TilesDrawer {
                         } // end if (is illuminated)
                         else {
                             zeroTileCounter++
-                            drawTile(mode, x, y, 1, 0) // black patch
+                            //drawTile(mode, x, y, 1, 0) // black patch
+                            GL11.glColor4f(0f, 0f, 0f, 1f)
+
+                            GL11.glTexCoord2f(0f, 0f)
+                            GL11.glVertex3f(x * TILE_SIZE.toFloat(), y * TILE_SIZE.toFloat(), 0f)
+                            GL11.glTexCoord2f(0f, 0f + TILE_SIZE)
+                            GL11.glVertex3f(x * TILE_SIZE.toFloat(), (y + 1) * TILE_SIZE.toFloat(), 0f)
+                            GL11.glTexCoord2f(0f + TILE_SIZE, 0f + TILE_SIZE)
+                            GL11.glVertex3f((x + 1) * TILE_SIZE.toFloat(), (y + 1) * TILE_SIZE.toFloat(), 0f)
+                            GL11.glTexCoord2f(0f + TILE_SIZE, 0f)
+                            GL11.glVertex3f((x + 1) * TILE_SIZE.toFloat(), y * TILE_SIZE.toFloat(), 0f)
+
+                            GL11.glColor4f(1f, 1f, 1f, 1f)
                         }
                     } // end if (not an air)
                 } catch (e: NullPointerException) {