Generalised BlockLayer

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

@@ -1,110 +1,14 @@
 package net.torvald.terrarum.gameworld
 
 import com.badlogic.gdx.utils.Disposable
-import net.torvald.terrarum.App.printdbg
-import net.torvald.terrarum.serialise.toUint
-import net.torvald.unsafe.UnsafeHelper
-import net.torvald.unsafe.UnsafePtr
 
 /**
- * Memory layout:
- * ```
- *  a7 a6 a5 a4 a3 a2 a1 a0 | aF aE aD aC aB aA a9 a8 ||
- * ```
- * where a_n is a tile number
- *
- * Original version Created by minjaesong on 2016-01-17.
- * Unsafe version Created by minjaesong on 2019-06-08.
- *
- * Note to self: refrain from using shorts--just do away with two bytes: different system have different endianness
+ * Created by minjaesong on 2023-10-10.
  */
-open class BlockLayer(val width: Int, val height: Int) : Disposable {
-    // for some reason, all the efforts of saving the memory space were futile.
+interface BlockLayer : Disposable {
 
-    // using unsafe pointer gets you 100 fps, whereas using directbytebuffer gets you 90
-    internal val ptr: UnsafePtr = UnsafeHelper.allocate(width * height * BYTES_PER_BLOCK)
+    val bytesPerBlock: Long
+    fun unsafeToBytes(x: Int, y: Int): ByteArray
+    fun unsafeSetTile(x: Int, y: Int, bytes: ByteArray)
 
-    val ptrDestroyed: Boolean
-        get() = ptr.destroyed
-
-    init {
-        ptr.fillWith(0)
-    }
-
-    /**
-     * @param data Byte array representation of the layer
-     */
-    constructor(width: Int, height: Int, data: ByteArray) : this(width, height) {
-        TODO()
-        data.forEachIndexed { index, byte -> UnsafeHelper.unsafe.putByte(ptr.ptr + index, byte) }
-    }
-
-    /**
-     * Returns an iterator over stored bytes.
-     *
-     * @return an Iterator.
-     */
-    fun bytesIterator(): Iterator<Byte> {
-        return object : Iterator<Byte> {
-            private var iteratorCount = 0L
-            override fun hasNext(): Boolean {
-                return iteratorCount < width * height * BYTES_PER_BLOCK
-            }
-            override fun next(): Byte {
-                iteratorCount += 1
-                return ptr[iteratorCount - 1]
-            }
-        }
-    }
-
-    internal fun unsafeGetTile(x: Int, y: Int): Int {
-        val offset = BYTES_PER_BLOCK * (y * width + x)
-        val lsb = ptr[offset]
-        val msb = ptr[offset + 1]
-
-        return lsb.toUint() + msb.toUint().shl(8)
-    }
-
-    internal fun unsafeSetTile(x: Int, y: Int, tile: Int) {
-        val offset = BYTES_PER_BLOCK * (y * width + x)
-
-        val lsb = tile.and(0xff).toByte()
-        val msb = tile.ushr(8).and(0xff).toByte()
-
-
-//        try {
-            ptr[offset] = lsb
-            ptr[offset + 1] = msb
-//        }
-//        catch (e: IndexOutOfBoundsException) {
-//            printdbgerr(this, "IndexOutOfBoundsException: x = $x, y = $y; offset = $offset")
-//            throw e
-//        }
-    }
-
-    /**
-     * @param blockOffset Offset in blocks. BlockOffset of 0x100 is equal to ```layerPtr + 0x200```
-     */
-    /*internal fun unsafeSetTile(blockOffset: Long, tile: Int) {
-        val offset = BYTES_PER_BLOCK * blockOffset
-
-        val lsb = tile.and(0xff).toByte()
-        val msb = tile.ushr(8).and(0xff).toByte()
-
-        unsafe.putByte(layerPtr + offset, lsb)
-        unsafe.putByte(layerPtr + offset + 1, msb)
-    }*/
-
-    fun isInBound(x: Int, y: Int) = (x >= 0 && y >= 0 && x < width && y < height)
-
-    override fun dispose() {
-        ptr.destroy()
-        printdbg(this, "BlockLayer with ptr ($ptr) successfully freed")
-    }
-
-    override fun toString(): String = ptr.toString()
-
-    companion object {
-        @Transient val BYTES_PER_BLOCK = 2L
-    }
-}
+}

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

