mirror of
https://github.com/Shu-Ying/noname-shuying.git
synced 2026-10-22 07:10:01 +08:00
911 lines
54 KiB
JavaScript
911 lines
54 KiB
JavaScript
// 刘备牌组沿用的 25 张铁甲牌及兼容重杀；保留原有卡名与效果接口。
|
|
import standard from "../../../../../../card/standard.js";
|
|
import { _status, game, get } from "../../../../../../noname.js";
|
|
import { cardCost, canPayCard, isActiveCardUse } from "../../../battle/combat-rules.js";
|
|
import { cardUpgradeLevel, cardUpgradeRule } from "../../upgrades.js";
|
|
import { applyMengsanDebuff } from "../../../monsters/artifact-status.js";
|
|
import { isAttackCard } from "../../../monsters/vine-tangled.js";
|
|
|
|
export function createLegacyLiuBeiCards({ copyToDiscard, reclaimFromDiscard, temporaryStrength, countStrikeCards, randomHandExhaust, battleEnergy, handExhaust, playDrawTop, blockDraw, blockUpgrade, lifeLossBlock, whirlwind, spite, rampage, isBattleActive = () => true } = {}) {
|
|
const card = {}, translate = {}, nativeSha = standard.card.sha;
|
|
card.mengsan_zhongsha = {
|
|
type: "basic",
|
|
fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_zhongsha.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_zhongsha" }),
|
|
enable(used, player, event) {
|
|
return !isActiveCardUse(event || _status.event, player) ||
|
|
canPayCard(player, used);
|
|
},
|
|
usable: Infinity,
|
|
selectTarget: 1,
|
|
range: nativeSha.range,
|
|
filterTarget: nativeSha.filterTarget,
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
const effect = cardUpgradeLevel(event.card)
|
|
? cardUpgradeRule("mengsan_zhongsha")
|
|
: { damage: 8, vulnerable: 2 };
|
|
const damage = target.damage(effect.damage, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
if (!target.isAlive()) return;
|
|
if (applyMengsanDebuff(target, "vulnerable", effect.vulnerable, player))
|
|
game.log(target, `获得${effect.vulnerable}层易伤`);
|
|
},
|
|
ai: { order: 4, result: { target: -1.5 },
|
|
tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const effect = cardUpgradeLevel(used)
|
|
? cardUpgradeRule("mengsan_zhongsha")
|
|
: { damage: 8, vulnerable: 2 };
|
|
return "梦三：主动使用消耗2费用。对攻击范围内的" +
|
|
`一名其他角色造成${effect.damage}点伤害，然后给予其` +
|
|
`${effect.vulnerable}层易伤。受到攻击伤害增加50%` +
|
|
"（向上取整），每个自身回合结束减少1层。" +
|
|
"每回合使用次数不限。";
|
|
},
|
|
};
|
|
translate.mengsan_zhongsha = "重杀";
|
|
translate.mengsan_zhongsha_info =
|
|
"梦三：主动使用消耗2费用。出牌阶段，对攻击范围内的" +
|
|
"一名其他角色造成8点伤害，然后给予其2层易伤。" +
|
|
"易伤使受到的攻击伤害增加50%（向上取整），" +
|
|
"每个自身回合结束减少1层。每回合使用次数不限。";
|
|
// STS2 Setup Strike: the new temporary strength does not enhance its own hit.
|
|
// STS2 Cinder: damage first, then exhaust one random remaining hand card.
|
|
card.mengsan_yujin = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_yujin.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_yujin" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
if (!isBattleActive() || !player.isAlive() || !target?.isAlive() ||
|
|
target === player || !player.isEnemyOf(target)) return;
|
|
if (!randomHandExhaust?.capture || !randomHandExhaust?.exhaust) throw new Error("余烬缺少随机消耗接口");
|
|
const battle = randomHandExhaust.capture();
|
|
if (!battle) return;
|
|
const rule = cardUpgradeRule("mengsan_yujin");
|
|
const damage = target.damage(cardUpgradeLevel(event.card) ? rule.damage : rule.baseDamage, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
if (isBattleActive() && player.isAlive()) await randomHandExhaust.exhaust(player, event, battle);
|
|
},
|
|
ai: { order: 6, result: { target: -2 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_yujin");
|
|
const amount = cardUpgradeLevel(used) ? rule.damage : rule.baseDamage;
|
|
return `梦三：主动使用消耗2费用。对一名敌方角色造成${amount}点伤害，然后随机消耗一张你的手牌（退出本场战斗，不进入弃牌堆或洗牌）。没有手牌时不消耗牌。每回合使用次数不限。`;
|
|
},
|
|
};
|
|
translate.mengsan_yujin = "余烬";
|
|
translate.mengsan_yujin_info = card.mengsan_yujin.cardPrompt({ name: "mengsan_yujin" });
|
|
// STS2 Perfected Strike counts current physical combat cards, including itself/exhaust.
|
|
card.mengsan_wanmeidaji = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_wanmeidaji.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_wanmeidaji" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
if (!isBattleActive() || !player.isAlive() || !target?.isAlive() ||
|
|
target === player || !player.isEnemyOf(target)) return;
|
|
if (typeof countStrikeCards !== "function") throw new Error("完美打击缺少打击牌计数接口");
|
|
const count = countStrikeCards(player, event);
|
|
if (!Number.isSafeInteger(count) || count < 0) throw new RangeError("打击牌数量无效");
|
|
const rule = cardUpgradeRule("mengsan_wanmeidaji");
|
|
const amount = rule.baseDamage + count * (cardUpgradeLevel(event.card) ? rule.perStrike : rule.basePerStrike);
|
|
if (!Number.isSafeInteger(amount) || amount < 0) throw new RangeError("完美打击伤害无效");
|
|
const damage = target.damage(amount, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
damage.mengsanStrikeCount_shuying = count;
|
|
await damage;
|
|
},
|
|
ai: { order: 7, result: { target: -2 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_wanmeidaji");
|
|
const bonus = cardUpgradeLevel(used) ? rule.perStrike : rule.basePerStrike;
|
|
return `梦三：主动使用消耗2费用。对一名敌方角色造成6点伤害，本场战斗的牌中每有一张【杀】或名称含“打击”的牌，伤害增加${bonus}点（包括手牌、个人抽牌堆、个人弃牌堆、消耗牌及打出区）。每回合使用次数不限。`;
|
|
},
|
|
};
|
|
translate.mengsan_wanmeidaji = "完美打击";
|
|
translate.mengsan_wanmeidaji_info = card.mengsan_wanmeidaji.cardPrompt({ name: "mengsan_wanmeidaji" });
|
|
card.mengsan_yubeidaji = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_yubeidaji.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_yubeidaji" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
if (!isBattleActive() || !player.isAlive() || !target?.isAlive() ||
|
|
target === player || !player.isEnemyOf(target)) return;
|
|
if (!temporaryStrength?.capture || !temporaryStrength?.grant) throw new Error("预备打击缺少临时力量接口");
|
|
const battle = temporaryStrength.capture();
|
|
if (!battle) return;
|
|
const rule = cardUpgradeRule("mengsan_yubeidaji");
|
|
const upgraded = cardUpgradeLevel(event.card);
|
|
const damage = target.damage(upgraded ? rule.damage : rule.baseDamage, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
if (isBattleActive() && player.isAlive()) {
|
|
temporaryStrength.grant(player, upgraded ? rule.strength : rule.baseStrength, event, battle);
|
|
}
|
|
},
|
|
ai: { order: 8, result: { player: 0.8, target: -1.5 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_yubeidaji");
|
|
const upgraded = cardUpgradeLevel(used);
|
|
return `梦三：主动使用消耗1费用。对一名敌方角色造成${upgraded ? rule.damage : rule.baseDamage}点伤害，然后在本回合内获得${upgraded ? rule.strength : rule.baseStrength}点力量。每回合使用次数不限。`;
|
|
},
|
|
};
|
|
translate.mengsan_yubeidaji = "预备打击";
|
|
translate.mengsan_yubeidaji_info = "梦三：主动使用消耗1费用。对一名敌方角色造成7点伤害，然后在本回合内获得2点力量。每回合使用次数不限。";
|
|
// STS2 Breakthrough: native life loss is paid once before the all-enemy attack.
|
|
card.mengsan_tupo = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_tupo.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_tupo" }),
|
|
notarget: true, usable: Infinity,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
if (!game.filterPlayer(target => target !== player &&
|
|
target.isAlive() && player.isEnemyOf(target)).length) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (!isBattleActive() || !player.isAlive()) return;
|
|
if (!game.filterPlayer(target => target !== player &&
|
|
target.isAlive() && player.isEnemyOf(target)).length) return;
|
|
// loseHp bypasses block and awaits the normal dying/rescue process.
|
|
await player.loseHp(1);
|
|
if (!isBattleActive() || !player.isAlive()) return;
|
|
const rule = cardUpgradeRule("mengsan_tupo");
|
|
const amount = cardUpgradeLevel(event.card) ? rule.damage : rule.baseDamage;
|
|
const targets = game.filterPlayer(target => target !== player &&
|
|
target.isAlive() && player.isEnemyOf(target));
|
|
for (const target of targets) {
|
|
if (!isBattleActive() || !player.isAlive()) break;
|
|
if (!target.isAlive() || !player.isEnemyOf(target)) continue;
|
|
player.line(target, "green");
|
|
const damage = target.damage(amount, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
}
|
|
},
|
|
ai: { order: 7, result: { player(player) { return player.hp <= 1 ? -10 : 1; } }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_tupo");
|
|
const amount = cardUpgradeLevel(used) ? rule.damage : rule.baseDamage;
|
|
return `梦三：主动使用消耗1费用。失去1点生命，然后对所有敌方角色造成${amount}点伤害。每回合使用次数不限。`;
|
|
},
|
|
};
|
|
translate.mengsan_tupo = "突破";
|
|
translate.mengsan_tupo_info = "梦三：主动使用消耗1费用。失去1点生命，然后对所有敌方角色造成9点伤害。每回合使用次数不限。";
|
|
// STS2 Headbutt: damage first, then choose from the actor's own real discard pile.
|
|
card.mengsan_touchui = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_touchui.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_touchui" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
if (!isBattleActive() || !player.isAlive() || !target?.isAlive() ||
|
|
target === player || !player.isEnemyOf(target)) return;
|
|
if (typeof reclaimFromDiscard !== "function") throw new Error("头槌缺少个人弃牌回收接口");
|
|
const rule = cardUpgradeRule("mengsan_touchui");
|
|
const amount = cardUpgradeLevel(event.card) ? rule.damage : rule.baseDamage;
|
|
const damage = target.damage(amount, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
// Defeating one enemy does not prevent recovery unless combat actually ends.
|
|
if (isBattleActive() && player.isAlive()) await reclaimFromDiscard(player);
|
|
},
|
|
ai: { order: 6, result: { player: 0.4, target: -1.5 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_touchui");
|
|
const amount = cardUpgradeLevel(used) ? rule.damage : rule.baseDamage;
|
|
return '梦三：主动使用消耗1费用。对一名敌方角色造成' + amount +
|
|
'点伤害，然后选择个人弃牌堆中的一张牌放到个人抽牌堆顶部。每回合使用次数不限。';
|
|
},
|
|
};
|
|
translate.mengsan_touchui = "头槌";
|
|
translate.mengsan_touchui_info = "梦三：主动使用消耗1费用。对一名敌方角色造成9点伤害，" +
|
|
"然后选择个人弃牌堆中的一张牌放到个人抽牌堆顶部。每回合使用次数不限。";
|
|
// STS2 Iron Wave: obtain block before resolving the attack.
|
|
card.mengsan_tiezhanbo = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_tiezhanbo.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_tiezhanbo" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
const canResolve = () => isBattleActive() && player.isAlive() &&
|
|
target?.isAlive() && target !== player && player.isEnemyOf(target);
|
|
if (!canResolve()) return;
|
|
const rule = cardUpgradeRule("mengsan_tiezhanbo");
|
|
const upgraded = cardUpgradeLevel(event.card) > 0;
|
|
await player.changeHujia(upgraded ? rule.block : rule.baseBlock);
|
|
// Block triggers may end combat or remove the acting player/target.
|
|
if (!canResolve()) return;
|
|
const damage = target.damage(upgraded ? rule.damage : rule.baseDamage, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
},
|
|
ai: { order: 7, result: { player: 0.6, target: -1.2 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_tiezhanbo");
|
|
const upgraded = cardUpgradeLevel(used) > 0;
|
|
const block = upgraded ? rule.block : rule.baseBlock;
|
|
const damage = upgraded ? rule.damage : rule.baseDamage;
|
|
return '梦三：主动使用消耗1费用。获得' + block +
|
|
'点格挡（护甲），然后对一名敌方角色造成' + damage +
|
|
'点伤害。每回合使用次数不限。';
|
|
},
|
|
};
|
|
translate.mengsan_tiezhanbo = "铁斩波";
|
|
translate.mengsan_tiezhanbo_info = "梦三：主动使用消耗1费用。获得5点格挡（护甲），" +
|
|
"然后对一名敌方角色造成5点伤害。每回合使用次数不限。";
|
|
// STS2 Twin Strike: each hit resolves on the same target separately.
|
|
card.mengsan_shuangchongdaji = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_shuangchongdaji.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_shuangchongdaji" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
const rule = cardUpgradeRule("mengsan_shuangchongdaji");
|
|
const amount = cardUpgradeLevel(event.card) ? rule.damage : rule.baseDamage;
|
|
for (let hitIndex = 0; hitIndex < rule.hits; hitIndex++) {
|
|
if (!isBattleActive() || !player.isAlive() || !target?.isAlive() ||
|
|
target === player || !player.isEnemyOf(target)) break;
|
|
const damage = target.damage(amount, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
}
|
|
},
|
|
ai: { order: 6, result: { target: -1.5 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_shuangchongdaji");
|
|
const amount = cardUpgradeLevel(used) ? rule.damage : rule.baseDamage;
|
|
return '梦三：主动使用消耗1费用。对一名敌方角色造成' +
|
|
amount + '点伤害两次，两次伤害分别结算。每回合使用次数不限。';
|
|
},
|
|
};
|
|
translate.mengsan_shuangchongdaji = "双重打击";
|
|
translate.mengsan_shuangchongdaji_info = "梦三：主动使用消耗1费用。对一名敌方角色造成5点伤害两次，" +
|
|
"两次伤害分别结算。每回合使用次数不限。";
|
|
// STS2 Thunderclap: hit each living enemy before adding new vulnerable.
|
|
card.mengsan_shandianpili = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_shandianpili.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_shandianpili" }),
|
|
notarget: true, usable: Infinity,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
if (!game.filterPlayer(target => target !== player &&
|
|
target.isAlive() && player.isEnemyOf(target)).length) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (!isBattleActive() || !player.isAlive()) return;
|
|
const rule = cardUpgradeRule("mengsan_shandianpili");
|
|
const amount = cardUpgradeLevel(event.card) ? rule.damage : rule.baseDamage;
|
|
const targets = game.filterPlayer(target => target !== player &&
|
|
target.isAlive() && player.isEnemyOf(target));
|
|
for (const target of targets) {
|
|
if (!isBattleActive() || !player.isAlive()) break;
|
|
if (!target.isAlive() || !player.isEnemyOf(target)) continue;
|
|
player.line(target, "green");
|
|
const damage = target.damage(amount, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
}
|
|
// 伤害结束后重新取得存活敌人，包含异蛙亡语刚生成的扭动虫。
|
|
for (const target of game.filterPlayer(target => target !== player && target.isAlive() && player.isEnemyOf(target))) {
|
|
if (!isBattleActive() || !player.isAlive()) break;
|
|
if (applyMengsanDebuff(target, "vulnerable", rule.vulnerable, player))
|
|
game.log(target, `获得${rule.vulnerable}层易伤`);
|
|
}
|
|
},
|
|
ai: { order: 7, result: { player: 1 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_shandianpili");
|
|
const amount = cardUpgradeLevel(used) ? rule.damage : rule.baseDamage;
|
|
return `梦三：主动使用消耗1费用。对所有敌方角色造成${amount}点伤害，然后给予其1层易伤。` +
|
|
"易伤使受到的攻击伤害增加50%（向上取整），每个自身回合结束减少1层。每回合使用次数不限。";
|
|
},
|
|
};
|
|
translate.mengsan_shandianpili = "闪电霹雳";
|
|
translate.mengsan_shandianpili_info = "梦三：主动使用消耗1费用。对所有敌方角色造成4点伤害，然后给予其1层易伤。" +
|
|
"易伤使受到的攻击伤害增加50%（向上取整），每个自身回合结束减少1层。每回合使用次数不限。";
|
|
// Each throw resolves separately and samples the still-living enemies again.
|
|
card.mengsan_feijianhuixuanbiao = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_feijianhuixuanbiao.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_feijianhuixuanbiao" }),
|
|
notarget: true, usable: Infinity,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
if (!game.filterPlayer(target => target !== player &&
|
|
target.isAlive() && player.isEnemyOf(target)).length) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const rule = cardUpgradeRule("mengsan_feijianhuixuanbiao");
|
|
const count = cardUpgradeLevel(event.card) ? rule.hits : rule.baseHits;
|
|
for (let hitIndex = 0; hitIndex < count; hitIndex++) {
|
|
if (!isBattleActive() || !player.isAlive()) break;
|
|
const enemies = game.filterPlayer(target => target !== player &&
|
|
target.isAlive() && player.isEnemyOf(target));
|
|
if (!enemies.length) break;
|
|
// Use the engine helper with an inclusive index range.
|
|
const target = enemies[get.rand(0, enemies.length - 1)];
|
|
player.line(target, "green");
|
|
const damage = target.damage(rule.damage, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
}
|
|
},
|
|
ai: { order: 6, result: { player: 1 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_feijianhuixuanbiao");
|
|
const count = cardUpgradeLevel(used) ? rule.hits : rule.baseHits;
|
|
return `梦三：主动使用消耗1费用。每次对随机一名敌方角色造成${rule.damage}点伤害，共${count}次。` +
|
|
"每次攻击重新随机选择存活的敌人，可以重复命中同一敌人。" +
|
|
"每回合使用次数不限。";
|
|
},
|
|
};
|
|
translate.mengsan_feijianhuixuanbiao = "飞剑回旋镖";
|
|
translate.mengsan_feijianhuixuanbiao_info = "梦三：主动使用消耗1费用。随机对敌人造成3点伤害3次。" +
|
|
"每次攻击重新随机选择存活的敌人，可以重复命中同一敌人。每回合使用次数不限。";
|
|
// Resolve damage before drawing from the acting player's mode-owned pile.
|
|
card.mengsan_jianbingdaji = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_jianbingdaji.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_jianbingdaji" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (!isBattleActive() || !player.isAlive()) return;
|
|
const rule = cardUpgradeRule("mengsan_jianbingdaji");
|
|
const upgraded = cardUpgradeLevel(event.card) > 0;
|
|
const damage = event.target.damage(upgraded ? rule.damage : rule.baseDamage, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
// Defeating the last enemy may dispose the personal pile during damage.
|
|
if (isBattleActive() && player.isAlive()) {
|
|
await player.draw(upgraded ? rule.draw : rule.baseDraw);
|
|
}
|
|
},
|
|
ai: { order: 6, result: { player: 0.6, target: -1.5 }, tag: { damage: 1, draw: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_jianbingdaji");
|
|
const upgraded = cardUpgradeLevel(used) > 0;
|
|
const damage = upgraded ? rule.damage : rule.baseDamage;
|
|
const draw = upgraded ? rule.draw : rule.baseDraw;
|
|
return `梦三：主动使用消耗1费用。对一名敌方角色造成${damage}点伤害，然后抽${draw}张牌。` +
|
|
"每回合使用次数不限。";
|
|
},
|
|
};
|
|
translate.mengsan_jianbingdaji = "剑柄打击";
|
|
translate.mengsan_jianbingdaji_info = "梦三：主动使用消耗1费用。对一名敌方角色造成9点伤害，然后抽1张牌。" +
|
|
"每回合使用次数不限。";
|
|
// Block determines base damage without spending the acting player's block.
|
|
card.mengsan_quanshenzhuangji = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_quanshenzhuangji.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_quanshenzhuangji" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (!isBattleActive() || !player.isAlive()) return;
|
|
const block = Number.isFinite(player.hujia) ? Math.max(0, player.hujia) : 0;
|
|
const storedStrength = player.storage?.mengsanStrength_shuying;
|
|
const strength = Number.isInteger(storedStrength) ? storedStrength : 0;
|
|
// Native damage(0) stops before damageBegin1, so strength must be included here.
|
|
const temporary = temporaryStrength?.amount(player) || 0;
|
|
const damage = event.target.damage(Math.max(0, block + strength + temporary), player);
|
|
damage.mengsanAttack_shuying = true;
|
|
damage.mengsanCardStrengthApplied_shuying = true;
|
|
damage.mengsanSetupStrengthApplied_shuying = true;
|
|
await damage;
|
|
},
|
|
ai: {
|
|
order: 5,
|
|
result: { target(used, player) { return player.hujia > 0 ? -1.5 : 0; } },
|
|
tag: { damage: 1 },
|
|
},
|
|
cardPrompt(used) {
|
|
const cost = cardCost(used || { name: "mengsan_quanshenzhuangji" });
|
|
return `梦三：主动使用消耗${cost}费用。对一名敌方角色造成等同于你当前格挡（护甲）值的伤害。` +
|
|
"不消耗格挡，可以受到力量加成。" +
|
|
"每回合使用次数不限。";
|
|
},
|
|
};
|
|
translate.mengsan_quanshenzhuangji = "全身撞击";
|
|
translate.mengsan_quanshenzhuangji_info = "梦三：主动使用消耗1费用。对一名敌方角色造成等同于你当前格挡（护甲）值的伤害。" +
|
|
"不消耗格挡，可以受到力量加成。每回合使用次数不限。";
|
|
// Double only the surviving target's existing vulnerable after damage resolves.
|
|
card.mengsan_rongrongzhiquan = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_rongrongzhiquan.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_rongrongzhiquan" }),
|
|
mengsanExhaust_shuying: true,
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
if (!isBattleActive() || !player.isAlive()) return false;
|
|
return !isActiveCardUse(event || _status.event, player) || canPayCard(player, used);
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (!isBattleActive() || !player.isAlive()) return;
|
|
const rule = cardUpgradeRule("mengsan_rongrongzhiquan");
|
|
const target = event.target;
|
|
const damage = target.damage(cardUpgradeLevel(event.card) ? rule.damage : rule.baseDamage, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
if (!target.isAlive() || !isBattleActive()) return;
|
|
const stacks = target.storage?.mengsanVulnerable_shuying;
|
|
if (!Number.isSafeInteger(stacks) || stacks <= 0) return;
|
|
const doubled = stacks * 2;
|
|
if (!Number.isSafeInteger(doubled)) throw new RangeError("易伤层数越界");
|
|
if (applyMengsanDebuff(target, "vulnerable", stacks, player))
|
|
game.log(target, `易伤层数从${stacks}翻倍为${doubled}`);
|
|
},
|
|
ai: { order: 6, result: { target: -1.5 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_rongrongzhiquan");
|
|
const damage = cardUpgradeLevel(used) ? rule.damage : rule.baseDamage;
|
|
return `梦三：主动使用消耗1费用。对一名敌方角色造成${damage}点伤害，然后将该目标已有的易伤层数翻倍。` +
|
|
"没有易伤时不会新增易伤。消耗：使用后退出本场战斗，不进入弃牌堆或洗牌。";
|
|
},
|
|
};
|
|
translate.mengsan_rongrongzhiquan = "熔融之拳";
|
|
translate.mengsan_rongrongzhiquan_info = "梦三：主动使用消耗1费用。对一名敌方角色造成10点伤害，然后将该目标已有的易伤层数翻倍。" +
|
|
"消耗：使用后退出本场战斗。";
|
|
// STS2【愤怒】：攻击后生成独立的战斗复制品，不扩充永久牌组。
|
|
card.mengsan_fennu = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_fennu.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_fennu" }),
|
|
enable(used, player, event) {
|
|
return !isActiveCardUse(event || _status.event, player) ||
|
|
canPayCard(player, used);
|
|
},
|
|
usable: Infinity, selectTarget: 1,
|
|
filterTarget(used, player, target) {
|
|
return target !== player && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (typeof copyToDiscard !== "function") throw new Error("愤怒缺少战斗复制接口");
|
|
const amount = cardUpgradeLevel(event.card)
|
|
? cardUpgradeRule("mengsan_fennu").damage : 6;
|
|
const damage = event.target.damage(amount, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
if (copyToDiscard(player, event.card, event.cards)) {
|
|
game.log(player, "将一张【愤怒】的复制品加入个人弃牌堆");
|
|
}
|
|
},
|
|
ai: { order: 6, result: { target: -1 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const amount = cardUpgradeLevel(used)
|
|
? cardUpgradeRule("mengsan_fennu").damage : 6;
|
|
return `梦三：主动使用消耗0费用。对一名敌方角色造成${amount}点伤害，` +
|
|
"然后将一张此牌的复制品加入你的个人弃牌堆。" +
|
|
"复制品保留原牌状态和词缀，仅存在于本场战斗。";
|
|
},
|
|
};
|
|
translate.mengsan_fennu = "愤怒";
|
|
translate.mengsan_fennu_info = "梦三：主动使用消耗0费用。对一名敌方角色造成6点伤害，" +
|
|
"然后将一张此牌的复制品加入你的个人弃牌堆。复制品保留原牌状态和词缀，仅存在于本场战斗。" +
|
|
"每回合使用次数不限。";
|
|
// STS2【放血】：先等待原生生命流失及濒死救援，再增加当前战斗费用。
|
|
card.mengsan_fangxue = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_fangxue.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_fangxue" }),
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(battleEnergy?.canUse(player)) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
usable: Infinity, toself: true, selectTarget: -1,
|
|
filterTarget(used, player, target) { return target === player; },
|
|
async content(event, trigger, player) {
|
|
if (typeof battleEnergy?.capture !== "function" || typeof battleEnergy?.grant !== "function") {
|
|
throw new Error("放血缺少战斗费用接口");
|
|
}
|
|
const rule = cardUpgradeRule("mengsan_fangxue");
|
|
const amount = cardUpgradeLevel(event.card) ? rule.energy : rule.baseEnergy;
|
|
const battle = battleEnergy.capture(player, amount);
|
|
if (!battle) return;
|
|
await player.loseHp(rule.loseHp);
|
|
battleEnergy.grant(player, amount, battle);
|
|
},
|
|
ai: { order: 9, result: { player: player => player.hp > 3 ? 1 : -1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_fangxue");
|
|
const amount = cardUpgradeLevel(used) ? rule.energy : rule.baseEnergy;
|
|
return "梦三：主动使用消耗0费用。失去" + rule.loseHp + "点生命，然后获得" + amount + "点费用。";
|
|
},
|
|
};
|
|
translate.mengsan_fangxue = "放血";
|
|
translate.mengsan_fangxue_info = "梦三：主动使用消耗0费用。失去3点生命，然后获得2点费用。";
|
|
// STS2【坚毅】：先获得格挡，再消耗一张自身当时的手牌。
|
|
card.mengsan_jianyi = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_jianyi.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_jianyi" }),
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
usable: Infinity, toself: true, selectTarget: -1,
|
|
filterTarget(used, player, target) { return target === player; },
|
|
async content(event, trigger, player) {
|
|
if (typeof handExhaust?.capture !== "function" || typeof handExhaust?.exhaust !== "function") {
|
|
throw new Error("坚毅缺少手牌消耗接口");
|
|
}
|
|
const battle = handExhaust.capture(player);
|
|
if (!battle) return;
|
|
const rule = cardUpgradeRule("mengsan_jianyi");
|
|
const current = cardUpgradeLevel(event.card);
|
|
await player.changeHujia(current ? rule.block : rule.baseBlock);
|
|
await handExhaust.exhaust(player, event, battle, Boolean(current && rule.chooseExhaust));
|
|
},
|
|
ai: { order: 7, result: { player: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_jianyi");
|
|
const current = cardUpgradeLevel(used);
|
|
const block = current ? rule.block : rule.baseBlock;
|
|
return "梦三：主动使用消耗1费用。获得" + block + "点格挡（护甲），然后" +
|
|
(current && rule.chooseExhaust ? "选择消耗" : "随机消耗") +
|
|
"一张你的手牌（退出本场战斗，不进入弃牌堆或洗牌）。没有手牌时不消耗牌。";
|
|
},
|
|
};
|
|
translate.mengsan_jianyi = "坚毅";
|
|
translate.mengsan_jianyi_info = "梦三：主动使用消耗1费用。获得7点格挡（护甲），然后随机消耗一张你的手牌（退出本场战斗，不进入弃牌堆或洗牌）。没有手牌时不消耗牌。";
|
|
// STS2【破灭】：免费使用自己的堆顶原牌，再将这一原牌消耗。
|
|
card.mengsan_pomie = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_pomie.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_pomie" }),
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
usable: Infinity, toself: true, selectTarget: -1,
|
|
filterTarget(used, player, target) { return target === player; },
|
|
async content(event, trigger, player) {
|
|
if (typeof playDrawTop !== "function") throw new Error("破灭缺少堆顶使用接口");
|
|
await playDrawTop(player);
|
|
},
|
|
ai: { order: 6, result: { player: 1 } },
|
|
cardPrompt(used) {
|
|
return "梦三：主动使用消耗" + cardCost(used) +
|
|
"费用。免费使用你抽牌堆顶部的牌，然后将该原牌消耗（退出本场战斗，不进入弃牌堆或洗牌）。抽牌堆为空时不生效。";
|
|
},
|
|
};
|
|
translate.mengsan_pomie = "破灭";
|
|
translate.mengsan_pomie_info = "梦三：主动使用消耗1费用。免费使用你抽牌堆顶部的牌，然后将该原牌消耗（退出本场战斗，不进入弃牌堆或洗牌）。抽牌堆为空时不生效。";
|
|
// STS2【耸肩无视】：先获得格挡，再抽一张牌。
|
|
card.mengsan_songjianwushi = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_songjianwushi.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_songjianwushi" }),
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
usable: Infinity, toself: true, selectTarget: -1,
|
|
filterTarget(used, player, target) { return target === player; },
|
|
async content(event, trigger, player) {
|
|
if (typeof blockDraw !== "function") throw new Error("耸肩无视缺少格挡抽牌接口");
|
|
const rule = cardUpgradeRule("mengsan_songjianwushi");
|
|
await blockDraw(player, cardUpgradeLevel(event.card) ? rule.block : rule.baseBlock, rule.draw);
|
|
},
|
|
ai: { order: 7, result: { player: 1 }, tag: { draw: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_songjianwushi");
|
|
const block = cardUpgradeLevel(used) ? rule.block : rule.baseBlock;
|
|
return "梦三：主动使用消耗1费用。获得" + block + "点格挡（护甲），然后抽" + rule.draw + "张牌。";
|
|
},
|
|
};
|
|
translate.mengsan_songjianwushi = "耸肩无视";
|
|
translate.mengsan_songjianwushi_info = "梦三：主动使用消耗1费用。获得8点格挡（护甲），然后抽1张牌。";
|
|
// STS2【暴走】：先攻击，再仅增加本场这张实体牌的伤害。
|
|
card.mengsan_baozou = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_baozou.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_baozou" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (typeof rampage?.apply !== "function") throw new Error("暴走缺少战斗累积接口");
|
|
const rule = cardUpgradeRule("mengsan_baozou");
|
|
const original = rampage.original(event) || event.card;
|
|
await rampage.apply(player, event, rule.damage,
|
|
cardUpgradeLevel(original) ? rule.increase : rule.baseIncrease);
|
|
},
|
|
ai: { order: 5, result: { target: -1.5 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_baozou");
|
|
const source = rampage?.card(used) || used;
|
|
const increase = cardUpgradeLevel(source) ? rule.increase : rule.baseIncrease;
|
|
const damage = rampage?.damage(used) ?? rule.damage;
|
|
return "梦三：主动使用消耗1费用。对一名敌方角色造成" + damage +
|
|
"点伤害，然后将这张牌在本场战斗中的伤害增加" + increase + "点。";
|
|
},
|
|
};
|
|
translate.mengsan_baozou = "暴走";
|
|
translate.mengsan_baozou_info = card.mengsan_baozou.cardPrompt({ name: "mengsan_baozou" });
|
|
// STS2【怨恨】：读取本回合实际生命损失，固定次数后逐次原生攻击。
|
|
card.mengsan_yuanhen = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_yuanhen.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_yuanhen" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (typeof spite !== "function") throw new Error("怨恨缺少战斗攻击接口");
|
|
const rule = cardUpgradeRule("mengsan_yuanhen");
|
|
await spite(player, event, rule.damage,
|
|
cardUpgradeLevel(event.card) ? rule.hits : rule.baseHits);
|
|
},
|
|
ai: { order: 4, result: { target: -1.5 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_yuanhen");
|
|
const hits = cardUpgradeLevel(used) ? rule.hits : rule.baseHits;
|
|
return "梦三：主动使用消耗0费用。对一名敌方角色造成5点伤害。" +
|
|
"如果你在本回合失去过生命值，则改为连续攻击" + hits + "次，每次造成5点伤害，分别结算。";
|
|
},
|
|
};
|
|
translate.mengsan_yuanhen = "怨恨";
|
|
translate.mengsan_yuanhen_info = card.mengsan_yuanhen.cardPrompt({ name: "mengsan_yuanhen" });
|
|
// STS2【旋风斩】：X 在原生用牌支付时固定，逐次重取存活敌人。
|
|
card.mengsan_xuanfengzhan = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_xuanfengzhan.png",
|
|
mengsanCost_shuying: "X", mengsanXCost_shuying: true,
|
|
notarget: true, usable: Infinity,
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
game.filterPlayer(target => target !== player && target.isAlive() && player.isEnemyOf(target)).length > 0 &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used, event || _status.event));
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (typeof whirlwind !== "function") throw new Error("旋风斩缺少X费用攻击接口");
|
|
const rule = cardUpgradeRule("mengsan_xuanfengzhan");
|
|
await whirlwind(player, event, cardUpgradeLevel(event.card) ? rule.damage : rule.baseDamage);
|
|
},
|
|
ai: { order: 3, result: { player: 1 }, tag: { damage: 1, multitarget: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_xuanfengzhan");
|
|
const amount = cardUpgradeLevel(used) ? rule.damage : rule.baseDamage;
|
|
return "梦三：X费用。消耗当前剩余费用，对所有敌方角色各造成" + amount +
|
|
"点伤害X次，每次分别结算。X为本次用于攻击的费用；缠结时先扣除1点附加费用。X为0时不造成伤害。";
|
|
},
|
|
};
|
|
translate.mengsan_xuanfengzhan = "旋风斩";
|
|
translate.mengsan_xuanfengzhan_info = card.mengsan_xuanfengzhan.cardPrompt({ name: "mengsan_xuanfengzhan" });
|
|
// STS2【欺凌】：按本次目标当前易伤层数计算一次基础攻击，不消耗易伤。
|
|
card.mengsan_qiling = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_qiling.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_qiling" }),
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
if (!isBattleActive() || !player.isAlive() || !target?.isAlive() ||
|
|
target === player || !player.isEnemyOf(target)) return;
|
|
const layers = target.storage?.mengsanVulnerable_shuying ?? 0;
|
|
if (!Number.isSafeInteger(layers) || layers < 0) throw new RangeError("欺凌易伤层数无效");
|
|
const rule = cardUpgradeRule("mengsan_qiling");
|
|
const perLayer = cardUpgradeLevel(event.card) ? rule.perVulnerable : rule.basePerVulnerable;
|
|
const amount = rule.baseDamage + layers * perLayer;
|
|
if (!Number.isSafeInteger(amount) || amount < 0) throw new RangeError("欺凌伤害越界");
|
|
const damage = target.damage(amount, player);
|
|
damage.mengsanAttack_shuying = true;
|
|
await damage;
|
|
},
|
|
ai: { order: 6, result: { target: -1.5 }, tag: { damage: 1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_qiling");
|
|
const perLayer = cardUpgradeLevel(used) ? rule.perVulnerable : rule.basePerVulnerable;
|
|
return "梦三：主动使用消耗0费用。对一名敌方角色造成4点伤害，" +
|
|
"该目标每有1层易伤，额外增加" + perLayer + "点伤害。不消耗易伤层数。每回合使用次数不限。";
|
|
},
|
|
};
|
|
translate.mengsan_qiling = "欺凌";
|
|
translate.mengsan_qiling_info = "梦三：主动使用消耗0费用。对一名敌方角色造成4点伤害，" +
|
|
"该目标每有1层易伤，额外增加2点伤害。不消耗易伤层数。每回合使用次数不限。";
|
|
// STS2【血墙】：等待原生生命流失及濒死救援，再给同一战斗中的使用者格挡。
|
|
card.mengsan_xueqiang = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_xueqiang.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_xueqiang" }),
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(lifeLossBlock?.canUse(player)) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
usable: Infinity, toself: true, selectTarget: -1,
|
|
filterTarget(used, player, target) { return target === player; },
|
|
async content(event, trigger, player) {
|
|
if (typeof lifeLossBlock?.apply !== "function") throw new Error("血墙缺少生命流失格挡接口");
|
|
const rule = cardUpgradeRule("mengsan_xueqiang");
|
|
await lifeLossBlock.apply(player, rule.loseHp,
|
|
cardUpgradeLevel(event.card) ? rule.block : rule.baseBlock);
|
|
},
|
|
ai: { order: 7, result: { player: player => player.hp > 2 ? 1 : -1 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_xueqiang");
|
|
const block = cardUpgradeLevel(used) ? rule.block : rule.baseBlock;
|
|
return "梦三：主动使用消耗2费用。失去2点生命，然后获得" + block + "点格挡（护甲）。";
|
|
},
|
|
};
|
|
translate.mengsan_xueqiang = "血墙";
|
|
translate.mengsan_xueqiang_info = "梦三：主动使用消耗2费用。失去2点生命，然后获得16点格挡（护甲）。";
|
|
// STS2【战栗】：施加易伤走既有人工制品入口，消耗走原生用牌及个人牌堆。
|
|
card.mengsan_zhanli = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_zhanli.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_zhanli" }),
|
|
mengsanExhaust_shuying: true,
|
|
usable: Infinity, selectTarget: 1,
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
filterTarget(used, player, target) {
|
|
return target !== player && target.isAlive() && player.isEnemyOf(target);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.target;
|
|
if (!isBattleActive() || !player.isAlive() || !target?.isAlive() ||
|
|
target === player || !player.isEnemyOf(target)) return;
|
|
const rule = cardUpgradeRule("mengsan_zhanli");
|
|
const amount = cardUpgradeLevel(event.card) ? rule.vulnerable : rule.baseVulnerable;
|
|
if (applyMengsanDebuff(target, "vulnerable", amount, player))
|
|
game.log(target, `获得${amount}层易伤`);
|
|
},
|
|
ai: { order: 9, result: { target: -1.2 } },
|
|
cardPrompt(used) {
|
|
const rule = cardUpgradeRule("mengsan_zhanli");
|
|
const amount = cardUpgradeLevel(used) ? rule.vulnerable : rule.baseVulnerable;
|
|
return "梦三：主动使用消耗1费用。给予一名敌方角色" + amount + "层易伤。" +
|
|
"易伤使受到的攻击伤害增加50%（向上取整），每个自身回合结束减少1层。" +
|
|
"消耗（使用后退出本场战斗，不进入弃牌堆或洗牌）。";
|
|
},
|
|
};
|
|
translate.mengsan_zhanli = "战栗";
|
|
translate.mengsan_zhanli_info = "梦三：主动使用消耗1费用。给予一名敌方角色3层易伤。" +
|
|
"易伤使受到的攻击伤害增加50%（向上取整），每个自身回合结束减少1层。" +
|
|
"消耗（使用后退出本场战斗，不进入弃牌堆或洗牌）。";
|
|
// STS2【武装】：格挡结算后只强化当前战斗的真实手牌。
|
|
card.mengsan_wuzhuang = {
|
|
type: "basic", fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_wuzhuang.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_wuzhuang" }),
|
|
enable(used, player, event) {
|
|
return isBattleActive() && Boolean(player?.isAlive?.()) &&
|
|
(!isActiveCardUse(event || _status.event, player) || canPayCard(player, used));
|
|
},
|
|
usable: Infinity, toself: true, selectTarget: -1,
|
|
filterTarget(used, player, target) { return target === player; },
|
|
async content(event, trigger, player) {
|
|
if (typeof blockUpgrade !== "function") throw new Error("武装缺少格挡强化接口");
|
|
await blockUpgrade(player, event, cardUpgradeRule("mengsan_wuzhuang").block,
|
|
Boolean(cardUpgradeLevel(event.card)));
|
|
},
|
|
ai: { order: 8, result: { player: 1 } },
|
|
cardPrompt(used) {
|
|
const selection = cardUpgradeLevel(used) ? "所有牌" : "一张牌";
|
|
return "梦三：主动使用消耗1费用。获得5点格挡（护甲），然后强化你手牌中的" + selection + "（仅本场战斗）。";
|
|
},
|
|
};
|
|
translate.mengsan_wuzhuang = "武装";
|
|
translate.mengsan_wuzhuang_info = "梦三：主动使用消耗1费用。获得5点格挡（护甲），然后强化你手牌中的一张牌（仅本场战斗）。";
|
|
// 【防御】沿用梦三护甲事件，保留脆弱与伤害抵扣等既有规则。
|
|
card.mengsan_fangyu = {
|
|
type: "basic",
|
|
fullimage: true,
|
|
image: "ext:术樱包/mengsan/assets/cards/mengsan_fangyu.png",
|
|
mengsanCost_shuying: cardCost({ name: "mengsan_fangyu" }),
|
|
enable(used, player, event) {
|
|
return !isActiveCardUse(event || _status.event, player) ||
|
|
canPayCard(player, used);
|
|
},
|
|
usable: Infinity,
|
|
toself: true,
|
|
selectTarget: -1,
|
|
filterTarget(used, player, target) { return target === player; },
|
|
async content(event, trigger, player) {
|
|
await player.changeHujia(cardUpgradeLevel(event.card) ? 8 : 5);
|
|
},
|
|
ai: { order: 7, result: { target: 1 } },
|
|
cardPrompt(used) { return `梦三：主动使用消耗1费用。获得${cardUpgradeLevel(used) ? 8 : 5}点格挡（护甲）。`; },
|
|
};
|
|
translate.mengsan_fangyu = "防御";
|
|
translate.mengsan_fangyu_info =
|
|
"梦三：主动使用消耗1费用。出牌阶段，对自己使用，获得5点格挡（护甲）。" +
|
|
"每回合使用次数不限。";
|
|
// 【桃】的回复量也由梦三牌本体提供；救援仍不消耗费用。
|
|
return { cards:card, translate, names:Object.keys(card) };
|
|
}
|