createtileatlas: fixing a mistake where non-47 blocks won't be rendered to atlas

src/net/torvald/terrarum/FuckingWorldRenderer.kt.unused

@@ -199,7 +199,7 @@ class Ingame(batch: SpriteBatch) : IngameInstance(batch) {
         private set
 
 
-    private val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
+    private val TILE_SIZEF = CreateTileAtlas.TILE_SIZE.toFloat()
 
     //////////////
     // GDX code //
@@ -485,8 +485,8 @@ class Ingame(batch: SpriteBatch) : IngameInstance(batch) {
 
                 // go to spawn position
                 player.setPosition(
-                        world.spawnX * FeaturesDrawer.TILE_SIZE.toDouble(),
+                        world.spawnX * CreateTileAtlas.TILE_SIZE.toDouble(),
-                        world.spawnY * FeaturesDrawer.TILE_SIZE.toDouble()
+                        world.spawnY * CreateTileAtlas.TILE_SIZE.toDouble()
                 )
 
                 addNewActor(player)
@@ -1214,18 +1214,18 @@ class Ingame(batch: SpriteBatch) : IngameInstance(batch) {
             min(// take min of normal position and wrapped (x < 0) position
                     (a.hitbox.centeredX - p.hitbox.centeredX).sqr() +
                     (a.hitbox.centeredY - p.hitbox.centeredY).sqr(),
-                    (a.hitbox.centeredX - p.hitbox.centeredX + world.width * FeaturesDrawer.TILE_SIZE).sqr() +
+                    (a.hitbox.centeredX - p.hitbox.centeredX + world.width * CreateTileAtlas.TILE_SIZE).sqr() +
                     (a.hitbox.centeredY - p.hitbox.centeredY).sqr(),
-                    (a.hitbox.centeredX - p.hitbox.centeredX - world.width * FeaturesDrawer.TILE_SIZE).sqr() +
+                    (a.hitbox.centeredX - p.hitbox.centeredX - world.width * CreateTileAtlas.TILE_SIZE).sqr() +
                     (a.hitbox.centeredY - p.hitbox.centeredY).sqr()
             )
     private fun distToCameraSqr(a: ActorWithBody) =
             min(
                     (a.hitbox.startX - WorldCamera.x).sqr() +
                     (a.hitbox.startY - WorldCamera.y).sqr(),
-                    (a.hitbox.startX - WorldCamera.x + world.width * FeaturesDrawer.TILE_SIZE).sqr() +
+                    (a.hitbox.startX - WorldCamera.x + world.width * CreateTileAtlas.TILE_SIZE).sqr() +
                     (a.hitbox.startY - WorldCamera.y).sqr(),
-                    (a.hitbox.startX - WorldCamera.x - world.width * FeaturesDrawer.TILE_SIZE).sqr() +
+                    (a.hitbox.startX - WorldCamera.x - world.width * CreateTileAtlas.TILE_SIZE).sqr() +
                     (a.hitbox.startY - WorldCamera.y).sqr()
             )
 

src/net/torvald/terrarum/Terrarum.kt

@@ -20,6 +20,7 @@ import net.torvald.terrarum.gameactors.Actor
 import net.torvald.terrarum.gameactors.ActorID
 import net.torvald.terrarum.imagefont.TinyAlphNum
 import net.torvald.terrarum.itemproperties.ItemCodex
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 import net.torvald.terrarum.worlddrawer.WorldCamera
 import net.torvald.terrarumsansbitmap.gdx.GameFontBase
@@ -476,16 +477,16 @@ object Terrarum : Screen {
         get() = WorldCamera.y + (Gdx.input.y - Gdx.input.deltaY) / (ingame?.screenZoom ?: 1f).toDouble()
     /** Position of the cursor in the world */
     @JvmStatic val mouseTileX: Int
-        get() = (mouseX / FeaturesDrawer.TILE_SIZE).floorInt()
+        get() = (mouseX / CreateTileAtlas.TILE_SIZE).floorInt()
     /** Position of the cursor in the world */
     @JvmStatic val mouseTileY: Int
-        get() = (mouseY / FeaturesDrawer.TILE_SIZE).floorInt()
+        get() = (mouseY / CreateTileAtlas.TILE_SIZE).floorInt()
     /** Position of the cursor in the world */
     @JvmStatic val oldMouseTileX: Int
-        get() = (oldMouseX / FeaturesDrawer.TILE_SIZE).floorInt()
+        get() = (oldMouseX / CreateTileAtlas.TILE_SIZE).floorInt()
     /** Position of the cursor in the world */
     @JvmStatic val oldMouseTileY: Int
-        get() = (oldMouseY / FeaturesDrawer.TILE_SIZE).floorInt()
+        get() = (oldMouseY / CreateTileAtlas.TILE_SIZE).floorInt()
     inline val mouseScreenX: Int
         get() = Gdx.input.x
     inline val mouseScreenY: Int

src/net/torvald/terrarum/TitleScreen.kt

@@ -29,7 +29,7 @@ import net.torvald.terrarum.modulebasegame.ui.UITitleRemoConYaml
 import net.torvald.terrarum.modulebasegame.weather.WeatherMixer
 import net.torvald.terrarum.serialise.ReadLayerData
 import net.torvald.terrarum.ui.UICanvas
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.LightmapRenderer
 import net.torvald.terrarum.worlddrawer.WorldCamera
 import java.io.FileInputStream
@@ -75,7 +75,7 @@ class TitleScreen(val batch: SpriteBatch) : Screen {
 
 
 
-            val tileSize = FeaturesDrawer.TILE_SIZE.toFloat()
+            val tileSize = CreateTileAtlas.TILE_SIZE.toFloat()
             val catmullRomTension = 0f
 
             // pan camera
@@ -122,7 +122,7 @@ class TitleScreen(val batch: SpriteBatch) : Screen {
 
     private lateinit var worldFBO: FrameBuffer
 
-    private val TILE_SIZE = FeaturesDrawer.TILE_SIZE
+    private val TILE_SIZE = CreateTileAtlas.TILE_SIZE
     private val TILE_SIZEF = TILE_SIZE.toFloat()
 
     private fun loadThingsWhileIntroIsVisible() {
@@ -141,7 +141,7 @@ class TitleScreen(val batch: SpriteBatch) : Screen {
             while (!BlockCodex[demoWorld.getTileFromTerrain(tileXPos, travelDownCounter)].isSolid) {
                 travelDownCounter += 4
             }
-            travelDownCounter * FeaturesDrawer.TILE_SIZE.toFloat()
+            travelDownCounter * CreateTileAtlas.TILE_SIZE.toFloat()
         }
 
 
@@ -149,7 +149,7 @@ class TitleScreen(val batch: SpriteBatch) : Screen {
             init {
                 setHitboxDimension(2, 2, 0, 0)
                 hitbox.setPosition(
-                        HQRNG().nextInt(demoWorld.width) * FeaturesDrawer.TILE_SIZE.toDouble(),
+                        HQRNG().nextInt(demoWorld.width) * CreateTileAtlas.TILE_SIZE.toDouble(),
                         0.0 // Y pos: placeholder; camera AI will take it over
                 )
                 isNoClip = true

src/net/torvald/terrarum/blockstats/BlockStats.kt

@@ -1,14 +1,13 @@
 package net.torvald.terrarum.blockstats
 
+import com.jme3.math.FastMath
+import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.gameworld.GameWorld
 import net.torvald.terrarum.gameworld.MapLayer
-import net.torvald.terrarum.worlddrawer.BlocksDrawer
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
-import net.torvald.terrarum.Terrarum
-import com.jme3.math.FastMath
 import net.torvald.terrarum.modulebasegame.Ingame
-
+import net.torvald.terrarum.worlddrawer.BlocksDrawer
-import java.util.Arrays
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
+import java.util.*
 
 /**
  * Created by minjaesong on 2016-02-01.
@@ -17,7 +16,7 @@ object BlockStats {
 
     private val tilestat = ShortArray(GameWorld.TILES_SUPPORTED)
 
-    private val TSIZE = FeaturesDrawer.TILE_SIZE
+    private val TSIZE = CreateTileAtlas.TILE_SIZE
 
     /**
      * Update tile stats from tiles on screen

src/net/torvald/terrarum/gameactors/ActorWBMovable.kt

@@ -11,6 +11,7 @@ import net.torvald.terrarum.gameworld.BlockAddress
 import net.torvald.terrarum.gameworld.GameWorld
 import net.torvald.terrarum.modulebasegame.gameactors.ActorHumanoid
 import net.torvald.terrarum.realestate.LandUtil
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 import net.torvald.terrarum.worlddrawer.WorldCamera
 import net.torvald.terrarumsansbitmap.gdx.TextureRegionPack
@@ -1621,8 +1622,8 @@ open class ActorWBMovable(renderOrder: RenderOrder, val immobileBody: Boolean =
         @Transient const val COLLISION_KNOCKBACK_GIVER = 4 // mobs
         @Transient const val COLLISION_KNOCKBACK_TAKER = 5 // benevolent NPCs
 
-        @Transient val TILE_SIZE = FeaturesDrawer.TILE_SIZE
+        @Transient val TILE_SIZE = CreateTileAtlas.TILE_SIZE
-        @Transient val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
+        @Transient val TILE_SIZEF = CreateTileAtlas.TILE_SIZE.toFloat()
 
         private fun div16TruncateToMapWidth(x: Int): Int {
             if (x < 0)

src/net/torvald/terrarum/gamecontroller/IngameController.kt

@@ -14,6 +14,7 @@ import net.torvald.terrarum.gameworld.fmod
 import net.torvald.terrarum.itemproperties.GameItem
 import net.torvald.terrarum.itemproperties.ItemCodex
 import net.torvald.terrarum.modulebasegame.Ingame
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 import net.torvald.terrarum.worlddrawer.WorldCamera
 
@@ -38,10 +39,10 @@ class IngameController(val ingame: Ingame) : InputAdapter() {
         get() = WorldCamera.y + Gdx.input.y / (ingame.screenZoom)
     /** currently pointing tile coordinate */
     val mouseTileX: Int
-        get() = (mouseX / FeaturesDrawer.TILE_SIZE).floorInt()
+        get() = (mouseX / CreateTileAtlas.TILE_SIZE).floorInt()
     /** currently pointing tile coordinate */
     val mouseTileY: Int
-        get() = (mouseY / FeaturesDrawer.TILE_SIZE).floorInt()
+        get() = (mouseY / CreateTileAtlas.TILE_SIZE).floorInt()
 
     init {
         if (Controllers.getControllers().size == 0) {

src/net/torvald/terrarum/modulebasegame/BuildingMaker.kt

@@ -26,7 +26,7 @@ import net.torvald.terrarum.serialise.toLittleShort
 import net.torvald.terrarum.serialise.toULittle48
 import net.torvald.terrarum.ui.UICanvas
 import net.torvald.terrarum.ui.UINSMenu
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer.TILE_SIZE
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas.TILE_SIZE
 import net.torvald.terrarum.worlddrawer.LightmapRenderer
 import net.torvald.terrarum.worlddrawer.WorldCamera
 import net.torvald.terrarumsansbitmap.gdx.TextureRegionPack

src/net/torvald/terrarum/modulebasegame/Ingame.kt

@@ -29,6 +29,7 @@ import net.torvald.terrarum.modulebasegame.worldgenerator.RoguelikeRandomiser
 import net.torvald.terrarum.modulebasegame.worldgenerator.WorldGenerator
 import net.torvald.terrarum.ui.ConsoleWindow
 import net.torvald.terrarum.ui.UICanvas
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 import net.torvald.terrarum.worlddrawer.LightmapRenderer
 import net.torvald.terrarum.worlddrawer.WorldCamera
@@ -144,7 +145,7 @@ open class Ingame(batch: SpriteBatch) : IngameInstance(batch) {
         internal set
 
 
-    private val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
+    private val TILE_SIZEF = CreateTileAtlas.TILE_SIZE.toFloat()
 
     //////////////
     // GDX code //
@@ -432,8 +433,8 @@ open class Ingame(batch: SpriteBatch) : IngameInstance(batch) {
             if (gameLoadMode == GameLoadMode.CREATE_NEW) {
                 // go to spawn position
                 actorNowPlaying?.setPosition(
-                        world.spawnX * FeaturesDrawer.TILE_SIZE.toDouble(),
+                        world.spawnX * CreateTileAtlas.TILE_SIZE.toDouble(),
-                        world.spawnY * FeaturesDrawer.TILE_SIZE.toDouble()
+                        world.spawnY * CreateTileAtlas.TILE_SIZE.toDouble()
                 )
             }
 
@@ -700,18 +701,18 @@ open class Ingame(batch: SpriteBatch) : IngameInstance(batch) {
             min(// take min of normal position and wrapped (x < 0) position
                     (a.hitbox.centeredX - p.hitbox.centeredX).sqr() +
                     (a.hitbox.centeredY - p.hitbox.centeredY).sqr(),
-                    (a.hitbox.centeredX - p.hitbox.centeredX + world.width * FeaturesDrawer.TILE_SIZE).sqr() +
+                    (a.hitbox.centeredX - p.hitbox.centeredX + world.width * CreateTileAtlas.TILE_SIZE).sqr() +
                     (a.hitbox.centeredY - p.hitbox.centeredY).sqr(),
-                    (a.hitbox.centeredX - p.hitbox.centeredX - world.width * FeaturesDrawer.TILE_SIZE).sqr() +
+                    (a.hitbox.centeredX - p.hitbox.centeredX - world.width * CreateTileAtlas.TILE_SIZE).sqr() +
                     (a.hitbox.centeredY - p.hitbox.centeredY).sqr()
             )
     private fun distToCameraSqr(a: ActorWithBody) =
             min(
                     (a.hitbox.startX - WorldCamera.x).sqr() +
                     (a.hitbox.startY - WorldCamera.y).sqr(),
-                    (a.hitbox.startX - WorldCamera.x + world.width * FeaturesDrawer.TILE_SIZE).sqr() +
+                    (a.hitbox.startX - WorldCamera.x + world.width * CreateTileAtlas.TILE_SIZE).sqr() +
                     (a.hitbox.startY - WorldCamera.y).sqr(),
-                    (a.hitbox.startX - WorldCamera.x - world.width * FeaturesDrawer.TILE_SIZE).sqr() +
+                    (a.hitbox.startX - WorldCamera.x - world.width * CreateTileAtlas.TILE_SIZE).sqr() +
                     (a.hitbox.startY - WorldCamera.y).sqr()
             )
 

src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt

@@ -15,10 +15,7 @@ import net.torvald.terrarum.modulebasegame.gameactors.ParticleBase
 import net.torvald.terrarum.modulebasegame.gameworld.GameWorldExtension
 import net.torvald.terrarum.modulebasegame.weather.WeatherMixer
 import net.torvald.terrarum.ui.UICanvas
-import net.torvald.terrarum.worlddrawer.BlocksDrawer
+import net.torvald.terrarum.worlddrawer.*
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
-import net.torvald.terrarum.worlddrawer.LightmapRenderer
-import net.torvald.terrarum.worlddrawer.WorldCamera
 import javax.swing.JFileChooser
 
 /**
@@ -589,7 +586,7 @@ object IngameRenderer {
 
     }
 
-    private val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
+    private val TILE_SIZEF = CreateTileAtlas.TILE_SIZE.toFloat()
 
     fun dispose() {
         fboRGB.dispose()

src/net/torvald/terrarum/modulebasegame/console/ImportLayerData.kt

@@ -5,6 +5,7 @@ import net.torvald.terrarum.console.ConsoleCommand
 import net.torvald.terrarum.console.Echo
 import net.torvald.terrarum.modulebasegame.gameworld.GameWorldExtension
 import net.torvald.terrarum.serialise.ReadLayerDataZip
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 import java.io.File
 
@@ -24,8 +25,8 @@ object ImportLayerData : ConsoleCommand {
 
         Terrarum.ingame!!.world = GameWorldExtension(1, layerData, 0, 0, 0) // FIXME null TIME_T for the (partial) test to pass
         Terrarum.ingame!!.actorNowPlaying?.setPosition(
-                (Terrarum.ingame!!.world).spawnY * FeaturesDrawer.TILE_SIZE.toDouble(),
+                (Terrarum.ingame!!.world).spawnY * CreateTileAtlas.TILE_SIZE.toDouble(),
-                (Terrarum.ingame!!.world).spawnX * FeaturesDrawer.TILE_SIZE.toDouble()
+                (Terrarum.ingame!!.world).spawnX * CreateTileAtlas.TILE_SIZE.toDouble()
         )
 
         Echo("Successfully loaded ${args[1]}")

src/net/torvald/terrarum/modulebasegame/console/Teleport.kt

@@ -1,12 +1,12 @@
 package net.torvald.terrarum.modulebasegame.console
 
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.console.ConsoleCommand
 import net.torvald.terrarum.console.Echo
 import net.torvald.terrarum.console.EchoError
-import net.torvald.terrarum.modulebasegame.Ingame
 import net.torvald.terrarum.gameactors.ActorWBMovable
+import net.torvald.terrarum.modulebasegame.Ingame
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 
 /**
  * Created by minjaesong on 2016-01-24.
@@ -19,8 +19,8 @@ internal object Teleport : ConsoleCommand {
             val x: Int
             val y: Int
             try {
-                x = args[1].toInt() * FeaturesDrawer.TILE_SIZE + FeaturesDrawer.TILE_SIZE / 2
+                x = args[1].toInt() * CreateTileAtlas.TILE_SIZE + CreateTileAtlas.TILE_SIZE / 2
-                y = args[2].toInt() * FeaturesDrawer.TILE_SIZE + FeaturesDrawer.TILE_SIZE / 2
+                y = args[2].toInt() * CreateTileAtlas.TILE_SIZE + CreateTileAtlas.TILE_SIZE / 2
             }
             catch (e: NumberFormatException) {
                 EchoError("Teleport: wrong number input.")
@@ -86,8 +86,8 @@ internal object Teleport : ConsoleCommand {
             val x: Int
             val y: Int
             try {
-                x = args[3].toInt() * FeaturesDrawer.TILE_SIZE + FeaturesDrawer.TILE_SIZE / 2
+                x = args[3].toInt() * CreateTileAtlas.TILE_SIZE + CreateTileAtlas.TILE_SIZE / 2
-                y = args[4].toInt() * FeaturesDrawer.TILE_SIZE + FeaturesDrawer.TILE_SIZE / 2
+                y = args[4].toInt() * CreateTileAtlas.TILE_SIZE + CreateTileAtlas.TILE_SIZE / 2
                 val actorID = args[1].toInt()
 
                 if (Terrarum.ingame!!.getActorByID(actorID) !is ActorWBMovable) {

src/net/torvald/terrarum/modulebasegame/debuggerapp/ActorValueTracker.kt

@@ -1,14 +1,16 @@
 package net.torvald.terrarum.modulebasegame.debuggerapp
 
-import net.torvald.terrarum.*
-import net.torvald.terrarum.gameactors.ActorValue
 import net.torvald.terrarum.Terrarum
+import net.torvald.terrarum.ccM
+import net.torvald.terrarum.ccW
+import net.torvald.terrarum.ccY
 import net.torvald.terrarum.console.Echo
-import net.torvald.terrarum.modulebasegame.console.SetAV
 import net.torvald.terrarum.gameactors.Actor
-import net.torvald.terrarum.modulebasegame.Ingame
+import net.torvald.terrarum.gameactors.ActorValue
 import net.torvald.terrarum.gameactors.ActorWBMovable
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
+import net.torvald.terrarum.modulebasegame.Ingame
+import net.torvald.terrarum.modulebasegame.console.SetAV
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import java.awt.BorderLayout
 import java.awt.GridLayout
 import java.awt.event.MouseAdapter
@@ -164,8 +166,8 @@ class ActorValueTracker constructor() : JFrame() {
 
         if (actor != null) {
             sb.append("toString: ${actor!!}\n")
-            sb.append("X: ${actor!!.hitbox.canonicalX} (${(actor!!.hitbox.canonicalX / FeaturesDrawer.TILE_SIZE).toInt()})\n")
+            sb.append("X: ${actor!!.hitbox.canonicalX} (${(actor!!.hitbox.canonicalX / CreateTileAtlas.TILE_SIZE).toInt()})\n")
-            sb.append("Y: ${actor!!.hitbox.canonicalY} (${(actor!!.hitbox.canonicalY / FeaturesDrawer.TILE_SIZE).toInt()})")
+            sb.append("Y: ${actor!!.hitbox.canonicalY} (${(actor!!.hitbox.canonicalY / CreateTileAtlas.TILE_SIZE).toInt()})")
 
             avPosArea.text = "$sb"
             sb.setLength(0) // clear stringbuffer

src/net/torvald/terrarum/modulebasegame/gameactors/ParticleBase.kt

@@ -10,7 +10,7 @@ import net.torvald.terrarum.blockproperties.BlockCodex
 import net.torvald.terrarum.floorInt
 import net.torvald.terrarum.gameactors.Actor
 import net.torvald.terrarum.gameactors.Hitbox
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer.TILE_SIZE
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas.TILE_SIZE
 import org.dyn4j.geometry.Vector2
 
 /**

src/net/torvald/terrarum/modulebasegame/gameactors/PlayerBuilderCynthia.kt

@@ -4,7 +4,7 @@ import net.torvald.terrarum.ModMgr
 import net.torvald.terrarum.gameactors.AVKey
 import net.torvald.terrarum.gameactors.ActorWBMovable
 import net.torvald.terrarum.gameactors.ai.NullAI
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarumsansbitmap.gdx.TextureRegionPack
 
 /**
@@ -31,7 +31,7 @@ object PlayerBuilderCynthia {
 
         p.setHitboxDimension(15, p.actorValue.getAsInt(AVKey.BASEHEIGHT) ?: ActorHumanoid.BASE_HEIGHT, 9, 0)
 
-        p.setPosition(4096.0 * FeaturesDrawer.TILE_SIZE, 300.0 * FeaturesDrawer.TILE_SIZE)
+        p.setPosition(4096.0 * CreateTileAtlas.TILE_SIZE, 300.0 * CreateTileAtlas.TILE_SIZE)
 
 
 

src/net/torvald/terrarum/modulebasegame/gameactors/PlayerBuilderTestSubject1.kt

@@ -3,6 +3,7 @@ package net.torvald.terrarum.modulebasegame.gameactors
 import net.torvald.spriteanimation.SpriteAnimation
 import net.torvald.terrarum.ModMgr
 import net.torvald.terrarum.gameactors.AVKey
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 
 /**
@@ -28,7 +29,7 @@ object PlayerBuilderTestSubject1 {
         p.reassembleSprite(p.sprite!!)
         p.setHitboxDimension(15, p.actorValue.getAsInt(AVKey.BASEHEIGHT) ?: ActorHumanoid.BASE_HEIGHT, 21, 0)
 
-        p.setPosition(3.0 * FeaturesDrawer.TILE_SIZE, 3.0 * FeaturesDrawer.TILE_SIZE)
+        p.setPosition(3.0 * CreateTileAtlas.TILE_SIZE, 3.0 * CreateTileAtlas.TILE_SIZE)
 
 
         PlayerBuilderSigrid.fillTestInventory(p.inventory)

src/net/torvald/terrarum/modulebasegame/gameworld/WorldSimulator.kt

@@ -1,18 +1,14 @@
 package net.torvald.terrarum.modulebasegame.gameworld
 
-import com.badlogic.gdx.Input
 import com.badlogic.gdx.graphics.Color
 import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.AppLoader.printdbg
 import net.torvald.terrarum.Terrarum
-import net.torvald.terrarum.blockproperties.Block
-import net.torvald.terrarum.roundInt
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 import net.torvald.terrarum.blockproperties.BlockCodex
 import net.torvald.terrarum.blockproperties.Fluid
-import net.torvald.terrarum.gamecontroller.KeyToggler
 import net.torvald.terrarum.gameworld.FluidType
 import net.torvald.terrarum.modulebasegame.gameactors.ActorHumanoid
+import net.torvald.terrarum.roundInt
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 
 /**
  * Created by minjaesong on 2016-08-03.
@@ -59,8 +55,8 @@ object WorldSimulator {
         //printdbg(this, "============================")
 
         if (p != null) {
-            updateXFrom = p.hitbox.centeredX.div(FeaturesDrawer.TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundInt()
+            updateXFrom = p.hitbox.centeredX.div(CreateTileAtlas.TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundInt()
-            updateYFrom = p.hitbox.centeredY.div(FeaturesDrawer.TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundInt()
+            updateYFrom = p.hitbox.centeredY.div(CreateTileAtlas.TILE_SIZE).minus(FLUID_UPDATING_SQUARE_RADIUS).roundInt()
             updateXTo = updateXFrom + DOUBLE_RADIUS
             updateYTo = updateYFrom + DOUBLE_RADIUS
         }

src/net/torvald/terrarum/modulebasegame/weather/WeatherMixer.kt

@@ -20,7 +20,7 @@ import net.torvald.terrarum.modulebasegame.gameworld.GameWorldExtension
 import net.torvald.terrarum.modulebasegame.gameworld.WorldTime
 import net.torvald.terrarum.modulebasegame.worldgenerator.WorldGenerator
 import net.torvald.terrarum.utils.JsonFetcher
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.WorldCamera
 import java.io.File
 import java.util.*
@@ -146,7 +146,7 @@ internal object WeatherMixer : RNGConsumer {
          .|         = // parallax of -1
          -+ <- 0.0  =
          */
-        val parallax: Float = (parallaxZeroPos - WorldCamera.gdxCamY.div(FeaturesDrawer.TILE_SIZE.toFloat())) / parallaxDomainSize
+        val parallax: Float = (parallaxZeroPos - WorldCamera.gdxCamY.div(CreateTileAtlas.TILE_SIZE.toFloat())) / parallaxDomainSize
 
 
         // draw skybox to provided graphics instance

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

@@ -12,7 +12,7 @@ import net.torvald.terrarum.gameworld.GameWorld
 import net.torvald.terrarum.modulebasegame.Ingame
 import net.torvald.terrarum.modulebasegame.gameworld.GameWorldExtension
 import net.torvald.terrarum.modulebasegame.ui.ItemSlotImageFactory
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.LightmapRenderer
 import net.torvald.terrarum.worlddrawer.WorldCamera
 
@@ -86,13 +86,13 @@ class BasicDebugInfoWindow : UICanvas() {
                                          + ccG
                                          + "${hitbox?.startX}"
                                          + " ("
-                                         + "${(hitbox?.startX?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+                                         + "${(hitbox?.startX?.div(CreateTileAtlas.TILE_SIZE))?.toInt()}"
                                          + ")")
             printLineColumn(batch, 2, 1, "endX "
                                          + ccG
                                          + "${hitbox?.endX}"
                                          + " ("
-                                         + "${(hitbox?.endX?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+                                         + "${(hitbox?.endX?.div(CreateTileAtlas.TILE_SIZE))?.toInt()}"
                                          + ")")
             printLineColumn(batch, 3, 1, "camX "
                                          + ccG
@@ -101,13 +101,13 @@ class BasicDebugInfoWindow : UICanvas() {
                                          + ccG
                                          + "${hitbox?.startY}"
                                          + " ("
-                                         + "${(hitbox?.startY?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+                                         + "${(hitbox?.startY?.div(CreateTileAtlas.TILE_SIZE))?.toInt()}"
                                          + ")")
             printLineColumn(batch, 2, 2, "endY "
                                          + ccG
                                          + "${hitbox?.endY}"
                                          + " ("
-                                         + "${(hitbox?.endY?.div(FeaturesDrawer.TILE_SIZE))?.toInt()}"
+                                         + "${(hitbox?.endY?.div(CreateTileAtlas.TILE_SIZE))?.toInt()}"
                                          + ")")
             printLineColumn(batch, 3, 2, "camY "
                                          + ccG

src/net/torvald/terrarum/worlddrawer/BlocksDrawerNew.kt

@@ -32,8 +32,8 @@ internal object BlocksDrawer {
 
     var world: GameWorld = GameWorld.makeNullWorld()
 
-    private val TILE_SIZE = FeaturesDrawer.TILE_SIZE
+    private val TILE_SIZE = CreateTileAtlas.TILE_SIZE
-    private val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
+    private val TILE_SIZEF = CreateTileAtlas.TILE_SIZE.toFloat()
 
     /**
      * Widths of the tile atlases must have exactly the same width (height doesn't matter)

src/net/torvald/terrarum/worlddrawer/BlocksDrawer_old.kt

@@ -25,8 +25,8 @@ object BlocksDrawerOLD {
     lateinit var world: GameWorld
 
 
-    private val TILE_SIZE = FeaturesDrawer.TILE_SIZE
+    private val TILE_SIZE = CreateTileAtlas.TILE_SIZE
-    private val TILE_SIZEF = FeaturesDrawer.TILE_SIZE.toFloat()
+    private val TILE_SIZEF = CreateTileAtlas.TILE_SIZE.toFloat()
 
     // TODO modular
     //val tilesTerrain = SpriteSheet(ModMgr.getPath("basegame", "blocks/terrain.tga.gz"), TILE_SIZE, TILE_SIZE) // 64 MB

src/net/torvald/terrarum/worlddrawer/CreateTileAtlas.kt

@@ -10,7 +10,6 @@ import net.torvald.terrarum.blockproperties.BlockCodex
 import net.torvald.terrarum.blockproperties.Fluid
 import net.torvald.terrarum.gameworld.GameWorld
 import net.torvald.terrarum.toInt
-import net.torvald.terrarum.worlddrawer.FeaturesDrawer.TILE_SIZE
 import kotlin.math.roundToInt
 
 /**
@@ -25,8 +24,12 @@ import kotlin.math.roundToInt
  */
 object CreateTileAtlas {
 
-    const val TILES_IN_X = 256
+    const val MAX_TEX_SIZE = 4096
-    
+    const val TILE_SIZE = 16
+    const val TILES_IN_X = MAX_TEX_SIZE / TILE_SIZE
+
+    private val TOTAL_TILES = TILES_IN_X * TILES_IN_X
+
     lateinit var atlas: Pixmap
     lateinit var atlasAutumn: Pixmap
     lateinit var atlasWinter: Pixmap
@@ -246,11 +249,14 @@ object CreateTileAtlas {
     }
 
     private fun drawToAtlantes(pixmap: Pixmap, tilesCount: Int) {
+        if (atlasCursor >= TOTAL_TILES) {
+            throw Error("Too much tiles for $MAX_TEX_SIZE texture size: $atlasCursor")
+        }
+
         val seasonal = pixmap.width == pixmap.height && pixmap.width == 14 * TILE_SIZE
         val txOfPixmap = pixmap.width / TILE_SIZE
-        val tyOfPixmap = pixmap.height / TILE_SIZE
         for (i in 0 until tilesCount) {
-            //printdbg(this, "Rendering to atlas, tile# $atlasCursor")
+            //printdbg(this, "Rendering to atlas, tile# $atlasCursor, tilesCount = $tilesCount, seasonal = $seasonal")
 
             // different texture for different seasons (224x224)
             if (seasonal) {
@@ -263,7 +269,7 @@ object CreateTileAtlas {
             }
             else {
                 val i = if (i < 41) i else i + 1 // to compensate the discontinuity between 40th and 41st tile
-                _drawToAtlantes(pixmap, atlasCursor, i % txOfPixmap, i / tyOfPixmap, 0)
+                _drawToAtlantes(pixmap, atlasCursor, i % txOfPixmap, i / txOfPixmap, 0)
                 atlasCursor += 1
             }
         }
@@ -285,6 +291,8 @@ object CreateTileAtlas {
             val sourceX = srcTileX * TILE_SIZE
             val sourceY = srcTileY * TILE_SIZE
 
+            //if (mode == 1) printdbg(this, "atlaspos: ($atlasX, $atlasY), srcpos: ($sourceX, $sourceY), srcpixmap = $pixmap")
+
             when (mode) {
                 1 -> atlas.drawPixmap(pixmap, sourceX, sourceY, TILE_SIZE, TILE_SIZE, atlasX, atlasY, TILE_SIZE, TILE_SIZE)
                 2 -> atlasAutumn.drawPixmap(pixmap, sourceX, sourceY, TILE_SIZE, TILE_SIZE, atlasX, atlasY, TILE_SIZE, TILE_SIZE)

src/net/torvald/terrarum/worlddrawer/FeaturesDrawer.kt

@@ -10,6 +10,7 @@ import net.torvald.terrarum.blockproperties.Block
 import net.torvald.terrarum.blockstats.BlockStats
 import net.torvald.terrarum.fillRect
 import net.torvald.terrarum.gameworld.GameWorld
+import net.torvald.terrarum.worlddrawer.CreateTileAtlas.TILE_SIZE
 
 /**
  * Created by minjaesong on 2015-12-31.
@@ -17,7 +18,7 @@ import net.torvald.terrarum.gameworld.GameWorld
 object FeaturesDrawer {
     lateinit var world: GameWorld
 
-    const val TILE_SIZE = 16
+    //const val TILE_SIZE = CreateTileAtlas.TILE_SIZE
 
     private val ENV_COLTEMP_LOWEST = 5500
     private val ENV_COLTEMP_HIGHEST = 7500

src/net/torvald/terrarum/worlddrawer/LightmapRenderer.kt

@@ -40,9 +40,9 @@ object LightmapRendererOld {
     // TODO resize(int, int) -aware
 
     val LIGHTMAP_WIDTH = (Terrarum.ingame?.ZOOM_MINIMUM ?: 1f).inv().times(Terrarum.WIDTH)
-            .div(FeaturesDrawer.TILE_SIZE).ceil() + overscan_open * 2 + 3
+            .div(CreateTileAtlas.TILE_SIZE).ceil() + overscan_open * 2 + 3
     val LIGHTMAP_HEIGHT = (Terrarum.ingame?.ZOOM_MINIMUM ?: 1f).inv().times(Terrarum.HEIGHT)
-            .div(FeaturesDrawer.TILE_SIZE).ceil() + overscan_open * 2 + 3
+            .div(CreateTileAtlas.TILE_SIZE).ceil() + overscan_open * 2 + 3
 
     /**
      * Float value, 1.0 for 1023
@@ -53,8 +53,8 @@ object LightmapRendererOld {
 
     private val AIR = Block.AIR
 
-    private const val TILE_SIZE = FeaturesDrawer.TILE_SIZE
+    private const val TILE_SIZE = CreateTileAtlas.TILE_SIZE
-    private val DRAW_TILE_SIZE: Float = FeaturesDrawer.TILE_SIZE / IngameRenderer.lightmapDownsample
+    private val DRAW_TILE_SIZE: Float = CreateTileAtlas.TILE_SIZE / IngameRenderer.lightmapDownsample
 
     // color model related constants
     const val MUL = 1024 // modify this to 1024 to implement 30-bit RGB

src/net/torvald/terrarum/worlddrawer/LightmapRendererNew.kt

@@ -33,7 +33,7 @@ import net.torvald.terrarum.realestate.LandUtil
  * own ingame renderer
  */
 object LightmapRenderer {
-    private const val TILE_SIZE = FeaturesDrawer.TILE_SIZE
+    private const val TILE_SIZE = CreateTileAtlas.TILE_SIZE
 
     private var world: GameWorld = GameWorld.makeNullWorld()
     private lateinit var lightCalcShader: ShaderProgram
@@ -91,7 +91,7 @@ object LightmapRenderer {
 
     private val AIR = Block.AIR
 
-    val DRAW_TILE_SIZE: Float = FeaturesDrawer.TILE_SIZE / IngameRenderer.lightmapDownsample
+    val DRAW_TILE_SIZE: Float = CreateTileAtlas.TILE_SIZE / IngameRenderer.lightmapDownsample
 
     // color model related constants
     const val MUL = 1024 // modify this to 1024 to implement 30-bit RGB

src/net/torvald/terrarum/worlddrawer/WorldCamera.kt

@@ -11,7 +11,7 @@ import org.dyn4j.geometry.Vector2
  * Created by minjaesong on 2016-12-30.
  */
 object WorldCamera {
-    private val TILE_SIZE = FeaturesDrawer.TILE_SIZE
+    private val TILE_SIZE = CreateTileAtlas.TILE_SIZE
 
     var x: Int = 0 // left position
         private set