@@ -0,0 +1,126 @@
+package net.torvald.terrarum.gameworld
+
+import com.badlogic.gdx.utils.Disposable
+import net.torvald.terrarum.App.printdbg
+import net.torvald.terrarum.serialise.toUint
+import net.torvald.unsafe.UnsafeHelper
+import net.torvald.unsafe.UnsafePtr
+
+/**
+ * Memory layout:
+ * ```
+ *  a7 a6 a5 a4 a3 a2 a1 a0 | aF aE aD aC aB aA a9 a8 ||
+ * ```
+ * where a_n is a tile number
+ *
+ * Original version Created by minjaesong on 2016-01-17.
+ * Unsafe version Created by minjaesong on 2019-06-08.
+ *
+ * Note to self: refrain from using shorts--just do away with two bytes: different system have different endianness
+ */
+open class BlockLayerI16(val width: Int, val height: Int) : BlockLayer {
+    override val bytesPerBlock = BYTES_PER_BLOCK
+
+    // for some reason, all the efforts of saving the memory space were futile.
+
+    // using unsafe pointer gets you 100 fps, whereas using directbytebuffer gets you 90
+    internal val ptr: UnsafePtr = UnsafeHelper.allocate(width * height * BYTES_PER_BLOCK)
+
+    val ptrDestroyed: Boolean
+        get() = ptr.destroyed
+
+    init {
+        ptr.fillWith(0)
+    }
+
+    /**
+     * @param data Byte array representation of the layer
+     */
+    constructor(width: Int, height: Int, data: ByteArray) : this(width, height) {
+        TODO()
+        data.forEachIndexed { index, byte -> UnsafeHelper.unsafe.putByte(ptr.ptr + index, byte) }
+    }
+
+    /**
+     * Returns an iterator over stored bytes.
+     *
+     * @return an Iterator.
+     */
+    fun bytesIterator(): Iterator<Byte> {
+        return object : Iterator<Byte> {
+            private var iteratorCount = 0L
+            override fun hasNext(): Boolean {
+                return iteratorCount < width * height * BYTES_PER_BLOCK
+            }
+            override fun next(): Byte {
+                iteratorCount += 1
+                return ptr[iteratorCount - 1]
+            }
+        }
+    }
+
+    internal fun unsafeGetTile(x: Int, y: Int): Int {
+        val offset = BYTES_PER_BLOCK * (y * width + x)
+        val lsb = ptr[offset]
+        val msb = ptr[offset + 1]
+
+        return lsb.toUint() + msb.toUint().shl(8)
+    }
+
+    override fun unsafeToBytes(x: Int, y: Int): ByteArray {
+        val offset = BYTES_PER_BLOCK * (y * width + x)
+        val lsb = ptr[offset]
+        val msb = ptr[offset + 1]
+
+        return byteArrayOf(msb, lsb)
+    }
+
+    internal fun unsafeSetTile(x: Int, y: Int, tile: Int) {
+        val offset = BYTES_PER_BLOCK * (y * width + x)
+
+        val lsb = tile.and(0xff).toByte()
+        val msb = tile.ushr(8).and(0xff).toByte()
+
+
+//        try {
+            ptr[offset] = lsb
+            ptr[offset + 1] = msb
+//        }
+//        catch (e: IndexOutOfBoundsException) {
+//            printdbgerr(this, "IndexOutOfBoundsException: x = $x, y = $y; offset = $offset")
+//            throw e
+//        }
+    }
+
+    override fun unsafeSetTile(x: Int, y: Int, bytes: ByteArray) {
+        val offset = BYTES_PER_BLOCK * (y * width + x)
+        ptr[offset] = bytes[1]
+        ptr[offset + 1] = bytes[0]
+    }
+
+    /**
+     * @param blockOffset Offset in blocks. BlockOffset of 0x100 is equal to ```layerPtr + 0x200```
+     */
+    /*internal fun unsafeSetTile(blockOffset: Long, tile: Int) {
+        val offset = BYTES_PER_BLOCK * blockOffset
+
+        val lsb = tile.and(0xff).toByte()
+        val msb = tile.ushr(8).and(0xff).toByte()
+
+        unsafe.putByte(layerPtr + offset, lsb)
+        unsafe.putByte(layerPtr + offset + 1, msb)
+    }*/
+
+    fun isInBound(x: Int, y: Int) = (x >= 0 && y >= 0 && x < width && y < height)
+
+    override fun dispose() {
+        ptr.destroy()
+        printdbg(this, "BlockLayerI16 with ptr ($ptr) successfully freed")
+    }
+
+    override fun toString(): String = ptr.toString("BlockLayerI16")
+
+    companion object {
+        @Transient val BYTES_PER_BLOCK = 2L
+    }
+}

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

