data/cardframes.json

@@ -19,7 +19,9 @@
   "classToFrame": {
     "warrior": "warrior",
     "fighter": "warrior",
+    "crusader": "warrior",
     "page": "warrior",
+    "knight": "warrior",
     "spearman": "warrior",
     "magician": "magician",
     "firepoison": "magician",

data/cards.json

@@ -955,6 +955,463 @@
       "class": "warrior",
       "rarity": "legend"
     },
+    "SlashBlast": {
+      "name": "슬래시 블러스트",
+      "cost": 1,
+      "kind": "Attack",
+      "damage": 7,
+      "aoe": true,
+      "damagePerCombo": 1,
+      "desc": "모든 적에게 피해 7. 콤보당 피해 +1",
+      "image": "863812c5c2f84132ac7465b50ec2283e",
+      "class": "warrior",
+      "rarity": "normal"
+    },
+    "WarriorLeap": {
+      "name": "워리어 리프",
+      "cost": 0,
+      "kind": "Skill",
+      "block": 4,
+      "nextTurnBlock": 4,
+      "exhaust": true,
+      "desc": "방어도 4. 다음 턴 방어도 4. 소멸.",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "warrior",
+      "rarity": "normal"
+    },
+    "LeapAttack": {
+      "name": "리프 어택",
+      "cost": 1,
+      "kind": "Attack",
+      "damage": 3,
+      "hits": 2,
+      "aoe": true,
+      "block": 5,
+      "desc": "모든 적에게 피해 3 x 2회. 방어도 5",
+      "image": "997fa6999aa04dbb97a1dd99025fa2ba",
+      "class": "warrior",
+      "rarity": "normal"
+    },
+    "IronBody": {
+      "name": "아이언 바디",
+      "cost": 1,
+      "kind": "Power",
+      "powerEffect": "blockPerTurn",
+      "value": 3,
+      "thorns": 2,
+      "desc": "매턴 방어도 3. 가시 2",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "warrior",
+      "rarity": "unique"
+    },
+    "WarriorMastery": {
+      "name": "워리어 마스터리",
+      "cost": 1,
+      "kind": "Power",
+      "strength": 1,
+      "dex": 1,
+      "desc": "힘 1. 민첩 1",
+      "image": "e2580523efc6457385114b78ad0d7cce",
+      "class": "warrior",
+      "rarity": "unique"
+    },
+    "Brandish": {
+      "name": "브랜디쉬",
+      "cost": 1,
+      "kind": "Attack",
+      "damage": 4,
+      "hits": 2,
+      "damagePerCombo": 1,
+      "comboGain": 1,
+      "desc": "피해 4 x 2회. 콤보당 피해 +1. 콤보 1 획득",
+      "image": "1bc3e52b330648faae9eafd5a205e37b",
+      "class": "fighter",
+      "rarity": "normal"
+    },
+    "FlashSlash": {
+      "name": "플래시 슬래시",
+      "cost": 1,
+      "kind": "Attack",
+      "damage": 2,
+      "hits": 5,
+      "aoe": true,
+      "block": 4,
+      "comboGain": 2,
+      "exhaust": true,
+      "desc": "모든 적에게 피해 2 x 5회. 방어도 4. 콤보 2 획득. 소멸.",
+      "image": "291b2298db88476f8ae3c6c78f53c9b7",
+      "class": "fighter",
+      "rarity": "unique"
+    },
+    "ComboAttack": {
+      "name": "콤보 어택",
+      "cost": 1,
+      "kind": "Power",
+      "comboOnAttack": 1,
+      "comboMax": 5,
+      "desc": "공격 카드를 사용할 때마다 콤보 1 획득. 최대 5",
+      "image": "e2580523efc6457385114b78ad0d7cce",
+      "class": "fighter",
+      "rarity": "unique"
+    },
+    "SpiritBlade": {
+      "name": "스피릿 블레이드",
+      "cost": 2,
+      "kind": "Power",
+      "strength": 2,
+      "thorns": 5,
+      "desc": "힘 2. 가시 5",
+      "image": "863812c5c2f84132ac7465b50ec2283e",
+      "class": "fighter",
+      "rarity": "unique"
+    },
+    "WeaponMastery": {
+      "name": "웨폰 마스터리",
+      "cost": 1,
+      "kind": "Power",
+      "strength": 1,
+      "attackPlayedDamage": 1,
+      "desc": "힘 1. 공격 카드를 사용할 때마다 대상에게 피해 1",
+      "image": "1bc3e52b330648faae9eafd5a205e37b",
+      "class": "fighter",
+      "rarity": "unique"
+    },
+    "WeaponAcceleration": {
+      "name": "웨폰 액셀레이션",
+      "cost": 1,
+      "kind": "Power",
+      "turnStartDraw": 1,
+      "comboGain": 2,
+      "desc": "콤보 2 획득. 턴 시작 시 카드 1장 추가로 뽑기",
+      "image": "291b2298db88476f8ae3c6c78f53c9b7",
+      "class": "fighter",
+      "rarity": "unique"
+    },
+    "FinalAttack": {
+      "name": "파이널 어택",
+      "cost": 1,
+      "kind": "Power",
+      "attackPlayedDamage": 3,
+      "desc": "공격 카드를 사용할 때마다 대상에게 피해 3",
+      "image": "997fa6999aa04dbb97a1dd99025fa2ba",
+      "class": "fighter",
+      "rarity": "legend"
+    },
+    "FighterPhysicalTraining": {
+      "name": "피지컬 트레이닝",
+      "cost": 2,
+      "kind": "Power",
+      "strength": 1,
+      "dex": 1,
+      "powerEffect": "blockPerTurn",
+      "value": 2,
+      "desc": "힘 1. 민첩 1. 매턴 방어도 2",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "fighter",
+      "rarity": "unique"
+    },
+    "BraveSlash": {
+      "name": "브레이브 슬래시",
+      "cost": 2,
+      "kind": "Attack",
+      "damage": 5,
+      "hits": 3,
+      "damagePerCombo": 1,
+      "comboGain": 1,
+      "desc": "피해 5 x 3회. 콤보당 피해 +1. 콤보 1 획득",
+      "image": "863812c5c2f84132ac7465b50ec2283e",
+      "class": "crusader",
+      "rarity": "normal"
+    },
+    "AuraBlade": {
+      "name": "오라 블레이드",
+      "cost": 2,
+      "kind": "Attack",
+      "damage": 4,
+      "hits": 4,
+      "aoe": true,
+      "pierce": true,
+      "exhaust": true,
+      "desc": "모든 적에게 방어도를 무시하고 피해 4 x 4회. 소멸.",
+      "image": "291b2298db88476f8ae3c6c78f53c9b7",
+      "class": "crusader",
+      "rarity": "legend"
+    },
+    "Rush": {
+      "name": "돌진",
+      "cost": 1,
+      "kind": "Attack",
+      "damage": 8,
+      "aoe": true,
+      "block": 7,
+      "comboGain": 1,
+      "desc": "모든 적에게 피해 8. 방어도 7. 콤보 1 획득",
+      "image": "997fa6999aa04dbb97a1dd99025fa2ba",
+      "class": "crusader",
+      "rarity": "unique"
+    },
+    "ScarringSword": {
+      "name": "스카링 소드",
+      "cost": 2,
+      "kind": "Power",
+      "attackWeak": 1,
+      "desc": "공격 카드로 피해를 주면 대상에게 약화 1",
+      "image": "1bc3e52b330648faae9eafd5a205e37b",
+      "class": "crusader",
+      "rarity": "legend"
+    },
+    "ComboSynergy": {
+      "name": "콤보 시너지",
+      "cost": 2,
+      "kind": "Power",
+      "comboOnAttack": 1,
+      "comboMax": 5,
+      "attackDamagePerCombo": 1,
+      "desc": "공격마다 콤보 1 획득. 모든 공격이 콤보당 피해 +1. 최대 5",
+      "image": "e2580523efc6457385114b78ad0d7cce",
+      "class": "crusader",
+      "rarity": "legend"
+    },
+    "SelfRecovery": {
+      "name": "셀프 리커버리",
+      "cost": 1,
+      "kind": "Power",
+      "powerEffect": "healPerTurn",
+      "value": 3,
+      "desc": "턴 시작 시 HP 3 회복",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "crusader",
+      "rarity": "unique"
+    },
+    "ChanceAttack": {
+      "name": "찬스 어택",
+      "cost": 1,
+      "kind": "Power",
+      "attackDamageVsWeakMultiplier": 1.5,
+      "desc": "약화 상태인 적에게 주는 공격 피해 1.5배",
+      "image": "291b2298db88476f8ae3c6c78f53c9b7",
+      "class": "crusader",
+      "rarity": "unique"
+    },
+    "Endure": {
+      "name": "인듀어",
+      "cost": 1,
+      "kind": "Power",
+      "removePlayerDebuffs": true,
+      "powerEffect": "blockPerTurn",
+      "value": 4,
+      "desc": "약화와 취약을 제거합니다. 매턴 방어도 4",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "crusader",
+      "rarity": "unique"
+    },
+    "DivineSwing": {
+      "name": "디바인 스윙",
+      "cost": 2,
+      "kind": "Attack",
+      "damage": 3,
+      "hits": 4,
+      "aoe": true,
+      "weak": 1,
+      "affectsAllEnemies": true,
+      "holyForce": true,
+      "desc": "모든 적에게 피해 3 x 4회, 약화 1. 홀리 포스.",
+      "image": "863812c5c2f84132ac7465b50ec2283e",
+      "class": "page",
+      "rarity": "normal"
+    },
+    "HolyCharge": {
+      "name": "홀리 차지",
+      "cost": 1,
+      "kind": "Power",
+      "holyChargeOnHolyForce": 1,
+      "holyChargeMax": 3,
+      "damageTakenReduction": 0.1,
+      "desc": "홀리 포스 카드를 사용하면 홀리 차지 1 획득. 최대 3. 받는 피해 10% 감소",
+      "image": "e2580523efc6457385114b78ad0d7cce",
+      "class": "page",
+      "rarity": "unique"
+    },
+    "PageOrder": {
+      "name": "페이지 오더",
+      "cost": 1,
+      "kind": "Attack",
+      "damage": 3,
+      "hits": 2,
+      "aoe": true,
+      "weak": 1,
+      "affectsAllEnemies": true,
+      "draw": 1,
+      "desc": "모든 적에게 피해 3 x 2회, 약화 1. 카드 1장 뽑기",
+      "image": "291b2298db88476f8ae3c6c78f53c9b7",
+      "class": "page",
+      "rarity": "normal"
+    },
+    "PageWeaponAcceleration": {
+      "name": "웨폰 액셀레이션",
+      "cost": 1,
+      "kind": "Power",
+      "strength": 1,
+      "turnStartDraw": 1,
+      "desc": "힘 1. 턴 시작 시 카드 1장 추가로 뽑기",
+      "image": "291b2298db88476f8ae3c6c78f53c9b7",
+      "class": "page",
+      "rarity": "unique"
+    },
+    "PageStance": {
+      "name": "스탠스",
+      "cost": 1,
+      "kind": "Power",
+      "powerEffect": "blockPerTurn",
+      "value": 4,
+      "desc": "매턴 방어도 4",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "page",
+      "rarity": "normal"
+    },
+    "PageWeaponMastery": {
+      "name": "웨폰 마스터리",
+      "cost": 1,
+      "kind": "Power",
+      "cardPlayedBlock": 1,
+      "desc": "카드를 사용할 때마다 방어도 1",
+      "image": "1bc3e52b330648faae9eafd5a205e37b",
+      "class": "page",
+      "rarity": "unique"
+    },
+    "PageFinalAttack": {
+      "name": "파이널 어택",
+      "cost": 1,
+      "kind": "Power",
+      "attackPlayedDamage": 2,
+      "desc": "공격 카드를 사용할 때마다 대상에게 피해 2",
+      "image": "997fa6999aa04dbb97a1dd99025fa2ba",
+      "class": "page",
+      "rarity": "legend"
+    },
+    "PagePhysicalTraining": {
+      "name": "피지컬 트레이닝",
+      "cost": 2,
+      "kind": "Power",
+      "strength": 1,
+      "dex": 1,
+      "powerEffect": "blockPerTurn",
+      "value": 2,
+      "desc": "힘 1. 민첩 1. 매턴 방어도 2",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "page",
+      "rarity": "unique"
+    },
+    "DivineCharge": {
+      "name": "디바인 차지",
+      "cost": 2,
+      "kind": "Attack",
+      "damage": 4,
+      "hits": 4,
+      "aoe": true,
+      "weak": 1,
+      "affectsAllEnemies": true,
+      "holyForce": true,
+      "damagePerHolyCharge": 1,
+      "desc": "모든 적에게 피해 4 x 4회, 약화 1. 홀리 차지당 피해 +1. 홀리 포스.",
+      "image": "863812c5c2f84132ac7465b50ec2283e",
+      "class": "knight",
+      "rarity": "unique"
+    },
+    "Restoration": {
+      "name": "리스토네이션",
+      "cost": 1,
+      "kind": "Skill",
+      "heal": 8,
+      "healPerHolyCharge": 4,
+      "holyChargeSpendAll": true,
+      "desc": "HP 8 회복. 홀리 차지당 추가로 4 회복한 뒤 모두 소비",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "knight",
+      "rarity": "unique"
+    },
+    "KnightRush": {
+      "name": "돌진",
+      "cost": 1,
+      "kind": "Attack",
+      "damage": 7,
+      "aoe": true,
+      "block": 4,
+      "blockPerHolyCharge": 2,
+      "desc": "모든 적에게 피해 7. 방어도 4, 홀리 차지당 방어도 +2",
+      "image": "997fa6999aa04dbb97a1dd99025fa2ba",
+      "class": "knight",
+      "rarity": "normal"
+    },
+    "NobleDemand": {
+      "name": "노블 디맨드",
+      "cost": 1,
+      "kind": "Skill",
+      "weak": 2,
+      "affectsAllEnemies": true,
+      "removeEnemyBlock": true,
+      "enemyStrengthLossThisTurn": 3,
+      "desc": "모든 적의 방어도를 제거하고 약화 2. 이번 턴 적 전체 힘 -3",
+      "image": "291b2298db88476f8ae3c6c78f53c9b7",
+      "class": "knight",
+      "rarity": "unique"
+    },
+    "ParashockGuard": {
+      "name": "파라쇼크 가드",
+      "cost": 2,
+      "kind": "Power",
+      "strength": 1,
+      "thorns": 3,
+      "cardPlayedBlock": 1,
+      "desc": "힘 1. 가시 3. 카드를 사용할 때마다 방어도 1",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "knight",
+      "rarity": "unique"
+    },
+    "CombatOrders": {
+      "name": "컴뱃 오더스",
+      "cost": 2,
+      "kind": "Power",
+      "nextSkillRepeatCount": 1,
+      "turnStartDraw": 1,
+      "desc": "다음 스킬을 1회 추가 발동. 턴 시작 시 카드 1장 추가로 뽑기",
+      "image": "e2580523efc6457385114b78ad0d7cce",
+      "class": "knight",
+      "rarity": "legend"
+    },
+    "KnightShieldMastery": {
+      "name": "실드 마스터리",
+      "cost": 2,
+      "kind": "Power",
+      "powerEffect": "blockPerTurn",
+      "value": 5,
+      "thorns": 2,
+      "desc": "매턴 방어도 5. 가시 2",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "knight",
+      "rarity": "unique"
+    },
+    "Achilles": {
+      "name": "아킬레스",
+      "cost": 2,
+      "kind": "Power",
+      "damageTakenReduction": 0.25,
+      "desc": "받는 피해 25% 감소",
+      "image": "90a9bf8eeb844b578b4e2d93ac43fedf",
+      "class": "knight",
+      "rarity": "legend"
+    },
+    "BlessingArmor": {
+      "name": "블레싱 아머",
+      "cost": 2,
+      "kind": "Power",
+      "blockOnDamaged": 6,
+      "strengthOnDamagedOnce": 2,
+      "desc": "HP 피해를 받으면 방어도 6. 전투 중 처음 발동할 때 힘 2",
+      "image": "e2580523efc6457385114b78ad0d7cce",
+      "class": "knight",
+      "rarity": "legend"
+    },
     "EnergyBolt": {
       "name": "에너지 볼트",
       "cost": 1,

docs/card-effect-fields.md

@@ -14,6 +14,10 @@ The goal is to keep card behavior reusable instead of hardcoding one-off card na
 - `damagePerDiscardedThisTurn`: bonus damage per card discarded this turn
 - `damagePerSkillInHand`: bonus damage per skill card in hand
 - `damagePerCardDrawnThisCombat`: bonus damage per card drawn this combat
+- `damagePerCombo`: bonus base damage per current Combo
+- `damagePerHolyCharge`: bonus base damage per current Holy Charge
+- `attackDamagePerCombo`: Power field that adds base damage per current Combo to all Attacks
+- `attackPlayedDamage`: Power field that deals extra damage after an Attack card is played
 - `damagePerTurn`: damage applied at turn start
 - `cardPlayedDamage`: damage when the card is played
 - `cardPlayedRandomDamage`: random damage when the card is played
@@ -65,6 +69,21 @@ The goal is to keep card behavior reusable instead of hardcoding one-off card na
 - `thorns`: gain Thorns
 - `selfVuln`: apply Vulnerable to self
 - `extraPoisonTicks`: add extra poison ticks at enemy turn start
+- `comboGain`: gain Combo when the card resolves; Attack cards gain it after dealing damage
+- `comboOnAttack`: Power field that gains Combo whenever an Attack card is played
+- `comboMax`: Power field that raises the maximum Combo above the default 5
+- `attackWeak`: Power field that applies Weak after an Attack card is played
+- `removePlayerDebuffs`: remove player Weak and Vulnerable
+- `holyForce`: marks a card as Holy Force for Holy Charge Power triggers
+- `holyChargeGain`: gain Holy Charge directly
+- `holyChargeOnHolyForce`: Power field that gains Holy Charge after a Holy Force card
+- `holyChargeMax`: Power field that raises the maximum Holy Charge above the default 3
+- `blockPerHolyCharge`: gain additional block per current Holy Charge
+- `healPerHolyCharge`: heal additional HP per current Holy Charge
+- `holyChargeSpendAll`: consume all Holy Charge after resolving the card
+- `damageTakenReduction`: Power field that reduces incoming damage; total reduction is capped at 75%
+- `blockOnDamaged`: Power field that grants block after taking HP damage
+- `strengthOnDamagedOnce`: Power field that grants Strength on the first HP damage each combat
 
 ## Status
 
@@ -108,6 +127,7 @@ The goal is to keep card behavior reusable instead of hardcoding one-off card na
 - `powerEffect: "blockPerTurn"`
 - `powerEffect: "poisonPerTurn"`
 - `powerEffect: "damagePerTurn"`
+- `powerEffect: "healPerTurn"`
 - `powerEffect: "retainOne"`
 - `powerEffect: "keepBlock"`
 - `turnStartShiv`: create Shivs at turn start

tools/balance/sim-balance.mjs

@@ -246,6 +246,9 @@ export function simulateCombat(data, rng, stats) {
   let cardsDrawnThisCombat = 0;
   let bonusRewardScreens = 0;
   let activeKillReward = 0;
+  let comboCount = 0;
+  let holyChargeCount = 0;
+  let damagePowerStrengthUsed = false;
   let energy = 0;
   const powers = [];
   const mob = monsters.map((m) => ({
@@ -467,6 +470,9 @@ export function simulateCombat(data, rng, stats) {
       base += countOwnedNameMatches(c.damageNameMatch) * c.damagePerOwnedNameMatch;
     }
     if (c.damageFromCurrentBlock) base += pBlock * c.damageFromCurrentBlock;
+    const comboScale = (c.damagePerCombo || 0) + powerFieldTotal('attackDamagePerCombo');
+    if (comboScale) base += comboCount * comboScale;
+    if (c.damagePerHolyCharge) base += holyChargeCount * c.damagePerHolyCharge;
     const otherHand = Math.max(0, hand.length - 1);
     if (c.damagePerOtherHandCard) base += otherHand * c.damagePerOtherHandCard;
     if (c.damagePerAttackPlayedThisTurn) base += turnAttackCardsPlayed * c.damagePerAttackPlayedThisTurn;
@@ -518,6 +524,23 @@ export function simulateCombat(data, rng, stats) {
     }
     return total;
   }
+  function powerFieldMax(field) {
+    let best = 0;
+    for (const pid of powers) best = Math.max(best, cards[pid]?.[field] || 0);
+    return best;
+  }
+  function comboMax() {
+    return Math.max(5, powerFieldMax('comboMax'));
+  }
+  function gainCombo(amount) {
+    if (amount > 0) comboCount = Math.min(comboMax(), comboCount + amount);
+  }
+  function holyChargeMax() {
+    return Math.max(3, powerFieldMax('holyChargeMax'));
+  }
+  function gainHolyCharge(amount) {
+    if (amount > 0) holyChargeCount = Math.min(holyChargeMax(), holyChargeCount + amount);
+  }
   function triggerExhaust(count = 1) {
     const drawOnExhaust = powerFieldTotal('drawOnExhaust');
     if (drawOnExhaust > 0 && count > 0) draw(drawOnExhaust * count);
@@ -607,8 +630,9 @@ export function simulateCombat(data, rng, stats) {
           if (!target || !target.alive) return { killed: false, dealt: 0 };
           let dealt = amount;
           if (target.vuln > 0) dealt = Math.floor(dealt * 1.5);
-          if (target.weak > 0 && c.attackDamageVsWeakMultiplier && c.attackDamageVsWeakMultiplier > 1) {
+          const weakMultiplier = Math.max(c.attackDamageVsWeakMultiplier || 1, powerFieldMax('attackDamageVsWeakMultiplier'));
-            dealt = Math.floor(dealt * c.attackDamageVsWeakMultiplier);
+          if (target.weak > 0 && weakMultiplier > 1) {
+            dealt = Math.floor(dealt * weakMultiplier);
           }
           if (c.pierce === true) {
             target.hp -= dealt;
@@ -669,11 +693,11 @@ export function simulateCombat(data, rng, stats) {
           roundKilled = resolveAttackRound();
         } while (c.repeatOnKill === true && roundKilled === true && countAliveMonsters() > 0);
       }
-      if (c.block) blockGained = addBlock(c.block);
+      if (c.block) blockGained = addBlock(c.block + holyChargeCount * (c.blockPerHolyCharge || 0));
     } else if (c.kind === 'Power') {
       powers.push(id);
     } else {
-      if (c.block) blockGained = addBlock(c.block);
+      if (c.block) blockGained = addBlock(c.block + holyChargeCount * (c.blockPerHolyCharge || 0));
       const weakAmount = (c.weak || 0) + (c.xWeakPerEnergy || 0) * xEnergy;
       const vulnAmount = c.vuln || 0;
       if ((weakAmount || vulnAmount || c.poison || c.removeEnemyBlock || c.removeEnemyArtifact || c.enemyStrengthLossThisTurn) && alive.length) {
@@ -705,8 +729,10 @@ export function simulateCombat(data, rng, stats) {
     if (c.dex) pDex += c.dex;
     if (c.thorns) pThorns += c.thorns;
     if (c.selfVuln) pVuln += c.selfVuln;
-    if (c.heal) pHp = Math.min(pHp + c.heal, playerMaxHp);
+    if (c.heal) pHp = Math.min(pHp + c.heal + holyChargeCount * (c.healPerHolyCharge || 0), playerMaxHp);
     if (c.gainEnergy) energy += c.gainEnergy;
+    if (c.kind !== 'Attack' && c.comboGain) gainCombo(c.comboGain);
+    if (c.removePlayerDebuffs === true) { pWeak = 0; pVuln = 0; }
     activeKillReward = c.rewardOnKill || 0;
     if (c.intangible) pIntangible += c.intangible;
     queueNextTurnEffects(c);
@@ -766,6 +792,28 @@ export function simulateCombat(data, rng, stats) {
         }
       }
     }
+    if (c.kind === 'Attack') {
+      gainCombo((c.comboGain || 0) + powerFieldTotal('comboOnAttack'));
+      const extraDamage = powerFieldTotal('attackPlayedDamage');
+      if (extraDamage > 0) {
+        const target = chooseTarget(aliveList(), extraDamage);
+        if (target) {
+          const r = applyDamage(target.hp, target.block, extraDamage);
+          target.hp = r.hp; target.block = r.block;
+          damageDealtThisTurn += extraDamage;
+          if (target.hp <= 0) target.alive = false;
+        }
+      }
+      const attackWeak = powerFieldTotal('attackWeak');
+      if (attackWeak > 0) {
+        const target = chooseTarget(aliveList(), 0);
+        if (target) applyMonsterWeak(target, attackWeak);
+      }
+    }
+    let holyGain = c.holyChargeGain || 0;
+    if (c.holyForce === true) holyGain += powerFieldTotal('holyChargeOnHolyForce');
+    gainHolyCharge(holyGain);
+    if (c.holyChargeSpendAll === true) holyChargeCount = 0;
     if (c.blockPerDamageDealtThisTurn && c.blockPerDamageDealtThisTurn > 0 && c.kind !== 'Power') {
       blockGained += addBlock(Math.max(0, damageDealtThisTurn * c.blockPerDamageDealtThisTurn));
     }
@@ -878,6 +926,8 @@ export function simulateCombat(data, rng, stats) {
           m.hp = r.hp; m.block = r.block;
           if (m.hp <= 0) m.alive = false;
         }
+      } else if (pc.powerEffect === 'healPerTurn') {
+        pHp = Math.min(playerMaxHp, pHp + (pc.value || 0));
       }
       if (pc.turnStartShiv) addCardsToHand('Shiv', pc.turnStartShiv);
       if (pc.turnStartDraw) powerTurnDraw += pc.turnStartDraw;
@@ -991,8 +1041,18 @@ export function simulateCombat(data, rng, stats) {
           const atk = calcEnemyAttack(it.value, m.str, m.weak, pVuln, enemyStrengthLossThisTurn);
           const beforeHp = pHp;
           let incoming = atk;
+          const reduction = Math.min(0.75, powerFieldTotal('damageTakenReduction'));
+          if (reduction > 0) incoming = Math.floor(incoming * (1 - reduction));
           if (pIntangible > 0 && incoming > 1) incoming = 1;
           const r = applyDamage(pHp, pBlock, incoming); pHp = r.hp; pBlock = r.block;
+          if (beforeHp > pHp) {
+            const reactiveBlock = powerFieldTotal('blockOnDamaged');
+            if (reactiveBlock > 0) addBlock(reactiveBlock);
+            if (!damagePowerStrengthUsed) {
+              const reactiveStrength = powerFieldTotal('strengthOnDamagedOnce');
+              if (reactiveStrength > 0) { pStr += reactiveStrength; damagePowerStrengthUsed = true; }
+            }
+          }
           if (beforeHp > pHp && pThorns > 0) {
             m.hp -= pThorns;
             if (m.hp <= 0) m.alive = false;

tools/balance/sim-balance.test.mjs

@@ -1391,3 +1391,102 @@ test("simulateCombat: shivAoe makes Shivs hit all enemies", () => {
   assert.equal(r.win, true);
   assert.equal(r.turns, 1);
 });
+
+test("simulateCombat: comboGain and damagePerCombo scale repeated attacks", () => {
+  const data = {
+    cards: {
+      Brandish: { name: "브랜디쉬", cost: 1, kind: "Attack", damage: 2, hits: 2, comboGain: 1, damagePerCombo: 1 },
+    },
+    starterDeck: ["Brandish"],
+    monsters: [{ name: "Dummy", maxHp: 14, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const stats = {};
+  const r = simulateCombat(data, () => 0.999999, stats);
+  assert.equal(r.win, true);
+  assert.ok(stats.Brandish.damage > stats.Brandish.plays * 4);
+});
+
+test("simulateCombat: comboMax power raises the combo cap", () => {
+  const data = {
+    cards: {
+      ComboSynergy: { name: "콤보 시너지", cost: 0, kind: "Power", comboMax: 8, comboOnAttack: 2, attackDamagePerCombo: 1, innate: true },
+      Hit: { name: "연속 베기", cost: 0, kind: "Attack", damage: 1 },
+    },
+    starterDeck: ["ComboSynergy", "Hit"],
+    monsters: [{ name: "Dummy", maxHp: 40, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const stats = {};
+  const r = simulateCombat(data, () => 0.999999, stats);
+  assert.equal(r.win, true);
+  assert.ok(stats.Hit.damage > stats.Hit.plays);
+});
+
+test("simulateCombat: healPerTurn power restores hp at turn start", () => {
+  const data = {
+    cards: {
+      Recovery: { name: "셀프 리커버리", cost: 0, kind: "Power", powerEffect: "healPerTurn", value: 3 },
+      Hit: { name: "마무리", cost: 1, kind: "Attack", damage: 1 },
+    },
+    starterDeck: ["Recovery", "Hit"],
+    monsters: [{ name: "Dummy", maxHp: 2, intents: [{ kind: "Attack", value: 2 }] }],
+    playerHp: 70,
+    playerMaxHp: 80,
+  };
+  const r = simulateCombat(data, () => 0.999999);
+  assert.equal(r.win, true);
+  assert.ok(r.playerHpRemaining >= 69);
+});
+
+test("simulateCombat: Holy Charge scales repeated Holy Force attacks", () => {
+  const data = {
+    cards: {
+      ChargeStrike: { name: "차지 타격", cost: 1, kind: "Attack", damage: 2, holyChargeGain: 1, damagePerHolyCharge: 1 },
+    },
+    starterDeck: ["ChargeStrike"],
+    monsters: [{ name: "Dummy", maxHp: 14, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const stats = {};
+  const r = simulateCombat(data, () => 0.999999, stats);
+  assert.equal(r.win, true);
+  assert.ok(stats.ChargeStrike.damage > stats.ChargeStrike.plays * 2);
+});
+
+test("simulateCombat: damageTakenReduction lowers incoming HP damage", () => {
+  const data = {
+    cards: {
+      Achilles: { name: "아킬레스", cost: 3, kind: "Power", damageTakenReduction: 0.25, innate: true },
+      Wait1: { name: "대기", cost: 99, kind: "Status", unplayable: true, innate: true },
+      Wait2: { name: "대기", cost: 99, kind: "Status", unplayable: true, innate: true },
+      Wait3: { name: "대기", cost: 99, kind: "Status", unplayable: true, innate: true },
+      Wait4: { name: "대기", cost: 99, kind: "Status", unplayable: true, innate: true },
+      Finish: { name: "마무리", cost: 3, kind: "Power", cardPlayedDamage: 2 },
+    },
+    starterDeck: ["Finish", "Achilles", "Wait1", "Wait2", "Wait3", "Wait4"],
+    monsters: [{ name: "Dummy", maxHp: 2, intents: [{ kind: "Attack", value: 10 }] }],
+  };
+  const r = simulateCombat(data, () => 0.999999);
+  assert.equal(r.win, true);
+  assert.equal(r.playerHpRemaining, 73);
+});
+
+test("simulateCombat: blockOnDamaged protects against later attackers", () => {
+  const data = {
+    cards: {
+      Armor: { name: "블레싱 아머", cost: 3, kind: "Power", blockOnDamaged: 6, strengthOnDamagedOnce: 2, innate: true },
+      Wait1: { name: "대기", cost: 99, kind: "Status", unplayable: true, innate: true },
+      Wait2: { name: "대기", cost: 99, kind: "Status", unplayable: true, innate: true },
+      Wait3: { name: "대기", cost: 99, kind: "Status", unplayable: true, innate: true },
+      Wait4: { name: "대기", cost: 99, kind: "Status", unplayable: true, innate: true },
+      Finish1: { name: "마무리", cost: 3, kind: "Power", cardPlayedDamage: 1 },
+      Finish2: { name: "마무리", cost: 3, kind: "Power", cardPlayedDamage: 1 },
+    },
+    starterDeck: ["Finish1", "Finish2", "Armor", "Wait1", "Wait2", "Wait3", "Wait4"],
+    monsters: [
+      { name: "A", maxHp: 1, intents: [{ kind: "Attack", value: 5 }] },
+      { name: "B", maxHp: 1, intents: [{ kind: "Attack", value: 5 }] },
+    ],
+  };
+  const r = simulateCombat(data, () => 0.999999);
+  assert.equal(r.win, true);
+  assert.equal(r.playerHpRemaining, 70);
+});

tools/deck/cb/combat.mjs

@@ -86,6 +86,8 @@ local function applyCardPlayHooks()
 	if c.cardPlayedRandomDamage ~= nil and c.cardPlayedRandomDamage > 0 then
 		self:DealDirectDamageToRandomMonster(c.cardPlayedRandomDamage)
 	end
+	self:ApplyAttackCardPlayHooks(c)
+	self:ApplyHolyForceCardPlayHooks(c)
 end
 applyCardPlayHooks()
 if skillRepeat > 0 then
@@ -550,6 +552,11 @@ for i = 1, #self.Monsters do
 	if self.Monsters[i].alive == true then self.TargetIndex = i; break end
 end`, [{ Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'slot' }]),
     method('DealDamageToPlayer', `local dmg = amount
+local reduction = self:AddPowerFieldTotal("damageTakenReduction")
+if reduction ~= nil and reduction > 0 then
+	reduction = math.min(0.75, reduction)
+	dmg = math.floor(dmg * (1 - reduction))
+end
 if self.PlayerBlock > 0 then
 	local absorbed = math.min(self.PlayerBlock, dmg)
 	self.PlayerBlock = self.PlayerBlock - absorbed
@@ -560,6 +567,17 @@ if dmg > 0 and self.PlayerIntangible ~= nil and self.PlayerIntangible > 0 and dm
 end
 if dmg > 0 then
 	self.PlayerHp = self.PlayerHp - dmg
+	local reactiveBlock = self:AddPowerFieldTotal("blockOnDamaged")
+	if reactiveBlock ~= nil and reactiveBlock > 0 then
+		self:AddCardBlock(reactiveBlock)
+	end
+	if self.DamagePowerStrengthUsed ~= true then
+		local reactiveStrength = self:AddPowerFieldTotal("strengthOnDamagedOnce")
+		if reactiveStrength ~= nil and reactiveStrength > 0 then
+			self.PlayerStr = self.PlayerStr + reactiveStrength
+			self.DamagePowerStrengthUsed = true
+		end
+	end
 	local reflect = self.PlayerThorns or 0
 	if self:HasRelic("bronzeScales") then
 		reflect = reflect + 3

tools/deck/cb/deckturn.mjs

@@ -291,6 +291,8 @@ if self.PlayerPowers ~= nil then
 				if self.Monsters ~= nil then
 					self:PlayAoeFx(pc.fx or pc.image, pc.value or 0)
 				end
+			elseif pc.powerEffect == "healPerTurn" then
+				self.PlayerHp = math.min(self.PlayerMaxHp, self.PlayerHp + pc.value)
 			end
 			if pc.turnStartShiv ~= nil then
 				self:AddCardsToHand("Shiv", pc.turnStartShiv)

tools/deck/cb/hand.mjs

@@ -346,6 +346,69 @@ countPile(self.DrawPile)
 countPile(self.DiscardPile)
 countPile(self.ExhaustPile)
 return n`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'match' }], 0, 'number'),
+    method('MaxPowerField', `local best = 0
+if self.PlayerPowers == nil then
+	return best
+end
+for i = 1, #self.PlayerPowers do
+	local powerCard = self.Cards[self.PlayerPowers[i]]
+	if powerCard ~= nil and powerCard[field] ~= nil and powerCard[field] > best then
+		best = powerCard[field]
+	end
+end
+return best`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'field' }], 0, 'number'),
+    method('GetComboMax', `local comboMax = 5
+local powerMax = self:MaxPowerField("comboMax")
+if powerMax ~= nil and powerMax > comboMax then
+	comboMax = powerMax
+end
+return comboMax`, [], 0, 'number'),
+    method('GainCombo', `if amount == nil or amount <= 0 then
+	return
+end
+self.ComboCount = math.min(self:GetComboMax(), (self.ComboCount or 0) + amount)`, [{ Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'amount' }]),
+    method('GetHolyChargeMax', `local chargeMax = 3
+local powerMax = self:MaxPowerField("holyChargeMax")
+if powerMax ~= nil and powerMax > chargeMax then
+	chargeMax = powerMax
+end
+return chargeMax`, [], 0, 'number'),
+    method('GainHolyCharge', `if amount == nil or amount <= 0 then
+	return
+end
+self.HolyChargeCount = math.min(self:GetHolyChargeMax(), (self.HolyChargeCount or 0) + amount)`, [{ Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'amount' }]),
+    method('ApplyHolyForceCardPlayHooks', `if c == nil then
+	return
+end
+local gain = c.holyChargeGain or 0
+if c.holyForce == true then
+	gain = gain + self:AddPowerFieldTotal("holyChargeOnHolyForce")
+end
+self:GainHolyCharge(gain)
+if c.holyChargeSpendAll == true then
+	self.HolyChargeCount = 0
+end`, [{ Type: 'any', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'c' }]),
+    method('ApplyAttackCardPlayHooks', `if c == nil or c.kind ~= "Attack" then
+	return
+end
+local comboGain = c.comboGain or 0
+comboGain = comboGain + self:AddPowerFieldTotal("comboOnAttack")
+self:GainCombo(comboGain)
+local extraDamage = self:AddPowerFieldTotal("attackPlayedDamage")
+if extraDamage ~= nil and extraDamage > 0 then
+	self:DealDirectDamageToTarget(extraDamage)
+end
+local weakAmount = self:AddPowerFieldTotal("attackWeak")
+if weakAmount ~= nil and weakAmount > 0 and self.Monsters ~= nil then
+	local target = self.Monsters[self.TargetIndex]
+	if target ~= nil and target.alive == true then
+		if target.artifact ~= nil and target.artifact > 0 then
+			target.artifact = target.artifact - 1
+		else
+			target.weak = (target.weak or 0) + weakAmount
+		end
+	end
+end`, [{ Type: 'any', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'c' }]),
     method('AttackBaseForCard', `local base2 = c.damage or 0
 if c.damageNameMatch ~= nil and c.damagePerOwnedNameMatch ~= nil then
 	base2 = base2 + self:CountOwnedNameMatches(c.damageNameMatch) * c.damagePerOwnedNameMatch
@@ -353,6 +416,14 @@ end
 if c.damageFromCurrentBlock ~= nil and c.damageFromCurrentBlock ~= 0 then
 	base2 = base2 + (self.PlayerBlock or 0) * c.damageFromCurrentBlock
 end
+local comboScale = c.damagePerCombo or 0
+comboScale = comboScale + self:AddPowerFieldTotal("attackDamagePerCombo")
+if comboScale ~= 0 then
+	base2 = base2 + (self.ComboCount or 0) * comboScale
+end
+if c.damagePerHolyCharge ~= nil and c.damagePerHolyCharge ~= 0 then
+	base2 = base2 + (self.HolyChargeCount or 0) * c.damagePerHolyCharge
+end
 local otherHand = 0
 if self.Hand ~= nil then
 	otherHand = #self.Hand - 1
@@ -431,6 +502,8 @@ local function applyCardPlayHooks()
 	if c.cardPlayedRandomDamage ~= nil and c.cardPlayedRandomDamage > 0 then
 		self:DealDirectDamageToRandomMonster(c.cardPlayedRandomDamage)
 	end
+	self:ApplyAttackCardPlayHooks(c)
+	self:ApplyHolyForceCardPlayHooks(c)
 end
 applyCardPlayHooks()
 if skillRepeat > 0 then
@@ -706,7 +779,7 @@ if c.kind == "Attack" then
 	if c.damage ~= nil or c.xDamagePerEnergy ~= nil or c.damageFromCurrentBlock ~= nil then
 		self:PlayerAttackMotion()
 		local baseDmg = self:AttackBaseForCard(slot, c)
-		self.ActiveAttackDamageVsWeakMultiplier = c.attackDamageVsWeakMultiplier or 1
+		self.ActiveAttackDamageVsWeakMultiplier = math.max(c.attackDamageVsWeakMultiplier or 1, self:MaxPowerField("attackDamageVsWeakMultiplier"))
 		if c.xDamagePerEnergy ~= nil and c.xDamagePerEnergy > 0 then
 			baseDmg = xEnergy * c.xDamagePerEnergy
 		end
@@ -788,14 +861,14 @@ if c.kind == "Attack" then
 		self.DamageDealtThisTurn = (self.DamageDealtThisTurn or 0) + totalDamage
 	end
 	if c.block ~= nil then
-		self:AddCardBlock(c.block)
+		self:AddCardBlock(c.block + (self.HolyChargeCount or 0) * (c.blockPerHolyCharge or 0))
 	end
 	if free ~= true then
 		self:ApplyRelics("cardPlayed")
 	end
 elseif c.kind == "Skill" then
 	if c.block ~= nil then
-		self:AddCardBlock(c.block)
+		self:AddCardBlock(c.block + (self.HolyChargeCount or 0) * (c.blockPerHolyCharge or 0))
 	end
 elseif c.kind == "Power" then
 	if free ~= true then
@@ -815,11 +888,19 @@ if c.selfVuln ~= nil then
 	self.PlayerVuln = self.PlayerVuln + c.selfVuln
 end
 if c.heal ~= nil then
-	self.PlayerHp = math.min(self.PlayerHp + c.heal, self.PlayerMaxHp)
+	local healAmount = c.heal + (self.HolyChargeCount or 0) * (c.healPerHolyCharge or 0)
+	self.PlayerHp = math.min(self.PlayerHp + healAmount, self.PlayerMaxHp)
 end
 if c.gainEnergy ~= nil and c.gainEnergy ~= 0 then
 	self.Energy = self.Energy + c.gainEnergy
 end
+if c.kind ~= "Attack" and c.comboGain ~= nil and c.comboGain > 0 then
+	self:GainCombo(c.comboGain)
+end
+if c.removePlayerDebuffs == true then
+	self.PlayerWeak = 0
+	self.PlayerVuln = 0
+end
 if c.intangible ~= nil and c.intangible > 0 then
 	self.PlayerIntangible = (self.PlayerIntangible or 0) + c.intangible
 end

tools/deck/cb/render.mjs

@@ -80,7 +80,15 @@ if self.PlayerThorns ~= nil and self.PlayerThorns > 0 then
 	if pb ~= "" then pb = pb .. " " end
 	pb = pb .. "가시" .. tostring(self.PlayerThorns)
 end
-if self.PlayerPowers ~= nil and #self.PlayerPowers > 0 then
+if self.ComboCount ~= nil and self.ComboCount > 0 then
+	if pb ~= "" then pb = pb .. " " end
+	pb = pb .. "콤보 " .. tostring(self.ComboCount) .. "/" .. tostring(self:GetComboMax())
+end
+if self.HolyChargeCount ~= nil and self.HolyChargeCount > 0 then
+	if pb ~= "" then pb = pb .. " " end
+	pb = pb .. "홀리 차지 " .. tostring(self.HolyChargeCount) .. "/" .. tostring(self:GetHolyChargeMax())
+end
+if self.PlayerPowers ~= nil and #self.PlayerPowers > 0 then
 	local names = {}
 	for i = 1, #self.PlayerPowers do
 		local pc = self.Cards[self.PlayerPowers[i]]

tools/deck/cb/run.mjs

@@ -101,6 +101,9 @@ self.FightAttackCount = 0
 self.TurnAttackCardsPlayed = 0
 self.TurnDiscardedCards = 0
 self.TurnCardsPlayedThisTurn = 0
+self.ComboCount = 0
+self.HolyChargeCount = 0
+self.DamagePowerStrengthUsed = false
 self.DamageDealtThisTurn = 0
 self.DmgPopSeq = 0
 self.FirstHpLossDone = false

tools/deck/gen-slaydeck.mjs

@@ -147,6 +147,9 @@ function writeCodeblocks() {
     prop('number', 'FightAttackCount', '0'),
     prop('number', 'TurnAttackCardsPlayed', '0'),
     prop('number', 'TurnCardsPlayedThisTurn', '0'),
+    prop('number', 'ComboCount', '0'),
+    prop('number', 'HolyChargeCount', '0'),
+    prop('boolean', 'DamagePowerStrengthUsed', 'false'),
     prop('number', 'DamageDealtThisTurn', '0'),
     prop('number', 'TurnDiscardedCards', '0'),
     prop('boolean', 'FirstHpLossDone', 'false'),

tools/deck/lib/data.mjs

@@ -19,15 +19,15 @@ for (const cls of Object.keys(CLASSES)) {
 // 전직 옵션
 const JOBS = {
   warrior: [
-    { id: 'fighter', name: '파이터', desc: '연속 공격 계열\n이중 타격 · 난타\n악마의 형상', starter: 'TwinStrike', tier: 2, parent: 'warrior' },
+    { id: 'fighter', name: '파이터', desc: '콤보와 다단 공격 특화\n공격으로 콤보를 쌓고\n추가타로 압박', starter: 'ComboAttack', tier: 2, parent: 'warrior' },
-    { id: 'page', name: '페이지', desc: '방어·운영 계열\n전투의 북소리 · 무적\n바리케이드', starter: 'DrumOfBattle', tier: 2, parent: 'warrior' },
+    { id: 'page', name: '페이지', desc: '홀리 포스와 방어 특화\n홀리 차지를 쌓아\n공격과 생존 강화', starter: 'HolyCharge', tier: 2, parent: 'warrior' },
     { id: 'spearman', name: '스피어맨', desc: '광역·장기전 계열\n대화재 · 소용돌이\n불의 심장', starter: 'Conflagration', tier: 2, parent: 'warrior' },
   ],
   fighter: [
-    { id: 'crusader', name: '크루세이더', desc: '파이터의 3차 전직\n아이언클래드 공격 풀 계승\n전사 카드 사용', starter: '', tier: 3, parent: 'fighter' },
+    { id: 'crusader', name: '크루세이더', desc: '파이터의 3차 전직\n콤보 상한과 연계 피해 강화\n파이터 카드 계승', starter: 'ComboSynergy', tier: 3, parent: 'fighter' },
   ],
   page: [
-    { id: 'knight', name: '나이트', desc: '페이지의 3차 전직\n아이언클래드 운영 풀 계승\n전사 카드 사용', starter: '', tier: 3, parent: 'page' },
+    { id: 'knight', name: '나이트', desc: '페이지의 3차 전직\n홀리 차지를 공격·방어·회복으로 전환\n페이지 카드 계승', starter: 'DivineCharge', tier: 3, parent: 'page' },
   ],
   spearman: [
     { id: 'berserker', name: '버서커', desc: '스피어맨의 3차 전직\n아이언클래드 장기전 풀 계승\n전사 카드 사용', starter: '', tier: 3, parent: 'spearman' },
@@ -225,6 +225,9 @@ function luaCardsTable(cards) {
     const fields = [`name = ${luaStr(c.name)}`, `cost = ${c.cost}`, `desc = ${luaStr(c.desc)}`, `kind = ${luaStr(c.kind)}`];
     if (c.damage != null) fields.push(`damage = ${c.damage}`);
     if (c.damageFromCurrentBlock != null) fields.push(`damageFromCurrentBlock = ${c.damageFromCurrentBlock}`);
+    if (c.damagePerCombo != null) fields.push(`damagePerCombo = ${c.damagePerCombo}`);
+    if (c.damagePerHolyCharge != null) fields.push(`damagePerHolyCharge = ${c.damagePerHolyCharge}`);
+    if (c.attackDamagePerCombo != null) fields.push(`attackDamagePerCombo = ${c.attackDamagePerCombo}`);
     if (c.damageNameMatch != null) fields.push(`damageNameMatch = ${luaStr(c.damageNameMatch)}`);
     if (c.damagePerOwnedNameMatch != null) fields.push(`damagePerOwnedNameMatch = ${c.damagePerOwnedNameMatch}`);
     if (c.damagePerOtherHandCard != null) fields.push(`damagePerOtherHandCard = ${c.damagePerOtherHandCard}`);
@@ -235,6 +238,7 @@ function luaCardsTable(cards) {
     if (c.damagePerTurn != null) fields.push(`damagePerTurn = ${c.damagePerTurn}`);
     if (c.cardPlayedDamage != null) fields.push(`cardPlayedDamage = ${c.cardPlayedDamage}`);
     if (c.cardPlayedRandomDamage != null) fields.push(`cardPlayedRandomDamage = ${c.cardPlayedRandomDamage}`);
+    if (c.attackPlayedDamage != null) fields.push(`attackPlayedDamage = ${c.attackPlayedDamage}`);
     if (c.firstCardDamageBonus != null) fields.push(`firstCardDamageBonus = ${c.firstCardDamageBonus}`);
     if (c.rewardOnKill != null) fields.push(`rewardOnKill = ${c.rewardOnKill}`);
     if (c.maxHpOnKill != null) fields.push(`maxHpOnKill = ${c.maxHpOnKill}`);
@@ -251,6 +255,14 @@ function luaCardsTable(cards) {
     if (c.dex != null) fields.push(`dex = ${c.dex}`);
     if (c.thorns != null) fields.push(`thorns = ${c.thorns}`);
     if (c.cardPlayedBlock != null) fields.push(`cardPlayedBlock = ${c.cardPlayedBlock}`);
+    if (c.comboOnAttack != null) fields.push(`comboOnAttack = ${c.comboOnAttack}`);
+    if (c.comboMax != null) fields.push(`comboMax = ${c.comboMax}`);
+    if (c.attackWeak != null) fields.push(`attackWeak = ${c.attackWeak}`);
+    if (c.holyChargeOnHolyForce != null) fields.push(`holyChargeOnHolyForce = ${c.holyChargeOnHolyForce}`);
+    if (c.holyChargeMax != null) fields.push(`holyChargeMax = ${c.holyChargeMax}`);
+    if (c.damageTakenReduction != null) fields.push(`damageTakenReduction = ${c.damageTakenReduction}`);
+    if (c.blockOnDamaged != null) fields.push(`blockOnDamaged = ${c.blockOnDamaged}`);
+    if (c.strengthOnDamagedOnce != null) fields.push(`strengthOnDamagedOnce = ${c.strengthOnDamagedOnce}`);
     if (c.drawOnExhaust != null) fields.push(`drawOnExhaust = ${c.drawOnExhaust}`);
     if (c.drawNameMatchAutoPlay != null) fields.push(`drawNameMatchAutoPlay = ${luaStr(c.drawNameMatchAutoPlay)}`);
     if (c.weak != null) fields.push(`weak = ${c.weak}`);
@@ -280,7 +292,14 @@ function luaCardsTable(cards) {
     if (c.playTopDrawPileCount != null) fields.push(`playTopDrawPileCount = ${c.playTopDrawPileCount}`);
     if (c.playTopDrawPileCountPerEnergy != null) fields.push(`playTopDrawPileCountPerEnergy = ${c.playTopDrawPileCountPerEnergy}`);
     if (c.heal != null) fields.push(`heal = ${c.heal}`);
+    if (c.healPerHolyCharge != null) fields.push(`healPerHolyCharge = ${c.healPerHolyCharge}`);
     if (c.gainEnergy != null) fields.push(`gainEnergy = ${c.gainEnergy}`);
+    if (c.comboGain != null) fields.push(`comboGain = ${c.comboGain}`);
+    if (c.removePlayerDebuffs === true) fields.push('removePlayerDebuffs = true');
+    if (c.holyForce === true) fields.push('holyForce = true');
+    if (c.holyChargeGain != null) fields.push(`holyChargeGain = ${c.holyChargeGain}`);
+    if (c.blockPerHolyCharge != null) fields.push(`blockPerHolyCharge = ${c.blockPerHolyCharge}`);
+    if (c.holyChargeSpendAll === true) fields.push('holyChargeSpendAll = true');
     if (c.poison != null) fields.push(`poison = ${c.poison}`);
     if (c.discard != null) fields.push(`discard = ${c.discard}`);
     if (c.discardAll === true) fields.push('discardAll = true');

tools/verify/cardkinds.mjs

@@ -17,6 +17,9 @@ const POWER_FIELDS = [
   'shivDamageBonus', 'firstShivDamageBonus', 'shivRetain', 'shivAoe',
   'attackPoison', 'drawDamage', 'drawPoison', 'attackDamageVsWeakMultiplier',
   'cardPlayedBlock', 'cardPlayedDamage', 'cardPlayedRandomDamage',
+  'comboOnAttack', 'comboMax', 'attackDamagePerCombo', 'attackPlayedDamage', 'attackWeak',
+  'holyChargeOnHolyForce', 'holyChargeMax', 'damageTakenReduction',
+  'blockOnDamaged', 'strengthOnDamagedOnce',
   'drawOnExhaust', 'drawNameMatchAutoPlay',
   'extraPoisonTicks', 'poisonApplicationBurstEvery', 'poisonApplicationBurstDamage',
   'skillSlyOnPlay', 'endTurnDexLoss',