fix: upgraded unstable bomb causing crash (#204)

* feat: add `runThenDone` helper function to set `isDone` at the end * refactor: use higher-order and scope function * fix: use RandomDamageAction * refactor: cleanups
scarf005 · Apr 28, 2023 · 2e9a7d4 · 2e9a7d4
1 parent 8f79a08
commit 2e9a7d4
Show file tree

Hide file tree

Showing 9 changed files with 107 additions and 192 deletions.
diff --git a/src/main/kotlin/marisa/Action.kt b/src/main/kotlin/marisa/Action.kt
@@ -39,3 +39,8 @@ fun AbstractGameAction.updateContext(block: () -> Unit) {
     block()
     isDone = true
 }
+
+fun AbstractGameAction.runThenDone(fn: (AbstractGameAction) -> Unit) {
+    fn(this)
+    isDone = true
+}
diff --git a/src/main/kotlin/marisa/action/DamageUpAction.kt b/src/main/kotlin/marisa/action/DamageUpAction.kt
@@ -1,10 +1,11 @@
 package marisa.action
 
 import com.megacrit.cardcrawl.actions.AbstractGameAction
+import com.megacrit.cardcrawl.cards.AbstractCard
 import com.megacrit.cardcrawl.cards.AbstractCard.CardType
 import com.megacrit.cardcrawl.core.Settings
 import com.megacrit.cardcrawl.dungeons.AbstractDungeon
-import marisa.MarisaContinued
+import marisa.runThenDone
 
 class DamageUpAction(amount: Int) : AbstractGameAction() {
     init {
@@ -13,17 +14,17 @@ class DamageUpAction(amount: Int) : AbstractGameAction() {
         this.amount = amount
     }
 
-    override fun update() {
-        if (duration == Settings.ACTION_DUR_FAST) {
-            for (c in AbstractDungeon.player.hand.group) {
-                if (c.type == CardType.ATTACK) {
-                    MarisaContinued.logger.info("Milky Way Action : add " + amount + " damage to " + c.cardID)
-                    c.baseDamage += amount
-                    c.applyPowers()
-                    c.flash()
-                }
-            }
-        }
+    private fun upgradeCard(card: AbstractCard) = card.apply {
+        baseDamage += amount
+        isDamageModified = true
+        applyPowers()
+        flash()
+    }
+
+    override fun update() = runThenDone {
+        AbstractDungeon.player.hand.group
+            .filter { it.type == CardType.ATTACK }
+            .forEach(::upgradeCard)
         tickDuration()
     }
 }
diff --git a/src/main/kotlin/marisa/action/MeteoricShowerAction.kt b/src/main/kotlin/marisa/action/MeteoricShowerAction.kt
@@ -8,19 +8,18 @@ import com.megacrit.cardcrawl.core.Settings
 import com.megacrit.cardcrawl.dungeons.AbstractDungeon
 import com.megacrit.cardcrawl.ui.panels.EnergyPanel
 
-class MeteoricShowerAction(number: Int, damage: Int, freeToPlay: Boolean) : AbstractGameAction() {
+class MeteoricShowerAction(number: Int, damage: Int, val freeToPlay: Boolean) :
+    AbstractGameAction() {
     private val p: AbstractPlayer
     private val num: Int
     private val dmg: Int
-    private val f2p: Boolean
 
     init {
         actionType = ActionType.CARD_MANIPULATION
         p = AbstractDungeon.player
         duration = Settings.ACTION_DUR_FAST
         num = number
         dmg = damage
-        f2p = freeToPlay
     }
 
     override fun update() {
@@ -44,20 +43,11 @@ class MeteoricShowerAction(number: Int, damage: Int, freeToPlay: Boolean) : Abst
             }
             AbstractDungeon.handCardSelectScreen.wereCardsRetrieved = true
             AbstractDungeon.handCardSelectScreen.selectedCards.group.clear()
-            if (cnt > 0) {
-                AbstractDungeon.actionManager.addToTop(
-                    UnstableBombAction(
-                        AbstractDungeon.getMonsters().getRandomMonster(true),
-                        dmg,
-                        dmg,
-                        cnt
-                    )
-                )
-            }
+            addToTop(RandomDamageAction(cnt) { dmg })
             AbstractDungeon.gridSelectScreen.selectedCards.clear()
             AbstractDungeon.player.hand.refreshHandLayout()
         }
-        if (!f2p) {
+        if (!freeToPlay) {
             p.energy.use(EnergyPanel.totalCount)
         }
         tickDuration()

diff --git a/src/main/kotlin/marisa/action/RandomDamageAction.kt b/src/main/kotlin/marisa/action/RandomDamageAction.kt
@@ -0,0 +1,38 @@
+package marisa.action
+
+import com.megacrit.cardcrawl.actions.AbstractGameAction
+import com.megacrit.cardcrawl.actions.common.DamageAction
+import com.megacrit.cardcrawl.actions.utility.WaitAction
+import com.megacrit.cardcrawl.cards.DamageInfo
+import com.megacrit.cardcrawl.dungeons.AbstractDungeon
+import marisa.p
+import marisa.runThenDone
+
+
+class RandomDamageAction(
+    private val numTimes: Int,
+    private val getDamage: () -> Int,
+) : AbstractGameAction() {
+
+    private fun doAttack() {
+        marisa.addToTop(
+            DamageAction(
+                AbstractDungeon.getMonsters().getRandomMonster(true),
+                DamageInfo(p, getDamage()),
+                AttackEffect.FIRE
+            ),
+            WaitAction(POST_ATTACK_WAIT_DUR),
+        )
+    }
+
+    override fun update() = runThenDone {
+        if (numTimes > 0) doAttack()
+        if (numTimes > 1) {
+            addToTop(RandomDamageAction(numTimes - 1, getDamage))
+        }
+    }
+
+    companion object {
+        private const val POST_ATTACK_WAIT_DUR = 0.2f
+    }
+}
diff --git a/src/main/kotlin/marisa/action/UnstableBombAction.kt b/src/main/kotlin/marisa/action/UnstableBombAction.kt
diff --git a/src/main/kotlin/marisa/cards/CollectingQuirk.kt b/src/main/kotlin/marisa/cards/CollectingQuirk.kt
@@ -9,7 +9,7 @@ import com.megacrit.cardcrawl.monsters.AbstractMonster
 import com.megacrit.cardcrawl.relics.Circlet
 import com.megacrit.cardcrawl.relics.RedCirclet
 import marisa.MarisaContinued
-import marisa.action.UnstableBombAction
+import marisa.action.RandomDamageAction
 import marisa.patches.AbstractCardEnum
 
 class CollectingQuirk : CustomCard(
@@ -23,35 +23,40 @@ class CollectingQuirk : CustomCard(
     CardRarity.RARE,
     CardTarget.ALL_ENEMY
 ) {
-    private var counter: Int
-
     init {
         baseDamage = ATK_DMG
         baseMagicNumber = DIVIDER
         magicNumber = baseMagicNumber
         baseBlock = 0
         block = baseBlock
-        counter = 0
     }
 
+    private val counter: Int
+        get() {
+            val p = AbstractDungeon.player
+            var divider = DIVIDER
+            if (upgraded) {
+                divider = UPG_DIVIDER
+            }
+            var counter = p.relics.size
+            p.getRelic(Circlet.ID)?.let { counter += it.counter - 1 }
+            p.getRelic(RedCirclet.ID)?.let { counter += it.counter - 1 }
+
+            counter /= divider
+            return counter
+        }
+
     override fun applyPowers() {
         super.applyPowers()
-        getCounter()
         modifyBlock()
         rawDescription = DESCRIPTION + EXTENDED_DESCRIPTION[0]
         initializeDescription()
         MarisaContinued.logger.info(
-            "CollectingQuirk : applyPowers : damage :"
-                    + damage
-                    + " ; counter : " + counter
-                    + " ; block :" + block
-                    + " ; magic number :" + magicNumber
+            """CollectingQuirk : applyPowers : damage :$damage ; counter : ${counter}; block :$block ; magic number :$magicNumber"""
         )
     }
 
     override fun calculateCardDamage(unused: AbstractMonster?) {
-        //super.calculateCardDamage(mo);
-        getCounter()
         modifyBlock()
         rawDescription = DESCRIPTION + EXTENDED_DESCRIPTION[0]
         initializeDescription()
@@ -64,17 +69,7 @@ class CollectingQuirk : CustomCard(
     }
 
     override fun use(p: AbstractPlayer, unused: AbstractMonster?) {
-        getCounter()
-        if (counter > 0) {
-            addToBot(
-                UnstableBombAction(
-                    AbstractDungeon.getMonsters().getRandomMonster(true),
-                    damage,
-                    damage,
-                    counter
-                )
-            )
-        }
+        addToBot(RandomDamageAction(counter) { damage })
     }
 
     override fun onMoveToDiscard() {
@@ -84,19 +79,6 @@ class CollectingQuirk : CustomCard(
 
     override fun makeCopy(): AbstractCard = CollectingQuirk()
 
-    private fun getCounter() {
-        val p = AbstractDungeon.player
-        var divider = DIVIDER
-        if (upgraded) {
-            divider = UPG_DIVIDER
-        }
-        counter = p.relics.size
-        p.getRelic(Circlet.ID)?.let { counter += it.counter - 1 }
-        p.getRelic(RedCirclet.ID)?.let { counter += it.counter - 1 }
-
-        counter /= divider
-    }
-
     override fun upgrade() {
         if (upgraded) return
         upgradeName()

diff --git a/src/main/kotlin/marisa/cards/MeteoricShower.kt b/src/main/kotlin/marisa/cards/MeteoricShower.kt
@@ -5,10 +5,14 @@ import com.megacrit.cardcrawl.cards.AbstractCard
 import com.megacrit.cardcrawl.characters.AbstractPlayer
 import com.megacrit.cardcrawl.core.CardCrawlGame
 import com.megacrit.cardcrawl.monsters.AbstractMonster
+import com.megacrit.cardcrawl.relics.ChemicalX
 import com.megacrit.cardcrawl.ui.panels.EnergyPanel
 import marisa.action.MeteoricShowerAction
 import marisa.patches.AbstractCardEnum
 
+
+private fun Boolean.toInt() = if (this) 1 else 0
+
 class MeteoricShower : CustomCard(
     ID,
     NAME,
@@ -24,20 +28,9 @@ class MeteoricShower : CustomCard(
         baseDamage = ATK_DMG
     }
 
-    override fun calculateCardDamage(unused: AbstractMonster?) {}
     override fun use(p: AbstractPlayer, unused: AbstractMonster?) {
-        var cnt = EnergyPanel.totalCount + 1
-        if (p.hasRelic("Chemical X")) {
-            cnt += 2
-        }
-        addToBot(
-            MeteoricShowerAction(cnt, damage, freeToPlayOnce)
-        )
-        /*
-    if (!this.freeToPlayOnce) {
-      p.energy.use(EnergyPanel.totalCount);
-    }
-    */
+        val cnt = EnergyPanel.totalCount + 1 + p.hasRelic(ChemicalX.ID).toInt() * 2
+        addToBot(MeteoricShowerAction(cnt, damage, freeToPlayOnce))
     }
 
     override fun makeCopy(): AbstractCard = MeteoricShower()

diff --git a/src/main/kotlin/marisa/cards/PowerUp.kt b/src/main/kotlin/marisa/cards/PowerUp.kt
@@ -25,9 +25,7 @@ class PowerUp : CustomCard(
     }
 
     override fun use(p: AbstractPlayer, unused: AbstractMonster?) {
-        addToBot(
-            DamageUpAction(magicNumber)
-        )
+        addToBot(DamageUpAction(magicNumber))
     }
 
     override fun makeCopy(): AbstractCard = PowerUp()