@@ -0,0 +1,126 @@
+package net.torvald.terrarum.gameworld
+
+import com.badlogic.gdx.utils.Disposable
+import net.torvald.terrarum.App
+import net.torvald.terrarum.serialise.toUint
+import net.torvald.unsafe.UnsafeHelper
+import net.torvald.unsafe.UnsafePtr
+
+/**
+ * Memory layout:
+ * ```
+ *  a7 a6 a5 a4 a3 a2 a1 a0 | aF aE aD aC aB aA a9 a8 | p7 p6 p5 p4 p3 p2 p1 p0 ||
+ * ```
+ * where a_n is a tile number, p_n is a placement index
+ * Created by minjaesong on 2023-10-10.
+ */
+class BlockLayerI16I8 (val width: Int, val height: Int) : BlockLayer {
+    override val bytesPerBlock = BYTES_PER_BLOCK
+
+    // for some reason, all the efforts of saving the memory space were futile.
+
+    // using unsafe pointer gets you 100 fps, whereas using directbytebuffer gets you 90
+    internal val ptr: UnsafePtr = UnsafeHelper.allocate(width * height * BYTES_PER_BLOCK)
+
+    val ptrDestroyed: Boolean
+        get() = ptr.destroyed
+
+    init {
+        ptr.fillWith(0)
+    }
+
+    /**
+     * @param data Byte array representation of the layer
+     */
+    constructor(width: Int, height: Int, data: ByteArray) : this(width, height) {
+        TODO()
+        data.forEachIndexed { index, byte -> UnsafeHelper.unsafe.putByte(ptr.ptr + index, byte) }
+    }
+
+    /**
+     * Returns an iterator over stored bytes.
+     *
+     * @return an Iterator.
+     */
+    fun bytesIterator(): Iterator<Byte> {
+        return object : Iterator<Byte> {
+            private var iteratorCount = 0L
+            override fun hasNext(): Boolean {
+                return iteratorCount < width * height * BYTES_PER_BLOCK
+            }
+            override fun next(): Byte {
+                iteratorCount += 1
+                return ptr[iteratorCount - 1]
+            }
+        }
+    }
+
+    internal fun unsafeGetTile(x: Int, y: Int): Pair<Int, Int> {
+        val offset = BYTES_PER_BLOCK * (y * width + x)
+        val lsb = ptr[offset]
+        val msb = ptr[offset + 1]
+        val placement = ptr[offset + 2]
+
+        return lsb.toUint() + msb.toUint().shl(8) to placement.toUint()
+    }
+
+    override fun unsafeToBytes(x: Int, y: Int): ByteArray {
+        val offset = BYTES_PER_BLOCK * (y * width + x)
+        val lsb = ptr[offset]
+        val msb = ptr[offset + 1]
+        val placement = ptr[offset + 2]
+
+        return byteArrayOf(msb, lsb, placement)
+    }
+
+    internal fun unsafeSetTile(x: Int, y: Int, tile: Int, placement: Int) {
+        val offset = BYTES_PER_BLOCK * (y * width + x)
+
+        val lsb = tile.and(0xff).toByte()
+        val msb = tile.ushr(8).and(0xff).toByte()
+
+
+//        try {
+        ptr[offset] = lsb
+        ptr[offset + 1] = msb
+        ptr[offset + 2] = placement.toByte()
+//        }
+//        catch (e: IndexOutOfBoundsException) {
+//            printdbgerr(this, "IndexOutOfBoundsException: x = $x, y = $y; offset = $offset")
+//            throw e
+//        }
+    }
+
+    override fun unsafeSetTile(x: Int, y: Int, bytes: ByteArray) {
+        val offset = BYTES_PER_BLOCK * (y * width + x)
+        ptr[offset] = bytes[1]
+        ptr[offset + 1] = bytes[0]
+        ptr[offset + 2] = bytes[2]
+    }
+
+    /**
+     * @param blockOffset Offset in blocks. BlockOffset of 0x100 is equal to ```layerPtr + 0x200```
+     */
+    /*internal fun unsafeSetTile(blockOffset: Long, tile: Int) {
+        val offset = BYTES_PER_BLOCK * blockOffset
+
+        val lsb = tile.and(0xff).toByte()
+        val msb = tile.ushr(8).and(0xff).toByte()
+
+        unsafe.putByte(layerPtr + offset, lsb)
+        unsafe.putByte(layerPtr + offset + 1, msb)
+    }*/
+
+    fun isInBound(x: Int, y: Int) = (x >= 0 && y >= 0 && x < width && y < height)
+
+    override fun dispose() {
+        ptr.destroy()
+        App.printdbg(this, "BlockLayerI16I8 with ptr ($ptr) successfully freed")
+    }
+
+    override fun toString(): String = ptr.toString("BlockLayerI16I8")
+
+    companion object {
+        @Transient val BYTES_PER_BLOCK = 3L
+    }
+}

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

