valtech-components 4.0.625 → 4.0.627

package/fesm2022/valtech-components.mjs

@@ -59,7 +59,7 @@ import fixWebmDuration from 'fix-webm-duration';
  * Current version of valtech-components.
  * This is automatically updated during the publish process.
  */
-const VERSION = '4.0.625';
+const VERSION = '4.0.627';
 
 // Control de estado de refresco (singleton a nivel de módulo)
 let isRefreshing = false;
@@ -74432,7 +74432,7 @@ function playCardFromHand(game, seat, card, options = {}) {
         spentOfferings = card.cost ?? 0;
         spendOfferings(player, spentOfferings);
         const life = card.life ?? 1;
-        player.battleZone.push({
+        const newChar = {
             instanceId: `${seat.toLowerCase()}_${next.revision + 1}_${player.battleZone.length}`,
             cardId: card.id,
             name: displayName,
@@ -74443,7 +74443,11 @@ function playCardFromHand(game, seat, card, options = {}) {
             currentHp: life,
             maxHp: life,
             canAttack: false,
-        });
+        };
+        bakeEffects(newChar, card.effects ?? []);
+        player.battleZone.push(newChar);
+        fireEffects(next, newChar, 'on_enter', seat);
+        fireEffects(next, newChar, 'passive', seat);
         player.battleZone.sort((left, right) => (left.slot ?? 0) - (right.slot ?? 0));
     }
     else if (card.type === 'tool') {
@@ -74538,8 +74542,10 @@ function resolveAttackLeader(game, attackerSeat, attackerInstanceId, messages) {
     const attacker = next.players[attackerSeat].battleZone.find(card => card.instanceId === attackerInstanceId);
     if (!attacker || !attacker.canAttack)
         return { game, attacked: false, attackerDamage: 0, targetDamage: 0, log: [] };
-    const damage = attacker.attack;
+    fireEffects(next, attacker, 'on_attack', attackerSeat, { targeting: 'leader' });
+    const damage = attacker.attack + (attacker.combatAttackBuff ?? 0);
     next.players[defenderSeat].leaderHp = Math.max(0, next.players[defenderSeat].leaderHp - damage);
+    attacker.combatAttackBuff = 0;
     attacker.canAttack = false;
     const log = [
         `${attacker.name} ${attackerSeat === 'P1' ? messages.attacksOpponentLeader : messages.attacksYourLeader}`,
@@ -74559,8 +74565,14 @@ function resolveAttackCharacter(game, attackerSeat, attackerInstanceId, targetIn
     if (!attacker || !target || !attacker.canAttack) {
         return { game, attacked: false, attackerDamage: 0, targetDamage: 0, log: [] };
     }
-    target.currentHp -= attacker.attack;
-    attacker.currentHp -= target.attack;
+    fireEffects(next, attacker, 'on_attack', attackerSeat, { targeting: 'character' }, target);
+    fireEffects(next, target, 'on_defend', defenderSeat, { targeting: 'character' }, attacker);
+    const attackerTotal = attacker.attack + (attacker.combatAttackBuff ?? 0);
+    const targetTotal = target.attack + (target.combatAttackBuff ?? 0);
+    target.currentHp -= attackerTotal;
+    attacker.currentHp -= targetTotal;
+    attacker.combatAttackBuff = 0;
+    target.combatAttackBuff = 0;
     attacker.canAttack = false;
     cleanupDestroyed(next.players[attackerSeat], next);
     cleanupDestroyed(next.players[defenderSeat], next);
@@ -74571,8 +74583,8 @@ function resolveAttackCharacter(game, attackerSeat, attackerInstanceId, targetIn
     return {
         game: next,
         attacked: true,
-        attackerDamage: target.attack,
-        targetDamage: attacker.attack,
+        attackerDamage: targetTotal,
+        targetDamage: attackerTotal,
         log,
     };
 }
@@ -74625,6 +74637,9 @@ function cleanupDestroyed(player, game) {
     const destroyed = player.battleZone.filter(card => card.currentHp <= 0);
     if (!destroyed.length)
         return;
+    for (const ch of destroyed) {
+        fireEffects(game, ch, 'on_death', ch.owner);
+    }
     game.historyZone.push(...destroyed.map(card => card.cardId));
     player.battleZone = player.battleZone.filter(card => card.currentHp > 0);
 }
@@ -74651,6 +74666,102 @@ function offeringAbilityReserveGain(abilityText, fallbackValue) {
 function opponentSeat(seat) {
     return seat === 'P1' ? 'P2' : 'P1';
 }
+function checkCondition(condition, ctx) {
+    if (!condition)
+        return true;
+    return condition.targeting === ctx.targeting;
+}
+function applyMutationToCharacter(ch, effect) {
+    const mut = effect.mutation;
+    const duration = effect.duration ?? 'permanent';
+    switch (mut.type) {
+        case 'buff_attack':
+            if (duration === 'combat') {
+                ch.combatAttackBuff = (ch.combatAttackBuff ?? 0) + mut.amount;
+            }
+            else {
+                ch.attack += mut.amount;
+            }
+            break;
+        case 'buff_life':
+            ch.currentHp += mut.amount;
+            ch.maxHp += mut.amount;
+            break;
+        case 'deal_damage':
+            ch.currentHp = Math.max(0, ch.currentHp - mut.amount);
+            break;
+        case 'restore_hp':
+            ch.currentHp = Math.min(ch.maxHp, ch.currentHp + mut.amount);
+            break;
+        case 'destroy':
+            ch.currentHp = 0;
+            break;
+    }
+}
+function applyEffect(game, effect, source, combatOpponent, seat) {
+    const { mutation: mut, target } = effect;
+    const opp = opponentSeat(seat);
+    switch (target) {
+        case 'self':
+            applyMutationToCharacter(source, effect);
+            break;
+        case 'combat_opponent':
+            if (combatOpponent)
+                applyMutationToCharacter(combatOpponent, effect);
+            break;
+        case 'all_friendly':
+            for (const ch of game.players[seat].battleZone)
+                applyMutationToCharacter(ch, effect);
+            break;
+        case 'all_enemy':
+            for (const ch of game.players[opp].battleZone)
+                applyMutationToCharacter(ch, effect);
+            break;
+        case 'opponent_leader':
+        case 'own_leader': {
+            const ls = target === 'opponent_leader' ? opp : seat;
+            if (mut.type === 'deal_damage') {
+                game.players[ls].leaderHp = Math.max(0, game.players[ls].leaderHp - mut.amount);
+            }
+            else if (mut.type === 'restore_hp') {
+                game.players[ls].leaderHp = Math.min(game.players[ls].leaderMaxHp, game.players[ls].leaderHp + mut.amount);
+            }
+            break;
+        }
+    }
+    // game-level mutations that bypass the character switch
+    if (mut.type === 'draw_card') {
+        for (let i = 0; i < mut.amount; i++)
+            drawCardFor(game, seat);
+    }
+    else if (mut.type === 'discard_card') {
+        const tSeat = mut.who === 'opponent' ? opp : seat;
+        const hand = game.players[tSeat].hand ?? [];
+        let seed = game.revision * 31 + game.turnCount * 7;
+        for (let i = 0; i < Math.min(mut.amount, hand.length); i++) {
+            seed = (seed * 1664525 + 1013904223) & 0xffffffff;
+            const idx = Math.abs(seed) % hand.length;
+            game.historyZone.push(hand.splice(idx, 1)[0]);
+        }
+        game.players[tSeat].hand = hand;
+    }
+    else if (mut.type === 'gain_offerings') {
+        game.players[seat].temporaryOfferingReserve =
+            (game.players[seat].temporaryOfferingReserve ?? 0) + mut.amount;
+    }
+}
+function fireEffects(game, source, trigger, seat, ctx = {}, combatOpponent = null) {
+    for (const effect of source.effects ?? []) {
+        if (effect.trigger !== trigger)
+            continue;
+        if (!checkCondition(effect.condition, ctx))
+            continue;
+        applyEffect(game, effect, source, combatOpponent, seat);
+    }
+}
+function bakeEffects(instance, effects) {
+    instance.effects = [...(instance.effects ?? []), ...effects];
+}
 // --- Tool equip passives (H8) ---
 function applyToolPassives(ch, card) {
     const text = card.abilities?.[0]?.text ?? '';
@@ -74667,6 +74778,7 @@ function applyToolPassives(ch, card) {
     if (lower.includes('puede atacar el turno en que entra')) {
         ch.canAttack = true;
     }
+    bakeEffects(ch, card.effects ?? []);
 }
 // --- Effect resolution (H7) ---
 function resolveCardEffect(game, card, seat) {