F3: chunk flag view

src/net/torvald/terrarum/gameworld/GameWorld.kt

@@ -14,6 +14,8 @@ import net.torvald.terrarum.itemproperties.ItemRemapTable
 import net.torvald.terrarum.itemproperties.ItemTable
 import net.torvald.terrarum.modulebasegame.gameactors.IngamePlayer
 import net.torvald.terrarum.realestate.LandUtil
+import net.torvald.terrarum.realestate.LandUtil.CHUNK_H
+import net.torvald.terrarum.realestate.LandUtil.CHUNK_W
 import net.torvald.terrarum.utils.*
 import net.torvald.terrarum.weather.WeatherMixer
 import net.torvald.terrarum.weather.Weatherbox
@@ -81,14 +83,14 @@ open class GameWorld(
     }
 
     //layers
-    @Transient lateinit open var layerWall: BlockLayerI16
-    @Transient lateinit open var layerTerrain: BlockLayerI16
-    @Transient lateinit open var layerOres: BlockLayerI16I8 // damage to the block follows `terrainDamages`
-    @Transient lateinit open var layerFluids: BlockLayerI16F16
+    @Transient open lateinit var layerWall: BlockLayerI16
+    @Transient open lateinit var layerTerrain: BlockLayerI16
+    @Transient open lateinit var layerOres: BlockLayerI16I8 // damage to the block follows `terrainDamages`
+    @Transient open lateinit var layerFluids: BlockLayerI16F16
     val wallDamages = HashArray<Float>()
     val terrainDamages = HashArray<Float>()
 
-
+    @Transient open lateinit var chunkFlags: Array<ByteArray>
 
     //val layerThermal: MapLayerHalfFloat // in Kelvins
     //val layerFluidPressure: MapLayerHalfFloat // (milibar - 1000)