@@ -7,22 +7,20 @@ import net.torvald.terrarum.*
 import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.blockproperties.Block
 import net.torvald.terrarum.blockproperties.Fluid
-import net.torvald.terrarum.concurrent.ThreadExecutor
 import net.torvald.terrarum.gameactors.ActorID
 import net.torvald.terrarum.gameitems.ItemID
 import net.torvald.terrarum.gameitems.isFluid
+import net.torvald.terrarum.gameitems.isOre
 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.utils.*
 import net.torvald.terrarum.weather.WeatherMixer
-import net.torvald.terrarum.weather.WeatherSchedule
 import net.torvald.terrarum.weather.Weatherbox
 import net.torvald.util.SortedArrayList
 import org.dyn4j.geometry.Vector2
 import java.util.*
-import kotlin.math.absoluteValue
 
 typealias BlockAddress = Long
 
@@ -40,8 +38,8 @@ class PhysicalStatus() {
  * Special version of GameWorld where everything, including layer data, are saved in a single JSON file (i.e. not chunked)
  */
 class SimpleGameWorld(width: Int, height: Int) : GameWorld(width, height) {
-    override lateinit var layerWall: BlockLayer
-    override lateinit var layerTerrain: BlockLayer
+    override lateinit var layerWall: BlockLayerI16
+    override lateinit var layerTerrain: BlockLayerI16
     constructor() : this(0, 0)
 }
 
@@ -83,12 +81,12 @@ open class GameWorld(
     }
 
     //layers
-    @Transient lateinit open var layerWall: BlockLayer
-    @Transient lateinit open var layerTerrain: BlockLayer
-    val layerOres = HashedOres() // damage to the block follows `terrainDamages`
+    @Transient lateinit open var layerWall: BlockLayerI16
+    @Transient lateinit open var layerTerrain: BlockLayerI16
+    @Transient lateinit open var layerOres: BlockLayerI16I8 // damage to the block follows `terrainDamages`
     val wallDamages = HashArray<Float>()
     val terrainDamages = HashArray<Float>()
-    val layerFluids = HashedFluidTypeAndFills()
+    val layerFluids = HashedFluidTypeAndFills() // TODO: chunk them using BlockLayerI32
 
 
 
@@ -201,8 +199,8 @@ open class GameWorld(
         this.spawnX = width / 2
         this.spawnY = 150
 
-        layerTerrain = BlockLayer(width, height)
-        layerWall = BlockLayer(width, height)
+        layerTerrain = BlockLayerI16(width, height)
+        layerWall = BlockLayerI16(width, height)
 
         // temperature layer: 2x2 is one cell
         //layerThermal = MapLayerHalfFloat(width, height, averageTemperature)
@@ -277,6 +275,7 @@ open class GameWorld(
     fun getLayer(index: Int) = when(index) {
         0 -> layerTerrain
         1 -> layerWall
+        2 -> layerOres
         else -> null//throw IllegalArgumentException("Unknown layer index: $index")
     }
 
@@ -549,6 +548,21 @@ open class GameWorld(
             throw IllegalArgumentException("illegal mode input: " + mode.toString())
     }
 
+    fun getTileFromOre(rawX: Int, rawY: Int): OrePlacement? {
+        val (x, y) = coerceXY(rawX, rawY)
+        val (tileNum, placement) = layerOres.unsafeGetTile(x, y)
+        val tileName = tileNumberToNameMap[tileNum.toLong()]
+        if (tileName == Block.AIR)
+            return null
+        else
+            return OrePlacement(tileName ?: Block.UPDATE, placement)
+    }
+
+    fun setTileOre(rawX: Int, rawY: Int, ore: ItemID, placement: Int) {
+        val (x, y) = coerceXY(rawX, rawY)
+        layerOres.unsafeSetTile(x, y, tileNameToNumberMap[ore]!!, placement)
+    }
+
     fun terrainIterator(): Iterator<ItemID> {
         return object : Iterator<ItemID> {