mirror of
https://github.com/Shu-Ying/noname-shuying.git
synced 2026-10-09 18:40:19 +08:00
Diuse
02e7a642ea
✨ 重构活动BOSS武将包并新增独立PVP武将包 ✨ 完善天书动态难度、过关奖励与羁绊系统 🎨 新增自定义技能选择、羁绊谱册及移动端适配 🔊 整理BOSS配音、图片与模块资源路径 🐛 修复天书关卡、伤害保护及武将包加载问题
922 lines
22 KiB
JavaScript
922 lines
22 KiB
JavaScript
import { lib, game, ui, get, ai, _status, getTianshuDifficulty } from "../../shared.js";
|
|
|
|
const skills = {
|
|
//水神共工 over
|
|
shuishen_shuying: {
|
|
mode: ["boss"],
|
|
forced: true,
|
|
group: ["shuishen_shuying_recover", "shuishen_shuying_draw", "shuishen_shuying_damage"],
|
|
subSkill: {
|
|
recover: {
|
|
trigger: { player: "recoverBegin" },
|
|
audio: false,
|
|
forced: true,
|
|
filter(event, player) {
|
|
return game.shuying_getDiscardNamesNum() >= 4;
|
|
},
|
|
async content(event, trigger, player) {
|
|
trigger.num++;
|
|
},
|
|
},
|
|
draw: {
|
|
trigger: { player: "phaseDrawBegin2" },
|
|
audio: false,
|
|
forced: true,
|
|
filter(event, player) {
|
|
return !event.numFixed && game.shuying_getDiscardNamesNum() >= 5;
|
|
},
|
|
async content(event, trigger, player) {
|
|
trigger.num += 5;
|
|
},
|
|
},
|
|
damage: {
|
|
trigger: { source: "damageBegin1" },
|
|
audio: false,
|
|
forced: true,
|
|
filter(event, player) {
|
|
return game.shuying_getDiscardNamesNum() >= 9;
|
|
},
|
|
async content(event, trigger, player) {
|
|
trigger.num++;
|
|
},
|
|
},
|
|
},
|
|
},
|
|
tuanliu_shuying: {
|
|
mode: ["boss"],
|
|
trigger: { player: "phaseJieshuBegin" },
|
|
audio: false,
|
|
forced: true,
|
|
filter(event, player) {
|
|
return game.shuying_getDiscardNum() > 4;
|
|
},
|
|
async content(event, trigger, player) {
|
|
let hp = 2;
|
|
let card = 4;
|
|
let damage = 1;
|
|
|
|
if (getTianshuDifficulty() == "nightmare") {
|
|
hp = 3;
|
|
card = 6;
|
|
}
|
|
|
|
|
|
const num = game.shuying_getDiscardNum();
|
|
if (num > 4) await player.recover(hp);
|
|
if (num > 5) await player.draw(card);
|
|
if (num > 9) {
|
|
for (const target of player.getEnemies(null, false).filter(target => target.isIn())) {
|
|
player.line(target);
|
|
await target.damage(player, damage);
|
|
}
|
|
}
|
|
},
|
|
},
|
|
juehong_shuying: {
|
|
mode: ["boss"],
|
|
trigger: { player: "phaseZhunbeiBegin" },
|
|
audio: false,
|
|
forced: true,
|
|
filter(event, player) {
|
|
return player.getEnemies(null, false).some(target => target.isIn());
|
|
},
|
|
async content(event, trigger, player) {
|
|
for (const target of player.getEnemies(null, false).filter(target => target.isIn())) {
|
|
player.line(target);
|
|
if (target.countCards("e")) await target.chooseToDiscard("e", true, target.countCards("e"));
|
|
else if (target.countCards("h")) await target.discard(target.getCards("h").randomGets(Math.min(2, target.countCards("h"))));
|
|
}
|
|
},
|
|
},
|
|
|
|
//火神祝融 over
|
|
xingxia_shuying: {
|
|
mode: ["boss"],
|
|
audio: false,
|
|
trigger: {
|
|
player: "phaseUseBegin",
|
|
},
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
const enemies = player.getEnemies(null, false);
|
|
return (
|
|
game.hasPlayer(target => {
|
|
return target.isIn() && !enemies.includes(target);
|
|
}) &&
|
|
enemies.some(target => target.isIn())
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const difficulty = getTianshuDifficulty();
|
|
const enemies = player
|
|
.getEnemies(null, false)
|
|
.filter(target => target.isIn());
|
|
const friends = game.filterPlayer(target => {
|
|
return target.isIn() && !enemies.includes(target);
|
|
});
|
|
if (!friends.length || !enemies.length) return;
|
|
|
|
const friend = friends.randomGet();
|
|
player.line(friend, "fire");
|
|
await friend.damage(1, player, "fire");
|
|
|
|
let discardNum = 1;
|
|
let damageNum = 1;
|
|
|
|
if (difficulty == "hard") {
|
|
discardNum = 2;
|
|
} else if (difficulty == "nightmare") {
|
|
discardNum = 3;
|
|
damageNum = 2;
|
|
}
|
|
|
|
for (const target of enemies) {
|
|
if (!target.isIn()) continue;
|
|
|
|
const canDiscard =
|
|
target.countCards("he", card => {
|
|
return (
|
|
get.color(card, target) == "red" &&
|
|
lib.filter.cardDiscardable(card, target)
|
|
);
|
|
}) >= discardNum;
|
|
|
|
let discarded = false;
|
|
if (canDiscard) {
|
|
const result = await target
|
|
.chooseToDiscard(
|
|
"he",
|
|
discardNum,
|
|
`行夏：弃置${get.cnNumber(discardNum)}张红色牌，或受到${get.cnNumber(damageNum)}点火焰伤害`
|
|
)
|
|
.set("filterCard", (card, target) => {
|
|
return (
|
|
get.color(card, target) == "red" &&
|
|
lib.filter.cardDiscardable(card, target)
|
|
);
|
|
})
|
|
.set("source", player)
|
|
.set("damageNum", damageNum)
|
|
.set("ai", card => {
|
|
const target = get.player();
|
|
const damageNum = get.event().damageNum;
|
|
|
|
if (target.hp <= damageNum) {
|
|
return 12 - get.value(card);
|
|
}
|
|
return 7 - get.value(card);
|
|
})
|
|
.forResult();
|
|
|
|
discarded = result.bool;
|
|
}
|
|
|
|
if (!discarded && target.isIn()) {
|
|
player.line(target, "fire");
|
|
await target.damage(damageNum, player, "fire");
|
|
}
|
|
}
|
|
},
|
|
ai: {
|
|
threaten: 1.8,
|
|
},
|
|
},
|
|
baoyan_shuying: {
|
|
mode: ["boss"],
|
|
audio: false,
|
|
trigger: {
|
|
global: "damageSource",
|
|
},
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return event.num > 0 && event.hasNature("fire");
|
|
},
|
|
async content(event, trigger, player) {
|
|
player.addMark("baoyan_shuying", 1, false);
|
|
},
|
|
marktext: "炎",
|
|
intro: {
|
|
name: "炎",
|
|
content: "mark",
|
|
},
|
|
group: "baoyan_shuying_burst",
|
|
subSkill: {
|
|
burst: {
|
|
audio: false,
|
|
trigger: {
|
|
player: "phaseEnd",
|
|
},
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return (
|
|
player.countMark("baoyan_shuying") > 0 &&
|
|
player
|
|
.getEnemies(null, false)
|
|
.some(target => target.isIn())
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const num = player.countMark("baoyan_shuying");
|
|
player.removeMark("baoyan_shuying", num, false);
|
|
|
|
const enemies = player
|
|
.getEnemies(null, false)
|
|
.filter(target => target.isIn());
|
|
if (!enemies.length) return;
|
|
|
|
if (getTianshuDifficulty() == "nightmare") {
|
|
const target = enemies.randomGet();
|
|
player.line(target, "fire");
|
|
await target.damage(num, player, "fire");
|
|
return;
|
|
}
|
|
|
|
const targets = enemies.randomGets(
|
|
Math.min(num, enemies.length)
|
|
);
|
|
for (const target of targets) {
|
|
if (!target.isIn()) continue;
|
|
|
|
player.line(target, "fire");
|
|
await target.damage(1, player, "fire");
|
|
}
|
|
},
|
|
},
|
|
},
|
|
ai: {
|
|
threaten: 1.7,
|
|
},
|
|
},
|
|
huoshen_shuying: {
|
|
mode: ["boss"],
|
|
audio: false,
|
|
trigger: {
|
|
global: "damageSource",
|
|
},
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return (
|
|
getTianshuDifficulty() == "nightmare" &&
|
|
event.num > 0 &&
|
|
event.hasNature("fire")
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
if (player.isDamaged()) {
|
|
await player.recover();
|
|
await player.draw();
|
|
} else {
|
|
await player.draw(3);
|
|
}
|
|
},
|
|
ai: {
|
|
threaten: 2,
|
|
},
|
|
},
|
|
|
|
//白起 over
|
|
changsheng_shuying: {
|
|
mode: ["boss"],
|
|
audio: false,
|
|
forced: true,
|
|
locked: true,
|
|
mod: {
|
|
targetInRange(card, player, target) {
|
|
const difficulty = getTianshuDifficulty();
|
|
if (
|
|
difficulty != "hard" &&
|
|
card.name == "sha"
|
|
) {
|
|
return true;
|
|
}
|
|
},
|
|
},
|
|
ai: {
|
|
unequip: true,
|
|
threaten: 1.2,
|
|
},
|
|
},
|
|
shashen_shuying: {
|
|
mode: ["boss"],
|
|
audio: false,
|
|
enable: ["chooseToUse", "chooseToRespond"],
|
|
filterCard: true,
|
|
position: "h",
|
|
viewAs: { name: "sha" },
|
|
viewAsFilter(player) {
|
|
return (
|
|
getTianshuDifficulty() != "normal" &&
|
|
player.countCards("h") > 0
|
|
);
|
|
},
|
|
prompt: "将一张手牌当【杀】使用或打出",
|
|
check(card) {
|
|
return 6 - get.value(card);
|
|
},
|
|
group: "shashen_shuying_draw",
|
|
subSkill: {
|
|
draw: {
|
|
trigger: { source: "damageEnd" },
|
|
forced: true,
|
|
locked: true,
|
|
usable(skill, player) {
|
|
return getTianshuDifficulty() == "hard"
|
|
? 1
|
|
: Infinity;
|
|
},
|
|
filter(event, player) {
|
|
const difficulty = getTianshuDifficulty();
|
|
if (
|
|
difficulty == "normal" ||
|
|
event.card?.name != "sha"
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
if (difficulty == "nightmare") {
|
|
return true;
|
|
}
|
|
|
|
// 困难难度只检查本回合使用的第一张【杀】
|
|
const useEvent = event.getParent("useCard");
|
|
if (!useEvent) return false;
|
|
|
|
const firstSha = player.getHistory(
|
|
"useCard",
|
|
evt => evt.card.name == "sha"
|
|
)[0];
|
|
|
|
return useEvent == firstSha;
|
|
},
|
|
async content(event, trigger, player) {
|
|
const num =
|
|
getTianshuDifficulty() == "nightmare"
|
|
? 3
|
|
: 2;
|
|
|
|
await player.draw(num);
|
|
},
|
|
},
|
|
},
|
|
ai: {
|
|
respondSha: true,
|
|
skillTagFilter(player) {
|
|
return (
|
|
getTianshuDifficulty() != "normal" &&
|
|
player.countCards("h") > 0
|
|
);
|
|
},
|
|
order(item, player) {
|
|
return get.order({ name: "sha" }, player) - 0.1;
|
|
},
|
|
},
|
|
},
|
|
wuan_shuying: {
|
|
mode: ["boss"],
|
|
audio: false,
|
|
forced: true,
|
|
locked: true,
|
|
mod: {
|
|
cardUsable(card, player, num) {
|
|
if (card.name != "sha") return;
|
|
|
|
const difficulty = getTianshuDifficulty();
|
|
if (difficulty == "nightmare") {
|
|
return num + 3;
|
|
}
|
|
if (difficulty == "hard") {
|
|
return num + 2;
|
|
}
|
|
return num + 1;
|
|
},
|
|
},
|
|
trigger: { source: "damageBegin1" },
|
|
filter(event, player) {
|
|
return event.card?.name == "sha";
|
|
},
|
|
async content(event, trigger, player) {
|
|
trigger.num++;
|
|
},
|
|
ai: {
|
|
damageBonus: true,
|
|
threaten: 2,
|
|
},
|
|
},
|
|
|
|
//夸父 over
|
|
shenqu_shuying: {
|
|
mode: ["boss"],
|
|
audio: false,
|
|
trigger: { player: "damageEnd" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return (
|
|
getTianshuDifficulty() == "nightmare" &&
|
|
player.countCards("h", card => get.color(card) == "red") > 0
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const cards = player.getCards("h", card => get.color(card) == "red");
|
|
await player.lose(cards, ui.cardPile);
|
|
await player.draw(cards.length);
|
|
},
|
|
ai: {
|
|
threaten: 1.5,
|
|
},
|
|
},
|
|
lieben_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:1",
|
|
trigger: { player: "useCardToPlayered" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return (
|
|
event.card.name == "sha" &&
|
|
event.isFirstTarget &&
|
|
ui.cardPile.lastChild
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const judge = player.judge(card => {
|
|
return get.color(card) == "red" ? 2 : -1;
|
|
});
|
|
judge.directresult = ui.cardPile.lastChild;
|
|
judge.judge2 = result => result.bool;
|
|
|
|
const result = await judge.forResult();
|
|
if (!result.bool) return;
|
|
|
|
const useEvent = trigger.getParent();
|
|
if (useEvent.addCount !== false) {
|
|
useEvent.addCount = false;
|
|
|
|
const stat = player.getStat().card;
|
|
if (typeof stat.sha == "number") {
|
|
stat.sha--;
|
|
}
|
|
}
|
|
|
|
if (getTianshuDifficulty() == "nightmare") {
|
|
useEvent.baseDamage = (useEvent.baseDamage || 1) + 1;
|
|
}
|
|
},
|
|
ai: {
|
|
threaten: 1.4,
|
|
},
|
|
},
|
|
yinjiang_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:1",
|
|
trigger: { player: "drawEnd" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return (
|
|
player.isPhaseUsing() &&
|
|
!player.hasSkill("yinjiang_shuying_disabled") &&
|
|
ui.cardPile.lastChild
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const card = ui.cardPile.lastChild;
|
|
await player.gain(card, "gain2");
|
|
|
|
if (get.color(card) != "red") return;
|
|
|
|
const enemies = player
|
|
.getEnemies(null, false)
|
|
.filter(target => target.isIn());
|
|
|
|
if (!enemies.length) return;
|
|
|
|
const targets =
|
|
getTianshuDifficulty() == "nightmare"
|
|
? enemies
|
|
: [enemies.randomGet()];
|
|
|
|
let count = 0;
|
|
|
|
for (const target of targets) {
|
|
if (!target?.isIn()) continue;
|
|
|
|
player.line(target);
|
|
const damageEvent = target.damage(1, player);
|
|
await damageEvent;
|
|
|
|
// 只统计实际成立的伤害事件
|
|
if (player.getHistory("sourceDamage").includes(damageEvent)) {
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if (!count) return;
|
|
|
|
player.storage.yinjiang_shuying_count =
|
|
(player.storage.yinjiang_shuying_count || 0) + count;
|
|
|
|
if (player.storage.yinjiang_shuying_count >= 2) {
|
|
player.addTempSkill("yinjiang_shuying_disabled", {
|
|
player: "phaseAfter",
|
|
});
|
|
}
|
|
},
|
|
group: "yinjiang_shuying_clear",
|
|
subSkill: {
|
|
clear: {
|
|
trigger: { player: "phaseUseEnd" },
|
|
silent: true,
|
|
charlotte: true,
|
|
async content(event, trigger, player) {
|
|
delete player.storage.yinjiang_shuying_count;
|
|
},
|
|
},
|
|
disabled: {
|
|
charlotte: true,
|
|
},
|
|
},
|
|
ai: {
|
|
threaten: 2,
|
|
},
|
|
},
|
|
zhuri_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:1",
|
|
forced: true,
|
|
locked: true,
|
|
group: ["zhuri_shuying_draw", "zhuri_shuying_bottom"],
|
|
subSkill: {
|
|
draw: {
|
|
trigger: { player: "useCard" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return get.color(event.card) == "red";
|
|
},
|
|
async content(event, trigger, player) {
|
|
await player.draw();
|
|
},
|
|
},
|
|
bottom: {
|
|
trigger: { global: "useCardAfter" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return (
|
|
event.targets?.includes(player) &&
|
|
(event.card.name == "sha" ||
|
|
get.type(event.card) == "trick") &&
|
|
event.cards?.someInD("d")
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const cards = trigger.cards.filterInD("d");
|
|
if (!cards.length) return;
|
|
|
|
game.log(cards, "被置于牌堆底");
|
|
await game.cardsGotoPile(cards);
|
|
},
|
|
},
|
|
},
|
|
ai: {
|
|
threaten: 1.8,
|
|
},
|
|
},
|
|
|
|
//少昊 over
|
|
baiyi_shuying: {
|
|
mode: ["boss"],
|
|
trigger: { global: "phaseBegin" },
|
|
forced: true,
|
|
logTarget: "player",
|
|
filter(event, player) {
|
|
return (
|
|
game.roundNumber < 7 &&
|
|
event.player?.isIn() &&
|
|
player.getEnemies(null, false).includes(event.player)
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
let num = 1;
|
|
const target = trigger.player;
|
|
player.line(target);
|
|
|
|
const difficulty = getTianshuDifficulty();
|
|
|
|
if (difficulty == "hard") {
|
|
num = 2;
|
|
} else if (difficulty == "nightmare") {
|
|
num = 3;
|
|
}
|
|
|
|
if (game.roundNumber < 3 && target.countGainableCards(player, "he") > 0) {
|
|
const cards = target.getCards("he").randomGets(Math.min(num, target.countCards("he")));
|
|
await player.gain(cards, target, "giveAuto");
|
|
}
|
|
|
|
if (game.roundNumber < 5 && target.isIn()) {
|
|
await target.damage(num, "thunder", player);
|
|
}
|
|
|
|
if (game.roundNumber < 7 && target.isIn()) {
|
|
const cards = target
|
|
.getCards("he")
|
|
.filter(card => lib.filter.cardDiscardable(card, target, "baiyi_shuying"))
|
|
.randomGets(num);
|
|
|
|
if (cards.length) {
|
|
await target.discard(cards);
|
|
}
|
|
}
|
|
},
|
|
ai: {
|
|
threaten: 3,
|
|
},
|
|
},
|
|
shenen_shuying: {
|
|
mode: ["boss"],
|
|
forced: true,
|
|
global: "shenen_shuying_global",
|
|
subSkill: {
|
|
global: {
|
|
mod: {
|
|
targetInRange(card, player, target) {
|
|
const owner = game.findPlayer(current => current.hasSkill("shenen_shuying"));
|
|
if (owner && !owner.getEnemies(null, false).includes(player)) return true;
|
|
},
|
|
},
|
|
},
|
|
},
|
|
ai: {
|
|
threaten: 1.5,
|
|
},
|
|
},
|
|
|
|
//玄女 over
|
|
xuanlie_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:1",
|
|
trigger: { player: "phaseJieshuBegin" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return game.hasPlayer(current => {
|
|
return (
|
|
current.isIn() &&
|
|
player.getEnemies(null, false).includes(current) &&
|
|
player.getHistory("gain", evt => evt.getl?.(current)?.cards2?.length).length
|
|
);
|
|
});
|
|
},
|
|
async content(event, trigger, player) {
|
|
const targets = game.filterPlayer(current => {
|
|
return (
|
|
current.isIn() &&
|
|
player.getEnemies(null, false).includes(current) &&
|
|
player.getHistory("gain", evt => evt.getl?.(current)?.cards2?.length).length
|
|
);
|
|
});
|
|
|
|
let num = 2;
|
|
if (getTianshuDifficulty() == "normal") num = 1;
|
|
|
|
for (const target of targets) {
|
|
player.line(target);
|
|
await target.damage(num, player);
|
|
}
|
|
},
|
|
ai: {
|
|
threaten: 2,
|
|
},
|
|
},
|
|
jiutian_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:1",
|
|
trigger: { player: "phaseZhunbeiBegin" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return player.getEnemies(null, false).some(target => target.isIn() && target.countGainableCards(player, "h") > 0);
|
|
},
|
|
async content(event, trigger, player) {
|
|
let num = 2;
|
|
const difficulty = getTianshuDifficulty();
|
|
if (difficulty == "normal") num = 1;
|
|
|
|
const targets = player.getEnemies(null, false).filter(target => target.isIn() && target.countGainableCards(player, "h") > 0);
|
|
const gained = [];
|
|
|
|
for (const target of targets) {
|
|
const cards = target.getCards("h").randomGets(Math.min(num, target.countCards("h")));
|
|
if (cards.length) {
|
|
player.line(target);
|
|
await player.gain(cards, target, "giveAuto");
|
|
gained.addArray(cards);
|
|
}
|
|
}
|
|
|
|
if (!gained.length) return;
|
|
|
|
const colors = gained.map(card => get.color(card, player)).unique();
|
|
const suits = gained.map(card => get.suit(card, player)).unique();
|
|
|
|
if (colors.length >= 2) {
|
|
for (const target of targets) {
|
|
if (!target.isIn()) continue;
|
|
player.line(target);
|
|
|
|
target.damage(1, player);
|
|
}
|
|
}
|
|
|
|
if (difficulty == "nightmare" && suits.length >= 4) {
|
|
for (const target of targets) {
|
|
if (!target.isIn()) continue;
|
|
player.line(target);
|
|
await target.loseHp();
|
|
}
|
|
}
|
|
},
|
|
ai: {
|
|
threaten: 3,
|
|
},
|
|
},
|
|
dishi_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:1",
|
|
trigger: { player: "useCard2" },
|
|
filter(event, player) {
|
|
if (!event.targets?.length) return false;
|
|
if (event.card.name != "sha" && get.type(event.card) != "trick") return false;
|
|
|
|
const info = get.info(event.card);
|
|
if (event.targets.length == 1) {
|
|
if (info.allowMultiple == false || info.multitarget) return false;
|
|
return game.hasPlayer(current => {
|
|
return (
|
|
!event.targets.includes(current) &&
|
|
lib.filter.targetEnabled2(event.card, player, current) &&
|
|
lib.filter.targetInRange(event.card, player, current)
|
|
);
|
|
});
|
|
}
|
|
|
|
return event.targets.length > 1;
|
|
},
|
|
async cost(event, trigger, player) {
|
|
if (trigger.targets.length == 1) {
|
|
event.result = await player
|
|
.chooseTarget(get.prompt(event.skill), `为${get.translation(trigger.card)}增加一个目标`, (card, player, target) => {
|
|
const trigger = get.event().getTrigger();
|
|
return (
|
|
!trigger.targets.includes(target) &&
|
|
lib.filter.targetEnabled2(trigger.card, player, target) &&
|
|
lib.filter.targetInRange(trigger.card, player, target)
|
|
);
|
|
})
|
|
.set("ai", target => {
|
|
const player = get.player();
|
|
const trigger = get.event().getTrigger();
|
|
const effect = get.effect(target, trigger.card, player, player);
|
|
if (player.getEnemies(null, false).includes(target)) return effect;
|
|
return Math.min(0, effect);
|
|
})
|
|
.forResult();
|
|
}
|
|
else {
|
|
event.result = await player
|
|
.chooseTarget(get.prompt(event.skill), `令${get.translation(trigger.card)}减少一个目标`, (card, player, target) => {
|
|
return get.event().getTrigger().targets.includes(target);
|
|
})
|
|
.set("ai", target => {
|
|
const player = get.player();
|
|
const trigger = get.event().getTrigger();
|
|
return -get.effect(target, trigger.card, player, player);
|
|
})
|
|
.forResult();
|
|
}
|
|
},
|
|
async content(event, trigger, player) {
|
|
const target = event.targets[0];
|
|
player.line(target);
|
|
|
|
if (trigger.targets.includes(target)) {
|
|
trigger.targets.remove(target);
|
|
game.log(target, "不再是", trigger.card, "的目标");
|
|
}
|
|
else {
|
|
trigger.targets.add(target);
|
|
game.log(target, "成为了", trigger.card, "的额外目标");
|
|
}
|
|
},
|
|
ai: {
|
|
threaten: 1.6,
|
|
},
|
|
},
|
|
|
|
//旱魃 over
|
|
xinji_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:2",
|
|
trigger: { global: "loseAfter" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return (
|
|
_status.currentPhase &&
|
|
_status.currentPhase.isIn() &&
|
|
event.player?.isIn() &&
|
|
event.player != _status.currentPhase &&
|
|
!player.getEnemies(null, false).includes(event.player) &&
|
|
event.type == "discard" &&
|
|
event.cards2?.some(card => get.position(card, true) == "d" && event.hs?.includes(card))
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
const difficulty = getTianshuDifficulty();
|
|
const num = difficulty == "nightmare" ? 2 : 1;
|
|
const target = _status.currentPhase;
|
|
player.line(target);
|
|
await target.damage(num, player);
|
|
},
|
|
ai: {
|
|
threaten: 1.6,
|
|
},
|
|
},
|
|
zhiri_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:2",
|
|
trigger: { global: "useCardToPlayered" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
return (
|
|
event.isFirstTarget &&
|
|
event.player?.isIn() &&
|
|
player.getEnemies(null, false).includes(event.player) &&
|
|
get.type2(event.card) == "trick" &&
|
|
get.color(event.card) == "red"
|
|
);
|
|
},
|
|
async content(event, trigger, player) {
|
|
let num = 1;
|
|
const difficulty = getTianshuDifficulty();
|
|
if (difficulty == "hard") {
|
|
num = 2;
|
|
} else if (difficulty == "nightmare") {
|
|
num = 3;
|
|
}
|
|
|
|
await player.draw(num);
|
|
},
|
|
ai: {
|
|
threaten: 1.4,
|
|
},
|
|
},
|
|
fenshi_shuying: {
|
|
mode: ["boss"],
|
|
audio: "ext:术樱包/pve/audio/skill/天书乱斗:2",
|
|
trigger: { player: "phaseZhunbeiBegin" },
|
|
forced: true,
|
|
locked: true,
|
|
filter(event, player) {
|
|
const num = player.countCards("h") - player.hp;
|
|
if (num < 0) return true;
|
|
if (num > 0) return player.getEnemies(null, false).some(target => target.isIn());
|
|
return false;
|
|
},
|
|
async content(event, trigger, player) {
|
|
const num = player.countCards("h") - player.hp;
|
|
|
|
if (num < 0) {
|
|
await player.draw(-num);
|
|
return;
|
|
}
|
|
|
|
const enemies = player.getEnemies(null, false).filter(target => target.isIn());
|
|
const map = new Map();
|
|
|
|
for (let i = 0; i < num && enemies.length; i++) {
|
|
const target = enemies.randomGet();
|
|
map.set(target, (map.get(target) || 0) + 1);
|
|
}
|
|
|
|
for (const [target, damage] of map) {
|
|
if (!target.isIn()) continue;
|
|
player.line(target);
|
|
await target.damage(damage, player);
|
|
}
|
|
},
|
|
ai: {
|
|
threaten: 2,
|
|
},
|
|
},
|
|
};
|
|
|
|
export default skills;
|