more axe wip

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

@@ -18,6 +18,7 @@ import net.torvald.terrarum.gameitems.ItemID
 import net.torvald.terrarum.gameparticles.createRandomBlockParticle
 import net.torvald.terrarum.gameworld.BlockAddress
 import net.torvald.terrarum.gameworld.GameWorld
+import net.torvald.terrarum.itemproperties.Calculate
 import net.torvald.terrarum.modulebasegame.TerrarumIngame
 import net.torvald.terrarum.modulebasegame.gameactors.ActorHumanoid
 import net.torvald.terrarum.modulebasegame.gameactors.IngamePlayer
@@ -356,9 +357,6 @@ open class ActorWithBody : Actor {
     @Transient internal val BASE_FRICTION = 0.3
 
     @Transient internal val BASE_FALLDAMAGE_DAMPEN = 50.0
-    val fallDamageDampening: Double
-        get() = BASE_FALLDAMAGE_DAMPEN * (actorValue.getAsDouble(AVKey.FALLDAMPENMULT) ?: 1.0)
-
 
     var collisionType = COLLISION_DYNAMIC
 
@@ -1107,10 +1105,9 @@ open class ActorWithBody : Actor {
 //                    val avrFeetTileStrength = feetTileStregthSum.toDouble() / feetTileCount
 //                    val adjustedTileStr = avrFeetTileStrength / 1176
 //                    val fallDamageDampenMult = (adjustedTileStr / (adjustedTileStr + 1)).sqr()
-                    val fallDamageDampenMult = (32.0 / 1176.0).sqr()
+
-                    // slam-into-whatever damage (such dirty; much hack; wow)
+                    collisionDamage = Calculate.collisionDamage(this, vectorSum)
-                    //                                                   vvvv hack (supposed to be 1.0)                           vvv 50% hack
+
-                    collisionDamage = mass * (vectorSum.magnitude / (10.0 / Terrarum.PHYS_TIME_FRAME).sqr()) * fallDamageDampenMult * GAME_TO_SI_ACC
                     // kg * m / s^2 (mass * acceleration), acceleration -> (vectorMagn / (0.01)^2).gameToSI()
                     // take material softness(?) into account
                     if (collisionDamage != 0.0) debug1("Collision damage: $collisionDamage N")

src/net/torvald/terrarum/itemproperties/Calculate.kt

@@ -1,7 +1,12 @@
 package net.torvald.terrarum.itemproperties
 
+import net.torvald.terrarum.Terrarum
+import net.torvald.terrarum.gameactors.AVKey
 import net.torvald.terrarum.gameactors.ActorWithBody
+import net.torvald.terrarum.gameactors.ActorWithBody.Companion.GAME_TO_SI_ACC
+import net.torvald.terrarum.sqr
 import net.torvald.terrarum.sqrt
+import org.dyn4j.geometry.Vector2
 
 /**
  * Created by minjaesong on 2017-04-17.
@@ -20,6 +25,18 @@ object Calculate {
         return (16.0 * (material?.forceMod?.toDouble() ?: 1.0).sqrt() * (actor.avStrength / 1000.0)).toFloat()
     }
 
+    @JvmStatic fun hatchetPower(actor: ActorWithBody, material: Material?): Float {
+        return (8.0 * (material?.forceMod?.toDouble() ?: 1.0).sqrt() * (actor.avStrength / 1000.0)).toFloat()
+    }
+
+    private val fallDamageDampenMult = (32.0 / 1176.0).sqr()
+    @JvmStatic fun collisionDamage(actor: ActorWithBody, movement: Vector2): Double {
+        return actor.mass * (movement.magnitude / (10.0 / Terrarum.PHYS_TIME_FRAME).sqr()) *
+                fallDamageDampenMult * // dampen factor (magic number)
+                (actor.actorValue.getAsDouble(AVKey.FALLDAMPENMULT) ?: 1.0) * // additional dampen factor (actorvalue)
+                GAME_TO_SI_ACC // unit conversion
+    }
+
 
     fun armorwhatever() { TODO() }
     fun yogafire() { TODO() }

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

@@ -103,7 +103,7 @@ open class FancyWorldReadLoadScreen(screenToBeLoaded: IngameInstance, private va
     }
 
     protected open fun getStage(): Int {
-        return 3 // fixed value for Read screen
+        return 5 // fixed value for Read screen
     }
 
     protected val batchColour = Color(-1) // create new Color instance just for the progress bar

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

@@ -667,7 +667,7 @@ open class TerrarumIngame(batch: FlippingSpriteBatch) : IngameInstance(batch) {
         ItemCodex[itemOnGrip]?.endPrimaryUse(actor, delta)
 
         if (canPerformBarehandAction) {
-            actor.actorValue.set(AVKey.__ACTION_TIMER, 0.0)
+            endPerformBarehandAction(actor)
         }
     }
 
@@ -1389,6 +1389,20 @@ open class TerrarumIngame(batch: FlippingSpriteBatch) : IngameInstance(batch) {
         particlesContainer.appendHead(particle)
     }
 
+    private var barehandAxeInUse = false
+    private var barehandPickInUse = false
+
+    fun endPerformBarehandAction(actor: ActorWithBody) {
+        if (barehandAxeInUse) {
+            barehandAxeInUse = false
+            AxeCore.endPrimaryUse(actor, null)
+        }
+        if (barehandPickInUse) {
+            barehandPickInUse = false
+            PickaxeCore.endPrimaryUse(actor, null)
+        }
+    }
+
     fun performBarehandAction(actor: ActorWithBody, delta: Float, mwx: Double, mwy: Double, mtx: Int, mty: Int) {
 
         val canAttackOrDig = actor.scale * actor.baseHitboxH >= (actor.actorValue.getAsDouble(AVKey.BAREHAND_MINHEIGHT) ?: 4294967296.0)
@@ -1450,6 +1464,7 @@ open class TerrarumIngame(batch: FlippingSpriteBatch) : IngameInstance(batch) {
         }
         // TODO punch a small tree/shrub
         else if (mouseUnderPunchableTreeTrunk) {
+            barehandAxeInUse = true
             AxeCore.startPrimaryUse(actor, delta, null, mtx, mty, punchBlockSize.coerceAtLeast(1), punchBlockSize.coerceAtLeast(1), listOf("TREESMALL"))
         }
         // TODO attack a mob
@@ -1458,6 +1473,7 @@ open class TerrarumIngame(batch: FlippingSpriteBatch) : IngameInstance(batch) {
         // else, punch a block
         else if (canAttackOrDig) {
             if (punchBlockSize > 0) {
+                barehandPickInUse = true
                 PickaxeCore.startPrimaryUse(actor, delta, null, mtx, mty, 1.0 / punchBlockSize, punchBlockSize, punchBlockSize)
             }
         }

src/net/torvald/terrarum/modulebasegame/gameitems/AxeCore.kt

@@ -67,22 +67,24 @@ object AxeCore {
 
                 INGAME.world.inflictTerrainDamage(
                     x, y,
-                    Calculate.pickaxePower(actor, item?.material) * swingDmgToFrameDmg
+                    Calculate.hatchetPower(actor, item?.material) * swingDmgToFrameDmg
                 ).let { tileBroken ->
                     // tile busted
                     if (tileBroken != null) {
-                        // make tree fell by scanning upwards
+                        var upCtr = 0
-                        TODO()
+                        while (true) {
-                        var drop = ""
+                            val tileHere = INGAME.world.getTileFromTerrain(x, y - upCtr)
-                        if (drop.isNotBlank()) {
+
-                            INGAME.queueActorAddition(
+                            if (BlockCodex[tileHere].hasTag("TREETRUNK")) {
-                                DroppedItem(
+                                PickaxeCore.dropItem(tileHere, x, y - upCtr) // todo use log item
-                                    drop,
+                            }
-                                    (x + 0.5) * TerrarumAppConfiguration.TILE_SIZED,
+                            else { // TODO check for leaves
-                                    (y + 1.0) * TerrarumAppConfiguration.TILE_SIZED
+                                break
-                                )
+                            }
-                            )
+
+                            upCtr += 1
                         }
+
                         PickaxeCore.makeDust(tile, x, y, 9)
                     }
                     // tile not busted
@@ -104,45 +106,8 @@ object AxeCore {
         usageStatus
     }
 
-    private val pixelOffs = intArrayOf(2, 7, 12) // hard-coded assuming TILE_SIZE=16
+    fun endPrimaryUse(actor: ActorWithBody, item: GameItem?): Boolean {
-    fun makeDust(tile: ItemID, x: Int, y: Int, density: Int = 9, drawCol: Color = Color.WHITE) {
+        item?.using = false
-        val pw = 3
-        val ph = 3
-        val xo = App.GLOBAL_RENDER_TIMER and 1
-        val yo = App.GLOBAL_RENDER_TIMER.ushr(1) and 1
-
-        val renderTag = App.tileMaker.getRenderTag(tile)
-        val baseTilenum = renderTag.tileNumber
-        val representativeTilenum = when (renderTag.maskType) {
-            CreateTileAtlas.RenderTag.MASK_47 -> 17
-            CreateTileAtlas.RenderTag.MASK_PLATFORM -> 7
-            else -> 0
-        }
-        val tileNum = baseTilenum + representativeTilenum // the particle won't match the visible tile anyway because of the seasons stuff
-
-        val indices = (0..8).toList().shuffled().subList(0, density)
-        for (it in indices) {
-            val u = pixelOffs[it % 3]
-            val v = pixelOffs[it / 3]
-            val pos = Vector2(
-                TerrarumAppConfiguration.TILE_SIZED * x + u + xo + 0.5,
-                TerrarumAppConfiguration.TILE_SIZED * y + v + yo + 2,
-            )
-            val veloMult = Vector2(
-                1.0 * (if (Math.random() < 0.5) -1 else 1),
-                (2.0 - (it / 3)) / 2.0 // 1, 0.5, 0
-            )
-            createRandomBlockParticle(tileNum, pos, veloMult, u, v, pw, ph).let {
-                it.despawnUponCollision = true
-                it.drawColour.set(drawCol)
-                (Terrarum.ingame as TerrarumIngame).addParticle(it)
-            }
-        }
-    }
-
-    fun endPrimaryUse(actor: ActorWithBody, delta: Float, item: GameItem): Boolean {
-
-        item.using = false
         // reset action timer to zero
         actor.actorValue.set(AVKey.__ACTION_TIMER, 0.0)
         return true

src/net/torvald/terrarum/modulebasegame/gameitems/PickaxeGeneric.kt

@@ -102,7 +102,7 @@ object PickaxeCore {
                             BlockCodex[tileBroken].drop
 
                         if (drop.isNotBlank()) {
-                            INGAME.queueActorAddition(DroppedItem(drop, (x + 0.5) * TILE_SIZED, (y + 1.0) * TILE_SIZED))
+                            dropItem(drop, x, y)
                         }
                         makeDust(tile, x, y, 9)
                     }
@@ -120,6 +120,16 @@ object PickaxeCore {
         usageStatus
     }
 
+    fun dropItem(item: ItemID, tx: Int, ty: Int) {
+        INGAME.queueActorAddition(
+            DroppedItem(
+                item,
+                (tx + 0.5) * TerrarumAppConfiguration.TILE_SIZED,
+                (ty + 1.0) * TerrarumAppConfiguration.TILE_SIZED
+            )
+        )
+    }
+
     private val pixelOffs = intArrayOf(2, 7, 12) // hard-coded assuming TILE_SIZE=16
     fun makeDust(tile: ItemID, x: Int, y: Int, density: Int = 9, drawCol: Color = Color.WHITE) {
         val pw = 3
@@ -156,9 +166,8 @@ object PickaxeCore {
         }
     }
 
-    fun endPrimaryUse(actor: ActorWithBody, delta: Float, item: GameItem): Boolean {
+    fun endPrimaryUse(actor: ActorWithBody, item: GameItem?): Boolean {
-
+        item?.using = false
-        item.using = false
         // reset action timer to zero
         actor.actorValue.set(AVKey.__ACTION_TIMER, 0.0)
         return true
@@ -219,7 +228,7 @@ class PickaxeCopper(originalID: ItemID) : GameItem(originalID) {
 
     override fun startPrimaryUse(actor: ActorWithBody, delta: Float) =
             if (PickaxeCore.startPrimaryUse(actor, delta, this, Terrarum.mouseTileX, Terrarum.mouseTileY)) 0L else -1L
-    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = PickaxeCore.endPrimaryUse(actor, delta, this)
+    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = PickaxeCore.endPrimaryUse(actor, this)
     override fun effectWhileEquipped(actor: ActorWithBody, delta: Float) = PickaxeCore.showOresTooltip(actor, this, Terrarum.mouseTileX, Terrarum.mouseTileY)
     override fun effectOnUnequip(actor: ActorWithBody) { INGAME.setTooltipMessage(null) }
 
@@ -249,7 +258,7 @@ class PickaxeIron(originalID: ItemID) : GameItem(originalID) {
 
     override fun startPrimaryUse(actor: ActorWithBody, delta: Float) =
             if (PickaxeCore.startPrimaryUse(actor , delta, this, Terrarum.mouseTileX, Terrarum.mouseTileY)) 0L else -1L
-    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = PickaxeCore.endPrimaryUse(actor, delta, this)
+    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = PickaxeCore.endPrimaryUse(actor, this)
     override fun effectWhileEquipped(actor: ActorWithBody, delta: Float) = PickaxeCore.showOresTooltip(actor, this, Terrarum.mouseTileX, Terrarum.mouseTileY)
     override fun effectOnUnequip(actor: ActorWithBody) { INGAME.setTooltipMessage(null) }
 
@@ -279,7 +288,7 @@ class PickaxeSteel(originalID: ItemID) : GameItem(originalID) {
 
     override fun startPrimaryUse(actor: ActorWithBody, delta: Float) =
             if (PickaxeCore.startPrimaryUse(actor, delta, this, Terrarum.mouseTileX, Terrarum.mouseTileY)) 0L else -1L
-    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = PickaxeCore.endPrimaryUse(actor, delta, this)
+    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = PickaxeCore.endPrimaryUse(actor, this)
     override fun effectWhileEquipped(actor: ActorWithBody, delta: Float) = PickaxeCore.showOresTooltip(actor, this, Terrarum.mouseTileX, Terrarum.mouseTileY)
     override fun effectOnUnequip(actor: ActorWithBody) { INGAME.setTooltipMessage(null) }
 
@@ -309,7 +318,7 @@ class PickaxeWood(originalID: ItemID) : GameItem(originalID) {
 
     override fun startPrimaryUse(actor: ActorWithBody, delta: Float) =
         if (PickaxeCore.startPrimaryUse(actor, delta, this, Terrarum.mouseTileX, Terrarum.mouseTileY)) 0L else -1L
-    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = PickaxeCore.endPrimaryUse(actor, delta, this)
+    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = PickaxeCore.endPrimaryUse(actor, this)
     override fun effectWhileEquipped(actor: ActorWithBody, delta: Float) = PickaxeCore.showOresTooltip(actor, this, Terrarum.mouseTileX, Terrarum.mouseTileY)
     override fun effectOnUnequip(actor: ActorWithBody) { INGAME.setTooltipMessage(null) }
 

src/net/torvald/terrarum/modulebasegame/gameitems/SledgehammerCore.kt

@@ -101,7 +101,7 @@ object SledgehammerCore {
                     if (Math.random() < dropProbability) {
                         val drop = BlockCodex[tileBroken].drop
                         if (drop.isNotBlank()) {
-                            INGAME.queueActorAddition(DroppedItem("wall@$drop", (x + 0.5) * TILE_SIZED, (y + 1.0) * TILE_SIZED))
+                            PickaxeCore.dropItem("wall@$drop", x, y)
                         }
                         PickaxeCore.makeDust(wall, x, y, 9, WALL_OVERLAY_COLOUR)
                     }
@@ -119,9 +119,8 @@ object SledgehammerCore {
         usageStatus
     }
 
-    fun endPrimaryUse(actor: ActorWithBody, delta: Float, item: GameItem): Boolean {
+    fun endPrimaryUse(actor: ActorWithBody, item: GameItem?): Boolean {
-
+        item?.using = false
-        item.using = false
         // reset action timer to zero
         actor.actorValue.set(AVKey.__ACTION_TIMER, 0.0)
         return true
@@ -152,7 +151,7 @@ class SledgehammerCopper(originalID: ItemID) : GameItem(originalID) {
 
     override fun startPrimaryUse(actor: ActorWithBody, delta: Float) =
         if (SledgehammerCore.startPrimaryUse(actor, delta, this, Terrarum.mouseTileX, Terrarum.mouseTileY)) 0L else -1L
-    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = SledgehammerCore.endPrimaryUse(actor, delta, this)
+    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = SledgehammerCore.endPrimaryUse(actor, this)
 }
 
 class SledgehammerIron(originalID: ItemID) : GameItem(originalID) {
@@ -176,7 +175,7 @@ class SledgehammerIron(originalID: ItemID) : GameItem(originalID) {
 
     override fun startPrimaryUse(actor: ActorWithBody, delta: Float) =
         if (SledgehammerCore.startPrimaryUse(actor , delta, this, Terrarum.mouseTileX, Terrarum.mouseTileY)) 0L else -1L
-    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = SledgehammerCore.endPrimaryUse(actor, delta, this)
+    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = SledgehammerCore.endPrimaryUse(actor, this)
 }
 
 class SledgehammerSteel(originalID: ItemID) : GameItem(originalID) {
@@ -200,7 +199,7 @@ class SledgehammerSteel(originalID: ItemID) : GameItem(originalID) {
 
     override fun startPrimaryUse(actor: ActorWithBody, delta: Float) =
         if (SledgehammerCore.startPrimaryUse(actor, delta, this, Terrarum.mouseTileX, Terrarum.mouseTileY)) 0L else -1L
-    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = SledgehammerCore.endPrimaryUse(actor, delta, this)
+    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = SledgehammerCore.endPrimaryUse(actor, this)
 }
 
 /**
@@ -227,5 +226,5 @@ class SledgehammerWood(originalID: ItemID) : GameItem(originalID) {
 
     override fun startPrimaryUse(actor: ActorWithBody, delta: Float) =
         if (SledgehammerCore.startPrimaryUse(actor, delta, this, Terrarum.mouseTileX, Terrarum.mouseTileY)) 0L else -1L
-    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = SledgehammerCore.endPrimaryUse(actor, delta, this)
+    override fun endPrimaryUse(actor: ActorWithBody, delta: Float) = SledgehammerCore.endPrimaryUse(actor, this)
 }