Renamed AppLoader into App

2026-06-09 10:04:05 +09:00 · 2021-09-09 09:48:33 +09:00
parent c3dd005fb2
commit 8f834fe869
116 changed files with 796 additions and 850 deletions
--- a/src/net/torvald/terrarum/modulebasegame/BuildingMaker.kt
+++ b/src/net/torvald/terrarum/modulebasegame/BuildingMaker.kt
@@ -15,7 +15,6 @@ import net.torvald.terrarum.gameitem.ItemID
 import net.torvald.terrarum.gameworld.GameWorld
 import net.torvald.terrarum.modulebasegame.gameactors.ActorHumanoid
 import net.torvald.terrarum.gameworld.WorldTime
-import net.torvald.terrarum.modulebasegame.ui.Notification
 import net.torvald.terrarum.modulebasegame.ui.UIBuildingMakerBlockChooser
 import net.torvald.terrarum.modulebasegame.ui.UIBuildingMakerPenMenu
 import net.torvald.terrarum.modulebasegame.ui.UIPaletteSelector
@@ -284,11 +283,11 @@ class BuildingMaker(batch: SpriteBatch) : IngameInstance(batch) {
        uiToolbox.isVisible = true
        uiToolbox.invocationArgument = arrayOf(this)

-        uiPaletteSelector.setPosition(AppLoader.screenSize.screenW - uiPaletteSelector.width, 0)
+        uiPaletteSelector.setPosition(App.scr.width - uiPaletteSelector.width, 0)
        uiPaletteSelector.isVisible = true

        notifier.setPosition(
-                (AppLoader.screenSize.screenW - notifier.width) / 2, AppLoader.screenSize.screenH - notifier.height)
+                (App.scr.width - notifier.width) / 2, App.scr.height - notifier.height)


        actorNowPlaying?.setPosition(512 * 16.0, 149 * 16.0)