@@ -220,6 +222,7 @@ open class GameWorld(
         layerWall = BlockLayerI16(width, height)
         layerOres = BlockLayerI16I8(width, height)
         layerFluids = BlockLayerI16F16(width, height)
+        chunkFlags = Array(height / CHUNK_H) { ByteArray(width / CHUNK_W) }
 
         // temperature layer: 2x2 is one cell
         //layerThermal = MapLayerHalfFloat(width, height, averageTemperature)
@@ -818,6 +821,10 @@ open class GameWorld(
         }
 
         val DEFAULT_GRAVITATION = Vector2(0.0, 9.8)
+
+        @Transient const val CHUNK_NULL = 0x00.toByte()
+        @Transient const val CHUNK_GENERATING = 0x01.toByte()
+        @Transient const val CHUNK_LOADED = 0x02.toByte()
     }
 
     open fun updateWorldTime(delta: Float) {

src/net/torvald/terrarum/modulebasegame/serialise/WriteSavegame.kt

@@ -8,6 +8,7 @@ import net.torvald.terrarum.gameworld.BlockLayerI16
 import net.torvald.terrarum.gameworld.BlockLayerI16F16
 import net.torvald.terrarum.gameworld.BlockLayerI16I8
 import net.torvald.terrarum.gameworld.GameWorld
+import net.torvald.terrarum.gameworld.GameWorld.Companion.CHUNK_LOADED
 import net.torvald.terrarum.langpack.Lang
 import net.torvald.terrarum.modulebasegame.FancyWorldReadLoadScreen
 import net.torvald.terrarum.modulebasegame.IngameRenderer
@@ -21,6 +22,7 @@ import net.torvald.terrarum.worlddrawer.WorldCamera
 import java.io.File
 import java.io.Reader
 import java.util.logging.Level
+import kotlin.experimental.or
 
 /**
  * It's your responsibility to create a new VirtualDisk if your save is new, and create a backup for modifying existing save.
@@ -145,10 +147,12 @@ object LoadSavegame {
         val worldDiskSavegameInfo = ByteArray64Reader(worldDisk.getFile(SAVEGAMEINFO)!!.bytes, Common.CHARSET)
         val world = ReadWorld(worldDiskSavegameInfo, worldDisk.diskFile)
 
+
         world.layerTerrain = BlockLayerI16(world.width, world.height)
         world.layerWall = BlockLayerI16(world.width, world.height)
         world.layerOres = BlockLayerI16I8(world.width, world.height)
         world.layerFluids = BlockLayerI16F16(world.width, world.height)
+        world.chunkFlags = Array(world.height / LandUtil.CHUNK_H) { ByteArray(world.width / LandUtil.CHUNK_W) }
 
         newIngame.world = world // must be set before the loadscreen, otherwise the loadscreen will try to read from the NullWorld which is already destroyed
         newIngame.worldDisk =  VDUtil.readDiskArchive(worldDisk.diskFile, Level.INFO)
@@ -183,6 +187,7 @@ object LoadSavegame {
             newIngame.gameLoadInfoPayload = worldParam
             newIngame.gameLoadMode = TerrarumIngame.GameLoadMode.LOAD_FROM
 
+            printdbg(this, "World dim: ${world.width}x${world.height}, ${world.width / LandUtil.CHUNK_W}x${world.height / LandUtil.CHUNK_H}")
 
             // load all the world blocklayer chunks
             val cw = LandUtil.CHUNK_W
@@ -196,9 +201,11 @@ object LoadSavegame {
                     loadscreen.addMessage(Lang["MENU_IO_LOADING"])
 
                     val chunkFile = newIngame.worldDisk.getFile(0x1_0000_0000L or layer.toLong().shl(24) or chunk)!!
-                    val chunkXY = LandUtil.chunkNumToChunkXY(world, chunk.toInt())
+                    val (cx, cy) = LandUtil.chunkNumToChunkXY(world, chunk.toInt())
 
-                    ReadWorld.decodeChunkToLayer(chunkFile.getContent(), worldLayer[layer]!!, chunkXY.x, chunkXY.y)
+                    ReadWorld.decodeChunkToLayer(chunkFile.getContent(), worldLayer[layer]!!, cx, cy)
+
+                    world.chunkFlags[cy][cx] = world.chunkFlags[cy][cx] or CHUNK_LOADED
                 }
                 loadscreen.progress.getAndAdd(1)
             }

src/net/torvald/terrarum/ui/BasicDebugInfoWindow.kt

@@ -12,6 +12,7 @@ import net.torvald.terrarum.*
 import net.torvald.terrarum.Terrarum.mouseTileX
 import net.torvald.terrarum.Terrarum.mouseTileY
 import net.torvald.terrarum.TerrarumAppConfiguration.TILE_SIZE
+import net.torvald.terrarum.TerrarumAppConfiguration.TILE_SIZED
 import net.torvald.terrarum.audio.*
 import net.torvald.terrarum.audio.dsp.*
 import net.torvald.terrarum.controller.TerrarumController
@@ -21,6 +22,9 @@ import net.torvald.terrarum.imagefont.TinyAlphNum
 import net.torvald.terrarum.modulebasegame.IngameRenderer
 import net.torvald.terrarum.modulebasegame.TerrarumIngame
 import net.torvald.terrarum.modulebasegame.ui.ItemSlotImageFactory
+import net.torvald.terrarum.realestate.LandUtil.CHUNK_H
+import net.torvald.terrarum.realestate.LandUtil.CHUNK_W
+import net.torvald.terrarum.serialise.toUint
 import net.torvald.terrarum.weather.WeatherDirBox
 import net.torvald.terrarum.weather.WeatherMixer
 import net.torvald.terrarum.weather.WeatherStateBox
@@ -72,10 +76,12 @@ class BasicDebugInfoWindow : UICanvas() {
     private val KEY_TIMERS = Input.Keys.T // + CONTROL_LEFT
     private val KEY_WEATHERS = Input.Keys.W // + CONTROL_LEFT
     private val KEY_AUDIOMIXER = Input.Keys.M // + CONTROL_LEFT
+    private val KEY_CHUNKS = Input.Keys.C // + CONTROL_LEFT
 
     private var showTimers = false
     private var showWeatherInfo = false
     private var showAudioMixer = false
+    private var showChunks = false
 
     override fun show() {
         ingame = Terrarum.ingame
@@ -133,6 +139,7 @@ class BasicDebugInfoWindow : UICanvas() {
         showTimers = showTimers xor (Gdx.input.isKeyJustPressed(KEY_TIMERS) && Gdx.input.isKeyPressed(Keys.CONTROL_LEFT))
         showWeatherInfo = showWeatherInfo xor (Gdx.input.isKeyJustPressed(KEY_WEATHERS) && Gdx.input.isKeyPressed(Keys.CONTROL_LEFT))
         showAudioMixer = showAudioMixer xor (Gdx.input.isKeyJustPressed(KEY_AUDIOMIXER) && Gdx.input.isKeyPressed(Keys.CONTROL_LEFT))
+        showChunks = showChunks xor (Gdx.input.isKeyJustPressed(KEY_CHUNKS) && Gdx.input.isKeyPressed(Keys.CONTROL_LEFT))
 
         App.audioMixer.masterTrack.filters[2].bypass = !showAudioMixer
 
@@ -140,6 +147,35 @@ class BasicDebugInfoWindow : UICanvas() {
         if (showTimers) drawTimers(batch)
         if (showWeatherInfo) drawWeatherInfo(batch)
         if (showAudioMixer) drawAudioMixer(batch)
+        if (showChunks) drawChunks(batch)
+    }
+
+
+    private val chunkStatColours = arrayOf(
+        Color(0x23252899),
+        Color(0x11bb2299),
+        Color(0xffffff99.toInt())
+    )
+    private val chunkStatCurrentChunk = Color(0xff008899.toInt())
+
+    private fun drawChunks(batch: SpriteBatch) {
+        val xo = 224
+        val yo = 78
+
+
+        world?.let { world ->
+            val ppos = ingame?.actorNowPlaying?.centrePosVector
+            val pcx = (ppos?.x?.div(TILE_SIZED)?.fmod(world.width.toDouble())?.div(CHUNK_W)?.toInt() ?: -999)
+            val pcy = (ppos?.y?.div(TILE_SIZED)?.fmod(world.height.toDouble())?.div(CHUNK_H)?.toInt() ?: -999)
+            
+            for (y in 0 until world.height / CHUNK_H) {
+                for (x in 0 until world.width / CHUNK_W) {
+                    val chunkStat = world.chunkFlags[y][x].toUint()
+                    batch.color = if (pcx == x && pcy == y) chunkStatCurrentChunk else chunkStatColours[chunkStat]
+                    Toolkit.fillArea(batch, xo + 3*x, yo + 3*y, 2, 2)
+                }
+            }
+        }
 
     }