当前花色：";
str += get.translation(player.storage.nzry_chenglve1);
}
return str;
},
},
enable: "phaseUse",
usable: 1,
audio: 2,
filter(event, player) {
// 加个检查喵
if (player.storage.nzry_chenglve != true) {
return player.countDiscardableCards(player, "h");
}
return true;
},
async content(event, trigger, player) {
let result;
if (player.storage.nzry_chenglve == true) {
await player.draw(2);
result = await player.chooseToDiscard("h", true).forResult();
} else {
await player.draw();
result = await player.chooseToDiscard("h", 2, true).forResult();
}
player.changeZhuanhuanji("nzry_chenglve");
if (result.bool) {
player.storage.nzry_chenglve1 = result.cards.map(card => get.suit(card, player)).unique();
player.markSkill("nzry_chenglve");
player.addTempSkill("nzry_chenglve1");
}
},
ai: {
order: 2.7,
result: {
player(player) {
if (!player.storage.nzry_chenglve && player.countCards("h") < 3) return 0;
return 1;
},
},
},
},
nzry_chenglve1: {
mod: {
cardUsable(card, player) {
const suit = get.suit(card);
if (suit == "unsure" || player.getStorage("nzry_chenglve1").includes(suit)) return Infinity;
},
targetInRange(card, player) {
const suit = get.suit(card);
if (suit == "unsure" || player.getStorage("nzry_chenglve1").includes(suit)) return true;
},
},
onremove: true,
},
nzry_shicai: {
audio: "nzry_shicai_2",
trigger: { player: ["useCardAfter", "useCardToTargeted"] },
prompt2(event, player) {
const cards = event.cards.filterInD("oe");
return "你可以将" + get.translation(cards) + (cards.length > 1 ? "以任意顺序" : "") + "置于牌堆顶，然后摸一张牌";
},
filter(event, player) {
if (!event.cards.someInD()) return false;
let evt = event,
type = get.type2(evt.card, false);
if (event.name == "useCardToTargeted") {
if (type != "equip" || player != event.target) return false;
evt = evt.getParent();
} else {
if (type == "equip") return false;
}
return !player.hasHistory(
"useCard",
evtx => {
return evtx != evt && get.type2(evtx.card, false) == type;
},
evt
);
},
check(event, player) {
if (get.type(event.card) == "equip") {
if (get.subtype(event.card) == "equip6") return true;
if (get.equipResult(player, player, event.card.name) <= 0) return true;
const eff1 = player.getUseValue(event.card);
const subtype = get.subtype(event.card);
return (
player.countCards("h", function (card) {
return get.subtype(card) == subtype && player.getUseValue(card) >= eff1;
}) > 0
);
}
return true;
},
async content(event, trigger, player) {
let cards = trigger.cards.filterInD();
if (cards.length > 1) {
const { result } = await player
.chooseToMove("恃才：将牌按顺序置于牌堆顶", true)
.set("list", [["牌堆顶", cards]])
.set("reverse", _status.currentPhase && _status.currentPhase.next && get.attitude(player, _status.currentPhase.next) > 0)
.set("processAI", function (list) {
const cards = list[0][1].slice(0);
cards.sort(function (a, b) {
return (_status.event.reverse ? 1 : -1) * (get.value(b) - get.value(a));
});
return [cards];
});
if (!result.bool) return;
cards = result.moved[0];
}
cards.reverse();
await game.cardsGotoPile(cards, "insert");
game.log(player, "将", cards, "置于了牌堆顶");
await player.draw();
},
subSkill: { 2: { audio: 2 } },
ai: {
reverseOrder: true,
skillTagFilter(player) {
if (
player.getHistory("useCard", function (evt) {
return get.type(evt.card) == "equip";
}).length > 0
)
return false;
},
effect: {
target_use(card, player, target) {
if (
player == target &&
get.type(card) == "equip" &&
!player.getHistory("useCard", function (evt) {
return get.type(evt.card) == "equip";
}).length
)
return [1, 3];
},
},
},
},
nzry_cunmu: {
audio: 2,
audioname: ["ol_pengyang"],
trigger: {
player: "drawBegin",
},
forced: true,
async content(event, trigger, player) {
trigger.bottom = true;
},
},
nzry_mingren: {
audio: "nzry_mingren_1",
audioname: ["sb_yl_luzhi"],
marktext: "任",
intro: {
content: "expansion",
markcount: "expansion",
},
onremove(player, skill) {
const cards = player.getExpansions(skill);
if (cards.length) player.loseToDiscardpile(cards);
},
group: ["nzry_mingren_1", "nzry_mingren_2"],
ai: {
combo: "nzry_zhenliang",
},
subSkill: {
1: {
audio: 2,
audioname: ["sb_yl_luzhi"],
trigger: {
global: "phaseBefore",
player: "enterGame",
},
forced: true,
locked: false,
filter(event, player) {
return (event.name != "phase" || game.phaseNumber == 0) && !player.getExpansions("nzry_mingren").length;
},
async content(event, trigger, player) {
await player.draw(2);
if (!player.countCards("h")) return;
const { result } = await player.chooseCard("h", "将一张手牌置于武将牌上，称为“任”", true).set("ai", function (card) {
return 6 - get.value(card);
});
if (result.bool) {
const next = player.addToExpansion(result.cards[0], player, "give", "log");
next.gaintag.add("nzry_mingren");
await next;
}
},
},
2: {
trigger: {
player: "phaseJieshuBegin",
},
filter(event, player) {
return player.countCards("h") > 0 && player.getExpansions("nzry_mingren").length > 0;
},
async cost(event, trigger, player) {
event.result = await player
.chooseCard("h", get.prompt("nzry_mingren"), "选择一张手牌替换“任”（" + get.translation(player.getExpansions("nzry_mingren")[0]) + "）")
.set("ai", function (card) {
const player = _status.event.player;
const color = get.color(card);
if (color == get.color(player.getExpansions("nzry_mingren")[0])) return false;
let num = 0;
const list = [];
player.countCards("h", function (cardx) {
if (cardx != card || get.color(cardx) != color) return false;
if (list.includes(cardx.name)) return false;
list.push(cardx.name);
switch (cardx.name) {
case "wuxie":
num += game.countPlayer() / 2.2;
break;
case "caochuan":
num += 1.1;
break;
case "shan":
num += 1;
break;
}
});
return num * (30 - get.value(card));
})
.forResult();
},
async content(event, trigger, player) {
// 考虑到getExpansions的实际执行在addToExpansion之前喵，此处调换顺序
const card = player.getExpansions("nzry_mingren")[0];
const next = player.addToExpansion(event.cards[0], "log", "give", player);
next.gaintag.add("nzry_mingren");
await next;
if (card) await player.gain(card, "gain2");
},
},
},
},
nzry_zhenliang: {
audio: "nzry_zhenliang_1",
mark: true,
locked: false,
zhuanhuanji: true,
marktext: "☯",
intro: {
content(storage, player, skill) {
if (player.storage.nzry_zhenliang == true) return "当你于回合外使用或打出的牌结算完成后，若此牌与“任”颜色相同，则你可以令一名角色摸一张牌。";
return "出牌阶段限一次，你可以弃置一张与“任”颜色相同的牌并对攻击范围内的一名角色造成1点伤害。";
},
},
group: ["nzry_zhenliang_1", "nzry_zhenliang_2"],
subSkill: {
1: {
prompt: "弃置一张与“任”颜色相同的牌，并对攻击范围内的一名角色造成1点伤害。",
audio: 2,
enable: "phaseUse",
filter(event, player) {
if (player.storage.nzry_zhenliang) return false;
const storage = player.getExpansions("nzry_mingren");
if (!storage.length) return false;
const color = get.color(storage[0]);
if (
player.countCards("he", function (card) {
return get.color(card) == color;
}) == 0
)
return false;
return game.hasPlayer(function (current) {
return player.inRange(current);
});
},
position: "he",
filterCard(card, player) {
return get.color(card) == get.color(player.getExpansions("nzry_mingren")[0]);
},
filterTarget(card, player, target) {
return player.inRange(target);
},
check(card) {
return 6.5 - get.value(card);
},
async content(event, trigger, player) {
player.changeZhuanhuanji("nzry_zhenliang");
await event.target.damage("nocard");
},
ai: {
order: 5,
result: {
player(player, target) {
return get.damageEffect(target, player, player);
},
},
},
},
2: {
trigger: {
player: ["useCardAfter", "respondAfter"],
},
filter(event, player) {
if (_status.currentPhase == player || !player.storage.nzry_zhenliang) return false;
const card = player.getExpansions("nzry_mingren")[0];
return card && get.color(event.card) == get.color(card);
},
async cost(event, trigger, player) {
const next = player.chooseTarget(get.prompt("nzry_zhenliang"), "令一名角色摸一张牌");
next.ai = function (target) {
if (target.hasSkillTag("nogain")) return 0.1;
const att = get.attitude(player, target);
return att * (Math.max(5 - target.countCards("h"), 2) + 3);
};
event.result = await next.forResult();
},
async content(event, trigger, player) {
player.changeZhuanhuanji("nzry_zhenliang");
event.targets[0].draw();
},
},
},
ai: {
combo: "nzry_mingren",
},
},
nzry_jianxiang: {
audio: 2,
trigger: {
target: "useCardToTargeted",
},
filter(event, player) {
return event.player != player;
},
async cost(event, trigger, player) {
const next = player.chooseTarget(get.prompt("nzry_jianxiang"), "令场上手牌数最少的一名角色摸一张牌", function (card, player, target) {
return target.isMinHandcard();
});
next.ai = function (target) {
return get.attitude(player, target);
};
event.result = await next.forResult();
},
async content(event, trigger, player) {
await event.targets[0].draw();
},
},
nzry_shenshi: {
mark: true,
audio: "nzry_shenshi_1",
locked: false,
zhuanhuanji: true,
marktext: "☯",
intro: {
content(storage, player, skill) {
if (player.storage.nzry_shenshi == true) return "其他角色对你造成伤害后，你可以观看该角色的手牌，然后交给其一张牌，当前角色回合结束时，若此牌仍在该角色的区域内，你将手牌摸至四张";
return "出牌阶段限一次，你可以将一张牌交给一名手牌数最多的角色，然后对其造成1点伤害，若该角色因此死亡，则你可以令一名角色将手牌摸至四张";
},
},
group: ["nzry_shenshi_1", "nzry_shenshi_2"],
subSkill: {
1: {
audio: 2,
prompt: "出牌阶段限一次，你可以将一张牌交给一名手牌数最多的角色，然后对其造成1点伤害，若该角色因此死亡，则你可以令一名角色将手牌摸至四张",
enable: "phaseUse",
usable: 1,
filter(event, player) {
return player.countCards("he") > 0 && player.storage.nzry_shenshi != true;
},
discard: false,
line: true,
lose: false,
delay: false,
position: "he",
filterCard: true,
filterTarget(card, player, target) {
return (
target != player &&
!game.hasPlayer(function (current) {
return current != player && current.countCards("h") > target.countCards("h");
})
);
},
check(card) {
return 5 - get.value(card);
},
async content(event, trigger, player) {
const target = event.target;
player.changeZhuanhuanji("nzry_shenshi");
await player.give(event.cards, target);
await target.damage("nocard");
if (target.isIn()) return;
const { result } = await player
.chooseTarget("令一名角色将手牌摸至四张", function (card, player, target) {
return target.countCards("h") < 4;
})
.set("ai", function (target) {
return get.attitude(player, target);
});
if (result.bool) {
player.line(result.targets);
await result.targets[0].draw(4 - result.targets[0].countCards("h"));
}
},
ai: {
order: 1,
result: {
target(player, target) {
return -1;
},
},
},
},
2: {
audio: "nzry_shenshi_1",
trigger: {
player: "damageEnd",
},
filter(event, player) {
return player.countCards("he") > 0 && event.source && event.source != player && player.storage.nzry_shenshi == true;
},
check(event, player) {
return event.source && event.source.countCards("h") <= 2 && player.countCards("h") < 4;
},
logTarget: "source",
prompt2: "其他角色对你造成伤害后，你可以观看该角色的手牌，然后交给其一张牌，当前角色回合结束时，若此牌仍在该角色的区域内，你将手牌摸至四张",
async content(event, trigger, player) {
player.changeZhuanhuanji("nzry_shenshi");
await player.viewHandcards(trigger.source);
const { result } = await player.chooseCard("he", true, "交给" + get.translation(trigger.source) + "一张牌").set("ai", function (card) {
return 5 - get.value(card);
});
if (result.bool) {
await player.give(result.cards, trigger.source);
trigger.source.storage.nzry_shenshi1 = result.cards[0];
trigger.source.storage.nzry_shenshi2 = player;
trigger.source.addSkill("nzry_shenshi1");
}
},
},
},
},
nzry_shenshi1: {
audio: 2,
trigger: {
global: "phaseJieshuBegin",
},
forced: true,
popup: false,
charlotte: true,
filter(event, player) {
return player.storage.nzry_shenshi1 != undefined && player.storage.nzry_shenshi2 != undefined;
},
async content(event, trigger, player) {
const pl = player.storage.nzry_shenshi2;
const card = player.storage.nzry_shenshi1;
if (player.getCards("he").includes(card) && 4 - pl.countCards("h") > 0) {
await pl.drawTo(4);
pl.logSkill("nzry_shenshi");
}
player.removeSkill("nzry_shenshi1");
delete player.storage.nzry_shenshi1;
delete player.storage.nzry_shenshi2;
},
},
xinjushou: {
audio: 2,
trigger: { player: "phaseJieshuBegin" },
async content(event, trigger, player) {
await player.draw(4);
await player.turnOver();
const { result } = await player
.chooseCard("h", true, "弃置一张手牌，若以此法弃置的是装备牌，则你改为使用之")
.set("ai", function (card) {
if (get.type(card) == "equip") {
return 5 - get.value(card);
}
return -get.value(card);
})
.set("filterCard", lib.filter.cardDiscardable);
if (result.bool && result.cards.length) {
const card = result.cards[0];
if (get.type(card) == "equip" && player.hasUseTarget(card)) {
player.chooseUseTarget(card, true, "nopopup");
} else {
player.discard(card);
}
}
},
ai: {
effect: {
target(card, player, target) {
if (card.name == "guiyoujie") return [0, 1];
},
},
},
},
xinjiewei: {
audio: 2,
enable: "chooseToUse",
filterCard: true,
position: "e",
viewAs: { name: "wuxie" },
filter(event, player) {
return player.countCards("e") > 0;
},
viewAsFilter(player) {
return player.countCards("e") > 0;
},
prompt: "将一张装备区内的牌当无懈可击使用",
check(card) {
return 8 - get.equipValue(card);
},
threaten: 1.2,
group: "xinjiewei_move",
subSkill: {
move: {
trigger: { player: "turnOverEnd" },
audio: "jiewei",
filter(event, player) {
return !player.isTurnedOver() && player.canMoveCard();
},
async cost(event, trigger, player) {
event.result = await player
.chooseToDiscard("he", get.prompt("xinjiewei"), "弃置一张牌并移动场上的一张牌", lib.filter.cardDiscardable)
.set("ai", function (card) {
if (!_status.event.check) return 0;
return 7 - get.value(card);
})
.set("check", player.canMoveCard(true))
.forResult();
},
async content(event, trigger, player) {
await player.moveCard(true);
},
},
},
},
jianchu: {
shaRelated: true,
audio: 2,
audioname: ["re_pangde"],
trigger: { player: "useCardToPlayered" },
filter(event, player) {
return event.card.name == "sha" && event.target.countDiscardableCards(player, "he") > 0;
},
preHidden: true,
check(event, player) {
return get.attitude(player, event.target) <= 0;
},
logTarget: "target",
async content(event, trigger, player) {
const { result } = await player
.discardPlayerCard(trigger.target, get.prompt("jianchu", trigger.target), true)
.set("ai", function (button) {
if (!_status.event.att) return 0;
if (get.position(button.link) == "e") {
if (get.subtype(button.link) == "equip2") return 2 * get.value(button.link);
return get.value(button.link);
}
return 1;
})
.set("att", get.attitude(player, trigger.target) <= 0);
if (result.bool && result.links && result.links.length) {
if (get.type(result.links[0], null, result.links[0].original == "h" ? player : false) == "equip") {
trigger.getParent().directHit.add(trigger.target);
} else if (trigger.cards) {
const list = [];
for (let i = 0; i < trigger.cards.length; i++) {
if (get.position(trigger.cards[i], true) == "o") list.push(trigger.cards[i]);
}
if (list.length) trigger.target.gain(list, "gain2", "log");
}
}
},
ai: {
unequip_ai: true,
directHit_ai: true,
skillTagFilter(player, tag, arg) {
if (tag == "directHit_ai")
return (
arg.card.name == "sha" &&
arg.target.countCards("e", function (card) {
return get.value(card) > 1;
}) > 0
);
if (arg && arg.name == "sha" && arg.target.getEquip(2)) return true;
return false;
},
},
},
redimeng: {
audio: "dimeng",
enable: "phaseUse",
usable: 1,
position: "he",
filterCard() {
if (ui.selected.targets.length == 2) return false;
return true;
},
selectCard: [0, Infinity],
selectTarget: 2,
complexCard: true,
complexSelect: true,
filterTarget(card, player, target) {
if (player == target) return false;
if (ui.selected.targets.length == 0) return true;
return Math.abs(ui.selected.targets[0].countCards("h") - target.countCards("h")) == ui.selected.cards.length;
},
multitarget: true,
multiline: true,
async content(event, trigger, player) {
// 改到一半发现又没人用这个技能
// 心态炸了喵_(:з」∠)_
const [target, target1] = event.targets;
const cards = target.getCards("h").concat(target1.getCards("h"));
event.dialogRef = true;
game.broadcastAll(
function (cards, id, player, targets) {
const dialog = ui.create.dialog("缔盟", true);
if (player.isUnderControl(true) || targets[0].isUnderControl(true) || targets[1].isUnderControl(true)) {
dialog.add(cards);
dialog.seeing = true;
} else {
dialog.add([cards, "blank"]);
}
_status.dieClose.push(dialog);
dialog.videoId = id;
if (_status.event.dialogRef) event.dialog = dialog;
},
cards,
dialog.videoId,
player,
event.targets
);
game.addVideo("cardDialog", null, ["缔盟", get.cardsInfo(cards), dialog.videoId]);
delete event.dialogRef;
const dialog = event.dialog;
let current = target;
let num1 = 0;
let num2 = 0;
await game.asyncDelay();
while (dialog.buttons.length) {
let card;
if (dialog.buttons.length > 1) {
const next = current.chooseButton(true, function (button) {
return get.value(button.link, _status.event.player);
});
next.set("dialog", dialog.videoId);
next.set("closeDialog", false);
next.set("dialogdisplay", true);
const { result } = await next;
if (!result.bool) return;
card = result.links[0];
} else {
card = dialog.buttons[0].link;
}
const button = dialog.buttons.find(button => button.link == card);
if (button) {
if (dialog.seeing) {
button.querySelector(".info").innerHTML = get.translation(current.name);
if (!_status.connectMode) {
game.log(current, "选择了", button.link);
}
}
dialog.buttons.remove(button);
}
if (card) {
await current.gain(card);
if (dialog.seeing) {
current.$draw(card, "nobroadcast");
} else {
current.$draw(1, "nobroadcast");
}
game.broadcast(
function (card, id, current) {
const dialog = get.idDialog(id);
if (dialog && dialog.seeing) {
const button = dialog.buttons.find(button => button.link == card);
if (button) {
button.querySelector(".info").innerHTML = get.translation(current.name);
dialog.buttons.remove(button);
}
current.$draw(card, "nobroadcast");
} else {
current.$draw(1, "nobroadcast");
}
},
card,
dialog.videoId,
current
);
}
if (current == target) {
num1++;
current = target1;
} else {
num2++;
current = target;
}
await game.asyncDelay(2);
}
if (!_status.connectMode) {
game.log(targets[0], "获得了" + get.cnNumber(num1) + "张牌");
game.log(targets[1], "获得了" + get.cnNumber(num2) + "张牌");
}
dialog.close();
_status.dieClose.remove(dialog);
game.broadcast(function (id) {
const dialog = get.idDialog(id);
if (dialog) {
dialog.close();
_status.dieClose.remove(dialog);
}
}, dialog.videoId);
game.addVideo("cardDialog", null, dialog.videoId);
},
targetprompt: ["先拿牌", "后拿牌"],
find(type) {
let list = game.filterPlayer(function (current) {
return current != player && get.attitude(player, current) > 3;
});
const player = _status.event.player;
const num = player.countCards("he", function (card) {
return get.value(card) < 7;
});
let count = null;
let from, nh;
if (list.length == 0) return null;
list.sort(function (a, b) {
return a.countCards("h") - b.countCards("h");
});
if (type == 1) return list[0];
from = list[0];
nh = from.countCards("h");
list = game.filterPlayer(function (current) {
return current != player && get.attitude(player, current) < 1;
});
if (list.length == 0) return null;
list.sort(function (a, b) {
return b.countCards("h") - a.countCards("h");
});
for (let i = 0; i < list.length; i++) {
const nh2 = list[i].countCards("h");
if (nh2 - nh <= num) {
count = nh2 - nh;
break;
}
}
if (count == null || count < 0) return null;
if (type == 3) return count;
return list[i];
},
check(card) {
const count = lib.skill.redimeng.find(3);
if (count == null) return -1;
if (ui.selected.cards.length < count) return 7 - get.value(card);
return -1;
},
ai: {
order: 8,
threaten: 1.6,
expose: 0.5,
result: {
player(player, target) {
if (ui.selected.targets.length == 0) {
if (target == lib.skill.redimeng.find(1)) return 1;
return 0;
} else {
if (target == lib.skill.redimeng.find(2)) return 1;
return 0;
}
},
},
},
},
reluanji: {
audio: 2,
enable: "phaseUse",
viewAs: { name: "wanjian" },
filterCard(card, player) {
if (!player.storage.reluanji) return true;
return !player.storage.reluanji.includes(get.suit(card));
},
position: "hs",
selectCard: 2,
check(card) {
const player = _status.event.player;
const targets = game.filterPlayer(function (current) {
return player.canUse("wanjian", current);
});
let num = 0;
for (let i = 0; i < targets.length; i++) {
let eff = get.sgn(get.effect(targets[i], { name: "wanjian" }, player, player));
if (targets[i].hp == 1) {
eff *= 1.5;
}
num += eff;
}
if (!player.needsToDiscard(-1)) {
if (targets.length >= 7) {
if (num < 2) return 0;
} else if (targets.length >= 5) {
if (num < 1.5) return 0;
}
}
return 6 - get.value(card);
},
ai: {
basic: {
order: 8.9,
},
},
group: ["reluanji_count", "reluanji_reset", "reluanji_respond", "reluanji_damage", "reluanji_draw"],
subSkill: {
reset: {
trigger: { player: "phaseAfter" },
silent: true,
async content(event, trigger, player) {
delete player.storage.reluanji;
delete player.storage.reluanji2;
},
},
count: {
trigger: { player: "useCard" },
silent: true,
filter(event) {
return event.skill == "reluanji";
},
async content(event, trigger, player) {
player.storage.reluanji2 = trigger.card;
if (!player.storage.reluanji) {
player.storage.reluanji = [];
}
player.storage.reluanji.addArray(trigger.cards.map(c => get.suit(c)));
},
},
respond: {
trigger: { global: "respond" },
silent: true,
filter(event) {
return event.getParent(2).skill == "reluanji";
},
async content(event, trigger, player) {
await trigger.player.draw();
},
},
damage: {
trigger: { source: "damage" },
forced: true,
silent: true,
popup: false,
filter(event, player) {
return player.storage.reluanji2 && event.card == player.storage.reluanji2;
},
async content(event, trigger, player) {
delete player.storage.reluanji2;
},
},
draw: {
trigger: { player: "useCardAfter" },
forced: true,
silent: true,
popup: false,
filter(event, player) {
return player.storage.reluanji2 && event.card == player.storage.reluanji2;
},
async content(event, trigger, player) {
await player.draw(trigger.targets.length);
delete player.storage.reluanji2;
},
},
},
},
qimou: {
unique: true,
limited: true,
audio: 2,
enable: "phaseUse",
filter(event, player) {
return !player.storage.qimou;
},
init(player) {
player.storage.qimou = false;
},
mark: true,
intro: {
content: "limited",
},
skillAnimation: true,
animationColor: "orange",
async content(event, trigger, player) {
const shas = player.getCards("h", "sha");
let num;
if (player.hp >= 4 && shas.length >= 3) {
num = 3;
} else if (player.hp >= 3 && shas.length >= 2) {
num = 2;
} else {
num = 1;
}
const map = {};
const list = [];
for (let i = 1; i <= player.hp; i++) {
const cn = get.cnNumber(i, true);
map[cn] = i;
list.push(cn);
}
player.awakenSkill("qimou");
player.storage.qimou = true;
const { result } = await player
.chooseControl(list, function () {
return get.cnNumber(_status.event.goon, true);
})
.set("prompt", "失去任意点体力")
.set("goon", num);
num = map[result.control] || 1;
player.storage.qimou2 = num;
player.addTempSkill("qimou2");
await player.loseHp(num);
},
ai: {
order: 2,
result: {
player(player) {
if (player.hp == 1) return 0;
const shas = player.getCards("h", "sha");
if (!shas.length) return 0;
const card = shas[0];
if (!lib.filter.cardEnabled(card, player)) return 0;
if (lib.filter.cardUsable(card, player)) return 0;
let mindist;
if (player.hp >= 4 && shas.length >= 3) {
mindist = 4;
} else if (player.hp >= 3 && shas.length >= 2) {
mindist = 3;
} else {
mindist = 2;
}
if (
game.hasPlayer(function (current) {
return current.hp <= mindist - 1 && get.distance(player, current, "attack") <= mindist && player.canUse(card, current, false) && get.effect(current, card, player, player) > 0;
})
) {
return 1;
}
return 0;
},
},
},
},
qimou2: {
onremove: true,
mod: {
cardUsable(card, player, num) {
if (typeof player.storage.qimou2 == "number" && card.name == "sha") {
return num + player.storage.qimou2;
}
},
globalFrom(from, to, distance) {
if (typeof from.storage.qimou2 == "number") {
return distance - from.storage.qimou2;
}
},
},
},
xinkuanggu: {
audio: "kuanggu",
audioname: ["re_weiyan", "ol_weiyan"],
trigger: { source: "damageSource" },
filter(event, player) {
return event.kuangguCheck && event.num > 0;
},
getIndex(event, player, triggername) {
return event.num;
},
preHidden: true,
async cost(event, trigger, player) {
let choice;
if (
player.isDamaged() &&
get.recoverEffect(player) > 0 &&
player.countCards("hs", function (card) {
return card.name == "sha" && player.hasValueTarget(card);
}) >= player.getCardUsable("sha")
) {
choice = "recover_hp";
} else {
choice = "draw_card";
}
const next = player.chooseDrawRecover("###" + get.prompt("xinkuanggu") + "###摸一张牌或回复1点体力");
next.set("choice", choice);
next.set("ai", function () {
return _status.event.getParent().choice;
});
next.setHiddenSkill("xinkuanggu");
const control = await next.forResultControl();
if (control == "cancel2") return;
event.result = { bool: true }; // 好像在content里面不能中断getIndex喵
},
async content(event, trigger, player) {},
group: "kuanggu_check",
},
xinliegong: {
shaRelated: true,
mod: {
aiOrder(player, card, num) {
if (num > 0 && (card.name === "sha" || get.tag(card, "draw"))) return num + 6;
},
targetInRange(card, player, target) {
if (card.name == "sha" && typeof get.number(card) == "number") {
if (get.distance(player, target) <= get.number(card)) return true;
}
},
},
audio: "liegong",
audioname: ["re_huangzhong", "ol_huangzhong"],
trigger: { player: "useCardToTargeted" },
logTarget: "target",
locked: false,
check(event, player) {
return get.attitude(player, event.target) <= 0;
},
filter(event, player) {
if (event.card.name != "sha") return false;
if (event.target.countCards("h") <= player.countCards("h")) return true;
if (event.target.hp >= player.hp) return true;
return false;
},
async content(event, trigger, player) {
if (trigger.target.countCards("h") <= player.countCards("h")) trigger.getParent().directHit.push(trigger.target);
if (trigger.target.hp >= player.hp) {
const id = trigger.target.playerid;
const map = trigger.getParent().customArgs;
if (!map[id]) map[id] = {};
if (typeof map[id].extraDamage != "number") {
map[id].extraDamage = 0;
}
map[id].extraDamage++;
}
},
ai: {
threaten: 0.5,
directHit_ai: true,
skillTagFilter(player, tag, arg) {
if (
get.attitude(player, arg.target) <= 0 &&
arg.card.name == "sha" &&
player.countCards("h", function (card) {
return card != arg.card && (!arg.card.cards || !arg.card.cards.includes(card));
}) >= arg.target.countCards("h")
)
return true;
return false;
},
},
},
tiaoxin: {
audio: 2,
audioname: ["sp_jiangwei", "xiahouba", "re_jiangwei", "gz_jiangwei", "ol_jiangwei"],
audioname2: {
dc_xiahouba: "tiaoxin_xiahouba",
},
enable: "phaseUse",
usable: 1,
filterTarget(card, player, target) {
return target != player && target.inRange(player) && target.countCards("he") > 0;
},
async content(event, trigger, player) {
const target = event.target;
const { result } = await target
.chooseToUse(
function (card, player, event) {
if (get.name(card) != "sha") return false;
return lib.filter.filterCard.apply(this, arguments);
},
"挑衅：对" + get.translation(player) + "使用一张杀，或令其弃置你的一张牌"
)
.set("targetRequired", true)
.set("complexSelect", true)
.set("filterTarget", function (card, player, target) {
if (target != _status.event.sourcex && !ui.selected.targets.includes(_status.event.sourcex)) return false;
return lib.filter.filterTarget.apply(this, arguments);
})
.set("sourcex", player);
if (result.bool == false && target.countCards("he") > 0) {
player.discardPlayerCard(target, "he", true);
}
},
ai: {
order: 4,
expose: 0.2,
result: {
target: -1,
player(player, target) {
if (target.countCards("h") == 0) return 0;
if (target.countCards("h") == 1) return -0.1;
if (player.hp <= 2) return -2;
if (player.countCards("h", "shan") == 0) return -1;
return -0.5;
},
},
threaten: 1.1,
},
},
tiaoxin_xiahouba: { audio: 2 },
zhiji: {
skillAnimation: true,
animationColor: "fire",
audio: 2,
audioname: ["re_jiangwei"],
unique: true,
juexingji: true,
//priority:-10,
derivation: "reguanxing",
trigger: { player: "phaseZhunbeiBegin" },
forced: true,
filter(event, player) {
if (player.storage.zhiji) return false;
return player.countCards("h") == 0;
},
async content(event, trigger, player) {
player.awakenSkill("zhiji");
await player.chooseDrawRecover(2, true);
await player.loseMaxHp();
await player.addSkills("reguanxing");
},
},
xiangle: {
audio: 2,
audioname: ["re_liushan", "ol_liushan"],
trigger: { target: "useCardToTargeted" },
forced: true,
preHidden: true,
filter(event, player) {
return event.card.name == "sha";
},
async content(event, trigger, player) {
const eff = get.effect(player, trigger.card, trigger.player, trigger.player);
const { result } = await trigger.player
.chooseToDiscard("享乐：弃置一张基本牌，否则杀对" + get.translation(player) + "无效", function (card) {
return get.type(card) == "basic";
})
.set("ai", function (card) {
if (_status.event.eff > 0) {
return 10 - get.value(card);
}
return 0;
})
.set("eff", eff);
if (result.bool == false) trigger.getParent().excluded.add(player);
},
ai: {
effect: {
target_use(card, player, target, current) {
if (card.name == "sha" && get.attitude(player, target) < 0) {
if (_status.event.name == "xiangle") return;
if (get.attitude(player, target) > 0 && current < 0) return "zerotarget";
const bs = player.getCards("h", { type: "basic" });
bs.remove(card);
if (card.cards) bs.removeArray(card.cards);
else bs.removeArray(ui.selected.cards);
if (!bs.length) return "zerotarget";
if (player.hasSkill("jiu") || player.hasSkill("tianxianjiu")) return;
if (bs.length <= 2) {
for (let i = 0; i < bs.length; i++) {
if (get.value(bs[i]) < 7) {
return [1, 0, 1, -0.5];
}
}
return [1, 0, 0.3, 0];
}
return [1, 0, 1, -0.5];
}
},
},
},
},
fangquan: {
audio: 2,
trigger: { player: "phaseUseBefore" },
filter(event, player) {
return player.countCards("h") > 0 && !player.hasSkill("fangquan3");
},
preHidden: true,
async cost(event, trigger, player) {
const fang = player.countMark("fangquan2") == 0 && player.hp >= 2 && player.countCards("h") <= player.hp + 1;
event.result = await player
.chooseBool(get.prompt2("fangquan"))
.set("ai", function () {
if (!_status.event.fang) return false;
return game.hasPlayer(function (target) {
if (target.hasJudge("lebu") || target == player) return false;
if (get.attitude(player, target) > 4) {
return get.threaten(target) / Math.sqrt(target.hp + 1) / Math.sqrt(target.countCards("h") + 1) > 0;
}
return false;
});
})
.set("fang", fang)
.setHiddenSkill(event.name)
.forResult();
},
async content(event, trigger, player) {
trigger.cancel();
player.addTempSkill("fangquan2");
player.addMark("fangquan2", 1, false);
//player.storage.fangquan=result.targets[0];
},
},
fangquan2: {
trigger: { player: "phaseEnd" },
locked: true,
log: false,
audio: false,
//priority:-50,
onremove: true,
getIndex(event, player) {
return player.countMark("fangquan2") || 1;
},
async cost(event, trigger, player) {
const chooseToDiscard = player.chooseToDiscard("是否弃置一张牌并令一名其他角色进行一个额外回合？");
chooseToDiscard.ai = function (card) {
return 20 - get.value(card);
};
if (!(await chooseToDiscard.forResultBool())) return;
const chooseTarget = player.chooseTarget(true, "请选择进行额外回合的目标角色", lib.filter.notMe);
chooseTarget.ai = function (target) {
if (target.hasJudge("lebu") || get.attitude(player, target) <= 0) return -1;
if (target.isTurnedOver()) return 0.18;
return get.threaten(target) / Math.sqrt(target.hp + 1) / Math.sqrt(target.countCards("h") + 1);
};
event.result = await chooseTarget.forResult();
},
async content(event, trigger, player) {
const [target] = event.targets;
player.logSkill(player.name == "re_liushan" ? "refangquan" : "fangquan", event.targets, "fire");
target.markSkillCharacter("fangquan", player, "放权", "进行一个额外回合");
target.insertPhase();
player.removeMark("fangquan2");
target.addSkill("fangquan3");
},
},
fangquan3: {
trigger: { player: ["phaseAfter", "phaseCancelled"] },
forced: true,
popup: false,
audio: false,
async content(event, trigger, player) {
player.unmarkSkill("fangquan");
player.removeSkill("fangquan3");
},
},
ruoyu: {
skillAnimation: true,
animationColor: "fire",
audio: 2,
audioname: ["re_liushan"],
unique: true,
juexingji: true,
zhuSkill: true,
keepSkill: true,
derivation: "rejijiang",
trigger: { player: "phaseZhunbeiBegin" },
forced: true,
filter(event, player) {
return player.isMinHp();
},
async content(event, trigger, player) {
player.awakenSkill("ruoyu");
await player.gainMaxHp();
await player.recover();
await player.addSkills("rejijiang");
},
},
qiaobian: {
audio: 2,
trigger: {
player: ["phaseJudgeBefore", "phaseDrawBefore", "phaseUseBefore", "phaseDiscardBefore"],
},
filter(event, player) {
return player.countCards("h") > 0;
},
preHidden: true,
async cost(event, trigger, player) {
let check,
str = "弃置一张手牌并跳过";
str += ["判定", "摸牌", "出牌", "弃牌"][lib.skill.qiaobian.trigger.player.indexOf(event.triggername)];
str += "阶段";
if (trigger.name == "phaseDraw") str += "，然后可以获得至多两名角色各一张手牌";
if (trigger.name == "phaseUse") str += "，然后可以移动场上的一张牌";
switch (trigger.name) {
case "phaseJudge":
check = player.countCards("j");
break;
case "phaseDraw":
let i,
num = 0,
num2 = 0;
const players = game.filterPlayer();
for (i = 0; i < players.length; i++) {
if (player != players[i] && players[i].countCards("h")) {
const att = get.attitude(player, players[i]);
if (att <= 0) {
num++;
}
if (att < 0) {
num2++;
}
}
}
check = num >= 2 && num2 > 0;
break;
case "phaseUse":
if (!player.canMoveCard(true)) {
check = false;
} else {
check = game.hasPlayer(function (current) {
return get.attitude(player, current) > 0 && current.countCards("j");
});
if (!check) {
if (player.countCards("h") > player.hp + 1) {
check = false;
} else if (player.countCards("h", { name: "wuzhong" })) {
check = false;
} else {
check = true;
}
}
}
break;
case "phaseDiscard":
check = player.needsToDiscard();
break;
}
event.result = await player
.chooseToDiscard(get.prompt("qiaobian"), str, lib.filter.cardDiscardable)
.set("ai", card => {
if (!_status.event.check) return -1;
return 7 - get.value(card);
})
.set("check", check)
.setHiddenSkill("qiaobian")
.forResult();
},
async content(event, trigger, player) {
trigger.cancel();
game.log(player, "跳过了", "#y" + ["判定", "摸牌", "出牌", "弃牌"][lib.skill.qiaobian.trigger.player.indexOf(event.triggername)] + "阶段");
if (trigger.name == "phaseUse") {
if (player.canMoveCard()) await player.moveCard();
} else if (trigger.name == "phaseDraw") {
const { result } = await player
.chooseTarget([1, 2], "获得至多两名角色各一张手牌", function (card, player, target) {
return target != player && target.countCards("h");
})
.set("ai", function (target) {
return 1 - get.attitude(_status.event.player, target);
});
if (!result.bool) return;
result.targets.sortBySeat();
player.line(result.targets, "green");
if (!result.targets.length) return;
await player.gainMultiple(result.targets);
await game.asyncDelay();
}
},
ai: { threaten: 3 },
},
tuntian: {
audio: 2,
audioname: ["gz_dengai"],
trigger: {
player: "loseAfter",
global: ["equipAfter", "addJudgeAfter", "gainAfter", "loseAsyncAfter", "addToExpansionAfter"],
},
frequent: true,
preHidden: true,
filter(event, player) {
if (player == _status.currentPhase) return false;
if (event.name == "gain" && event.player == player) return false;
const evt = event.getl(player);
return evt && evt.cards2 && evt.cards2.length > 0;
},
async content(event, trigger, player) {
const judge = player.judge(function (card) {
if (get.suit(card) == "heart") return -1;
return 1;
});
judge.judge2 = function (result) {
return result.bool;
};
if (get.mode() != "guozhan") {
judge.callback = lib.skill.tuntian.callback;
return void (await judge);
}
const { result } = await judge;
if (!result.bool || get.position(result.card) != "d") {
//game.cardsDiscard(card);
return;
}
const card = result.card;
const chooseBool = player.chooseBool("是否将" + get.translation(card) + "作为“田”置于武将牌上？");
chooseBool.ai = function () {
return true;
};
const bool = await chooseBool.forResultBool();
if (!bool && !event.directbool) return;
const addToExpansion = player.addToExpansion(event.card, "gain2");
addToExpansion.gaintag.add("tuntian");
await addToExpansion;
},
async callback(event, trigger, player) {
if (!event.judgeResult.bool) return;
const next = player.addToExpansion(event.judgeResult.card, "gain2");
next.gaintag.add("tuntian");
await next;
},
marktext: "田",
intro: {
content: "expansion",
markcount: "expansion",
},
onremove(player, skill) {
const cards = player.getExpansions(skill);
if (cards.length) player.loseToDiscardpile(cards);
},
group: "tuntian_dist",
locked: false,
subSkill: {
dist: {
locked: false,
mod: {
globalFrom(from, to, distance) {
let num = distance - from.getExpansions("tuntian").length;
if (_status.event.skill == "jixi_backup" || _status.event.skill == "gzjixi_backup") num++;
return num;
},
},
},
},
ai: {
effect: {
target(card, player, target, current) {
if (
typeof card === "object" &&
get.name(card) === "sha" &&
target.mayHaveShan(
player,
"use",
target.getCards("h", i => {
return i.hasGaintag("sha_notshan");
})
)
)
return [0.6, 0.75];
if (!target.hasFriend() && !player.hasUnknown()) return;
if (_status.currentPhase == target || get.type(card) === "delay") return;
if (card.name != "shuiyanqijunx" && get.tag(card, "loseCard") && target.countCards("he")) {
if (target.hasSkill("ziliang")) return 0.7;
return [0.5, Math.max(2, target.countCards("h"))];
}
if (target.isUnderControl(true, player)) {
if ((get.tag(card, "respondSha") && target.countCards("h", "sha")) || (get.tag(card, "respondShan") && target.countCards("h", "shan"))) {
if (target.hasSkill("ziliang")) return 0.7;
return [0.5, 1];
}
} else if (get.tag(card, "respondSha") || get.tag(card, "respondShan")) {
if (get.attitude(player, target) > 0 && card.name == "juedou") return;
if (get.tag(card, "damage") && target.hasSkillTag("maixie")) return;
if (target.countCards("h") == 0) return 2;
if (target.hasSkill("ziliang")) return 0.7;
if (get.mode() == "guozhan") return 0.5;
return [0.5, Math.max(target.countCards("h") / 4, target.countCards("h", "sha") + target.countCards("h", "shan"))];
}
},
},
threaten(player, target) {
if (target.countCards("h") == 0) return 2;
return 0.5;
},
nodiscard: true,
nolose: true,
},
},
zaoxian: {
skillAnimation: true,
animationColor: "thunder",
audio: 2,
audioname: ["re_dengai"],
unique: true,
juexingji: true,
trigger: { player: "phaseZhunbeiBegin" },
forced: true,
filter(event, player) {
return player.getExpansions("tuntian").length >= 3;
},
derivation: "jixi",
async content(event, trigger, player) {
player.awakenSkill("zaoxian");
await player.loseMaxHp();
await player.addSkills("jixi");
},
ai: {
combo: "tuntian",
},
},
jixi: {
audio: 2,
audioname: ["re_dengai", "gz_dengai", "ol_dengai"],
enable: "phaseUse",
filter(event, player) {
return player.getExpansions("tuntian").length > 0 && event.filterCard({ name: "shunshou" }, player, event);
},
chooseButton: {
dialog(event, player) {
return ui.create.dialog("急袭", player.getExpansions("tuntian"), "hidden");
},
filter(button, player) {
const card = button.link;
if (!game.checkMod(card, player, "unchanged", "cardEnabled2", player)) return false;
const evt = _status.event.getParent();
return evt.filterCard(get.autoViewAs({ name: "shunshou" }, [card]), player, evt);
},
backup(links, player) {
const skill = _status.event.buttoned;
return {
audio: "jixi",
audioname: ["re_dengai", "gz_dengai", "ol_dengai"],
selectCard: -1,
position: "x",
filterCard: skill == "jixi" ? card => card == lib.skill.jixi_backup.card : card => card == lib.skill.gzjixi_backup.card,
viewAs: { name: "shunshou" },
card: links[0],
};
},
prompt(links, player) {
return "选择 顺手牵羊（" + get.translation(links[0]) + "）的目标";
},
},
ai: {
order: 10,
result: {
player(player) {
return player.getExpansions("tuntian").length - 1;
},
},
combo: "tuntian",
},
},
jiang: {
shaRelated: true,
audio: 2,
preHidden: true,
audioname: ["sp_lvmeng", "re_sunben", "re_sunce"],
mod: {
aiOrder(player, card, num) {
if (get.color(card) === "red" && get.name(card) === "sha") return get.order({ name: "sha" }) + 0.15;
},
},
trigger: {
player: "useCardToPlayered",
target: "useCardToTargeted",
},
filter(event, player) {
if (!(event.card.name == "juedou" || (event.card.name == "sha" && get.color(event.card) == "red"))) return false;
return player == event.target || event.getParent().triggeredTargets3.length == 1;
},
locked: false,
frequent: true,
async content(event, trigger, player) {
player.draw();
},
ai: {
effect: {
target_use(card, player, target) {
if (card.name == "sha" && get.color(card) == "red") return [1, 0.6];
},
player_use(card, player, target) {
if (card.name == "sha" && get.color(card) == "red") return [1, 1];
},
},
},
},
hunzi: {
//audioname:['re_sunben'],
skillAnimation: true,
animationColor: "wood",
audio: 2,
juexingji: true,
derivation: ["reyingzi", "gzyinghun"],
unique: true,
trigger: { player: "phaseZhunbeiBegin" },
filter(event, player) {
return player.hp <= 1 && !player.storage.hunzi;
},
forced: true,
//priority:3,
async content(event, trigger, player) {
player.awakenSkill(event.name);
await player.loseMaxHp();
await player.addSkills(["reyingzi", "gzyinghun"]);
},
ai: {
threaten(player, target) {
if (target.hp == 1) return 2;
return 0.5;
},
maixie: true,
effect: {
target(card, player, target) {
if (!target.hasFriend()) return;
if (target.hp === 2 && get.tag(card, "damage") == 1 && !target.isTurnedOver() && _status.currentPhase !== target && get.distance(_status.currentPhase, target, "absolute") <= 3) return [0.5, 1];
if (target.hp === 1 && get.tag(card, "recover") && !target.isTurnedOver() && _status.currentPhase !== target && get.distance(_status.currentPhase, target, "absolute") <= 3) return [1, -3];
},
},
},
},
zhiba: {
unique: true,
global: "zhiba2",
audioname: ["re_sunben"],
audio: "zhiba2",
zhuSkill: true,
},
zhiba2: {
audio: 2,
audioname: ["re_sunben"],
//forceaudio:true,
enable: "phaseUse",
prompt() {
const player = _status.event.player;
const list = game.filterPlayer(function (target) {
return target.hasZhuSkill("zhiba", player) && player.canCompare(target);
});
let str = "和" + get.translation(list);
if (list.length > 1) str += "中的一人";
str += "进行拼点。若你没赢，其可以获得两张拼点牌。";
return str;
},
filter(event, player) {
if (player.group != "wu" || player.countCards("h") == 0) return false;
return game.hasPlayer(function (target) {
return target.hasZhuSkill("zhiba", player) && player.canCompare(target);
});
},
filterTarget(card, player, target) {
return target.hasZhuSkill("zhiba", player) && player.canCompare(target);
},
log: false,
prepare(cards, player, targets) {
targets[0].logSkill("zhiba");
},
usable: 1,
async content(event, trigger, player) {
const target = event.target;
if (target.storage.hunzi || target.storage.rehunzi) {
const control = await target
.chooseControl("拒绝", "不拒绝")
.set("prompt", "是否拒绝制霸拼点？")
.set("choice", get.attitude(target, player) <= 0)
.forResultControl();
if (control == "拒绝") {
game.log(target, "拒绝了拼点");
target.chat("拒绝");
return;
}
} else event.forced = true;
if (!event.forced && result.control == "拒绝") {
game.log(target, "拒绝了拼点");
target.chat("拒绝");
event.finish();
return;
}
const { result } = await player
.chooseToCompare(target, function (card) {
if (card.name == "du") return 20;
const player = get.owner(card);
const target = _status.event.getParent().target;
if (player != target && get.attitude(player, target) > 0) {
return -get.number(card);
}
return get.number(card);
})
.set("preserve", "lose");
if (result.bool == false) {
const list = [];
if (get.position(result.player) == "d") list.push(result.player);
if (get.position(result.target) == "d") list.push(result.target);
if (!list.length) return;
event.list = list;
const next = target.chooseBool("是否获得" + get.translation(list) + "？");
next.ai = function () {
return get.value(list) > 0;
};
if (await next.forResultBool()) await target.gain(event.list, "gain2");
}
},
ai: {
basic: {
order: 1,
},
expose: 0.2,
result: {
target(player, target) {
if (player.countCards("h", "du") && get.attitude(player, target) < 0) return -1;
if (player.countCards("h") <= player.hp) return 0;
let maxnum = 0;
const cards2 = target.getCards("h");
for (let i = 0; i < cards2.length; i++) {
if (get.number(cards2[i]) > maxnum) {
maxnum = get.number(cards2[i]);
}
}
if (maxnum > 10) maxnum = 10;
if (maxnum < 5 && cards2.length > 1) maxnum = 5;
const cards = player.getCards("h");
for (let i = 0; i < cards.length; i++) {
if (get.number(cards[i]) < maxnum) return 1;
}
return 0;
},
},
},
},
zhijian: {
audio: 2,
enable: "phaseUse",
filter(event, player) {
return player.countCards("h", { type: "equip" }) > 0;
},
filterCard(card) {
return get.type(card) == "equip";
},
check(card) {
const player = _status.currentPhase;
if (player.countCards("he", { subtype: get.subtype(card) }) > 1) {
return 11 - get.equipValue(card);
}
return 6 - get.value(card);
},
filterTarget(card, player, target) {
if (target.isMin()) return false;
return player != target && target.canEquip(card);
},
async content(event, trigger, player) {
await event.target.equip(event.cards[0]);
await player.draw();
},
discard: false,
lose: false,
prepare(cards, player, targets) {
player.$give(cards, targets[0], false);
},
ai: {
basic: {
order: 10,
},
result: {
target(player, target) {
const card = ui.selected.cards[0];
if (card) return get.effect(target, card, target, target);
return 0;
},
},
threaten: 1.3,
},
},
guzheng: {
audio: 2,
audioname: ["re_zhangzhang"],
trigger: { global: "phaseDiscardAfter" },
filter(event, player) {
if (event.player != player && event.player.isIn()) {
return (
event.player.getHistory("lose", function (evt) {
return evt.type == "discard" && evt.getParent("phaseDiscard") == event && evt.hs.someInD("d");
}).length > 0
);
}
return false;
},
checkx(event, player, cards, cards2) {
if (cards.length > 2 || get.attitude(player, event.player) > 0) return true;
for (let i = 0; i < cards2.length; i++) {
if (get.value(cards2[i], event.player, "raw") < 0) return true;
}
return false;
},
preHidden: true,
async cost(event, trigger, player) {
const cards = [],
cards2 = [];
const target = trigger.player;
game.getGlobalHistory("cardMove", function (evt) {
if (evt.name == "cardsDiscard") {
if (evt.getParent("phaseDiscard") == trigger) {
const moves = evt.cards.filterInD("d");
cards.addArray(moves);
cards2.removeArray(moves);
}
}
if (evt.name == "lose") {
if (evt.type != "discard" || evt.position != ui.discardPile || evt.getParent("phaseDiscard") != trigger) return;
const moves = evt.cards.filterInD("d");
cards.addArray(moves);
if (evt.player == target) cards2.addArray(moves);
else cards2.removeArray(moves);
}
});
if (!cards2.length) return;
if (cards.length == 1) {
event.card = cards[0];
event.result = await player
.chooseBool()
.set("createDialog", [get.prompt("guzheng", target), '点击“确认”以令其收回此牌', cards])
.set("choice", lib.skill.guzheng.checkx(trigger, player, cards, cards2))
.set("ai", function () {
return _status.event.choice;
})
.setHiddenSkill("guzheng")
.forResult();
event.result.cost_data = {
action: "single",
cards: cards,
};
} else {
event.result = await player
.chooseButton(2, [get.prompt("guzheng", target), '被选择的牌将成为对方收回的牌', cards, [["获得剩余的牌", "放弃剩余的牌"], "tdnodes"]])
.set("filterButton", function (button) {
const type = typeof button.link;
if (ui.selected.buttons.length && type == typeof ui.selected.buttons[0].link) return false;
return type == "string" || _status.event.allowed.includes(button.link);
})
.set("allowed", cards2)
.set("check", lib.skill.guzheng.checkx(trigger, player, cards, cards2))
.set("ai", function (button) {
if (typeof button.link == "string") {
return button.link == "获得剩余的牌" ? 1 : 0;
}
if (_status.event.check) {
return 20 - get.value(button.link, _status.event.getTrigger().player);
}
return 0;
})
.setHiddenSkill("guzheng")
.forResult();
event.result.cost_data = {
action: "multiple",
cards: event.result.links,
};
}
},
logTarget: "player",
async content(event, trigger, player) {
const target = trigger.player;
const action = event.cost_data.action;
const cards = event.cost_data.cards;
if (action != "multiple") {
const gain = target.gain(cards[0], "gain2");
gain.giver = player;
await gain;
} else {
if (typeof cards[0] != "string") cards.reverse();
const [, card] = cards;
const gain = target.gain(card, "gain2");
gain.giver = player;
await gain;
if (cards[0] != "获得剩余的牌") return;
}
//避免插入结算改变弃牌堆 重新判断一次
cards.length = 0;
game.getGlobalHistory("cardMove", function (evt) {
if (evt.name == "cardsDiscard") {
if (evt.getParent("phaseDiscard") == trigger) {
const moves = evt.cards.filterInD("d");
cards.addArray(moves);
}
}
if (evt.name == "lose") {
if (evt.type != "discard" || evt.position != ui.discardPile || evt.getParent("phaseDiscard") != trigger) return;
const moves = evt.cards.filterInD("d");
cards.addArray(moves);
}
});
if (cards.length > 0) await player.gain(cards, "gain2");
},
ai: {
threaten: 1.3,
expose: 0.2,
},
},
beige: {
audio: 2,
audioname: ["re_caiwenji", "ol_caiwenji"],
trigger: { global: "damageEnd" },
filter(event, player) {
return event.card && event.card.name == "sha" && event.source && event.player.isIn() && player.countCards("he");
},
checkx(event, player) {
const att1 = get.attitude(player, event.player);
const att2 = get.attitude(player, event.source);
return att1 > 0 && att2 <= 0;
},
preHidden: true,
async cost(event, trigger, player) {
const next = player.chooseToDiscard("he", get.prompt2("beige", trigger.player));
const check = lib.skill.beige.checkx(trigger, player);
next.set("ai", function (card) {
if (_status.event.goon) return 8 - get.value(card);
return 0;
});
next.set("goon", check);
next.setHiddenSkill("beige");
event.result = await next.forResult();
},
async content(event, trigger, player) {
const { result } = await trigger.player.judge();
switch (result.suit) {
case "heart":
await trigger.player.recover();
break;
case "diamond":
await trigger.player.draw(2);
break;
case "club":
await trigger.source.chooseToDiscard("he", 2, true);
break;
case "spade":
await trigger.source.turnOver();
break;
}
},
ai: {
expose: 0.3,
},
},
duanchang: {
audio: 2,
audioname: ["re_caiwenji", "ol_caiwenji"],
forbid: ["boss"],
trigger: { player: "die" },
forced: true,
forceDie: true,
skillAnimation: true,
animationColor: "gray",
filter(event) {
return event.source && event.source.isIn();
},
async content(event, trigger, player) {
trigger.source.clearSkills();
},
logTarget: "source",
ai: {
maixie_defend: true,
threaten(player, target) {
if (target.hp == 1) return 0.2;
return 1.5;
},
effect: {
target(card, player, target, current) {
if (!target.hasFriend()) return;
if (target.hp <= 1 && get.tag(card, "damage")) {
if (player.hasSkillTag("jueqing", false, target)) return 3;
return [1, 0, 0, -3 * get.threaten(player)];
}
},
},
},
},
// ---------- 本次分界线喵 ----------
huashen: {
audio: "huashen2",
unique: true,
init(player) {
if (!player.storage.huashen) {
player.storage.huashen = {
owned: {},
};
}
player.when("dieBegin").then(() => {
const name = player.name ? player.name : player.name1;
if (name) {
const sex = get.character(name, 0);
const group = get.character(name, 1);
if (player.sex != sex) {
game.broadcastAll(
(player, sex) => {
player.sex = sex;
},
player,
sex
);
game.log(player, "将性别变为了", "#y" + get.translation(sex) + "性");
}
if (player.group != group) player.changeGroup(group);
}
});
},
intro: {
content(storage, player) {
var str = "";
var list = Object.keys(storage.owned);
if (list.length) {
str += get.translation(list[0]);
for (var i = 1; i < list.length; i++) {
str += "、" + get.translation(list[i]);
}
}
var skill = player.storage.huashen.current2;
if (skill) {
str += "当前技能：" + get.translation(skill);
}
return str;
},
onunmark(storage, player) {
_status.characterlist.addArray(Object.keys(storage.owned));
storage.owned = [];
},
mark(dialog, content, player) {
var list = Object.keys(content.owned);
if (list.length) {
var skill = player.storage.huashen.current2;
var character = player.storage.huashen.current;
if (skill && character) {
dialog.addSmall([[character], (item, type, position, noclick, node) => lib.skill.rehuashen.$createButton(item, type, position, noclick, node)]);
dialog.add('
【' + get.translation(lib.translate[skill + "_ab"] || get.translation(skill).slice(0, 2)) + "】
" + "
" + get.skillInfoTranslation(skill, player) + "
失效技能：" + get.translation(list);
return str;
},
},
audio: 2,
trigger: { player: "changeHp" },
filter(event, player) {
return player.hp == 1;
},
forced: true,
content() {},
},
guhuo_phase: {},
};
export default skills;