@@ -318,22 +317,22 @@ class BuildingMaker(batch: SpriteBatch) : IngameInstance(batch) {

        var i = 0L
        while (updateAkku >= updateRate) {
-            AppLoader.measureDebugTime("Ingame.Update") { updateGame(updateRate) }
+            App.measureDebugTime("Ingame.Update") { updateGame(updateRate) }
            updateAkku -= updateRate
            i += 1
        }
-        AppLoader.setDebugTime("Ingame.UpdateCounter", i)
+        App.setDebugTime("Ingame.UpdateCounter", i)

        // render? just do it anyway
-        AppLoader.measureDebugTime("Ingame.Render") { renderGame() }
-        AppLoader.setDebugTime("Ingame.Render - (Light + Tiling)",
-                ((AppLoader.debugTimers["Ingame.Render"] as? Long) ?: 0) -
+        App.measureDebugTime("Ingame.Render") { renderGame() }
+        App.setDebugTime("Ingame.Render - (Light + Tiling)",
+                ((App.debugTimers["Ingame.Render"] as? Long) ?: 0) -
                (
-                        ((AppLoader.debugTimers["Renderer.Lanterns"] as? Long) ?: 0) +
-                        ((AppLoader.debugTimers["Renderer.LightPrecalc"] as? Long) ?: 0) +
-                        ((AppLoader.debugTimers["Renderer.LightRuns"] as? Long) ?: 0) +
-                        ((AppLoader.debugTimers["Renderer.LightToScreen"] as? Long) ?: 0) +
-                        ((AppLoader.debugTimers["Renderer.Tiling"] as? Long) ?: 0)
+                        ((App.debugTimers["Renderer.Lanterns"] as? Long) ?: 0) +
+                        ((App.debugTimers["Renderer.LightPrecalc"] as? Long) ?: 0) +
+                        ((App.debugTimers["Renderer.LightRuns"] as? Long) ?: 0) +
+                        ((App.debugTimers["Renderer.LightToScreen"] as? Long) ?: 0) +
+                        ((App.debugTimers["Renderer.Tiling"] as? Long) ?: 0)
                )
        )

@@ -364,19 +363,19 @@ class BuildingMaker(batch: SpriteBatch) : IngameInstance(batch) {

        // make pen work HERE
        // when LEFT mouse is down
-        if (!tappedOnUI && Gdx.input.isButtonPressed(AppLoader.getConfigInt("config_mouseprimary")) && !mouseOnUI) {
+        if (!tappedOnUI && Gdx.input.isButtonPressed(App.getConfigInt("config_mouseprimary")) && !mouseOnUI) {

            makePenWork(Terrarum.mouseTileX, Terrarum.mouseTileY)
            // TODO drag support using bresenham's algo
            //      for some reason it just doesn't work...
        }
-        else if (!uiPenMenu.isVisible && Gdx.input.isButtonPressed(AppLoader.getConfigInt("config_mousesecondary"))) {
+        else if (!uiPenMenu.isVisible && Gdx.input.isButtonPressed(App.getConfigInt("config_mousesecondary"))) {
            // open pen menu
            // position the menu to where the cursor is
            uiPenMenu.posX = Terrarum.mouseScreenX - uiPenMenu.width / 2
            uiPenMenu.posY = Terrarum.mouseScreenY - uiPenMenu.height / 2
-            uiPenMenu.posX = uiPenMenu.posX.coerceIn(0, AppLoader.screenSize.screenW - uiPenMenu.width)
-            uiPenMenu.posY = uiPenMenu.posY.coerceIn(0, AppLoader.screenSize.screenH - uiPenMenu.height)
+            uiPenMenu.posX = uiPenMenu.posX.coerceIn(0, App.scr.width - uiPenMenu.width)
+            uiPenMenu.posY = uiPenMenu.posY.coerceIn(0, App.scr.height - uiPenMenu.height)

            // actually open
            uiPenMenu.setAsOpen()
@@ -390,14 +389,14 @@ class BuildingMaker(batch: SpriteBatch) : IngameInstance(batch) {

        IngameRenderer.invoke(false, actorsRenderOverlay = if (showSelection) actorsRenderOverlay + essentialOverlays else essentialOverlays, uiContainer = uiContainer)

-        AppLoader.setDebugTime("Test.MarkerDrawCalls", _testMarkerDrawCalls)
+        App.setDebugTime("Test.MarkerDrawCalls", _testMarkerDrawCalls)
    }

    override fun resize(width: Int, height: Int) {
-        IngameRenderer.resize(AppLoader.screenSize.screenW, AppLoader.screenSize.screenH)
+        IngameRenderer.resize(App.scr.width, App.scr.height)
        uiToolbox.setPosition(0, 0)
        notifier.setPosition(
-                (AppLoader.screenSize.screenW - notifier.width) / 2, AppLoader.screenSize.screenH - notifier.height)
+                (App.scr.width - notifier.width) / 2, App.scr.height - notifier.height)

        println("[BuildingMaker] Resize event")
    }
@@ -554,12 +553,12 @@ class MovableWorldCamera(val parent: BuildingMaker) : ActorHumanoid(0, physProp

    // TODO resize-aware
    private var coerceInStart = Point2d(
-            (AppLoader.screenSize.screenW - hitbox.width) / 2.0,
-            (AppLoader.screenSize.screenH - hitbox.height) / 2.0
+            (App.scr.width - hitbox.width) / 2.0,
+            (App.scr.height - hitbox.height) / 2.0
    )
    private var coerceInEnd = Point2d(
-            parent.world.width * TILE_SIZE - (AppLoader.screenSize.screenW - hitbox.width) / 2.0,
-            parent.world.height * TILE_SIZE - (AppLoader.screenSize.screenH - hitbox.height) / 2.0
+            parent.world.width * TILE_SIZE - (App.scr.width - hitbox.width) / 2.0,
+            parent.world.height * TILE_SIZE - (App.scr.height - hitbox.height) / 2.0
    )

    override fun update(delta: Float) {
@@ -582,7 +581,7 @@ class MovableWorldCamera(val parent: BuildingMaker) : ActorHumanoid(0, physProp

 class YamlCommandExit : YamlInvokable {
    override fun invoke(args: Array<Any>) {
-        AppLoader.setScreen(TitleScreen(AppLoader.batch))
+        App.setScreen(TitleScreen(App.batch))
    }
 }

--- a/src/net/torvald/terrarum/modulebasegame/EntryPoint.kt
+++ b/src/net/torvald/terrarum/modulebasegame/EntryPoint.kt
@@ -1,8 +1,8 @@
 package net.torvald.terrarum.modulebasegame

 import net.torvald.terrarum.*
-import net.torvald.terrarum.AppLoader.IS_DEVELOPMENT_BUILD
-import net.torvald.terrarum.AppLoader.printdbg
+import net.torvald.terrarum.App.IS_DEVELOPMENT_BUILD
+import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.blockproperties.BlockProp
 import net.torvald.terrarum.gameitem.GameItem
 import net.torvald.terrarum.modulebasegame.gameitems.BlockBase
--- a/src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt
+++ b/src/net/torvald/terrarum/modulebasegame/IngameRenderer.kt
@@ -9,7 +9,7 @@ import com.badlogic.gdx.graphics.glutils.FrameBuffer
 import com.badlogic.gdx.graphics.glutils.ShaderProgram
 import com.badlogic.gdx.utils.Disposable
 import net.torvald.terrarum.*
-import net.torvald.terrarum.AppLoader.measureDebugTime
+import net.torvald.terrarum.App.measureDebugTime
 import net.torvald.terrarum.TerrarumAppConfiguration.TILE_SIZE
 import net.torvald.terrarum.TerrarumAppConfiguration.TILE_SIZEF
 import net.torvald.terrarum.gameactors.ActorWithBody
@@ -58,8 +58,8 @@ object IngameRenderer : Disposable {
    val shaderAtoGrey: ShaderProgram
    val shaderPassthru = SpriteBatch.createDefaultShader()

-    private val WIDTH = AppLoader.screenSize.screenW
-    private val HEIGHT = AppLoader.screenSize.screenH
+    private val WIDTH = App.scr.width
+    private val HEIGHT = App.scr.height
    private val WIDTHF = WIDTH.toFloat()
    private val HEIGHTF = HEIGHT.toFloat()

@@ -88,25 +88,25 @@ object IngameRenderer : Disposable {
    // these codes will run regardless of the invocation of the "initialise()" function
    // the "initialise()" function will also be called
    init {
-        shaderBlur = AppLoader.loadShaderFromFile("assets/blur.vert", "assets/blur.frag")
+        shaderBlur = App.loadShaderFromFile("assets/blur.vert", "assets/blur.frag")


-        if (AppLoader.getConfigBoolean("fxdither")) {
-            shaderBayer = AppLoader.loadShaderFromFile("assets/4096.vert", "assets/4096_bayer.frag")
+        if (App.getConfigBoolean("fxdither")) {
+            shaderBayer = App.loadShaderFromFile("assets/4096.vert", "assets/4096_bayer.frag")
            shaderBayer.bind()
            shaderBayer.setUniformf("rcount", 64f)
            shaderBayer.setUniformf("gcount", 64f)
            shaderBayer.setUniformf("bcount", 64f)
        }
        else {
-            shaderBayer = AppLoader.loadShaderFromFile("assets/4096.vert", "assets/passthrurgb.frag")
+            shaderBayer = App.loadShaderFromFile("assets/4096.vert", "assets/passthrurgb.frag")
        }


-        shaderBlendGlow = AppLoader.loadShaderFromFile("assets/blendGlow.vert", "assets/blendGlow.frag")
+        shaderBlendGlow = App.loadShaderFromFile("assets/blendGlow.vert", "assets/blendGlow.frag")

-        shaderRGBOnly = AppLoader.loadShaderFromFile("assets/4096.vert", "assets/rgbonly.frag")
-        shaderAtoGrey = AppLoader.loadShaderFromFile("assets/4096.vert", "assets/aonly.frag")
+        shaderRGBOnly = App.loadShaderFromFile("assets/4096.vert", "assets/rgbonly.frag")
+        shaderAtoGrey = App.loadShaderFromFile("assets/4096.vert", "assets/aonly.frag")


        if (!shaderBlendGlow.isCompiled) {
@@ -115,7 +115,7 @@ object IngameRenderer : Disposable {
        }


-        if (AppLoader.getConfigBoolean("fxdither")) {
+        if (App.getConfigBoolean("fxdither")) {
            if (!shaderBayer.isCompiled) {
                Gdx.app.log("shaderBayer", shaderBayer.log)
                exitProcess(1)
@@ -132,7 +132,7 @@ object IngameRenderer : Disposable {
     * actually matter */
    @JvmStatic fun initialise() {
        if (!initialisedExternally) {
-            AppLoader.disposableSingletonsPool.add(this)
+            App.disposableSingletonsPool.add(this)

            // also initialise these sinigletons
            BlocksDrawer
@@ -206,7 +206,7 @@ object IngameRenderer : Disposable {
        if (!gamePaused || newWorldLoadedLatch) {
            measureDebugTime("Renderer.ApparentLightRun") {
                // recalculate for even frames, or if the sign of the cam-x changed
-                if (AppLoader.GLOBAL_RENDER_TIMER % 3 == 0 || WorldCamera.x * oldCamX < 0 || newWorldLoadedLatch)
+                if (App.GLOBAL_RENDER_TIMER % 3 == 0 || WorldCamera.x * oldCamX < 0 || newWorldLoadedLatch)
                    LightmapRenderer.fireRecalculateEvent(actorsRenderBehind, actorsRenderFront, actorsRenderMidTop, actorsRenderMiddle, actorsRenderOverlay)

                oldCamX = WorldCamera.x
@@ -601,7 +601,7 @@ object IngameRenderer : Disposable {
     * Camera will be moved so that (newX, newY) would be sit on the top-left edge.
     */
    private fun setCameraPosition(newX: Float, newY: Float) {
-        camera.position.set((-newX + AppLoader.screenSize.halfScreenW).round(), (-newY + AppLoader.screenSize.halfScreenH).round(), 0f)
+        camera.position.set((-newX + App.scr.halfw).round(), (-newY + App.scr.halfh).round(), 0f)
        camera.update()
        batch.projectionMatrix = camera.combined
    }
--- a/src/net/torvald/terrarum/modulebasegame/TerrarumIngame.kt
+++ b/src/net/torvald/terrarum/modulebasegame/TerrarumIngame.kt
@@ -6,12 +6,10 @@ import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import net.torvald.EMDASH
 import net.torvald.terrarum.*
-import net.torvald.terrarum.AppLoader.*
+import net.torvald.terrarum.App.*
 import net.torvald.terrarum.TerrarumAppConfiguration.TILE_SIZE
 import net.torvald.terrarum.TerrarumAppConfiguration.TILE_SIZED
-import net.torvald.terrarum.blockproperties.BlockCodex
 import net.torvald.terrarum.blockproperties.BlockPropUtil
-import net.torvald.terrarum.blockproperties.WireCodex
 import net.torvald.terrarum.blockstats.BlockStats
 import net.torvald.terrarum.blockstats.MinimapComposer
 import net.torvald.terrarum.concurrent.ThreadExecutor
@@ -22,7 +20,6 @@ import net.torvald.terrarum.gameactors.AVKey
 import net.torvald.terrarum.gameactors.Actor
 import net.torvald.terrarum.gameactors.ActorWithBody
 import net.torvald.terrarum.gameactors.WireActor
-import net.torvald.terrarum.gameactors.faction.FactionCodex
 import net.torvald.terrarum.gamecontroller.IngameController
 import net.torvald.terrarum.gamecontroller.KeyToggler
 import net.torvald.terrarum.gameitem.GameItem
@@ -30,7 +27,6 @@ import net.torvald.terrarum.gameparticles.ParticleBase
 import net.torvald.terrarum.gameworld.GameWorld
 import net.torvald.terrarum.gameworld.WorldSimulator
 import net.torvald.terrarum.itemproperties.ItemCodex
-import net.torvald.terrarum.itemproperties.MaterialCodex
 import net.torvald.terrarum.modulebasegame.gameactors.*
 import net.torvald.terrarum.modulebasegame.gameactors.physicssolver.CollisionSolver
 import net.torvald.terrarum.modulebasegame.gameworld.GameEconomy
@@ -47,7 +43,6 @@ import net.torvald.terrarum.worlddrawer.BlocksDrawer
 import net.torvald.terrarum.worlddrawer.FeaturesDrawer
 import net.torvald.terrarum.worlddrawer.WorldCamera
 import net.torvald.util.CircularArray
-import org.khelekore.prtree.MBRConverter
 import org.khelekore.prtree.PRTree
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.math.roundToInt
@@ -68,7 +63,7 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
     * list of Actors that is sorted by Actors' referenceID
     */
    //val ACTORCONTAINER_INITIAL_SIZE = 64
-    val PARTICLES_MAX = AppLoader.getConfigInt("maxparticles")
+    val PARTICLES_MAX = App.getConfigInt("maxparticles")
    val particlesContainer = CircularArray<ParticleBase>(PARTICLES_MAX, true)
    val uiContainer = UIContainer()

@@ -86,14 +81,14 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
    companion object {
        /** Sets camera position so that (0,0) would be top-left of the screen, (width, height) be bottom-right. */
        fun setCameraPosition(batch: SpriteBatch, camera: Camera, newX: Float, newY: Float) {
-            camera.position.set((-newX + AppLoader.screenSize.halfScreenW).round(), (-newY + AppLoader.screenSize.halfScreenH).round(), 0f)
+            camera.position.set((-newX + App.scr.halfw).round(), (-newY + App.scr.halfh).round(), 0f)
            camera.update()
            batch.projectionMatrix = camera.combined
        }

-        fun getCanonicalTitle() = AppLoader.GAME_NAME +
+        fun getCanonicalTitle() = App.GAME_NAME +
                                  " $EMDASH F: ${Gdx.graphics.framesPerSecond}" +
-                                  if (AppLoader.IS_DEVELOPMENT_BUILD)
+                                  if (App.IS_DEVELOPMENT_BUILD)
                                      " (ΔF${Terrarum.updateRateStr})" +
                                      " $EMDASH M: J${Terrarum.memJavaHeap}M / N${Terrarum.memNativeHeap}M / U${Terrarum.memUnsafe}M / X${Terrarum.memXmx}M"
                                  else
@@ -287,12 +282,12 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
            printdbg(this, "loaded successfully.")
        }
        else {
-            AppLoader.getLoadScreen().addMessage("${AppLoader.GAME_NAME} version ${AppLoader.getVERSION_STRING()}")
-            AppLoader.getLoadScreen().addMessage("Creating new world")
+            App.getLoadScreen().addMessage("${App.GAME_NAME} version ${App.getVERSION_STRING()}")
+            App.getLoadScreen().addMessage("Creating new world")


            // init map as chosen size
-            val timeNow = AppLoader.getTIME_T()
+            val timeNow = App.getTIME_T()
            world = GameWorld(1, worldParams.width, worldParams.height, timeNow, timeNow, 0) // new game, so the creation time is right now
            gameworldIndices.add(world.worldIndex)
            world.extraFields["basegame.economy"] = GameEconomy()
@@ -322,7 +317,7 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {

            savegameArchive = VDUtil.createNewDisk(
                    1L shl 60,
-                    actorNowPlaying!!.actorValue.getAsString(AVKey.NAME) ?: "Player ${AppLoader.getTIME_T()}",
+                    actorNowPlaying!!.actorValue.getAsString(AVKey.NAME) ?: "Player ${App.getTIME_T()}",
                    Common.CHARSET
            )
        }
@@ -335,8 +330,8 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {

        // make controls work
        Gdx.input.inputProcessor = ingameController
-        if (AppLoader.gamepad != null) {
-            ingameController.gamepad = AppLoader.gamepad
+        if (App.gamepad != null) {
+            ingameController.gamepad = App.gamepad
        }

        // init console window
@@ -355,11 +350,11 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
        // quick bar
        uiQuickBar = UIQuickslotBar()
        uiQuickBar.isVisible = true
-        uiQuickBar.setPosition((AppLoader.screenSize.screenW - uiQuickBar.width) / 2, AppLoader.screenSize.tvSafeGraphicsHeight)
+        uiQuickBar.setPosition((App.scr.width - uiQuickBar.width) / 2, App.scr.tvSafeGraphicsHeight)

        // pie menu
        uiPieMenu = UIQuickslotPie()
-        uiPieMenu.setPosition(AppLoader.screenSize.halfScreenW, AppLoader.screenSize.halfScreenH)
+        uiPieMenu.setPosition(App.scr.halfw, App.scr.halfh)

        // vital metre
        // fill in getter functions by
@@ -374,14 +369,14 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
        uiWatchTierOne = UITierOneWatch()
        uiWatchTierOne.setAsAlwaysVisible()
        uiWatchTierOne.setPosition(
-                ((AppLoader.screenSize.screenW - AppLoader.screenSize.tvSafeActionWidth) - (uiQuickBar.posX + uiQuickBar.width) - uiWatchTierOne.width) / 2 + (uiQuickBar.posX + uiQuickBar.width),
-                AppLoader.screenSize.tvSafeGraphicsHeight + 8
+                ((App.scr.width - App.scr.tvSafeActionWidth) - (uiQuickBar.posX + uiQuickBar.width) - uiWatchTierOne.width) / 2 + (uiQuickBar.posX + uiQuickBar.width),
+                App.scr.tvSafeGraphicsHeight + 8
        )

        // basic watch-style notification bar (temperature, new mail)
        uiBasicInfo = UIBasicInfo()
        uiBasicInfo.setAsAlwaysVisible()
-        uiBasicInfo.setPosition((uiQuickBar.posX - uiBasicInfo.width - AppLoader.screenSize.tvSafeActionWidth) / 2 + AppLoader.screenSize.tvSafeActionWidth, uiWatchTierOne.posY)
+        uiBasicInfo.setPosition((uiQuickBar.posX - uiBasicInfo.width - App.scr.tvSafeActionWidth) / 2 + App.scr.tvSafeActionWidth, uiWatchTierOne.posY)



@@ -418,7 +413,7 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
        // these need to appear on top of any others
        uiContainer.add(notifier)

-        AppLoader.setDebugTime("Ingame.UpdateCounter", 0)
+        App.setDebugTime("Ingame.UpdateCounter", 0)

        // some sketchy test code here

@@ -435,7 +430,7 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
        // TODO actorsUnderMouse: support ROUNDWORLD
        val actorsUnderMouse: List<FixtureBase> = getActorsAt(Terrarum.mouseX, Terrarum.mouseY).filterIsInstance<FixtureBase>()
        if (actorsUnderMouse.size > 1) {
-            AppLoader.printdbgerr(this, "Multiple fixtures at world coord ${Terrarum.mouseX}, ${Terrarum.mouseY}")
+            App.printdbgerr(this, "Multiple fixtures at world coord ${Terrarum.mouseX}, ${Terrarum.mouseY}")
        }
        // scan for the one with non-null UI.
        // what if there's multiple of such fixtures? whatever, you are supposed to DISALLOW such situation.
@@ -521,7 +516,7 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {


        // define custom update rate
-        val updateRate = if (KeyToggler.isOn(Input.Keys.APOSTROPHE)) 1f / 8f else AppLoader.UPDATE_RATE
+        val updateRate = if (KeyToggler.isOn(Input.Keys.APOSTROPHE)) 1f / 8f else App.UPDATE_RATE

        // ASYNCHRONOUS UPDATE AND RENDER //

@@ -822,11 +817,11 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {

            val actors = actorContainerActive.size.toFloat()
            // set up indices
-            for (i in 0..AppLoader.THREAD_COUNT - 1) {
+            for (i in 0..App.THREAD_COUNT - 1) {
                ThreadExecutor.submit(
                        ThreadActorUpdate(
-                                actors.div(AppLoader.THREAD_COUNT).times(i).roundToInt(),
-                                actors.div(AppLoader.THREAD_COUNT).times(i + 1).roundToInt() - 1
+                                actors.div(App.THREAD_COUNT).times(i).roundToInt(),
+                                actors.div(App.THREAD_COUNT).times(i + 1).roundToInt() - 1
                        )
                )
            }
@@ -963,7 +958,7 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
    override fun addNewActor(actor: Actor?) {
        if (actor == null) return

-        if (AppLoader.IS_DEVELOPMENT_BUILD && theGameHasActor(actor.referenceID)) {
+        if (App.IS_DEVELOPMENT_BUILD && theGameHasActor(actor.referenceID)) {
            throw ReferencedActorAlreadyExistsException(actor)
        }
        else {
@@ -978,7 +973,7 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
    }

    fun activateDormantActor(actor: Actor) {
-        if (AppLoader.IS_DEVELOPMENT_BUILD && !isInactive(actor.referenceID)) {
+        if (App.IS_DEVELOPMENT_BUILD && !isInactive(actor.referenceID)) {
            /*if (isActive(actor.referenceID))
                throw Error("The actor $actor is already activated")
            else
@@ -1033,7 +1028,7 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
        //MegaRainGovernor.resize()


-        IngameRenderer.resize(AppLoader.screenSize.screenW, AppLoader.screenSize.screenH)
+        IngameRenderer.resize(App.scr.width, App.scr.height)


        if (gameInitialised) {
@@ -1045,8 +1040,8 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {
            // resize UIs

            notifier.setPosition(
-                    (AppLoader.screenSize.screenW - notifier.width) / 2, AppLoader.screenSize.screenH - notifier.height)
-            uiQuickBar.setPosition((AppLoader.screenSize.screenW - uiQuickBar.width) / 2, AppLoader.screenSize.tvSafeGraphicsHeight)
+                    (App.scr.width - notifier.width) / 2, App.scr.height - notifier.height)
+            uiQuickBar.setPosition((App.scr.width - uiQuickBar.width) / 2, App.scr.tvSafeGraphicsHeight)

            // inventory
            /*uiInventoryPlayer =
@@ -1058,10 +1053,10 @@ open class TerrarumIngame(batch: SpriteBatch) : IngameInstance(batch) {


            // basic watch-style notification bar (temperature, new mail)
-            uiBasicInfo.setPosition(AppLoader.screenSize.screenW - uiBasicInfo.width, 0)
+            uiBasicInfo.setPosition(App.scr.width - uiBasicInfo.width, 0)
            uiWatchTierOne.setPosition(
-                    ((AppLoader.screenSize.screenW - AppLoader.screenSize.tvSafeGraphicsWidth) - (uiQuickBar.posX + uiQuickBar.width) - uiWatchTierOne.width) / 2 + (uiQuickBar.posX + uiQuickBar.width),
-                    AppLoader.screenSize.tvSafeGraphicsHeight + 8
+                    ((App.scr.width - App.scr.tvSafeGraphicsWidth) - (uiQuickBar.posX + uiQuickBar.width) - uiWatchTierOne.width) / 2 + (uiQuickBar.posX + uiQuickBar.width),
+                    App.scr.tvSafeGraphicsHeight + 8
            )

        }
--- a/src/net/torvald/terrarum/modulebasegame/WorldgenLoadScreen.kt
+++ b/src/net/torvald/terrarum/modulebasegame/WorldgenLoadScreen.kt
@@ -4,7 +4,6 @@ import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.Pixmap
 import com.badlogic.gdx.graphics.Texture
 import net.torvald.terrarum.*
-import net.torvald.terrarum.blockproperties.BlockCodex
 import net.torvald.terrarum.gameworld.GameWorld
 import kotlin.math.roundToInt

@@ -18,7 +17,7 @@ class WorldgenLoadScreen(screenToBeLoaded: IngameInstance, private val worldwidt
    // a Class impl is chosen to make resize-handling easier, there's not much benefit making this a singleton anyway

    init {
-        AppLoader.disposableSingletonsPool.add(this)
+        App.disposableSingletonsPool.add(this)
    }

    override var screenToLoad: IngameInstance? = screenToBeLoaded
@@ -27,15 +26,15 @@ class WorldgenLoadScreen(screenToBeLoaded: IngameInstance, private val worldwidt

    companion object {
        private const val WIDTH_RATIO = 0.7
-        private const val PREVIEW_UPDATE_RATE = AppLoader.UPDATE_RATE
+        private const val PREVIEW_UPDATE_RATE = App.UPDATE_RATE

        private val COL_TERR = Color.WHITE
        private val COL_WALLED = Color(.5f, .5f, .5f, 1f)
        private val COL_AIR = Color.BLACK
    }

-    private val previewWidth = (AppLoader.screenSize.screenW * WIDTH_RATIO).roundToInt()
-    private val previewHeight = (AppLoader.screenSize.screenW * WIDTH_RATIO * worldheight / worldwidth).roundToInt()
+    private val previewWidth = (App.scr.width * WIDTH_RATIO).roundToInt()
+    private val previewHeight = (App.scr.width * WIDTH_RATIO * worldheight / worldwidth).roundToInt()

    private lateinit var previewPixmap: Pixmap
    private lateinit var previewTexture: Texture
@@ -66,18 +65,18 @@ class WorldgenLoadScreen(screenToBeLoaded: IngameInstance, private val worldwidt
        }


-        AppLoader.batch.inUse {
+        App.batch.inUse {
            it.color = Color.WHITE
-            val previewY = (AppLoader.screenSize.screenH - previewHeight.times(1.5f)).div(2f).round()
+            val previewY = (App.scr.height - previewHeight.times(1.5f)).div(2f).round()
            it.draw(previewTexture,
-                    (AppLoader.screenSize.screenW - previewWidth).div(2f).round(),
+                    (App.scr.width - previewWidth).div(2f).round(),
                    previewY
            )
            val text = messages.getHeadElem() ?: ""
-            AppLoader.fontGame.draw(it,
+            App.fontGame.draw(it,
                    text,
-                    (AppLoader.screenSize.screenW - AppLoader.fontGame.getWidth(text)).div(2f).round(),
-                    previewY + previewHeight + 98 - AppLoader.fontGame.lineHeight
+                    (App.scr.width - App.fontGame.getWidth(text)).div(2f).round(),
+                    previewY + previewHeight + 98 - App.fontGame.lineHeight
            )
        }

--- a/src/net/torvald/terrarum/modulebasegame/console/ExportAV.kt
+++ b/src/net/torvald/terrarum/modulebasegame/console/ExportAV.kt
@@ -1,6 +1,6 @@
 package net.torvald.terrarum.modulebasegame.console

-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.utils.JsonWriter
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.console.ConsoleCommand
@@ -21,7 +21,7 @@ internal object ExportAV : ConsoleCommand {

                JsonWriter.writeToFile(
                        player,
-                        AppLoader.defaultDir + "/Exports/" + args[1] + ".json")
+                        App.defaultDir + "/Exports/" + args[1] + ".json")

                Echo("ExportAV: exported to " + args[1] + ".json")
            }
--- a/src/net/torvald/terrarum/modulebasegame/console/ExportMap.kt
+++ b/src/net/torvald/terrarum/modulebasegame/console/ExportMap.kt
@@ -1,13 +1,12 @@
 package net.torvald.terrarum.modulebasegame.console

 import net.torvald.gdx.graphics.Cvec
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 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.utils.RasterWriter
-import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarum.worlddrawer.toRGBA
 import java.io.File
 import java.io.IOException
@@ -33,7 +32,7 @@ internal object ExportMap : ConsoleCommand {
            var mapDataPointer = 0

            for (tile in world.terrainIterator()) {
-                val colArray = AppLoader.tileMaker.terrainTileColourMap.get(tile)!!.toByteArray()
+                val colArray = App.tileMaker.terrainTileColourMap.get(tile)!!.toByteArray()

                for (i in 0..2) {
                    mapData[mapDataPointer + i] = colArray[i]
@@ -42,7 +41,7 @@ internal object ExportMap : ConsoleCommand {
                mapDataPointer += 3
            }

-            val dir = AppLoader.defaultDir + "/Exports/"
+            val dir = App.defaultDir + "/Exports/"
            val dirAsFile = File(dir)
            if (!dirAsFile.exists()) {
                dirAsFile.mkdir()
--- a/src/net/torvald/terrarum/modulebasegame/console/ExportMeta.kt
+++ b/src/net/torvald/terrarum/modulebasegame/console/ExportMeta.kt
@@ -1,7 +1,6 @@
 package net.torvald.terrarum.modulebasegame.console

-import com.badlogic.gdx.utils.Json
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.Terrarum.ingame
 import net.torvald.terrarum.console.ConsoleCommand
@@ -11,7 +10,6 @@ import net.torvald.terrarum.modulebasegame.gameactors.IngamePlayer
 import net.torvald.terrarum.serialise.WriteActor
 import net.torvald.terrarum.serialise.WriteMeta
 import net.torvald.terrarum.serialise.WriteWorld
-import net.torvald.terrarum.utils.JsonWriter
 import java.io.IOException

 /**
@@ -20,9 +18,9 @@ import java.io.IOException
 object ExportMeta : ConsoleCommand {
    override fun execute(args: Array<String>) {
        try {
-            val currentPlayTime_t = AppLoader.getTIME_T() - ingame!!.loadedTime_t
+            val currentPlayTime_t = App.getTIME_T() - ingame!!.loadedTime_t
            val str = WriteMeta(ingame!! as TerrarumIngame, currentPlayTime_t)
-            val writer = java.io.FileWriter(AppLoader.defaultDir + "/Exports/savegame.json", false)
+            val writer = java.io.FileWriter(App.defaultDir + "/Exports/savegame.json", false)
            writer.write(str)
            writer.close()
            Echo("Exportmeta: exported to savegame.json")
@@ -43,7 +41,7 @@ object ExportWorld : ConsoleCommand {
        if (args.size == 2) {
            try {
                val str = WriteWorld(ingame!! as TerrarumIngame)
-                val writer = java.io.FileWriter(AppLoader.defaultDir + "/Exports/${args[1]}.json", false)
+                val writer = java.io.FileWriter(App.defaultDir + "/Exports/${args[1]}.json", false)
                writer.write(str)
                writer.close()
                Echo("Exportworld: exported to ${args[1]}.json")
@@ -71,7 +69,7 @@ object ExportActor : ConsoleCommand {
                if (player == null) return

                val str = WriteActor(player as IngamePlayer)
-                val writer = java.io.FileWriter(AppLoader.defaultDir + "/Exports/${args[1]}.json", false)
+                val writer = java.io.FileWriter(App.defaultDir + "/Exports/${args[1]}.json", false)
                writer.write(str)
                writer.close()

--- a/src/net/torvald/terrarum/modulebasegame/console/GsonTest.kt
+++ b/src/net/torvald/terrarum/modulebasegame/console/GsonTest.kt
@@ -1,15 +1,5 @@
 package net.torvald.terrarum.modulebasegame.console

-import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.Terrarum
-import net.torvald.terrarum.console.ConsoleCommand
-import net.torvald.terrarum.console.Echo
-import net.torvald.terrarum.modulebasegame.TerrarumIngame
-import net.torvald.terrarum.utils.JsonWriter
-import java.io.BufferedWriter
-import java.io.FileWriter
-import java.io.IOException
-
 /**
 * Created by minjaesong on 2016-02-10.
 */
--- a/src/net/torvald/terrarum/modulebasegame/console/ImportWorld.kt
+++ b/src/net/torvald/terrarum/modulebasegame/console/ImportWorld.kt
@@ -1,13 +1,12 @@
 package net.torvald.terrarum.modulebasegame.console

-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.console.ConsoleCommand
 import net.torvald.terrarum.console.Echo
 import net.torvald.terrarum.modulebasegame.TerrarumIngame
 import net.torvald.terrarum.serialise.ReadActor
 import net.torvald.terrarum.serialise.ReadWorld
-import net.torvald.terrarum.serialise.WriteMeta
 import java.io.IOException

 /**
@@ -17,7 +16,7 @@ object ImportWorld : ConsoleCommand {
    override fun execute(args: Array<String>) {
        if (args.size == 2) {
            try {
-                val reader = java.io.FileReader(AppLoader.defaultDir + "/Exports/${args[1]}.json")
+                val reader = java.io.FileReader(App.defaultDir + "/Exports/${args[1]}.json")
                ReadWorld.readWorldAndSetNewWorld(Terrarum.ingame!! as TerrarumIngame, reader)
                Echo("Importworld: imported a world from ${args[1]}.json")
            }
@@ -40,7 +39,7 @@ object ImportActor : ConsoleCommand {
    override fun execute(args: Array<String>) {
        if (args.size == 2) {
            try {
-                val reader = java.io.FileReader(AppLoader.defaultDir + "/Exports/${args[1]}.json")
+                val reader = java.io.FileReader(App.defaultDir + "/Exports/${args[1]}.json")
                ReadActor.readActorAndAddToWorld(Terrarum.ingame!! as TerrarumIngame, reader)
                Echo("Importactor: imported an actor from ${args[1]}.json")
            }
--- a/src/net/torvald/terrarum/modulebasegame/console/Load.kt
+++ b/src/net/torvald/terrarum/modulebasegame/console/Load.kt
@@ -1,20 +1,16 @@
 package net.torvald.terrarum.modulebasegame.console

 import net.torvald.ELLIPSIS
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.ccC
 import net.torvald.terrarum.ccG
 import net.torvald.terrarum.ccR
 import net.torvald.terrarum.console.ConsoleCommand
 import net.torvald.terrarum.console.Echo
-import net.torvald.terrarum.modulecomputers.virtualcomputer.tvd.ByteArray64Reader
-import net.torvald.terrarum.modulecomputers.virtualcomputer.tvd.EntryFile
 import net.torvald.terrarum.modulecomputers.virtualcomputer.tvd.VDUtil
 import net.torvald.terrarum.serialise.*
 import java.io.File
 import java.io.IOException
-import java.io.StringReader
-import kotlin.reflect.full.declaredMemberProperties

 /**
 * Created by minjaesong on 2021-08-30.
@@ -27,7 +23,7 @@ object Load : ConsoleCommand {
                Echo("${ccC}Changing context, ${ccR}do not touch the controller$ccC and ${ccG}wait$ccC$ELLIPSIS")

                val charset = Common.CHARSET
-                val file = File(AppLoader.defaultDir + "/Exports/${args[1]}")
+                val file = File(App.defaultDir + "/Exports/${args[1]}")
                val disk = VDUtil.readDiskArchive(file, charset = charset)

                LoadSavegame(disk)
--- a/src/net/torvald/terrarum/modulebasegame/console/Save.kt
+++ b/src/net/torvald/terrarum/modulebasegame/console/Save.kt
@@ -1,6 +1,6 @@
 package net.torvald.terrarum.modulebasegame.console

-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.CommonResourcePool
 import net.torvald.terrarum.ReferencingRanges
 import net.torvald.terrarum.Terrarum
@@ -40,7 +40,7 @@ object Save : ConsoleCommand {
                val ingame = Terrarum.ingame!! as TerrarumIngame
                val savename = args[1].trim()
                val disk = VDUtil.createNewDisk(1L shl 60, savename, Common.CHARSET)
-                val file = File(AppLoader.defaultDir + "/Exports/${args[1]}")
+                val file = File(App.defaultDir + "/Exports/${args[1]}")

                WriteSavegame(disk, file, ingame)

--- a/src/net/torvald/terrarum/modulebasegame/gameactors/ActorHumanoid.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/ActorHumanoid.kt
@@ -5,11 +5,10 @@ import com.jme3.math.FastMath
 import net.torvald.gdx.graphics.Cvec
 import net.torvald.spriteanimation.HasAssembledSprite
 import net.torvald.terrarum.*
-import net.torvald.terrarum.AppLoader.printdbg
+import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.gameactors.*
 import net.torvald.terrarum.gameactors.faction.Faction
 import net.torvald.terrarum.gameitem.GameItem
-import net.torvald.terrarum.itemproperties.ItemCodex
 import net.torvald.terrarum.itemproperties.Material
 import net.torvald.terrarum.realestate.LandUtil
 import org.dyn4j.geometry.Vector2
@@ -224,22 +223,22 @@ open class ActorHumanoid : ActorWithBody, Controllable, Pocketed, Factionable, L

    private fun updateGamerControlBox() {
        if (isGamer) {
-            isUpDown = Gdx.input.isKeyPressed(AppLoader.getConfigInt("config_keyup"))
-            isLeftDown = Gdx.input.isKeyPressed(AppLoader.getConfigInt("config_keyleft"))
-            isDownDown = Gdx.input.isKeyPressed(AppLoader.getConfigInt("config_keydown"))
-            isRightDown = Gdx.input.isKeyPressed(AppLoader.getConfigInt("config_keyright"))
-            isJumpDown = Gdx.input.isKeyPressed(AppLoader.getConfigInt("config_keyjump"))
+            isUpDown = Gdx.input.isKeyPressed(App.getConfigInt("config_keyup"))
+            isLeftDown = Gdx.input.isKeyPressed(App.getConfigInt("config_keyleft"))
+            isDownDown = Gdx.input.isKeyPressed(App.getConfigInt("config_keydown"))
+            isRightDown = Gdx.input.isKeyPressed(App.getConfigInt("config_keyright"))
+            isJumpDown = Gdx.input.isKeyPressed(App.getConfigInt("config_keyjump"))

-            val gamepad = AppLoader.gamepad
+            val gamepad = App.gamepad

            if (gamepad != null) {
-                axisX =  gamepad.getAxis(AppLoader.getConfigInt("config_gamepadaxislx"))
-                axisY =  gamepad.getAxis(AppLoader.getConfigInt("config_gamepadaxisly"))
-                axisRX = gamepad.getAxis(AppLoader.getConfigInt("config_gamepadaxisrx"))
-                axisRY = gamepad.getAxis(AppLoader.getConfigInt("config_gamepadaxisry"))
+                axisX =  gamepad.getAxis(App.getConfigInt("config_gamepadaxislx"))
+                axisY =  gamepad.getAxis(App.getConfigInt("config_gamepadaxisly"))
+                axisRX = gamepad.getAxis(App.getConfigInt("config_gamepadaxisrx"))
+                axisRY = gamepad.getAxis(App.getConfigInt("config_gamepadaxisry"))

-                isJumpDown = Gdx.input.isKeyPressed(AppLoader.getConfigInt("config_keyjump")) ||
-                             gamepad.getButton(AppLoader.getConfigInt("config_gamepadltrigger"))
+                isJumpDown = Gdx.input.isKeyPressed(App.getConfigInt("config_keyjump")) ||
+                             gamepad.getButton(App.getConfigInt("config_gamepadltrigger"))
            }

            if (isJumpJustDown && jumpJustPressedLatched) {
@@ -263,7 +262,7 @@ open class ActorHumanoid : ActorWithBody, Controllable, Pocketed, Factionable, L
    }

    private inline val hasController: Boolean
-        get() = if (isGamer) AppLoader.gamepad != null
+        get() = if (isGamer) App.gamepad != null
                else true

    private var playerJumpKeyHeldDown = false
@@ -308,11 +307,11 @@ open class ActorHumanoid : ActorWithBody, Controllable, Pocketed, Factionable, L
        // ↑F, ↓S
        if (isRightDown && !isLeftDown) {
            walkHorizontal(false, AXIS_KEYBOARD)
-            prevHMoveKey = AppLoader.getConfigInt("config_keyright")
+            prevHMoveKey = App.getConfigInt("config_keyright")
        } // ↓F, ↑S
        else if (isLeftDown && !isRightDown) {
            walkHorizontal(true, AXIS_KEYBOARD)
-            prevHMoveKey = AppLoader.getConfigInt("config_keyleft")
+            prevHMoveKey = App.getConfigInt("config_keyleft")
        } // ↓F, ↓S
        /*else if (isLeftDown && isRightDown) {
               if (prevHMoveKey == KeyMap.getKeyCode(EnumKeyFunc.MOVE_LEFT)) {
@@ -336,11 +335,11 @@ open class ActorHumanoid : ActorWithBody, Controllable, Pocketed, Factionable, L
            // ↑E, ↓D
            if (isDownDown && !isUpDown) {
                walkVertical(false, AXIS_KEYBOARD)
-                prevVMoveKey = AppLoader.getConfigInt("config_keydown")
+                prevVMoveKey = App.getConfigInt("config_keydown")
            } // ↓E, ↑D
            else if (isUpDown && !isDownDown) {
                walkVertical(true, AXIS_KEYBOARD)
-                prevVMoveKey = AppLoader.getConfigInt("config_keyup")
+                prevVMoveKey = App.getConfigInt("config_keyup")
            } // ↓E, ↓D
            /*else if (isUpDown && isDownDown) {
                if (prevVMoveKey == KeyMap.getKeyCode(EnumKeyFunc.MOVE_UP)) {
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/ActorInventory.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/ActorInventory.kt
@@ -1,6 +1,6 @@
 package net.torvald.terrarum.modulebasegame.gameactors

-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.ItemCodex
 import net.torvald.terrarum.gameactors.AVKey
 import net.torvald.terrarum.gameactors.Actor
@@ -96,7 +96,7 @@ class ActorInventory() : FixtureInventory() {
                actor.avStrength / 1000.0
            else
                1.0 // TODO variable: scale, strength
-            val swingDmgToFrameDmg = AppLoader.UPDATE_RATE.toDouble() / actor.actorValue.getAsDouble(AVKey.ACTION_INTERVAL)!!
+            val swingDmgToFrameDmg = App.UPDATE_RATE.toDouble() / actor.actorValue.getAsDouble(AVKey.ACTION_INTERVAL)!!

            // damage the item
            newItem.durability -= (baseDamagePerSwing * swingDmgToFrameDmg).toFloat()
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureBase.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureBase.kt
@@ -1,18 +1,16 @@
 package net.torvald.terrarum.modulebasegame.gameactors

-import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.AppLoader.printdbg
+import net.torvald.terrarum.App
+import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.IngameInstance
 import net.torvald.terrarum.Point2i
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.TerrarumAppConfiguration.TILE_SIZED
 import net.torvald.terrarum.blockproperties.Block
-import net.torvald.terrarum.blockproperties.BlockCodex
 import net.torvald.terrarum.gameactors.ActorID
 import net.torvald.terrarum.gameactors.ActorWithBody
 import net.torvald.terrarum.gameactors.PhysProperties
 import net.torvald.terrarum.gameitem.ItemID
-import net.torvald.terrarum.gameworld.GameWorld
 import net.torvald.terrarum.ui.UICanvas
 import org.dyn4j.geometry.Vector2
 import net.torvald.terrarum.*
@@ -57,7 +55,7 @@ open class FixtureBase : ActorWithBody, CuedByTerrainChange {
        this.inventory = inventory

        if (mainUI != null)
-            AppLoader.disposableSingletonsPool.add(mainUI)
+            App.disposableSingletonsPool.add(mainUI)
    }

    /**
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureStorageChest.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureStorageChest.kt
@@ -57,15 +57,15 @@ internal class FixtureStorageChest : FixtureBase {


 internal class UIStorageChest : UICanvas(
-        toggleKeyLiteral = AppLoader.getConfigInt("config_keyinventory"),
-        toggleButtonLiteral = AppLoader.getConfigInt("config_gamepadstart"),
+        toggleKeyLiteral = App.getConfigInt("config_keyinventory"),
+        toggleButtonLiteral = App.getConfigInt("config_gamepadstart"),
 ), HasInventory {

    lateinit var chestInventory: FixtureInventory
    lateinit var chestNameFun: () -> String

-    override var width = AppLoader.screenSize.screenW
-    override var height = AppLoader.screenSize.screenH
+    override var width = App.scr.width
+    override var height = App.scr.height
    override var openCloseTime: Second = 0.0f

    private val shapeRenderer = ShapeRenderer()
@@ -127,8 +127,8 @@ internal class UIStorageChest : UICanvas(

            catBar = UIItemInventoryCatBar(
                    this,
-                    (AppLoader.screenSize.screenW - catBarWidth) / 2,
-                    42 + (AppLoader.screenSize.screenH - internalHeight) / 2,
+                    (App.scr.width - catBarWidth) / 2,
+                    42 + (App.scr.height - internalHeight) / 2,
                    internalWidth,
                    catBarWidth,
                    false
@@ -195,17 +195,17 @@ internal class UIStorageChest : UICanvas(
        gdxSetBlendNormal()


-        val gradTopStart = (AppLoader.screenSize.screenH - internalHeight).div(2).toFloat()
-        val gradBottomEnd = AppLoader.screenSize.screenH - gradTopStart
+        val gradTopStart = (App.scr.height - internalHeight).div(2).toFloat()
+        val gradBottomEnd = App.scr.height - gradTopStart

        shapeRenderer.inUse {
-            shapeRenderer.rect(0f, gradTopStart, AppLoader.screenSize.screenWf, gradHeight, gradStartCol, gradStartCol, gradEndCol, gradEndCol)
-            shapeRenderer.rect(0f, gradBottomEnd, AppLoader.screenSize.screenWf, -gradHeight, gradStartCol, gradStartCol, gradEndCol, gradEndCol)
+            shapeRenderer.rect(0f, gradTopStart, App.scr.wf, gradHeight, gradStartCol, gradStartCol, gradEndCol, gradEndCol)
+            shapeRenderer.rect(0f, gradBottomEnd, App.scr.wf, -gradHeight, gradStartCol, gradStartCol, gradEndCol, gradEndCol)

-            shapeRenderer.rect(0f, gradTopStart + gradHeight, AppLoader.screenSize.screenWf, internalHeight - (2 * gradHeight), gradEndCol, gradEndCol, gradEndCol, gradEndCol)
+            shapeRenderer.rect(0f, gradTopStart + gradHeight, App.scr.wf, internalHeight - (2 * gradHeight), gradEndCol, gradEndCol, gradEndCol, gradEndCol)

-            shapeRenderer.rect(0f, 0f, AppLoader.screenSize.screenWf, gradTopStart, gradStartCol, gradStartCol, gradStartCol, gradStartCol)
-            shapeRenderer.rect(0f, AppLoader.screenSize.screenHf, AppLoader.screenSize.screenWf, -(AppLoader.screenSize.screenHf - gradBottomEnd), gradStartCol, gradStartCol, gradStartCol, gradStartCol)
+            shapeRenderer.rect(0f, 0f, App.scr.wf, gradTopStart, gradStartCol, gradStartCol, gradStartCol, gradStartCol)
+            shapeRenderer.rect(0f, App.scr.hf, App.scr.wf, -(App.scr.hf - gradBottomEnd), gradStartCol, gradStartCol, gradStartCol, gradStartCol)
        }


@@ -225,7 +225,7 @@ internal class UIStorageChest : UICanvas(
        // encumbrance meter
        val encumbranceText = Lang["GAME_INVENTORY_ENCUMBRANCE"]
        val encumbBarXPos = itemListPlayer.posX + itemListPlayer.width - weightBarWidth
-        val encumbBarTextXPos = encumbBarXPos - 6 - AppLoader.fontGame.getWidth(encumbranceText)
+        val encumbBarTextXPos = encumbBarXPos - 6 - App.fontGame.getWidth(encumbranceText)
        val encumbBarYPos = UIInventoryCells.encumbBarYPos
        val encumbCol = UIItemInventoryCellCommonRes.getHealthMeterColour(1f - encumbrancePerc, 0f, 1f)
        val encumbBack = encumbCol mul UIItemInventoryCellCommonRes.meterBackDarkening
@@ -250,10 +250,10 @@ internal class UIStorageChest : UICanvas(

        // chest name text
        batch.color = Color.WHITE
-        AppLoader.fontGame.draw(batch, chestName, itemListChest.posX + 6f, encumbBarYPos - 3f)
+        App.fontGame.draw(batch, chestName, itemListChest.posX + 6f, encumbBarYPos - 3f)
        // encumb text
        batch.color = Color.WHITE
-        AppLoader.fontGame.draw(batch, encumbranceText, encumbBarTextXPos, encumbBarYPos - 3f)
+        App.fontGame.draw(batch, encumbranceText, encumbBarTextXPos, encumbBarYPos - 3f)
    }

    override fun doOpening(delta: Float) {
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/InjectCreatureRaw.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/InjectCreatureRaw.kt
@@ -2,7 +2,7 @@ package net.torvald.terrarum.modulebasegame.gameactors

 import net.torvald.terrarum.utils.JsonFetcher
 import net.torvald.random.Fudge3
-import net.torvald.terrarum.AppLoader.printdbg
+import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.ModMgr
 import net.torvald.terrarum.gameactors.AVKey
 import net.torvald.terrarum.gameactors.ActorValue
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/PlayerBuilderSigrid.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/PlayerBuilderSigrid.kt
@@ -1,12 +1,9 @@
 package net.torvald.terrarum.modulebasegame.gameactors

-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.ModMgr
-import net.torvald.terrarum.blockproperties.BlockCodex
-import net.torvald.terrarum.blockproperties.WireCodex
 import net.torvald.terrarum.gameactors.AVKey
 import net.torvald.terrarum.gameactors.faction.FactionFactory
-import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import net.torvald.terrarumsansbitmap.gdx.TextureRegionPack
 import net.torvald.terrarum.*

@@ -79,7 +76,7 @@ object PlayerBuilderSigrid {

    fun fillTestInventory(inventory: ActorInventory) {

-        AppLoader.tileMaker.tags.forEach { t, _ ->
+        App.tileMaker.tags.forEach { t, _ ->
            inventory.add(t, 9995)
            try {
                inventory.add("wall@"+t, 9995) // this code will try to add nonexisting wall items, do not get surprised with NPEs
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/Pocketed.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/Pocketed.kt
@@ -1,9 +1,8 @@
 package net.torvald.terrarum.modulebasegame.gameactors

-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.gameactors.ActorValue
 import net.torvald.terrarum.gameitem.GameItem
-import net.torvald.terrarum.itemproperties.ItemCodex
 import net.torvald.terrarum.gameitem.ItemID
 import net.torvald.terrarum.*

@@ -36,7 +35,7 @@ interface Pocketed {
        // Relevant Actorvalue is NOT being updated on time
        // They're being safely handled by UIItemInventoryElem*.touchDown() and ActorInventory.remove

-        item.effectOnUnequip(AppLoader.UPDATE_RATE)
+        item.effectOnUnequip(App.UPDATE_RATE)
    }

    fun unequipItem(itemID: ItemID?) {
@@ -67,7 +66,7 @@ interface Pocketed {

        if (item.equipPosition >= 0) {
            inventory.itemEquipped[item.equipPosition] = item.dynamicID
-            item.effectWhenEquipped(AppLoader.UPDATE_RATE)
+            item.effectWhenEquipped(App.UPDATE_RATE)
        }
        // else do nothing
    }
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/ThreadActorUpdate.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/ThreadActorUpdate.kt
@@ -1,8 +1,7 @@
 package net.torvald.terrarum.modulebasegame.gameactors

-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Terrarum
-import net.torvald.terrarum.itemproperties.ItemCodex
 import java.util.concurrent.Callable
 import net.torvald.terrarum.*

@@ -13,13 +12,13 @@ class ThreadActorUpdate(val startIndex: Int, val endIndex: Int) : Callable<Unit>
    override fun call() {
        for (i in startIndex..endIndex) {
            val it = Terrarum.ingame!!.actorContainerActive[i]
-            it.update(AppLoader.UPDATE_RATE)
+            it.update(App.UPDATE_RATE)

            if (it is Pocketed) {
                it.inventory.forEach { inventoryEntry ->
-                    ItemCodex[inventoryEntry.itm]?.effectWhileInPocket(AppLoader.UPDATE_RATE)
+                    ItemCodex[inventoryEntry.itm]?.effectWhileInPocket(App.UPDATE_RATE)
                    if (it.equipped(inventoryEntry.itm)) {
-                        ItemCodex[inventoryEntry.itm]?.effectWhenEquipped(AppLoader.UPDATE_RATE)
+                        ItemCodex[inventoryEntry.itm]?.effectWhenEquipped(App.UPDATE_RATE)
                    }
                }
            }
--- a/src/net/torvald/terrarum/modulebasegame/ui/FloatDrawer.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/FloatDrawer.kt
@@ -2,7 +2,7 @@ package net.torvald.terrarum.modulebasegame.ui

 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import com.badlogic.gdx.utils.Disposable
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarumsansbitmap.gdx.TextureRegionPack

 /**
@@ -13,7 +13,7 @@ object FloatDrawer : Disposable {
    val tile = TextureRegionPack("assets/graphics/gui/message_black_tileable.tga", 36, 36)

    init {
-        AppLoader.disposableSingletonsPool.add(this)
+        App.disposableSingletonsPool.add(this)
    }

    /**
--- a/src/net/torvald/terrarum/modulebasegame/ui/Notification.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/Notification.kt
@@ -3,7 +3,7 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.blendNormal
 import net.torvald.terrarum.ui.UICanvas
@@ -26,7 +26,7 @@ class Notification : UICanvas() {

    override var height: Int = 0
    private val visibleTime = Math.min(
-            AppLoader.getConfigInt("notificationshowuptime"),
+            App.getConfigInt("notificationshowuptime"),
            SHOWUP_MAX
    ) / 1000f
    private var displayTimer = 0f
@@ -55,15 +55,15 @@ class Notification : UICanvas() {
        fontCol.a = handler.opacity

        val realTextWidth = 12 + if (message.size == 1)
-            AppLoader.fontGame.getWidth(message[0])
+            App.fontGame.getWidth(message[0])
        else
-            message.map { AppLoader.fontGame.getWidth(it) }.sorted().last()
+            message.map { App.fontGame.getWidth(it) }.sorted().last()
        val displayedTextWidth = maxOf(240, realTextWidth)

        // force the UI to the centre of the screen
-        this.posX = (AppLoader.screenSize.screenW - displayedTextWidth) / 2
+        this.posX = (App.scr.width - displayedTextWidth) / 2

-        val textHeight = message.size * AppLoader.fontGame.lineHeight
+        val textHeight = message.size * App.fontGame.lineHeight

        batch.color = drawColor

@@ -72,8 +72,8 @@ class Notification : UICanvas() {
        batch.color = fontCol
        message.forEachIndexed { index, s ->
            val xoff = 6 + (displayedTextWidth - realTextWidth) / 2
-            val y = -textHeight + AppLoader.fontGame.lineHeight * index
-            AppLoader.fontGame.draw(batch, s, LRmargin + xoff, y)
+            val y = -textHeight + App.fontGame.lineHeight * index
+            App.fontGame.draw(batch, s, LRmargin + xoff, y)
        }


--- a/src/net/torvald/terrarum/modulebasegame/ui/UIBasicInfo.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIBasicInfo.kt
@@ -42,7 +42,7 @@ class UIBasicInfo() : UICanvas() {
            ELuptimer += delta
        }

-        if (mouseUp || Gdx.input.isKeyPressed(AppLoader.getConfigInt("config_keyinteract"))) {
+        if (mouseUp || Gdx.input.isKeyPressed(App.getConfigInt("config_keyinteract"))) {
            ELuptimer = 0f
            ELon = true
        }
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIBuildingMakerBlockChooser.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIBuildingMakerBlockChooser.kt
@@ -4,18 +4,15 @@ import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.blendNormal
-import net.torvald.terrarum.blockproperties.BlockCodex
 import net.torvald.terrarum.fillRect
-import net.torvald.terrarum.itemproperties.ItemCodex
 import net.torvald.terrarum.modulebasegame.BuildingMaker
 import net.torvald.terrarum.modulebasegame.ui.ItemSlotImageFactory.CELLCOLOUR_WHITE
 import net.torvald.terrarum.ui.UICanvas
 import net.torvald.terrarum.ui.UIItemImageButton
 import net.torvald.terrarum.ui.UIItemTextButtonList
 import net.torvald.terrarum.ui.UIItemTextButtonList.Companion.DEFAULT_BACKGROUNDCOL
-import net.torvald.terrarum.worlddrawer.CreateTileAtlas
 import kotlin.math.roundToInt
 import net.torvald.terrarum.*

@@ -89,7 +86,7 @@ class UIBuildingMakerBlockChooser(val parent: BuildingMaker): UICanvas() {
        }

        // respond to click
-        if (Gdx.input.isButtonPressed(AppLoader.getConfigInt("config_mouseprimary"))) {
+        if (Gdx.input.isButtonPressed(App.getConfigInt("config_mouseprimary"))) {
            // scroll bar
            if (relativeMouseX in width - SCROLLBAR_SIZE until width && relativeMouseY in 0 until height) {
                mouseOnScroll = true
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIBuildingMakerPenMenu.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIBuildingMakerPenMenu.kt
@@ -7,7 +7,6 @@ import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import net.torvald.terrarum.*
 import net.torvald.terrarum.blockproperties.Block
-import net.torvald.terrarum.itemproperties.ItemCodex
 import net.torvald.terrarum.modulebasegame.BuildingMaker
 import net.torvald.terrarum.ui.UICanvas
 import net.torvald.terrarum.ui.UIItemImageButton
@@ -71,8 +70,8 @@ class UIBuildingMakerPenMenu(val parent: BuildingMaker): UICanvas() {
            {
                parent.uiPalette.isVisible = true
                parent.uiPalette.setPosition(Gdx.input.x - parent.uiPalette.width / 2, Gdx.input.y - parent.uiPalette.height / 2)
-                parent.uiPalette.posX = parent.uiPalette.posX.coerceIn(0, AppLoader.screenSize.screenW - parent.uiPalette.width)
-                parent.uiPalette.posY = parent.uiPalette.posY.coerceIn(0, AppLoader.screenSize.screenH - parent.uiPalette.height)
+                parent.uiPalette.posX = parent.uiPalette.posX.coerceIn(0, App.scr.width - parent.uiPalette.width)
+                parent.uiPalette.posY = parent.uiPalette.posY.coerceIn(0, App.scr.height - parent.uiPalette.height)
            },
            {
                parent.currentPenMode = BuildingMaker.PENMODE_PENCIL_ERASE
@@ -100,7 +99,7 @@ class UIBuildingMakerPenMenu(val parent: BuildingMaker): UICanvas() {
            uiItems.add(button)

            button.clickOnceListener = { _, _, b ->
-                if (b == AppLoader.getConfigInt("config_mouseprimary")) {
+                if (b == App.getConfigInt("config_mouseprimary")) {
                    toolButtonsJob[index].invoke()
                    closeGracefully()
                }
@@ -134,7 +133,7 @@ class UIBuildingMakerPenMenu(val parent: BuildingMaker): UICanvas() {
        }

        // primary click
-        if (Gdx.input.isButtonPressed(AppLoader.getConfigInt("config_mouseprimary"))) {
+        if (Gdx.input.isButtonPressed(App.getConfigInt("config_mouseprimary"))) {
            // close by clicking close button or out-of-boud
            if (mouseVec.distanceSquared(RADIUS, RADIUS) !in CLOSE_BUTTON_RADIUS.sqr()..RADIUSF.sqr()) {
                closeGracefully()
@@ -176,7 +175,7 @@ class UIBuildingMakerPenMenu(val parent: BuildingMaker): UICanvas() {
            batch.draw(ItemCodex.getItemImage(slotConfig[i]), x - 16, y - 16, 32f, 32f)

            // update as well while looping
-            if (i == mouseOnBlocksSlot && Gdx.input.isButtonPressed(AppLoader.getConfigInt("config_mouseprimary"))) {
+            if (i == mouseOnBlocksSlot && Gdx.input.isButtonPressed(App.getConfigInt("config_mouseprimary"))) {
                parent.setPencilColour(slotConfig[i])
                closeGracefully()
            }
--- a/src/net/torvald/terrarum/modulebasegame/ui/UICheatDetected.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UICheatDetected.kt
@@ -3,7 +3,7 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.fillRect
@@ -16,11 +16,11 @@ import net.torvald.terrarum.ui.UICanvas
 class UICheatDetected : UICanvas() {

    override var width: Int
-        get() = AppLoader.screenSize.screenW
+        get() = App.scr.width
        set(value) { throw UnsupportedOperationException() }

    override var height: Int
-        get() = AppLoader.screenSize.screenH
+        get() = App.scr.height
        set(value) { throw UnsupportedOperationException() }

    override var openCloseTime: Second = 0f
@@ -38,10 +38,10 @@ class UICheatDetected : UICanvas() {

        batch.color = Color.WHITE
        val txt = Lang["ERROR_GENERIC_CHEATING"]
-        val txtW = AppLoader.fontGame.getWidth(txt)
-        val txtH = AppLoader.fontGame.lineHeight.toInt()
+        val txtW = App.fontGame.getWidth(txt)
+        val txtH = App.fontGame.lineHeight.toInt()

-        AppLoader.fontGame.draw(batch, txt, width.minus(txtW).ushr(1).toFloat(), height.minus(txtH).ushr(1).toFloat())
+        App.fontGame.draw(batch, txt, width.minus(txtW).ushr(1).toFloat(), height.minus(txtH).ushr(1).toFloat())
    }

    override fun updateUI(delta: Float) {
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIInventoryCells.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIInventoryCells.kt
@@ -4,7 +4,6 @@ import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import net.torvald.terrarum.*
-import net.torvald.terrarum.gameactors.ActorWithBody
 import net.torvald.terrarum.langpack.Lang
 import net.torvald.terrarum.modulebasegame.gameactors.FixtureInventory
 import net.torvald.terrarum.modulebasegame.ui.UIInventoryFull.Companion.CELLS_HOR
@@ -22,8 +21,8 @@ internal class UIInventoryCells(
        val full: UIInventoryFull
 ) : UICanvas() {

-    override var width: Int = AppLoader.screenSize.screenW
-    override var height: Int = AppLoader.screenSize.screenH
+    override var width: Int = App.scr.width
+    override var height: Int = App.scr.height
    override var openCloseTime: Second = 0.0f

    companion object {
@@ -53,7 +52,7 @@ internal class UIInventoryCells(
    private val equipped: UIItemInventoryEquippedView =
            UIItemInventoryEquippedView(
                    full,
-                    internalWidth - UIItemInventoryEquippedView.WIDTH + (AppLoader.screenSize.screenW - internalWidth) / 2,
+                    internalWidth - UIItemInventoryEquippedView.WIDTH + (App.scr.width - internalWidth) / 2,
                    INVENTORY_CELLS_OFFSET_Y,
                    { rebuildList() }
            )
@@ -64,7 +63,7 @@ internal class UIInventoryCells(
    }

    fun rebuildList() {
-        AppLoader.printdbg(this, "rebuilding list")
+        App.printdbg(this, "rebuilding list")

        itemList.rebuild(full.catBar.catIconsMeaning[full.catBar.selectedIcon])
        equipped.rebuild()
@@ -94,21 +93,21 @@ internal class UIInventoryCells(
        val controlHintXPos = full.offsetX
        blendNormal(batch)
        batch.color = Color.WHITE
-        AppLoader.fontGame.draw(batch, full.listControlHelp, controlHintXPos, full.yEnd - 20)
+        App.fontGame.draw(batch, full.listControlHelp, controlHintXPos, full.yEnd - 20)


        // encumbrance meter
        val encumbranceText = Lang["GAME_INVENTORY_ENCUMBRANCE"]
        // encumbrance bar will go one row down if control help message is too long
        val encumbBarXPos = full.xEnd - weightBarWidth
-        val encumbBarTextXPos = encumbBarXPos - 6 - AppLoader.fontGame.getWidth(encumbranceText)
+        val encumbBarTextXPos = encumbBarXPos - 6 - App.fontGame.getWidth(encumbranceText)
        val encumbBarYPos = full.yEnd-20 + 3f +
-                            if (AppLoader.fontGame.getWidth(full.listControlHelp) + 2 + controlHintXPos >= encumbBarTextXPos)
-                                AppLoader.fontGame.lineHeight
+                            if (App.fontGame.getWidth(full.listControlHelp) + 2 + controlHintXPos >= encumbBarTextXPos)
+                                App.fontGame.lineHeight
                            else 0f
        Companion.encumbBarYPos = encumbBarYPos // q&d hack to share some numbers

-        AppLoader.fontGame.draw(batch,
+        App.fontGame.draw(batch,
                encumbranceText,
                encumbBarTextXPos,
                encumbBarYPos - 3f
@@ -136,7 +135,7 @@ internal class UIInventoryCells(
        // debug text
        batch.color = Color.LIGHT_GRAY
        if (INVEN_DEBUG_MODE) {
-            AppLoader.fontSmallNumbers.draw(batch,
+            App.fontSmallNumbers.draw(batch,
                    "${full.actor.inventory.capacity}/${full.actor.inventory.maxCapacity}",
                    encumbBarTextXPos,
                    encumbBarYPos + controlHelpHeight - 4f
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIInventoryEscMenu.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIInventoryEscMenu.kt
@@ -4,7 +4,7 @@ import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.TitleScreen
 import net.torvald.terrarum.blendNormal
 import net.torvald.terrarum.modulebasegame.ui.UIInventoryFull.Companion.INVENTORY_CELLS_OFFSET_Y
@@ -15,8 +15,8 @@ import net.torvald.terrarum.ui.UIItemTextButtonList.Companion.DEFAULT_LINE_HEIGH

 class UIInventoryEscMenu(val full: UIInventoryFull) : UICanvas() {

-    override var width: Int = AppLoader.screenSize.screenW
-    override var height: Int = AppLoader.screenSize.screenH
+    override var width: Int = App.scr.width
+    override var height: Int = App.scr.height
    override var openCloseTime = 0.0f

    private val gameMenu = arrayOf("MENU_LABEL_MAINMENU", "MENU_LABEL_DESKTOP", "MENU_OPTIONS_CONTROLS", "MENU_OPTIONS_SOUND", "MENU_LABEL_GRAPHICS")
@@ -24,7 +24,7 @@ class UIInventoryEscMenu(val full: UIInventoryFull) : UICanvas() {
    private val gameMenuListWidth = 400
    private val gameMenuButtons = UIItemTextButtonList(
            this, DEFAULT_LINE_HEIGHT, gameMenu,
-            (AppLoader.screenSize.screenW - gameMenuListWidth) / 2,
+            (App.scr.width - gameMenuListWidth) / 2,
            INVENTORY_CELLS_OFFSET_Y + (INVENTORY_CELLS_UI_HEIGHT - gameMenuListHeight) / 2,
            gameMenuListWidth, gameMenuListHeight,
            readFromLang = true,
@@ -41,7 +41,7 @@ class UIInventoryEscMenu(val full: UIInventoryFull) : UICanvas() {

        gameMenuButtons.selectionChangeListener = { _, new ->
            when (new) {
-                0 -> AppLoader.setScreen(TitleScreen(AppLoader.batch))
+                0 -> App.setScreen(TitleScreen(App.batch))
                1 -> Gdx.app.exit()
            }
        }
@@ -55,7 +55,7 @@ class UIInventoryEscMenu(val full: UIInventoryFull) : UICanvas() {
        // control hints
        blendNormal(batch)
        batch.color = Color.WHITE
-        AppLoader.fontGame.draw(batch, full.gameMenuControlHelp, full.offsetX, full.yEnd - 20)
+        App.fontGame.draw(batch, full.gameMenuControlHelp, full.offsetX, full.yEnd - 20)

        // text buttons
        gameMenuButtons.render(batch, camera)
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIInventoryFull.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIInventoryFull.kt
@@ -5,12 +5,11 @@ import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import com.badlogic.gdx.graphics.glutils.ShapeRenderer
 import net.torvald.ENDASH
 import net.torvald.terrarum.*
-import net.torvald.terrarum.AppLoader.*
+import net.torvald.terrarum.App.*
 import net.torvald.terrarum.blockstats.MinimapComposer
 import net.torvald.terrarum.langpack.Lang
 import net.torvald.terrarum.modulebasegame.TerrarumIngame
 import net.torvald.terrarum.modulebasegame.gameactors.ActorHumanoid
-import net.torvald.terrarum.modulebasegame.gameactors.Pocketed
 import net.torvald.terrarum.ui.*
 import net.torvald.terrarumsansbitmap.gdx.TextureRegionPack

@@ -18,7 +17,7 @@ import net.torvald.terrarumsansbitmap.gdx.TextureRegionPack
 * Created by minjaesong on 2017-10-21.
 */
 class UIInventoryFull(
-        toggleKeyLiteral: Int? = AppLoader.getConfigInt("config_keyinventory"), toggleButtonLiteral: Int? = AppLoader.getConfigInt("config_gamepadstart"),
+        toggleKeyLiteral: Int? = App.getConfigInt("config_keyinventory"), toggleButtonLiteral: Int? = App.getConfigInt("config_gamepadstart"),
        // UI positions itself? (you must g.flush() yourself after the g.translate(Int, Int))
        customPositioning: Boolean = false, // mainly used by vital meter
        doNotWarnConstant: Boolean = false
@@ -27,8 +26,8 @@ class UIInventoryFull(
    val actor: ActorHumanoid
        get() = Terrarum.ingame!!.actorNowPlaying!!

-    override var width: Int = AppLoader.screenSize.screenW
-    override var height: Int = AppLoader.screenSize.screenH
+    override var width: Int = App.scr.width
+    override var height: Int = App.scr.height
    override var openCloseTime: Second = 0.0f

    companion object {
@@ -36,7 +35,7 @@ class UIInventoryFull(

        const val REQUIRED_MARGIN: Int = 138 // hard-coded value. Don't know the details. Range: [91-146]. I chose MAX-8 because cell gap is 8
        const val CELLS_HOR = 10
-        val CELLS_VRT: Int; get() = (AppLoader.screenSize.screenH - REQUIRED_MARGIN - 134 + UIItemInventoryItemGrid.listGap) / // 134 is another magic number
+        val CELLS_VRT: Int; get() = (App.scr.height - REQUIRED_MARGIN - 134 + UIItemInventoryItemGrid.listGap) / // 134 is another magic number
                                (UIItemInventoryElemSimple.height + UIItemInventoryItemGrid.listGap)

        const val itemListToEquipViewGap = UIItemInventoryItemGrid.listGap // used to be 24; figured out that the extra gap does nothig
@@ -47,8 +46,8 @@ class UIInventoryFull(
        val itemListHeight: Int = CELLS_VRT * UIItemInventoryElemSimple.height + (CELLS_VRT - 1) * net.torvald.terrarum.modulebasegame.ui.UIItemInventoryItemGrid.Companion.listGap

        val INVENTORY_CELLS_UI_HEIGHT: Int = CELLS_VRT * UIItemInventoryElemSimple.height + (CELLS_VRT - 1) * UIItemInventoryItemGrid.listGap
-        val INVENTORY_CELLS_OFFSET_X = 0 + (AppLoader.screenSize.screenW - internalWidth) / 2
-        val INVENTORY_CELLS_OFFSET_Y: Int = 107 + (AppLoader.screenSize.screenH - internalHeight) / 2
+        val INVENTORY_CELLS_OFFSET_X = 0 + (App.scr.width - internalWidth) / 2
+        val INVENTORY_CELLS_OFFSET_Y: Int = 107 + (App.scr.height - internalHeight) / 2

        val catBarWidth = 330

@@ -56,7 +55,7 @@ class UIInventoryFull(
        val gradEndCol   = Color(0x000000_70)
        val gradHeight = 48f

-        val controlHelpHeight = AppLoader.fontGame.lineHeight
+        val controlHelpHeight = App.fontGame.lineHeight
    }

    //val REQUIRED_MARGIN: Int = 138 // hard-coded value. Don't know the details. Range: [91-146]. I chose MAX-8 because cell gap is 8
@@ -86,7 +85,7 @@ class UIInventoryFull(

    private val SP = "${0x3000.toChar()} "
    val listControlHelp: String
-        get() = if (AppLoader.environment == RunningEnvironment.PC)
+        get() = if (App.environment == RunningEnvironment.PC)
            "${0xe031.toChar()} ${Lang["GAME_ACTION_CLOSE"]}$SP" +
            "${0xe006.toChar()} ${Lang["GAME_INVENTORY_USE"]}$SP" +
            "${0xe011.toChar()}$ENDASH${0x2009.toChar()}${0xe010.toChar()} ${Lang["GAME_INVENTORY_REGISTER"]}$SP" +
@@ -99,7 +98,7 @@ class UIInventoryFull(
            "$gamepadLabelNorth$gamepadLabelLStick ${Lang["GAME_INVENTORY_REGISTER"]}$SP" +
            "$gamepadLabelEast ${Lang["GAME_INVENTORY_DROP"]}"
    val minimapControlHelp: String
-        get() = if (AppLoader.environment == RunningEnvironment.PC)
+        get() = if (App.environment == RunningEnvironment.PC)
            "${0xe031.toChar()} ${Lang["GAME_ACTION_CLOSE"]}$SP" +
            "${0xe006.toChar()} ${Lang["GAME_ACTION_MOVE_VERB"]}"
        else
@@ -107,7 +106,7 @@ class UIInventoryFull(
            "$gamepadLabelRStick ${Lang["GAME_ACTION_MOVE_VERB"]}$SP" +
            "$gamepadLabelRT ${Lang["GAME_INVENTORY"]}"
    val gameMenuControlHelp: String
-        get() = if (AppLoader.environment == RunningEnvironment.PC)
+        get() = if (App.environment == RunningEnvironment.PC)
            "${0xe031.toChar()} ${Lang["GAME_ACTION_CLOSE"]}"
        else
            "$gamepadLabelStart ${Lang["GAME_ACTION_CLOSE"]}$SP" +
@@ -115,8 +114,8 @@ class UIInventoryFull(

    val catBar = UIItemInventoryCatBar(
            this,
-            (AppLoader.screenSize.screenW - catBarWidth) / 2,
-            42 + (AppLoader.screenSize.screenH - internalHeight) / 2,
+            (App.scr.width - catBarWidth) / 2,
+            42 + (App.scr.height - internalHeight) / 2,
            internalWidth,
            catBarWidth,
            true,
@@ -129,10 +128,10 @@ class UIInventoryFull(
    private val transitionalEscMenu = UIInventoryEscMenu(this)
    private val transitionPanel = UIItemHorizontalFadeSlide(
            this,
-            (AppLoader.screenSize.screenW - internalWidth) / 2,
+            (App.scr.width - internalWidth) / 2,
            INVENTORY_CELLS_OFFSET_Y,
-            AppLoader.screenSize.screenW,
-            AppLoader.screenSize.screenH,
+            App.scr.width,
+            App.scr.height,
            1f,
            transitionalMinimap, transitionalItemCells, transitionalEscMenu
    )
@@ -153,9 +152,9 @@ class UIInventoryFull(

    }

-    internal var offsetX = ((AppLoader.screenSize.screenW - internalWidth) / 2).toFloat()
+    internal var offsetX = ((App.scr.width - internalWidth) / 2).toFloat()
        private set
-    internal var offsetY = ((AppLoader.screenSize.screenH - internalHeight) / 2).toFloat()
+    internal var offsetY = ((App.scr.height - internalHeight) / 2).toFloat()
        private set

    fun requestTransition(target: Int) = transitionPanel.requestTransition(target)
@@ -174,9 +173,9 @@ class UIInventoryFull(
    //private val gradHeight = 48f
    private val shapeRenderer = ShapeRenderer()

-    internal var xEnd = (AppLoader.screenSize.screenW + internalWidth).div(2).toFloat()
+    internal var xEnd = (App.scr.width + internalWidth).div(2).toFloat()
        private set
-    internal var yEnd = (AppLoader.screenSize.screenH + internalHeight).div(2).toFloat()
+    internal var yEnd = (App.scr.height + internalHeight).div(2).toFloat()
        private set

    override fun renderUI(batch: SpriteBatch, camera: Camera) {
@@ -187,17 +186,17 @@ class UIInventoryFull(
        gdxSetBlendNormal()


-        val gradTopStart = (AppLoader.screenSize.screenH - internalHeight).div(2).toFloat()
-        val gradBottomEnd = AppLoader.screenSize.screenH - gradTopStart
+        val gradTopStart = (App.scr.height - internalHeight).div(2).toFloat()
+        val gradBottomEnd = App.scr.height - gradTopStart

        shapeRenderer.inUse {
-            shapeRenderer.rect(0f, gradTopStart, AppLoader.screenSize.screenWf, gradHeight, gradStartCol, gradStartCol, gradEndCol, gradEndCol)
-            shapeRenderer.rect(0f, gradBottomEnd, AppLoader.screenSize.screenWf, -gradHeight, gradStartCol, gradStartCol, gradEndCol, gradEndCol)
+            shapeRenderer.rect(0f, gradTopStart, App.scr.wf, gradHeight, gradStartCol, gradStartCol, gradEndCol, gradEndCol)
+            shapeRenderer.rect(0f, gradBottomEnd, App.scr.wf, -gradHeight, gradStartCol, gradStartCol, gradEndCol, gradEndCol)

-            shapeRenderer.rect(0f, gradTopStart + gradHeight, AppLoader.screenSize.screenWf, internalHeight - (2 * gradHeight), gradEndCol, gradEndCol, gradEndCol, gradEndCol)
+            shapeRenderer.rect(0f, gradTopStart + gradHeight, App.scr.wf, internalHeight - (2 * gradHeight), gradEndCol, gradEndCol, gradEndCol, gradEndCol)

-            shapeRenderer.rect(0f, 0f, AppLoader.screenSize.screenWf, gradTopStart, gradStartCol, gradStartCol, gradStartCol, gradStartCol)
-            shapeRenderer.rect(0f, AppLoader.screenSize.screenHf, AppLoader.screenSize.screenWf, -(AppLoader.screenSize.screenHf - gradBottomEnd), gradStartCol, gradStartCol, gradStartCol, gradStartCol)
+            shapeRenderer.rect(0f, 0f, App.scr.wf, gradTopStart, gradStartCol, gradStartCol, gradStartCol, gradStartCol)
+            shapeRenderer.rect(0f, App.scr.hf, App.scr.wf, -(App.scr.hf - gradBottomEnd), gradStartCol, gradStartCol, gradStartCol, gradStartCol)
        }


@@ -257,11 +256,11 @@ class UIInventoryFull(
    override fun resize(width: Int, height: Int) {
        super.resize(width, height)

-        offsetX = ((AppLoader.screenSize.screenW - internalWidth) / 2).toFloat()
-        offsetY = ((AppLoader.screenSize.screenH - internalHeight) / 2).toFloat()
+        offsetX = ((App.scr.width - internalWidth) / 2).toFloat()
+        offsetY = ((App.scr.height - internalHeight) / 2).toFloat()

-        xEnd = (AppLoader.screenSize.screenW + internalWidth).div(2).toFloat()
-        yEnd = (AppLoader.screenSize.screenH + internalHeight).div(2).toFloat()
+        xEnd = (App.scr.width + internalWidth).div(2).toFloat()
+        yEnd = (App.scr.height + internalHeight).div(2).toFloat()
    }
 }

--- a/src/net/torvald/terrarum/modulebasegame/ui/UIInventoryMinimap.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIInventoryMinimap.kt
@@ -15,8 +15,8 @@ class UIInventoryMinimap(val full: UIInventoryFull) : UICanvas() {

    private val debugvals = true

-    override var width: Int = AppLoader.screenSize.screenW
-    override var height: Int = AppLoader.screenSize.screenH
+    override var width: Int = App.scr.width
+    override var height: Int = App.scr.height
    override var openCloseTime = 0.0f

    private val MINIMAP_WIDTH = 800f
@@ -44,7 +44,7 @@ class UIInventoryMinimap(val full: UIInventoryFull) : UICanvas() {

        // update map panning
        // if left click is down and cursor is in the map area
-        if (Gdx.input.isButtonPressed(AppLoader.getConfigInt("config_mouseprimary")) &&
+        if (Gdx.input.isButtonPressed(App.getConfigInt("config_mouseprimary")) &&
            Terrarum.mouseScreenY in INVENTORY_CELLS_OFFSET_Y..INVENTORY_CELLS_OFFSET_Y + INVENTORY_CELLS_UI_HEIGHT) {
            minimapPanX += Terrarum.mouseDeltaX * 2f / minimapZoom
            minimapPanY += Terrarum.mouseDeltaY * 2f / minimapZoom
@@ -115,23 +115,23 @@ class UIInventoryMinimap(val full: UIInventoryFull) : UICanvas() {
        batch.begin()

        if (debugvals) {
-            AppLoader.fontSmallNumbers.draw(batch, "$minimapPanX, $minimapPanY; x$minimapZoom", (AppLoader.screenSize.screenW - MINIMAP_WIDTH) / 2, -10f + INVENTORY_CELLS_OFFSET_Y)
+            App.fontSmallNumbers.draw(batch, "$minimapPanX, $minimapPanY; x$minimapZoom", (App.scr.width - MINIMAP_WIDTH) / 2, -10f + INVENTORY_CELLS_OFFSET_Y)
        }

        batch.projectionMatrix = camera.combined
        // 1px stroke
        batch.color = Color.WHITE
-        batch.fillRect((AppLoader.screenSize.screenW - MINIMAP_WIDTH) / 2, -1 + INVENTORY_CELLS_OFFSET_Y.toFloat(), MINIMAP_WIDTH, 1f)
-        batch.fillRect((AppLoader.screenSize.screenW - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y + MINIMAP_HEIGHT, MINIMAP_WIDTH, 1f)
-        batch.fillRect(-1 + (AppLoader.screenSize.screenW - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y.toFloat(), 1f, MINIMAP_HEIGHT)
-        batch.fillRect((AppLoader.screenSize.screenW - MINIMAP_WIDTH) / 2 + MINIMAP_WIDTH, INVENTORY_CELLS_OFFSET_Y.toFloat(), 1f, MINIMAP_HEIGHT)
+        batch.fillRect((App.scr.width - MINIMAP_WIDTH) / 2, -1 + INVENTORY_CELLS_OFFSET_Y.toFloat(), MINIMAP_WIDTH, 1f)
+        batch.fillRect((App.scr.width - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y + MINIMAP_HEIGHT, MINIMAP_WIDTH, 1f)
+        batch.fillRect(-1 + (App.scr.width - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y.toFloat(), 1f, MINIMAP_HEIGHT)
+        batch.fillRect((App.scr.width - MINIMAP_WIDTH) / 2 + MINIMAP_WIDTH, INVENTORY_CELLS_OFFSET_Y.toFloat(), 1f, MINIMAP_HEIGHT)

        // control hints
        batch.color = Color.WHITE
-        AppLoader.fontGame.draw(batch, full.minimapControlHelp, full.offsetX, full.yEnd - 20)
+        App.fontGame.draw(batch, full.minimapControlHelp, full.offsetX, full.yEnd - 20)

        // the minimap
-        batch.draw(minimapFBO.colorBufferTexture, (AppLoader.screenSize.screenW - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y.toFloat())
+        batch.draw(minimapFBO.colorBufferTexture, (App.scr.width - MINIMAP_WIDTH) / 2, INVENTORY_CELLS_OFFSET_Y.toFloat())
    }

    override fun doOpening(delta: Float) {}
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIItemPlayerInfoCell.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIItemPlayerInfoCell.kt
@@ -38,7 +38,7 @@ class UIItemPlayerInfoCell(
    private val backColInactive = ItemSlotImageFactory.CELLCOLOUR_BLACK
    private val backColActive = ItemSlotImageFactory.CELLCOLOUR_BLACK_ACTIVE

-    private val textRow1 = (((height / 2) - AppLoader.fontGame.lineHeight) / 2).toFloat()
+    private val textRow1 = (((height / 2) - App.fontGame.lineHeight) / 2).toFloat()
    private val textRow2 = textRow1 + (height / 2)

    private val creationTimeStr: String
@@ -62,7 +62,7 @@ class UIItemPlayerInfoCell(


        worldCountStr = Lang["CONTEXT_WORLD_COUNT"] + saveInfo.get("worlds").asIntArray().size
-        worldCountStrWidth = AppLoader.fontGame.getWidth(worldCountStr)
+        worldCountStrWidth = App.fontGame.getWidth(worldCountStr)
    }

    override fun render(batch: SpriteBatch, camera: Camera) {
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIItemSavegameInfoCell.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIItemSavegameInfoCell.kt
@@ -2,8 +2,7 @@ package net.torvald.terrarum.modulebasegame.ui

 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.Terrarum
+import net.torvald.terrarum.App
 import net.torvald.terrarum.ui.UICanvas
 import net.torvald.terrarum.ui.UIItem
 import java.io.File
@@ -21,7 +20,7 @@ class UIItemSavegameInfoCell(
        initialY: Int
 ) : UIItem(parent, initialX, initialY) {

-    override val height: Int = AppLoader.fontGame.lineHeight.toInt() * 2
+    override val height: Int = App.fontGame.lineHeight.toInt() * 2

    override fun render(batch: SpriteBatch, camera: Camera) {

--- a/src/net/torvald/terrarum/modulebasegame/ui/UIPaletteSelector.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIPaletteSelector.kt
@@ -5,12 +5,11 @@ import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.Pixmap
 import com.badlogic.gdx.graphics.Texture
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.blendNormal
 import net.torvald.terrarum.blockproperties.Block
 import net.torvald.terrarum.fillRect
 import net.torvald.terrarum.gameitem.ItemID
-import net.torvald.terrarum.itemproperties.ItemCodex
 import net.torvald.terrarum.modulebasegame.BuildingMaker
 import net.torvald.terrarum.modulebasegame.ui.ItemSlotImageFactory.CELLCOLOUR_BLACK
 import net.torvald.terrarum.ui.UICanvas
@@ -28,7 +27,7 @@ class UIPaletteSelector(val parent: BuildingMaker) : UICanvas() {

    val LINE_HEIGHT = 24
    val TEXT_OFFSETX = 3f
-    val TEXT_OFFSETY = (LINE_HEIGHT - AppLoader.fontGame.lineHeight) / 2f
+    val TEXT_OFFSETY = (LINE_HEIGHT - App.fontGame.lineHeight) / 2f

    fun mouseOnTitleBar() =
            relativeMouseX in 0 until width && relativeMouseY in 0 until LINE_HEIGHT
@@ -80,7 +79,7 @@ class UIPaletteSelector(val parent: BuildingMaker) : UICanvas() {

        // draw "Pal."
        batch.color = UINSMenu.DEFAULT_TITLETEXTCOL
-        AppLoader.fontGame.draw(batch, titleText, TEXT_OFFSETX, TEXT_OFFSETY)
+        App.fontGame.draw(batch, titleText, TEXT_OFFSETX, TEXT_OFFSETY)

        // draw background
        batch.color = CELLCOLOUR_BLACK
@@ -91,7 +90,7 @@ class UIPaletteSelector(val parent: BuildingMaker) : UICanvas() {
        // TODO carve the overlap
        batch.draw(ItemCodex.getItemImage(back), 14f, 41f)
        batch.draw(ItemCodex.getItemImage(fore), 6f, 33f)
-        AppLoader.fontSmallNumbers.draw(batch, fore.toString(), 3f, 61f)
+        App.fontSmallNumbers.draw(batch, fore.toString(), 3f, 61f)

        // draw swap icon
        batch.color = Color.WHITE
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIProxyNewBuildingMaker.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIProxyNewBuildingMaker.kt
@@ -2,7 +2,7 @@ package net.torvald.terrarum.modulebasegame.ui

 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.SanicLoadScreen
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.Terrarum
@@ -32,11 +32,11 @@ class UIProxyNewBuildingMaker : UICanvas() {
    }

    override fun endOpening(delta: Float) {
-        val ingame = BuildingMaker(AppLoader.batch)
+        val ingame = BuildingMaker(App.batch)

        Terrarum.setCurrentIngameInstance(ingame)
        SanicLoadScreen.screenToLoad = ingame
-        AppLoader.setLoadScreen(SanicLoadScreen)
+        App.setLoadScreen(SanicLoadScreen)
    }

    override fun endClosing(delta: Float) {
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIProxyNewRandomGame.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIProxyNewRandomGame.kt
@@ -3,8 +3,8 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import net.torvald.random.HQRNG
-import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.AppLoader.printdbg
+import net.torvald.terrarum.App
+import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.modulebasegame.TerrarumIngame
@@ -37,7 +37,7 @@ class UIProxyNewRandomGame : UICanvas() {
        printdbg(this, "endOpening")


-        val ingame = TerrarumIngame(AppLoader.batch)
+        val ingame = TerrarumIngame(App.batch)
 //        val worldParam = TerrarumIngame.NewWorldParameters(2400, 1280, 0x51621DL)
        val worldParam = TerrarumIngame.NewWorldParameters(2400, 1280, HQRNG().nextLong())

@@ -52,7 +52,7 @@ class UIProxyNewRandomGame : UICanvas() {
        //LoadScreen.screenToLoad = ingame
        //AppLoader.setScreen(LoadScreen)
        val loadScreen = WorldgenLoadScreen(ingame, worldParam.width, worldParam.height)
-        AppLoader.setLoadScreen(loadScreen)
+        App.setLoadScreen(loadScreen)
    }

    override fun endClosing(delta: Float) {
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIQuickslotBar.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIQuickslotBar.kt
@@ -3,12 +3,11 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.gameactors.AVKey
 import net.torvald.terrarum.gameworld.fmod
-import net.torvald.terrarum.itemproperties.ItemCodex
 import net.torvald.terrarum.modulebasegame.TerrarumIngame
 import net.torvald.terrarum.ui.UICanvas
 import net.torvald.terrarum.*
@@ -23,7 +22,7 @@ class UIQuickslotBar : UICanvas() {

    private val gutter = 10 - 6 // do -6 to get a gutter size of not-enlarged cells
    override var width: Int = cellSize * SLOT_COUNT + gutter * (SLOT_COUNT - 1) // 452
-    override var height: Int = ItemSlotImageFactory.slotImage.tileH + 4 + AppLoader.fontGame.lineHeight.toInt()
+    override var height: Int = ItemSlotImageFactory.slotImage.tileH + 4 + App.fontGame.lineHeight.toInt()
    /**
     * In milliseconds
     */
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIQuickslotPie.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIQuickslotPie.kt
@@ -4,11 +4,10 @@ import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import com.jme3.math.FastMath
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.gameactors.AVKey
-import net.torvald.terrarum.itemproperties.ItemCodex
 import net.torvald.terrarum.modulebasegame.TerrarumIngame
 import net.torvald.terrarum.modulebasegame.ui.UIQuickslotBar.Companion.COMMON_OPEN_CLOSE
 import net.torvald.terrarum.modulebasegame.ui.UIQuickslotBar.Companion.SLOT_COUNT
@@ -50,7 +49,7 @@ class UIQuickslotPie : UICanvas() {
        // update controls
        if (handler.isOpened || handler.isOpening) {
            val cursorPos = Vector2(Terrarum.mouseScreenX.toDouble(), Terrarum.mouseScreenY.toDouble())
-            val centre = Vector2(AppLoader.screenSize.halfScreenW.toDouble(), AppLoader.screenSize.halfScreenH.toDouble())
+            val centre = Vector2(App.scr.halfw.toDouble(), App.scr.halfh.toDouble())
            val deg = -(centre - cursorPos).direction.toFloat()

            selection = Math.round(deg * slotCount / FastMath.TWO_PI)
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIRemoCon.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIRemoCon.kt
@@ -5,8 +5,8 @@ import com.badlogic.gdx.Input
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.AppLoader.printdbgerr
+import net.torvald.terrarum.App
+import net.torvald.terrarum.App.printdbgerr
 import net.torvald.terrarum.QNDTreeNode
 import net.torvald.terrarum.Yaml
 import net.torvald.terrarum.ui.UICanvas
@@ -295,7 +295,7 @@ open class UIRemoCon(treeRepresentation: QNDTreeNode<String>) : UICanvas() {
        val remoConWidth = 300
        fun getRemoConHeight(menu: ArrayList<String>) = DEFAULT_LINE_HEIGHT * menu.size.plus(1)
        fun getRemoConHeight(menu: Array<String>) = DEFAULT_LINE_HEIGHT * menu.size.plus(1)
-        val menubarOffX: Int; get() = (0.11 * AppLoader.screenSize.screenW).toInt()
-        val menubarOffY: Int; get() = (0.82 * AppLoader.screenSize.screenH).toInt()
+        val menubarOffX: Int; get() = (0.11 * App.scr.width).toInt()
+        val menubarOffY: Int; get() = (0.82 * App.scr.height).toInt()
    }
 }
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIScreenZoom.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIScreenZoom.kt
@@ -4,7 +4,7 @@ import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import net.torvald.EMDASH
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.TerrarumScreenSize
 import net.torvald.terrarum.keyToIcon
@@ -17,13 +17,13 @@ import net.torvald.terrarum.ui.UICanvas
 * Created by minjaesong on 2019-08-11.
 */
 class UIScreenZoom : UICanvas(
-        AppLoader.getConfigInt("config_keyzoom")
+        App.getConfigInt("config_keyzoom")
 ) {

    val zoomText = "${keyToIcon(handler.toggleKeyLiteral!!)} $EMDASH Zoom Out"

-    override var width = AppLoader.fontGame.getWidth(zoomText)
-    override var height = AppLoader.fontGame.lineHeight.toInt()
+    override var width = App.fontGame.getWidth(zoomText)
+    override var height = App.fontGame.lineHeight.toInt()

    override var openCloseTime = 0.15f

@@ -38,10 +38,10 @@ class UIScreenZoom : UICanvas(
    override fun renderUI(batch: SpriteBatch, camera: Camera) {
        batch.color = Color.WHITE

-        AppLoader.fontGame.draw(
+        App.fontGame.draw(
                batch, zoomText,
-                (AppLoader.screenSize.screenW * TerrarumScreenSize.TV_SAFE_GRAPHICS + 1).toInt().toFloat(),
-                (AppLoader.screenSize.screenH - height - AppLoader.screenSize.tvSafeGraphicsHeight).toFloat()
+                (App.scr.width * TerrarumScreenSize.TV_SAFE_GRAPHICS + 1).toInt().toFloat(),
+                (App.scr.height - height - App.scr.tvSafeGraphicsHeight).toFloat()
        )
    }

--- a/src/net/torvald/terrarum/modulebasegame/ui/UITierOneWatch.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UITierOneWatch.kt
@@ -5,7 +5,6 @@ import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import net.torvald.terrarum.*
-import net.torvald.terrarum.modulebasegame.gameactors.ActorHumanoid
 import net.torvald.terrarum.gameworld.WorldTime
 import net.torvald.terrarum.modulebasegame.imagefont.WatchFont
 import net.torvald.terrarum.ui.UICanvas
@@ -46,7 +45,7 @@ class UITierOneWatch() : UICanvas() {
            ELuptimer += delta
        }

-        if (mouseUp || Gdx.input.isKeyPressed(AppLoader.getConfigInt("config_keyinteract"))) {
+        if (mouseUp || Gdx.input.isKeyPressed(App.getConfigInt("config_keyinteract"))) {
            ELuptimer = 0f
            ELon = true
        }
--- a/src/net/torvald/terrarum/modulebasegame/ui/UITitleCharactersList.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UITitleCharactersList.kt
@@ -3,7 +3,7 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.blendNormal
 import net.torvald.terrarum.ui.UICanvas
@@ -19,8 +19,8 @@ class UITitleCharactersList : UICanvas() {
    private val moduleAreaHMargin = 48
    private val moduleAreaBorder = 8

-    override var width = AppLoader.screenSize.screenW - UIRemoCon.remoConWidth - moduleAreaHMargin
-    override var height = AppLoader.screenSize.screenH - moduleAreaHMargin * 2
+    override var width = App.scr.width - UIRemoCon.remoConWidth - moduleAreaHMargin
+    override var height = App.scr.height - moduleAreaHMargin * 2

    private val moduleInfoCells = ArrayList<UIItemSavegameInfoCell>()
    // build characters list
--- a/src/net/torvald/terrarum/modulebasegame/ui/UITitleLanguage.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UITitleLanguage.kt
@@ -3,7 +3,7 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.langpack.Lang
 import net.torvald.terrarum.ui.UICanvas
@@ -20,14 +20,14 @@ class UITitleLanguage : UICanvas() {


    private val textAreaHMargin = 48
-    override var width = (AppLoader.screenSize.screenW * 0.75).toInt()
-    override var height = AppLoader.screenSize.screenH - textAreaHMargin * 2
+    override var width = (App.scr.width * 0.75).toInt()
+    override var height = App.scr.height - textAreaHMargin * 2

    private val localeList = Lang.languageList.toList().sorted()
    private val textArea = UIItemTextButtonList(this,
            24,
            localeList.map { Lang.langpack["MENU_LANGUAGE_THIS_$it"] ?: "!ERR: $it" }.toTypedArray(),
-            AppLoader.screenSize.screenW - width, textAreaHMargin,
+            App.scr.width - width, textAreaHMargin,
            width, height,
            textAreaWidth = width,
            readFromLang = false,
@@ -51,7 +51,7 @@ class UITitleLanguage : UICanvas() {

        // attach listeners
        textArea.selectionChangeListener = { _, newSelectionIndex ->
-            AppLoader.GAME_LOCALE = localeList[newSelectionIndex]
+            App.GAME_LOCALE = localeList[newSelectionIndex]
        }


--- a/src/net/torvald/terrarum/modulebasegame/ui/UITitleModules.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UITitleModules.kt
@@ -3,7 +3,7 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.ModMgr
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.blendNormal
@@ -21,8 +21,8 @@ class UITitleModules : UICanvas() {
    private val moduleAreaHMargin = 48
    private val moduleAreaBorder = 8

-    override var width = AppLoader.screenSize.screenW - UIRemoCon.remoConWidth - moduleAreaHMargin
-    override var height = AppLoader.screenSize.screenH - moduleAreaHMargin * 2
+    override var width = App.scr.width - UIRemoCon.remoConWidth - moduleAreaHMargin
+    override var height = App.scr.height - moduleAreaHMargin * 2


    private val moduleInfoCells = ArrayList<UIItemModuleInfoCell>()
--- a/src/net/torvald/terrarum/modulebasegame/ui/UITitleRemoConYaml.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UITitleRemoConYaml.kt
@@ -1,6 +1,6 @@
 package net.torvald.terrarum.modulebasegame.ui

-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Yaml


@@ -42,7 +42,7 @@ object UITitleRemoConYaml {
         - MENU_LABEL_RETURN
        """.trimIndent()*/

-    operator fun invoke() = if (AppLoader.IS_DEVELOPMENT_BUILD)
+    operator fun invoke() = if (App.IS_DEVELOPMENT_BUILD)
        Yaml(menus + "\n" + debugTools).parse()
    else
        Yaml(menus).parse()
--- a/src/net/torvald/terrarum/modulebasegame/ui/UITitleWallOfText.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UITitleWallOfText.kt
@@ -3,7 +3,7 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.CreditSingleton
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.ui.UICanvas
@@ -15,8 +15,8 @@ open class UITitleWallOfText(private val text: List<String>) : UICanvas() {


    private val textAreaHMargin = 48
-    override var width = AppLoader.screenSize.screenW - UIRemoCon.remoConWidth - textAreaHMargin
-    override var height = AppLoader.screenSize.screenH - textAreaHMargin * 2
+    override var width = App.scr.width - UIRemoCon.remoConWidth - textAreaHMargin
+    override var height = App.scr.height - textAreaHMargin * 2
    private val textArea = UIItemTextArea(this,
            UIRemoCon.remoConWidth, textAreaHMargin,
            width, height
--- a/src/net/torvald/terrarum/modulebasegame/ui/UITooltip.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UITooltip.kt
@@ -3,7 +3,7 @@ package net.torvald.terrarum.modulebasegame.ui
 import com.badlogic.gdx.graphics.Camera
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.Terrarum
 import net.torvald.terrarum.ui.UICanvas
@@ -28,7 +28,7 @@ class UITooltip : UICanvas() {
            msgWidth = msgBuffer.maxOf { font.getWidth(it) }
        }

-    private val font = AppLoader.fontGame
+    private val font = App.fontGame
    private var msgWidth = 0

    val textMarginX = 4
--- a/src/net/torvald/terrarum/modulebasegame/ui/UIVitalMetre.kt
+++ b/src/net/torvald/terrarum/modulebasegame/ui/UIVitalMetre.kt
@@ -5,7 +5,7 @@ import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import com.jme3.math.FastMath
 import net.torvald.colourutil.darkerLab
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.Second
 import net.torvald.terrarum.modulebasegame.gameactors.ActorHumanoid
 import net.torvald.terrarum.ui.UICanvas
@@ -50,8 +50,8 @@ class UIVitalMetre(

    override fun updateUI(delta: Float) {
        handler.setPosition(
-                AppLoader.screenSize.halfScreenW,
-                AppLoader.screenSize.halfScreenH
+                App.scr.halfw,
+                App.scr.halfh
        )
    }

--- a/src/net/torvald/terrarum/modulebasegame/worldgenerator/Biomegen.kt
+++ b/src/net/torvald/terrarum/modulebasegame/worldgenerator/Biomegen.kt
@@ -1,18 +1,16 @@
 package net.torvald.terrarum.modulebasegame.worldgenerator

-import com.badlogic.gdx.graphics.Pixmap
 import com.sudoplay.joise.Joise
 import com.sudoplay.joise.module.ModuleAutoCorrect
 import com.sudoplay.joise.module.ModuleBasisFunction
 import com.sudoplay.joise.module.ModuleFractal
 import com.sudoplay.joise.module.ModuleScaleDomain
-import net.torvald.terrarum.AppLoader
+import net.torvald.terrarum.App
 import net.torvald.terrarum.blockproperties.Block
 import net.torvald.terrarum.concurrent.ThreadExecutor
 import net.torvald.terrarum.concurrent.sliceEvenly
 import net.torvald.terrarum.gameworld.GameWorld
 import net.torvald.terrarum.gameworld.fmod
-import java.util.concurrent.Future
 import kotlin.math.cos
 import kotlin.math.sin

@@ -49,7 +47,7 @@ class Biomegen(world: GameWorld, seed: Long, params: Any) : Gen(world, seed, par

        ThreadExecutor.join()

-        AppLoader.printdbg(this, "Waking up Worldgen")
+        App.printdbg(this, "Waking up Worldgen")
    }

    companion object {
--- a/src/net/torvald/terrarum/modulebasegame/worldgenerator/Terragen.kt
+++ b/src/net/torvald/terrarum/modulebasegame/worldgenerator/Terragen.kt
@@ -3,14 +3,11 @@ package net.torvald.terrarum.modulebasegame.worldgenerator
 import com.sudoplay.joise.Joise
 import com.sudoplay.joise.module.*
 import net.torvald.random.XXHash32
-import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.AppLoader.printdbg
+import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.blockproperties.Block
 import net.torvald.terrarum.concurrent.ThreadExecutor
 import net.torvald.terrarum.concurrent.sliceEvenly
 import net.torvald.terrarum.gameworld.GameWorld
-import net.torvald.terrarum.toInt
-import java.util.concurrent.Future
 import kotlin.math.cos
 import kotlin.math.sin

--- a/src/net/torvald/terrarum/modulebasegame/worldgenerator/WorldGenerator.kt.unused
+++ b/src/net/torvald/terrarum/modulebasegame/worldgenerator/WorldGenerator.kt.unused
@@ -4,8 +4,8 @@ import com.jme3.math.FastMath
 import com.sudoplay.joise.Joise
 import com.sudoplay.joise.module.*
 import net.torvald.random.HQRNG
-import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.AppLoader.printdbg
+import net.torvald.terrarum.App
+import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.blockproperties.Block
 import net.torvald.terrarum.blockproperties.BlockCodex
 import net.torvald.terrarum.concurrent.ThreadParallel
--- a/src/net/torvald/terrarum/modulebasegame/worldgenerator/Worldgen.kt
+++ b/src/net/torvald/terrarum/modulebasegame/worldgenerator/Worldgen.kt
@@ -1,9 +1,8 @@
 package net.torvald.terrarum.modulebasegame.worldgenerator

-import net.torvald.terrarum.AppLoader
-import net.torvald.terrarum.AppLoader.printdbg
+import net.torvald.terrarum.App
+import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.gameworld.GameWorld
-import java.util.concurrent.Callable

 /**
 * New world generator.
@@ -35,7 +34,7 @@ object Worldgen {

            val it = jobs[i]

-            AppLoader.getLoadScreen().addMessage(it.loadingScreenName)
+            App.getLoadScreen().addMessage(it.loadingScreenName)
            it.theWork.getDone()
        }