gotchi-battler-game-logic 4.0.6 → 4.0.7

package/scripts/rerunBattle.js

@@ -6,7 +6,7 @@ const { battle } = require('..')
 
 const main = async () => {
     console.time('Rerun battle')
-    const logs = require('./data/enlightened.json')
+    const logs = require('./data/cleaver2.json')
     const teams = logToInGameTeams(logs)
     const result = await battle(teams[0], teams[1], Number(logs.meta.seed))
 

package/tests/getModifiedStats.test.js

@@ -22,7 +22,8 @@ describe('getModifiedStats', () => {
     it('applies flat stat buffs from statuses', () => {
         const g = makeGotchi({ statuses: ['spd_up', 'atk_up', 'def_up'] })
         const m = getModifiedStats(g)
-        expect(m.speed).to.equal(11)
+        // v2.0 statuses are percent-based; with base speed=10, spd_up (+15%) rounds to +2
+        expect(m.speed).to.equal(12)
         expect(m.attack).to.equal(6)
         expect(m.defense).to.equal(4)
     })
@@ -30,11 +31,15 @@ describe('getModifiedStats', () => {
     it('stacks multiple statuses and nets against opposing debuffs', () => {
         const g = makeGotchi({ statuses: ['spd_up', 'spd_up', 'spd_down'] })
         const m = getModifiedStats(g)
-        expect(m.speed).to.equal(11) // 10 + 1 net
+        // Each spd_up: 10 * 0.15 => 1.5 => Math.round => 2
+        // spd_down: 10 * -0.15 => -1.5 => Math.round => -1 (JS rounds halves toward +∞)
+        // Net: +2 +2 -1 = +3
+        expect(m.speed).to.equal(13)
     })
 
     it('keeps speed at minimum 1 to avoid zero/negative speed', () => {
-        const g = makeGotchi({ speed: 2, statuses: ['spd_down', 'spd_down', 'spd_down'] })
+        // Use a base speed where percent debuffs round to at least -1 per stack
+        const g = makeGotchi({ speed: 4, statuses: ['spd_down', 'spd_down', 'spd_down'] })
         const m = getModifiedStats(g)
         expect(m.speed).to.equal(1)
     })

package/tests/repeatAttack.test.js

@@ -0,0 +1,89 @@
+const { expect } = require('chai')
+const path = require('path')
+
+const { attack } = require(path.join('..', 'game-logic', 'v2.0', 'index'))
+
+const makeStats = () => ({
+    hits: 0,
+    crits: 0,
+    dmgGiven: 0,
+    dmgReceived: 0,
+    counters: 0,
+    focuses: 0,
+    resists: 0,
+})
+
+const makeGotchi = (overrides = {}) => ({
+    id: 1,
+    name: 'Test',
+    speed: 10,
+    attack: 10,
+    defense: 5,
+    criticalRate: 0,
+    criticalDamage: 15,
+    resist: 0,
+    focus: 0,
+    statuses: [],
+    environmentEffects: [],
+    health: 1000,
+    fullHealth: 1000,
+    stats: makeStats(),
+    special: { initialCooldown: 0 },
+    ...overrides,
+})
+
+const makeTeam = (gotchis) => ({
+    leader: gotchis[0]?.id ?? 1,
+    formation: {
+        front: gotchis.slice(0, 3),
+        back: gotchis.slice(3, 5),
+    },
+})
+
+describe('repeat_attack special effect', () => {
+    it('rolls repeat_attack chance once per special use (not once per target)', () => {
+        const attacker = makeGotchi({
+            id: 100,
+            specialExpanded: {
+                actionType: 'attack',
+                target: 'all_enemies',
+                actionMultiplier: 0.5,
+                effects: [
+                    { effectType: 'repeat_attack', target: 'same_as_attack', chance: 0.5 },
+                ],
+            },
+        })
+
+        const enemies = [1, 2, 3, 4, 5].map((n) =>
+            makeGotchi({
+                id: 200 + n,
+                name: `Enemy ${n}`,
+                stats: makeStats(),
+                health: 1000,
+                fullHealth: 1000,
+                environmentEffects: [],
+            })
+        )
+
+        const attackingTeam = makeTeam([attacker])
+        const defendingTeam = makeTeam(enemies)
+
+        // RNG sequence:
+        // - 1 repeat_attack roll (once per special use): 0.6 (fail for chance=0.5)
+        // - 5 crit rolls (one per target): 0.9 (no crit)
+        const seq = [
+            0.6,
+            0.9, 0.9, 0.9, 0.9, 0.9,
+        ]
+        let i = 0
+        const rng = () => {
+            if (i >= seq.length) return 0.99
+            return seq[i++]
+        }
+
+        const result = attack(attacker, attackingTeam, defendingTeam, rng, true)
+        expect(result.repeatAttack).to.equal(false)
+    })
+})
+
+