11985 lines
355 KiB
JavaScript
11985 lines
355 KiB
JavaScript
import { lib, game, ui, get, ai, _status } from "../../noname.js";
|
||
|
||
/** @type { importCharacterConfig['skill'] } */
|
||
const skills = {
|
||
//星孙坚
|
||
starruijun: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "useCardToPlayered",
|
||
},
|
||
filter(event, player) {
|
||
if (event.targets.length > 1) return false;
|
||
if (
|
||
player.hasHistory("useCard", evt => {
|
||
if (evt === event.getParent()) return false;
|
||
const targets = evt.targets;
|
||
return targets.length === 1 && targets[0] !== player;
|
||
})
|
||
)
|
||
return false;
|
||
const target = event.target;
|
||
if (target === player || !target.isIn()) return false;
|
||
return true;
|
||
},
|
||
logTarget: "target",
|
||
locked: false,
|
||
check(event, player) {
|
||
return (
|
||
get.attitude(player, event.target) <= 0 ||
|
||
!player.hasCard(card => {
|
||
return game.hasPlayer(current => {
|
||
return get.effect(current, card, player, player) > 0 && player.canUse(card, current, true, true);
|
||
});
|
||
}, "hs")
|
||
);
|
||
},
|
||
prompt2(event, player) {
|
||
return `摸${get.cnNumber(player.getDamagedHp() + 1)}张牌，令所有除${get.translation(event.target)}外的其他角色不在你的攻击范围内，且你对其造成的伤害逐次增加。`;
|
||
},
|
||
async content(event, trigger, player) {
|
||
await player.draw(player.getDamagedHp() + 1);
|
||
player.addTempSkill("starruijun_effect", "phaseChange");
|
||
player.markAuto("starruijun_effect", trigger.target);
|
||
},
|
||
subSkill: {
|
||
effect: {
|
||
audio: "starruijun",
|
||
trigger: {
|
||
source: "damageBegin2",
|
||
},
|
||
charlotte: true,
|
||
forced: true,
|
||
onremove: true,
|
||
async content(event, trigger, player) {
|
||
let num = 1;
|
||
const evts = player.getHistory("sourceDamage", evt => {
|
||
return evt.source === player && evt.player === trigger.player;
|
||
});
|
||
if (evts.length) num += evts.lastItem.num;
|
||
trigger.num = Math.min(5, num);
|
||
},
|
||
mod: {
|
||
inRange(from, to) {
|
||
if (!from.getStorage("starruijun_effect").includes(to)) return false;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
mod: {
|
||
aiOrder(player, card, num) {
|
||
const event = get.event();
|
||
if (!event || event.type !== "phase") return;
|
||
if (
|
||
game.hasPlayer(current => {
|
||
return get.effect(current, card, player, player) > 0 && player.canUse(card, current, true, true) && get.damageEffect(current, player, player) > 0;
|
||
})
|
||
)
|
||
return num * 2;
|
||
return num / 1.5;
|
||
},
|
||
},
|
||
},
|
||
stargangyi: {
|
||
audio: 2,
|
||
trigger: {
|
||
source: "damage",
|
||
},
|
||
silent: true,
|
||
forced: true,
|
||
group: "stargangyi_recover",
|
||
async content(event, trigger, player) {
|
||
player.addTempSkill("stargangyi_access");
|
||
},
|
||
subSkill: {
|
||
recover: {
|
||
audio: "stargangyi",
|
||
trigger: {
|
||
player: "recoverBegin",
|
||
},
|
||
filter(event, player) {
|
||
const evt = event.getParent(3);
|
||
if (!player.isDying() || evt.type !== "dying") return false;
|
||
return ["tao", "jiu"].includes(event.getParent().name);
|
||
},
|
||
forced: true,
|
||
async content(event, trigger, player) {
|
||
trigger.num++;
|
||
},
|
||
},
|
||
access: {
|
||
charlotte: true,
|
||
},
|
||
},
|
||
mod: {
|
||
cardEnabled(card, player) {
|
||
if (player.hasSkill("stargangyi_access")) return;
|
||
if (player === _status.currentPhase && card.name === "tao") return false;
|
||
},
|
||
cardSavable(card, player) {
|
||
if (player.hasSkill("stargangyi_access")) return;
|
||
if (player === _status.currentPhase && card.name === "tao") return false;
|
||
},
|
||
},
|
||
},
|
||
//李傕郭汜
|
||
xiongsuan: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
filterTarget: true,
|
||
filterCard: lib.filter.cardDiscardable,
|
||
position: "h",
|
||
usable: 1,
|
||
async content(event, trigger, player) {
|
||
const target = event.target;
|
||
await target.damage();
|
||
await player.draw(3);
|
||
if (target != player) await player.loseHp();
|
||
},
|
||
ai: {
|
||
order: 9,
|
||
result: {
|
||
player(player, target) {
|
||
let res = 2 * get.effect(player, { name: "draw" }, player, player);
|
||
if (player !== target) res += get.effect(player, { name: "losehp" }, player, player);
|
||
return res;
|
||
},
|
||
target(player, target) {
|
||
return get.damageEffect(target, player, target);
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//张春华
|
||
starliangyan: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: lib.filter.notMe,
|
||
chooseButton: {
|
||
dialog(event, player) {
|
||
const name = get.translation(event.result.targets[0]);
|
||
const list = ["你摸一张牌，其弃置一张牌", "你弃置一张牌，其摸一张牌", "你摸两张牌，其弃置两张牌", "你弃置两张牌，其摸两张牌"].map((item, i) => [i, item]);
|
||
const dialog = ui.create.dialog(`梁燕：请选择你与${name}要执行的选项`, [list.slice(0, 2), "tdnodes"], [list.slice(2, 4), "tdnodes"], "hidden");
|
||
return dialog;
|
||
},
|
||
filter(button, player) {
|
||
const link = button.link;
|
||
if (link % 2 === 0) return true;
|
||
return player.countDiscardableCards(player, "he") >= (link + 1) / 2;
|
||
},
|
||
check(button) {
|
||
const player = get.player(),
|
||
target = get.event().getParent().result.targets[0];
|
||
const link = button.link;
|
||
if (get.attitude(player, target) <= 0 && link === 2) return 100;
|
||
const ph = player.countCards("h"),
|
||
th = target.countCards("h");
|
||
if (link % 2 === 0) {
|
||
const num = link / 2 + 1;
|
||
if (ph + num === th - num) return 10;
|
||
} else {
|
||
const num = (link + 1) / 2;
|
||
if (ph - num === th + num) return 10;
|
||
}
|
||
return 5;
|
||
},
|
||
backup(links) {
|
||
return {
|
||
audio: "starliangyan",
|
||
target: get.event().result.targets[0],
|
||
link: links[0],
|
||
filterTarget(card, player, target) {
|
||
return target === lib.skill.starliangyan_backup.target;
|
||
},
|
||
selectTarget: -1,
|
||
async content(content, trigger, player) {
|
||
const target = lib.skill.starliangyan_backup.target;
|
||
const link = lib.skill.starliangyan_backup.link;
|
||
const num = link <= 1 ? 1 : 2;
|
||
const fn = ["draw", "chooseToDiscard"];
|
||
if (link % 2 === 1) fn.reverse();
|
||
await player[fn[0]](num, true, "he");
|
||
await target[fn[1]](num, true, "he");
|
||
if (player.countCards("h") === target.countCards("h")) {
|
||
const skipper = [player, target][link % 2];
|
||
skipper.skip("phaseDiscard");
|
||
game.log(skipper, "跳过了下一个", "#y弃牌阶段");
|
||
}
|
||
},
|
||
};
|
||
},
|
||
prompt(links) {
|
||
return "点击“确定”以执行效果";
|
||
},
|
||
},
|
||
subSkill: {
|
||
backup: {},
|
||
},
|
||
ai: {
|
||
order(item, player) {
|
||
if (!game.hasPlayer(current => current !== player && get.attitude(player, current) > 0) && game.hasPlayer(current => get.attitude(player, current) <= 0)) return 10;
|
||
if (
|
||
game.hasPlayer(current => {
|
||
const del = player.countCards("h") - current.countCards("h"),
|
||
toFind = [2, 4].find(num => Math.abs(del) === num);
|
||
if (toFind === 4 && del < 0 && get.attitude(player, current) <= 0) {
|
||
return true;
|
||
}
|
||
return false;
|
||
})
|
||
)
|
||
return 10;
|
||
return 1;
|
||
},
|
||
result: {
|
||
target(player, target) {
|
||
const del = player.countCards("h") - target.countCards("h"),
|
||
toFind = [2, 4].find(num => Math.abs(del) === num);
|
||
if (toFind) {
|
||
return (-del * (get.attitude(player, target) * Math.min(3, target.countCards("h"))) * toFind) / 10;
|
||
}
|
||
return -1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
starminghui: {
|
||
audio: 2,
|
||
trigger: { global: "phaseEnd" },
|
||
filter(event, player) {
|
||
return player.isMinHandcard() || player.isMaxHandcard();
|
||
},
|
||
direct: true,
|
||
async content(event, trigger, player) {
|
||
let logged = false;
|
||
if (player.isMinHandcard()) {
|
||
const card = new lib.element.VCard({
|
||
name: "sha",
|
||
});
|
||
const result = await player
|
||
.chooseUseTarget(`###${get.prompt("starminghui")}###视为使用一张无距离限制的【杀】`, card, false, "nodistance")
|
||
.set("logSkill", "starminghui")
|
||
.forResult();
|
||
if (result.bool) logged = true;
|
||
}
|
||
const num = player.countCards("h");
|
||
if (player.isMaxHandcard() && num > 0) {
|
||
const maxNum = game
|
||
.findPlayer(current => {
|
||
if (current === player) return false;
|
||
return !game.hasPlayer(current2 => {
|
||
if (current2 === player) return false;
|
||
return current2.countCards("h") > current.countCards("h");
|
||
});
|
||
})
|
||
.countCards("h");
|
||
const leastDiscardNum = num - maxNum + 1;
|
||
const prompt = logged ? `是否将手牌弃置至不为最多？` : get.prompt("starminghui");
|
||
const next = player
|
||
.chooseToDiscard(prompt, `弃置至少${get.cnNumber(leastDiscardNum)}张手牌，然后你令一名角色回复1点体力`)
|
||
.set("selectCard", [leastDiscardNum, Infinity])
|
||
.set(
|
||
"goon",
|
||
game.hasPlayer(current => get.recoverEffect(current, get.player(), get.player()))
|
||
)
|
||
.set("ai", card => {
|
||
if (!get.event("goon")) return 0;
|
||
if (get.tag(card, "recover")) return 0;
|
||
if (ui.selected.cards.length === get.event("selectCard")[0] - 1) return 6.5 - get.value(card);
|
||
return 4 - get.value(card);
|
||
});
|
||
if (!logged) next.set("logSkill", "starminghui");
|
||
const result = await next.forResult();
|
||
if (!result.bool) return;
|
||
if (!player.isUnderControl(true) && !player.isOnline()) await game.asyncDelayx();
|
||
const [bool, targets] = await player
|
||
.chooseTarget("令一名角色回复1点体力")
|
||
.set("ai", target => get.recoverEffect(target, get.player(), get.player()))
|
||
.forResult("bool", "targets");
|
||
if (bool) {
|
||
const target = targets[0];
|
||
player.line(target, "green");
|
||
await target.recover();
|
||
}
|
||
}
|
||
},
|
||
},
|
||
//星袁绍
|
||
starxiaoyan: {
|
||
audio: 2,
|
||
trigger: {
|
||
global: "phaseBefore",
|
||
player: ["enterGame" /*,'logSkill'*/],
|
||
},
|
||
filter(event, player) {
|
||
if (!game.hasPlayer(current => current != player)) return false;
|
||
//if(event.name=='logSkill'&&evt.skill!='starjiaowang') return false;
|
||
return event.name != "phase" || game.phaseNumber == 0;
|
||
},
|
||
forced: true,
|
||
async content(event, trigger, player) {
|
||
let targets = game.filterPlayer(current => current != player);
|
||
player.line(targets);
|
||
for (const target of targets) await target.damage("fire");
|
||
targets = targets.filter(i => i.isIn());
|
||
if (targets.length) {
|
||
for (const target of targets) {
|
||
if (!target.countCards("he")) continue;
|
||
const {
|
||
result: { bool },
|
||
} = await target
|
||
.chooseToGive("he", player)
|
||
.set("prompt", "是否交给" + get.translation(player) + "一张牌" + (target.isDamaged() ? "并回复1点体力" : "") + "？")
|
||
.set("ai", card => {
|
||
const target = get.event("player"),
|
||
player = get.event("target");
|
||
const att = get.attitude(target, player);
|
||
if (get.recoverEffect(target, target, target) <= 0) {
|
||
if (att <= 0) return -get.value(card);
|
||
return 0;
|
||
}
|
||
return 7 - get.value(card);
|
||
})
|
||
.set("target", player);
|
||
if (bool) await target.recover();
|
||
}
|
||
}
|
||
},
|
||
},
|
||
starzongshi: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
filter(event, player) {
|
||
const cards = player.getCards("h", card => {
|
||
const type = get.type(card, player);
|
||
if (type != "basic" && type != "trick") return false;
|
||
return (
|
||
lib.filter.cardUsable(card, player) &&
|
||
game.hasPlayer(target => {
|
||
return lib.filter.targetEnabled2(card, player, target) /*&&lib.filter.targetInRange(card,player,target)*/;
|
||
})
|
||
);
|
||
});
|
||
if (!cards.length) return false;
|
||
return cards.some(card => {
|
||
const cardss = player.getCards("h", cardx => card != cardx && get.suit(card, player) == get.suit(cardx, player));
|
||
return cardss.length && !cardss.some(cardx => !game.checkMod(cardx, player, "unchanged", "cardEnabled2", player));
|
||
});
|
||
},
|
||
filterCard(card, player) {
|
||
if (ui.selected.cards.length) return false;
|
||
const cards = player.getCards("h", card => {
|
||
const type = get.type(card, player);
|
||
if (type != "basic" && type != "trick") return false;
|
||
return (
|
||
lib.filter.cardUsable(card, player) &&
|
||
game.hasPlayer(target => {
|
||
return lib.filter.targetEnabled2(card, player, target) /*&&lib.filter.targetInRange(card,player,target)*/;
|
||
})
|
||
);
|
||
});
|
||
if (!cards.includes(card)) return false;
|
||
const cardss = player.getCards("h", cardx => card != cardx && get.suit(card, player) == get.suit(cardx, player));
|
||
return cardss.length && !cardss.some(cardx => !game.checkMod(cardx, player, "unchanged", "cardEnabled2", player));
|
||
},
|
||
selectCard: [1, 2],
|
||
complexCard: true,
|
||
check(card) {
|
||
const player = get.event("player"),
|
||
select = get.copy(get.info(card).selectTarget);
|
||
let range;
|
||
if (select == undefined) range = [1, 1];
|
||
else if (typeof select == "number") range = [select, select];
|
||
else if (get.itemtype(select) == "select") range = select;
|
||
else if (typeof select == "function") range = select(card, player);
|
||
game.checkMod(card, player, range, "selectTarget", player);
|
||
const cards = player.getCards("h", cardx => card != cardx && get.suit(card, player) == get.suit(cardx, player));
|
||
let targets = game.filterPlayer(target => lib.filter.targetEnabled2(card, player, target) /*&&lib.filter.targetInRange(card,player,target)*/ && get.effect(target, card, player, player) > 0);
|
||
const max = range[1],
|
||
max2 = Math.min(cards.length, targets.length);
|
||
if (max > max2) return 0;
|
||
targets = targets.sort((a, b) => get.effect(b, card, player, player) - get.effect(a, card, player, player)).slice(0, max2);
|
||
const sum = targets.reduce((num, target) => num + get.effect(target, card, player, player), 0);
|
||
if (max == -1) {
|
||
if (
|
||
game
|
||
.filterPlayer(target => {
|
||
return lib.filter.targetEnabled2(card, player, target) /*&&lib.filter.targetInRange(card,player,target)*/;
|
||
})
|
||
.reduce((num, target) => num + get.effect(target, card, player, player), 0) > sum
|
||
)
|
||
return 0;
|
||
}
|
||
return sum;
|
||
},
|
||
position: "h",
|
||
discard: false,
|
||
lose: false,
|
||
delay: false,
|
||
async content(event, trigger, player) {
|
||
const card = event.cards[0],
|
||
cards = player.getCards("h", cardx => card != cardx && get.suit(card, player) == get.suit(cardx, player));
|
||
await player.showCards([card], get.translation(player) + "发动了【纵势】");
|
||
const cardx = new lib.element.VCard({
|
||
name: get.name(card, player),
|
||
nature: get.nature(card, player),
|
||
cards: cards,
|
||
});
|
||
const {
|
||
result: { bool, targets },
|
||
} = await player
|
||
.chooseTarget((card, player, target) => {
|
||
//return player.canUse(get.event('cardx'),target);
|
||
return lib.filter.targetEnabled2(get.event("cardx"), player, target) /*&&lib.filter.targetInRange(get.event('cardx'),player,target)*/;
|
||
}, true)
|
||
.set("cardx", cardx)
|
||
.set("selectTarget", [1, cards.length])
|
||
.set("prompt", "请选择" + (game.hasNature(cardx) ? get.translation(get.nature(cardx)) : "") + "【" + get.translation(cardx) + "】（" + get.translation(cards) + "）的目标")
|
||
.set("ai", target => {
|
||
const player = get.event("player"),
|
||
card = get.event("cardx");
|
||
return get.effect(target, card, player, player);
|
||
});
|
||
if (bool) player.useCard(cardx, cards, targets.sortBySeat());
|
||
},
|
||
ai: {
|
||
order: 9,
|
||
result: { player: 1 },
|
||
},
|
||
},
|
||
starjiaowang: {
|
||
audio: 2,
|
||
trigger: { global: "roundStart" },
|
||
filter(event, player) {
|
||
if (game.roundNumber <= 1) return false;
|
||
const history = game.getAllGlobalHistory();
|
||
for (let i = history.length - 2; i >= 0; i--) {
|
||
const evt = history[i]["everything"];
|
||
for (let j = evt.length - 1; j >= 0; j--) {
|
||
if (evt[j].name == "die" && evt[j].getParent(3).name != "starxiaoyan") return false;
|
||
}
|
||
if (history[i].isRound) break;
|
||
}
|
||
return true;
|
||
},
|
||
forced: true,
|
||
async content(event, trigger, player) {
|
||
await player.loseHp();
|
||
if (game.hasPlayer(current => current != player)) player.useResult({ skill: "starxiaoyan" }, event);
|
||
},
|
||
},
|
||
staraoshi: {
|
||
audio: 2,
|
||
zhuSkill: true,
|
||
global: "staraoshi_global",
|
||
subSkill: {
|
||
global: {
|
||
audio: "staraoshi",
|
||
forceaudio: true,
|
||
enable: "phaseUse",
|
||
filter(event, player) {
|
||
return player.group == "qun" && game.hasPlayer(target => lib.skill.staraoshi.subSkill.global.filterTarget(null, player, target));
|
||
},
|
||
filterTarget(card, player, target) {
|
||
return target != player && target.hasZhuSkill("staraoshi");
|
||
},
|
||
prompt() {
|
||
const player = get.event("player");
|
||
const targets = game.filterPlayer(target => lib.skill.staraoshi.subSkill.global.filterTarget(null, player, target));
|
||
return "交给" + get.translation(targets) + (targets.length > 1 ? "中的一人" : "") + "一张手牌，然后其可以发动一次【纵势】";
|
||
},
|
||
filterCard: true,
|
||
check(card) {
|
||
const player = get.event("player");
|
||
const target = game
|
||
.filterPlayer(target => {
|
||
return lib.skill.staraoshi.subSkill.global.filterTarget(null, player, target);
|
||
})
|
||
.sort((a, b) => b.countCards("h") - a.countCards("h"))[0];
|
||
return target.getUseValue(card);
|
||
},
|
||
discard: false,
|
||
lose: false,
|
||
delay: false,
|
||
usable: 1,
|
||
async content(event, trigger, player) {
|
||
const target = event.target,
|
||
info = get.info("starzongshi");
|
||
await player.give(event.cards, target);
|
||
const {
|
||
result: { bool, cards },
|
||
} = await target
|
||
.chooseCard(info.position, (card, player) => {
|
||
return get.event("info").filterCard(card, player);
|
||
})
|
||
.set("info", info)
|
||
.set("ai", card => get.event("info").check(card))
|
||
.set("selectCard", [1, 2])
|
||
.set("complexCard", true)
|
||
.set("prompt", get.prompt("starzongshi"))
|
||
.set("prompt2", lib.translate.starzongshi_info.slice(8).slice(0, -1));
|
||
if (bool) target.useResult({ skill: "starzongshi", cards: cards }, event);
|
||
},
|
||
ai: {
|
||
order: 9,
|
||
result: {
|
||
target(player, target) {
|
||
return target.countCards("h") + 1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//星董卓
|
||
starweilin: {
|
||
audio: 2,
|
||
trigger: { source: "damageBegin1" },
|
||
filter: function (event, player) {
|
||
return !event.player.getHistory("damage").length && player.getHistory("useCard").length >= event.player.getHp();
|
||
},
|
||
forced: true,
|
||
logTarget: "player",
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
},
|
||
starzhangrong: {
|
||
audio: 2,
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
filter: function (event, player) {
|
||
return player.getHp() > 0;
|
||
},
|
||
direct: true,
|
||
content: function* (event, map) {
|
||
var player = map.player;
|
||
var str = get.cnNumber(player.getHp());
|
||
var choiceList = ["令至多" + str + "名体力值大于等于你的角色各失去1点体力", "令至多" + str + "名手牌数大于等于你的角色各弃置一张手牌"],
|
||
list = ["cancel2"];
|
||
if (
|
||
game.hasPlayer(target => {
|
||
if (target == player) return player.countCards("h", card => lib.filter.cardDiscardable(card, player));
|
||
return target.countCards("h") >= Math.max(1, player.countCards("h"));
|
||
})
|
||
)
|
||
list.unshift("弃牌");
|
||
else choiceList[1] = '<span style="opacity:0.5">' + choiceList[1] + "</span>";
|
||
list.unshift("扣血");
|
||
var result = yield player
|
||
.chooseControl(list)
|
||
.set("prompt", "###" + get.prompt("starzhangrong") + "###选择其中一项令任意名符合条件的角色执行，然后你摸等量的牌，回合结束时，若这些角色中有本回合未受到过伤害的角色，则你失去1点体力")
|
||
.set("ai", () => {
|
||
var player = _status.event.player;
|
||
var controls = _status.event.controls.slice();
|
||
/*
|
||
var cards=player.getCards('hes',card=>get.tag(card,'damage')&&player.hasValueTarget(card));
|
||
var cardx=cards.filter(card=>get.name(card)=='sha');
|
||
cardx.sort((a,b)=>player.getUseValue(b)-player.getUseValue(a));
|
||
cardx=cardx.slice(Math.min(cardx.length,player.getCardUsable('sha')),cardx.length);
|
||
cards.removeArray(cardx);
|
||
*/
|
||
var targets1 = game.filterPlayer(target => get.attitude(player, target) < 0 && target.getHp() >= player.getHp() && get.effect(target, { name: "losehp" }, player, player) > 0 /*&&cards.some(card=>player.canUse(card,target))*/);
|
||
_status.starzhangrong_check = true;
|
||
var targets2 = game.filterPlayer(target => get.attitude(player, target) < 0 && target.countCards("h") >= Math.max(1, player.countCards("h")) && get.effect(target, { name: "guohe_copy2" }, player, player) > 0 /*&&cards.some(card=>player.canUse(card,target))*/);
|
||
delete _status.starzhangrong_check;
|
||
[targets1, targets2].forEach(list => {
|
||
list.sort((a, b) => get.damageEffect(b) - get.damageEffect(a));
|
||
list = list.slice(0, Math.min(player.getHp() /*,cards.length*/));
|
||
});
|
||
if (!controls.includes("弃牌")) return 1 - get.sgn(targets1.length);
|
||
return Math.max(0, get.sgn(targets2.length - targets1.length));
|
||
})
|
||
.set("choiceList", choiceList);
|
||
if (result.control != "cancel2") {
|
||
var choice = result.index;
|
||
var result2 = yield player
|
||
.chooseTarget([1, player.getHp()], "请选择【掌戎】的目标", "令至多" + str + "名" + (choice ? "手牌数" : "体力值") + "大于你的角色各" + (choice ? "弃置一张手牌" : "失去1点体力"), (card, player, target) => {
|
||
var name = _status.event.card.name;
|
||
if (name == "guohe_copy2") {
|
||
if (target == player) return player.countCards("h", card => lib.filter.cardDiscardable(card, player));
|
||
return target.countCards("h") >= Math.max(1, player.countCards("h"));
|
||
}
|
||
return target.getHp() >= player.getHp();
|
||
})
|
||
.set("ai", target => {
|
||
var player = _status.event.player;
|
||
if (get.attitude(player, target) >= 0) return 0;
|
||
return get.effect(target, _status.event.card, player, player);
|
||
})
|
||
.set("card", { name: choice ? "guohe_copy2" : "losehp" });
|
||
if (result2.bool) {
|
||
var targets = result2.targets.sortBySeat();
|
||
player.logSkill("starzhangrong", targets);
|
||
targets.forEach(target => {
|
||
target.addTempSkill("starzhangrong_threaten");
|
||
if (choice) target.chooseToDiscard("h", true);
|
||
else target.loseHp();
|
||
});
|
||
player.draw(targets.length);
|
||
player
|
||
.when("phaseEnd")
|
||
.then(() => {
|
||
targets.forEach(target => target.removeSkill("starzhangrong_threaten"));
|
||
var targetx = targets.filter(target => !target.getHistory("damage").length);
|
||
if (targetx.length) {
|
||
targetx.forEach(target => target.chat("乐"));
|
||
player.popup("杯具");
|
||
player.loseHp();
|
||
return;
|
||
}
|
||
player.popup("洗具");
|
||
})
|
||
.vars({ targets: targets });
|
||
}
|
||
}
|
||
},
|
||
global: "starzhangrong_check",
|
||
subSkill: {
|
||
check: {
|
||
mod: {
|
||
canBeDiscarded: function (card, player, target) {
|
||
if (!_status.starzhangrong_check) return;
|
||
if (player.hasSkill("starzhangrong") && get.position(card) != "h") return false;
|
||
},
|
||
},
|
||
},
|
||
threaten: {
|
||
charlotte: true,
|
||
trigger: { player: "damageEnd" },
|
||
firstDo: true,
|
||
forced: true,
|
||
popup: false,
|
||
content: function () {
|
||
player.removeSkill("starzhangrong_threaten");
|
||
},
|
||
ai: { threaten: 114514 + 1919810 },
|
||
mark: true,
|
||
markimage: "image/card/sha.png",
|
||
intro: { content: "我还没受到伤害哟！" },
|
||
},
|
||
},
|
||
},
|
||
starhaoshou: {
|
||
unique: true,
|
||
audio: 2,
|
||
trigger: { global: "useCardAfter" },
|
||
filter: function (event, player) {
|
||
return event.player != player && event.card.name == "jiu" && player.isDamaged() && event.player.group == "qun";
|
||
},
|
||
direct: true,
|
||
zhuSkill: true,
|
||
content: function* (event, map) {
|
||
var player = map.player,
|
||
target = map.trigger.player;
|
||
var result = yield target.chooseBool(get.prompt("starhaoshou", player), "令" + get.translation(player) + "回复1点体力").set("choice", get.recoverEffect(player, target, target) > 0);
|
||
if (result.bool) {
|
||
target.line(player);
|
||
player.logSkill("starhaoshou");
|
||
player.recover();
|
||
}
|
||
},
|
||
//global:'starhaoshou_global',
|
||
subSkill: {
|
||
global: {
|
||
audio: "starhaoshou",
|
||
forceaudio: true,
|
||
filter: function (event, player) {
|
||
if (
|
||
!player.countCards("hes", card => {
|
||
if (get.position(card) == "h" && _status.connectMode) return true;
|
||
return get.name(card) == "jiu";
|
||
})
|
||
)
|
||
return false;
|
||
return event.type == "dying" && event.dying && event.dying != player && event.dying.hp <= 0 && event.dying.hasZhuSkill("starhaoshou") && player.group == "qun";
|
||
},
|
||
filterCard: function (card, player) {
|
||
return get.name(card) == "jiu";
|
||
},
|
||
check: () => 1,
|
||
viewAs: { name: "tao" },
|
||
position: "hes",
|
||
prompt: function () {
|
||
return "将一张【酒】当作【桃】对" + get.translation(_status.event.dying) + "使用";
|
||
},
|
||
ai: {
|
||
save: true,
|
||
skillTagFilter: function (player, arg, target) {
|
||
if (
|
||
!player.countCards("hes", card => {
|
||
if (get.position(card) == "h" && _status.connectMode) return true;
|
||
return get.name(card) == "jiu";
|
||
}) ||
|
||
player == target ||
|
||
!target.hasSkill("starhaoshou") ||
|
||
player.group != "qun"
|
||
)
|
||
return false;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//星袁术
|
||
starcanxi: {
|
||
audio: 2,
|
||
trigger: {
|
||
global: ["phaseBefore", "roundStart"],
|
||
player: "enterGame",
|
||
},
|
||
filter: function (event, player, name) {
|
||
if (name == "roundStart") return player.getSkills().some(skill => skill.indexOf("starcanxi_") == 0);
|
||
return event.name != "phase" || game.phaseNumber == 0;
|
||
},
|
||
forced: true,
|
||
content: function () {
|
||
"step 0";
|
||
if (event.triggername != "roundStart") {
|
||
var list = game.filterPlayer().reduce((list, target) => list.add(target.group), []);
|
||
list.sort((a, b) => lib.group.indexOf(a) - lib.group.indexOf(b));
|
||
list.forEach(group => lib.skill.starcanxi.create(group, player));
|
||
event.finish();
|
||
return;
|
||
}
|
||
"step 1";
|
||
var groups = player.getSkills().filter(skill => skill.indexOf("starcanxi_") == 0);
|
||
groups = groups.map(group => group.slice(10));
|
||
groups.sort((a, b) => lib.group.indexOf(a) - lib.group.indexOf(b));
|
||
var map = {};
|
||
groups.forEach(group => (map[group] = get.translation(group + "2")));
|
||
event.map = map;
|
||
player
|
||
.chooseButton(
|
||
[
|
||
'###残玺###<div class="text center">请选择势力和效果</div>',
|
||
[Object.values(map), "tdnodes"],
|
||
[
|
||
[
|
||
["wangsheng", '<div class="popup text" style="width:calc(100% - 10px);display:inline-block"><div class="skill">【妄生】</div><div>被选择势力角色每回合首次造成的伤害+1且计算与其他角色间的距离-1</div></div>'],
|
||
["xiangsi", '<div class="popup text" style="width:calc(100% - 10px);display:inline-block"><div class="skill">【向死】</div><div>其他被选择势力角色每回合首次回复体力后失去1点体力且每回合对你使用的第一张牌无效</div></div>'],
|
||
],
|
||
"textbutton",
|
||
],
|
||
],
|
||
2,
|
||
true
|
||
)
|
||
.set("filterButton", function (button) {
|
||
var list = ["wangsheng", "xiangsi"];
|
||
if (!ui.selected.buttons.length) return true;
|
||
return list.includes(ui.selected.buttons[0].link) != list.includes(button.link);
|
||
})
|
||
.set("ai", function (button) {
|
||
var player = _status.event.player;
|
||
var map = _status.event.map,
|
||
list = ["wangsheng", "xiangsi"];
|
||
var getNum = function (group, effect) {
|
||
var num = 0,
|
||
sgn = effect == "wangsheng" ? 1.05 : -1;
|
||
game.countPlayer(function (current) {
|
||
if (!(current == player && sgn == -1)) num += get.sgn(get.attitude(player, current)) * sgn;
|
||
});
|
||
return num;
|
||
};
|
||
var listx = [];
|
||
Object.keys(map).forEach(group => list.forEach(effect => listx.add([group, effect])));
|
||
listx.sort((a, b) => getNum(b[0], b[1]) - getNum(a[0], a[1]));
|
||
if (button.link == map[listx[0][0]] || button.link == listx[0][1]) return 1;
|
||
return 0;
|
||
})
|
||
.set("map", map);
|
||
"step 2";
|
||
if (result.bool) {
|
||
if (!Object.keys(event.map).some(group => event.map[group] == result.links[0])) result.links.reverse();
|
||
player.popup(result.links[0]);
|
||
var group = Object.keys(event.map).find(group => event.map[group] == result.links[0]);
|
||
var skill = "starcanxi_" + result.links[1];
|
||
player.popup(skill);
|
||
game.log(player, "选择了", "#g" + result.links[0], "、", "#y" + get.translation(skill));
|
||
player.addTempSkill(skill, "roundStart");
|
||
player.markAuto(skill, [group]);
|
||
}
|
||
},
|
||
create: function (group, player) {
|
||
const skill = "starcanxi_" + group;
|
||
get.info("starcanxi").createSkill(skill);
|
||
if (!_status.postReconnect.starcanxi) {
|
||
_status.postReconnect.starcanxi = [get.info("starcanxi").createSkill, []];
|
||
}
|
||
_status.postReconnect.starcanxi[1].add(skill);
|
||
player.addSkill(skill);
|
||
},
|
||
createSkill(skill) {
|
||
if (!lib.skill[skill])
|
||
game.broadcastAll(skill => {
|
||
const group = skill.slice("starcanxi_".length);
|
||
lib.skill[skill] = {
|
||
mark: true,
|
||
charlotte: true,
|
||
onremove: function (player) {
|
||
player.addMark("starpizhi", 1, false);
|
||
},
|
||
intro: { content: "玉玺的一角" },
|
||
};
|
||
lib.translate[skill] = "残玺·" + get.translation(group + "2");
|
||
lib.skill[skill].marktext = get.translation(group);
|
||
lib.translate[skill + "_bg"] = get.translation(group);
|
||
}, skill);
|
||
},
|
||
subSkill: {
|
||
wangsheng: {
|
||
charlotte: true,
|
||
onremove: true,
|
||
trigger: { global: "damageBegin1" },
|
||
filter: function (event, player) {
|
||
if (!event.source || !player.getStorage("starcanxi_wangsheng").includes(event.source.group)) return false;
|
||
return !event.source.getHistory("sourceDamage").length;
|
||
},
|
||
forced: true,
|
||
logTarget: "source",
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
group: "starcanxi_remove",
|
||
global: "starcanxi_effect",
|
||
intro: { content: "$势力角色每回合首次造成的伤害+1且计算与其他角色间的距离-1" },
|
||
},
|
||
xiangsi: {
|
||
charlotte: true,
|
||
onremove: true,
|
||
trigger: { global: "recoverEnd" },
|
||
filter: function (event, player) {
|
||
if (!player.getStorage("starcanxi_xiangsi").includes(event.player.group) || event.player == player) return false;
|
||
return (
|
||
game.getGlobalHistory("changeHp", function (evt) {
|
||
return evt.getParent().name == "recover" && evt.player == event.player;
|
||
}).length == 1
|
||
);
|
||
},
|
||
forced: true,
|
||
logTarget: "player",
|
||
content: function () {
|
||
trigger.player.loseHp();
|
||
},
|
||
group: ["starcanxi_remove", "starcanxi_cancel"],
|
||
global: "starcanxi_effect",
|
||
intro: {
|
||
content: "其他$势力角色每回合首次回复体力后失去1点体力且每回合对你使用的第一张牌无效",
|
||
},
|
||
},
|
||
cancel: {
|
||
charlotte: true,
|
||
trigger: { global: "useCard" },
|
||
filter: function (event, player) {
|
||
if (!event.targets || !event.targets.includes(player) || !player.getStorage("starcanxi_xiangsi").includes(event.player.group) || event.player == player) return false;
|
||
return event.player.getHistory("useCard", evt => evt.targets && evt.targets.includes(player)).indexOf(event) == 0;
|
||
},
|
||
forced: true,
|
||
logTarget: "player",
|
||
content: function () {
|
||
trigger.excluded.add(player);
|
||
},
|
||
},
|
||
effect: {
|
||
mod: {
|
||
globalFrom: function (from, to, distance) {
|
||
if (game.hasPlayer(target => target.getStorage("starcanxi_wangsheng").includes(from.group))) return distance - 1;
|
||
},
|
||
},
|
||
ai: {
|
||
effect: {
|
||
player_use: function (card, player, target) {
|
||
var targets = game.filterPlayer(targetx => targetx != player && targetx.getStorage("starcanxi_xiangsi").includes(player.group));
|
||
if (!targets.length) return;
|
||
if (get.tag(card, "recover") && target == player && target.hp > 2) return 0;
|
||
if (get.tag(card, "damage") && targets.includes(target)) return 0.5;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
remove: {
|
||
charlotte: true,
|
||
trigger: { player: "die" },
|
||
forced: true,
|
||
popup: false,
|
||
firstDo: true,
|
||
forceDie: true,
|
||
content: function () {
|
||
player.removeSkill("starcanxi_wangsheng");
|
||
player.removeSkill("starcanxi_xiangsi");
|
||
},
|
||
},
|
||
},
|
||
},
|
||
starpizhi: {
|
||
audio: 2,
|
||
trigger: { player: "phaseEnd", global: "die" },
|
||
filter: function (event, player) {
|
||
if (event.name == "phase") return player.hasMark("starpizhi");
|
||
if (!player.getStorage("starcanxi_wangsheng").includes(event.player.group) && !player.getStorage("starcanxi_xiangsi").includes(event.player.group)) return false;
|
||
var groups = player.getSkills().filter(skill => skill.indexOf("starcanxi_") == 0);
|
||
groups = groups.map(group => group.slice(10));
|
||
return groups.includes(event.player.group);
|
||
},
|
||
forced: true,
|
||
content: function () {
|
||
"step 0";
|
||
if (trigger.name == "die") {
|
||
var skills = player.getSkills().filter(skill => skill.indexOf("starcanxi_") == 0 && skill.slice(10) == trigger.player.group);
|
||
player.removeSkill(skills);
|
||
}
|
||
"step 1";
|
||
player.draw(player.countMark("starpizhi"));
|
||
},
|
||
intro: { content: "已失去#个“玺角”" },
|
||
ai: { combo: "starcanxi" },
|
||
},
|
||
starzhonggu: {
|
||
unique: true,
|
||
audio: 2,
|
||
trigger: { player: "phaseDrawBegin2" },
|
||
filter: function (event, player) {
|
||
return !event.numFixed;
|
||
},
|
||
forced: true,
|
||
zhuSkill: true,
|
||
content: function () {
|
||
var num = game.roundNumber >= game.countPlayer(current => current.group == "qun") ? 2 : -1;
|
||
trigger.num += num;
|
||
},
|
||
},
|
||
//星曹仁
|
||
starsujun: {
|
||
audio: 2,
|
||
trigger: { player: "useCard" },
|
||
filter: function (event, player) {
|
||
return player.countCards("h", { type: "basic" }) * 2 == player.countCards("h");
|
||
},
|
||
frequent: true,
|
||
locked: false,
|
||
content: function () {
|
||
player.draw(2);
|
||
},
|
||
mod: {
|
||
aiOrder: function (player, card, num) {
|
||
var num = player.countCards("h") - 2 * player.countCards("h", { type: "basic" });
|
||
if (Math.abs(num) != 1) return;
|
||
if (num == 1 && get.type(card) != "basic") return num + 10;
|
||
if (num == -1 && get.type(card) == "basic") return num + 10;
|
||
},
|
||
},
|
||
},
|
||
starlifeng: {
|
||
audio: 2,
|
||
enable: "chooseToUse",
|
||
filter: function (event, player) {
|
||
if (!event.filterCard(get.autoViewAs({ name: "sha" }, "unsure"), player, event) && !event.filterCard(get.autoViewAs({ name: "wuxie" }, "unsure"), player, event)) return false;
|
||
return player.hasCard(card => {
|
||
return !player.getStorage("starlifeng_count").includes(get.color(card, player));
|
||
}, "hs");
|
||
},
|
||
chooseButton: {
|
||
dialog: function (event, player) {
|
||
var list = [];
|
||
if (event.filterCard(get.autoViewAs({ name: "sha" }, "unsure"), player, event)) list.push(["基本", "", "sha"]);
|
||
if (event.filterCard(get.autoViewAs({ name: "wuxie" }, "unsure"), player, event)) list.push(["锦囊", "", "wuxie"]);
|
||
return ui.create.dialog("砺锋", [list, "vcard"]);
|
||
},
|
||
check: function (button) {
|
||
var player = _status.event.player;
|
||
return _status.event.getParent().type == "phase" ? player.getUseValue({ name: button.link[2] }) : 1;
|
||
},
|
||
backup: function (links, player) {
|
||
return {
|
||
filterCard: function (card, player) {
|
||
return !player.getStorage("starlifeng_count").includes(get.color(card, player));
|
||
},
|
||
precontent: function () {
|
||
delete event.result.skill;
|
||
player.logSkill("starlifeng");
|
||
event.getParent().addCount = false;
|
||
},
|
||
popname: true,
|
||
viewAs: {
|
||
name: links[0][2],
|
||
},
|
||
ai1: function (card) {
|
||
var player = _status.event.player;
|
||
var num = player.countCards("h") - 2 * player.countCards("h", { type: "basic" });
|
||
if (player.hasSkill("starsujin") && Math.abs(num) == 1) {
|
||
if (num == 1 && get.type(card) != "basic") return 15 - get.value(card);
|
||
if (num == -1 && get.type(card) == "basic") return 15 - get.value(card);
|
||
}
|
||
return 7 - get.value(card);
|
||
},
|
||
};
|
||
},
|
||
prompt: function (links) {
|
||
return "将一张本回合未使用过的颜色的手牌当做【" + get.translation(links[0][2]) + "】使用";
|
||
},
|
||
},
|
||
hiddenCard: function (player, name) {
|
||
if (name == "wuxie")
|
||
return player.countCards("hs", card => {
|
||
return !player.getStorage("starlifeng_count").includes(get.color(card, player)) || _status.connectMode;
|
||
});
|
||
},
|
||
ai: {
|
||
respondSha: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
if (arg == "respond") return false;
|
||
if (
|
||
!player.countCards("hs", card => {
|
||
return !player.getStorage("starlifeng_count").includes(get.color(card, player)) || _status.connectMode;
|
||
})
|
||
)
|
||
return false;
|
||
},
|
||
order: 10,
|
||
result: { player: 1 },
|
||
},
|
||
group: "starlifeng_mark",
|
||
subSkill: {
|
||
mark: {
|
||
charlotte: true,
|
||
trigger: { global: "useCard1" },
|
||
filter: function (event, player) {
|
||
return !player.getStorage("starlifeng_count").includes(get.color(event.card));
|
||
},
|
||
forced: true,
|
||
popup: false,
|
||
firstDo: true,
|
||
content: function () {
|
||
player.addTempSkill("starlifeng_count");
|
||
player.markAuto("starlifeng_count", [get.color(trigger.card)]);
|
||
},
|
||
},
|
||
count: {
|
||
charlotte: true,
|
||
onremove: true,
|
||
},
|
||
},
|
||
},
|
||
//小程序刘伶
|
||
mpjiusong: {
|
||
audio: 2,
|
||
enable: "chooseToUse",
|
||
trigger: { global: "useCard" },
|
||
filterCard: function (card) {
|
||
return get.type2(card) == "trick";
|
||
},
|
||
viewAs: { name: "jiu" },
|
||
position: "hs",
|
||
viewAsFilter: function (player) {
|
||
return player.hasCard(card => get.type2(card) == "trick", "hs");
|
||
},
|
||
check: function (card) {
|
||
if (get.itemtype(card) !== "card") return true;
|
||
if (get.event().type == "dying") return 1 / Math.max(0.1, get.value(card));
|
||
return 4 - get.value(card);
|
||
},
|
||
prompt: "将一张锦囊牌当【酒】使用",
|
||
filter: function (event, player) {
|
||
if (event.name == "chooseToUse") return player.hasCard(card => get.type2(card) == "trick", "hs");
|
||
return event.card.name == "jiu" && player.countMark("mpjiusong") < 3;
|
||
},
|
||
forced: true,
|
||
locked: false,
|
||
content: function () {
|
||
player.addMark("mpjiusong");
|
||
},
|
||
marktext: "醉",
|
||
intro: {
|
||
name: "醉(酒颂/酕醄)",
|
||
name2: "醉",
|
||
content: "mark",
|
||
},
|
||
},
|
||
mpmaotao: {
|
||
audio: 2,
|
||
trigger: { global: "useCardToPlayer" },
|
||
filter: function (event, player) {
|
||
if (event.targets.length != 1 || !event.isFirstTarget) return false;
|
||
if (!["basic", "trick"].includes(get.type(event.card))) return false;
|
||
return event.player != player && player.countMark("mpjiusong");
|
||
},
|
||
prompt2: function (event, player) {
|
||
let list;
|
||
if (get.type(event.card) != "delay")
|
||
list = game.filterPlayer(current => {
|
||
return lib.filter.targetEnabled2(event.card, event.player, current);
|
||
});
|
||
else list = game.filterPlayer(current => current.canAddJudge(event.card));
|
||
const gainText = `${list.length > 1 && !player.storage.mpmaotao_gained ? `若新目标与原目标相同，你` : ""}${!player.storage.mpmaotao_gained ? "获得牌堆中的一张锦囊牌。" : ""}`;
|
||
return `移去1枚“醉”${list.length > 1 ? `，令${get.translation(event.card)}目标改为${get.translation(list)}中的一名随机角色` : ""}。${gainText}`;
|
||
},
|
||
check: function (event, player) {
|
||
const eff = get.effect(event.target, event.card, player, player);
|
||
let list;
|
||
if (get.type(event.card) != "delay")
|
||
list = game.filterPlayer(current => {
|
||
return lib.filter.targetEnabled2(event.card, event.player, current);
|
||
});
|
||
else list = game.filterPlayer(current => current.canAddJudge(event.card));
|
||
let list2 = list.filter(current => get.effect(current, event.card, player, player) > eff);
|
||
let list3 = list.filter(current => get.effect(current, event.card, player, player) > 0);
|
||
return list2.length >= list.length / 2 || (player.countMark("mpjiusong") >= 2 && list3.length >= list.length / 2);
|
||
},
|
||
content: function () {
|
||
player.removeMark("mpjiusong", 1);
|
||
var list,
|
||
oriTarget = trigger.target;
|
||
trigger.targets.remove(oriTarget);
|
||
trigger.getParent().triggeredTargets1.remove(oriTarget);
|
||
trigger.untrigger();
|
||
game.delayx();
|
||
if (get.type(trigger.card) != "delay")
|
||
list = game.filterPlayer(current => {
|
||
return lib.filter.targetEnabled2(trigger.card, trigger.player, current);
|
||
});
|
||
else list = game.filterPlayer(current => current.canAddJudge(trigger.card));
|
||
if (list.length) target = list.randomGet();
|
||
trigger.targets.push(target);
|
||
trigger.player.line(target, "thunder");
|
||
game.log(trigger.card, "的目标被改为", target);
|
||
if (target == oriTarget && !player.storage.mpmaotao_gained) {
|
||
var card = get.cardPile2(card => get.type2(card) == "trick");
|
||
if (card) {
|
||
if (!player.storage.mpmaotao_gained) {
|
||
player.when({ global: "phaseAfter" }).then(() => {
|
||
delete player.storage.mpmaotao_gained;
|
||
});
|
||
player.storage.mpmaotao_gained = true;
|
||
}
|
||
player.gain(card, "gain2");
|
||
} else {
|
||
// player.chat('没酒了！');
|
||
// game.log('但是牌堆中已经没有','#y酒','了!');
|
||
player.chat("没牌了！");
|
||
game.log("但是牌堆中已经没有", "#y锦囊牌", "了!");
|
||
}
|
||
}
|
||
},
|
||
},
|
||
mpbishi: {
|
||
audio: 2,
|
||
forced: true,
|
||
trigger: { global: "useCard1" },
|
||
filter: function (event, player) {
|
||
if (get.type2(event.card) != "trick" || !get.tag(event.card, "damage")) return false;
|
||
if (!lib.skill.xunshi.isXunshi(event.card)) return false;
|
||
const targets = event.targets.slice();
|
||
targets.remove(event.player);
|
||
return targets.length == game.countPlayer() - 2;
|
||
},
|
||
content: function* () {},
|
||
mod: {
|
||
targetEnabled: function (card) {
|
||
if (get.type2(card) == "trick" && get.tag(card, "damage") > 0) return false;
|
||
},
|
||
},
|
||
},
|
||
//十周年嵇康
|
||
dcjuexiang: {
|
||
derivation: "dccanyun",
|
||
audio: "juexiang",
|
||
trigger: { player: "die" },
|
||
forced: true,
|
||
locked: false,
|
||
forceDie: true,
|
||
skillAnimation: true,
|
||
animationColor: "water",
|
||
content: function () {
|
||
"step 0";
|
||
if (trigger.source && trigger.source.isIn()) {
|
||
trigger.source.discard(trigger.source.getCards("e"));
|
||
trigger.source.loseHp();
|
||
}
|
||
"step 1";
|
||
player
|
||
.chooseTarget("绝响：是否令一名其他角色获得技能〖残韵〗？", lib.filter.notMe)
|
||
.set("ai", function (target) {
|
||
return get.attitude(_status.event.player, target);
|
||
})
|
||
.set("forceDie", true);
|
||
"step 2";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.line(target, "thunder");
|
||
target.addSkills("dccanyun");
|
||
}
|
||
},
|
||
},
|
||
dccanyun: {
|
||
enable: "phaseUse",
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(function (target) {
|
||
return lib.skill.dccanyun.filterTarget(null, player, target);
|
||
});
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
var list = [player];
|
||
player.getAllHistory("useSkill", function (evt) {
|
||
if (evt.skill == "dccanyun") list.addArray(evt.targets);
|
||
});
|
||
return !list.includes(target) && !ui.selected.targets.length;
|
||
},
|
||
selectTarget: [1, 2],
|
||
targetprompt: function (target) {
|
||
var pe = _status.event.player.countCards("e", function (card) {
|
||
return ui.selected.cards.includes(card) == false;
|
||
});
|
||
var te = target.countCards("e");
|
||
if (pe > te) return "回复体力";
|
||
else if (pe == te) return "摸一张牌";
|
||
else if (pe < te) return "失去体力";
|
||
},
|
||
filterCard: true,
|
||
position: "he",
|
||
check: function (cardx) {
|
||
var player = _status.event.player;
|
||
var number = game.countPlayer(function (target) {
|
||
if (player == target) return false;
|
||
var pe = player.countCards("e", function (card) {
|
||
return card != cardx && ui.selected.cards.includes(card) == false;
|
||
});
|
||
var te = target.countCards("e");
|
||
if (pe > te && target.isDamaged() && get.attitude(player, target) > 2) return true;
|
||
else if (pe < te && get.attitude(player, target) < 0) return true;
|
||
return false;
|
||
});
|
||
if (ui.selected.cards.length < number) return 6 - get.value(cardx);
|
||
else return 0;
|
||
},
|
||
usable: 1,
|
||
content: function () {
|
||
var pe = player.countCards("e");
|
||
var te = target.countCards("e");
|
||
if (pe > te) target.recover();
|
||
else if (pe == te) target.draw();
|
||
else if (pe < te) target.loseHp();
|
||
},
|
||
contentAfter: function () {
|
||
if (player.hp == 1) player.draw();
|
||
},
|
||
ai: {
|
||
order: 10,
|
||
result: {
|
||
target: function (player, target) {
|
||
var pe = player.countCards("e");
|
||
var te = target.countCards("e");
|
||
if (pe > te && target.isDamaged()) return 2;
|
||
else if (pe == te) return 1;
|
||
else if (pe < te) return -2.5;
|
||
else return 0;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//董翓
|
||
dcjiaoxia: {
|
||
mod: {
|
||
cardUsableTarget: function (card, player, target) {
|
||
if (!player.isPhaseUsing()) return;
|
||
if (card.name == "sha" && !player.getStorage("dcjiaoxia_mark").includes(target)) return true;
|
||
},
|
||
targetInRange: function (card, player, target) {
|
||
if (!player.isPhaseUsing()) return;
|
||
if (card.name == "sha" && !player.getStorage("dcjiaoxia_mark").includes(target)) return true;
|
||
},
|
||
},
|
||
audio: 2,
|
||
locked: false,
|
||
trigger: { player: "phaseUseBegin" },
|
||
filter: function (event, player) {
|
||
return player.countCards("h");
|
||
},
|
||
check: function (event, player) {
|
||
return player.countCards("h", card => {
|
||
return game.hasPlayer(target => {
|
||
var cardx = get.autoViewAs({ name: "sha" }, [card]);
|
||
return player.canUse(cardx, target) && get.effect(target, cardx, player, player) > 0 && (!player.hasUseTarget(card) || player.hasValueTarget(card));
|
||
});
|
||
});
|
||
},
|
||
content: function () {
|
||
var cards = player.getCards("h");
|
||
player.addTempSkill("dcjiaoxia_used", "phaseUseAfter");
|
||
player.addGaintag(cards, "dcjiaoxia_used");
|
||
},
|
||
group: "dcjiaoxia_load",
|
||
subSkill: {
|
||
load: {
|
||
charlotte: true,
|
||
trigger: { player: "useCard1" },
|
||
filter: function (event, player) {
|
||
if (!player.isPhaseUsing()) return false;
|
||
return event.card.name == "sha" && event.targets && event.targets.some(target => !player.getStorage("dcjiaoxia_mark").includes(target));
|
||
},
|
||
forced: true,
|
||
popup: false,
|
||
firstDo: true,
|
||
content: function () {
|
||
player.addTempSkill("dcjiaoxia_mark", "phaseUseAfter");
|
||
player.markAuto(
|
||
"dcjiaoxia_mark",
|
||
trigger.targets.filter(target => !player.getStorage("dcjiaoxia_mark").includes(target))
|
||
);
|
||
},
|
||
},
|
||
mark: {
|
||
charlotte: true,
|
||
onremove: true,
|
||
},
|
||
used: {
|
||
mod: {
|
||
aiOrder: function (player, card, num) {
|
||
if (get.itemtype(card) == "card" && card.hasGaintag("dcjiaoxia_used")) return num + 1;
|
||
},
|
||
cardname: function (card, player) {
|
||
if (get.itemtype(card) == "card" && card.hasGaintag("dcjiaoxia_used")) return "sha";
|
||
},
|
||
},
|
||
charlotte: true,
|
||
onremove: function (player) {
|
||
player.removeGaintag("dcjiaoxia_used");
|
||
},
|
||
trigger: { player: "useCardAfter" },
|
||
filter: function (event, player) {
|
||
return (
|
||
event.cards &&
|
||
event.cards.length == 1 &&
|
||
player.hasUseTarget(get.copy(event.cards[0])) &&
|
||
player.getHistory("lose", evt => {
|
||
if (evt.getParent() != event) return false;
|
||
for (var i in evt.gaintag_map) {
|
||
if (evt.gaintag_map[i].includes("dcjiaoxia_used")) return true;
|
||
}
|
||
return false;
|
||
}).length &&
|
||
player.getHistory("sourceDamage", evt => evt.card == event.card).length &&
|
||
player.hasUseTarget(event.cards[0])
|
||
);
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
player.chooseUseTarget(trigger.cards[0], get.prompt("dcjiaoxia"), false, false).set("prompt2", "使用" + get.translation(card)).logSkill = "dcjiaoxia";
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dchumei: {
|
||
subSkill: {
|
||
0: { charlotte: true },
|
||
1: { charlotte: true },
|
||
2: { charlotte: true },
|
||
},
|
||
onChooseToUse: function (event) {
|
||
if (!game.online && !event.dchumei_num) {
|
||
var player = event.player;
|
||
var evtx = event.getParent("phaseUse");
|
||
event.set(
|
||
"dchumei_num",
|
||
player
|
||
.getHistory("sourceDamage", evt => {
|
||
return evt.getParent("phaseUse") == evtx;
|
||
})
|
||
.reduce((sum, evt) => sum + evt.num, 0)
|
||
);
|
||
}
|
||
},
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
filter: function (event, player) {
|
||
if (typeof event.dchumei_num != "number") return false;
|
||
return game.hasPlayer(target => lib.skill.dchumei.filterTarget(null, player, target));
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
if (target.getHp() > _status.event.dchumei_num) return false;
|
||
if (!player.hasSkill("dchumei_0")) return true;
|
||
if (!player.hasSkill("dchumei_1") && target.countCards("he")) return true;
|
||
if (!player.hasSkill("dchumei_2") && target.isDamaged()) return true;
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var str = get.translation(target);
|
||
player
|
||
.chooseButton(
|
||
[
|
||
"狐魅：请选择一项",
|
||
[
|
||
[
|
||
[0, "令" + str + "摸一张牌"],
|
||
[1, "令" + str + "交给你一张牌"],
|
||
[2, "令" + str + "回复1点体力"],
|
||
].filter(list => {
|
||
if (player.hasSkill("dchumei_" + list[0])) return false;
|
||
if (list[0] == 1 && !target.countCards("he")) return false;
|
||
if (list[0] == 2 && target.isHealthy()) return false;
|
||
return true;
|
||
}),
|
||
"textbutton",
|
||
],
|
||
],
|
||
true
|
||
)
|
||
.set("filterButton", button => {
|
||
var target = _status.event.target;
|
||
if (player.hasSkill("dchumei_" + button.link)) return false;
|
||
if (button.link == 1 && !target.countCards("he")) return false;
|
||
if (button.link == 2 && target.isHealthy()) return false;
|
||
return true;
|
||
})
|
||
.set("ai", function (button) {
|
||
var target = _status.event.target;
|
||
return [get.effect(target, { name: "draw" }, player, player), get.effect(target, { name: "shunshou_copy2" }, player, player), get.recoverEffect(target, player, player)][button.link];
|
||
})
|
||
.set("target", target);
|
||
"step 1";
|
||
if (result.bool) {
|
||
var num = result.links[0];
|
||
player.addTempSkill("dchumei_" + num, "phaseUseAfter");
|
||
switch (num) {
|
||
case 0:
|
||
target.draw();
|
||
break;
|
||
case 1:
|
||
target.chooseCard("狐魅：交给" + get.translation(player) + "一张牌", "he", true);
|
||
break;
|
||
case 2:
|
||
target.recover();
|
||
break;
|
||
}
|
||
if (num != 1) event.finish();
|
||
} else event.finish();
|
||
"step 2";
|
||
if (result.bool) player.gain(result.cards, target, "giveAuto");
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
result: {
|
||
target: function (player, target) {
|
||
if (!player.hasSkill("dchumei_0")) return 1;
|
||
if (!player.hasSkill("dchumei_1")) return -1;
|
||
if (!player.hasSkill("dchumei_2")) return 1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//魏关羽
|
||
dcdanji: {
|
||
audio: "danji",
|
||
skillAnimation: true,
|
||
animationColor: "water",
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
forced: true,
|
||
juexingji: true,
|
||
derivation: ["mashu", "dcnuchen"],
|
||
filter(event, player) {
|
||
return player.countCards("hej") > player.getHp();
|
||
},
|
||
async content(event, trigger, player) {
|
||
player.awakenSkill("dcdanji");
|
||
await player.loseMaxHp();
|
||
await player.recover(player.maxHp - player.hp);
|
||
await player.draw(player.getHp());
|
||
await player.addSkills(["mashu", "dcnuchen"]);
|
||
},
|
||
ai: {
|
||
maixie: true,
|
||
skillTagFilter: (player, tag, arg) => {
|
||
if (tag === "maixie") return player.hp >= 2 && !player.storage.dcdanji && !player.hasSkill("dcnuchen") && player.countCards("h") === player.hp;
|
||
},
|
||
effect: {
|
||
target: (card, player, target) => {
|
||
let hs = target.countCards("h");
|
||
if (target.hp < 3 || target.storage.dcdanji || target.hasSkill("dcnuchen") || hs > target.hp + 1) return;
|
||
if (get.tag(card, "draw")) return 1.6;
|
||
if (get.tag(card, "lose") || get.tag(card, "discard")) return [1, -0.8];
|
||
if (hs === target.hp && get.tag(card, "damage")) return [1, target.hp / 3];
|
||
if (hs > target.hp && target.hp > 3 && (card.name === "shan" || card.name === "wuxie")) return "zeroplayertarget";
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dcnuchen: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: function (card, player, target) {
|
||
return target.countCards("h") && target != player;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.choosePlayerCard(target, true, "h");
|
||
"step 1";
|
||
if (result.bool) {
|
||
var card = result.cards[0];
|
||
event.card = card;
|
||
player.showCards(card, get.translation(player) + "对" + get.translation(target) + "发动了【怒嗔】");
|
||
} else event.finish();
|
||
"step 2";
|
||
var suit = get.suit(card);
|
||
var str = get.translation(suit);
|
||
player
|
||
.chooseToDiscard("怒嗔：是否弃置至少一张" + str + "牌？", "若如此做，你对其造成等量伤害；或点击“取消”，获得其所有" + str + "手牌", "he", { suit: suit }, [1, Infinity])
|
||
.set("ai", card => {
|
||
if (ui.selected.cards.length >= _status.event.num) return 0;
|
||
return 6 - get.value(card);
|
||
})
|
||
.set(
|
||
"num",
|
||
(function () {
|
||
var eff = get.damageEffect(target, player, player);
|
||
if (eff > 0) {
|
||
if (get.attitude(player, target) > 0) {
|
||
return 1;
|
||
}
|
||
var cards = target.getCards("h", { suit: suit });
|
||
if (cards.length > 2 || get.value(cards) >= 6) {
|
||
return 0;
|
||
}
|
||
if (!player.hasSkillTag("jueqing", false, target) && target.hasSkillTag("filterDamage", null, { player: player })) return 1;
|
||
return Infinity;
|
||
}
|
||
return 0;
|
||
})()
|
||
);
|
||
"step 3";
|
||
if (result.bool) {
|
||
target.damage(result.cards.length);
|
||
} else {
|
||
var cards = target.getCards("h", { suit: get.suit(card) });
|
||
if (cards.length) player.gain(cards, target, "giveAuto", "bySelf");
|
||
}
|
||
},
|
||
ai: {
|
||
expose: 0.4,
|
||
order: 10,
|
||
result: {
|
||
target: function (player, target) {
|
||
return -Math.sqrt(target.countCards("h"));
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//孟达
|
||
dclibang: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterCard: true,
|
||
position: "he",
|
||
filter: function (event, player) {
|
||
return (
|
||
player.hasCard(function (card) {
|
||
return lib.filter.cardDiscardable(card, player, "dclibang");
|
||
}, "he") && game.countPlayer(current => current != player) >= 2
|
||
);
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target != player;
|
||
},
|
||
selectTarget: 2,
|
||
multiline: true,
|
||
multitarget: true,
|
||
content: function () {
|
||
"step 0";
|
||
event.num = 0;
|
||
event.cardsx = [];
|
||
event.targets.sortBySeat();
|
||
"step 1";
|
||
var current = targets[event.num];
|
||
if (current.countCards("he")) player.gainPlayerCard(current, "he", true, "visibleMove");
|
||
event.num++;
|
||
"step 2";
|
||
if (result.bool) {
|
||
var card = result.cards[0];
|
||
event.cardsx.push(card);
|
||
}
|
||
if (event.num < targets.length) event.goto(1);
|
||
"step 3";
|
||
player.judge().set("callback", lib.skill.dclibang.contentx);
|
||
},
|
||
contentx: function () {
|
||
"step 0";
|
||
var card = event.judgeResult.card;
|
||
var color = event.judgeResult.color;
|
||
var player = event.getParent(2).player;
|
||
var cards = event.getParent(2).cardsx;
|
||
for (var cardx of cards) {
|
||
if (get.color(cardx) == color) {
|
||
if (get.position(card, true) == "o") player.gain(card, "gain2");
|
||
return;
|
||
}
|
||
}
|
||
event.goto(3);
|
||
"step 1";
|
||
var targets = event.getParent(2).targets.filter(target => {
|
||
return player.canUse("sha", target);
|
||
});
|
||
if (!targets.length) event.finish();
|
||
else
|
||
player
|
||
.chooseTarget("利傍：视为对其中一名角色使用一张【杀】", true, (card, player, target) => {
|
||
return _status.event.targets.includes(target);
|
||
})
|
||
.set("targets", targets)
|
||
.set("ai", target => {
|
||
return get.effect(target, { name: "sha" }, player, player);
|
||
});
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.useCard({ name: "sha", isCard: true }, result.targets[0], false);
|
||
}
|
||
event.finish();
|
||
"step 3";
|
||
player.chooseCardTarget({
|
||
filterCard: function (card) {
|
||
return get.itemtype(card) == "card";
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return _status.event.targets.includes(target);
|
||
},
|
||
selectCard: 2,
|
||
targets: event.getParent(2).targets,
|
||
position: "he",
|
||
prompt: "交给其中一名角色两张牌，或失去1点体力",
|
||
ai1: function (card) {
|
||
return 1;
|
||
},
|
||
ai2: function (target) {
|
||
var player = _status.event.player,
|
||
card = ui.selected.cards[0];
|
||
var val = get.value(card, target);
|
||
if (val > 0) return get.attitude(player, target) * 2;
|
||
return (val - 2) * get.attitude(player, target);
|
||
},
|
||
});
|
||
"step 4";
|
||
if (result.bool) {
|
||
player.give(result.cards, result.targets[0]);
|
||
} else player.loseHp();
|
||
},
|
||
ai: {
|
||
order: 8,
|
||
result: {
|
||
target: function (player, target) {
|
||
if (get.attitude(player, target) > 0 && ui.selected.targets.length) return 0.1;
|
||
return -1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dcwujie: {
|
||
audio: 2,
|
||
trigger: {
|
||
global: ["discardBegin", "drawBegin"],
|
||
},
|
||
forced: true,
|
||
forceDie: true,
|
||
group: "dcwujie_inf",
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
return event.getParent().name == "die" && event.getParent().source == event.player && event.player != player && event.getParent().player == player;
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
},
|
||
subSkill: {
|
||
inf: {
|
||
trigger: { player: "useCard1" },
|
||
forced: true,
|
||
popup: false,
|
||
firstDo: true,
|
||
filter: function (event, player) {
|
||
if (get.color(event.card) == "none" && event.addCount !== false) return true;
|
||
return false;
|
||
},
|
||
content: function () {
|
||
trigger.addCount = false;
|
||
var stat = player.getStat().card,
|
||
name = trigger.card.name;
|
||
if (typeof stat[name] == "number") stat[name]--;
|
||
},
|
||
},
|
||
},
|
||
mod: {
|
||
targetInRange: function (card, player) {
|
||
const color = get.color(card);
|
||
if (color === "none" || color === "unsure") return true;
|
||
},
|
||
cardUsable: function (card) {
|
||
const color = get.color(card);
|
||
if (color === "none" || color === "unsure") return Infinity;
|
||
},
|
||
},
|
||
},
|
||
//关宁
|
||
dcxiuwen: {
|
||
audio: 2,
|
||
trigger: { player: "useCard" },
|
||
filter: function (event, player) {
|
||
return !player.getStorage("dcxiuwen").includes(event.card.name);
|
||
},
|
||
frequent: true,
|
||
content: function () {
|
||
player.draw();
|
||
player.markAuto("dcxiuwen", [trigger.card.name]);
|
||
},
|
||
intro: { content: "已使用：$" },
|
||
},
|
||
oldlongsong: {
|
||
audio: "dclongsong",
|
||
trigger: { player: "phaseUseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("h") > 0;
|
||
},
|
||
getSkills: function (target, player, trigger) {
|
||
return target.getSkills(null, false).filter(skill => {
|
||
var skills = game.expandSkills([skill]);
|
||
if (
|
||
skills.filter(skillx => {
|
||
var info = get.info(skillx);
|
||
if (!info || !info.enable || (info.usable && !(info.usable >= 1))) return false;
|
||
if (info.enable != "phaseUse" && (!Array.isArray(info.enable) || !info.enable.includes("phaseUse"))) return false;
|
||
if (info.viewAs && info.usable && info.usable != 1) return false;
|
||
if (info.juexingji || info.hiddenSkill || info.charlotte || info.limited || info.dutySkill) return false;
|
||
if ((!info.usable || info.usable > 1) && info.filter) {
|
||
try {
|
||
var bool1 = info.filter(trigger, player);
|
||
var num = player.getStat().skill[skillx];
|
||
player.getStat().skill[skillx] = 1;
|
||
var bool2 = info.filter(trigger, player);
|
||
if (!num) delete player.getStat().skill[skillx];
|
||
else player.getStat().skill[skillx] = num;
|
||
var bool3 = !(bool1 && !bool2);
|
||
} catch (e) {
|
||
console.trace(e);
|
||
}
|
||
if (!bool1 && !bool2 && get.skillInfoTranslation(skill, player).indexOf("出牌阶段限一次") == -1) return false;
|
||
if ((bool1 || bool2) && bool3) return false;
|
||
}
|
||
return true;
|
||
}).length
|
||
)
|
||
return true;
|
||
return false;
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseCardTarget({
|
||
filterCard: true,
|
||
selectCard: 1,
|
||
filterTarget: function (card, player, target) {
|
||
return player != target;
|
||
},
|
||
ai1: function (card) {
|
||
return 6 - get.value(card);
|
||
},
|
||
ai2: function (target) {
|
||
var att = get.attitude(_status.event.player, target),
|
||
trigger = _status.event.getTrigger(),
|
||
player = _status.event.player;
|
||
return lib.skill.oldlongsong.getSkills(target, player, trigger).length * 3 + att / 3;
|
||
},
|
||
prompt: get.prompt2("oldlongsong"),
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("oldlongsong", target);
|
||
event.target = target;
|
||
player.line(target, "green");
|
||
player.give(result.cards, target);
|
||
var skills = lib.skill.oldlongsong.getSkills(target, player, trigger);
|
||
if (skills.length) {
|
||
if (!event.isMine() && !event.isOnline()) game.delayx();
|
||
target.disableSkill("oldlongsong_back", skills);
|
||
target.markAuto("oldlongsong_back", skills);
|
||
target.addTempSkill("oldlongsong_back", ["phaseUseAfter", "phaseAfter"]);
|
||
var str = "";
|
||
for (var i = 0; i < skills.length; i++) {
|
||
str += "【" + get.translation(skills[i]) + "】";
|
||
if (i != skills.length - 1) str += "、";
|
||
}
|
||
game.log(target, "的技能", "#g" + str, "失效了");
|
||
// game.log(player,'获得了技能','#g'+str);
|
||
player.popup(skills, "thunder");
|
||
for (var skill of skills) {
|
||
player.addTempSkills(skill, ["phaseUseAfter", "phaseAfter"]);
|
||
}
|
||
}
|
||
}
|
||
},
|
||
ai: { expose: 0.2 },
|
||
subSkill: {
|
||
back: {
|
||
charlotte: true,
|
||
onremove: function (player, skill) {
|
||
var skills = player.getStorage("oldlongsong_back");
|
||
for (var key of skills) {
|
||
game.log(player, "恢复了技能", "#g【" + get.translation(key) + "】");
|
||
delete player.storage[key];
|
||
}
|
||
player.enableSkill(skill);
|
||
player.popup(skills, "thunder");
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dclongsong: {
|
||
audio: 2,
|
||
trigger: { player: "phaseUseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("h") > 0;
|
||
},
|
||
getSkills(target, skills) {
|
||
return (target && !skills ? target.getSkills(null, false) : skills).filter(skill => {
|
||
var str = get.skillInfoTranslation(skill, target);
|
||
if (str.indexOf("当你于出牌阶段") != -1) return true;
|
||
var skills = game.expandSkills([skill]);
|
||
if (
|
||
skills.some(skillx => {
|
||
var info = get.info(skillx);
|
||
if (!info || !info.enable) return false;
|
||
if (info.enable != "phaseUse" && info.enable != "chooseToUse" && (!Array.isArray(info.enable) || (!info.enable.includes("phaseUse") && !info.enable.includes("chooseToUse")))) return false;
|
||
if (info.juexingji || info.hiddenSkill || info.charlotte || info.limited || info.dutySkill) return false;
|
||
if (info.ai && info.ai.notemp) return false;
|
||
return true;
|
||
})
|
||
)
|
||
return true;
|
||
return false;
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseCardTarget({
|
||
filterCard: { color: "red" },
|
||
selectCard: 1,
|
||
position: "he",
|
||
filterTarget: function (card, player, target) {
|
||
return player != target;
|
||
},
|
||
ai1: function (card) {
|
||
return 6 - get.value(card);
|
||
},
|
||
ai2: function (target) {
|
||
var att = get.attitude(_status.event.player, target);
|
||
return lib.skill.dclongsong.getSkills(target).length * 2 + att / 2.5;
|
||
},
|
||
prompt: get.prompt2("dclongsong"),
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("dclongsong", target);
|
||
event.target = target;
|
||
player.line(target, "green");
|
||
player.give(result.cards, target);
|
||
var skills = lib.skill.dclongsong.getSkills(target);
|
||
if (skills.length) {
|
||
if (!event.isMine() && !event.isOnline()) game.delayx();
|
||
target.disableSkill("dclongsong_back", skills);
|
||
target.markAuto("dclongsong_back", skills);
|
||
player.addTempSkill("dclongsong_remove", ["phaseUseAfter", "phaseAfter"]);
|
||
player.markAuto("dclongsong_remove", skills);
|
||
target.addTempSkill("dclongsong_back", ["phaseUseAfter", "phaseAfter"]);
|
||
var str = "";
|
||
for (var i = 0; i < skills.length; i++) {
|
||
str += "【" + get.translation(skills[i]) + "】";
|
||
if (i != skills.length - 1) str += "、";
|
||
}
|
||
game.log(target, "的技能", "#g" + str, "失效了");
|
||
// game.log(player,'获得了技能','#g'+str);
|
||
player.popup(skills, "thunder");
|
||
for (var skill of skills) {
|
||
player.addTempSkills(skill, ["phaseUseAfter", "phaseAfter"]);
|
||
}
|
||
}
|
||
}
|
||
},
|
||
ai: { expose: 0.2 },
|
||
subSkill: {
|
||
back: {
|
||
charlotte: true,
|
||
onremove: function (player, skill) {
|
||
var skills = player.getStorage("dclongsong_back");
|
||
for (var key of skills) {
|
||
game.log(player, "恢复了技能", "#g【" + get.translation(key) + "】");
|
||
//delete player.storage[key];
|
||
}
|
||
player.enableSkill(skill);
|
||
player.popup(skills, "thunder");
|
||
},
|
||
},
|
||
remove: {
|
||
trigger: { player: ["useSkill", "logSkillBegin"] },
|
||
forced: true,
|
||
charlotte: true,
|
||
popup: false,
|
||
onremove: true,
|
||
filter: function (event, player) {
|
||
var skill = event.sourceSkill || event.skill;
|
||
return player.getStorage("dclongsong_remove").includes(skill) && !player.getStockSkills(false, true).includes(skill);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var skill = trigger.sourceSkill || trigger.skill;
|
||
player.removeSkills(skill);
|
||
player.unmarkAuto("dclongsong_remove", [skill]);
|
||
},
|
||
},
|
||
},
|
||
},
|
||
longsong: {
|
||
audio: "dclongsong",
|
||
trigger: { player: "phaseUseBegin" },
|
||
filter(event, player) {
|
||
return game.hasPlayer(target => {
|
||
if (target == player) return false;
|
||
return target.hasCard(card => {
|
||
if (get.position(card) == "h") return true;
|
||
return get.color(card) == "red" && lib.filter.canBeGained(card, player, target);
|
||
}, "he");
|
||
});
|
||
},
|
||
async cost(event, trigger, player) {
|
||
event.result = await player
|
||
.chooseCardTarget({
|
||
prompt: get.prompt2("longsong"),
|
||
filterTarget(card, player, target) {
|
||
if (target === player) return false;
|
||
const skills = lib.skill.dclongsong.getSkills(target).map(skill => get.translation(skill));
|
||
if (skills.length) {
|
||
target.prompt(skills.join("<br>"));
|
||
}
|
||
return (
|
||
ui.selected.cards.length ||
|
||
target.hasCard(card => {
|
||
if (get.position(card) == "h") return true;
|
||
return get.color(card) == "red" && lib.filter.canBeGained(card, player, target);
|
||
}, "he")
|
||
);
|
||
},
|
||
filterCard: { color: "red" },
|
||
selectCard: [0, 1],
|
||
multitarget: true,
|
||
ai1(card) {
|
||
const ai2 = get.event("ai2");
|
||
if (
|
||
game.hasPlayer(current => {
|
||
return ai2(current) > 0;
|
||
})
|
||
) {
|
||
return -1 - get.value(card);
|
||
}
|
||
return 6 - get.value(card);
|
||
},
|
||
ai2(target) {
|
||
const player = get.event("player"),
|
||
att = get.attitude(player, target);
|
||
if (att > 0 && !target.getGainableCards(player, "he").some(card => get.color(card) == "red")) return 0;
|
||
return lib.skill.dclongsong.getSkills(target).length + (att > 0 ? 0 : Math.max(0, get.effect(target, { name: "shunshou_copy2" }, player, player)));
|
||
},
|
||
})
|
||
.forResult();
|
||
},
|
||
async content(event, trigger, player) {
|
||
const target = event.targets[0],
|
||
cards = event.cards,
|
||
gainableCards = target.getGainableCards(player, "he").filter(card => get.color(card) == "red");
|
||
if (cards) {
|
||
await player.give(cards, target);
|
||
} else {
|
||
if (gainableCards.length) {
|
||
let dialog = ["龙诵：获得" + get.translation(target) + "的一张红色牌"];
|
||
let cards1 = gainableCards.filter(i => get.position(i) == "h"),
|
||
cards2 = gainableCards.filter(i => get.position(i) == "e");
|
||
if (cards1.length) {
|
||
dialog.push('<div class="text center">手牌区</div>');
|
||
if (player.hasSkillTag("viewHandcard", null, target, true)) dialog.push(cards1);
|
||
else dialog.push([cards1.randomSort(), "blank"]);
|
||
}
|
||
if (cards2.length) {
|
||
dialog.push('<div class="text center">装备区</div>');
|
||
dialog.push(cards2);
|
||
}
|
||
const {
|
||
result: { bool, links },
|
||
} = await player.chooseButton(dialog, true).set("ai", button => {
|
||
const player = get.event("player"),
|
||
target = get.event().getParent().targets[0];
|
||
return get.value(button.link, player) * get.value(button.link, target) * (1 + Math.random());
|
||
});
|
||
if (!bool) return;
|
||
await player.gain(links, target, "giveAuto", "bySelf");
|
||
} else {
|
||
player.popup("杯具");
|
||
player.chat("无牌可得？！");
|
||
game.log("但是", target, "没有红色牌可被" + get.translation(player) + "获得！");
|
||
}
|
||
}
|
||
let skills = lib.skill.dclongsong.getSkills(target),
|
||
fromTarget = true;
|
||
if (!skills.length) {
|
||
if (!_status.characterlist) {
|
||
lib.skill.pingjian.initList();
|
||
}
|
||
const allList = _status.characterlist.slice(0);
|
||
allList.randomSort();
|
||
for (const name of allList) {
|
||
const curSkills = lib.character[name][3];
|
||
const filteredSkills = lib.skill.dclongsong.getSkills(null, curSkills);
|
||
if (filteredSkills.length > 0) {
|
||
skills = filteredSkills.randomGets(1);
|
||
fromTarget = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (!skills.length) return;
|
||
if (!event.isMine() && !event.isOnline()) await game.asyncDelayx();
|
||
skills.forEach(skill => {
|
||
player.popup(skill, "thunder");
|
||
});
|
||
if (fromTarget) {
|
||
target.disableSkill("dclongsong_back", skills);
|
||
target.markAuto("dclongsong_back", skills);
|
||
target.addTempSkill("dclongsong_back", ["phaseUseAfter", "phaseAfter"]);
|
||
let str = "";
|
||
for (let i = 0; i < skills.length; i++) {
|
||
str += "【" + get.translation(skills[i]) + "】";
|
||
if (i != skills.length - 1) str += "、";
|
||
}
|
||
game.log(target, "的技能", "#g" + str, "失效了");
|
||
}
|
||
player.addTempSkill("dclongsong_remove", ["phaseUseAfter", "phaseAfter"]);
|
||
player.markAuto("dclongsong_remove", skills);
|
||
await player.addTempSkills(skills, ["phaseUseAfter", "phaseAfter"]);
|
||
},
|
||
},
|
||
//伏完
|
||
dcmoukui: {
|
||
audio: "moukui",
|
||
trigger: { player: "useCardToPlayered" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return event.card && event.card.name == "sha" && event.isFirstTarget;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseButton([
|
||
get.prompt("dcmoukui"),
|
||
[
|
||
[
|
||
["draw", "摸一张牌"],
|
||
["discard", "弃置" + (trigger.targets.length == 1 ? get.translation(trigger.targets[0]) : "一名目标角色") + "的一张牌"],
|
||
],
|
||
"textbutton",
|
||
],
|
||
])
|
||
.set("filterButton", button => {
|
||
if (
|
||
button.link == "discard" &&
|
||
_status.event.getTrigger().targets.every(target => {
|
||
return target.countDiscardableCards(_status.event.player, "he") == 0;
|
||
})
|
||
)
|
||
return false;
|
||
return true;
|
||
})
|
||
.set("ai", function (button) {
|
||
if (
|
||
button.link == "discard" &&
|
||
_status.event.getTrigger().targets.every(target => {
|
||
return get.effect(target, { name: "guohe_copy2" }, _status.event.player) <= 0;
|
||
})
|
||
)
|
||
return 0;
|
||
return 1;
|
||
})
|
||
.set("selectButton", [1, 2]);
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.logSkill("dcmoukui");
|
||
var choices = result.links;
|
||
event.choices = choices;
|
||
if (choices.includes("draw")) {
|
||
game.log(player, "选择了", "#y选项一");
|
||
player.draw();
|
||
}
|
||
if (choices.includes("discard")) {
|
||
game.log(player, "选择了", "#y选项二");
|
||
if (trigger.targets.length == 1) event.directtarget = trigger.targets[0];
|
||
else
|
||
player
|
||
.chooseTarget("谋溃：弃置一名目标角色的一张牌", true, (card, player, target) => {
|
||
return _status.event.getTrigger().targets.includes(target) && target.countDiscardableCards(player, "he") > 0;
|
||
})
|
||
.set("ai", target => {
|
||
return get.effect(target, { name: "guohe_copy2" }, _status.event.player);
|
||
});
|
||
} else event.finish();
|
||
if (choices.length >= 2) {
|
||
player.addTempSkill("dcmoukui_conseq");
|
||
player.markAuto("dcmoukui_conseq", [trigger.card]);
|
||
}
|
||
}
|
||
"step 2";
|
||
player.discardPlayerCard(event.directtarget || result.targets[0], true, "he").boolline = true;
|
||
},
|
||
subSkill: {
|
||
conseq: {
|
||
trigger: {
|
||
global: ["shaMiss", "useCardToExcluded", "eventNeutralized", "shaCancelled"],
|
||
},
|
||
forced: true,
|
||
popup: false,
|
||
charlotte: true,
|
||
onremove: true,
|
||
filter: function (event, player, name) {
|
||
if (!event.card) return false;
|
||
var cards = player.getStorage("dcmoukui_conseq");
|
||
if (!cards.includes(event.card)) return false;
|
||
return true;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
game.delayx();
|
||
"step 1";
|
||
trigger.target.discardPlayerCard(player, true, "he").boolline = true;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//孙桓
|
||
dcniji: {
|
||
audio: 2,
|
||
trigger: { target: "useCardToTargeted" },
|
||
filter: function (event, player) {
|
||
return get.type(event.card) != "equip";
|
||
},
|
||
frequent: true,
|
||
group: "dcniji_discard",
|
||
content: function () {
|
||
var next = player.draw();
|
||
var evt = trigger.getParent("dcniji_discard");
|
||
if (!evt || evt.player != player) next.gaintag = ["dcniji"];
|
||
player.addTempSkill("dcniji_clear");
|
||
},
|
||
subSkill: {
|
||
clear: {
|
||
charlotte: true,
|
||
onremove: function (player) {
|
||
player.removeGaintag("dcniji");
|
||
},
|
||
},
|
||
discard: {
|
||
audio: "dcniji",
|
||
trigger: { global: "phaseJieshuBegin" },
|
||
filter: function (event, player) {
|
||
return player.hasCard(card => card.hasGaintag("dcniji") && lib.filter.cardDiscardable(card, player, "dcniji"), "h");
|
||
},
|
||
forced: true,
|
||
locked: false,
|
||
content: function () {
|
||
"step 0";
|
||
var cards = player.getCards("h", card => card.hasGaintag("dcniji") && lib.filter.cardDiscardable(card, player, "dcniji"));
|
||
event.cards = cards;
|
||
// if(cards.length>=player.hp){
|
||
if (cards.some(card => player.hasUseTarget(card))) {
|
||
player.chooseToUse({
|
||
prompt: "是否使用一张“逆击”牌？",
|
||
filterCard: function (card, player) {
|
||
if (get.itemtype(card) == "card" && !card.hasGaintag("dcniji")) return false;
|
||
return lib.filter.filterCard.apply(this, arguments);
|
||
},
|
||
ai1: function (card) {
|
||
return get.player().getUseValue(card);
|
||
},
|
||
});
|
||
}
|
||
// }
|
||
"step 1";
|
||
if (result.bool) game.delayex();
|
||
var cards = cards.filter(card => get.owner(card) == player && get.position(card) == "h" && lib.filter.cardDiscardable(card, player, "dcniji"));
|
||
if (cards.length) player.discard(cards);
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//孙狼
|
||
dctingxian: {
|
||
audio: 2,
|
||
trigger: { player: "useCardToPlayered" },
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return event.card.name == "sha" && event.getParent().triggeredTargets3.length == event.targets.length;
|
||
},
|
||
check: function (event, player) {
|
||
return event.targets.some(target => get.effect(target, event.card, player, player) <= 0);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var num = player.countCards("e") + 1;
|
||
event.num = num;
|
||
player.draw(num);
|
||
"step 1";
|
||
var num = Math.min(trigger.targets.length, num);
|
||
player
|
||
.chooseTarget("铤险：令此杀对其中至多" + get.cnNumber(num) + "个目标无效", [1, num], true, (card, player, target) => {
|
||
return _status.event.getTrigger().targets.includes(target);
|
||
})
|
||
.set("ai", target => {
|
||
return 1 - get.effect(target, _status.event.getTrigger().card, _status.event.player, _status.event.player);
|
||
});
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.line(result.targets);
|
||
trigger.getParent().excluded.addArray(result.targets);
|
||
}
|
||
},
|
||
ai: {
|
||
effect: {
|
||
player: function (card, player, target) {
|
||
if (_status.event.name == "chooseToUse" && get.name(card) == "sha" && (!player.storage.counttrigger || !player.storage.counttrigger.dctingxian) && !_status._dctingxian_aiChecking) {
|
||
_status._dctingxian_aiChecking = true;
|
||
var eff = get.effect(target, { name: "sha" }, player, player);
|
||
delete _status._dctingxian_aiChecking;
|
||
if (
|
||
eff < 0 &&
|
||
ui.selected.targets.filter(targetx => {
|
||
if (targetx == target) return false;
|
||
_status._dctingxian_aiChecking = true;
|
||
var eff = get.effect(targetx, { name: "sha" }, player, player);
|
||
delete _status._dctingxian_aiChecking;
|
||
if (eff < 0) return true;
|
||
}).length <
|
||
player.countCards("e") + 1
|
||
)
|
||
return [0, 0, 0, 0.5];
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dcbenshi: {
|
||
audio: 2,
|
||
forced: true,
|
||
trigger: { player: "useCard1" },
|
||
filter: function (event, player) {
|
||
if (event.card.name != "sha") return false;
|
||
var card = event.card;
|
||
var range;
|
||
var select = get.copy(get.info(card).selectTarget);
|
||
if (select == undefined) {
|
||
if (get.info(card).filterTarget == undefined) return false;
|
||
range = [1, 1];
|
||
} else if (typeof select == "number") range = [select, select];
|
||
else if (get.itemtype(select) == "select") range = select;
|
||
else if (typeof select == "function") range = select(card, player);
|
||
game.checkMod(card, player, range, "selectTarget", player);
|
||
return range[1] == -1;
|
||
},
|
||
content: function () {},
|
||
mod: {
|
||
attackRangeBase: function (player, num) {
|
||
if (num !== "unchanged") return num;
|
||
var range = 1;
|
||
var equips = player.getCards("e", function (card) {
|
||
return get.subtype(card) != "equip1" && (!ui.selected.cards || !ui.selected.cards.includes(card));
|
||
});
|
||
for (var i = 0; i < equips.length; i++) {
|
||
var info = get.info(equips[i], false).distance;
|
||
if (!info) continue;
|
||
if (info.attackFrom) {
|
||
range -= info.attackFrom;
|
||
}
|
||
}
|
||
return range;
|
||
},
|
||
attackRange: function (player, num) {
|
||
return num + 1;
|
||
},
|
||
selectTarget: function (card, player, range) {
|
||
if (card.name == "sha") {
|
||
range[0] = -1;
|
||
range[1] = -1;
|
||
}
|
||
},
|
||
},
|
||
},
|
||
//是仪
|
||
dccuichuan: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: true,
|
||
filterCard: true,
|
||
derivation: "dczuojian",
|
||
filter: function (event, player) {
|
||
return player.countCards("h") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.num = target.countCards("e");
|
||
var subtypes = [];
|
||
for (var i = 1; i < 7; i++) {
|
||
if (target.hasEmptySlot(i)) subtypes.push("equip" + i);
|
||
}
|
||
if (subtypes.length) {
|
||
subtypes.randomSort();
|
||
for (var subtype of subtypes) {
|
||
var card = get.cardPile2(card => get.subtype(card) == subtype);
|
||
if (card && target.canUse(card, target)) {
|
||
target.chooseUseTarget(card, true, "nopopup");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
"step 1";
|
||
var numx = target.countCards("e");
|
||
if (numx > 0) player.draw(numx);
|
||
game.delayx();
|
||
"step 2";
|
||
event.num2 = target.countCards("e");
|
||
if (event.num2 == 4 && num != 4) {
|
||
player.trySkillAnimate("dccuichuan_animate", "dccuichuan_animate", player.checkShow("dccuichuan"));
|
||
//player.removeSkill('dccuichuan');
|
||
//game.log(player,'失去了技能','#g【榱椽】');
|
||
player.changeSkills(["dczuojian"], ["dccuichuan"]);
|
||
target.insertPhase();
|
||
game.delayx();
|
||
}
|
||
},
|
||
subSkill: {
|
||
animate: {
|
||
skillAnimation: true,
|
||
animationColor: "wood",
|
||
},
|
||
},
|
||
ai: {
|
||
order: 7,
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.countCards("e") == 3) return 2;
|
||
return 1;
|
||
},
|
||
player: function (player, target) {
|
||
if (target.countCards("e") == 3) return 0.5;
|
||
return target.countCards("e") + 1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dczhengxu: {
|
||
audio: 2,
|
||
group: ["dczhengxu_lose", "dczhengxu_damage"],
|
||
subSkill: {
|
||
lose: {
|
||
audio: "dczhengxu",
|
||
trigger: {
|
||
player: "loseAfter",
|
||
global: ["equipAfter", "addJudgeAfter", "gainAfter", "loseAsyncAfter", "addToExpansionAfter"],
|
||
},
|
||
prompt2: function (event, player) {
|
||
return "当你失去牌后，若你本回合受到过伤害，你可以摸等量的牌（" + get.cnNumber(event.getl(player).cards2.length) + "张）";
|
||
},
|
||
check: () => true,
|
||
filter: function (event, player) {
|
||
if (event.name == "gain" && event.player == player) return false;
|
||
if (!player.getHistory("damage").length || player.hasHistory("useSkill", evt => evt.skill == "dczhengxu_lose")) return false;
|
||
var evt = event.getl(player);
|
||
return evt && evt.cards2 && evt.cards2.length > 0;
|
||
},
|
||
content: function () {
|
||
player.draw(trigger.getl(player).cards2.length);
|
||
},
|
||
ai: {
|
||
effect: {
|
||
target: (card, player, target) => {
|
||
if ((get.tag(card, "lose") || get.tag(card, "discard")) && target.getHistory("damage").length && !target.hasHistory("useSkill", evt => evt.skill == "dczhengxu_lose")) return [1, 1];
|
||
},
|
||
},
|
||
},
|
||
},
|
||
damage: {
|
||
audio: "dczhengxu",
|
||
trigger: {
|
||
player: "damageBegin4",
|
||
},
|
||
prompt2: "当你受到伤害时，若你本回合失去过牌，你可以防止之",
|
||
check: () => true,
|
||
filter: function (event, player) {
|
||
if (!player.hasHistory("lose", evt => evt.cards2 && evt.cards2.length) || player.hasHistory("useSkill", evt => evt.skill == "dczhengxu_damage")) return false;
|
||
return true;
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
},
|
||
ai: {
|
||
effect: {
|
||
target: (card, player, target) => {
|
||
if (player.hasSkillTag("jueqing", false, target) || !get.tag(card, "damage")) return;
|
||
if (target.hasHistory("useSkill", evt => evt.skill == "dczhengxu_damage") || !target.hasHistory("lose", evt => evt.cards2 && evt.cards2.length)) return;
|
||
if (get.attitude(player, target) >= 0) return "zeroplayertarget";
|
||
let num = 0,
|
||
shas = player.getCardUsable("sha"),
|
||
hs = player.getCards("hs", i => {
|
||
if (i === card || (card.cards && card.cards.includes(i)) || !get.tag(i, "damage") || !player.canUse(i, target)) return false;
|
||
if (get.name(i) === "sha") {
|
||
num++;
|
||
return false;
|
||
}
|
||
return true;
|
||
});
|
||
if (card.name === "sha") shas--;
|
||
num = Math.min(num, shas);
|
||
num += hs.length;
|
||
if (!num) return "zeroplayertarget";
|
||
num = 1 - 2 / 3 / num;
|
||
return [num, 0, num, 0];
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dczuojian: {
|
||
audio: 2,
|
||
trigger: { player: "phaseUseEnd" },
|
||
filter: function (event, player) {
|
||
return (
|
||
player.getHistory("useCard", evt => {
|
||
var evtx = evt.getParent("phaseUse");
|
||
if (evtx && evtx == event) return true;
|
||
return false;
|
||
}).length >= player.hp
|
||
);
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
var choices = [];
|
||
var choiceList = ["令装备区牌数多于你的角色各摸一张牌", "令装备区牌数少于你的角色各弃置一张手牌"];
|
||
var num = player.countCards("e");
|
||
var targets = [],
|
||
targets2 = [];
|
||
var eff = 0,
|
||
eff2 = 0;
|
||
for (var target of game.filterPlayer()) {
|
||
if (target.countCards("e") > num) {
|
||
targets.push(target);
|
||
eff += get.attitude(player, target);
|
||
}
|
||
if (target.countCards("e") < num) {
|
||
targets2.push(target);
|
||
eff2 -= get.attitude(player, target);
|
||
}
|
||
}
|
||
event.targets = targets;
|
||
event.targets2 = targets2;
|
||
if (targets.length) {
|
||
choices.push("选项一");
|
||
choiceList[0] += "（" + get.translation(targets) + "）";
|
||
} else choiceList[0] = '<span style="opacity:0.5; ">' + choiceList[0] + "</span>";
|
||
if (targets2.length) {
|
||
choices.push("选项二");
|
||
choiceList[1] += "（" + get.translation(targets2) + "）";
|
||
} else choiceList[1] = '<span style="opacity:0.5; ">' + choiceList[1] + "</span>";
|
||
if (!choices.length) event.finish();
|
||
else
|
||
player
|
||
.chooseControl(choices, "cancel2")
|
||
.set("prompt", get.prompt("dczuojian"))
|
||
.set("choiceList", choiceList)
|
||
.set("ai", () => {
|
||
var controls = _status.event.controls,
|
||
choice = _status.event.choice;
|
||
if (!controls.includes("选项一") || (controls.includes("选项二") && choice == 1)) return "选项二";
|
||
return "选项一";
|
||
})
|
||
.set("choice", eff <= 0 && eff2 <= 0 ? "cancel2" : eff > -eff2 ? 0 : 1);
|
||
"step 1";
|
||
if (result.control == "选项一") {
|
||
player.logSkill("dczuojian", targets);
|
||
game.asyncDraw(targets, 1);
|
||
} else if (result.control == "选项二") {
|
||
player.logSkill("dczuojian", event.targets2);
|
||
for (var target of event.targets2) {
|
||
player.discardPlayerCard("h", target, true);
|
||
}
|
||
}
|
||
},
|
||
},
|
||
//胡金定
|
||
dcdeshi: {
|
||
audio: 2,
|
||
trigger: { player: "damageBegin4" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player.isDamaged() && event.card && event.card.name == "sha";
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
trigger.cancel();
|
||
for (var func of ["discardPile", "cardPile2"]) {
|
||
var card = get[func](card => card.name == "sha");
|
||
if (card) {
|
||
player.gain(card, "gain2");
|
||
break;
|
||
}
|
||
}
|
||
"step 1";
|
||
player.loseMaxHp();
|
||
},
|
||
ai: {
|
||
halfneg: true,
|
||
filterDamage: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
if (arg && arg.card && arg.card.name == "sha") return true;
|
||
return false;
|
||
},
|
||
},
|
||
},
|
||
dcwuyuan: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return player.countCards("h", "sha") > 0;
|
||
},
|
||
filterCard: { name: "sha" },
|
||
filterTarget: lib.filter.notMe,
|
||
check: function (card) {
|
||
var player = _status.event.player;
|
||
if (
|
||
get.color(card) == "red" &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && current.isDamaged() && get.attitude(player, current) > 2;
|
||
})
|
||
)
|
||
return 2;
|
||
if (get.natureList(card).length) return 1.5;
|
||
return 1;
|
||
},
|
||
discard: false,
|
||
lose: false,
|
||
delay: false,
|
||
content: function () {
|
||
"step 0";
|
||
player.give(cards, target, "give");
|
||
player.recover();
|
||
"step 1";
|
||
var num = 1;
|
||
if (get.natureList(cards[0]).length) num++;
|
||
player.draw("nodelay");
|
||
target.draw(num);
|
||
if (get.color(cards[0]) == "red") target.recover();
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
result: {
|
||
player: function (player, target) {
|
||
if (player.isDamaged()) return 1;
|
||
return 0;
|
||
},
|
||
target: function (player, target) {
|
||
if (ui.selected.cards.length) {
|
||
var num = 1;
|
||
if (get.natureList(ui.selected.cards[0]).length) num++;
|
||
if (target.hasSkillTag("nogain")) num = 0;
|
||
if (get.color(ui.selected.cards[0]) == "red") return num + 2;
|
||
else return num + 1;
|
||
}
|
||
return 1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//李异谢旌
|
||
dcdouzhen: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: ["useCard", "respond"],
|
||
},
|
||
forced: true,
|
||
zhuanhuanji: "number",
|
||
mark: true,
|
||
marktext: "☯",
|
||
intro: {
|
||
content: function (storage, player) {
|
||
var str = "<li>已转换过" + get.cnNumber(storage || 0) + "次。<li>你的回合内，";
|
||
str += player.countMark("dcdouzhen") % 2 ? "你的红色基本牌均视为普【杀】且无次数限制。" : "你的黑色基本牌均视为【决斗】且使用时获得目标的一张牌。";
|
||
return str;
|
||
},
|
||
},
|
||
filter: function (event, player) {
|
||
if (player != _status.currentPhase || !event.card.isCard || !event.cards || event.cards.length != 1 || get.type(event.cards[0]) != "basic") return false;
|
||
if (player.countMark("dcdouzhen") % 2) return get.color(event.cards[0]) == "red" && event.card.name == "sha";
|
||
return event.name != "respond" && get.color(event.cards[0]) == "black" && event.card.name == "juedou";
|
||
},
|
||
content: function () {
|
||
if (player.countMark("dcdouzhen") % 2) {
|
||
// if(trigger.addCount!==false){
|
||
// trigger.addCount=false;
|
||
// if(player.stat[player.stat.length-1].card.sha>0){
|
||
// player.stat[player.stat.length-1].card.sha--;
|
||
// }
|
||
// }
|
||
} else {
|
||
if (trigger.targets.length && trigger.targets.filter(i => i.countGainableCards(player, "he") > 0).length) player.gainMultiple(trigger.targets.sortBySeat(), "he");
|
||
}
|
||
player.changeZhuanhuanji("dcdouzhen");
|
||
},
|
||
ai: {
|
||
effect: {
|
||
player: function (card, player, target) {
|
||
if (card.name != "juedou") return;
|
||
if (
|
||
player.hasSkillTag(
|
||
"directHit_ai",
|
||
true,
|
||
{
|
||
target: target,
|
||
card: card,
|
||
},
|
||
true
|
||
)
|
||
) {
|
||
return [1, 1];
|
||
}
|
||
var hs1 = target.getCards("h", "sha");
|
||
var hs2 = player.getCards("h", card => (get.color(card) == "red" && get.type(card) == "basic") || get.name(card) == "sha");
|
||
var hsx = target.getCards("h");
|
||
if (hs1.length > hs2.length + 1 || (hsx.length > 2 && hs2.length == 0 && hsx[0].number < 6) || (hsx.length > 3 && hs2.length == 0) || (hs1.length > hs2.length && (!hs2.length || hs1[0].number > hs2[0].number))) {
|
||
return [1, -2];
|
||
}
|
||
return [1, -0.5];
|
||
},
|
||
},
|
||
},
|
||
mod: {
|
||
cardname: function (card, player) {
|
||
if (get.type(card, null, false) != "basic" || player != _status.currentPhase) return;
|
||
if (player.countMark("dcdouzhen") % 2) {
|
||
if (get.color(card) == "red") return "sha";
|
||
} else {
|
||
if (get.color(card) == "black") return "juedou";
|
||
}
|
||
},
|
||
cardnature: function (card, player) {
|
||
if (get.type(card, null, false) != "basic" || player != _status.currentPhase) return;
|
||
if (player.countMark("dcdouzhen") % 2) {
|
||
if (get.color(card) == "red") return false;
|
||
}
|
||
},
|
||
cardUsable: function (card, player) {
|
||
if (_status.currentPhase == player && card.name == "sha" && player.countMark("dcdouzhen") % 2 && get.color(card) == "red" && card.isCard) return Infinity;
|
||
},
|
||
},
|
||
},
|
||
//穆顺
|
||
dcjinjian: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "damageEnd",
|
||
source: "damageSource",
|
||
},
|
||
forced: true,
|
||
locked: false,
|
||
filter: function (event, player, name) {
|
||
return name == "damageSource" || (event.source && event.source != player && event.source.isIn());
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.addMark("dcjinjian", 1);
|
||
game.delayx();
|
||
"step 1";
|
||
var source = trigger.source;
|
||
if (source && source != player && source.isIn() && player.canCompare(source)) {
|
||
player
|
||
.chooseBool("是否和" + get.translation(source) + "拼点？", "若你赢，则你恢复1点体力")
|
||
.set(
|
||
"goon",
|
||
(player.countCards("h") == 1 ||
|
||
player.hasCard(function (card) {
|
||
return get.value(card) <= 5 || get.number(card) > 10;
|
||
})) &&
|
||
(get.attitude(player, source) <= 0 || source.countCards("h") >= 4)
|
||
)
|
||
.set("ai", function () {
|
||
return _status.event.goon;
|
||
});
|
||
} else event.finish();
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.line(trigger.source, "green");
|
||
player.chooseToCompare(trigger.source);
|
||
} else event.finish();
|
||
"step 3";
|
||
if (result.bool) player.recover();
|
||
},
|
||
intro: {
|
||
name2: "劲",
|
||
content: "mark",
|
||
},
|
||
mod: {
|
||
attackRange: function (player, num) {
|
||
return num + player.countMark("dcjinjian");
|
||
},
|
||
},
|
||
},
|
||
dcshizhao: {
|
||
audio: 2,
|
||
usable: 1,
|
||
trigger: {
|
||
player: ["loseAfter"],
|
||
global: ["equipAfter", "addJudgeAfter", "gainAfter", "loseAsyncAfter", "addToExpansionAfter"],
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player != _status.currentPhase && player.countCards("h") == 0 && event.getl(player).hs.length > 0;
|
||
},
|
||
content: function () {
|
||
if (player.hasMark("dcjinjian")) {
|
||
player.removeMark("dcjinjian", 1);
|
||
player.draw(2);
|
||
} else {
|
||
player.addTempSkill("dcshizhao_effect");
|
||
player.addMark("dcshizhao_effect", 1, false);
|
||
game.delayx();
|
||
}
|
||
},
|
||
subSkill: {
|
||
effect: {
|
||
charlotte: true,
|
||
onremove: true,
|
||
trigger: { player: "damageBegin1" },
|
||
forced: true,
|
||
content: function () {
|
||
trigger.num += player.countMark(event.name);
|
||
player.removeSkill(event.name);
|
||
},
|
||
},
|
||
},
|
||
ai: {
|
||
combo: "dcjinjian",
|
||
},
|
||
},
|
||
//赵俨
|
||
dcfuning: {
|
||
audio: 2,
|
||
trigger: { player: "useCard" },
|
||
prompt2: function (event, player) {
|
||
return (
|
||
"摸两张牌，然后弃置" +
|
||
get.cnNumber(
|
||
1 +
|
||
player.getHistory("useSkill", function (evt) {
|
||
return evt.skill == "dcfuning";
|
||
}).length
|
||
) +
|
||
"张牌"
|
||
);
|
||
},
|
||
check: function (event, player) {
|
||
return (
|
||
player.getHistory("useSkill", function (evt) {
|
||
return evt.skill == "dcfuning";
|
||
}).length < 2
|
||
);
|
||
},
|
||
content: function () {
|
||
player.draw(2);
|
||
player.chooseToDiscard(
|
||
"he",
|
||
true,
|
||
+player.getHistory("useSkill", function (evt) {
|
||
return evt.skill == "dcfuning";
|
||
}).length
|
||
);
|
||
},
|
||
},
|
||
dcbingji: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 4,
|
||
filter: function (event, player) {
|
||
var hs = player.getCards("h"),
|
||
suits = player.getStorage("dcbingji_mark");
|
||
if (!hs.length) return false;
|
||
var suit = get.suit(hs[0], player);
|
||
if (suit == "none" || suits.includes(suit)) return false;
|
||
for (var i = 1; i < hs.length; i++) {
|
||
if (get.suit(hs[i], player) != suit) return false;
|
||
}
|
||
return true;
|
||
},
|
||
ai: {
|
||
order: 10,
|
||
result: { player: 1 },
|
||
},
|
||
chooseButton: {
|
||
dialog: function (event, player) {
|
||
return ui.create.dialog("秉纪", [["sha", "tao"], "vcard"], "hidden");
|
||
},
|
||
filter: function (button, player) {
|
||
return lib.filter.cardEnabled(
|
||
{
|
||
name: button.link[2],
|
||
isCard: true,
|
||
storage: { dcbingji: true },
|
||
},
|
||
player,
|
||
"forceEnable"
|
||
);
|
||
},
|
||
check: function (button) {
|
||
var card = {
|
||
name: button.link[2],
|
||
isCard: true,
|
||
storage: { dcbingji: true },
|
||
},
|
||
player = _status.event.player;
|
||
return Math.max.apply(
|
||
Math,
|
||
game
|
||
.filterPlayer(function (target) {
|
||
if (player == target) return false;
|
||
return lib.filter.targetEnabled2(card, player, target) && lib.filter.targetInRange(card, player, target);
|
||
})
|
||
.map(function (target) {
|
||
return get.effect(target, card, player, player);
|
||
})
|
||
);
|
||
},
|
||
backup: function (links, player) {
|
||
return {
|
||
viewAs: {
|
||
name: links[0][2],
|
||
isCard: true,
|
||
storage: { dcbingji: true },
|
||
},
|
||
filterCard: () => false,
|
||
selectCard: -1,
|
||
filterTarget: function (card, player, target) {
|
||
if (!card) card = get.card();
|
||
if (player == target) return false;
|
||
return lib.filter.targetEnabled2(card, player, target) && lib.filter.targetInRange(card, player, target);
|
||
},
|
||
selectTarget: 1,
|
||
ignoreMod: true,
|
||
filterOk: () => true,
|
||
precontent: function () {
|
||
player.logSkill("dcbingji");
|
||
delete event.result.skill;
|
||
var hs = player.getCards("h");
|
||
player.showCards(hs, get.translation(player) + "发动了【秉纪】");
|
||
player.markAuto("dcbingji_mark", [get.suit(hs[0], player)]);
|
||
player.addTempSkill("dcbingji_mark");
|
||
},
|
||
};
|
||
},
|
||
prompt: function (links, player) {
|
||
return "请选择【" + get.translation(links[0][2]) + "】的目标";
|
||
},
|
||
},
|
||
subSkill: {
|
||
mark: {
|
||
charlotte: true,
|
||
onremove: true,
|
||
trigger: { player: "useCard1" },
|
||
forced: true,
|
||
popup: false,
|
||
firstDo: true,
|
||
filter: function (event, player) {
|
||
return event.addCount !== false && event.card.name == "sha" && event.card.storage && event.card.storage.dcbingji;
|
||
},
|
||
content: function () {
|
||
trigger.addCount = false;
|
||
player.getStat("card").sha--;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//王威
|
||
dcruizhan: {
|
||
audio: 2,
|
||
trigger: { global: "phaseZhunbeiBegin" },
|
||
filter: function (event, player) {
|
||
return player != event.player && event.player.countCards("h") >= Math.max(1, event.player.hp) && player.canCompare(event.player);
|
||
},
|
||
logTarget: "player",
|
||
check: function (event, player) {
|
||
var goon = player.hasCard(function (card) {
|
||
return card.name == "sha" || get.value(card) <= 5;
|
||
});
|
||
var target = event.player;
|
||
if (goon && get.attitude(player, target) < 0) {
|
||
return get.effect(target, { name: "sha" }, player, player) > 0;
|
||
}
|
||
return 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.target = trigger.player;
|
||
player.chooseToCompare(event.target).set("ai", function (card) {
|
||
if (typeof card == "string" && lib.skill[card]) {
|
||
var ais =
|
||
lib.skill[card].check ||
|
||
function () {
|
||
return 0;
|
||
};
|
||
return ais();
|
||
}
|
||
var player = get.owner(card);
|
||
var getn = function (card) {
|
||
if (player.hasSkill("tianbian") && get.suit(card) == "heart") return 13;
|
||
return get.number(card);
|
||
};
|
||
var event = _status.event.getParent();
|
||
var to = player == event.player ? event.target : event.player;
|
||
var addi = get.value(card) >= 8 && get.type(card) != "equip" ? -6 : 0;
|
||
if (card.name == "du") addi -= 5;
|
||
if (player == event.player) {
|
||
if (get.name(card, player) == "sha") {
|
||
return 10 + getn(card);
|
||
}
|
||
return getn(card) - get.value(card) / 2 + addi;
|
||
} else {
|
||
if (get.name(card, player) == "sha") {
|
||
return -10 - getn(card) - get.value(card) / 2 + addi;
|
||
}
|
||
return getn(card) - get.value(card) / 2 + addi;
|
||
}
|
||
});
|
||
"step 1";
|
||
var bool1 = result.bool;
|
||
var bool2 = get.name(result.player, player) == "sha" || get.name(result.target, target) == "sha";
|
||
if (bool1 || bool2) {
|
||
if (player.canUse("sha", target, false)) {
|
||
player.useCard({ name: "sha", isCard: true }, target, false);
|
||
if (!bool1 || !bool2) event.finish();
|
||
} else event.finish();
|
||
} else event.finish();
|
||
"step 2";
|
||
if (
|
||
target.hasCard(function (card) {
|
||
return lib.filter.canBeGained(card, target, player);
|
||
}, "he") &&
|
||
player.hasHistory("sourceDamage", function (evt) {
|
||
var evtx = evt.getParent("useCard");
|
||
return evtx && evtx.card == evt.card && evtx.getParent() == event;
|
||
})
|
||
)
|
||
player.gainPlayerCard(target, true, "he");
|
||
},
|
||
},
|
||
dcshilie: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
chooseButton: {
|
||
dialog: function (event, player) {
|
||
return ui.create.dialog(
|
||
"示烈：请选择一项",
|
||
[
|
||
[
|
||
["recover", "回复1点体力，将两张牌置于武将牌上作为“示烈”"],
|
||
["losehp", "失去1点体力，获得两张“示烈”牌"],
|
||
],
|
||
"textbutton",
|
||
],
|
||
"hidden"
|
||
);
|
||
},
|
||
check: function (button) {
|
||
return button.link == "recover" ? 1 : 0;
|
||
},
|
||
backup: function (links, player) {
|
||
return get.copy(lib.skill["dcshilie_" + links[0]]);
|
||
},
|
||
prompt: () => "点击“确定”以执行选项",
|
||
},
|
||
intro: {
|
||
markcount: "expansion",
|
||
content: "expansion",
|
||
},
|
||
onremove: function (player, skill) {
|
||
var cards = player.getExpansions(skill);
|
||
if (cards.length) player.loseToDiscardpile(cards);
|
||
},
|
||
group: "dcshilie_die",
|
||
ai: {
|
||
order: 0.5,
|
||
result: {
|
||
player: function (player) {
|
||
if (player.isDamaged() && !player.countCards("h", "tao")) return 1;
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
subSkill: {
|
||
backup: {},
|
||
recover: {
|
||
audio: "dcshilie",
|
||
selectCard: -1,
|
||
selectTarget: -1,
|
||
filterCard: () => false,
|
||
filterTarget: () => false,
|
||
multitarget: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.recover();
|
||
"step 1";
|
||
var hs = player.getCards("he");
|
||
if (!hs.length) event.finish();
|
||
else if (hs.length <= 2) event._result = { bool: true, cards: hs };
|
||
else player.chooseCard("he", 2, true, "选择两张牌作为“示烈”牌");
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.addToExpansion(result.cards, player, "give").gaintag.add("dcshilie");
|
||
} else event.finish();
|
||
"step 3";
|
||
var cards = player.getExpansions("dcshilie");
|
||
if (cards.length > game.countPlayer()) {
|
||
player.loseToDiscardpile(cards.slice(game.countPlayer()));
|
||
}
|
||
},
|
||
},
|
||
losehp: {
|
||
audio: "dcshilie",
|
||
selectCard: -1,
|
||
selectTarget: -1,
|
||
filterCard: () => false,
|
||
filterTarget: () => false,
|
||
multitarget: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.loseHp();
|
||
"step 1";
|
||
var hs = player.getExpansions("dcshilie");
|
||
if (!hs.length) event.finish();
|
||
else if (hs.length <= 2) event._result = { bool: true, links: hs };
|
||
else player.chooseButton(["选择获得两张“示烈”牌", hs], 2, true);
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.gain(result.links, "gain2");
|
||
}
|
||
},
|
||
},
|
||
die: {
|
||
audio: "dcshilie",
|
||
forceDie: true,
|
||
trigger: { player: "die" },
|
||
filter: function (event, player) {
|
||
return player.getExpansions("dcshilie").length > 0;
|
||
},
|
||
direct: true,
|
||
skillAnimation: true,
|
||
animationColor: "metal",
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt("dcshilie"), "令一名角色获得你的“示烈”牌", function (card, player, target) {
|
||
return target != player && target != _status.event.getTrigger().source;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("dcshilie_die", target);
|
||
player.give(player.getExpansions("dcshilie"), target, "give");
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//胡班
|
||
dcchongyi: {
|
||
audio: 2,
|
||
init: () => {
|
||
game.addGlobalSkill("dcchongyi_ai");
|
||
},
|
||
onremove: () => {
|
||
if (!game.hasPlayer(i => i.hasSkill("dcchongyi"), true)) game.removeGlobalSkill("dcchongyi_ai");
|
||
},
|
||
trigger: { global: "useCard" },
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
if (event.card.name != "sha" || !event.player.isIn()) return false;
|
||
var evt = event.getParent("phaseUse");
|
||
if (!evt || evt.player != event.player) return false;
|
||
var goon = false;
|
||
var history = event.player.getHistory("useCard", function (evtx) {
|
||
if (goon || evtx.getParent("phaseUse") != evt) return false;
|
||
goon = true;
|
||
return true;
|
||
});
|
||
return history[0] == event;
|
||
},
|
||
prompt2: event => "令其摸两张牌，且使用【杀】的次数上限+1",
|
||
check: function (event, player) {
|
||
return get.attitude(player, event.player) > 0;
|
||
},
|
||
content: function () {
|
||
var target = trigger.player;
|
||
target.draw(2);
|
||
target.addMark("dcchongyi_sha", 1, false);
|
||
target.addTempSkill("dcchongyi_sha");
|
||
},
|
||
group: "dcchongyi_end",
|
||
subSkill: {
|
||
ai: {
|
||
mod: {
|
||
aiOrder: function (player, card, num) {
|
||
if (card.name != "sha") return;
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (!evt || evt.player != player) return;
|
||
if (
|
||
player.hasHistory("useCard", function (evtx) {
|
||
return evtx.getParent("phaseUse") == evt;
|
||
})
|
||
)
|
||
return;
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return current.hasSkill("dcchongyi") && get.attitude(player, current) >= 0;
|
||
})
|
||
)
|
||
return num + 10;
|
||
},
|
||
},
|
||
trigger: { player: "dieAfter" },
|
||
filter: () => {
|
||
return !game.hasPlayer(i => i.hasSkill("dcchongyi"), true);
|
||
},
|
||
silent: true,
|
||
forceDie: true,
|
||
content: () => {
|
||
game.removeGlobalSkill("dcchongyi_ai");
|
||
},
|
||
},
|
||
end: {
|
||
audio: "dcchongyi",
|
||
trigger: { global: "phaseUseEnd" },
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
if (!event.player.isIn()) return false;
|
||
var history = event.player.getHistory("useCard", function (evt) {
|
||
return evt.getParent("phaseUse") == event;
|
||
});
|
||
return history.length && history[history.length - 1].card.name == "sha";
|
||
},
|
||
prompt2(event, player) {
|
||
const target = event.player;
|
||
const history = target.getHistory("useCard", evt => {
|
||
return evt.getParent("phaseUse") === event;
|
||
});
|
||
const evt = history.lastItem,
|
||
cards = evt.cards.filterInD("d");
|
||
let str = "令" + get.translation(target) + "本回合的手牌上限+1";
|
||
if (cards.length) str += `，然后你获得${get.translation(cards)}`;
|
||
str += "。";
|
||
return str;
|
||
},
|
||
check: function (event, player) {
|
||
return get.attitude(player, event.player) > 0;
|
||
},
|
||
async content(event, trigger, player) {
|
||
const target = trigger.player;
|
||
target.addMark("dcchongyi_keep", 1, false);
|
||
target.addTempSkill("dcchongyi_keep");
|
||
const history = target.getHistory("useCard", evt => {
|
||
return evt.getParent("phaseUse") === trigger;
|
||
});
|
||
const evt = history.lastItem,
|
||
cards = evt.cards.filterInD("d");
|
||
if (cards.length) await player.gain(cards, "gain2");
|
||
else await game.asyncDelayx();
|
||
},
|
||
},
|
||
sha: {
|
||
charlotte: true,
|
||
mod: {
|
||
cardUsable: function (card, player, num) {
|
||
if (card.name == "sha") return num + player.countMark("dcchongyi_sha");
|
||
},
|
||
},
|
||
onremove: true,
|
||
intro: { content: "使用【杀】的次数上限+#" },
|
||
},
|
||
keep: {
|
||
charlotte: true,
|
||
mod: {
|
||
maxHandcard: function (player, num) {
|
||
return num + player.countMark("dcchongyi_keep");
|
||
},
|
||
},
|
||
onremove: true,
|
||
intro: { content: "手牌上限+#" },
|
||
},
|
||
},
|
||
},
|
||
//牛辅
|
||
dcxiaoxi: {
|
||
auto: 2,
|
||
trigger: { player: "phaseUseBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player.maxHp > 1;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (player.maxHp <= 2) event._result = { index: 0 };
|
||
else
|
||
player
|
||
.chooseControl("1点", "2点")
|
||
.set("prompt", "宵袭：减少1或2点体力上限")
|
||
.set("ai", function () {
|
||
var player = _status.event.player;
|
||
if (
|
||
!game.hasPlayer(function (current) {
|
||
if (!player.inRange(current) || get.attitude(player, current) >= 0) return false;
|
||
if (
|
||
get.effect(current, { name: "shunshou_copy2" }, player, player) > 0 &&
|
||
current.countCards("h") +
|
||
current.countCards("e", function (card) {
|
||
return get.value(card, current) > 0;
|
||
}) >
|
||
1
|
||
)
|
||
return true;
|
||
if (get.effect(current, { name: "sha" }, player, player) > 0 && current.countCards("hs", "shan") + current.hp > 1) return true;
|
||
})
|
||
)
|
||
return 0;
|
||
return 1;
|
||
});
|
||
"step 1";
|
||
player.loseMaxHp(1 + result.index);
|
||
event.num = 1 + result.index;
|
||
"step 2";
|
||
if (!game.hasPlayer(current => player.inRange(current))) event.finish();
|
||
else
|
||
player
|
||
.chooseTarget(
|
||
"请选择【宵袭】的目标",
|
||
"然后你选择一项：⒈获得该角色的" + get.cnNumber(num) + "张牌。⒉视为对其使用" + get.cnNumber(num) + "张【杀】。",
|
||
function (card, player, target) {
|
||
return player.inRange(target);
|
||
},
|
||
true
|
||
)
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
if (get.attitude(player, target) >= 0) return 0;
|
||
var eff1 = get.effect(target, { name: "shunshou_copy2" }, player, player);
|
||
if (
|
||
eff1 > 0 &&
|
||
target.countCards("h") +
|
||
target.countCards("e", function (card) {
|
||
return get.value(card, target) > 0;
|
||
}) >
|
||
1
|
||
)
|
||
eff1 *= 1.6;
|
||
var eff2 = player.canUse("sha", target) ? get.effect(target, { name: "sha" }, player, player) : 0;
|
||
if (eff2 > 0 && target.countCards("hs", "shan") + target.hp > 1) eff2 *= 2;
|
||
return Math.max(eff1, eff2);
|
||
});
|
||
"step 3";
|
||
var target = result.targets[0];
|
||
player.line(target, "green");
|
||
event.target = target;
|
||
var bool1 = target.countGainableCards(player, "he") > 0;
|
||
var bool2 = player.canUse("sha", target);
|
||
if (!bool1 && !bool2) event.finish();
|
||
else if (bool1 && bool2) {
|
||
var str = get.translation(target),
|
||
numx = get.cnNumber(num);
|
||
player
|
||
.chooseControl()
|
||
.set("choiceList", ["获得" + str + "的" + numx + "张牌", "视为对" + str + "使用" + numx + "张【杀】"])
|
||
.set("ai", function () {
|
||
var player = _status.event.player,
|
||
target = _status.event.getParent().target;
|
||
var eff1 = get.effect(target, { name: "shunshou_copy2" }, player, player);
|
||
if (
|
||
eff1 > 0 &&
|
||
target.countCards("h") +
|
||
target.countCards("e", function (card) {
|
||
return get.value(card, target) > 0;
|
||
}) >
|
||
1
|
||
)
|
||
eff1 *= 1.6;
|
||
var eff2 = player.canUse("sha", target) ? get.effect(target, { name: "sha" }, player, player) : 0;
|
||
if (eff2 > 0 && target.countCards("hs", "shan") + target.hp > 1) eff2 *= 2;
|
||
return eff1 > eff2 ? 0 : 1;
|
||
});
|
||
} else event._result = { index: bool1 ? 0 : 1 };
|
||
"step 4";
|
||
if (result.index == 0) {
|
||
player.gainPlayerCard(target, true, num, "he");
|
||
event.finish();
|
||
}
|
||
"step 5";
|
||
event.num--;
|
||
if (player.canUse("sha", target, false)) {
|
||
player.useCard({ name: "sha", isCard: true }, target, false);
|
||
if (event.num > 0) event.redo();
|
||
}
|
||
},
|
||
ai: {
|
||
halfneg: true
|
||
},
|
||
},
|
||
xiongrao: {
|
||
audio: 2,
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
limited: true,
|
||
skillAnimation: true,
|
||
animationColor: "soil",
|
||
prompt: function (event, player) {
|
||
var str = "是否发动【熊扰】？";
|
||
str += "（可摸" + get.cnNumber(Math.max(0, 7 - player.maxHp)) + "张牌）";
|
||
return str;
|
||
},
|
||
logTarget: (event, player) => game.filterPlayer(current => current != player),
|
||
check: function (event, player) {
|
||
return player.maxHp <= 3;
|
||
},
|
||
content: function () {
|
||
player.awakenSkill("xiongrao");
|
||
game.countPlayer(function (current) {
|
||
if (current != player) current.addTempSkill("xiongrao_blocker");
|
||
});
|
||
var num = 7 - player.maxHp;
|
||
if (num > 0) {
|
||
player.gainMaxHp(num);
|
||
player.draw(num);
|
||
}
|
||
},
|
||
subSkill: {
|
||
blocker: {
|
||
init: function (player, skill) {
|
||
player.addSkillBlocker(skill);
|
||
},
|
||
onremove: function (player, skill) {
|
||
player.removeSkillBlocker(skill);
|
||
},
|
||
charlotte: true,
|
||
locked: true,
|
||
skillBlocker: function (skill, player) {
|
||
var info = get.info(skill);
|
||
return info && !info.charlotte && !get.is.locked(skill) && !info.limited && !info.juexingji;
|
||
},
|
||
mark: true,
|
||
marktext: "扰",
|
||
intro: {
|
||
content: function (list, player, skill) {
|
||
var storage = player.getSkills(null, false, false).filter(function (i) {
|
||
return lib.skill.xiongrao_blocker.skillBlocker(i, player);
|
||
});
|
||
if (storage.length) return "失效技能：" + get.translation(storage);
|
||
return "无失效技能";
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//卞喜
|
||
dunxi: {
|
||
audio: 2,
|
||
trigger: { player: "useCard" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
if (!get.tag(event.card, "damage")) return false;
|
||
return event.targets.some(target => target != player && target.isIn());
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var targets = trigger.targets.filter(function (current) {
|
||
return current != player && current.isIn();
|
||
});
|
||
if (targets.length == 1) {
|
||
event.target = targets[0];
|
||
player
|
||
.chooseBool(get.prompt("dunxi", event.target), "令" + get.translation(event.target) + "获得一枚“钝”标记")
|
||
.set("goon", get.attitude(player, event.target) < 0)
|
||
.set("ai", () => _status.event.goon);
|
||
} else {
|
||
player
|
||
.chooseTarget(get.prompt("dunxi"), "选择一名目标角色获得一枚“钝”标记", function (card, player, target) {
|
||
return target != player && _status.event.getTrigger().targets.includes(target);
|
||
})
|
||
.set("ai", function (target) {
|
||
var att = get.attitude(_status.event.player, target);
|
||
if (att >= 0) return 0;
|
||
return -att / (1 + target.hasMark("dunxi"));
|
||
});
|
||
}
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = event.target || result.targets[0];
|
||
player.logSkill("dunxi", target);
|
||
target.addMark("dunxi", 1);
|
||
game.delayx();
|
||
}
|
||
},
|
||
intro: { content: "mark", name2: "钝" },
|
||
group: "dunxi_random",
|
||
subSkill: {
|
||
random: {
|
||
audio: "dunxi",
|
||
trigger: { global: "useCard" },
|
||
forced: true,
|
||
locked: false,
|
||
filter: function (event, player) {
|
||
if (!event.player.hasMark("dunxi") || event.targets.length != 1 || event._dunxi || _status.dying.length) return false;
|
||
var type = get.type2(event.card, false);
|
||
return type == "basic" || type == "trick";
|
||
},
|
||
logTarget: "player",
|
||
line: "fire",
|
||
content: function () {
|
||
"step 0";
|
||
trigger._dunxi = true;
|
||
trigger.player.removeMark("dunxi", 1);
|
||
var target = trigger.targets[0];
|
||
event.target = target;
|
||
trigger.targets.remove(target);
|
||
//trigger.triggeredTargets1.remove(target);
|
||
trigger.untrigger();
|
||
game.delayx();
|
||
"step 1";
|
||
var list;
|
||
if (get.type(event.card) != "delay")
|
||
list = game.filterPlayer(function (current) {
|
||
return lib.filter.targetEnabled2(trigger.card, trigger.player, current);
|
||
});
|
||
else
|
||
list = game.filterPlayer(function (current) {
|
||
return current.canAddJudge(event.card);
|
||
});
|
||
if (list.length) target = list.randomGet();
|
||
trigger.targets.push(target);
|
||
trigger.player.line(target, "fire");
|
||
game.log(trigger.card, "的目标被改为", target);
|
||
if (target == event.target) {
|
||
trigger.player.loseHp();
|
||
var evt = trigger.getParent("phaseUse");
|
||
if (evt && evt.player == trigger.player) evt.skipped = true;
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//冯方
|
||
dcditing: {
|
||
audio: 2,
|
||
trigger: { global: "phaseUseBegin" },
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
return player.hp > 0 && event.player.countCards("h") > 0 && event.player.inRange(player);
|
||
},
|
||
prompt2: (event, player) => "观看其" + get.cnNumber(Math.min(player.hp, event.player.countCards("h"))) + "张手牌并选择其中一张",
|
||
check: function (event, player) {
|
||
var target = event.player;
|
||
if (get.attitude(player, target) > 0) return true;
|
||
if (Math.min(player.hp, target.countCards("h")) > 2) return true;
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var target = trigger.player;
|
||
var cards = target.getCards("h");
|
||
var num = Math.min(cards.length, player.hp),
|
||
cards2 = cards.randomGets(num);
|
||
player.chooseButton([get.translation(target) + "的手牌（" + num + "/" + cards.length + "）", cards2], true).set("ai", function (button) {
|
||
var player = _status.event.player,
|
||
target = _status.event.getTrigger().player,
|
||
card = button.link;
|
||
var att = get.attitude(player, target);
|
||
var val = target.getUseValue(card, null, true);
|
||
if (val <= 0) return (-get.value(card, target) / 2) * get.sgn(att - 0.05);
|
||
if (target.canUse(card, player) && get.effect(player, card, target, target) > 0) {
|
||
var eff = get.effect(player, card, target, player);
|
||
if (eff < 0) val -= eff;
|
||
}
|
||
return val;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.addTempSkill("dcditing_effect", "phaseUseAfter");
|
||
player.storage.dcditing_effect = [trigger.player, result.links[0]];
|
||
}
|
||
},
|
||
subSkill: {
|
||
effect: {
|
||
audio: "dcditing",
|
||
charlotte: true,
|
||
trigger: { target: "useCardToTargeted" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
var list = player.storage.dcditing_effect;
|
||
return list && event.player == list[0] && event.cards.includes(list[1]);
|
||
},
|
||
content: function () {
|
||
trigger.excluded.add(player);
|
||
game.delayx();
|
||
},
|
||
group: ["dcditing_draw", "dcditing_gain"],
|
||
},
|
||
draw: {
|
||
audio: "dcditing",
|
||
charlotte: true,
|
||
trigger: { global: "useCardAfter" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
var list = player.storage.dcditing_effect;
|
||
return list && event.player == list[0] && event.cards.includes(list[1]) && !event.targets.includes(player);
|
||
},
|
||
content: function () {
|
||
player.draw(2);
|
||
},
|
||
},
|
||
gain: {
|
||
audio: "dcditing",
|
||
charlotte: true,
|
||
trigger: { global: "phaseUseEnd" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
var list = player.storage.dcditing_effect;
|
||
return list && event.player == list[0] && event.player.getCards("h").includes(list[1]);
|
||
},
|
||
content: function () {
|
||
var list = player.storage.dcditing_effect;
|
||
player.gain(list[0], list[1], "giveAuto", "bySelf");
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dcbihuo: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "damageEnd",
|
||
source: "damageSource",
|
||
},
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return event.source && event.player != event.source;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.num = event.triggername == "damageEnd" ? 1 : -1;
|
||
player.chooseTarget(get.prompt("dcbihuo"), "令一名角色下回合的额定摸牌数" + (event.num > 0 ? "+1" : "-1")).set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
num = _status.event.getParent().num;
|
||
var att = get.attitude(player, target);
|
||
if (num > 0) {
|
||
if (att <= 0) return 0;
|
||
if (target.hasJudge("lebu")) return att / 10;
|
||
return (att / Math.sqrt(Math.min(5, 1 + target.countCards("h")))) * Math.sqrt(1 + target.hp);
|
||
}
|
||
if (num < 0) {
|
||
if (att >= 0) return 0;
|
||
if ((target.storage.dcbihuo_effect || 0) <= -2) return -att / 10;
|
||
return (-att / Math.sqrt(Math.min(5, 1 + target.countCards("h")))) * Math.sqrt(1 + target.hp);
|
||
}
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("dcbihuo", target);
|
||
if (typeof target.storage.dcbihuo_effect != "number") target.storage.dcbihuo_effect = 0;
|
||
target.storage.dcbihuo_effect += event.num;
|
||
target.addTempSkill("dcbihuo_effect", { player: "phaseAfter" });
|
||
game.delayx();
|
||
}
|
||
},
|
||
subSkill: {
|
||
effect: {
|
||
charlotte: true,
|
||
trigger: { player: "phaseDrawBegin" },
|
||
forced: true,
|
||
onremove: true,
|
||
content: function () {
|
||
var num = player.storage.dcbihuo_effect;
|
||
trigger.num += num;
|
||
game.log(player, "的额定摸牌数", "#g" + (num >= 0 ? "+" : "") + num);
|
||
},
|
||
mark: true,
|
||
intro: {
|
||
content: num => "额定摸牌数" + (num >= 0 ? "+" : "") + num,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//秦宜禄
|
||
piaoping: {
|
||
audio: 2,
|
||
trigger: { player: "useCard" },
|
||
forced: true,
|
||
zhuanhuanji: true,
|
||
filter: function (event, player) {
|
||
return !player.hasSkill("piaoping_blocker", null, null, false);
|
||
},
|
||
content: function () {
|
||
player.changeZhuanhuanji("piaoping");
|
||
var num = Math.min(
|
||
player.hp,
|
||
player.getHistory("useSkill", function (evt) {
|
||
return evt.skill == "piaoping";
|
||
}).length
|
||
);
|
||
if (num <= 0) return;
|
||
if (player.storage.piaoping == true) player.draw(num);
|
||
else if (
|
||
player.hasCard(function (card) {
|
||
return lib.filter.cardDiscardable(card, player, "piaoping");
|
||
}, "he")
|
||
) {
|
||
game.delayx();
|
||
player.chooseToDiscard(true, "he", num);
|
||
}
|
||
},
|
||
mark: true,
|
||
marktext: "☯",
|
||
intro: {
|
||
content: function (storage) {
|
||
if (storage) return "转换技，锁定技。当你使用一张牌时，你弃置X张牌。（X为你本阶段内发动过〖漂萍〗的次数且至多等于你的体力值）";
|
||
return "转换技，锁定技。当你使用一张牌时，你摸X张牌。（X为你本阶段内发动过〖漂萍〗的次数且至多等于你的体力值）";
|
||
},
|
||
},
|
||
subSkill: { blocker: { charlotte: true } },
|
||
},
|
||
tuoxian: {
|
||
audio: 2,
|
||
ai: { combo: "piaoping" },
|
||
trigger: { player: "loseAfter" },
|
||
marktext: "栗",
|
||
filter: function (event, player) {
|
||
return event.type == "discard" && event.getParent(3).name == "piaoping" && player.countMark("tuoxian") > 0 && event.cards.filterInD("d").length > 0;
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
event.cards = trigger.cards.filterInD("d");
|
||
player.chooseTarget(lib.filter.notMe, get.prompt("tuoxian"), "令一名其他角色获得" + get.translation(event.cards)).set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
att = get.attitude(player, target);
|
||
if (att < 0) return 0;
|
||
if (target.hasSkillTag("nogain")) att /= 10;
|
||
return att * Math.pow(1 + target.countCards("he"), 0.25);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("tuoxian", target);
|
||
player.removeMark("tuoxian", 1);
|
||
target.gain(cards, "gain2");
|
||
} else event.finish();
|
||
"step 2";
|
||
target
|
||
.chooseControl()
|
||
.set("choiceList", ["弃置区域内的" + get.cnNumber(cards.length) + "张牌", "令" + get.translation(player) + "的〖漂萍〗于本回合内失效"])
|
||
.set("ai", function () {
|
||
var player = _status.event.player,
|
||
target = _status.event.getParent().player;
|
||
if (
|
||
player.hasCard(function (card) {
|
||
return get.effect(player, { name: card.viewAs || card.name }, player, player) < 0;
|
||
}, "j") ||
|
||
player.hasCard(function (card) {
|
||
return get.value(card, player) <= 0;
|
||
})
|
||
)
|
||
return 0;
|
||
if (get.attitude(player, target) <= 0 || !target.isPhaseUsing()) return 1;
|
||
if (
|
||
!target.needsToDiscard() &&
|
||
!target.hasCard(function (card) {
|
||
return !target.hasValueTarget(card, null, true);
|
||
}, "hs")
|
||
)
|
||
return 1;
|
||
return 0;
|
||
});
|
||
"step 3";
|
||
if (result.index == 0) {
|
||
if (target.countCards("j") > 0) target.discardPlayerCard(target, cards.length, true, "hej");
|
||
else target.chooseToDiscard("he", true, cards.length);
|
||
} else player.addTempSkill("piaoping_blocker");
|
||
},
|
||
init(player) {
|
||
player.addMark("tuoxian", 1, false);
|
||
},
|
||
intro: { name2: "栗", content: "剩余可用#次" },
|
||
},
|
||
chuaili: {
|
||
audio: 2,
|
||
trigger: { target: "useCardToTargeted" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (player == event.player || get.color(event.card) != "black") return false;
|
||
if (!player.hasSkill("piaoping", null, null, false)) return false;
|
||
return player.storage.piaoping == true || !player.hasSkill("chuaili_blocker", null, null, false);
|
||
},
|
||
content: function () {
|
||
if (player.storage.piaoping == true) {
|
||
player.changeZhuanhuanji("piaoping");
|
||
} else {
|
||
player.addMark("tuoxian", 1, false);
|
||
if (player.countCards("tuoxian") > 3) player.addTempSkill("chuaili_blocker");
|
||
}
|
||
game.delayx();
|
||
},
|
||
ai: { combo: "piaoping" },
|
||
subSkill: { blocker: { charlotte: true } },
|
||
},
|
||
//闫柔
|
||
choutao: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "useCard",
|
||
target: "useCardToTargeted",
|
||
},
|
||
filter: function (event, player) {
|
||
if (event.card.name != "sha" || !event.player.isIn()) return false;
|
||
if (player == event.player)
|
||
return player.hasCard(function (card) {
|
||
return lib.filter.cardDiscardable(card, player, "choutao");
|
||
}, "he");
|
||
return event.player.hasCard(function (card) {
|
||
return lib.filter.canBeDiscarded(card, player, event.player);
|
||
}, "he");
|
||
},
|
||
check: function (event, player) {
|
||
if (player == event.player) {
|
||
if (
|
||
!player.hasCard(function (card) {
|
||
return get.value(card) <= 5;
|
||
}, "he")
|
||
)
|
||
return false;
|
||
for (var i of event.targets) {
|
||
var eff1 = get.damageEffect(i, player, player);
|
||
if (eff1 < 0) return false;
|
||
if (i.hasShan() && eff1 > 0) return true;
|
||
}
|
||
var sha = false;
|
||
return (
|
||
player.getCardUsable({ name: "sha" }) <= 0 &&
|
||
player.hasCard(function (card) {
|
||
if (!sha && get.name(card) == "sha" && player.getUseValue(card) > 0) {
|
||
sha = true;
|
||
return false;
|
||
}
|
||
return sha && get.value(card) <= 5;
|
||
}, "hs")
|
||
);
|
||
} else {
|
||
var eff1 = get.effect(event.player, { name: "guohe_copy2" }, player, player);
|
||
var eff2 = get.damageEffect(player, event.player, player);
|
||
if (!player.hasShan()) return eff1 > 0;
|
||
if (eff2 > 0) return eff1 > 0;
|
||
return player.hp > 2 && eff2 < eff1;
|
||
}
|
||
},
|
||
logTarget: "player",
|
||
shaRelated: true,
|
||
content: function () {
|
||
"step 0";
|
||
if (player != game.me && !player.isOnline() && !player.isUnderControl()) game.delayx();
|
||
if (player == trigger.player)
|
||
player.chooseToDiscard("he", true).set("ai", function (card) {
|
||
var player = _status.event.player;
|
||
var val = player.getUseValue(card);
|
||
if (get.name(card) == "sha" && player.getUseValue(card) > 0) val += 5;
|
||
return 20 - val;
|
||
});
|
||
else player.discardPlayerCard(trigger.player, true, "he");
|
||
"step 1";
|
||
trigger.directHit.addArray(game.players);
|
||
if (player == trigger.player && trigger.addCount !== false) {
|
||
trigger.addCount = false;
|
||
player.getStat().card.sha--;
|
||
}
|
||
},
|
||
},
|
||
xiangshu: {
|
||
audio: 2,
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
direct: true,
|
||
limited: true,
|
||
skillAnimation: true,
|
||
animationColor: "gray",
|
||
filter: function (event, player) {
|
||
return (player.getStat("damage") || 0) > 0 && game.hasPlayer(current => current.isDamaged());
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.num = Math.min(5, player.getStat("damage"));
|
||
player
|
||
.chooseTarget("是否发动限定技【襄戍】？", "令一名角色回复" + event.num + "点体力并摸" + get.cnNumber(event.num) + "张牌", function (card, player, target) {
|
||
return target.isDamaged();
|
||
})
|
||
.set("ai", function (target) {
|
||
var num = _status.event.getParent().num,
|
||
player = _status.event.player;
|
||
var att = get.attitude(player, target);
|
||
if (att > 0 && num >= Math.min(player.hp, 2)) return att * Math.sqrt(target.getDamagedHp());
|
||
return 0;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.awakenSkill("xiangshu");
|
||
player.logSkill("xiangshu", target);
|
||
target.recover(num);
|
||
target.draw(num);
|
||
if (player != target) player.addExpose(0.2);
|
||
}
|
||
},
|
||
},
|
||
//朱灵
|
||
dczhanyi: {
|
||
audio: 2,
|
||
trigger: { player: "phaseUseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
var list = ["basic", "trick", "equip"];
|
||
var list2 = [];
|
||
var hs = player.getCards("he");
|
||
for (var card of hs) {
|
||
var type = get.type2(card, player);
|
||
if (list.includes(type)) {
|
||
var bool = lib.filter.cardDiscardable(card, player, "dczhanyi");
|
||
if (bool) list2.add(type);
|
||
else {
|
||
list.remove(type);
|
||
list2.remove(type);
|
||
}
|
||
}
|
||
}
|
||
return list2.length > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var list = ["basic", "trick", "equip"];
|
||
var list2 = [];
|
||
var hs = player.getCards("he");
|
||
for (var card of hs) {
|
||
var type = get.type2(card, player);
|
||
if (list.includes(type)) {
|
||
var bool = lib.filter.cardDiscardable(card, player, "dczhanyi");
|
||
if (bool) list2.add(type);
|
||
else {
|
||
list.remove(type);
|
||
list2.remove(type);
|
||
}
|
||
}
|
||
}
|
||
player
|
||
.chooseControl(list2, "cancel2")
|
||
.set("prompt", get.prompt("dczhanyi"))
|
||
.set("prompt2", "弃置一种类型的所有牌")
|
||
.set("ai", function () {
|
||
var player = _status.event.player;
|
||
var getval = function (control) {
|
||
if (control == "cancel2") return 0;
|
||
var hs = player.getCards("h"),
|
||
eff = 0;
|
||
var es = player.getCards("e");
|
||
var ss = player.getCards("s");
|
||
var sha = player.getCardUsable({ name: "sha" });
|
||
for (var i of hs) {
|
||
var type = get.type2(i);
|
||
if (type == control) {
|
||
eff -= get.value(i, player);
|
||
} else {
|
||
switch (type) {
|
||
case "basic":
|
||
if (sha > 0 && get.name(i) == "sha") {
|
||
sha--;
|
||
var add = 3;
|
||
if (!player.hasValueTarget(i) && player.hasValueTarget(i, false)) add += player.getUseValue(i, false);
|
||
eff += add;
|
||
}
|
||
break;
|
||
case "trick":
|
||
if (player.hasValueTarget(i)) eff += 6;
|
||
break;
|
||
case "equip":
|
||
if (player.hasValueTarget({ name: "guohe_copy2" })) eff += player.getUseValue({ name: "guohe_copy2" });
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (control == "equip") {
|
||
for (var i of es) eff -= get.value(i, player);
|
||
} else {
|
||
for (var i of ss) {
|
||
var type = get.type2(i);
|
||
if (type == control) continue;
|
||
switch (type) {
|
||
case "basic":
|
||
if (sha > 0 && get.name(i) == "sha") {
|
||
sha--;
|
||
var add = 3;
|
||
if (!player.hasValueTarget(i) && player.hasValueTarget(i, false)) add += player.getUseValue(i, false);
|
||
eff += add;
|
||
}
|
||
break;
|
||
case "trick":
|
||
if (player.hasValueTarget(i)) eff += 6;
|
||
break;
|
||
case "equip":
|
||
if (player.hasValueTarget({ name: "guohe_copy2" })) eff += player.getUseValue({ name: "guohe_copy2" });
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return eff;
|
||
};
|
||
var controls = _status.event.controls.slice(0);
|
||
var eff = 0,
|
||
current = "cancel2";
|
||
for (var i of controls) {
|
||
var effx = getval(i);
|
||
if (effx > eff) {
|
||
eff = effx;
|
||
current = i;
|
||
}
|
||
}
|
||
return current;
|
||
});
|
||
"step 1";
|
||
var type = result.control;
|
||
if (type != "cancel2") {
|
||
event.type = type;
|
||
var cards = player.getCards("he", function (card) {
|
||
return get.type2(card, player) == type;
|
||
});
|
||
if (cards.length) {
|
||
player.logSkill("dczhanyi");
|
||
player.discard(cards);
|
||
} else event.finish();
|
||
} else event.finish();
|
||
"step 2";
|
||
var list = ["basic", "trick", "equip"];
|
||
for (var i of list) {
|
||
if (i != event.type) player.addTempSkill("dczhanyi_" + i, { player: "phaseBegin" });
|
||
}
|
||
},
|
||
subSkill: {
|
||
basic: {
|
||
charlotte: true,
|
||
marktext: "基",
|
||
mark: true,
|
||
intro: {
|
||
content: "使用基本牌无距离限制，且伤害值和回复值基数+1",
|
||
},
|
||
trigger: { source: ["damageBegin1", "recoverBegin"] },
|
||
filter: function (event, player) {
|
||
var evt = event.getParent();
|
||
return evt.type == "card" && get.type(evt.card, false) == "basic";
|
||
},
|
||
forced: true,
|
||
logTarget: "player",
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
mod: {
|
||
targetInRange: function (card) {
|
||
if (get.type(card) == "basic") return true;
|
||
},
|
||
},
|
||
ai: {
|
||
damageBonus: true,
|
||
},
|
||
},
|
||
trick: {
|
||
charlotte: true,
|
||
marktext: "锦",
|
||
mark: true,
|
||
intro: {
|
||
content: "使用锦囊牌时摸一张牌，且锦囊牌不计入本回合的手牌上限",
|
||
},
|
||
trigger: { player: "useCard" },
|
||
filter: function (event, player) {
|
||
return get.type2(event.card) == "trick";
|
||
},
|
||
forced: true,
|
||
content: function () {
|
||
player.draw();
|
||
},
|
||
mod: {
|
||
ignoredHandcard: function (card, player) {
|
||
if (get.type2(card, player) == "trick") return true;
|
||
},
|
||
cardDiscardable: function (card, player, name) {
|
||
if (name == "phaseDiscard" && get.type2(card, player) == "trick") return false;
|
||
},
|
||
},
|
||
},
|
||
equip: {
|
||
charlotte: true,
|
||
marktext: "装",
|
||
mark: true,
|
||
intro: {
|
||
content: "有装备牌进入你的装备区时，可弃置一名其他角色的一张牌",
|
||
},
|
||
trigger: { player: "equipAfter" },
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(target => target != player && target.countDiscardableCards(player, "he") > 0);
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget("战意：是否弃置一名其他角色的一张牌？", function (card, player, target) {
|
||
return target != player && target.countDiscardableCards(player, "he") > 0;
|
||
})
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return get.effect(target, { name: "guohe_copy2" }, player, player);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("dczhanyi_equip", target);
|
||
player.discardPlayerCard(target, "he", true);
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//李采薇
|
||
yijiao: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(function (current) {
|
||
return current != player && !current.hasMark("yijiao");
|
||
});
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && !target.hasMark("yijiao");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseControl("10个", "20个", "30个", "40个")
|
||
.set("prompt", "要令" + get.translation(target) + "获得多少标记？")
|
||
.set("ai", function () {
|
||
var player = _status.event.player,
|
||
target = _status.event.getParent().target;
|
||
/*if(get.attitude(player,target)<0&&game.hasPlayer(function(current){
|
||
return current!=player&¤t!=target&&!current.hasMark('yijiao')&&get.attitude(player,current)<0;
|
||
})) return 3;*/
|
||
return 0;
|
||
});
|
||
"step 1";
|
||
target.addMark("yijiao", 10 * (1 + result.index));
|
||
},
|
||
ai: {
|
||
order: 1.1,
|
||
result: {
|
||
player: 1,
|
||
target: -0.5,
|
||
},
|
||
},
|
||
group: "yijiao_effect",
|
||
subSkill: {
|
||
effect: {
|
||
trigger: { global: "phaseJieshuBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return event.player.isIn() && event.player != player && event.player.hasMark("yijiao");
|
||
},
|
||
logTarget: "player",
|
||
content: function () {
|
||
var target = trigger.player,
|
||
num = target.countMark("yijiao");
|
||
var num2 = 0;
|
||
target.getHistory("useCard", function (evt) {
|
||
var numz = get.number(evt.card);
|
||
if (typeof numz == "number") num2 += numz;
|
||
});
|
||
if (num > num2) {
|
||
var hs = target.getCards("he", function (card) {
|
||
return lib.filter.cardDiscardable(card, target, "yijiao_effect");
|
||
});
|
||
if (hs.length) target.discard(hs.randomGets(get.rand(1, 3)));
|
||
} else if (num == num2) {
|
||
target.insertPhase();
|
||
player.draw(2);
|
||
} else {
|
||
player.draw(3);
|
||
}
|
||
target.removeMark("yijiao", num);
|
||
},
|
||
},
|
||
},
|
||
intro: {
|
||
onunmark: true,
|
||
name2: "异",
|
||
content: "mark",
|
||
},
|
||
},
|
||
qibie: {
|
||
audio: 2,
|
||
trigger: { global: "die" },
|
||
filter: function (event, player) {
|
||
return (
|
||
player.countCards("h") > 0 &&
|
||
!player.hasCard(function (card) {
|
||
return !lib.filter.cardDiscardable(card, player, "qibie");
|
||
}, "h")
|
||
);
|
||
},
|
||
check: function (event, player) {
|
||
return player.isDamaged() && player.countCards("h", "tao") < Math.max(2, player.hp);
|
||
},
|
||
content: function () {
|
||
var hs = player.getCards("h");
|
||
player.discard(hs);
|
||
player.recover();
|
||
player.draw(hs.length + 2);
|
||
},
|
||
},
|
||
//严夫人
|
||
channi: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return player.countCards("h") > 0;
|
||
},
|
||
filterTarget: lib.filter.notMe,
|
||
filterCard: true,
|
||
selectCard: [1, Infinity],
|
||
check: function (card) {
|
||
let player = _status.event.player,
|
||
num = player.hasSkill("nifu") ? 15 : 8;
|
||
if (ui.selected.cards.length <= Math.max(1, player.needsToDiscard(), player.countCards("h") - 4)) return num - get.value(card);
|
||
return num / 2 - get.value(card);
|
||
},
|
||
position: "h",
|
||
discard: false,
|
||
lose: false,
|
||
delay: false,
|
||
content: function () {
|
||
"step 0";
|
||
player.give(cards, target);
|
||
"step 1";
|
||
if (target.countCards("h") > 0) {
|
||
game.broadcastAll(function (num) {
|
||
lib.skill.channi_backup.selectCard = [1, num];
|
||
}, cards.length);
|
||
var next = target.chooseToUse();
|
||
next.set("openskilldialog", "将至多" + get.cnNumber(cards.length) + "张手牌当做【决斗】使用");
|
||
next.set("norestore", true);
|
||
next.set("addCount", false);
|
||
next.set("_backupevent", "channi_backup");
|
||
next.set("custom", {
|
||
add: {},
|
||
replace: { window: function () {} },
|
||
});
|
||
next.backup("channi_backup");
|
||
} else event.finish();
|
||
"step 2";
|
||
if (result.bool) {
|
||
var evts = target.getHistory("useCard", function (evt) {
|
||
return evt.card.name == "juedou" && evt.getParent(2) == event;
|
||
});
|
||
if (!evts.length) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
var num = evts[0].cards.length;
|
||
if (
|
||
target.hasHistory("sourceDamage", function (evt) {
|
||
return evt.card && evt.card.name == "juedou" && evt.getParent(4) == event;
|
||
})
|
||
)
|
||
target.draw(num);
|
||
} else event.finish();
|
||
"step 3";
|
||
if (
|
||
player.countCards("h") > 0 &&
|
||
target.hasHistory("damage", function (evt) {
|
||
return evt.card && evt.card.name == "juedou" && evt.getParent(4) == event;
|
||
})
|
||
)
|
||
player.chooseToDiscard("h", true, player.countCards("h"));
|
||
},
|
||
subSkill: {
|
||
backup: {
|
||
filterCard: function (card) {
|
||
return get.itemtype(card) == "card";
|
||
},
|
||
viewAs: { name: "juedou" },
|
||
position: "h",
|
||
filterTarget: lib.filter.targetEnabled,
|
||
ai1: card => {
|
||
if (get.name(card) === "sha") return 0;
|
||
return 5.5 - get.value(card);
|
||
},
|
||
log: false,
|
||
precontent: function () {
|
||
delete event.result.skill;
|
||
},
|
||
},
|
||
},
|
||
ai: {
|
||
order: 0.3,
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target == game.me || target.isOnline() || target.hasValueTarget({ name: "juedou" })) return 2;
|
||
if (player.needsToDiscard()) return 0.5;
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
nifu: {
|
||
audio: 2,
|
||
trigger: { global: "phaseEnd" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("h") != 3;
|
||
},
|
||
content: function () {
|
||
var num = player.countCards("h") - 3;
|
||
if (num > 0) player.chooseToDiscard("h", num, true);
|
||
else player.draw(-num);
|
||
},
|
||
},
|
||
//郝萌
|
||
xiongmang: {
|
||
audio: 2,
|
||
enable: "chooseToUse",
|
||
viewAs: { name: "sha" },
|
||
viewAsFilter: function (player) {
|
||
return player.countCards("hs") > 0;
|
||
},
|
||
selectCard: function () {
|
||
return [1, 4];
|
||
},
|
||
selectTarget: function () {
|
||
var card = get.card(),
|
||
player = get.player();
|
||
if (card == undefined) return;
|
||
var range = [1, Math.max(1, ui.selected.cards.length)];
|
||
game.checkMod(card, player, range, "selectTarget", player);
|
||
return range;
|
||
},
|
||
complexCard: true,
|
||
filterCard: function (card) {
|
||
if (!ui.selected.cards.length) return true;
|
||
var suit = get.suit(card);
|
||
for (var i of ui.selected.cards) {
|
||
if (get.suit(i) == suit) return false;
|
||
}
|
||
return true;
|
||
},
|
||
filterOk: function () {
|
||
if (!ui.selected.targets.length) return false;
|
||
var card = get.card(),
|
||
player = get.player();
|
||
if (card == undefined) return;
|
||
var range = [1, Math.max(1, ui.selected.cards.length)];
|
||
game.checkMod(card, player, range, "selectTarget", player);
|
||
if ((range[0] <= ui.selected.targets.length && range[1] >= ui.selected.targets.length) || range[0] == -1) return true;
|
||
return false;
|
||
},
|
||
check: function (card) {
|
||
var player = _status.event.player,
|
||
card = get.autoViewAs({ name: "sha" }, ui.selected.cards.concat(card));
|
||
if (
|
||
game.countPlayer(function (current) {
|
||
return (_status.event.filterTarget || lib.filter.filterTarget)(card, player, current) && get.effect_use(current, card, player, player) > 0;
|
||
}) <= ui.selected.cards.length
|
||
)
|
||
return 0;
|
||
return 5 - get.value(card);
|
||
},
|
||
position: "hs",
|
||
onuse: function (links, player) {
|
||
player.addTempSkill("xiongmang_effect");
|
||
},
|
||
ai: {
|
||
order: () => get.order({ name: "sha" }) + 0.2,
|
||
respondSha: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
return player.countCards("hs") > 0;
|
||
},
|
||
},
|
||
subSkill: {
|
||
effect: {
|
||
trigger: { player: "useCardAfter" },
|
||
forced: true,
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
player.maxHp > 1 &&
|
||
event.skill == "xiongmang" &&
|
||
!player.hasHistory("sourceDamage", function (evt) {
|
||
return evt.card == event.card;
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
player.loseMaxHp();
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//庞德公
|
||
heqia: {
|
||
audio: 2,
|
||
trigger: { player: "phaseUseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(current => current.countCards(current == player ? "he" : "h") > 0);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseCardTarget({
|
||
prompt: get.prompt("heqia"),
|
||
prompt2: "操作提示：选择要给出的牌和目标角色，或直接选择一名目标角色，令其将牌交给自己",
|
||
filterCard: true,
|
||
position: "he",
|
||
selectCard: function () {
|
||
if (ui.selected.targets.length && !ui.selected.targets[0].countCards("h")) return [1, Infinity];
|
||
return [0, Infinity];
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
if (player == target) return false;
|
||
if (!ui.selected.cards.length) return target.countCards("h") > 0;
|
||
return true;
|
||
},
|
||
ai1: function (card) {
|
||
if (!_status.event.nogive || ui.selected.cards.length) return 0 - get.value(card);
|
||
return 1 / Math.max(1, get.value(card));
|
||
},
|
||
ai2: function (target) {
|
||
return (get.attitude(player, target) - 0.1) * (ui.selected.cards.length ? 1 : -1);
|
||
},
|
||
nogive: !game.hasPlayer(function (current) {
|
||
return current != player && get.attitude(player, current) <= 0 && current.countCards("h") > 0;
|
||
}),
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("heqia", target);
|
||
if (result.cards.length) {
|
||
player.give(result.cards, target);
|
||
event.source = target;
|
||
event.num = result.cards.length;
|
||
event.goto(4);
|
||
}
|
||
} else event.finish();
|
||
"step 2";
|
||
var he = target.getCards("he");
|
||
if (he.length > 0) {
|
||
if (he.length > 1) target.chooseCard("he", true, [1, Infinity], "选择交给" + get.translation(player) + "任意张牌").set("ai", card => -get.value(card));
|
||
else event._result = { bool: true, cards: he };
|
||
} else event.finish();
|
||
"step 3";
|
||
if (result.bool) {
|
||
event.source = player;
|
||
target.give(result.cards, player);
|
||
event.num = result.cards.length;
|
||
} else event.finish();
|
||
"step 4";
|
||
if (source && source.isIn() && source.countCards("h") > 0) {
|
||
var list = [];
|
||
for (var name of lib.inpile) {
|
||
if (get.type(name) != "basic") continue;
|
||
if (source.hasUseTarget({ name: name }, false)) list.push(["基本", "", name]);
|
||
if (name == "sha") {
|
||
for (var nature of lib.inpile_nature) {
|
||
if (source.hasUseTarget({ name: name, nature: nature }, false)) list.push(["基本", "", name, nature]);
|
||
}
|
||
}
|
||
}
|
||
if (list.length) {
|
||
source.chooseButton(["是否将一张手牌当做一种基本牌使用？", [list, "vcard"]]).set("ai", button => _status.event.player.getUseValue({ name: button.link[2], nature: button.link[3] }, false));
|
||
} else event.finish();
|
||
} else event.finish();
|
||
"step 5";
|
||
if (result.bool) {
|
||
var card = { name: result.links[0][2], nature: result.links[0][3] };
|
||
game.broadcastAll(function (card) {
|
||
lib.skill.heqia_backup.viewAs = card;
|
||
}, card);
|
||
var next = source.chooseToUse();
|
||
next.set("openskilldialog", "将一张手牌当做" + get.translation(card) + "使用");
|
||
next.set("norestore", true);
|
||
next.set("addCount", false);
|
||
next.set("_backupevent", "heqia_backup");
|
||
next.set("custom", {
|
||
add: {},
|
||
replace: { window: function () {} },
|
||
});
|
||
next.backup("heqia_backup");
|
||
}
|
||
},
|
||
group: "heqia_add",
|
||
subSkill: {
|
||
backup: {
|
||
filterCard: function (card) {
|
||
return get.itemtype(card) == "card";
|
||
},
|
||
position: "h",
|
||
filterTarget: lib.filter.targetEnabled,
|
||
selectCard: 1,
|
||
check: card => 6 - get.value(card),
|
||
log: false,
|
||
precontent: function () {
|
||
delete event.result.skill;
|
||
},
|
||
},
|
||
add: {
|
||
trigger: { global: "useCard2" },
|
||
charlotte: true,
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
var evt = event.getParent(2);
|
||
if (evt.name != "heqia" || evt.player != player || !event.targets || evt.num <= event.targets.length) return false;
|
||
var card = event.card,
|
||
info = get.info(card);
|
||
if (info.allowMultiple == false) return false;
|
||
if (event.targets && !info.multitarget) {
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return !event.targets.includes(current) && lib.filter.targetEnabled2(card, event.player, current);
|
||
})
|
||
) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var num = trigger.getParent(2).num - trigger.targets.length;
|
||
var prompt2 = "是否为" + get.translation(trigger.card) + "增加至多" + get.cnNumber(num) + "个目标？";
|
||
trigger.player
|
||
.chooseTarget(prompt2, [1, num], function (card, player, target) {
|
||
var player = _status.event.player;
|
||
return !_status.event.targets.includes(target) && lib.filter.targetEnabled2(_status.event.card, player, target);
|
||
})
|
||
.set("ai", function (target) {
|
||
var trigger = _status.event.getTrigger();
|
||
var player = _status.event.player;
|
||
return get.effect(target, trigger.card, player, player);
|
||
})
|
||
.set("card", trigger.card)
|
||
.set("targets", trigger.targets);
|
||
"step 1";
|
||
if (result.bool) {
|
||
trigger.player.line(result.targets);
|
||
game.log(result.targets, "也成为了", trigger.card, "的目标");
|
||
trigger.targets.addArray(result.targets);
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
yinyi: {
|
||
audio: 2,
|
||
trigger: { player: "damageBegin1" },
|
||
forced: true,
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return event.source && event.source.hp != player.hp && !event.hasNature("linked") && event.source.countCards("h") != player.countCards("h");
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
},
|
||
ai: {
|
||
effect: {
|
||
target: function (card, player, target, current) {
|
||
if (get.tag(card, "damage")) {
|
||
if (player.hp == target.hp || lib.linked.includes(get.nature(card))) return;
|
||
var cards = [card];
|
||
if (card.cards && card.cards.length) cards.addArray(card.cards);
|
||
if (ui.selected.cards.length) cards.addArray(ui.selected.cards);
|
||
if (
|
||
player.countCards("h", function (card) {
|
||
return !cards.includes(card);
|
||
}) == target.countCards("h")
|
||
)
|
||
return;
|
||
return "zeroplayertarget";
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//韩猛
|
||
jieliang: {
|
||
trigger: { global: "phaseDrawBegin2" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return event.player != player && !event.numFixed && event.num > 1 && player.countCards("he") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.target = trigger.player;
|
||
player
|
||
.chooseToDiscard(get.prompt2("jieliang", event.target), "he")
|
||
.set("goon", get.attitude(player, trigger.player) < -2)
|
||
.set("ai", function (card) {
|
||
if (!_status.event.goon) return 0;
|
||
return 7 - get.value(card);
|
||
}).logSkill = ["jieliang", event.target];
|
||
"step 1";
|
||
if (result.bool) {
|
||
trigger.num--;
|
||
if (get.mode() != "identity" || player.identity != "nei") player.addExpose(0.15);
|
||
target.addMark("jieliang_less", 1, false);
|
||
target.addTempSkill("jieliang_less");
|
||
player.addTempSkill("jieliang_gain");
|
||
}
|
||
},
|
||
subSkill: {
|
||
less: {
|
||
charlotte: true,
|
||
mod: {
|
||
maxHandcard: function (player, num) {
|
||
return num - player.countMark("jieliang_less");
|
||
},
|
||
},
|
||
onremove: true,
|
||
intro: { content: "手牌上限-#" },
|
||
},
|
||
gain: {
|
||
trigger: { global: "loseAfter" },
|
||
charlotte: true,
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return event.type == "discard" && event.player == _status.currentPhase && event.getParent(3).name == "phaseDiscard" && event.cards2.filterInD("d").length > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseButton(["截粮：是否获得一张牌?", trigger.cards2.filterInD("d")]).set("ai", function (button) {
|
||
return get.value(button.link, _status.event.player);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.logSkill("jieliang", trigger.player);
|
||
player.gain(result.links, "gain2");
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
quanjiu: {
|
||
audio: 2,
|
||
mod: {
|
||
aiOrder: function (player, card, num) {
|
||
if ((card.name == "jiu" || card.name == "xujiu") && get.name(card) == "sha") return num + 0.5;
|
||
},
|
||
cardname: function (card, player, name) {
|
||
if (card.name == "jiu" || card.name == "xujiu") return "sha";
|
||
},
|
||
},
|
||
trigger: { player: "useCard1" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return event.addCount !== false && event.card.isCard && event.card.name == "sha" && event.cards.length == 1 && (event.cards[0].name == "jiu" || event.cards[0].name == "xujiu");
|
||
},
|
||
content: function () {
|
||
trigger.addCount = false;
|
||
player.getStat().card.sha--;
|
||
},
|
||
},
|
||
//辛评
|
||
fuyuan: {
|
||
audio: 2,
|
||
trigger: { player: ["useCard", "respond"] },
|
||
filter: function (event, player) {
|
||
var target = _status.currentPhase;
|
||
return target && target != player && target.isIn();
|
||
},
|
||
logTarget: function (event, player) {
|
||
var target = _status.currentPhase;
|
||
return target.countCards("h") < player.countCards("h") ? target : player;
|
||
},
|
||
check: function (event, player) {
|
||
var target = lib.skill.fuyuan.logTarget(event, player);
|
||
return get.attitude(player, target) > 0;
|
||
},
|
||
prompt: "是否发动【辅袁】？",
|
||
prompt2: function (event, player) {
|
||
var target = lib.skill.fuyuan.logTarget(event, player);
|
||
return "令" + get.translation(target) + (target == player ? "（你）" : "") + "摸一张牌";
|
||
},
|
||
content: function () {
|
||
lib.skill.fuyuan.logTarget(trigger, player).draw();
|
||
},
|
||
},
|
||
zhongjie: {
|
||
trigger: { player: "die" },
|
||
direct: true,
|
||
forceDie: true,
|
||
skillAnimation: true,
|
||
animationColor: "gray",
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt2("zhongjie"), lib.filter.notMe).set("ai", function (target) {
|
||
return get.attitude(_status.event.player, target);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
//player.awakenSkill('zhongjie');
|
||
var target = result.targets[0];
|
||
player.logSkill("zhongjie", target);
|
||
target.gainMaxHp();
|
||
target.recover();
|
||
target.draw();
|
||
}
|
||
},
|
||
},
|
||
//张宁
|
||
tianze: {
|
||
audio: 2,
|
||
trigger: { global: "useCardAfter" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
player != event.player &&
|
||
event.player.isIn() &&
|
||
get.color(event.card) == "black" &&
|
||
event.player.hasHistory("lose", function (evt) {
|
||
return evt && evt.hs.length && evt.getParent() == event;
|
||
}) &&
|
||
event.player.isPhaseUsing() &&
|
||
!player.hasSkill("tianze_block")
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.addTempSkill("tianze_block");
|
||
if (
|
||
!player.hasCard(function (card) {
|
||
if (_status.connectMode && get.position(card) == "h") return true;
|
||
return get.color(card, player) == "black";
|
||
}, "he")
|
||
)
|
||
event.finish();
|
||
else
|
||
player
|
||
.chooseToDiscard(
|
||
"he",
|
||
function (card, player) {
|
||
return get.color(card, player) == "black";
|
||
},
|
||
get.prompt("tianze", trigger.player),
|
||
"弃置一张黑色牌并对其造成1点伤害"
|
||
)
|
||
.set("ai", function (card) {
|
||
if (!_status.event.goon) return 0;
|
||
return 8 - get.value(card);
|
||
})
|
||
.set("goon", get.damageEffect(trigger.player, player, player) > 0).logSkill = ["tianze", trigger.player];
|
||
"step 1";
|
||
if (result.bool) {
|
||
if (get.mode() != "identity" || player.identity != "nei") player.addExpose(0.2);
|
||
trigger.player.damage();
|
||
} else event.finish();
|
||
"step 2";
|
||
game.delayx();
|
||
},
|
||
group: "tianze_draw",
|
||
subSkill: {
|
||
block: { charlotte: true },
|
||
draw: {
|
||
trigger: { global: "judgeEnd" },
|
||
forced: true,
|
||
locked: false,
|
||
filter: function (event, player) {
|
||
return event.player != player && event.result && event.result.color == "black";
|
||
},
|
||
content: function () {
|
||
player.draw();
|
||
},
|
||
},
|
||
},
|
||
},
|
||
difa: {
|
||
trigger: { player: "gainAfter" },
|
||
filter: function (event, player) {
|
||
if (player != _status.currentPhase || event.getParent().name != "draw") return false;
|
||
var hs = player.getCards("h");
|
||
if (!hs.length) return false;
|
||
for (var i of event.cards) {
|
||
if (hs.includes(i) && get.color(i, player) == "red" && lib.filter.cardDiscardable(i, player, "difa")) return true;
|
||
}
|
||
return false;
|
||
},
|
||
usable: 1,
|
||
check: function (event, player) {
|
||
var hs = player.getCards("h"),
|
||
cards = event.cards.filter(function (i) {
|
||
return hs.includes(i) && get.color(i, player) == "red" && lib.filter.cardDiscardable(i, player, "difa");
|
||
});
|
||
var value = get.value(hs, player);
|
||
return Array.from(ui.cardPile.childNodes).some(function (card) {
|
||
return get.type2(card, false) == "trick" && get.value(card, player) > value;
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var hs = player.getCards("h"),
|
||
cards = trigger.cards.filter(function (i) {
|
||
return hs.includes(i) && get.color(i, player) == "red" && lib.filter.cardDiscardable(i, player, "difa");
|
||
});
|
||
if (!cards.length) event.finish();
|
||
else {
|
||
event.cards = cards;
|
||
player.discard(cards);
|
||
}
|
||
"step 1";
|
||
var list = lib.inpile.filter(function (i) {
|
||
return get.type2(i, false) == "trick";
|
||
});
|
||
if (!list.length) event.finish();
|
||
else
|
||
player
|
||
.chooseButton(["选择获得一种锦囊牌", [list.map(i => ["锦囊", "", i]), "vcard"]], true)
|
||
.set("ai", function (button) {
|
||
var card = { name: button.link[2] };
|
||
if (!_status.event.list.includes(card.name)) return 0;
|
||
return _status.event.player.getUseValue(card);
|
||
})
|
||
.set(
|
||
"list",
|
||
Array.from(ui.cardPile.childNodes)
|
||
.filter(function (card) {
|
||
return get.type2(card, false) == "trick";
|
||
})
|
||
.map(function (card) {
|
||
return card.name;
|
||
})
|
||
.reduce(function (list, name) {
|
||
if (!list.includes(name)) list.add(name);
|
||
return list;
|
||
}, [])
|
||
);
|
||
"step 2";
|
||
var card = get.cardPile(function (i) {
|
||
return i.name == result.links[0][2] && !event.cards.includes(i);
|
||
});
|
||
if (card) player.gain(card, "gain2");
|
||
},
|
||
},
|
||
//童渊
|
||
chaofeng: {
|
||
audio: 2,
|
||
trigger: { source: "damageBegin1" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("h") > 0 && player.isPhaseUsing() && !player.hasSkill("chaofeng2");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var str = "弃置一张手牌并摸一张牌",
|
||
color,
|
||
type;
|
||
if (trigger.card) {
|
||
type = get.type2(trigger.card, false);
|
||
color = get.color(trigger.card, false);
|
||
if (color != "none") str += "；若弃置" + get.translation(color) + "牌则改为摸两张牌";
|
||
if (type) str += "；若弃置类型为" + get.translation(type) + "的牌则伤害+1";
|
||
}
|
||
var next = player.chooseToDiscard("h", get.prompt("chaofeng", trigger.player), str);
|
||
next.set("ai", function (card) {
|
||
var player = _status.event.player,
|
||
att = _status.event.att;
|
||
var val = 4.2 - get.value(card);
|
||
if (get.color(card) == _status.event.color) val += 3;
|
||
if (get.type2(card) == _status.event.type) {
|
||
if (att < 0) val += 4;
|
||
else if (att === 0) val += 2;
|
||
else val = 0;
|
||
}
|
||
return val;
|
||
});
|
||
next.set("att", get.attitude(player, trigger.player));
|
||
next.logSkill = ["chaofeng", trigger.player];
|
||
if (color != "none") {
|
||
event.color = color;
|
||
next.set("color", color);
|
||
}
|
||
if (type) {
|
||
event.type = type;
|
||
next.set("type", type);
|
||
}
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.addTempSkill("chaofeng2", "phaseUseEnd");
|
||
var card = result.cards[0];
|
||
player.draw(event.color && get.color(card, card.original == "h" ? player : false) == event.color ? 2 : 1);
|
||
if (event.type && get.type2(card, card.original == "h" ? player : false) == event.type) trigger.num++;
|
||
}
|
||
},
|
||
},
|
||
chaofeng2: {},
|
||
chuanshu: {
|
||
audio: 2,
|
||
trigger: { player: ["phaseZhunbeiBegin", "die"] },
|
||
direct: true,
|
||
limited: true,
|
||
forceDie: true,
|
||
filter: function (event, player) {
|
||
return player.isDamaged() && (event.name == "die" || player.isIn());
|
||
},
|
||
skillAnimation: true,
|
||
animationColor: "gray",
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(lib.filter.notMe, get.prompt("chuanshu"), "令一名其他角色获得〖朝凤〗")
|
||
.set("ai", function (target) {
|
||
return get.attitude(_status.event.player, target);
|
||
})
|
||
.set("forceDie", true);
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.awakenSkill("chuanshu");
|
||
player.logSkill("chuanshu", target);
|
||
target.addSkills("chaofeng");
|
||
if (player.isDead()) event.finish();
|
||
} else event.finish();
|
||
"step 2";
|
||
player.addSkills(lib.skill.chuanshu.derivation);
|
||
},
|
||
derivation: ["ollongdan", "drlt_congjian", "chuanyun"],
|
||
},
|
||
longdan_tongyuan: { audio: true },
|
||
ocongjian_tongyuan: { audio: true },
|
||
chuanyun: {
|
||
audio: true,
|
||
trigger: { player: "useCardToPlayered" },
|
||
shaRelated: true,
|
||
filter: function (event, player) {
|
||
return event.card.name == "sha" && event.target.countCards("e") > 0;
|
||
},
|
||
logTarget: "target",
|
||
content: function () {
|
||
var target = trigger.target;
|
||
card = target.getCards("e").randomGet();
|
||
if (card) target.discard(card);
|
||
},
|
||
},
|
||
//南华老仙
|
||
jinghe: {
|
||
enable: "phaseUse",
|
||
filter: function (event, player) {
|
||
return !player.hasSkill("jinghe_clear");
|
||
},
|
||
selectCard: function () {
|
||
if (ui.selected.targets.length) return [ui.selected.targets.length, 4];
|
||
return [1, 4];
|
||
},
|
||
selectTarget: function () {
|
||
return ui.selected.cards.length;
|
||
},
|
||
filterTarget: true,
|
||
filterCard: function (card) {
|
||
if (ui.selected.cards.length) {
|
||
var name = get.name(card);
|
||
for (var i of ui.selected.cards) {
|
||
if (get.name(i) == name) return false;
|
||
}
|
||
}
|
||
return true;
|
||
},
|
||
check: function (card) {
|
||
var player = _status.event.player;
|
||
if (
|
||
game.countPlayer(function (current) {
|
||
return get.attitude(player, current) > 0;
|
||
}) > ui.selected.cards.length
|
||
)
|
||
return 1;
|
||
return 0;
|
||
},
|
||
position: "h",
|
||
complexCard: true,
|
||
discard: false,
|
||
lose: false,
|
||
delay: false,
|
||
multitarget: true,
|
||
multiline: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.showCards(cards, get.translation(player) + "发动了【经合】");
|
||
event.skills = lib.skill.jinghe.derivation.randomGets(4);
|
||
player.addTempSkill("jinghe_clear", { player: "phaseBegin" });
|
||
event.targets.sortBySeat();
|
||
event.num = 0;
|
||
"step 1";
|
||
event.target = targets[num];
|
||
event.num++;
|
||
event.target
|
||
.chooseControl(event.skills, "cancel2")
|
||
.set(
|
||
"choiceList",
|
||
event.skills.map(function (i) {
|
||
return '<div class="skill">【' + get.translation(lib.translate[i + "_ab"] || get.translation(i).slice(0, 2)) + "】</div><div>" + get.skillInfoTranslation(i, player) + "</div>";
|
||
})
|
||
)
|
||
.set("displayIndex", false)
|
||
.set("prompt", "选择获得一个技能");
|
||
"step 2";
|
||
var skill = result.control;
|
||
if (skill != "cancel2") {
|
||
event.skills.remove(skill);
|
||
target.addAdditionalSkills("jinghe_" + player.playerid, skill);
|
||
target.popup(skill);
|
||
}
|
||
if (event.num < event.targets.length) event.goto(1);
|
||
if (target != game.me && !target.isOnline2()) game.delayx();
|
||
},
|
||
ai: {
|
||
threaten: 3,
|
||
order: 10,
|
||
result: {
|
||
target: 1,
|
||
},
|
||
},
|
||
derivation: ["releiji", "rebiyue", "new_retuxi", "remingce", "xinzhiyan", "nhyinbing", "nhhuoqi", "nhguizhu", "nhxianshou", "nhlundao", "nhguanyue", "nhyanzheng"],
|
||
subSkill: {
|
||
clear: {
|
||
onremove: function (player) {
|
||
game.countPlayer(function (current) {
|
||
current.removeAdditionalSkills("jinghe_" + player.playerid);
|
||
});
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gongxiu: {
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.hasSkill("jinghe_clear");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.list1 = [];
|
||
event.list2 = [];
|
||
event.addIndex = 0;
|
||
var choices = [];
|
||
game.countPlayer(function (current) {
|
||
if (current.additionalSkills["jinghe_" + player.playerid]) event.list1.push(current);
|
||
else event.list2.push(current);
|
||
});
|
||
event.list1.sortBySeat();
|
||
if (event.list1.length) choices.push("令" + get.translation(event.list1) + (event.list1.length > 1 ? "各" : "") + "摸一张牌");
|
||
else event.addIndex++;
|
||
event.list2.sortBySeat();
|
||
if (event.list2.length) choices.push("令" + get.translation(event.list2) + (event.list2.length > 1 ? "各" : "") + "弃置一张手牌");
|
||
player
|
||
.chooseControl("cancel2")
|
||
.set("choiceList", choices)
|
||
.set("prompt", get.prompt("gongxiu"))
|
||
.set("", function () {
|
||
var evt = _status.event.getParent();
|
||
if (
|
||
evt.list2.filter(function (current) {
|
||
return get.attitude(player, current) <= 0 && !current.hasSkillTag("noh");
|
||
}).length -
|
||
evt.list1.length >
|
||
1
|
||
)
|
||
return 1 - evt.addIndex;
|
||
return 0;
|
||
});
|
||
"step 1";
|
||
if (result.control != "cancel2") {
|
||
if (result.index + event.addIndex == 0) {
|
||
player.logSkill("gongxiu", event.list1);
|
||
game.asyncDraw(event.list1);
|
||
} else {
|
||
player.logSkill("gongxiu", event.list2);
|
||
for (var i of event.list2) i.chooseToDiscard("h", true);
|
||
event.finish();
|
||
}
|
||
} else event.finish();
|
||
"step 2";
|
||
game.delayx();
|
||
},
|
||
ai: {
|
||
combo: "jinghe",
|
||
},
|
||
},
|
||
nhyinbing: {
|
||
trigger: { source: "damageBefore" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return event.card && event.card.name == "sha";
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
trigger.player.loseHp(trigger.num);
|
||
},
|
||
group: "nhyinbing_draw",
|
||
subSkill: {
|
||
draw: {
|
||
trigger: { global: "loseHpAfter" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player != event.player;
|
||
},
|
||
content: function () {
|
||
player.draw();
|
||
},
|
||
},
|
||
},
|
||
ai: {
|
||
jueqing: true,
|
||
},
|
||
},
|
||
nhhuoqi: {
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return player.countCards("he") > 0;
|
||
},
|
||
position: "he",
|
||
filterCard: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target.isMinHp();
|
||
},
|
||
check: function (card) {
|
||
return 7 - get.value(card);
|
||
},
|
||
content: function () {
|
||
target.recover();
|
||
target.draw();
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
tag: {
|
||
draw: 1,
|
||
recover: 1,
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.isDamaged()) return 3;
|
||
if (ui.selected.cards.length) return 0;
|
||
return 1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
nhguizhu: {
|
||
trigger: { global: "dying" },
|
||
usable: 1,
|
||
logTarget: "player",
|
||
frequent: true,
|
||
content: function () {
|
||
player.draw(2);
|
||
},
|
||
},
|
||
nhxianshou: {
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: true,
|
||
content: function () {
|
||
target.draw(target.isHealthy() ? 2 : 1);
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
tag: {
|
||
draw: 1,
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
return target.isHealthy() ? 2 : 0.5;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
nhlundao: {
|
||
trigger: { player: "damageEnd" },
|
||
filter: function (event, player) {
|
||
return event.source && player != event.source && player.countCards("h") != event.source.countCards("h");
|
||
},
|
||
logTarget: "source",
|
||
check: function (event, player) {
|
||
return player.countCards("h") < event.source.countCards("h") || get.effect(event.source, { name: "guohe_copy2" }, player, player) > 0;
|
||
},
|
||
content: function () {
|
||
if (player.countCards("h") > trigger.source.countCards("h")) player.draw();
|
||
else player.discardPlayerCard(trigger.source, "he", true);
|
||
},
|
||
},
|
||
nhguanyue: {
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
frequent: true,
|
||
content: function () {
|
||
"step 0";
|
||
var cards = get.cards(2);
|
||
player.chooseButton(["观月：选择获得一张牌", cards.slice(0)], true).set("ai", function (button) {
|
||
return get.value(button.link, _status.event.player);
|
||
});
|
||
while (cards.length) {
|
||
ui.cardPile.insertBefore(cards.pop(), ui.cardPile.firstChild);
|
||
}
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.gain(result.links, "gain2");
|
||
}
|
||
},
|
||
},
|
||
nhyanzheng: {
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("h") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseCard("h", get.prompt("nhyanzheng"))
|
||
.set(
|
||
"goon",
|
||
(function () {
|
||
var num = player.countCards("h") - 1;
|
||
return (
|
||
game.countPlayer(function (current) {
|
||
return get.damageEffect(current, player, player) > 0;
|
||
}) >= Math.min(3, num)
|
||
);
|
||
})()
|
||
)
|
||
.set("ai", function (card) {
|
||
if (_status.event.goon) return Math.max(1, get.value(card));
|
||
return 0;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.logSkill("nhyanzheng");
|
||
var cards = player.getCards("h", function (card) {
|
||
return card != result.cards[0] && lib.filter.cardDiscardable(card, player, "nhyanzheng");
|
||
});
|
||
if (cards.length) {
|
||
player.discard(cards);
|
||
event.num = cards.length;
|
||
} else event.finish();
|
||
} else event.finish();
|
||
"step 2";
|
||
num = Math.min(num, game.countPlayer());
|
||
player.chooseTarget([1, num], true, "对" + (num > 1 ? "至多" : "") + get.cnNumber(num) + "名角色造成1点伤害").set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return get.damageEffect(target, player, player);
|
||
});
|
||
"step 3";
|
||
if (result.bool) {
|
||
var targets = result.targets.sortBySeat();
|
||
player.line(targets, "green");
|
||
for (var i of targets) i.damage();
|
||
}
|
||
},
|
||
},
|
||
//樊稠
|
||
xinxingluan: {
|
||
audio: "xinfu_xingluan",
|
||
usable: 1,
|
||
trigger: { player: "useCardAfter" },
|
||
filter: function (event, player) {
|
||
return player.isPhaseUsing();
|
||
},
|
||
async cost(event, trigger, player) {
|
||
const choiceList = ["观看牌堆中两张点数为6的牌并获得其中一张", "令一名其他角色弃置一张点数为6的牌或交给你一张牌", "获得场上一张点数为6的牌"],
|
||
choices = ["选项一"];
|
||
if (game.hasPlayer(current => current != player && current.countCards("he") > 0)) {
|
||
choices.push("选项二");
|
||
} else {
|
||
choiceList[1] = `<span style="opacity:0.5">${choiceList[1]}</span>`;
|
||
}
|
||
if (
|
||
game.hasPlayer(current => {
|
||
return current.hasCard(function (card) {
|
||
return get.number(card) == 6 && lib.filter.canBeGained(card, current, player);
|
||
}, "ej");
|
||
})
|
||
) {
|
||
choices.push("选项三");
|
||
} else {
|
||
choiceList[2] = `<span style="opacity:0.5">${choiceList[2]}</span>`;
|
||
}
|
||
const result = await player
|
||
.chooseControl(choices, "cancel2")
|
||
.set("choiceList", choiceList)
|
||
.set("prompt", get.prompt("xinxingluan"))
|
||
.set("ai", function () {
|
||
var player = _status.event.player;
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
if (current == player) return false;
|
||
var att = -get.sgn(get.attitude(player, current) - 0.1);
|
||
return current.hasCard(function (card) {
|
||
return get.number(card) == 6 && lib.filter.canBeGained(card, current, player) && get.sgn(get.useful(card, current)) == att;
|
||
}, "ej");
|
||
})
|
||
)
|
||
return "选项三";
|
||
if (
|
||
game.hasPlayer(function (target) {
|
||
if (target == player) return false;
|
||
var att = get.attitude(player, target);
|
||
return (
|
||
att < 0 &&
|
||
target.countCards("he") > 0 &&
|
||
!target.hasCard(function (card) {
|
||
return get.value(card, target) <= 0;
|
||
}, "he")
|
||
);
|
||
})
|
||
)
|
||
return "选项二";
|
||
return "选项一";
|
||
})
|
||
.forResult();
|
||
if (result.control !== "cancel2") {
|
||
const results = { bool: true, cost_data: { index: choices.indexOf(result.control) } };
|
||
if (results.cost_data.index === 1) {
|
||
const { targets } = await player
|
||
.chooseTarget("令一名其他角色弃置一张点数为6的牌，否则交给你一张牌", true, function (card, player, current) {
|
||
return current != player && current.countCards("he") > 0;
|
||
})
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
att = get.attitude(player, target);
|
||
if (att >= 0) return 0;
|
||
if (
|
||
!target.hasCard(function (card) {
|
||
return get.value(card, target) <= 0;
|
||
}, "he")
|
||
)
|
||
return -att / Math.sqrt(target.countCards("he"));
|
||
return 0;
|
||
})
|
||
.forResult();
|
||
results.targets = targets;
|
||
} else if (results.cost_data.index === 2) {
|
||
const { targets } = await player
|
||
.chooseTarget("获得一名角色装备区或判定区内点数为6的牌", true, function (card, player, current) {
|
||
return current.hasCard(function (card) {
|
||
return get.number(card) == 6 && lib.filter.canBeGained(card, current, player);
|
||
}, "ej");
|
||
})
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
att = -get.sgn(get.attitude(player, target) - 0.1),
|
||
max = 0,
|
||
ej = target.getCards("ej", function (card) {
|
||
return get.number(card) == 6 && lib.filter.canBeGained(card, target, player);
|
||
});
|
||
for (var i of ej) {
|
||
var num = get.useful(i, target) * att;
|
||
if (num > max) max = num;
|
||
return max;
|
||
}
|
||
})
|
||
.forResult();
|
||
results.targets = targets;
|
||
}
|
||
event.result = results;
|
||
}
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var result = event.cost_data;
|
||
if (result.index === 1) event.goto(4);
|
||
else if (result.index === 2) event.goto(3);
|
||
"step 1";
|
||
var cards = [];
|
||
while (cards.length < 2) {
|
||
var card = get.cardPile2(function (card) {
|
||
return !cards.includes(card) && get.number(card) == 6;
|
||
});
|
||
if (!card) break;
|
||
cards.push(card);
|
||
}
|
||
if (!cards.length) {
|
||
player.draw(6);
|
||
event.finish();
|
||
} else if (cards.length == 1) {
|
||
event._result = { bool: true, links: cards };
|
||
} else
|
||
player.chooseButton(["兴乱：选择获得其中一张", cards], true).set("ai", function (button) {
|
||
return get.value(button.link, _status.event.player);
|
||
});
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.gain(result.links, "gain2");
|
||
}
|
||
event.finish();
|
||
"step 3";
|
||
var target = targets[0];
|
||
player.gainPlayerCard(target, "ej", true).set("filterButton", function (button) {
|
||
return get.number(button.link) == 6;
|
||
});
|
||
event.finish();
|
||
"step 4";
|
||
var target = targets[0];
|
||
event.target = target;
|
||
target.chooseToDiscard("he", "弃置一张点数为6的牌，否则交给" + get.translation(player) + "一张牌", function (card) {
|
||
return get.number(card) == 6;
|
||
}).ai = card => 8 - get.value(card);
|
||
"step 5";
|
||
if (!result.bool) {
|
||
target.chooseCard("he", true, "交给" + get.translation(player) + "一张牌");
|
||
} else event.finish();
|
||
"step 6";
|
||
if (result.bool) target.give(result.cards, player, "giveAuto");
|
||
},
|
||
},
|
||
rexingluan: {
|
||
audio: "xinfu_xingluan",
|
||
usable: 1,
|
||
trigger: { player: "useCardAfter" },
|
||
filter: function (event, player) {
|
||
return event.targets && event.targets.length == 1 && typeof get.number(event.card, false) == "number" && player.isPhaseUsing();
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
var str = "",
|
||
num = get.number(trigger.card, false),
|
||
nums = get.strNumber(num);
|
||
var list = game.filterPlayer(function (current) {
|
||
return current.hasCard(function (card) {
|
||
return get.number(card) == num && lib.filter.canBeGained(card, current, player);
|
||
}, "ej");
|
||
});
|
||
if (list.length) {
|
||
str += "获得一名角色装备区或判定区内的一张点数为" + nums + "的牌，或直接从牌堆中获得一张点数为" + nums + "的牌";
|
||
player
|
||
.chooseTarget(get.prompt("rexingluan"), str, [0, 1], function (card, player, target) {
|
||
return _status.event.targets.includes(target);
|
||
})
|
||
.set("targets", list)
|
||
.set("ai", function (target) {
|
||
if (!target) return 1;
|
||
var player = _status.event.player,
|
||
num = get.number(_status.event.getTrigger().card, false),
|
||
att = -get.sgn(get.attitude(player, target));
|
||
if (
|
||
target.hasCard(function (card) {
|
||
return get.number(card) == num && get.effect(target, card, target, player) < 0;
|
||
}, "j")
|
||
)
|
||
return 1.2 * Math.abs(get.attitude(player, target));
|
||
if (
|
||
target.hasCard(function (card) {
|
||
return get.number(card) == num && get.sgn(get.value(card, target) + 0.1) == att;
|
||
}, "e")
|
||
)
|
||
return Math.abs(get.attitude(player, target));
|
||
return 0;
|
||
});
|
||
} else {
|
||
player.chooseBool(get.prompt("rexingluan"), "从牌堆中获得一张点数为" + nums + "的牌").ai = () => true;
|
||
}
|
||
"step 1";
|
||
if (result.bool) {
|
||
if (result.targets && result.targets.length) {
|
||
var target = result.targets[0];
|
||
player.logSkill("rexingluan", target);
|
||
player
|
||
.gainPlayerCard(target, "ej", true)
|
||
.set("num", get.number(trigger.card, false))
|
||
.set("filterButton", function (button) {
|
||
return get.number(button.link) == _status.event.num;
|
||
});
|
||
} else {
|
||
player.logSkill("rexingluan");
|
||
var num = get.number(trigger.card, false),
|
||
card = get.cardPile2(function (i) {
|
||
return get.number(i, false) == num;
|
||
});
|
||
if (card) player.gain(card, "gain2");
|
||
}
|
||
}
|
||
},
|
||
},
|
||
//杜夫人
|
||
yise: {
|
||
audio: 2,
|
||
trigger: {
|
||
global: "gainAfter",
|
||
player: "loseAsyncAfter",
|
||
},
|
||
filter: function (event, player) {
|
||
if (event.name == "loseAsync") {
|
||
if (event.type != "gain") return false;
|
||
}
|
||
var cards = event.getl(player).cards2;
|
||
return game.hasPlayer(function (current) {
|
||
if (current == player) return false;
|
||
var cardsx = event.getg(current);
|
||
for (var i of cardsx) {
|
||
if (cards.includes(i)) {
|
||
if (current.isDamaged()) return true;
|
||
return get.color(i, player) == "black";
|
||
}
|
||
}
|
||
return false;
|
||
});
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
var cards = trigger.getl(player).cards2;
|
||
event.cards = cards;
|
||
event.targets = game
|
||
.filterPlayer(function (current) {
|
||
if (current == player) return false;
|
||
var cardsx = trigger.getg(current);
|
||
for (var i of cardsx) {
|
||
if (cards.includes(i)) return true;
|
||
}
|
||
return false;
|
||
})
|
||
.sortBySeat();
|
||
if (!event.targets.length) event.finish();
|
||
"step 1";
|
||
var target = targets.shift();
|
||
var cardsx = trigger.getg(target);
|
||
var goon = false;
|
||
for (var i of cardsx) {
|
||
if (cards.includes(i)) {
|
||
if (target.isDamaged() || get.color(i, player) == "black") {
|
||
goon = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (goon) {
|
||
var next = game.createEvent("yise_insert");
|
||
next.player = player;
|
||
next.target = target;
|
||
next.cards = cardsx;
|
||
next.setContent(lib.skill.yise.contentx);
|
||
}
|
||
if (targets.length > 0) event.redo();
|
||
},
|
||
contentx: function () {
|
||
"step 0";
|
||
for (var i of cards) {
|
||
event[get.color(i, player)] = true;
|
||
if (event.red && event.black) break;
|
||
}
|
||
if (event.red && target.isDamaged()) {
|
||
player.chooseBool(get.prompt("yise", target), "令" + get.translation(target) + "回复1点体力").set("ai", () => get.recoverEffect(_status.event.getParent().target, _status.event.player, _status.event.player) > 0);
|
||
}
|
||
"step 1";
|
||
if (event.black || (event.red && result.bool)) player.logSkill("yise", target);
|
||
if (event.red && result.bool) target.recover();
|
||
if (event.black) {
|
||
target.addMark("yise_damage", 1, false);
|
||
target.addSkill("yise_damage");
|
||
}
|
||
},
|
||
subSkill: {
|
||
damage: {
|
||
trigger: { player: "damageBegin1" },
|
||
forced: true,
|
||
charlotte: true,
|
||
onremove: true,
|
||
filter: function (event, player) {
|
||
return event.card && event.card.name == "sha" && event.getParent().name == "sha";
|
||
},
|
||
content: function () {
|
||
trigger.num += player.countMark("yise_damage");
|
||
player.removeSkill("yise_damage");
|
||
},
|
||
intro: {
|
||
content: "下一次受到杀的伤害+#",
|
||
},
|
||
},
|
||
},
|
||
},
|
||
shunshi: {
|
||
trigger: { player: ["damageEnd", "phaseZhunbeiBegin"] },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
(event.name != "damage" || player != _status.currentPhase) &&
|
||
player.countCards("he") > 0 &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && current != event.source;
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseCardTarget({
|
||
prompt: get.prompt("shunshi"),
|
||
prompt2: "将一张牌交给一名其他角色，并获得+1效果",
|
||
filterCard: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && target != _status.event.source;
|
||
},
|
||
position: "he",
|
||
source: trigger.source,
|
||
ai1: function (card) {
|
||
var player = _status.event.player;
|
||
if (player.hasSkill("yise")) {
|
||
if (
|
||
get.color(card, player) == "red" &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && current != _status.event.source && current.isDamaged() && get.recoverEffect(current, player, player) > 0;
|
||
})
|
||
)
|
||
return 10 - get.value(card);
|
||
if (get.color(card, player) == "black") return 4 - get.value(card);
|
||
}
|
||
return 8 - get.value(card);
|
||
},
|
||
ai2: function (target) {
|
||
var player = _status.event.player,
|
||
card = ui.selected.cards[0];
|
||
if (player.hasSkill("yise")) {
|
||
if (get.color(card) == "red" && target.isDamaged()) return 2 * get.recoverEffect(target, player, player);
|
||
if (get.color(card) == "black") return -get.attitude(player, target);
|
||
}
|
||
if (get.value(card, target) < 0) return -get.attitude(player, target);
|
||
if (get.value(card, target) < 1) return 0.01 * -get.attitude(player, target);
|
||
return Math.max(1, get.value(card, target) - get.value(card, player)) * get.attitude(player, target);
|
||
},
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("shunshi", target);
|
||
player.give(result.cards, target);
|
||
player.addMark("shunshi_mark", 1, false);
|
||
player.addTempSkill("shunshi_mark", { player: "phaseEnd" });
|
||
}
|
||
},
|
||
subSkill: {
|
||
mark: {
|
||
onremove: true,
|
||
trigger: { player: "phaseDrawBegin2" },
|
||
forced: true,
|
||
charlotte: true,
|
||
popup: false,
|
||
filter: function (event, player) {
|
||
return !event.numFixed;
|
||
},
|
||
content: function () {
|
||
trigger.num += player.countMark("shunshi_mark");
|
||
},
|
||
mod: {
|
||
maxHandcard: function (player, num) {
|
||
return num + player.countMark("shunshi_mark");
|
||
},
|
||
cardUsable: function (card, player, num) {
|
||
if (card.name == "sha") return num + player.countMark("shunshi_mark");
|
||
},
|
||
},
|
||
intro: {
|
||
content: "拥有#层效果",
|
||
},
|
||
},
|
||
},
|
||
},
|
||
xianwei: {
|
||
audio: 2,
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player.hasEnabledSlot();
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseToDisable().ai = function (event, player, list) {
|
||
var getVal = function (num) {
|
||
var card = player.getEquip(num);
|
||
if (card) {
|
||
var val = get.value(card);
|
||
if (val > 0) return 0;
|
||
return 5 - val;
|
||
}
|
||
switch (num) {
|
||
case "equip3":
|
||
return 4.5;
|
||
case "equip4":
|
||
return 4.4;
|
||
case "equip5":
|
||
return 4.3;
|
||
case "equip2":
|
||
return (3 - player.hp) * 1.5;
|
||
case "equip1": {
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return (get.realAttitude || get.attitude)(player, current) < 0 && get.distance(player, current) > 1;
|
||
})
|
||
)
|
||
return 0;
|
||
return 3.2;
|
||
}
|
||
}
|
||
};
|
||
list.sort(function (a, b) {
|
||
return getVal(b) - getVal(a);
|
||
});
|
||
return list[0];
|
||
};
|
||
"step 1";
|
||
var cardType = result.control;
|
||
event.cardType = cardType;
|
||
var num = player.countDisabledSlot();
|
||
if (num < 5) player.draw(5 - num);
|
||
player
|
||
.chooseTarget(lib.filter.notMe, "是否令一名其他角色从牌堆中使用一张" + get.translation(cardType) + "牌？")
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
type = _status.event.cardType;
|
||
var card = get.cardPile2(function (card) {
|
||
return get.subtype(card) == type && target.canUse(card, target);
|
||
});
|
||
if (!card) return 0;
|
||
return get.effect(target, card, target, player);
|
||
})
|
||
.set("cardType", event.cardType);
|
||
"step 2";
|
||
if (!result.bool) return;
|
||
var target = result.targets[0];
|
||
player.line(target, "green");
|
||
var card = get.cardPile2(function (card) {
|
||
return get.subtype(card) == event.cardType && target.canUse(card, target);
|
||
});
|
||
if (card) target.chooseUseTarget(card, "nopopup", true);
|
||
else target.draw();
|
||
},
|
||
group: "xianwei_all",
|
||
subSkill: {
|
||
all: {
|
||
trigger: { player: "disableEquipAfter" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return !player.hasEnabledSlot();
|
||
},
|
||
content: function () {
|
||
player.gainMaxHp(2);
|
||
player.addSkill("xianwei_effect");
|
||
},
|
||
},
|
||
effect: {
|
||
charlotte: true,
|
||
mark: true,
|
||
intro: { content: "和其他角色视为在彼此的攻击范围内" },
|
||
mod: {
|
||
inRange: () => true,
|
||
inRangeOf: () => true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
rehuoshui: {
|
||
audio: 2,
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
var num = Math.min(game.countPlayer() - 1, Math.max(1, player.getDamagedHp()));
|
||
var str;
|
||
if (num > 1) {
|
||
str = "选择至多" + get.cnNumber(num) + "名其他角色。";
|
||
var list = ["第一名角色的非锁定技失效直到回合结束", "；第二名角色交给你一张手牌", "；第三名及之后角色弃置装备区内的所有牌"];
|
||
for (var i = 0; i < Math.min(3, num); i++) {
|
||
str += list[i];
|
||
}
|
||
str += "。";
|
||
} else str = "令一名其他角色的非锁定技本回合内失效";
|
||
player.chooseTarget([1, num], get.prompt("rehuoshui"), str, lib.filter.notMe).set("ai", function (target) {
|
||
var att = -get.attitude(_status.event.player, target);
|
||
if (att <= 0) return 0;
|
||
if (target.hasSkillTag("maixie") || target.hasSkill("maixie_hp") || target.hasSkill("maixie_defed")) att *= 3;
|
||
return att / get.threaten(target);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var targets = result.targets;
|
||
player.logSkill("rehuoshui", targets);
|
||
event.targets = targets;
|
||
targets[0].addTempSkill("fengyin");
|
||
if (targets.length < 2) event.goto(5);
|
||
} else event.finish();
|
||
"step 2";
|
||
if (targets[1].countCards("h") == 0) event.goto(targets.length > 2 ? 4 : 5);
|
||
else targets[1].chooseCard("h", true, "交给" + get.translation(player) + "一张手牌");
|
||
"step 3";
|
||
if (result.bool) {
|
||
targets[1].give(result.cards, player);
|
||
}
|
||
if (targets.length < 3) {
|
||
event.goto(5);
|
||
} else {
|
||
targets.splice(0, 2);
|
||
}
|
||
"step 4";
|
||
var target = targets.shift();
|
||
var num = target.countCards("e");
|
||
if (num > 0) target.chooseToDiscard("e", true, num);
|
||
if (targets.length > 0) event.redo();
|
||
"step 5";
|
||
game.delayx();
|
||
},
|
||
},
|
||
reqingcheng: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(current => lib.skill.reqingcheng.filterTarget(null, player, current));
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && target.hasSex("male") && target.countCards("h") <= player.countCards("h");
|
||
},
|
||
content: function () {
|
||
player.swapHandcards(target);
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
result: {
|
||
player: function (player, target) {
|
||
if (target.countCards("h") > 0) return -Math.max(get.value(target.getCards("h"), player) - get.value(player.getCards("h"), player), 0);
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//丘力居
|
||
koulve: {
|
||
audio: 2,
|
||
trigger: { source: "damageSource" },
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
return event.player.isDamaged() && event.player.countCards("h") > 0 && player.isPhaseUsing();
|
||
},
|
||
check: function (event, player) {
|
||
if (player.hp == 1 && player.isHealthy()) return false;
|
||
return get.attitude(player, event.player) <= 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.choosePlayerCard(trigger.player, "h", true, trigger.player.getDamagedHp());
|
||
"step 1";
|
||
var card = result.cards;
|
||
event.cards = card;
|
||
player.showCards(card, get.translation(player) + "发动了【宼略】");
|
||
"step 2";
|
||
var gains = [],
|
||
red = false;
|
||
var target = trigger.player;
|
||
for (var card of cards) {
|
||
var type = get.type2(card, target);
|
||
if ((type == "basic" || type == "trick") && get.tag(card, "damage") > 0) gains.push(card);
|
||
if (!red && get.color(card, target) == "red") red = true;
|
||
}
|
||
if (gains.length) player.gain(gains, "gain2");
|
||
if (!red) event.finish();
|
||
"step 3";
|
||
player[player.isDamaged() ? "loseMaxHp" : "loseHp"]();
|
||
player.draw(2);
|
||
},
|
||
},
|
||
qljsuiren: {
|
||
audio: 2,
|
||
trigger: { player: "die" },
|
||
direct: true,
|
||
forceDie: true,
|
||
skillAnimation: true,
|
||
animationColor: "gray",
|
||
filter: function (event, player) {
|
||
return player.countCards("h", function (card) {
|
||
var type = get.type(card, player);
|
||
return (type == "basic" || type == "trick") && get.tag(card, "damage") > 0;
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(lib.filter.notMe, get.prompt("qljsuiren"), "将所有伤害性基本牌和锦囊牌交给一名其他角色")
|
||
.set("forceDie", true)
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
cards = _status.event.aiCards;
|
||
var att = get.attitude(player, target);
|
||
if (att <= 0) return 0;
|
||
if (target.hasSkillTag("nogain")) att /= 100;
|
||
var num = 0.1;
|
||
for (var i of cards) num += Math.max(0, target.getUseValue(card));
|
||
return num * att;
|
||
})
|
||
.set(
|
||
"aiCards",
|
||
player.getCards("h", function (card) {
|
||
var type = get.type(card, player);
|
||
return (type == "basic" || type == "trick") && get.tag(card, "damage") > 0;
|
||
})
|
||
);
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("qljsuiren", target);
|
||
player.give(
|
||
player.getCards("h", function (card) {
|
||
var type = get.type(card, player);
|
||
return (type == "basic" || type == "trick") && get.tag(card, "damage") > 0;
|
||
}),
|
||
target,
|
||
"give"
|
||
);
|
||
}
|
||
},
|
||
},
|
||
//胡车儿
|
||
redaoji: {
|
||
audio: 2,
|
||
trigger: { global: "useCard" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
if (player == event.player || get.subtype(event.card, false) != "equip1" || (event.player.isDead() && !event.cards.filterInD().length)) return false;
|
||
var all = event.player.getAllHistory("useCard");
|
||
for (var i of all) {
|
||
if (get.subtype(i.card, false) == "equip1") return i == event;
|
||
}
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var list = [];
|
||
event.addIndex = 0;
|
||
if (trigger.cards.filterInD().length > 0) list.push("获得" + get.translation(trigger.cards.filterInD()));
|
||
else event.addIndex++;
|
||
if (trigger.player.isIn()) list.push("令" + get.translation(trigger.player) + "本回合不能使用或打出【杀】");
|
||
player
|
||
.chooseControl("cancel2")
|
||
.set("choiceList", list)
|
||
.set("prompt", get.prompt("redaoji", trigger.player))
|
||
.set("ai", function () {
|
||
var evt = _status.event.getParent(),
|
||
player = evt.player,
|
||
evt2 = evt._trigger;
|
||
if (evt.addIndex == 0) {
|
||
var noob = get.attitude(player, evt2.player) < 0 ? 1 : "cancel2";
|
||
if (player.countMark("fuzhong") == 3) return noob;
|
||
if (get.effect(evt2.targets[0], evt2.card, evt2.player, player) <= 0) return 0;
|
||
return noob;
|
||
}
|
||
return get.attitude(player, evt2.player) < 0 ? 0 : "cancel2";
|
||
});
|
||
"step 1";
|
||
if (result.control != "cancel2") {
|
||
player.logSkill("redaoji", trigger.player);
|
||
game.delayx();
|
||
if (result.index + event.addIndex == 0) {
|
||
player.gain(trigger.cards.filterInD(), "gain2");
|
||
} else trigger.player.addTempSkill("redaoji2");
|
||
}
|
||
},
|
||
},
|
||
redaoji2: {
|
||
charlotte: true,
|
||
mark: true,
|
||
mod: {
|
||
cardEnabled: function (card) {
|
||
if (card.name == "sha") return false;
|
||
},
|
||
cardRespondable: function (card) {
|
||
if (card.name == "sha") return false;
|
||
},
|
||
},
|
||
intro: {
|
||
content: "本回合不能使用或打出杀",
|
||
},
|
||
},
|
||
fuzhong: {
|
||
audio: 2,
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player.countMark("fuzhong") > 3;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(lib.filter.notMe, "对一名其他角色造成1点伤害", true).set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return get.damageEffect(target, player, player);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.line(target);
|
||
target.damage("nocard");
|
||
}
|
||
player.removeMark("fuzhong", 4);
|
||
},
|
||
marktext: "重",
|
||
intro: { content: "mark" },
|
||
group: ["fuzhong_gain", "fuzhong_yingzi"],
|
||
mod: {
|
||
maxHandcard: function (player, num) {
|
||
if (player.countMark("fuzhong") > 2) return num + 3;
|
||
},
|
||
globalFrom: function (player, target, num) {
|
||
if (player.countMark("fuzhong") > 1) return num - 2;
|
||
},
|
||
},
|
||
subSkill: {
|
||
gain: {
|
||
audio: "fuzhong",
|
||
trigger: {
|
||
player: "gainAfter",
|
||
global: "loseAsyncAfter",
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player != _status.currentPhase && event.getg(player).length > 0;
|
||
},
|
||
content: function () {
|
||
player.addMark("fuzhong", 1);
|
||
},
|
||
},
|
||
yingzi: {
|
||
audio: "fuzhong",
|
||
trigger: { player: "phaseDrawBegin2" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return !event.numFixed && player.countMark("fuzhong") > 0;
|
||
},
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//董承
|
||
xuezhao: {
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return player.maxHp > 0 && player.countCards("h") > 0;
|
||
},
|
||
filterCard: true,
|
||
position: "h",
|
||
filterTarget: lib.filter.notMe,
|
||
selectTarget: function () {
|
||
return [1, _status.event.player.maxHp];
|
||
},
|
||
check: function (card) {
|
||
return 2 * (_status.event.player.maxHp + 2) - get.value(card);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (!target.countCards("he")) event._result = { bool: false };
|
||
else
|
||
target.chooseCard("he", "交给" + get.translation(player) + "一张牌并摸一张牌，或不能响应其使用的牌直到回合结束").set("ai", function (card) {
|
||
var player = _status.event.player,
|
||
target = _status.event.getParent().player,
|
||
val = get.value(card);
|
||
if (get.attitude(player, target) > 0) {
|
||
if (get.name(card, target) == "sha" && target.hasValueTarget(card)) return 30 - val;
|
||
return 20 - val;
|
||
}
|
||
return -val;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.addTempSkill("xuezhao_sha");
|
||
player.addMark("xuezhao_sha", 1, false);
|
||
target.give(result.cards, player);
|
||
target.draw();
|
||
} else {
|
||
player.addTempSkill("xuezhao_hit");
|
||
player.markAuto("xuezhao_hit", [target]);
|
||
}
|
||
},
|
||
ai: {
|
||
threaten: 2.4,
|
||
order: 3.6,
|
||
result: {
|
||
player: function (player, target) {
|
||
if (get.attitude(target, player) > 0) {
|
||
if (
|
||
target.countCards("e", function (card) {
|
||
return get.value(card, target) < 0;
|
||
})
|
||
)
|
||
return 3;
|
||
return Math.sqrt(target.countCards("he"));
|
||
}
|
||
if (
|
||
target.mayHaveShan(
|
||
player,
|
||
"use",
|
||
target.getCards("h", i => {
|
||
return i.hasGaintag("sha_notshan");
|
||
})
|
||
) &&
|
||
player.countCards("hs", function (card) {
|
||
return !ui.selected.cards.includes(card) && get.name(card) == "sha" && player.canUse(card, target) && get.effect(target, card, player, player) != 0;
|
||
})
|
||
)
|
||
return -Math.sqrt(Math.abs(get.attitude(player, target))) / 2;
|
||
return 0.1;
|
||
},
|
||
},
|
||
},
|
||
subSkill: {
|
||
sha: {
|
||
charlotte: true,
|
||
onremove: true,
|
||
marktext: "血",
|
||
intro: { content: "多杀#刀，誓诛曹贼！" },
|
||
mod: {
|
||
cardUsable: function (card, player, num) {
|
||
if (card.name == "sha") return num + player.countMark("xuezhao_sha");
|
||
},
|
||
},
|
||
},
|
||
hit: {
|
||
charlotte: true,
|
||
onremove: true,
|
||
marktext: "诏",
|
||
intro: { content: "$篡汉，其心可诛！" },
|
||
trigger: { player: "useCard1" },
|
||
forced: true,
|
||
popup: false,
|
||
content: function () {
|
||
trigger.directHit.addArray(player.getStorage("xuezhao_hit"));
|
||
},
|
||
ai: {
|
||
directHit_ai: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
return player.getStorage("xuezhao_hit").includes(arg.target);
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//唐姬
|
||
kangge: {
|
||
audio: 2,
|
||
trigger: { player: "phaseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.phaseNumber == 1 && !player.storage.kangge && game.hasPlayer(current => current != player);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget("请选择【抗歌】的目标", "其于回合外摸牌后，你摸等量的牌；其进入濒死状态时，你可令其回复体力至1点；其死亡后，你弃置所有牌并失去1点体力", lib.filter.notMe, true).set("ai", function (target) {
|
||
return get.attitude(_status.event.player, target);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("kangge", target);
|
||
player.addSkill("kangge_clear");
|
||
player.storage.kangge = target;
|
||
player.markSkill("kangge");
|
||
game.delayx();
|
||
}
|
||
},
|
||
intro: { content: "已指定$为目标" },
|
||
group: ["kangge_draw", "kangge_dying", "kangge_die"],
|
||
subSkill: {
|
||
draw: {
|
||
audio: "kangge",
|
||
trigger: {
|
||
global: ["gainAfter", "loseAsyncAfter"],
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (player.countMark("kangge_draw") >= 3) return false;
|
||
var target = player.storage.kangge;
|
||
return target && target != _status.currentPhase && event.getg(target).length > 0;
|
||
},
|
||
logTarget: "player",
|
||
content: function () {
|
||
var num = Math.min(3 - player.countMark("kangge_draw"), trigger.getg(player.storage.kangge).length);
|
||
player.addMark("kangge_draw", num, false);
|
||
player.draw(num);
|
||
},
|
||
},
|
||
clear: {
|
||
trigger: { global: "phaseBeginStart" },
|
||
forced: true,
|
||
firstDo: true,
|
||
popup: false,
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
return player.countMark("kangge_draw") > 0;
|
||
},
|
||
content: function () {
|
||
player.removeMark("kangge_draw", player.countMark("kangge_draw"), false);
|
||
},
|
||
},
|
||
dying: {
|
||
audio: "kangge",
|
||
trigger: { global: "dying" },
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
return event.player == player.storage.kangge && event.player.hp < 1 && !player.hasSkill("kangge_temp");
|
||
},
|
||
check: function (event, player) {
|
||
return get.attitude(player, event.player) > 0;
|
||
},
|
||
prompt2: "令其将体力值回复至1点",
|
||
content: function () {
|
||
trigger.player.recover(1 - trigger.player.hp);
|
||
player.addTempSkill("kangge_temp", "roundStart");
|
||
},
|
||
},
|
||
temp: {},
|
||
die: {
|
||
audio: "kangge",
|
||
trigger: { global: "dieAfter" },
|
||
filter: function (event, player) {
|
||
return event.player == player.storage.kangge;
|
||
},
|
||
forced: true,
|
||
content: function () {
|
||
var cards = player.getCards("he");
|
||
if (cards.length) player.discard(cards);
|
||
player.loseHp();
|
||
},
|
||
},
|
||
},
|
||
ai: {
|
||
threaten: 2,
|
||
},
|
||
},
|
||
jielie: {
|
||
audio: 2,
|
||
trigger: { player: "damageBegin4" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return (!event.source || (event.source != player && event.source != player.storage.kangge)) && player.storage.kangge && player.storage.kangge.isIn();
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseControl(lib.suit.slice(0), "cancel2")
|
||
.set("prompt", get.prompt("jielie"))
|
||
.set("prompt2", "防止伤害并改为失去等量体力，且令" + get.translation(player.storage.kangge) + "从弃牌堆中获得等量的花色牌")
|
||
.set("ai", function () {
|
||
var player = _status.event.player;
|
||
if (get.attitude(player, player.storage.kangge) <= 0) return "cancel2";
|
||
return lib.suit.randomGet();
|
||
});
|
||
"step 1";
|
||
if (result.control != "cancel2") {
|
||
event.suit = result.control;
|
||
player.logSkill("jielie", player.storage.kangge);
|
||
trigger.cancel();
|
||
player.loseHp(trigger.num);
|
||
} else event.finish();
|
||
"step 2";
|
||
var cards = [];
|
||
while (cards.length < trigger.num) {
|
||
var card = get.discardPile(function (card) {
|
||
return get.suit(card, false) == event.suit && !cards.includes(card);
|
||
});
|
||
if (card) cards.push(card);
|
||
else break;
|
||
}
|
||
if (cards.length) player.storage.kangge.gain(cards, "gain2");
|
||
},
|
||
},
|
||
//张横
|
||
dangzai: {
|
||
trigger: { player: "phaseUseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
!player.isDisabledJudge() &&
|
||
game.hasPlayer(function (current) {
|
||
return (
|
||
current != player &&
|
||
current.countCards("j", function (card) {
|
||
return player.canAddJudge(card);
|
||
}) > 0
|
||
);
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(
|
||
function (card, player, target) {
|
||
return (
|
||
target != player &&
|
||
target.countCards("j", function (card) {
|
||
return player.canAddJudge(card);
|
||
}) > 0
|
||
);
|
||
},
|
||
get.prompt("dangzai"),
|
||
"将一名其他角色判定区内的一张牌移动到你的判定区内"
|
||
);
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("dangzai", target);
|
||
player.choosePlayerCard(target, "j", true).set("filterButton", function (button) {
|
||
return _status.event.player.canAddJudge(button.link);
|
||
});
|
||
} else event.finish();
|
||
"step 2";
|
||
if (result.bool && result.cards && result.cards.length) {
|
||
var card = result.cards[0];
|
||
target.$give(card, player);
|
||
game.delayx();
|
||
var name = card.viewAs || card.name;
|
||
if (card.name != name) {
|
||
player.addJudge(name, card);
|
||
} else {
|
||
player.addJudge(card);
|
||
}
|
||
}
|
||
},
|
||
},
|
||
liangjue: {
|
||
trigger: {
|
||
player: "loseAfter",
|
||
global: ["equipAfter", "addJudgeAfter", "gainAfter", "loseAsyncAfter", "addToExpansionAfter"],
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (player.hp <= 1) return false;
|
||
if (event.player == player) {
|
||
if (event.name == "equip" && get.color(event.card, player) == "black") return true;
|
||
if (event.name == "addJudge" && get.color(event.cards[0], player) == "black") return true;
|
||
}
|
||
var evt = event.getl(player);
|
||
if (!evt || !evt.es || !evt.js || (!evt.es.length && !evt.js.length)) return false;
|
||
for (var i of evt.es) {
|
||
if (get.color(i, player) == "black") return true;
|
||
}
|
||
for (var i of evt.js) {
|
||
if (get.color(i, player) == "black") return true;
|
||
}
|
||
return false;
|
||
},
|
||
content: function () {
|
||
player.loseHp();
|
||
player.draw(2);
|
||
},
|
||
},
|
||
//狼灭
|
||
langmie: {
|
||
trigger: { global: "phaseUseEnd" },
|
||
//forced:true,
|
||
filter: function (event, player) {
|
||
if (player == event.player || !player.countCards("he")) return false;
|
||
var map = {};
|
||
var list = event.player.getHistory("useCard", function (evt) {
|
||
var evt2 = evt.getParent("phaseUse");
|
||
return evt2 == event;
|
||
});
|
||
for (var i of list) {
|
||
var name = get.type2(i.card, false);
|
||
if (!map[name]) map[name] = true;
|
||
else return true;
|
||
}
|
||
},
|
||
frequent: true,
|
||
content: function () {
|
||
player.draw();
|
||
},
|
||
group: "langmie_damage",
|
||
},
|
||
langmie_damage: {
|
||
audio: "langmie",
|
||
trigger: { global: "phaseEnd" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return event.player != player && (event.player.getStat("damage") || 0) > 1 && player.countCards("he") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseToDiscard("he", get.prompt("langmie", trigger.player), "弃置一张牌并对其造成1点伤害")
|
||
.set("goon", get.damageEffect(trigger.player, player, player) > 0)
|
||
.set("ai", function (card) {
|
||
if (!_status.event.goon) return 0;
|
||
return 7 - get.value(card);
|
||
}).logSkill = ["langmie_damage", trigger.player];
|
||
"step 1";
|
||
if (result.bool) trigger.player.damage();
|
||
},
|
||
ai: { expose: 0.2 },
|
||
},
|
||
//牛金
|
||
recuorui: {
|
||
audio: "cuorui",
|
||
enable: "phaseUse",
|
||
limited: true,
|
||
skillAnimation: true,
|
||
animationColor: "thunder",
|
||
filter: function (event, player) {
|
||
return (
|
||
player.hp > 0 &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && current.countGainableCards(player, "h") > 0;
|
||
})
|
||
);
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && target.countGainableCards(player, "h") > 0;
|
||
},
|
||
selectTarget: function () {
|
||
return [1, _status.event.player.hp];
|
||
},
|
||
content: function () {
|
||
if (num == 0) player.awakenSkill("recuorui");
|
||
player.gainPlayerCard(target, true, "h");
|
||
},
|
||
ai: {
|
||
order: 10,
|
||
result: {
|
||
player: 1,
|
||
target: function (player, target) {
|
||
if (target.hasSkillTag("noh")) return 0;
|
||
return -1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
reliewei: {
|
||
audio: "liewei",
|
||
trigger: { global: "dying" },
|
||
filter: function (event, player) {
|
||
return player == _status.currentPhase || player.getHistory("useSkill", evt => evt.skill == "reliewei").length < player.getHp();
|
||
},
|
||
frequent: true,
|
||
content: function () {
|
||
player.draw();
|
||
},
|
||
},
|
||
//张邈
|
||
mouni: {
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("h", "sha") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.addSkill("mouni2");
|
||
player.chooseTarget(get.prompt2("mouni"), lib.filter.notMe).set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
cards = player.getCards("h", "sha");
|
||
if (
|
||
get.attitude(player, target) >= 0 ||
|
||
!player.canUse(cards[0], target, false) ||
|
||
(!player.hasJudge("lebu") &&
|
||
target.mayHaveShan(
|
||
player,
|
||
"use",
|
||
target.getCards("h", i => {
|
||
return i.hasGaintag("sha_notshan");
|
||
})
|
||
) &&
|
||
!player.hasSkillTag(
|
||
"directHit_ai",
|
||
true,
|
||
{
|
||
target: target,
|
||
card: cards[0],
|
||
},
|
||
true
|
||
))
|
||
)
|
||
return 0;
|
||
return get.effect(target, cards[0], player, player);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("mouni", target);
|
||
event.cards = player.getCards("h", "sha");
|
||
} else event.finish();
|
||
"step 2";
|
||
if (event.mouni_dying) return;
|
||
var hs = player.getCards("h");
|
||
cards = cards.filter(function (card) {
|
||
return (
|
||
hs.includes(card) &&
|
||
get.name(card, player) == "sha" &&
|
||
player.canUse(
|
||
{
|
||
name: "sha",
|
||
nature: get.nature(card, player),
|
||
isCard: true,
|
||
cards: [card],
|
||
},
|
||
target,
|
||
false
|
||
)
|
||
);
|
||
});
|
||
if (cards.length) {
|
||
var card = cards.randomRemove(1)[0];
|
||
player.useCard(target, false, card);
|
||
event.redo();
|
||
}
|
||
"step 3";
|
||
if (
|
||
player.getHistory("useCard", function (evt) {
|
||
return (
|
||
evt.getParent() == event &&
|
||
!player.getHistory("sourceDamage", function (evt2) {
|
||
return evt.card == evt2.card;
|
||
}).length
|
||
);
|
||
}).length
|
||
) {
|
||
player.skip("phaseUse");
|
||
player.skip("phaseDiscard");
|
||
}
|
||
player.removeSkill("mouni2");
|
||
},
|
||
},
|
||
mouni2: {
|
||
charlotte: true,
|
||
trigger: { global: "dying" },
|
||
forced: true,
|
||
firstDo: true,
|
||
popup: false,
|
||
filter: function (event, player) {
|
||
var evt = event.getParent("mouni");
|
||
return evt && evt.player == player && evt.target == event.player;
|
||
},
|
||
content: function () {
|
||
trigger.getParent("mouni").mouni_dying = true;
|
||
},
|
||
},
|
||
zongfan: {
|
||
derivation: "zhangu",
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
juexingji: true,
|
||
forced: true,
|
||
skillAnimation: true,
|
||
animationColor: "gray",
|
||
filter: function (event, player) {
|
||
return (
|
||
!player.getHistory("skipped").includes("phaseUse") &&
|
||
player.getHistory("useCard", function (evt) {
|
||
return evt.getParent().name == "mouni";
|
||
}).length > 0
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.awakenSkill("zongfan");
|
||
var num = player.countCards("he");
|
||
if (num > 0) {
|
||
player.chooseCardTarget({
|
||
prompt: "是否将任意张牌交给一名其他角色？",
|
||
selectCard: [1, num],
|
||
filterCard: true,
|
||
filterTarget: lib.filter.notMe,
|
||
position: "he",
|
||
ai1: function (card) {
|
||
if (card.name == "du") return 10;
|
||
else if (ui.selected.cards.length && ui.selected.cards[0].name == "du") return 0;
|
||
var player = _status.event.player;
|
||
if (
|
||
ui.selected.cards.length > 4 ||
|
||
!game.hasPlayer(function (current) {
|
||
return get.attitude(player, current) > 0 && !current.hasSkillTag("nogain");
|
||
})
|
||
)
|
||
return 0;
|
||
return 1 / Math.max(0.1, get.value(card));
|
||
},
|
||
ai2: function (target) {
|
||
var player = _status.event.player,
|
||
att = get.attitude(player, target);
|
||
if (ui.selected.cards[0].name == "du") return -att;
|
||
if (target.hasSkillTag("nogain")) att /= 6;
|
||
return att;
|
||
},
|
||
});
|
||
} else event.goto(2);
|
||
"step 1";
|
||
if (result.bool) {
|
||
var cards = result.cards,
|
||
target = result.targets[0],
|
||
num = Math.min(5, cards.length);
|
||
player.give(cards, target);
|
||
player.gainMaxHp(num);
|
||
player.recover(num);
|
||
}
|
||
"step 2";
|
||
//player.removeSkill('mouni');
|
||
player.changeSkills(["zhangu"], ["mouni"]);
|
||
},
|
||
},
|
||
zhangu: {
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player.maxHp > 1 && (player.countCards("h") == 0 || player.countCards("e") == 0);
|
||
},
|
||
content: function () {
|
||
var cards = [],
|
||
types = [];
|
||
for (var i = 0; i < 3; i++) {
|
||
var card = get.cardPile2(function (card) {
|
||
return !cards.includes(card) && !types.includes(get.type2(card, false));
|
||
});
|
||
if (card) {
|
||
cards.push(card);
|
||
types.push(get.type2(card, false));
|
||
} else break;
|
||
}
|
||
if (cards.length) player.gain(cards, "gain2");
|
||
player.loseMaxHp();
|
||
},
|
||
},
|
||
//梁兴
|
||
lulve: {
|
||
audio: 2,
|
||
trigger: { player: "phaseUseBegin" },
|
||
filter: function (event, player) {
|
||
var hs = player.countCards("h");
|
||
return (
|
||
hs > 1 &&
|
||
game.hasPlayer(function (target) {
|
||
var ts = target.countCards("h");
|
||
return target != player && ts > 0 && hs > ts;
|
||
})
|
||
);
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt2("lulve"), function (card, player, target) {
|
||
var hs = player.countCards("h"),
|
||
ts = target.countCards("h");
|
||
return target != player && ts > 0 && hs > ts;
|
||
})
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
att = get.attitude(player, target);
|
||
if (target.isTurnedOver()) return att / 10;
|
||
if (!player.hasShan() && target.canUse({ name: "sha", isCard: true }, player, false) && get.effect(player, { name: "sha", isCard: true }, target, player) < 0 && player.hp < 4) return 0;
|
||
return -att * Math.sqrt(target.countCards("h"));
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("lulve", target);
|
||
var str = get.translation(player);
|
||
target
|
||
.chooseControl()
|
||
.set("choiceList", ["将所有手牌交给" + str + "，然后其将武将牌翻面", "将武将牌翻面，然后视为对" + str + "使用【杀】"])
|
||
.set("ai", function () {
|
||
var player = _status.event.player,
|
||
target = _status.event.getParent().player;
|
||
if (player.isTurnedOver()) return 1;
|
||
if (!target.hasShan() && player.canUse({ name: "sha", isCard: true }, target, false) && get.effect(target, { name: "sha", isCard: true }, player, player) < 0) return 0;
|
||
return Math.random() < 0.5 ? 0 : 1;
|
||
});
|
||
} else event.finish();
|
||
"step 2";
|
||
if (result.index == 0) {
|
||
target.give(target.getCards("h"), player);
|
||
player.turnOver();
|
||
event.finish();
|
||
} else target.turnOver();
|
||
"step 3";
|
||
if (target.canUse({ name: "sha", isCard: true }, player, false)) target.useCard({ name: "sha", isCard: true }, player, false);
|
||
},
|
||
},
|
||
lxzhuixi: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "damageBegin3",
|
||
source: "damageBegin1",
|
||
},
|
||
forced: true,
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
return event.source && event.player.isTurnedOver() != event.source.isTurnedOver();
|
||
},
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
},
|
||
//陶谦和曹嵩
|
||
reyirang: {
|
||
audio: "yirang",
|
||
audioname: ["re_taoqian"],
|
||
trigger: { player: "phaseUseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
if (
|
||
!player.countCards("he", function (card) {
|
||
return get.type(card) != "basic";
|
||
})
|
||
) {
|
||
return false;
|
||
}
|
||
return game.hasPlayer(function (current) {
|
||
return current != player;
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt2("reyirang"), function (card, player, target) {
|
||
return target != player;
|
||
})
|
||
.set("ai", function (target) {
|
||
return (get.attitude(_status.event.player, target) - 2) * target.maxHp;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var cards = player.getCards("he", function (card) {
|
||
return get.type(card) != "basic";
|
||
});
|
||
var target = result.targets[0];
|
||
player.logSkill("reyirang", target);
|
||
player.give(cards, target, "give");
|
||
if (target.maxHp > player.maxHp) player.gainMaxHp(target.maxHp - player.maxHp, true);
|
||
player.recover(cards.length);
|
||
}
|
||
},
|
||
},
|
||
cslilu: {
|
||
audio: 2,
|
||
trigger: { player: "phaseDrawBegin1" },
|
||
filter: function (event, player) {
|
||
return !event.numFixed;
|
||
},
|
||
check: function (event, player) {
|
||
return (
|
||
Math.min(player.maxHp, 5) - player.countCards("h") > 3 ||
|
||
game.hasPlayer(function (current) {
|
||
return current != player && get.attitude(player, current) > 0;
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
trigger.changeToZero();
|
||
"step 1";
|
||
player.drawTo(Math.min(player.maxHp, 5));
|
||
"step 2";
|
||
if (player.countCards("h") > 0) {
|
||
var str = "将至少一张手牌交给一名其他角色";
|
||
var num = player.countMark("cslilu");
|
||
if (num < player.countCards("h")) {
|
||
if (num > 0) str += "。若给出的牌数大于" + get.cnNumber(num) + "张，则你";
|
||
else str += "，并";
|
||
str += "加1点体力上限并回复1点体力";
|
||
}
|
||
player.chooseCardTarget({
|
||
prompt: str,
|
||
filterCard: true,
|
||
filterTarget: lib.filter.notMe,
|
||
selectCard: [1, Infinity],
|
||
forced: true,
|
||
ai1: function (card) {
|
||
if (ui.selected.cards.length < _status.event.goon) {
|
||
if (
|
||
get.tag(card, "damage") &&
|
||
game.hasPlayer(function (current) {
|
||
current != player && get.attitude(player, current) > 0 && !current.hasSkillTag("nogain") && !current.hasJudge("lebu") && current.hasValueTarget(card);
|
||
})
|
||
)
|
||
return 1;
|
||
return 1 / Math.max(0.1, get.value(card));
|
||
}
|
||
return 0;
|
||
},
|
||
ai2: function (target) {
|
||
return Math.sqrt(5 - Math.min(4, target.countCards("h"))) * get.attitude(_status.event.player, target);
|
||
},
|
||
goon: (function () {
|
||
if (
|
||
!game.hasPlayer(function (current) {
|
||
return current != player && get.attitude(player, current) > 0 && !current.hasSkillTag("nogain") && !current.hasJudge("lebu");
|
||
})
|
||
)
|
||
return 1;
|
||
if (num < player.countCards("h")) return num + 1;
|
||
return 1;
|
||
})(),
|
||
});
|
||
} else event.finish();
|
||
"step 3";
|
||
if (result.bool) {
|
||
var num = player.countMark("cslilu");
|
||
player.give(result.cards, result.targets[0]);
|
||
if (result.cards.length > num) {
|
||
player.gainMaxHp();
|
||
player.recover();
|
||
}
|
||
player.storage.cslilu = result.cards.length;
|
||
player.markSkill("cslilu");
|
||
}
|
||
},
|
||
},
|
||
csyizheng: {
|
||
audio: 2,
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt2("csyizheng"), lib.filter.notMe).set("ai", function (target) {
|
||
if (target.isTurnedOver() || target.hasJudge("lebu")) return 0;
|
||
return get.attitude(_status.event.player, target) * Math.max(0, target.countCards("h") - 2);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("csyizheng", target);
|
||
player.storage.csyizheng2 = target;
|
||
player.addTempSkill("csyizheng2", { player: "phaseBegin" });
|
||
}
|
||
},
|
||
},
|
||
csyizheng2: {
|
||
audio: "csyizheng",
|
||
trigger: {
|
||
global: ["recoverBegin", "damageBegin1"],
|
||
},
|
||
forced: true,
|
||
charlotte: true,
|
||
logTarget: function (event) {
|
||
return event.name == "damage" ? event.source : event.player;
|
||
},
|
||
filter: function (event, player) {
|
||
var target = lib.skill.csyizheng2.logTarget(event);
|
||
if (target != player.storage.csyizheng2) return false;
|
||
return player.maxHp > target.maxHp;
|
||
},
|
||
content: function () {
|
||
player.loseMaxHp();
|
||
trigger.num++;
|
||
},
|
||
mark: "character",
|
||
intro: {
|
||
content: "$造成伤害或回复体力时，若你的体力上限大于其，则你减1点体力上限，然后此伤害/回复量+1",
|
||
},
|
||
},
|
||
reyixiang: {
|
||
audio: "yixiang",
|
||
audioname: ["re_taoqian"],
|
||
trigger: { player: "damageBegin1" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
var evt = event.getParent(2);
|
||
if (evt.name != "useCard" || evt.card != event.card) return false;
|
||
var source = evt.player;
|
||
var phsu = evt.getParent("phaseUse");
|
||
if (!source || source == player || source != phsu.player) return false;
|
||
return (
|
||
source.getHistory("useCard", function (evt2) {
|
||
return evt2.getParent("phaseUse") == phsu;
|
||
})[0] == evt
|
||
);
|
||
},
|
||
content: function () {
|
||
trigger.num--;
|
||
},
|
||
group: "reyixiang_card",
|
||
subSkill: {
|
||
card: {
|
||
audio: "yixiang",
|
||
audioname: ["re_taoqian"],
|
||
trigger: { target: "useCardToTargeted" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (get.color(event.card) != "black") return false;
|
||
var evt = event.getParent();
|
||
var source = evt.player;
|
||
var phsu = evt.getParent("phaseUse");
|
||
if (!source || source == player || source != phsu.player) return false;
|
||
return (
|
||
source
|
||
.getHistory("useCard", function (evt2) {
|
||
return evt2.getParent("phaseUse") == phsu;
|
||
})
|
||
.indexOf(evt) == 1
|
||
);
|
||
},
|
||
content: function () {
|
||
trigger.excluded.add(player);
|
||
},
|
||
},
|
||
},
|
||
ai: {
|
||
effect: {
|
||
target: function (card, player, target, current, isLink) {
|
||
if (isLink || typeof card !== "object" || !player.isPhaseUsing()) return;
|
||
var num;
|
||
var evt = _status.event.getParent("useCard"),
|
||
evt2 = _status.event.getParent("phaseUse");
|
||
if (evt.card == card) {
|
||
num = player
|
||
.getHistory("useCard", function (evt) {
|
||
return evt.getParent("phaseUse") == evt2;
|
||
})
|
||
.indexOf(evt);
|
||
} else
|
||
num = player.getHistory("useCard", function (evt) {
|
||
return evt.getParent("phaseUse") == evt2;
|
||
}).length;
|
||
if (num < 0 || num > 1) return;
|
||
if (num === 0 && get.tag(card, "damage")) {
|
||
if (
|
||
target.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
}) ||
|
||
!player.hasSkillTag("damageBonus", true, {
|
||
target: target,
|
||
card: card,
|
||
})
|
||
)
|
||
return "zerotarget";
|
||
return [0.5, 0, 0.5, 0];
|
||
}
|
||
if (num === 1 && get.color(card) == "black") return "zeroplayertarget";
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//赵忠
|
||
yangzhong: {
|
||
audio: 2,
|
||
trigger: {
|
||
source: "damageSource",
|
||
player: "damageEnd",
|
||
},
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
var target = event.player,
|
||
source = event.source;
|
||
if (player != source && !player.hasSkill("yangzhong")) return false;
|
||
if (!target || !source || !target.isIn() || !source.isIn()) return false;
|
||
return source.countCards("he") > 1;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
trigger.source.chooseToDiscard("是否对" + get.translation(trigger.player) + "发动【殃众】？", "弃置两张牌，并令其失去1点体力", "he", 2).set("ai", function (card) {
|
||
var evt = _status.event;
|
||
if (get.attitude(evt.player, evt.getTrigger().player) >= 0) return 0;
|
||
return 7 - get.value(card);
|
||
}).logSkill = ["yangzhong", trigger.player];
|
||
"step 1";
|
||
if (result.bool) trigger.player.loseHp();
|
||
},
|
||
},
|
||
huangkong: {
|
||
audio: 2,
|
||
trigger: { target: "useCardToTargeted" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (player == _status.currentPhase || player.countCards("h")) return false;
|
||
return event.card.name == "sha" || get.type(event.card, false) == "trick";
|
||
},
|
||
content: function () {
|
||
player.draw(2);
|
||
},
|
||
},
|
||
hfjieying: {
|
||
audio: 2,
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt2("hfjieying"), lib.filter.notMe).set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return (
|
||
(get.attitude(player, target) *
|
||
(1 +
|
||
target.countCards("h", function (card) {
|
||
return !get.tag(card, "damage") && target.hasValueTarget(card);
|
||
}))) /
|
||
(1 + target.countCards("h"))
|
||
);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("hfjieying", target);
|
||
target.addTempSkill("hfjieying2", { player: "phaseJieshuBegin" });
|
||
}
|
||
},
|
||
ai: {
|
||
expose: 0.05,
|
||
},
|
||
},
|
||
hfjieying2: {
|
||
mod: {
|
||
cardEnabled: function (card, player) {
|
||
if (player.storage.hfjieying2) return false;
|
||
},
|
||
cardSavable: function (card, player) {
|
||
if (player.storage.hfjieying2) return false;
|
||
},
|
||
targetInRange: function (card, player) {
|
||
if (player == _status.currentPhase && (card.name == "sha" || get.type(card) == "trick")) return true;
|
||
},
|
||
aiOrder: function (player, card, num) {
|
||
var info = get.info(card);
|
||
if (!get.tag(card, "damage") && (!info || !info.toself)) return num + 8;
|
||
},
|
||
},
|
||
onremove: true,
|
||
trigger: { player: "useCard2" },
|
||
direct: true,
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
if (player != _status.currentPhase || event.targets.length != 1) return false;
|
||
var card = event.card;
|
||
if (card.name != "sha" && get.type(card) != "trick") return false;
|
||
var info = get.info(card);
|
||
if (info.allowMultiple == false) return false;
|
||
if (event.targets && !info.multitarget) {
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return !event.targets.includes(current) && lib.filter.targetEnabled2(card, player, current);
|
||
})
|
||
) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var prompt2 = "为" + get.translation(trigger.card) + "增加一个目标";
|
||
player
|
||
.chooseTarget(get.prompt("hfjieying2"), function (card, player, target) {
|
||
var player = _status.event.player;
|
||
return !_status.event.targets.includes(target) && lib.filter.targetEnabled2(_status.event.card, player, target);
|
||
})
|
||
.set("prompt2", prompt2)
|
||
.set("ai", function (target) {
|
||
var trigger = _status.event.getTrigger();
|
||
var player = _status.event.player;
|
||
return get.effect(target, trigger.card, player, player);
|
||
})
|
||
.set("card", trigger.card)
|
||
.set("targets", trigger.targets);
|
||
"step 1";
|
||
if (result.bool) {
|
||
if (!event.isMine() && !event.isOnline()) game.delayx();
|
||
event.targets = result.targets;
|
||
} else {
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
if (event.targets) {
|
||
player.logSkill("hfjieying2", event.targets);
|
||
trigger.targets.addArray(event.targets);
|
||
}
|
||
},
|
||
group: "hfjieying3",
|
||
mark: true,
|
||
intro: {
|
||
content: function (player) {
|
||
if (player) return "不能使用牌直到回合结束";
|
||
return "使用【杀】或普通锦囊牌时无距离限制且可以多指定一个目标";
|
||
},
|
||
},
|
||
},
|
||
hfjieying3: {
|
||
trigger: { source: "damageSource" },
|
||
forced: true,
|
||
popup: false,
|
||
filter: function (event, player) {
|
||
return !player.storage.hfjieying2 && player == _status.currentPhase;
|
||
},
|
||
content: function () {
|
||
player.storage.hfjieying2 = true;
|
||
},
|
||
},
|
||
weipo: {
|
||
audio: 2,
|
||
trigger: { target: "useCardToTargeted" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player != event.player && !player.hasSkill("weipo3") && player.countCards("h") < Math.min(5, player.maxHp) && (event.card.name == "sha" || get.type(event.card) == "trick");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.addTempSkill("weipo2");
|
||
player.drawTo(Math.min(5, player.maxHp));
|
||
"step 1";
|
||
var evt = trigger.getParent();
|
||
if (!evt.weipo) evt.weipo = {};
|
||
evt.weipo[player.playerid] = player.countCards("h");
|
||
},
|
||
},
|
||
weipo2: {
|
||
charlotte: true,
|
||
trigger: { global: "useCardAfter" },
|
||
forced: true,
|
||
popup: false,
|
||
filter: function (event, player) {
|
||
return event.weipo && event.weipo[player.playerid] != undefined && event.weipo[player.playerid] > player.countCards("h");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.addTempSkill("weipo3", { player: "phaseBegin" });
|
||
if (player.countCards("h") && trigger.player.isIn()) {
|
||
player.chooseCard("h", true, "将一张手牌交给" + get.translation(trigger.player));
|
||
} else event.finish();
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.give(result.cards, trigger.player);
|
||
}
|
||
},
|
||
},
|
||
weipo3: { charlotte: true },
|
||
refuqi: {
|
||
audio: "fuqi",
|
||
forced: true,
|
||
trigger: {
|
||
player: "useCard",
|
||
},
|
||
filter: function (event, player) {
|
||
return (
|
||
event.card &&
|
||
(get.type(event.card) == "trick" || (get.type(event.card) == "basic" && !["shan", "tao", "jiu", "du"].includes(event.card.name))) &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && get.distance(player, current) <= 1;
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
trigger.directHit.addArray(
|
||
game.filterPlayer(function (current) {
|
||
return current != player && get.distance(player, current) <= 1;
|
||
})
|
||
);
|
||
},
|
||
ai: {
|
||
directHit_ai: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
return get.distance(player, arg.target) <= 1;
|
||
},
|
||
},
|
||
},
|
||
zhuide: {
|
||
audio: 2,
|
||
trigger: { player: "die" },
|
||
forceDie: true,
|
||
skillAnimation: true,
|
||
animationColor: "thunder",
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt2("zhuide"), lib.filter.notMe).set("ai", function (target) {
|
||
return get.attitude(_status.event.player, target);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("zhuide", target);
|
||
var names = [];
|
||
var cards = [];
|
||
while (cards.length < 4) {
|
||
var card = get.cardPile2(function (card) {
|
||
return !cards.includes(card) && !names.includes(card.name) && get.type(card) == "basic";
|
||
});
|
||
if (card) {
|
||
cards.push(card);
|
||
names.push(card.name);
|
||
} else break;
|
||
}
|
||
if (cards.length) target.gain(cards, "gain2");
|
||
}
|
||
},
|
||
},
|
||
juntun: {
|
||
audio: 2,
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player.maxHp > 1;
|
||
},
|
||
content: function () {
|
||
player.loseMaxHp();
|
||
player.draw(player.maxHp);
|
||
},
|
||
},
|
||
jiaojie: {
|
||
audio: 2,
|
||
mod: {
|
||
ignoredHandcard: function (card, player) {
|
||
if (get.color(card) == "red") {
|
||
return true;
|
||
}
|
||
},
|
||
cardDiscardable: function (card, player, name) {
|
||
if (name == "phaseDiscard" && get.color(card) == "red") {
|
||
return false;
|
||
}
|
||
},
|
||
targetInRange: function (card) {
|
||
const color = get.color(card);
|
||
if (color === "black" || color === "unsure") return true;
|
||
},
|
||
cardUsable: function (card) {
|
||
const color = get.color(card);
|
||
if (color === "black" || color === "unsure") return Infinity;
|
||
},
|
||
},
|
||
},
|
||
decadewuniang: {
|
||
trigger: {
|
||
player: ["useCard", "respond"],
|
||
},
|
||
audio: "xinfu_wuniang",
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return event.card.name == "sha";
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt2("decadewuniang"), function (card, player, target) {
|
||
if (player == target) return false;
|
||
return target.countGainableCards(player, "he") > 0;
|
||
})
|
||
.set("ai", function (target) {
|
||
return 10 - get.attitude(_status.event.player, target);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("decadewuniang", target);
|
||
player.line(target, "fire");
|
||
player.gainPlayerCard(target, "he", true);
|
||
target.draw();
|
||
if (!player.storage.decadexushen) event.finish();
|
||
} else event.finish();
|
||
"step 2";
|
||
var list = game.filterPlayer(function (current) {
|
||
return current.name == "dc_guansuo" || current.name2 == "dc_guansuo";
|
||
});
|
||
if (list.length) game.asyncDraw(list);
|
||
else event.finish();
|
||
"step 3";
|
||
game.delayx();
|
||
},
|
||
},
|
||
minsi: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
getResult: function (cards) {
|
||
var l = cards.length;
|
||
var all = Math.pow(l, 2);
|
||
var list = [];
|
||
for (var i = 1; i < all; i++) {
|
||
var array = [];
|
||
for (var j = 0; j < l; j++) {
|
||
if (Math.floor((i % Math.pow(2, j + 1)) / Math.pow(2, j)) > 0) array.push(cards[j]);
|
||
}
|
||
var num = 0;
|
||
for (var k of array) {
|
||
num += get.number(k);
|
||
}
|
||
if (num == 13) list.push(array);
|
||
}
|
||
if (list.length) {
|
||
list.sort(function (a, b) {
|
||
if (a.length != b.length) return b.length - a.length;
|
||
return get.value(a) - get.value(b);
|
||
});
|
||
return list[0];
|
||
}
|
||
return list;
|
||
},
|
||
usable: 1,
|
||
filterCard: function (card) {
|
||
var num = 0;
|
||
for (var i = 0; i < ui.selected.cards.length; i++) {
|
||
num += get.number(ui.selected.cards[i]);
|
||
}
|
||
return get.number(card) + num <= 13;
|
||
},
|
||
complexCard: true,
|
||
selectCard: function () {
|
||
var num = 0;
|
||
for (var i = 0; i < ui.selected.cards.length; i++) {
|
||
num += get.number(ui.selected.cards[i]);
|
||
}
|
||
if (num == 13) return ui.selected.cards.length;
|
||
return ui.selected.cards.length + 2;
|
||
},
|
||
check: function (card) {
|
||
var evt = _status.event;
|
||
if (!evt.minsi_choice) evt.minsi_choice = lib.skill.minsi.getResult(evt.player.getCards("he"));
|
||
if (!evt.minsi_choice.includes(card)) return 0;
|
||
return 1;
|
||
},
|
||
position: "he",
|
||
content: function () {
|
||
player.draw(cards.length * 2).gaintag = ["minsi2"];
|
||
player.addTempSkill("minsi2");
|
||
},
|
||
ai: {
|
||
order: 5,
|
||
result: { player: 1 },
|
||
},
|
||
},
|
||
minsi2: {
|
||
onremove: function (player) {
|
||
player.removeGaintag("minsi2");
|
||
},
|
||
mod: {
|
||
targetInRange: function (card, player, target) {
|
||
if (!card.cards || !card.cards.length) return;
|
||
for (var i of card.cards) {
|
||
if (!i.hasGaintag("minsi2") || get.color(i) != "black") return;
|
||
}
|
||
return true;
|
||
},
|
||
ignoredHandcard: function (card, player) {
|
||
if (card.hasGaintag("minsi2") && get.color(card) == "red") {
|
||
return true;
|
||
}
|
||
},
|
||
cardDiscardable: function (card, player, name) {
|
||
if (name == "phaseDiscard" && card.hasGaintag("minsi2") && get.color(card) == "red") {
|
||
return false;
|
||
}
|
||
},
|
||
aiOrder: function (player, card, num) {
|
||
if (get.itemtype(card) == "card" && card.hasGaintag("minsi2") && get.color(card) == "black") return num - 0.1;
|
||
},
|
||
},
|
||
},
|
||
jijing: {
|
||
audio: 2,
|
||
trigger: { player: "damageEnd" },
|
||
frequent: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.judge();
|
||
"step 1";
|
||
var num = result.number;
|
||
var next = player.chooseToDiscard(
|
||
"是否弃置任意张点数之和为" + get.cnNumber(num) + "的牌并回复1点体力？",
|
||
function (card) {
|
||
var num = 0;
|
||
for (var i = 0; i < ui.selected.cards.length; i++) {
|
||
num += get.number(ui.selected.cards[i]);
|
||
}
|
||
return get.number(card) + num <= _status.event.num;
|
||
},
|
||
"he"
|
||
);
|
||
next.set("num", num);
|
||
next.set("complexCard", true);
|
||
next.set("selectCard", function () {
|
||
var num = 0;
|
||
for (var i = 0; i < ui.selected.cards.length; i++) {
|
||
num += get.number(ui.selected.cards[i]);
|
||
}
|
||
if (num == _status.event.num) return ui.selected.cards.length;
|
||
return ui.selected.cards.length + 2;
|
||
});
|
||
next.set(
|
||
"cardResult",
|
||
(function () {
|
||
var cards = player.getCards("he");
|
||
var l = cards.length;
|
||
var all = Math.pow(l, 2);
|
||
var list = [];
|
||
for (var i = 1; i < all; i++) {
|
||
var array = [];
|
||
for (var j = 0; j < l; j++) {
|
||
if (Math.floor((i % Math.pow(2, j + 1)) / Math.pow(2, j)) > 0) array.push(cards[j]);
|
||
}
|
||
var numx = 0;
|
||
for (var k of array) {
|
||
numx += get.number(k);
|
||
}
|
||
if (numx == num) list.push(array);
|
||
}
|
||
if (list.length) {
|
||
list.sort(function (a, b) {
|
||
return get.value(a) - get.value(b);
|
||
});
|
||
return list[0];
|
||
}
|
||
return list;
|
||
})()
|
||
);
|
||
next.set("ai", function (card) {
|
||
if (!_status.event.cardResult.includes(card)) return 0;
|
||
return 6 - get.value(card);
|
||
});
|
||
"step 2";
|
||
if (result.bool) player.recover();
|
||
},
|
||
},
|
||
cixiao: {
|
||
audio: 2,
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
if (
|
||
!game.hasPlayer(function (current) {
|
||
return current.hasSkill("panshi");
|
||
})
|
||
)
|
||
return true;
|
||
return (
|
||
player.countCards("he") >= 1 &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && !current.hasSkill("panshi");
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return current.hasSkill("panshi");
|
||
})
|
||
)
|
||
event.goto(2);
|
||
else
|
||
player.chooseTarget(lib.filter.notMe, get.prompt("cixiao"), "令一名其他角色获得「义子」标记").set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
var att = -get.attitude(player, target);
|
||
return att * target.countCards("h");
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("cixiao", target);
|
||
target.addSkills("panshi");
|
||
}
|
||
event.finish();
|
||
"step 2";
|
||
var list = game.filterPlayer(function (current) {
|
||
return current.hasSkill("panshi");
|
||
});
|
||
player.chooseCardTarget({
|
||
prompt: get.prompt("cixiao"),
|
||
prompt2: "弃置一张牌并将" + get.translation(list) + "的「义子」标记转移给其他角色",
|
||
position: "he",
|
||
filterTarget: function (card, player, target) {
|
||
return player != target && !target.hasSkill("panshi");
|
||
},
|
||
filterCard: lib.filter.cardDiscardable,
|
||
ai1: function (card) {
|
||
if (_status.event.goon) return 5 - get.value(card);
|
||
return 0;
|
||
},
|
||
ai2: function (target) {
|
||
var player = _status.event.player;
|
||
var att = -get.attitude(player, target);
|
||
return att * target.countCards("h");
|
||
},
|
||
goon: (function (target) {
|
||
var att = -get.attitude(player, target);
|
||
return att * target.countCards("h") <= 0;
|
||
})(list[0]),
|
||
});
|
||
"step 3";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("cixiao");
|
||
player.discard(result.cards).delay = false;
|
||
player.line2(
|
||
game
|
||
.filterPlayer(function (current) {
|
||
if (current.hasSkill("panshi")) {
|
||
current.removeSkills("panshi");
|
||
return true;
|
||
}
|
||
})
|
||
.concat(result.targets),
|
||
"green"
|
||
);
|
||
target.addSkills("panshi");
|
||
} else event.finish();
|
||
"step 4";
|
||
game.delayx();
|
||
},
|
||
derivation: "panshi",
|
||
ai: { threaten: 8 },
|
||
},
|
||
panshi: {
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
player.countCards("h") > 0 &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && current.hasSkill("cixiao");
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var targets = game.filterPlayer(function (current) {
|
||
return current != player && current.hasSkill("cixiao");
|
||
});
|
||
if (targets.length == 1) {
|
||
event.target = targets[0];
|
||
player.chooseCard("h", true, "叛弑：将一张手牌交给" + get.translation(targets));
|
||
} else
|
||
player.chooseCardTarget({
|
||
prompt: "叛弑：将一张手牌交给" + get.translation(targets) + "中的一名角色",
|
||
filterCard: true,
|
||
position: "h",
|
||
targets: targets,
|
||
forced: true,
|
||
filterTarget: function (card, player, target) {
|
||
return _status.event.targets.includes(target);
|
||
},
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
if (!target) target = result.targets[0];
|
||
player.line(target);
|
||
player.give(result.cards, target);
|
||
}
|
||
},
|
||
mark: true,
|
||
marktext: "子",
|
||
intro: {
|
||
name: "义子",
|
||
//content:'我是儿子',
|
||
//R·I·P——永远怀念：被棘手砍掉的“我是儿子”
|
||
content(_, player) {
|
||
const targets = game.filterPlayer2(target => target.hasSkill("cixiao", null, null, false)).sortBySeat(player);
|
||
if (!targets.length) return "我义父呢？！";
|
||
if (
|
||
["name", "name1", "name2"].some(name => {
|
||
if (!player[name] || !get.character(player[name]) || typeof get.translation(player[name]) != "string") return false;
|
||
return player[name].includes("lvbu") && get.translation(player[name]).includes("吕布");
|
||
})
|
||
)
|
||
return "公若不弃，布愿拜为义父";
|
||
return (
|
||
"我是" +
|
||
get.translation(targets) +
|
||
"的" +
|
||
(player => {
|
||
switch (player.sex) {
|
||
case "female":
|
||
return "义女";
|
||
case "double":
|
||
return "义子义女";
|
||
default:
|
||
return "义子";
|
||
}
|
||
})(player)
|
||
);
|
||
},
|
||
},
|
||
group: "panshi_damage",
|
||
ai: {
|
||
halfneg: true,
|
||
},
|
||
},
|
||
panshi_damage: {
|
||
trigger: { source: "damageBegin1" },
|
||
forced: true,
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
return player.isPhaseUsing() && event.card && event.card.name == "sha" && event.player.hasSkill("cixiao");
|
||
},
|
||
content: function () {
|
||
trigger.num++;
|
||
if (
|
||
["name", "name1", "name2"].some(name => {
|
||
if (!player[name] || !get.character(player[name]) || typeof get.translation(player[name]) != "string") return false;
|
||
return player[name].includes("lvbu") && get.translation(player[name]).includes("吕布");
|
||
})
|
||
)
|
||
player.chat("吾堂堂丈夫，安肯为汝子乎！");
|
||
var evt = event.getParent("phaseUse");
|
||
if (evt && evt.player == player) evt.skipped = true;
|
||
},
|
||
},
|
||
xianshuai: {
|
||
audio: 2,
|
||
trigger: { global: "damageSource" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return event.source && event.source.isIn() && !player.hasSkill("xianshuai2");
|
||
},
|
||
content: function () {
|
||
player.addTempSkill("xianshuai2", "roundStart");
|
||
player.draw();
|
||
if (player == trigger.source && trigger.player.isIn()) {
|
||
player.line(trigger.player, "green");
|
||
trigger.player.damage();
|
||
}
|
||
},
|
||
},
|
||
xianshuai2: { charlotte: true },
|
||
decadexushen: {
|
||
derivation: "decadezhennan",
|
||
audio: "xinfu_xushen",
|
||
trigger: { player: "dying" },
|
||
limited: true,
|
||
skillAnimation: true,
|
||
animationColor: "orange",
|
||
filter: function (event, player) {
|
||
return player.hp < 1;
|
||
},
|
||
content: function () {
|
||
player.awakenSkill("decadexushen");
|
||
player.addSkills("decadezhennan");
|
||
player.addTempSkill("decadexushen2");
|
||
trigger.decadexushen = true;
|
||
player.recover();
|
||
},
|
||
},
|
||
decadexushen2: {
|
||
trigger: { player: "dyingAfter" },
|
||
forced: true,
|
||
popup: false,
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
event.decadexushen == true &&
|
||
!game.hasPlayer(function (current) {
|
||
return current.name == "dc_guansuo" || current.name2 == "dc_guansuo";
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(lib.filter.notMe, "许身：是否令一名其他角色选择是否将其武将牌替换为“关索”并令其摸三张牌？").set("ai", function (target) {
|
||
return get.attitude(_status.event.player, target);
|
||
});
|
||
"step 1";
|
||
if (!result.bool) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.line(target, "fire");
|
||
target.chooseBool("许身：是否将自己的一张武将牌替换为“关索”并令" + get.translation(player) + "摸三张牌？");
|
||
"step 2";
|
||
if (result.bool) {
|
||
if (target.name2 != undefined) {
|
||
target.chooseControl(target.name1, target.name2).set("prompt", "请选择要更换的武将牌");
|
||
} else event._result = { control: target.name1 };
|
||
} else event.goto(4);
|
||
"step 3";
|
||
target.reinitCharacter(result.control, "dc_guansuo");
|
||
"step 4";
|
||
target.draw(3);
|
||
},
|
||
},
|
||
decadezhennan: {
|
||
audio: "xinfu_zhennan",
|
||
trigger: {
|
||
global: "useCardToPlayered",
|
||
},
|
||
filter: function (event, player) {
|
||
return event.isFirstTarget && event.targets && event.targets.length > 1 && get.type2(event.card) == "trick";
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt("decadezhennan"), "对一名其他角色造成1点伤害", function (card, player, target) {
|
||
return target != player;
|
||
})
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return get.damageEffect(target, player, player);
|
||
});
|
||
"step 1";
|
||
if (result.bool && result.targets && result.targets.length) {
|
||
player.logSkill("decadezhennan", result.targets);
|
||
result.targets[0].damage();
|
||
}
|
||
},
|
||
ai: {
|
||
expose: 0.25,
|
||
},
|
||
},
|
||
yujue: {
|
||
audio: 2,
|
||
derivation: "zhihu",
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return player.hasEnabledSlot();
|
||
},
|
||
chooseButton: {
|
||
dialog: function (event, player) {
|
||
return ui.create.dialog("###鬻爵###" + lib.translate.yujue_info);
|
||
},
|
||
chooseControl: function (event, player) {
|
||
var list = [];
|
||
for (var i = 1; i < 6; i++) {
|
||
if (player.hasEnabledSlot(i)) list.push("equip" + i);
|
||
}
|
||
list.push("cancel2");
|
||
return list;
|
||
},
|
||
check: function (event, player) {
|
||
for (var i = 5; i > 0; i--) {
|
||
if (player.hasEmptySlot(i)) return "equip" + i;
|
||
}
|
||
return "cancel2";
|
||
},
|
||
backup: function (result) {
|
||
var next = get.copy(lib.skill.yujuex);
|
||
next.position = result.control;
|
||
return next;
|
||
},
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
result: {
|
||
player: function (player) {
|
||
if (
|
||
game.hasPlayer(function (target) {
|
||
if (player == target) return false;
|
||
var hs = target.countCards("h");
|
||
return hs > 2 && get.attitude(player, target) > 0;
|
||
})
|
||
)
|
||
return 1;
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
yujuex: {
|
||
audio: "yujue",
|
||
async content(event, trigger, player) {
|
||
await player.disableEquip(lib.skill.yujue_backup.position);
|
||
if (
|
||
player.isIn() &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && current.countCards("h");
|
||
})
|
||
) {
|
||
const result = await player
|
||
.chooseTarget(true, "选择一名角色交给你一张牌并获得技能〖执笏〗", function (card, player, target) {
|
||
if (player == target) return false;
|
||
return target.countCards("h") > 0;
|
||
})
|
||
.set("ai", function (target) {
|
||
return get.attitude(_status.event.player, target) * target.countCards("h");
|
||
})
|
||
.forResult();
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.line(target);
|
||
const result2 = await target.chooseCard("h", true, "交给" + get.translation(player) + "一张手牌").forResult();
|
||
if (result2.bool && result2.cards && result2.cards.length) {
|
||
await target.give(result2.cards, player);
|
||
target.storage.zhihu_mark = player;
|
||
await target.addSkills("zhihu");
|
||
target.addSkill("zhihu_mark");
|
||
}
|
||
}
|
||
}
|
||
},
|
||
},
|
||
zhihu: {
|
||
usable: 2,
|
||
trigger: { source: "damageSource" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player != event.player;
|
||
},
|
||
content: function () {
|
||
player.draw(2);
|
||
},
|
||
},
|
||
zhihu_mark: {
|
||
mark: "character",
|
||
intro: {
|
||
content: "以$之名，授予汝技能〖执笏〗，直至$的下回合开始为止！",
|
||
},
|
||
onremove: function (player) {
|
||
delete player.storage.zhihu_mark;
|
||
player.removeSkills("zhihu");
|
||
},
|
||
trigger: { global: "phaseBeginStart" },
|
||
firstDo: true,
|
||
charlotte: true,
|
||
silent: true,
|
||
filter: function (event, player) {
|
||
return event.player == player.storage.zhihu_mark;
|
||
},
|
||
content: function () {
|
||
player.removeSkill("zhihu_mark");
|
||
},
|
||
},
|
||
tuxing: {
|
||
audio: 2,
|
||
trigger: { player: "disableEquipAfter" },
|
||
forced: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.gainMaxHp();
|
||
player.recover();
|
||
"step 1";
|
||
if (!player.hasEnabledSlot()) {
|
||
player.loseMaxHp(4);
|
||
player.addSkill("tuxing2");
|
||
}
|
||
},
|
||
},
|
||
tuxing2: {
|
||
audio: "tuxing",
|
||
trigger: { source: "damageBegin1" },
|
||
forced: true,
|
||
charlotte: true,
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
mark: true,
|
||
intro: {
|
||
content: "造成伤害时，此伤害+1",
|
||
},
|
||
},
|
||
gongjian: {
|
||
audio: 2,
|
||
trigger: { global: "useCardToPlayered" },
|
||
usable: 1,
|
||
logTarget: function (event) {
|
||
return event.parent.gongjian_targets.filter(function (target) {
|
||
return event.targets.includes(target) && target.countCards("he") > 0;
|
||
});
|
||
},
|
||
filter: function (event, player) {
|
||
if (event.card.name != "sha" || !event.isFirstTarget) return false;
|
||
if (
|
||
event.parent.gongjian_targets &&
|
||
event.parent.gongjian_targets.filter(function (target) {
|
||
return event.targets.includes(target) && target.countCards("he") > 0;
|
||
}).length > 0
|
||
)
|
||
return true;
|
||
return false;
|
||
},
|
||
check: function (event, player) {
|
||
var targets = event.parent.gongjian_targets.filter(function (target) {
|
||
return event.targets.includes(target) && target.countCards("he") > 0;
|
||
}),
|
||
att = 0;
|
||
for (var i of targets) {
|
||
att += get.attitude(player, i);
|
||
}
|
||
return att < 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.targets = trigger.parent.gongjian_targets.filter(function (target) {
|
||
return trigger.targets.includes(target);
|
||
});
|
||
event.num = 0;
|
||
"step 1";
|
||
var target = targets[num];
|
||
player.discardPlayerCard(target, true, "he", [1, 2]).set("forceAuto", true);
|
||
"step 2";
|
||
event.num++;
|
||
if (event.num < targets.length) event.goto(1);
|
||
else {
|
||
var cards = [];
|
||
game.getGlobalHistory("cardMove", function (evt) {
|
||
if (evt.player && evt.hs && evt.type == "discard" && evt.getParent(3) == event) {
|
||
for (var i of evt.hs) {
|
||
if (get.name(i, evt.player) == "sha" && get.position(i, true) == "d") cards.add(i);
|
||
}
|
||
}
|
||
});
|
||
if (cards.length) player.gain(cards, "gain2");
|
||
}
|
||
},
|
||
group: "gongjian_count",
|
||
subSkill: {
|
||
count: {
|
||
trigger: { global: "useCard1" },
|
||
silent: true,
|
||
firstDo: true,
|
||
filter: function (event, player) {
|
||
return event.card && event.card.name == "sha";
|
||
},
|
||
content: function () {
|
||
if (player.storage.gongjian) trigger.gongjian_targets = player.storage.gongjian;
|
||
player.storage.gongjian = trigger.targets;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
kuimang: {
|
||
audio: 2,
|
||
trigger: { global: "dieAfter" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
player.getAllHistory("sourceDamage", function (target) {
|
||
return target.player == event.player;
|
||
}).length > 0
|
||
);
|
||
},
|
||
content: function () {
|
||
player.draw(2);
|
||
},
|
||
},
|
||
rexiemu: {
|
||
audio: 2,
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return !game.hasPlayer(function (current) {
|
||
return current.hasMark("rexiemu");
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt2("rexiemu"), lib.filter.notMe).set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return get.attitude(player, target) * Math.sqrt(Math.max(1 + player.countCards("h"), 1 + target.countCards("h")));
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("rexiemu", target);
|
||
target.addMark("rexiemu", 1);
|
||
player.addSkill("rexiemu2");
|
||
}
|
||
},
|
||
intro: { content: "mark" },
|
||
ai: {
|
||
expose: 0.1,
|
||
},
|
||
},
|
||
rexiemu2: {
|
||
audio: "rexiemu",
|
||
trigger: { global: ["loseAfter"] },
|
||
forced: true,
|
||
charlotte: true,
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return (
|
||
(event.player == player || event.player.hasMark("rexiemu")) &&
|
||
["useCard", "respond"].includes(event.getParent().name) &&
|
||
event.hs &&
|
||
event.hs.length &&
|
||
event.player != _status.currentPhase &&
|
||
game.hasPlayer(function (current) {
|
||
return current.hasMark("rexiemu");
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
game.asyncDraw(
|
||
game.filterPlayer(function (current) {
|
||
return current == player || current == trigger.player || current.hasMark("rexiemu");
|
||
})
|
||
);
|
||
"step 1";
|
||
game.delayx();
|
||
},
|
||
group: "rexiemu3",
|
||
},
|
||
rexiemu3: {
|
||
trigger: { player: "phaseBegin" },
|
||
forced: true,
|
||
charlotte: true,
|
||
silent: true,
|
||
firstDo: true,
|
||
content: function () {
|
||
player.removeSkill("rexiemu2");
|
||
game.countPlayer(function (current) {
|
||
var num = current.countMark("rexiemu");
|
||
if (num) current.removeMark("rexiemu", num);
|
||
});
|
||
},
|
||
},
|
||
heli: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(function (current) {
|
||
return lib.skill.heli.filterTarget(null, player, current);
|
||
});
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target.countCards("h") < player.countCards("h");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (target.countCards("h")) target.showHandcards();
|
||
"step 1";
|
||
var list = [];
|
||
var cards = [];
|
||
for (var i of lib.inpile) list.add(get.type2(i));
|
||
for (var i of list) {
|
||
if (
|
||
!target.countCards("h", function (card) {
|
||
return get.type2(card, target) == i;
|
||
})
|
||
) {
|
||
var card = get.cardPile2(function (card) {
|
||
return get.type2(card, false) == i;
|
||
});
|
||
if (card) cards.push(card);
|
||
}
|
||
}
|
||
if (cards.length) target.gain(cards, "gain2", "log");
|
||
},
|
||
ai: {
|
||
order: 10,
|
||
result: {
|
||
target: function (player, target) {
|
||
return 1 / Math.sqrt(1 + target.countCards("h"));
|
||
},
|
||
},
|
||
},
|
||
},
|
||
moying: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "loseAfter",
|
||
global: ["equipAfter", "addJudgeAfter", "gainAfter", "loseAsyncAfter", "addToExpansionAfter"],
|
||
},
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
if (player == _status.currentPhase || event.getParent().name == "useCard") return false;
|
||
if (event.name == "gain" && event.player == player) return false;
|
||
var evt = event.getl(player);
|
||
return evt && evt.cards2 && evt.cards2.length == 1 && ["equip", "trick"].includes(get.type2(evt.cards2[0], evt.type == "discard" && evt.hs.includes(evt.cards2[0]) ? player : false)) && !player.hasSkill("moying2");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var number = trigger.getl(player).cards2[0].number;
|
||
var numbers = [number - 2, number - 1, number, number + 1, number + 2].filter(function (number) {
|
||
return number >= 1 && number <= 13;
|
||
});
|
||
if (player.isUnderControl()) {
|
||
game.swapPlayerAuto(player);
|
||
}
|
||
var switchToAuto = function () {
|
||
_status.imchoosing = false;
|
||
event._result = {
|
||
bool: true,
|
||
suit: lib.suit.randomGet(),
|
||
number: numbers.randomGet(),
|
||
};
|
||
if (event.dialog) event.dialog.close();
|
||
if (event.control) event.control.close();
|
||
};
|
||
var chooseButton = function (player, numbers) {
|
||
var event = _status.event;
|
||
player = player || event.player;
|
||
if (!event._result) event._result = {};
|
||
var dialog = ui.create.dialog("是否发动【墨影】？", "forcebutton", "hidden");
|
||
event.dialog = dialog;
|
||
dialog.addText("花色");
|
||
var table = document.createElement("div");
|
||
table.classList.add("add-setting");
|
||
table.style.margin = "0";
|
||
table.style.width = "100%";
|
||
table.style.position = "relative";
|
||
var listi = ["spade", "heart", "club", "diamond"];
|
||
for (var i = 0; i < listi.length; i++) {
|
||
var td = ui.create.div(".shadowed.reduce_radius.pointerdiv.tdnode");
|
||
td.link = listi[i];
|
||
table.appendChild(td);
|
||
td.innerHTML = "<span>" + get.translation(listi[i]) + "</span>";
|
||
td.addEventListener(lib.config.touchscreen ? "touchend" : "click", function () {
|
||
if (_status.dragged) return;
|
||
if (_status.justdragged) return;
|
||
_status.tempNoButton = true;
|
||
setTimeout(function () {
|
||
_status.tempNoButton = false;
|
||
}, 500);
|
||
var link = this.link;
|
||
var current = this.parentNode.querySelector(".bluebg");
|
||
if (current) {
|
||
current.classList.remove("bluebg");
|
||
}
|
||
this.classList.add("bluebg");
|
||
event._result.suit = link;
|
||
});
|
||
}
|
||
dialog.content.appendChild(table);
|
||
dialog.addText("点数");
|
||
var table2 = document.createElement("div");
|
||
table2.classList.add("add-setting");
|
||
table2.style.margin = "0";
|
||
table2.style.width = "100%";
|
||
table2.style.position = "relative";
|
||
for (var i = 0; i < numbers.length; i++) {
|
||
var td = ui.create.div(".shadowed.reduce_radius.pointerdiv.tdnode");
|
||
td.link = numbers[i];
|
||
table2.appendChild(td);
|
||
var num = numbers[i];
|
||
switch (num) {
|
||
case 1:
|
||
num = "A";
|
||
break;
|
||
case 11:
|
||
num = "J";
|
||
break;
|
||
case 12:
|
||
num = "Q";
|
||
break;
|
||
case 13:
|
||
num = "K";
|
||
break;
|
||
}
|
||
td.innerHTML = "<span>" + num + "</span>";
|
||
td.addEventListener(lib.config.touchscreen ? "touchend" : "click", function () {
|
||
if (_status.dragged) return;
|
||
if (_status.justdragged) return;
|
||
_status.tempNoButton = true;
|
||
setTimeout(function () {
|
||
_status.tempNoButton = false;
|
||
}, 500);
|
||
var link = this.link;
|
||
var current = this.parentNode.querySelector(".bluebg");
|
||
if (current) {
|
||
current.classList.remove("bluebg");
|
||
}
|
||
this.classList.add("bluebg");
|
||
event._result.number = link;
|
||
});
|
||
}
|
||
dialog.content.appendChild(table2);
|
||
dialog.add(" ");
|
||
event.dialog.open();
|
||
|
||
event.switchToAuto = function () {
|
||
event._result = {
|
||
bool: true,
|
||
number: numbers.randomGet(),
|
||
suit: lib.suit.randomGet(),
|
||
};
|
||
event.dialog.close();
|
||
event.control.close();
|
||
game.resume();
|
||
_status.imchoosing = false;
|
||
};
|
||
event.control = ui.create.control("ok", "cancel2", function (link) {
|
||
var result = event._result;
|
||
if (link == "cancel2") result.bool = false;
|
||
else {
|
||
if (!result.number || !result.suit) return;
|
||
result.bool = true;
|
||
}
|
||
event.dialog.close();
|
||
event.control.close();
|
||
game.resume();
|
||
_status.imchoosing = false;
|
||
});
|
||
for (var i = 0; i < event.dialog.buttons.length; i++) {
|
||
event.dialog.buttons[i].classList.add("selectable");
|
||
}
|
||
game.pause();
|
||
game.countChoose();
|
||
};
|
||
if (event.isMine()) {
|
||
chooseButton(player, numbers);
|
||
} else if (event.isOnline()) {
|
||
event.player.send(chooseButton, event.player, numbers);
|
||
event.player.wait();
|
||
game.pause();
|
||
} else {
|
||
switchToAuto();
|
||
}
|
||
"step 1";
|
||
var map = event.result || result;
|
||
if (map.bool) {
|
||
player.logSkill("moying");
|
||
player.addTempSkill("moying2");
|
||
var cards = [];
|
||
for (var i = 0; i < ui.cardPile.childNodes.length; i++) {
|
||
var card = ui.cardPile.childNodes[i];
|
||
if (get.suit(card) == map.suit && get.number(card) == map.number) cards.push(card);
|
||
}
|
||
if (cards.length) player.gain(cards, "gain2", "log");
|
||
}
|
||
},
|
||
},
|
||
moying2: {},
|
||
juanhui: {
|
||
audio: 2,
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt("juanhui"), lib.filter.notMe, "选择记录一名其他角色使用过的牌").set("ai", function (target) {
|
||
if (target.isTurnedOver() || target.hasJudge("lebu")) return Math.random();
|
||
return (1 + target.countCards("h")) * 2 + Math.random();
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("juanhui", target);
|
||
player.storage.juanhui2 = target;
|
||
player.storage.juanhui3 = [];
|
||
player.addSkill("juanhui2");
|
||
}
|
||
},
|
||
},
|
||
juanhui2: {
|
||
charlotte: true,
|
||
mark: true,
|
||
mod: {
|
||
cardUsable: function (card) {
|
||
if (card.name == "sha" && _status.event.skill == "juanhui2_backup") return Infinity;
|
||
},
|
||
},
|
||
intro: {
|
||
markcount: function (storage, player) {
|
||
return player.getStorage("juanhui3").length;
|
||
},
|
||
mark: function (dialog, storage, player) {
|
||
dialog.addText("记录目标");
|
||
dialog.addSmall([storage]);
|
||
var vcard = player.getStorage("juanhui3");
|
||
if (vcard.length) {
|
||
dialog.addText("记录卡牌");
|
||
dialog.addSmall([vcard, "vcard"]);
|
||
}
|
||
},
|
||
content: function (storage, player) {
|
||
var str = "记录目标：" + get.translation(storage);
|
||
var vcard = player.getStorage("juanhui3");
|
||
if (vcard.length) {
|
||
str += "<br>记录卡牌：";
|
||
for (var i of vcard) {
|
||
if (i[2] == "sha" && i[3]) str += get.translation(i[3]);
|
||
str += get.translation(i[2]);
|
||
str += "、";
|
||
}
|
||
str = str.slice(0, str.length - 1);
|
||
}
|
||
return str;
|
||
},
|
||
},
|
||
onremove: function (player) {
|
||
delete player.storage.juanhui2;
|
||
delete player.storage.juanhui3;
|
||
},
|
||
group: "juanhui3",
|
||
enable: "phaseUse",
|
||
filter: function (event, player) {
|
||
return player.getStorage("juanhui3").length > 0 && player.countCards("hs") > 0;
|
||
},
|
||
chooseButton: {
|
||
dialog: function (event, player) {
|
||
return ui.create.dialog("绢绘", [player.getStorage("juanhui3"), "vcard"], "hidden");
|
||
},
|
||
filter: function (button, player) {
|
||
return lib.filter.cardEnabled(
|
||
{
|
||
name: button.link[2],
|
||
nature: button.link[3],
|
||
},
|
||
player,
|
||
_status.event.getParent()
|
||
);
|
||
},
|
||
check: function (button) {
|
||
var player = _status.event.player;
|
||
var card = {
|
||
name: button.link[2],
|
||
nature: button.link[3],
|
||
};
|
||
if (player.getUseValue(card) > 0) return get.order(card);
|
||
return -1;
|
||
},
|
||
backup: function (links, player) {
|
||
return {
|
||
audio: "juanhui",
|
||
popname: true,
|
||
filterCard: true,
|
||
position: "hs",
|
||
viewAs: {
|
||
name: links[0][2],
|
||
nature: links[0][3],
|
||
},
|
||
check: function (card) {
|
||
return 6 - get.value(card);
|
||
},
|
||
precontent: function () {
|
||
var card = event.result.card;
|
||
if (card.name == "sha") event.getParent().addCount = false;
|
||
var vcard = player.storage.juanhui3;
|
||
for (var i = 0; i < vcard.length; i++) {
|
||
if (vcard[i][2] == card.name) vcard.splice(i--, 1);
|
||
}
|
||
if (vcard.length) player.markSkill("juanhui2");
|
||
else {
|
||
player.unmarkSkill("juanhui2");
|
||
event.getParent().juanhui = true;
|
||
}
|
||
},
|
||
};
|
||
},
|
||
prompt: function (links, player) {
|
||
return "将一张手牌当做" + (links[0][2] == "sha" && links[0][3] ? get.translation(links[0][3]) : "") + get.translation(links[0][2]) + "使用";
|
||
},
|
||
},
|
||
ai: {
|
||
order: function (item, player) {
|
||
var muniu = player.getStorage("juanhui3");
|
||
var order = 0;
|
||
for (var i = 0; i < muniu.length; i++) {
|
||
var card = { name: muniu[i][2], nature: muniu[i][3] };
|
||
if (player.getUseValue(card) > 0) {
|
||
var order2 = get.order(card);
|
||
if (order2 > order) order = order2;
|
||
}
|
||
}
|
||
return order + 0.1;
|
||
},
|
||
result: {
|
||
player: 1,
|
||
},
|
||
},
|
||
},
|
||
juanhui3: {
|
||
charlotte: true,
|
||
firstDo: true,
|
||
trigger: {
|
||
global: "useCard2",
|
||
player: ["phaseUseEnd", "phaseUseSkipped", "useCardAfter"],
|
||
},
|
||
silent: true,
|
||
filter: function (event, player, name) {
|
||
if (event.name == "phaseUse") return true;
|
||
else if (name == "useCardAfter") return event.getParent().juanhui;
|
||
return (
|
||
event.player == player.storage.juanhui2 &&
|
||
event.player.isPhaseUsing() &&
|
||
["basic", "trick"].includes(get.type(event.card)) &&
|
||
player.getStorage("juanhui3").filter(function (vcard) {
|
||
return vcard[2] == event.card.name;
|
||
}).length == 0
|
||
);
|
||
},
|
||
content: function () {
|
||
if (trigger.name == "phaseUse") player.removeSkill("juanhui2");
|
||
else if (event.triggername == "useCardAfter") {
|
||
player.recover();
|
||
player.drawTo(3);
|
||
} else {
|
||
var vcard = [get.type(trigger.card), "", trigger.card.name];
|
||
if (game.hasNature(trigger.card)) vcard.push(get.nature(trigger.card));
|
||
player.storage.juanhui3.push(vcard);
|
||
player.markSkill("juanhui2");
|
||
}
|
||
},
|
||
},
|
||
mubing: {
|
||
audio: 2,
|
||
audioname: ["sp_key_yuri"],
|
||
trigger: { player: "phaseUseBegin" },
|
||
//direct:true,
|
||
frequent: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("he") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var num = player.storage.mubing2 ? 4 : 3;
|
||
event.num = num;
|
||
event.cards = game.cardsGotoOrdering(get.cards(num)).cards;
|
||
game.log(player, "展示了", event.cards);
|
||
event.videoId = lib.status.videoId++;
|
||
game.broadcastAll(
|
||
function (player, id, cards) {
|
||
var str = get.translation(player) + "发动了【募兵】";
|
||
var dialog = ui.create.dialog(str, cards);
|
||
dialog.videoId = id;
|
||
},
|
||
player,
|
||
event.videoId,
|
||
event.cards
|
||
);
|
||
game.addVideo("showCards", player, [get.translation(player) + "发动了【募兵】", get.cardsInfo(event.cards)]);
|
||
game.delay(2);
|
||
"step 1";
|
||
var numa = 0;
|
||
cards.sort(function (a, b) {
|
||
return a.number - b.number;
|
||
});
|
||
for (var i of cards) {
|
||
if (get.value(i, player) > 0) numa += get.number(i);
|
||
}
|
||
player
|
||
.chooseToDiscard([1, Infinity], "h")
|
||
.set("ai", function (card) {
|
||
var player = _status.event.player;
|
||
var numa = _status.event.numa;
|
||
//if(card.name!='tengjia'&&get.position(card)=='e'&&get.equipValue(card,player)<=0) return 14;
|
||
var num = 0;
|
||
for (var i of ui.selected.cards) {
|
||
num += i.number;
|
||
}
|
||
if (num >= numa) return 0;
|
||
if (card.number + num >= numa) return 15 - get.value(card);
|
||
if (!ui.selected.cards.length) {
|
||
var min = _status.event.min;
|
||
if (
|
||
card.number < min &&
|
||
!player.countCards("h", function (xcard) {
|
||
return xcard != card && card.number + xcard.number > min;
|
||
})
|
||
)
|
||
return 0;
|
||
return card.number;
|
||
}
|
||
return Math.max(5 - get.value(card), card.number);
|
||
})
|
||
.set("prompt", false)
|
||
.set("numa", numa)
|
||
.set("min", cards[0].number);
|
||
var func = function (id) {
|
||
var dialog = get.idDialog(id);
|
||
if (dialog) dialog.content.firstChild.innerHTML = "请选择要弃置的牌";
|
||
};
|
||
if (player == game.me) func(event.videoId);
|
||
else if (player.isOnline()) player.send(func, event.videoId);
|
||
"step 2";
|
||
if (!result.bool) {
|
||
return;
|
||
}
|
||
var numx = 0;
|
||
for (var i of result.cards) {
|
||
numx += get.number(i);
|
||
}
|
||
event.numx = numx;
|
||
var next = player.chooseButton([0, num]);
|
||
next.set("dialog", event.videoId);
|
||
next.set("filterButton", function (button) {
|
||
var num = 0;
|
||
for (var i = 0; i < ui.selected.buttons.length; i++) {
|
||
num += get.number(ui.selected.buttons[i].link);
|
||
}
|
||
return num + get.number(button.link) <= _status.event.maxNum;
|
||
});
|
||
next.set("maxNum", event.numx);
|
||
next.set("ai", function (button) {
|
||
return get.value(button.link, _status.event.player);
|
||
});
|
||
var func = function (id) {
|
||
var dialog = get.idDialog(id);
|
||
if (dialog) dialog.content.firstChild.innerHTML = "请选择要获得的牌";
|
||
};
|
||
if (player == game.me) func(event.videoId);
|
||
else if (player.isOnline()) player.send(func, event.videoId);
|
||
"step 3";
|
||
if (!result.bool) event.cards = [];
|
||
else event.cards = result.links;
|
||
"step 4";
|
||
game.broadcastAll("closeDialog", event.videoId);
|
||
game.addVideo("cardDialog", null, event.videoId);
|
||
if (!cards.length) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
player.gain(cards, "log", "gain2");
|
||
if (!player.storage.mubing2) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
event.given = [];
|
||
"step 5";
|
||
var hs = player.getCards("h");
|
||
cards = cards.filter(function (card) {
|
||
return hs.includes(card);
|
||
});
|
||
if (
|
||
cards.length &&
|
||
game.hasPlayer(function (current) {
|
||
return current != player && !event.given.includes(current);
|
||
})
|
||
)
|
||
player.chooseCardTarget({
|
||
prompt: "是否将得到的牌中的任意张交给其他角色？",
|
||
selectCard: [1, cards.length],
|
||
filterCard: function (card) {
|
||
return _status.event.cards.includes(card);
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && !_status.event.given.includes(target);
|
||
},
|
||
cards: cards,
|
||
given: event.given,
|
||
ai1: function (card) {
|
||
return -1;
|
||
},
|
||
});
|
||
else event.finish();
|
||
"step 6";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
var cards = result.cards;
|
||
event.given.push(target);
|
||
event.cards.removeArray(cards);
|
||
player.line(target, "green");
|
||
player.give(cards, target);
|
||
event.goto(5);
|
||
}
|
||
},
|
||
},
|
||
ziqu: {
|
||
audio: 2,
|
||
audioname: ["sp_key_yuri"],
|
||
trigger: { source: "damageBegin2" },
|
||
filter: function (event, player) {
|
||
return event.player != player && !player.getStorage("ziqu").includes(event.player) && event.player.countCards("he") > 0;
|
||
},
|
||
check: function (event, player) {
|
||
var target = event.player;
|
||
var eff = get.damageEffect(target, player, player);
|
||
if (get.attitude(player, target) > 0) {
|
||
if (eff >= 0) return false;
|
||
return true;
|
||
}
|
||
if (eff <= 0) return true;
|
||
if (target.hp == 1) return false;
|
||
if (event.num > 1) return false;
|
||
var cards = target.getCards("he");
|
||
for (var i = 0; i < cards.length; i++) {
|
||
if (get.number(cards[i]) > 10) return true;
|
||
}
|
||
return false;
|
||
},
|
||
logTarget: "player",
|
||
content: function () {
|
||
"step 0";
|
||
trigger.cancel();
|
||
if (!player.storage.ziqu) player.storage.ziqu = [];
|
||
player.storage.ziqu.push(trigger.player);
|
||
player.markSkill("ziqu");
|
||
trigger.player.chooseCard(true, "he", function (card, player) {
|
||
return !player.countCards("he", function (cardx) {
|
||
return cardx.number > card.number;
|
||
});
|
||
});
|
||
"step 1";
|
||
if (result.bool && result.cards && result.cards.length) trigger.player.give(result.cards, player);
|
||
},
|
||
intro: { content: "已对$发动过" },
|
||
},
|
||
mubing_rewrite: {
|
||
mark: true,
|
||
intro: {
|
||
content: "出牌阶段开始时，你可以亮出牌堆顶的四张牌。你可弃置任意张手牌，并可获得任意张点数之和不大于你弃置的牌点数之和的牌。然后你可将以此法得到的牌以任意方式交给其他角色。",
|
||
},
|
||
ai: {
|
||
combo: "mubing",
|
||
},
|
||
},
|
||
diaoling: {
|
||
audio: 2,
|
||
audioname: ["sp_key_yuri"],
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
forced: true,
|
||
juexingji: true,
|
||
skillAnimation: true,
|
||
animationColor: "metal",
|
||
filter: function (event, player) {
|
||
var num = 0;
|
||
player.getAllHistory("gain", function (evt) {
|
||
var evt2 = evt.getParent();
|
||
if (evt2.name == "mubing" && evt2.player == player)
|
||
num += evt.cards.filter(function (card) {
|
||
return card.name == "sha" || get.subtype(card, false) == "equip1" || (get.type2(card, false) == "trick" && get.tag({ name: card.name }, "damage"));
|
||
}).length;
|
||
});
|
||
return num >= 6;
|
||
},
|
||
content: function () {
|
||
player.awakenSkill("diaoling");
|
||
player.storage.mubing2 = true;
|
||
player.markSkill("mubing_rewrite");
|
||
player.chooseDrawRecover(2, true);
|
||
},
|
||
ai: {
|
||
combo: "mubing",
|
||
},
|
||
derivation: "mubing_rewrite",
|
||
},
|
||
refenyin_wufan: { audio: 2 },
|
||
//官渡之战
|
||
xiying: {
|
||
trigger: { player: "phaseUseBegin" },
|
||
audio: 2,
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
player.countCards("h", function (card) {
|
||
return _status.connectMode || get.type(card) != "basic";
|
||
}) > 0
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var list = game.filterPlayer(function (current) {
|
||
return current != player;
|
||
});
|
||
list.sortBySeat();
|
||
event.targets = list;
|
||
player
|
||
.chooseToDiscard(get.prompt2("xiying"), "h", function (card) {
|
||
return get.type(card) != "basic";
|
||
})
|
||
.set("logSkill", ["xiying", list])
|
||
.set("ai", function (card) {
|
||
return _status.event.val - get.value(card);
|
||
})
|
||
.set(
|
||
"val",
|
||
(function () {
|
||
return (
|
||
4 *
|
||
Math.sqrt(
|
||
game.countPlayer(function (current) {
|
||
return get.attitude(player, current) < 0 && current.countCards("he") > 0;
|
||
})
|
||
)
|
||
);
|
||
})()
|
||
);
|
||
"step 1";
|
||
if (!result.bool) event.finish();
|
||
else player.addTempSkill("xiying_gain");
|
||
"step 2";
|
||
var target = targets.shift();
|
||
event.target = target;
|
||
if (target.isIn())
|
||
target.chooseToDiscard("he", "弃置一张牌，或本回合内不能使用或打出牌").set("ai", function (card) {
|
||
var player = _status.event.player;
|
||
var source = _status.event.getTrigger().player;
|
||
if (get.attitude(source, player) > 0) return -1;
|
||
if (_status.event.getRand() > 0.5) return 5 - get.value(card);
|
||
return -1;
|
||
});
|
||
"step 3";
|
||
if (target.isIn() && !result.bool) target.addTempSkill("xiying2");
|
||
if (targets.length) event.goto(2);
|
||
},
|
||
ai: {
|
||
directHit_ai: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
return arg.target.hasSkill("xiying2");
|
||
},
|
||
},
|
||
subSkill: {
|
||
gain: {
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
forced: true,
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
player.getHistory("sourceDamage", function (evt) {
|
||
return evt.isPhaseUsing(player);
|
||
}).length > 0
|
||
);
|
||
},
|
||
content: function () {
|
||
var card = get.cardPile2(function (card) {
|
||
var type = get.type(card, false);
|
||
if (type != "basic" && type != "trick") return false;
|
||
return get.tag(card, "damage") > 0;
|
||
});
|
||
if (card) player.gain(card, "gain2");
|
||
},
|
||
},
|
||
},
|
||
},
|
||
xiying2: {
|
||
mark: true,
|
||
intro: { content: "本回合内不能使用或打出牌" },
|
||
mod: {
|
||
cardEnabled2: function (card) {
|
||
return false;
|
||
},
|
||
},
|
||
},
|
||
gangzhi: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "damageBefore",
|
||
source: "damageBefore",
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (event.source == event.player) return false;
|
||
if (event.player == player) {
|
||
return event.source && event.source.isIn();
|
||
}
|
||
return true;
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
trigger.player.loseHp(trigger.num);
|
||
},
|
||
ai: {
|
||
jueqing: true,
|
||
},
|
||
},
|
||
beizhan: {
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
direct: true,
|
||
audio: 2,
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt2("beizhan")).set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
var att = get.attitude(player, target);
|
||
var hs = target.countCards("h");
|
||
var ht = target.maxHp;
|
||
if (hs >= ht && target.isMaxHandcard()) return -att * hs;
|
||
if (
|
||
hs < ht &&
|
||
game.hasPlayer(function (current) {
|
||
return current.countCards("h") > ht;
|
||
})
|
||
)
|
||
return att * 2 * (ht - hs);
|
||
return 0;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("beizhan", target);
|
||
target.drawTo(Math.min(5, target.maxHp));
|
||
target.addSkill("beizhan2");
|
||
}
|
||
},
|
||
ai: {
|
||
expose: 0.25,
|
||
},
|
||
},
|
||
beizhan2: {
|
||
trigger: { player: "phaseBegin" },
|
||
silent: true,
|
||
firstDo: true,
|
||
content: function () {
|
||
player.removeSkill("beizhan2");
|
||
if (player.isMaxHandcard()) player.addTempSkill("zishou2");
|
||
},
|
||
mark: true,
|
||
intro: { content: "回合开始时，若手牌数为全场最多，则回合内不能使用牌指定其他角色为目标" },
|
||
},
|
||
fenglve: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "phaseUseBegin",
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
var goon = player.hasCard(function (card) {
|
||
if (get.position(card) != "h") return false;
|
||
var val = get.value(card);
|
||
if (val < 0) return true;
|
||
if (val <= 5) {
|
||
return card.number >= 12;
|
||
}
|
||
if (val <= 6) {
|
||
return card.number >= 13;
|
||
}
|
||
return false;
|
||
});
|
||
player
|
||
.chooseTarget(get.prompt2("fenglve"), function (card, player, target) {
|
||
return player.canCompare(target);
|
||
})
|
||
.set("ai", function (target) {
|
||
if (!_status.event.goon) return 0;
|
||
return (-get.attitude(player, target) * (1 + target.countCards("e"))) / (1 + target.countCards("j"));
|
||
})
|
||
.set("goon", goon);
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("fenglve", target);
|
||
player.chooseToCompare(target);
|
||
} else {
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
if (result.bool) {
|
||
var num = 0;
|
||
if (target.countCards("h")) num++;
|
||
if (target.countCards("e")) num++;
|
||
if (target.countCards("j")) num++;
|
||
if (num) {
|
||
event.gainner = player;
|
||
event.giver = target;
|
||
target
|
||
.choosePlayerCard(target, num, "hej", true)
|
||
.set("filterButton", function (button) {
|
||
for (var i = 0; i < ui.selected.buttons.length; i++) {
|
||
if (get.position(button.link) == get.position(ui.selected.buttons[i].link)) return false;
|
||
}
|
||
return true;
|
||
})
|
||
.set("prompt", "选择交给" + get.translation(event.gainner) + "的牌");
|
||
} else event.finish();
|
||
} else {
|
||
if (player.countCards("he")) {
|
||
event.gainner = target;
|
||
event.giver = player;
|
||
player.choosePlayerCard(player, true, "he").set("prompt", "选择交给" + get.translation(event.gainner) + "的牌");
|
||
} else event.finish();
|
||
}
|
||
"step 3";
|
||
event.giver.give(result.links, event.gainner);
|
||
},
|
||
group: "fenglve2",
|
||
ai: {
|
||
expose: 0.25,
|
||
},
|
||
},
|
||
fenglve2: {
|
||
trigger: {
|
||
player: "chooseToCompareAfter",
|
||
target: "chooseToCompareAfter",
|
||
},
|
||
check: function (event, player) {
|
||
var card, target;
|
||
if (player == event.player) {
|
||
card = event.card1;
|
||
target = event.target;
|
||
} else {
|
||
card = event.card2;
|
||
target = event.player;
|
||
}
|
||
return get.attitude(player, target) * get.value(card, target, "raw") > 0;
|
||
},
|
||
filter: function (event, player) {
|
||
if (event.targets) return false;
|
||
var card, target;
|
||
if (player == event.player) {
|
||
card = event.card1;
|
||
target = event.target;
|
||
} else {
|
||
card = event.card2;
|
||
target = event.player;
|
||
}
|
||
return get.position(card, true) == "o";
|
||
},
|
||
prompt: function (event, player) {
|
||
var card, target;
|
||
if (player == event.player) {
|
||
card = event.card1;
|
||
target = event.target;
|
||
} else {
|
||
card = event.card2;
|
||
target = event.player;
|
||
}
|
||
return "是否发动【锋略】，令" + get.translation(target) + "获得" + get.translation(card) + "？";
|
||
},
|
||
logTarget: function (event, player) {
|
||
var target;
|
||
if (player == event.player) {
|
||
target = event.target;
|
||
} else {
|
||
target = event.player;
|
||
}
|
||
return target;
|
||
},
|
||
content: function () {
|
||
var card, target;
|
||
if (player == trigger.player) {
|
||
card = trigger.card1;
|
||
target = trigger.target;
|
||
} else {
|
||
card = trigger.card2;
|
||
target = trigger.player;
|
||
}
|
||
target.gain(card, "gain2", "log");
|
||
},
|
||
},
|
||
mouzhi: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
return player.countCards("h") > 0;
|
||
},
|
||
filterCard: true,
|
||
filterTarget: function (card, player, target) {
|
||
if (target.storage.mouzhi2 && target.storage.mouzhi2.includes(player)) return false;
|
||
return target != player;
|
||
},
|
||
delay: 0,
|
||
lose: false,
|
||
discard: false,
|
||
check: function (card) {
|
||
if (card.name == "du") return 20;
|
||
var player = _status.event.player;
|
||
var useval = player.getUseValue(card);
|
||
var maxval = 0;
|
||
game.countPlayer(function (current) {
|
||
if (current != player && !current.hasSkillTag("nogain") && get.attitude(player, current) > 0) {
|
||
var temp = current.getUseValue(card);
|
||
if (temp > maxval) maxval = temp;
|
||
}
|
||
});
|
||
if (maxval > 0 && get.tag(card, "damage")) return 15;
|
||
if (maxval > useval) return 10;
|
||
if (player.needsToDiscard()) return 1 / Math.max(0.1, get.value(card));
|
||
return -1;
|
||
},
|
||
content: function () {
|
||
player.give(cards, target);
|
||
target.addTempSkill("mouzhi2", { player: "phaseEnd" });
|
||
target.storage.mouzhi2.add(player);
|
||
target.storage.mouzhi2.sortBySeat(target);
|
||
target.markSkill("mouzhi2");
|
||
},
|
||
ai: {
|
||
order: 10,
|
||
result: {
|
||
target: function (player, target) {
|
||
if (ui.selected.cards.length) {
|
||
var card = ui.selected.cards[0];
|
||
if (card.name == "du") return target.hasSkill("lucia_duqu") ? 1 : -1;
|
||
var t = target.getUseValue(card);
|
||
var p = player.getUseValue(card);
|
||
if (t > p) return 2;
|
||
if (t > 0) return 1.5;
|
||
if (player.needsToDiscard()) return 1;
|
||
return 0;
|
||
}
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
mouzhi2: {
|
||
init: function (player, skill) {
|
||
if (!player.storage[skill]) player.storage[skill] = [];
|
||
},
|
||
onremove: true,
|
||
trigger: { source: "damageSource" },
|
||
forced: true,
|
||
intro: {
|
||
content: "出牌阶段内第一次对一名其他角色造成伤害时，$摸一张牌",
|
||
},
|
||
filter: function (event, player) {
|
||
var evt2 = event.getParent("phaseUse");
|
||
if (!evt2 || evt2.player != player) return false;
|
||
var history = event.player.getHistory("damage", function (evt) {
|
||
return evt.source == player && evt.getParent("phaseUse") == evt2;
|
||
});
|
||
return history[0] == event;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
game.asyncDraw(player.storage.mouzhi2);
|
||
"step 1";
|
||
game.delay();
|
||
},
|
||
},
|
||
yuanlve: {
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
audio: 2,
|
||
filter: function (event, player) {
|
||
return player.countCards("h", function (card) {
|
||
return get.type(card) != "equip";
|
||
});
|
||
},
|
||
filterCard: function (card) {
|
||
return get.type(card) != "equip";
|
||
},
|
||
filterTarget: lib.filter.notMe,
|
||
delay: false,
|
||
discard: false,
|
||
lose: false,
|
||
check: function (card) {
|
||
if (card.name == "du") return 20;
|
||
var player = _status.event.player;
|
||
var useval = player.getUseValue(card);
|
||
var maxval = 0;
|
||
game.countPlayer(function (current) {
|
||
if (current != player && !current.hasSkillTag("nogain") && get.attitude(player, current) > 0) {
|
||
var temp = current.getUseValue(card);
|
||
if (temp > maxval) maxval = temp;
|
||
}
|
||
});
|
||
if (maxval > useval) return 15;
|
||
if (maxval > 0) return 10;
|
||
if (player.needsToDiscard()) return 1 / Math.max(0.1, get.value(card));
|
||
return -1;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.give(cards, target);
|
||
"step 1";
|
||
target.chooseUseTarget(cards[0]);
|
||
"step 2";
|
||
if (result.bool) player.draw();
|
||
},
|
||
ai: {
|
||
order: 10,
|
||
result: {
|
||
target: function (player, target) {
|
||
if (ui.selected.cards.length) {
|
||
var card = ui.selected.cards[0];
|
||
if (card.name == "du") return target.hasSkill("lucia_duqu") ? 1 : -1;
|
||
var t = target.getUseValue(card);
|
||
var p = player.getUseValue(card);
|
||
if (t > p) return 2;
|
||
if (t > 0) return 1.5;
|
||
if (player.needsToDiscard()) return 1;
|
||
return 0;
|
||
}
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//吕旷吕翔和淳于琼和官渡哔哔机
|
||
spshicai: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
position: "he",
|
||
filter: function (event, player) {
|
||
return !player.storage.spshicai2 || !player.getCards("h").includes(player.storage.spshicai2);
|
||
},
|
||
filterCard: true,
|
||
prompt: function () {
|
||
var str = "弃置一张牌，然后获得";
|
||
if (get.itemtype(_status.pileTop) == "card") str += get.translation(_status.pileTop);
|
||
else str += "牌堆顶的一张牌";
|
||
return str;
|
||
},
|
||
check: function (card) {
|
||
var player = _status.event.player;
|
||
var cardx = _status.pileTop;
|
||
if (get.itemtype(cardx) != "card") return 0;
|
||
var val = player.getUseValue(cardx, null, true);
|
||
if (!val) return 0;
|
||
var val2 = player.getUseValue(card, null, true);
|
||
return (val - val2) / Math.max(0.1, get.value(card));
|
||
},
|
||
content: function () {
|
||
var card = get.cards()[0];
|
||
player.storage.spshicai2 = card;
|
||
player.gain(card, "draw");
|
||
game.log(player, "获得了牌堆顶的一张牌");
|
||
},
|
||
group: "spshicai_mark",
|
||
ai: {
|
||
order: 1,
|
||
result: { player: 1 },
|
||
},
|
||
},
|
||
spshicai_mark: {
|
||
trigger: { player: "phaseUseBegin" },
|
||
silent: true,
|
||
firstDo: true,
|
||
content: function () {
|
||
player.addTempSkill("spshicai2", "phaseUseEnd");
|
||
},
|
||
},
|
||
spshicai2: {
|
||
onremove: true,
|
||
mark: true,
|
||
intro: {
|
||
mark: function (dialog, content, player) {
|
||
if (player != game.me) return get.translation(player) + "观看牌堆中...";
|
||
if (get.itemtype(_status.pileTop) != "card") return "牌堆顶无牌";
|
||
dialog.add([_status.pileTop]);
|
||
},
|
||
},
|
||
},
|
||
spfushi: {
|
||
group: ["zezhu", "chenggong"],
|
||
derivation: ["zezhu", "chenggong"],
|
||
locked: true,
|
||
},
|
||
zezhu: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filter: function (event, player) {
|
||
var enemy = 0;
|
||
var friend = 0;
|
||
var zhu = 0;
|
||
for (var i of game.players) {
|
||
if (i.isEnemyOf(player)) enemy++;
|
||
else friend++;
|
||
if (i != player && i.isZhu) zhu++;
|
||
}
|
||
return zhu > 0 && enemy < friend;
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && target.isZhu;
|
||
},
|
||
selectTarget: -1,
|
||
multiline: true,
|
||
multitarget: true,
|
||
content: function () {
|
||
"step 0";
|
||
event.targets.sortBySeat();
|
||
event.targets2 = event.targets.slice(0);
|
||
"step 1";
|
||
var target = event.targets2.shift();
|
||
if (target.countGainableCards(player, "he") > 0) player.gainPlayerCard(target, "he", true);
|
||
else player.draw();
|
||
if (event.targets2.length) event.redo();
|
||
"step 2";
|
||
if (player.countCards("he") >= targets.length) {
|
||
player.chooseCard("he", true, "依次选择" + get.cnNumber(targets.length) + "张牌，分别交给" + get.translation(targets), targets.length).set("ai", function (card) {
|
||
var target = _status.event.getParent().targets[ui.selected.cards.length];
|
||
var player = _status.event.player;
|
||
return get.attitude(player, target) * get.value(card, target);
|
||
});
|
||
} else event.finish();
|
||
"step 3";
|
||
var list = [];
|
||
for (var i = 0; i < targets.length; i++) {
|
||
list.push([targets[i], result.cards[i]]);
|
||
}
|
||
game.loseAsync({
|
||
gain_list: list,
|
||
giver: player,
|
||
player: player,
|
||
cards: result.cards,
|
||
animate: "giveAuto",
|
||
}).setContent("gaincardMultiple");
|
||
},
|
||
ai: {
|
||
order: 6,
|
||
result: { player: 1 },
|
||
},
|
||
},
|
||
chenggong: {
|
||
audio: 2,
|
||
trigger: { global: "useCardToPlayered" },
|
||
filter: function (event, player) {
|
||
if (!(event.isFirstTarget && event.targets && event.targets.length > 1 && event.player.isIn())) return false;
|
||
var enemy = 0;
|
||
var friend = 0;
|
||
for (var i of game.players) {
|
||
if (i.isEnemyOf(player)) enemy++;
|
||
else friend++;
|
||
}
|
||
return enemy > friend;
|
||
},
|
||
check: function (event, player) {
|
||
return get.attitude(player, event.player) > 0;
|
||
},
|
||
logTarget: "player",
|
||
content: function () {
|
||
trigger.player.draw();
|
||
},
|
||
},
|
||
cangchu: {
|
||
trigger: {
|
||
global: "phaseBefore",
|
||
player: ["damageEnd", "enterGame"],
|
||
},
|
||
audio: 2,
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (event.name != "damage") return event.name != "phase" || game.phaseNumber == 0;
|
||
return event.hasNature("fire") && player.countMark("cangchu") > 0;
|
||
},
|
||
content: function () {
|
||
if (trigger.name != "damage") player.addMark("cangchu", 3);
|
||
else {
|
||
player.removeMark("cangchu", Math.min(trigger.num, player.countMark("cangchu")));
|
||
if (!player.hasMark("cangchu")) event.trigger("cangchuAwaken");
|
||
}
|
||
},
|
||
marktext: "粮",
|
||
intro: {
|
||
name2: "粮",
|
||
content: "mark",
|
||
},
|
||
ai: {
|
||
threaten: function (player, target) {
|
||
return 1 + target.countMark("cangchu") / 2;
|
||
},
|
||
effect: {
|
||
target: function (card, player, target, current) {
|
||
if (target.hasMark("cangchu")) {
|
||
if (card.name == "sha") {
|
||
if (lib.skill.global.includes("huoshaowuchao") || game.hasNature(card, "fire") || player.hasSkill("zhuque_skill")) return 2;
|
||
}
|
||
if (get.tag(card, "fireDamage") && current < 0) return 2;
|
||
}
|
||
},
|
||
},
|
||
combo: "liangying",
|
||
},
|
||
},
|
||
sushou: {
|
||
audio: 2,
|
||
trigger: { player: "phaseDiscardBegin" },
|
||
frequent: true,
|
||
async content(event, trigger, player) {
|
||
await player.draw(1 + player.countMark("cangchu"));
|
||
const num = Math.min(
|
||
player.countCards("h"),
|
||
player.countCards("he"),
|
||
game.countPlayer(target => target != player && target.isFriendOf(player))
|
||
);
|
||
if (num) {
|
||
let list = [];
|
||
if (_status.connectMode) game.broadcastAll(() => (_status.noclearcountdown = true));
|
||
while (num - list.length > 0) {
|
||
const {
|
||
result: { bool, targets, cards },
|
||
} = await player
|
||
.chooseCardTarget({
|
||
prompt: "宿守：你可以交给友方角色各一张牌",
|
||
position: "he",
|
||
animate: false,
|
||
filterCard(card, player) {
|
||
return !get.event("list").some(list => list[1] == card);
|
||
},
|
||
filterTarget(card, player, target) {
|
||
return target != player && target.isFriendOf(player) && !get.event("list").some(list => list[0] == target);
|
||
},
|
||
ai1(card) {
|
||
if (card.name == "shan") return 1;
|
||
return Math.random();
|
||
},
|
||
ai2(target) {
|
||
return get.attitude(get.event("player"), target);
|
||
},
|
||
})
|
||
.set("list", list);
|
||
if (bool) {
|
||
list.push([targets[0], cards[0]]);
|
||
player.addGaintag(cards, "olsujian_given");
|
||
} else break;
|
||
}
|
||
if (_status.connectMode) {
|
||
game.broadcastAll(() => {
|
||
delete _status.noclearcountdown;
|
||
game.stopCountChoose();
|
||
});
|
||
}
|
||
if (list.length) {
|
||
await game
|
||
.loseAsync({
|
||
gain_list: list,
|
||
player: player,
|
||
cards: list.slice().map(list => list[1]),
|
||
giver: player,
|
||
animate: "giveAuto",
|
||
})
|
||
.setContent("gaincardMultiple");
|
||
}
|
||
}
|
||
},
|
||
},
|
||
liangying: {
|
||
trigger: {
|
||
global: "phaseDrawBegin2",
|
||
player: "cangchuAwaken",
|
||
},
|
||
forced: true,
|
||
audio: 1,
|
||
logTarget: function (event, player) {
|
||
if (event.name == "phaseDraw") return event.player;
|
||
return game.filterPlayer(function (current) {
|
||
return current.isEnemyOf(player);
|
||
});
|
||
},
|
||
filter: function (event, player) {
|
||
if (event.name == "cangchu") return true;
|
||
return player.hasMark("cangchu") && !event.numFixed && event.player.isFriendOf(player);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (trigger.name == "cangchu") {
|
||
player.loseMaxHp();
|
||
var list = game.filterPlayer(function (current) {
|
||
return current.isEnemyOf(player);
|
||
});
|
||
if (list.length) {
|
||
game.asyncDraw(list, 2);
|
||
}
|
||
} else {
|
||
trigger.num++;
|
||
event.finish();
|
||
}
|
||
"step 1";
|
||
game.delay();
|
||
},
|
||
ai: {
|
||
combo: "cangchu",
|
||
},
|
||
},
|
||
liehou: {
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
audio: 2,
|
||
filterTarget: function (card, player, target) {
|
||
return player.inRange(target) && target.countCards("h");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
target.chooseCard("h", true, "交给" + get.translation(player) + "一张牌");
|
||
"step 1";
|
||
if (result.bool) {
|
||
target.give(result.cards, player);
|
||
} else event.finish();
|
||
"step 2";
|
||
if (
|
||
player.countCards("h") &&
|
||
game.hasPlayer(function (current) {
|
||
return current != target && player.inRange(current);
|
||
})
|
||
) {
|
||
player.chooseCardTarget({
|
||
position: "h",
|
||
filterCard: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target != _status.event.getParent().target && player.inRange(target);
|
||
},
|
||
forced: true,
|
||
prompt: "将一张手牌交给一名攻击范围内的其他角色",
|
||
ai1: function (card) {
|
||
var player = _status.event.player;
|
||
if (get.name(card) == "du") return 20;
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return current != _status.event.getParent().target && player.inRange(current) && get.attitude(player, current) > 0 && current.getUseValue(card) > player.getUseValue(card) && current.getUseValue(card) > player.getUseValue(card);
|
||
})
|
||
)
|
||
return 12;
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return current != player && get.attitude(player, current) > 0;
|
||
})
|
||
) {
|
||
if (card.name == "wuxie") return 11;
|
||
if (card.name == "shan" && player.countCards("h", "shan") > 1) return 9;
|
||
}
|
||
return 6 / Math.max(1, get.value(card));
|
||
},
|
||
ai2: function (target) {
|
||
var player = _status.event.player;
|
||
var card = ui.selected.cards[0];
|
||
var att = get.attitude(player, target);
|
||
if (card.name == "du") return -6 * att;
|
||
if (att > 0) {
|
||
if (get.position(card) == "h" && target.getUseValue(card) > player.getUseValue(card)) return 4 * att;
|
||
if (get.value(card, target) > get.value(card, player)) return 2 * att;
|
||
return 1.2 * att;
|
||
}
|
||
return (-att * Math.min(4, target.countCards("he"))) / 6;
|
||
},
|
||
});
|
||
} else event.finish();
|
||
"step 3";
|
||
if (result.bool) player.give(result.cards, result.targets[0]);
|
||
},
|
||
ai: {
|
||
order: 6,
|
||
result: {
|
||
target: -1,
|
||
},
|
||
},
|
||
},
|
||
qigong: {
|
||
trigger: { player: "shaMiss" },
|
||
direct: true,
|
||
audio: 2,
|
||
filter: function (event, player) {
|
||
return (
|
||
event.target.isIn() &&
|
||
game.hasPlayer(function (current) {
|
||
return current != event.target && current.canUse("sha", event.target, false);
|
||
})
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt("qigong"), "令一名角色可再对" + get.translation(trigger.target) + "使用一张【杀】", function (card, player, target) {
|
||
var source = _status.event.getTrigger().target;
|
||
return target != source && target.canUse("sha", source, false);
|
||
})
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player,
|
||
card = { name: "sha" },
|
||
source = _status.event.getTrigger().target;
|
||
if (target.hasSha()) {
|
||
var eff1 = get.effect(source, card, target, target);
|
||
if (eff1 > 0) return get.effect(source, card, target, player);
|
||
}
|
||
return target != player ? Math.random() * get.attitude(player, target) : 0;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("qigong", target);
|
||
target.addTempSkill("qigong_ai", "chooseToUseEnd");
|
||
target
|
||
.chooseToUse(
|
||
"是否再对" + get.translation(trigger.target) + "使用一张【杀】？",
|
||
function (card, player, event) {
|
||
if (get.name(card) != "sha") return false;
|
||
return lib.filter.filterCard.apply(this, arguments);
|
||
},
|
||
trigger.target,
|
||
-1
|
||
)
|
||
.set("addCount", false)
|
||
.set("oncard", function () {
|
||
_status.event.directHit.addArray(game.players);
|
||
});
|
||
}
|
||
},
|
||
subSkill: {
|
||
ai: {
|
||
ai: {
|
||
directHit_ai: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
return arg.card && arg.card.name == "sha";
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//和沙摩柯一起上线的新服三将
|
||
spjiedao: {
|
||
audio: 2,
|
||
trigger: {
|
||
source: "damageBegin1",
|
||
},
|
||
filter: function (event, player) {
|
||
return player.isDamaged() && !player.getHistory("sourceDamage").length;
|
||
},
|
||
logTarget: "player",
|
||
direct: true,
|
||
check: function (trigger, player) {
|
||
if (get.attitude(player, trigger.player) >= -1) return false;
|
||
return !trigger.player.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: trigger.card,
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var num = player.getDamagedHp();
|
||
var map = {};
|
||
var list = [];
|
||
for (var i = 1; i <= num; i++) {
|
||
var cn = get.cnNumber(i, true);
|
||
map[cn] = i;
|
||
list.push(cn);
|
||
}
|
||
event.map = map;
|
||
player
|
||
.chooseControl(list, "cancel2", function () {
|
||
if (!lib.skill.spjiedao.check(_status.event.getTrigger(), player)) return "cancel2";
|
||
return get.cnNumber(_status.event.goon, true);
|
||
})
|
||
.set("prompt", get.prompt2("spjiedao", trigger.player))
|
||
.set("goon", num);
|
||
"step 1";
|
||
if (result.control == "cancel2") return;
|
||
player.logSkill("spjiedao", trigger.player);
|
||
var num = event.map[result.control] || 1;
|
||
trigger.num += num;
|
||
var next = game.createEvent("spjiedao_after", null, trigger.getParent());
|
||
next.player = player;
|
||
next.target = trigger.player;
|
||
next.num = num;
|
||
next.setContent(function () {
|
||
if (target.isIn()) player.chooseToDiscard(num, true, "he");
|
||
});
|
||
},
|
||
},
|
||
biaozhao: {
|
||
audio: 2,
|
||
intro: {
|
||
content: "expansion",
|
||
markcount: "expansion",
|
||
},
|
||
onremove: function (player, skill) {
|
||
var cards = player.getExpansions(skill);
|
||
if (cards.length) player.loseToDiscardpile(cards);
|
||
},
|
||
trigger: {
|
||
player: "phaseJieshuBegin",
|
||
},
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("he") > 0 && !player.getExpansions("biaozhao").length;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseCard("he", get.prompt("biaozhao"), "将一张牌置于武将牌上作为“表”").ai = function (card) {
|
||
return 6 - get.value(card);
|
||
};
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.logSkill("biaozhao");
|
||
player.addToExpansion(result.cards, player, "give").gaintag.add("biaozhao");
|
||
}
|
||
},
|
||
ai: {
|
||
notemp: true,
|
||
},
|
||
group: ["biaozhao2", "biaozhao3"],
|
||
},
|
||
biaozhao2: {
|
||
trigger: {
|
||
global: ["loseAsyncAfter", "loseAfter", "cardsDiscardAfter"],
|
||
},
|
||
forced: true,
|
||
audio: "biaozhao",
|
||
filter: function (event, player) {
|
||
if (event.name == "loseAsyncAfter" && event.type != "discard") return false;
|
||
if (event.name == "lose" && (event.getlx === false || event.position != ui.discardPile)) return false;
|
||
var cards = player.getExpansions("biaozhao");
|
||
if (!cards.length) return false;
|
||
var suit = get.suit(cards[0]);
|
||
var num = get.number(cards[0]);
|
||
var cards = event.getd();
|
||
for (var card of cards) {
|
||
if (get.suit(card) == suit && get.number(card) == num) return true;
|
||
}
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var card = player.getExpansions("biaozhao")[0];
|
||
if (trigger.getParent().name == "discard") {
|
||
trigger.player.gain(card, player, "give", "bySelf");
|
||
} else {
|
||
player.loseToDiscardpile(card);
|
||
}
|
||
"step 1";
|
||
player.loseHp();
|
||
},
|
||
},
|
||
biaozhao3: {
|
||
trigger: {
|
||
player: "phaseZhunbeiBegin",
|
||
},
|
||
forced: true,
|
||
charlotte: true,
|
||
audio: "biaozhao",
|
||
filter: function (event, player) {
|
||
return player.getExpansions("biaozhao").length > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var card = player.getExpansions("biaozhao")[0];
|
||
player.loseToDiscardpile(card);
|
||
"step 1";
|
||
event.num = 0;
|
||
game.countPlayer(function (current) {
|
||
if (current.countCards("h") > event.num) event.num = current.countCards("h");
|
||
});
|
||
player.chooseTarget("是否令一名角色将手牌摸至" + event.num + "张并回复1点体力？").ai = function (target) {
|
||
var num = Math.min(event.num - target.countCards("h"), 5);
|
||
if (target.isDamaged()) num++;
|
||
return num * get.attitude(_status.event.player, target);
|
||
};
|
||
"step 2";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.line(target, "green");
|
||
var draw = Math.min(num - target.countCards("h"), 5);
|
||
if (draw) target.draw(draw);
|
||
target.recover();
|
||
}
|
||
},
|
||
},
|
||
yechou: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "die",
|
||
},
|
||
direct: true,
|
||
forceDie: true,
|
||
skillAnimation: true,
|
||
animationColor: "wood",
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt2("yechou"), function (card, player, target) {
|
||
return player != target && target.getDamagedHp() > 1;
|
||
})
|
||
.set("forceDie", true)
|
||
.set("ai", function (target) {
|
||
let att = get.attitude(_status.event.player, target);
|
||
if (att > 0) return 0;
|
||
att = Math.sqrt(0.01 - att);
|
||
return att * (get.distance(_status.currentPhase, target, "absolute") || game.players.length);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("yechou", target);
|
||
player.line(target, "green");
|
||
target.addTempSkill("yechou2", { player: "phaseZhunbeiBegin" });
|
||
}
|
||
},
|
||
ai: {
|
||
expose: 0.5,
|
||
maixie_defend: true,
|
||
},
|
||
},
|
||
yechou2: {
|
||
mark: true,
|
||
marktext: "仇",
|
||
intro: {
|
||
content: "每个回合结束时失去1点体力直到回合开始",
|
||
},
|
||
trigger: {
|
||
global: "phaseAfter",
|
||
},
|
||
forced: true,
|
||
content: function () {
|
||
player.loseHp();
|
||
},
|
||
},
|
||
yanjiao: {
|
||
audio: 2,
|
||
ai: {
|
||
order: 10,
|
||
result: {
|
||
player: 1,
|
||
target: 1.1,
|
||
},
|
||
},
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: function (card, player, target) {
|
||
return target != player;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var num = 4;
|
||
if (player.storage.xingshen) {
|
||
num += player.storage.xingshen;
|
||
player.storage.xingshen = 0;
|
||
player.unmarkSkill("xingshen");
|
||
}
|
||
if (player.storage.olxingshen) {
|
||
num += player.storage.olxingshen;
|
||
player.storage.olxingshen = 0;
|
||
player.unmarkSkill("olxingshen");
|
||
}
|
||
num = Math.min(10, num);
|
||
event.cards = get.cards(num);
|
||
game.cardsGotoOrdering(event.cards);
|
||
player.showCards(event.cards);
|
||
"step 1";
|
||
event.getedResult = lib.skill.yanjiao.getResult(cards);
|
||
if (!event.getedResult.length) {
|
||
player.addTempSkill("yanjiao2");
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
target.chooseControl("自动分配", "手动分配").set("prompt", "【严教】：是否让系统自动分配方案？").ai = function () {
|
||
return 0;
|
||
};
|
||
"step 3";
|
||
if (result.control == "手动分配") {
|
||
event.goto(8);
|
||
}
|
||
"step 4";
|
||
event.index = 0;
|
||
event.togain = event.getedResult[event.index];
|
||
target.showCards(event.togain[0], get.translation(target) + "分出的第一份牌");
|
||
"step 5";
|
||
target.showCards(event.togain[1], get.translation(target) + "分出的第二份牌");
|
||
"step 6";
|
||
target.chooseControl().set("choiceList", ["获得" + get.translation(event.togain[0]), "获得" + get.translation(event.togain[1])]).ai = function () {
|
||
return Math.random() < 0.5 ? 1 : 0;
|
||
};
|
||
"step 7";
|
||
var list = [
|
||
[target, event.togain[result.index]],
|
||
[player, event.togain[1 - result.index]],
|
||
];
|
||
game.loseAsync({
|
||
gain_list: list,
|
||
giver: target,
|
||
animate: "gain2",
|
||
}).setContent("gaincardMultiple");
|
||
if (event.togain[2].length > 1) player.addTempSkill("yanjiao2");
|
||
event.finish();
|
||
"step 8";
|
||
var next = target.chooseToMove("严教：分出点数相等的两组牌");
|
||
next.set("chooseTime", (cards.length * 4).toString());
|
||
next.set("list", [
|
||
[
|
||
"未分配",
|
||
cards,
|
||
function (list) {
|
||
var num = 0;
|
||
for (var i of list) num += i.number;
|
||
return "未分配（点数和" + num + "）";
|
||
},
|
||
],
|
||
[
|
||
"第一组",
|
||
[],
|
||
function (list) {
|
||
var num = 0;
|
||
for (var i of list) num += i.number;
|
||
return "第一组（点数和" + num + "）";
|
||
},
|
||
],
|
||
[
|
||
"第二组",
|
||
[],
|
||
function (list) {
|
||
var num = 0;
|
||
for (var i of list) num += i.number;
|
||
return "第二组（点数和" + num + "）";
|
||
},
|
||
],
|
||
]);
|
||
next.set("filterOk", function (moved) {
|
||
var num1 = 0;
|
||
for (var i of moved[1]) num1 += i.number;
|
||
if (num1 == 0) return false;
|
||
var num2 = 0;
|
||
for (var i of moved[2]) num2 += i.number;
|
||
return num1 == num2;
|
||
});
|
||
next.set("processAI", () => false);
|
||
"step 9";
|
||
if (result.bool) {
|
||
var moved = result.moved;
|
||
event.getedResult = [[moved[1], moved[2], moved[0]]];
|
||
event.goto(4);
|
||
} else {
|
||
player.addTempSkill("yanjiao2");
|
||
}
|
||
},
|
||
getResult: function (cards) {
|
||
var cl = cards.length;
|
||
var maxmium = Math.pow(3, cl);
|
||
var filter = function (list) {
|
||
if (!list[1].length || !list[0].length) return false;
|
||
var num1 = 0;
|
||
for (var i = 0; i < list[1].length; i++) {
|
||
num1 += list[1][i].number;
|
||
}
|
||
var num2 = 0;
|
||
for (var j = 0; j < list[0].length; j++) {
|
||
num2 += list[0][j].number;
|
||
}
|
||
return num1 == num2;
|
||
};
|
||
var results = [];
|
||
for (var i = 0; i < maxmium; i++) {
|
||
var result = [[], [], []];
|
||
for (var j = 0; j < cl; j++) {
|
||
result[Math.floor((i % Math.pow(3, j + 1)) / Math.pow(3, j))].push(cards[j]);
|
||
}
|
||
if (filter(result)) results.push(result);
|
||
}
|
||
var filterSame = function (list1, list2) {
|
||
if (list1[1].length == list2[0].length && list1[0].length == list2[1].length) {
|
||
for (var i = 0; i < list1[0].length; i++) {
|
||
if (!list2[1].includes(list1[0][i])) return false;
|
||
}
|
||
for (var i = 0; i < list1[1].length; i++) {
|
||
if (!list2[0].includes(list1[1][i])) return false;
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
};
|
||
for (var i = 0; i < results.length; i++) {
|
||
for (var j = i + 1; j < results.length; j++) {
|
||
if (filterSame(results[i], results[j])) results.splice(j--, 1);
|
||
}
|
||
}
|
||
results.sort(function (a, b) {
|
||
return a[2].length - b[2].length;
|
||
});
|
||
return results.slice(0, 50);
|
||
},
|
||
},
|
||
yanjiao2: {
|
||
marktext: "教",
|
||
mark: true,
|
||
intro: {
|
||
content: "本回合手牌上限-1",
|
||
},
|
||
mod: {
|
||
maxHandcard: function (player, num) {
|
||
return num - 1;
|
||
},
|
||
},
|
||
},
|
||
xingshen: {
|
||
audio: 2,
|
||
intro: {
|
||
content: "下一次发动【严教】时多展示#张牌",
|
||
},
|
||
trigger: {
|
||
player: "damageEnd",
|
||
},
|
||
frequent: true,
|
||
content: function () {
|
||
player.draw(player.isMinHandcard() ? 2 : 1);
|
||
if (!player.storage.xingshen) player.storage.xingshen = 0;
|
||
player.storage.xingshen += player.isMinHp() ? 2 : 1;
|
||
if (player.storage.xingshen > 4) player.storage.xingshen = 4;
|
||
player.markSkill("xingshen");
|
||
},
|
||
},
|
||
pingjian: {
|
||
initList: function () {
|
||
var list = [];
|
||
if (_status.connectMode) list = get.charactersOL();
|
||
else {
|
||
var list = [];
|
||
for (var i in lib.character) {
|
||
if (!lib.filter.characterDisabled2(i) && !lib.filter.characterDisabled(i)) list.push(i);
|
||
}
|
||
}
|
||
game.countPlayer2(function (current) {
|
||
list.remove(current.name);
|
||
list.remove(current.name1);
|
||
list.remove(current.name2);
|
||
});
|
||
_status.characterlist = list;
|
||
},
|
||
init: function (player) {
|
||
player.addSkill("pingjian_check");
|
||
if (!player.storage.pingjian_check) player.storage.pingjian_check = {};
|
||
},
|
||
audio: 2,
|
||
trigger: { player: ["damageEnd", "phaseJieshuBegin"] },
|
||
frequent: true,
|
||
content: function () {
|
||
"step 0";
|
||
if (!_status.characterlist) {
|
||
lib.skill.pingjian.initList();
|
||
}
|
||
var allList = _status.characterlist.slice(0);
|
||
game.countPlayer(function (current) {
|
||
if (current.name && lib.character[current.name] && current.name.indexOf("gz_shibing") != 0 && current.name.indexOf("gz_jun_") != 0) allList.add(current.name);
|
||
if (current.name1 && lib.character[current.name1] && current.name1.indexOf("gz_shibing") != 0 && current.name1.indexOf("gz_jun_") != 0) allList.add(current.name1);
|
||
if (current.name2 && lib.character[current.name2] && current.name2.indexOf("gz_shibing") != 0 && current.name2.indexOf("gz_jun_") != 0) allList.add(current.name2);
|
||
});
|
||
var list = [];
|
||
var skills = [];
|
||
var map = [];
|
||
allList.randomSort();
|
||
var name2 = event.triggername;
|
||
for (var i = 0; i < allList.length; i++) {
|
||
var name = allList[i];
|
||
if (name.indexOf("zuoci") != -1 || name.indexOf("xushao") != -1) continue;
|
||
var skills2 = lib.character[name][3];
|
||
for (var j = 0; j < skills2.length; j++) {
|
||
if (player.getStorage("pingjian").includes(skills2[j])) continue;
|
||
if (skills.includes(skills2[j])) {
|
||
list.add(name);
|
||
if (!map[name]) map[name] = [];
|
||
map[name].push(skills2[j]);
|
||
skills.add(skills2[j]);
|
||
continue;
|
||
}
|
||
var list2 = [skills2[j]];
|
||
game.expandSkills(list2);
|
||
for (var k = 0; k < list2.length; k++) {
|
||
var info = lib.skill[list2[k]];
|
||
if (get.is.zhuanhuanji(list2[k], player)) continue;
|
||
if (!info || !info.trigger || !info.trigger.player || info.silent || info.limited || info.juexingji || info.hiddenSkill || info.dutySkill || (info.zhuSkill && !player.isZhu2())) continue;
|
||
if (info.trigger.player == name2 || (Array.isArray(info.trigger.player) && info.trigger.player.includes(name2))) {
|
||
if (info.ai && (info.ai.combo || info.ai.notemp || info.ai.neg)) continue;
|
||
if (info.init) continue;
|
||
if (info.filter) {
|
||
try {
|
||
var bool = info.filter(trigger, player, name2);
|
||
if (!bool) continue;
|
||
} catch (e) {
|
||
continue;
|
||
}
|
||
}
|
||
list.add(name);
|
||
if (!map[name]) map[name] = [];
|
||
map[name].push(skills2[j]);
|
||
skills.add(skills2[j]);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (list.length > 2) break;
|
||
}
|
||
if (skills.length) {
|
||
event.list = list;
|
||
player.chooseControl(skills).set("dialog", ["评鉴：请选择尝试发动的技能", [list, "character"]]);
|
||
} else event.finish();
|
||
"step 1";
|
||
player.markAuto("pingjian", [result.control]);
|
||
player.addTempSkill(result.control);
|
||
player.storage.pingjian_check[result.control] = trigger.name == "damage" ? trigger : "phaseJieshu";
|
||
var name = event.list.find(name => lib.character[name][3].includes(result.control));
|
||
// if(name) lib.skill.rehuashen.createAudio(name,result.control,'xushao');
|
||
if (name) game.broadcastAll((player, name) => player.tempname.add(name), player, name);
|
||
},
|
||
group: "pingjian_use",
|
||
phaseUse_special: [],
|
||
ai: { threaten: 5 },
|
||
},
|
||
pingjian_use: {
|
||
audio: "pingjian",
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
prompt: () => lib.translate.pingjian_info,
|
||
content: function () {
|
||
"step 0";
|
||
var list = [];
|
||
var skills = [];
|
||
var map = [];
|
||
var evt = event.getParent(2);
|
||
if (!_status.characterlist) {
|
||
lib.skill.pingjian.initList();
|
||
}
|
||
var allList = _status.characterlist.slice(0);
|
||
game.countPlayer(function (current) {
|
||
if (current.name && lib.character[current.name] && current.name.indexOf("gz_shibing") != 0 && current.name.indexOf("gz_jun_") != 0) allList.add(current.name);
|
||
if (current.name1 && lib.character[current.name1] && current.name1.indexOf("gz_shibing") != 0 && current.name1.indexOf("gz_jun_") != 0) allList.add(current.name1);
|
||
if (current.name2 && lib.character[current.name2] && current.name2.indexOf("gz_shibing") != 0 && current.name2.indexOf("gz_jun_") != 0) allList.add(current.name2);
|
||
});
|
||
allList.randomSort();
|
||
for (var i = 0; i < allList.length; i++) {
|
||
var name = allList[i];
|
||
if (name.indexOf("zuoci") != -1 || name.indexOf("xushao") != -1) continue;
|
||
var skills2 = lib.character[name][3];
|
||
for (var j = 0; j < skills2.length; j++) {
|
||
if (player.getStorage("pingjian").includes(skills2[j])) continue;
|
||
if (get.is.locked(skills2[j], player)) continue;
|
||
var info = lib.translate[skills2[j] + "_info"];
|
||
if (skills.includes(skills2[j]) || (info && info.indexOf("当你于出牌阶段") != -1 && info.indexOf("当你于出牌阶段外") == -1)) {
|
||
list.add(name);
|
||
if (!map[name]) map[name] = [];
|
||
map[name].push(skills2[j]);
|
||
skills.add(skills2[j]);
|
||
continue;
|
||
}
|
||
var list2 = [skills2[j]];
|
||
game.expandSkills(list2);
|
||
for (var k = 0; k < list2.length; k++) {
|
||
var info = lib.skill[list2[k]];
|
||
if (get.is.zhuanhuanji(list2[k], player)) continue;
|
||
if (!info || !info.enable || info.charlotte || info.limited || info.juexingji || info.hiddenSkill || info.dutySkill || (info.zhuSkill && !player.isZhu2())) continue;
|
||
if (info.enable == "phaseUse" || (Array.isArray(info.enable) && info.enable.includes("phaseUse")) || info.enable == "chooseToUse" || (Array.isArray(info.enable) && info.enable.includes("chooseToUse"))) {
|
||
if (info.ai && (info.ai.combo || info.ai.notemp || info.ai.neg)) continue;
|
||
if (info.init || info.onChooseToUse) continue;
|
||
if (info.filter) {
|
||
try {
|
||
var bool = info.filter(evt, player);
|
||
if (!bool) continue;
|
||
} catch (e) {
|
||
continue;
|
||
}
|
||
} else if (info.viewAs && typeof info.viewAs != "function") {
|
||
try {
|
||
if (evt.filterCard && !evt.filterCard(info.viewAs, player, evt)) continue;
|
||
if (info.viewAsFilter && info.viewAsFilter(player) == false) continue;
|
||
} catch (e) {
|
||
continue;
|
||
}
|
||
}
|
||
list.add(name);
|
||
if (!map[name]) map[name] = [];
|
||
map[name].push(skills2[j]);
|
||
skills.add(skills2[j]);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (list.length > 2) break;
|
||
}
|
||
if (skills.length) {
|
||
event.list = list;
|
||
player.chooseControl(skills).set("dialog", ["评鉴：请选择尝试发动的技能", [list, "character"]]);
|
||
} else event.finish();
|
||
"step 1";
|
||
player.markAuto("pingjian", [result.control]);
|
||
player.addTempSkill(result.control);
|
||
player.storage.pingjian_check[result.control] = "phaseUse";
|
||
var name = event.list.find(name => lib.character[name][3].includes(result.control));
|
||
// if(name) lib.skill.rehuashen.createAudio(name,result.control,'xushao');
|
||
if (name) game.broadcastAll((player, name) => player.tempname.add(name), player, name);
|
||
},
|
||
ai: { order: 12, result: { player: 1 } },
|
||
},
|
||
pingjian_check: {
|
||
charlotte: true,
|
||
trigger: { player: ["useSkill", "logSkillBegin"] },
|
||
filter: function (event, player) {
|
||
var info = get.info(event.skill);
|
||
if (info && info.charlotte) return false;
|
||
var skill = event.sourceSkill || event.skill;
|
||
return player.storage.pingjian_check[skill];
|
||
},
|
||
direct: true,
|
||
firstDo: true,
|
||
priority: Infinity,
|
||
content: function () {
|
||
var skill = trigger.sourceSkill || trigger.skill;
|
||
player.removeSkill(skill);
|
||
const names = player.tempname && player.tempname.filter(i => lib.character[i][3].includes(skill));
|
||
if (names) game.broadcastAll((player, names) => player.tempname.removeArray(names), player, names);
|
||
delete player.storage.pingjian_check[skill];
|
||
},
|
||
group: "pingjian_check2",
|
||
},
|
||
pingjian_check2: {
|
||
charlotte: true,
|
||
trigger: { player: ["phaseUseEnd", "damageEnd", "phaseJieshuBegin"] },
|
||
filter: function (event, player) {
|
||
return Object.keys(player.storage.pingjian_check).find(function (skill) {
|
||
if (event.name != "damage") return player.storage.pingjian_check[skill] == event.name;
|
||
return player.storage.pingjian_check[skill] == event;
|
||
});
|
||
},
|
||
direct: true,
|
||
lastDo: true,
|
||
priority: -Infinity,
|
||
content: function () {
|
||
var skills = Object.keys(player.storage.pingjian_check).filter(function (skill) {
|
||
if (trigger.name != "damage") return player.storage.pingjian_check[skill] == trigger.name;
|
||
return player.storage.pingjian_check[skill] == trigger;
|
||
});
|
||
player.removeSkill(skills);
|
||
const names = player.tempname && player.tempname.filter(i => skills.some(skill => lib.character[i][3].includes(skill)));
|
||
if (names) game.broadcastAll((player, names) => player.tempname.removeArray(names), player, names);
|
||
for (var skill of skills) delete player.storage.pingjian_check[skill];
|
||
},
|
||
},
|
||
//上兵伐谋
|
||
//伊籍在标包 不会移动
|
||
songshu: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
filter: function (event, player) {
|
||
return !player.hasSkill("songshu_reflectionblue", null, null, false) && player.countCards("h") > 0;
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && player.canCompare(target);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseToCompare(target).set("small", get.attitude(player, target) > 0);
|
||
"step 1";
|
||
if (!result.bool) {
|
||
player.draw(2, "nodelay");
|
||
target.draw(2);
|
||
player.addTempSkill("songshu_reflectionblue", "phaseUseAfter");
|
||
} else {
|
||
target.addTempSkill("songshu_ai");
|
||
}
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 1,
|
||
},
|
||
expose: 0.2,
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.hasSkill("songshu_ai", null, null, false)) return 0;
|
||
var maxnum = 0;
|
||
var cards2 = target.getCards("h");
|
||
for (var 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;
|
||
var cards = player.getCards("h");
|
||
for (var i = 0; i < cards.length; i++) {
|
||
if (get.number(cards[i]) < maxnum) return 1;
|
||
}
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
songshu_ai: { charlotte: true },
|
||
songshu_reflectionblue: { charlotte: true },
|
||
sibian: {
|
||
audio: 2,
|
||
trigger: { player: "phaseDrawBegin1" },
|
||
filter: function (event, player) {
|
||
return !event.numFixed;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
trigger.changeToZero();
|
||
event.cards = get.cards(4);
|
||
game.cardsGotoOrdering(event.cards);
|
||
player.showCards(event.cards);
|
||
"step 1";
|
||
cards.sort(function (a, b) {
|
||
return b.number - a.number;
|
||
});
|
||
var gains = [];
|
||
var mx = [cards[0].number, cards[3].number];
|
||
for (var i = 0; i < cards.length; i++) {
|
||
if (mx.includes(cards[i].number)) gains.addArray(cards.splice(i--, 1));
|
||
}
|
||
player.gain(gains, "gain2");
|
||
if (cards.length > 0)
|
||
player
|
||
.chooseTarget("是否令一名手牌数最少的角色获得" + get.translation(cards), function (card, player, target) {
|
||
return target.isMinHandcard();
|
||
})
|
||
.set("ai", function (target) {
|
||
return get.attitude(_status.event.player, target);
|
||
});
|
||
else event.finish();
|
||
"step 2";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.line(target);
|
||
player.addExpose(0.2);
|
||
target.gain(cards, "gain2");
|
||
}
|
||
},
|
||
},
|
||
lslixun: {
|
||
audio: 2,
|
||
forced: true,
|
||
trigger: { player: "damageBegin4" },
|
||
marktext: "珠",
|
||
intro: {
|
||
name2: "珠",
|
||
content: "共有#个“珠”",
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
player.addMark("lslixun", trigger.num);
|
||
},
|
||
group: "lslixun_fate",
|
||
},
|
||
lslixun_fate: {
|
||
audio: "lslixun",
|
||
trigger: { player: "phaseUseBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return player.countMark("lslixun") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.forceDie = true;
|
||
_status.lslixun = player.countMark("lslixun");
|
||
player.judge(function (card) {
|
||
if (get.number(card) < _status.lslixun) return -_status.lslixun;
|
||
return 1;
|
||
}).judge2 = function (result) {
|
||
return result.bool ? true : false;
|
||
};
|
||
"step 1";
|
||
delete _status.lslixun;
|
||
if (!result.bool) {
|
||
player.chooseToDiscard([1, player.countMark("lslixun")], "h").ai = lib.skill.qiangxi.check;
|
||
} else event.finish();
|
||
"step 2";
|
||
var num = player.countMark("lslixun");
|
||
if (result.cards && result.cards.length) num -= result.cards.length;
|
||
if (num) player.loseHp(num);
|
||
},
|
||
},
|
||
lskuizhu: {
|
||
audio: 2,
|
||
trigger: { player: "phaseUseEnd" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return player.isMaxHp(true) == false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseTarget(get.prompt2("lskuizhu"), function (card, player, target) {
|
||
return target != player && target.isMaxHp();
|
||
}).ai = function (target) {
|
||
var player = _status.event.player;
|
||
var ts = Math.min(5, target.countCards("h"));
|
||
var delta = ts - player.countCards("h");
|
||
if (delta <= 0) return 0;
|
||
if (get.attitude(player, target) < 1) return false;
|
||
return target.countCards("he", function (card) {
|
||
return lib.skill.zhiheng.check(card) > 0;
|
||
}) > 1
|
||
? delta
|
||
: 0;
|
||
};
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("lskuizhu", target);
|
||
player.drawTo(Math.min(5, target.countCards("h")));
|
||
} else event.finish();
|
||
"step 2";
|
||
if (!player.countCards("h")) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
target.viewHandcards(player);
|
||
"step 3";
|
||
if (!target.countCards("h")) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
target.chooseToDiscard(true, "h", [1, player.countCards("h")], "弃置至多" + get.cnNumber(player.countCards("h")) + "张手牌，并获得" + get.translation(player) + "等量的手牌").ai = function (card) {
|
||
if (ui.selected.cards.length > 1) return -1;
|
||
return lib.skill.zhiheng.check.apply(this, arguments);
|
||
};
|
||
"step 4";
|
||
if (result.bool && result.cards && result.cards.length && player.countGainableCards(target, "h") > 0) {
|
||
target.gainPlayerCard(player, "h", true, result.cards.length).visible = true;
|
||
}
|
||
"step 5";
|
||
if (result.bool && result.cards && result.cards.length > 1) {
|
||
var bool = player.storage.lslixun > 0 !== true;
|
||
player
|
||
.chooseTarget(bool, "令" + get.translation(target) + "对其攻击范围内的一名角色造成1点伤害" + (bool ? "" : "，或点「取消」移去一个“珠”"), function (card, player, target) {
|
||
var source = _status.event.source;
|
||
return target != source && source.inRange(target);
|
||
})
|
||
.set("source", target)
|
||
.set("ai", function (target) {
|
||
return get.damageEffect(target, _status.event.source, _status.event.player);
|
||
});
|
||
} else event.finish();
|
||
"step 6";
|
||
if (result.bool && result.targets && result.targets.length) {
|
||
player.line(result.targets[0]);
|
||
result.targets[0].damage(target);
|
||
} else {
|
||
player.removeMark("lslixun", 1);
|
||
}
|
||
},
|
||
ai: {
|
||
expose: 0.25,
|
||
},
|
||
},
|
||
xpchijie: {
|
||
audio: 2,
|
||
trigger: {
|
||
target: "useCardToAfter",
|
||
},
|
||
filter: function (event, player) {
|
||
var evt = event.getParent();
|
||
var targets = evt.targets.slice(evt.num + 1);
|
||
return event.player != player && targets.length > 0;
|
||
},
|
||
usable: 1,
|
||
prompt2: function (event, player) {
|
||
var evt = event.getParent();
|
||
var targets = evt.targets.slice(evt.num + 1);
|
||
return "令" + get.translation(event.card) + "对" + get.translation(targets) + "无效";
|
||
},
|
||
check: function (event, player) {
|
||
var evt = event.getParent();
|
||
var targets = evt.targets.slice(evt.num + 1);
|
||
var num = 0;
|
||
for (var i = 0; i < targets.length; i++) {
|
||
num += get.effect(targets[i], evt.card, evt.player, player);
|
||
}
|
||
return num < -1;
|
||
},
|
||
content: function () {
|
||
var evt = trigger.getParent();
|
||
evt.excluded.addArray(evt.targets);
|
||
},
|
||
group: "xpchijie2",
|
||
},
|
||
xpchijie2: {
|
||
trigger: { global: "useCardAfter" },
|
||
audio: "xpchijie",
|
||
filter: function (event, player) {
|
||
return (
|
||
event.player != player &&
|
||
event.targets.includes(player) &&
|
||
event.cards.filterInD().length > 0 &&
|
||
!game.hasPlayer2(function (current) {
|
||
return (
|
||
current.getHistory("damage", function (evt) {
|
||
return evt.card == event.card;
|
||
}).length > 0
|
||
);
|
||
})
|
||
);
|
||
},
|
||
usable: 1,
|
||
check: function (event, player) {
|
||
return get.value(event.cards.filterInD(), player, "raw") > 0;
|
||
},
|
||
prompt2: function (event, player) {
|
||
return "获得" + get.translation(event.cards.filterInD()) + "。";
|
||
},
|
||
content: function () {
|
||
player.gain(trigger.cards.filterInD(), "log", "gain2");
|
||
},
|
||
},
|
||
xpchijie4: {},
|
||
yinju: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
limited: true,
|
||
filterTarget: lib.filter.notMe,
|
||
skillAnimation: true,
|
||
animationColor: "water",
|
||
content: function () {
|
||
player.awakenSkill("yinju");
|
||
player.storage.yinju2 = target;
|
||
player.addTempSkill("yinju2");
|
||
},
|
||
ai: {
|
||
result: {
|
||
order: 10,
|
||
player: function (player, target) {
|
||
if (
|
||
player.countCards("hs", function (card) {
|
||
return get.tag(card, "damage") && player.canUse(card, target);
|
||
}) >= 1 &&
|
||
target.hp <= 2
|
||
)
|
||
return 0.1;
|
||
if (
|
||
player.countCards("hes", function (card) {
|
||
return player.canUse(card, target);
|
||
}) <= 2
|
||
)
|
||
return -100;
|
||
return 1;
|
||
},
|
||
target: function (player, target) {
|
||
return target.isDamaged() ? 5 : 3;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
yinju2: {
|
||
trigger: {
|
||
player: "useCardToPlayered",
|
||
source: "damageBefore",
|
||
},
|
||
forced: true,
|
||
onremove: true,
|
||
filter: function (event, player, name) {
|
||
if (name == "useCardToPlayered") return event.target == player.storage.yinju2;
|
||
return event.player == player.storage.yinju2;
|
||
},
|
||
logTarget: function (event) {
|
||
return event[event.name == "damage" ? "player" : "target"];
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (trigger.name == "damage") {
|
||
trigger.cancel();
|
||
trigger.player.recover(trigger.num);
|
||
event.finish();
|
||
} else {
|
||
game.asyncDraw([player, trigger.target]);
|
||
}
|
||
"step 1";
|
||
game.delayx();
|
||
},
|
||
ai: {
|
||
effect: {
|
||
player: function (card, player, target) {
|
||
if (target != player.storage.yinju2) return;
|
||
if (card.name == "lebu") return;
|
||
if (card.name !== "huogong" && get.tag(card, "damage") && target.isDamaged()) [1, 0.6, 0, 2.4];
|
||
return [1, 0.6, 1, 0.6];
|
||
},
|
||
},
|
||
},
|
||
},
|
||
rewenji: {
|
||
audio: "spwenji",
|
||
trigger: { player: "phaseUseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(function (current) {
|
||
return current != player && current.countCards("he");
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt2("rewenji"), function (card, player, target) {
|
||
return target != player && target.countCards("he") > 0;
|
||
})
|
||
.set("ai", function (target) {
|
||
var att = get.attitude(_status.event.player, target);
|
||
if (att > 0) return Math.sqrt(att) / 10;
|
||
return 5 - att;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("rewenji", target);
|
||
target.chooseCard("he", true, "问计：将一张牌交给" + get.translation(player));
|
||
} else {
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.addTempSkill("rewenji_respond");
|
||
player.storage.rewenji_respond = get.type2(result.cards[0], target);
|
||
event.target.give(result.cards, player, true);
|
||
}
|
||
},
|
||
subSkill: {
|
||
respond: {
|
||
onremove: true,
|
||
trigger: { player: "useCard" },
|
||
forced: true,
|
||
charlotte: true,
|
||
audio: "spwenji",
|
||
filter: function (event, player) {
|
||
return get.type2(event.card) == player.storage.rewenji_respond;
|
||
},
|
||
content: function () {
|
||
trigger.directHit.addArray(
|
||
game.filterPlayer(function (current) {
|
||
return current != player;
|
||
})
|
||
);
|
||
},
|
||
ai: {
|
||
directHit_ai: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
return get.type2(arg.card) == player.storage.rewenji_respond;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
spwenji: {
|
||
audio: 2,
|
||
trigger: { player: "phaseUseBegin" },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(function (current) {
|
||
return current != player && current.countCards("he");
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt2("spwenji"), function (card, player, target) {
|
||
return target != player && target.countCards("he") > 0;
|
||
})
|
||
.set("ai", function (target) {
|
||
var att = get.attitude(_status.event.player, target);
|
||
if (att > 0) return Math.sqrt(att) / 10;
|
||
return 5 - att;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
event.target = target;
|
||
player.logSkill("spwenji", target);
|
||
target.chooseCard("he", true, "问计：将一张牌交给" + get.translation(player));
|
||
} else {
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.addTempSkill("spwenji_respond");
|
||
player.storage.spwenji_respond = result.cards[0].name;
|
||
event.target.give(result.cards, player, true);
|
||
}
|
||
},
|
||
subSkill: {
|
||
respond: {
|
||
onremove: true,
|
||
trigger: { player: "useCard" },
|
||
forced: true,
|
||
charlotte: true,
|
||
audio: "spwenji",
|
||
filter: function (event, player) {
|
||
return event.card.name == player.storage.spwenji_respond;
|
||
},
|
||
content: function () {
|
||
trigger.directHit.addArray(
|
||
game.filterPlayer(function (current) {
|
||
return current != player;
|
||
})
|
||
);
|
||
},
|
||
ai: {
|
||
directHit_ai: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
return arg.card.name == player.storage.spwenji_respond;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
sptunjiang: {
|
||
audio: 2,
|
||
trigger: { player: "phaseJieshuBegin" },
|
||
frequent: true,
|
||
filter: function (event, player) {
|
||
//if(player.getHistory('skipped').includes('phaseUse')) return false;
|
||
return (
|
||
player.getHistory("useCard", function (evt) {
|
||
if (evt.targets && evt.targets.length && evt.isPhaseUsing()) {
|
||
var targets = evt.targets.slice(0);
|
||
while (targets.includes(player)) targets.remove(player);
|
||
return targets.length > 0;
|
||
}
|
||
return false;
|
||
}).length == 0
|
||
);
|
||
},
|
||
content: function () {
|
||
player.draw(game.countGroup());
|
||
},
|
||
},
|
||
bingzhao: {
|
||
audio: 2,
|
||
unique: true,
|
||
zhuSkill: true,
|
||
forced: true,
|
||
locked: false,
|
||
intro: {
|
||
content: function (group) {
|
||
return "已选择了" + get.translation(group) + "势力";
|
||
},
|
||
},
|
||
trigger: { global: ["phaseBefore", "zhuUpdate"] },
|
||
filter: function (event, player) {
|
||
if (
|
||
!lib.group.some(function (group) {
|
||
if (group == player.group) return false;
|
||
return (
|
||
lib.group.includes(group) ||
|
||
game.hasPlayer(function (current) {
|
||
return current.group == group;
|
||
})
|
||
);
|
||
})
|
||
)
|
||
return false;
|
||
return !player.storage.bingzhao && player.hasZhuSkill("bingzhao") && (event.name != "phase" || game.phaseNumber == 0);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var list = lib.group.filter(function (group) {
|
||
if (group == player.group) return false;
|
||
return (
|
||
lib.group.includes(group) ||
|
||
game.hasPlayer(function (current) {
|
||
return current.group == group;
|
||
})
|
||
);
|
||
});
|
||
player
|
||
.chooseControl(list)
|
||
.set("prompt", "秉诏：请选择一个其他势力")
|
||
.set("ai", function () {
|
||
var listx = list.slice(0);
|
||
listx.sort(function (a, b) {
|
||
return (
|
||
game.countPlayer(function (current) {
|
||
return current != player && current.group == b;
|
||
}) -
|
||
game.countPlayer(function (current) {
|
||
return current != player && current.group == a;
|
||
})
|
||
);
|
||
});
|
||
return listx[0];
|
||
});
|
||
"step 1";
|
||
var group = result.control;
|
||
player.popup(get.translation(group) + "势力", get.groupnature(group, "raw"));
|
||
game.log(player, "选择了", "#y" + get.translation(group) + "势力");
|
||
player.storage.bingzhao = group;
|
||
player.markSkill("bingzhao");
|
||
},
|
||
ai: {
|
||
combo: "guju",
|
||
},
|
||
},
|
||
baijia: {
|
||
audio: 2,
|
||
audioname: ["tw_beimihu"],
|
||
unique: true,
|
||
derivation: "bmcanshi",
|
||
juexingji: true,
|
||
ai: {
|
||
combo: "guju",
|
||
},
|
||
trigger: { player: "phaseZhunbeiBegin" },
|
||
forced: true,
|
||
skillAnimation: true,
|
||
animationColor: "thunder",
|
||
filter: function (event, player) {
|
||
return player.hasSkill("guju") && player.storage.guju >= 7;
|
||
},
|
||
content: function () {
|
||
player.awakenSkill("baijia");
|
||
player.gainMaxHp();
|
||
player.recover();
|
||
var list = game.filterPlayer();
|
||
for (var i = 0; i < list.length; i++) {
|
||
if (list[i] != player && !list[i].hasMark("zongkui_mark")) {
|
||
list[i].addMark("zongkui_mark", 1);
|
||
player.line(list[i], "green");
|
||
}
|
||
}
|
||
//player.removeSkill('guju');
|
||
player.changeSkills(["bmcanshi"], ["guju"]);
|
||
},
|
||
},
|
||
bmcanshi: {
|
||
audio: 2,
|
||
audioname: ["tw_beimihu"],
|
||
group: ["bmcanshi_add", "bmcanshi_remove"],
|
||
ai: {
|
||
combo: "zongkui",
|
||
},
|
||
subSkill: {
|
||
add: {
|
||
audio: "bmcanshi",
|
||
trigger: { player: "useCard2" },
|
||
filter: function (event, player) {
|
||
if (!event.targets || event.targets.length != 1) return false;
|
||
var info = get.info(event.card);
|
||
if (info.multitarget) return false;
|
||
if (info.allowMultiple == false) return false;
|
||
if (info.type == "equip") return false;
|
||
if (info.type == "delay") return false;
|
||
return game.hasPlayer(function (current) {
|
||
if (!current.hasMark("zongkui_mark")) return false;
|
||
return !event.targets.includes(current) && lib.filter.targetEnabled2(event.card, player, current);
|
||
});
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt2("bmcanshi"), [1, Infinity], function (card, player, target) {
|
||
if (!target.hasMark("zongkui_mark")) return false;
|
||
var trigger = _status.event.getTrigger();
|
||
return !trigger.targets.includes(target) && lib.filter.targetEnabled2(trigger.card, player, target);
|
||
})
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return get.effect(target, _status.event.getTrigger().card, player, player);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
if (!event.isMine() && !event.isOnline()) game.delayx();
|
||
event.targets = result.targets.sortBySeat();
|
||
} else {
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
player.logSkill("bmcanshi", event.targets);
|
||
for (var i = 0; i < event.targets.length; i++) {
|
||
event.targets[i].removeMark("zongkui_mark", 1);
|
||
}
|
||
trigger.targets.addArray(event.targets);
|
||
},
|
||
},
|
||
remove: {
|
||
audio: "bmcanshi",
|
||
trigger: {
|
||
target: "useCardToTarget",
|
||
},
|
||
check: function (event, player) {
|
||
return get.attitude(event.player, player) < 0 && get.effect(player, event.card, event.player, player) < 0;
|
||
},
|
||
logTarget: "player",
|
||
filter: function (event, player) {
|
||
if (!["basic", "trick"].includes(get.type(event.card))) return false;
|
||
if (!event.targets || event.targets.length != 1) return false;
|
||
return event.player.hasMark("zongkui_mark");
|
||
},
|
||
content: function () {
|
||
trigger.targets.remove(player);
|
||
trigger.getParent().triggeredTargets2.remove(player);
|
||
game.delay();
|
||
trigger.player.removeMark("zongkui_mark");
|
||
},
|
||
},
|
||
},
|
||
},
|
||
guju: {
|
||
audio: 2,
|
||
audioname: ["tw_beimihu"],
|
||
init: function (player) {
|
||
if (!player.storage.guju) player.storage.guju = 0;
|
||
},
|
||
intro: {
|
||
content: "已因此技能得到#张牌",
|
||
},
|
||
trigger: { global: "damageEnd" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return event.player != player && event.player.isIn() && event.player.hasMark("zongkui_mark");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.draw();
|
||
player.storage.guju++;
|
||
player.markSkill("guju");
|
||
"step 1";
|
||
if (player.hasZhuSkill("bingzhao", trigger.player) && trigger.player.group == player.storage.bingzhao && trigger.player.isIn()) {
|
||
trigger.player.chooseBool("是否对" + get.translation(player) + "发动【秉诏】？").ai = function () {
|
||
return get.attitude(trigger.player, player) > 1;
|
||
};
|
||
} else event.finish();
|
||
"step 2";
|
||
if (result.bool) {
|
||
trigger.player.logSkill("bingzhao", player);
|
||
player.draw();
|
||
player.storage.guju++;
|
||
player.markSkill("guju");
|
||
}
|
||
},
|
||
ai: {
|
||
combo: "zongkui",
|
||
},
|
||
},
|
||
zongkui: {
|
||
trigger: {
|
||
player: "phaseBeforeEnd",
|
||
global: "roundStart",
|
||
},
|
||
direct: true,
|
||
audio: 2,
|
||
audioname: ["tw_beimihu"],
|
||
filter: function (event, player, name) {
|
||
return game.hasPlayer(function (current) {
|
||
if (name == "roundStart" && !current.isMinHp()) return false;
|
||
return current != player && !current.hasMark("zongkui_mark");
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var targets = game.filterPlayer(function (current) {
|
||
if (event.triggername == "roundStart" && !current.isMinHp()) return false;
|
||
return current != player && !current.hasMark("zongkui_mark");
|
||
});
|
||
if (event.triggername == "roundStart" && targets.length == 1) {
|
||
event._result = { bool: true, targets: targets };
|
||
} else {
|
||
var next = player
|
||
.chooseTarget(get.prompt("zongkui"), "令一名" + (event.triggername == "roundStart" ? "体力值最小的" : "") + "其他角色获得“傀”标记", function (card, player, target) {
|
||
if (_status.event.round && !target.isMinHp()) return false;
|
||
return target != player && !target.hasMark("zongkui_mark");
|
||
})
|
||
.set("ai", function (target) {
|
||
var num = target.isMinHp() ? 0.5 : 1;
|
||
return num * get.threaten(target);
|
||
})
|
||
.set("round", event.triggername == "roundStart");
|
||
if (event.triggername == "roundStart") next.set("forced", true);
|
||
}
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.logSkill("zongkui", target);
|
||
target.addMark("zongkui_mark", 1);
|
||
game.delayx();
|
||
}
|
||
},
|
||
subSkill: {
|
||
mark: {
|
||
marktext: "傀",
|
||
intro: {
|
||
name2: "傀",
|
||
content: "mark",
|
||
},
|
||
},
|
||
},
|
||
ai: {
|
||
combo: "guju",
|
||
threaten: 1.4,
|
||
},
|
||
},
|
||
xinfu_langxi: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "phaseZhunbeiBegin",
|
||
},
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(function (current) {
|
||
return current != player && current.hp <= player.hp;
|
||
});
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(get.prompt("xinfu_langxi"), "对一名体力值不大于你的其他角色造成0-2点随机伤害", function (card, player, target) {
|
||
return target.hp <= player.hp && target != player;
|
||
})
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return get.damageEffect(target, player, player);
|
||
});
|
||
"step 1";
|
||
if (result.bool && result.targets && result.targets.length) {
|
||
player.logSkill("xinfu_langxi", result.targets);
|
||
var num = [1, 2, 0].randomGet();
|
||
if (get.isLuckyStar(player)) num = 2;
|
||
player.line(result.targets[0], "green");
|
||
result.targets[0].damage(num);
|
||
}
|
||
},
|
||
ai: {
|
||
expose: 0.25,
|
||
threaten: 1.7,
|
||
},
|
||
},
|
||
xinfu_yisuan: {
|
||
usable: 1,
|
||
audio: 2,
|
||
trigger: {
|
||
player: "useCardEnd",
|
||
},
|
||
check: function (event, player) {
|
||
return get.value(event.cards) + player.maxHp * 2 - 18 > 0;
|
||
},
|
||
prompt2: function (event, player) {
|
||
return "你可以减1点体力上限，然后获得" + get.translation(event.cards.filterInD()) + "。";
|
||
},
|
||
filter: function (event, player) {
|
||
return player.isPhaseUsing() && get.type(event.card) == "trick" && event.cards.filterInD().length > 0;
|
||
},
|
||
content: function () {
|
||
player.loseMaxHp();
|
||
player.gain(trigger.cards.filterInD(), "gain2", "log");
|
||
},
|
||
},
|
||
xinfu_xingluan: {
|
||
usable: 1,
|
||
audio: 2,
|
||
trigger: {
|
||
player: "useCardAfter",
|
||
},
|
||
filter: function (event, player) {
|
||
if (!player.isPhaseUsing()) return false;
|
||
if (get.type(event.card) == undefined) return false;
|
||
return event.targets && event.targets.length == 1;
|
||
},
|
||
content: function () {
|
||
var card = get.cardPile2(function (card) {
|
||
return card.number == 6;
|
||
});
|
||
if (!card) {
|
||
player.chat("无牌可得了吗");
|
||
game.log("但是牌堆里面已经没有点数为6的牌了！");
|
||
event.finish();
|
||
return;
|
||
}
|
||
player.gain(card, "gain2");
|
||
},
|
||
},
|
||
xinfu_lveming: {
|
||
init: function (player) {
|
||
player.storage.xinfu_lveming = 0;
|
||
},
|
||
mark: true,
|
||
intro: {
|
||
content: "已发动过#次",
|
||
},
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: function (card, player, target) {
|
||
return player != target && target.countCards("e") < player.countCards("e");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13].map(i => get.strNumber(i));
|
||
target
|
||
.chooseControl(list)
|
||
.set("ai", function () {
|
||
return get.rand(0, 12);
|
||
})
|
||
.set("prompt", "请选择一个点数");
|
||
"step 1";
|
||
if (result.control) {
|
||
target.$damagepop(result.control, "thunder");
|
||
var num = result.index + 1;
|
||
event.num = num;
|
||
} else {
|
||
target.$damagepop("K", "thunder");
|
||
event.num = 13;
|
||
}
|
||
game.log(target, "选择的点数是", "#y" + get.strNumber(event.num));
|
||
player.storage.xinfu_lveming++;
|
||
player.judge(function (card) {
|
||
if (card.number == _status.event.getParent("xinfu_lveming").num) return 4;
|
||
return 0;
|
||
});
|
||
"step 2";
|
||
if (result.bool == true) {
|
||
target.damage(2);
|
||
} else {
|
||
var card = target.getCards("hej").randomGet();
|
||
player.gain(card, target, "giveAuto", "bySelf");
|
||
}
|
||
},
|
||
ai: {
|
||
order: 9,
|
||
result: {
|
||
target: function (player, target) {
|
||
var numj = target.countCards("j");
|
||
var numhe = target.countCards("he");
|
||
if (numhe == 0) return numj > 0 ? 6 : -6;
|
||
return -6 - (numj + 1) / numhe;
|
||
},
|
||
},
|
||
threaten: 1.1,
|
||
},
|
||
},
|
||
xinfu_tunjun: {
|
||
skillAnimation: true,
|
||
animationColor: "metal",
|
||
limited: true,
|
||
unique: true,
|
||
enable: "phaseUse",
|
||
audio: 2,
|
||
filter: function (event, player) {
|
||
if (player.storage.xinfu_tunjun) return false;
|
||
return player.storage.xinfu_lveming && player.storage.xinfu_lveming > 0;
|
||
},
|
||
filterTarget: true,
|
||
selectTarget: 1,
|
||
content: function () {
|
||
"step 0";
|
||
player.awakenSkill("xinfu_tunjun");
|
||
event.num = player.storage.xinfu_lveming;
|
||
event.toequip = [];
|
||
"step 1";
|
||
var equip = get.cardPile(function (card) {
|
||
var bool1 = true;
|
||
for (var i = 0; i < event.toequip.length; i++) {
|
||
if (get.type(card) == "equip" && get.subtype(card) == get.subtype(event.toequip[i])) bool1 = false;
|
||
}
|
||
return get.type(card) == "equip" && !event.toequip.includes(card) && target.hasEmptySlot(card) && bool1;
|
||
});
|
||
if (equip) event.toequip.push(equip);
|
||
else event.num = 0;
|
||
event.num--;
|
||
"step 2";
|
||
if (event.num > 0) event.goto(1);
|
||
"step 3";
|
||
for (var i = 0; i < event.toequip.length; i++) {
|
||
target.chooseUseTarget(event.toequip[i], true).set("animate", false).set("nopopup", true);
|
||
}
|
||
},
|
||
ai: {
|
||
combo: "xinfu_lveming",
|
||
order: function () {
|
||
var player = _status.event.player,
|
||
num = 0;
|
||
for (var i = 1; i < 6; i++) {
|
||
num += player.countEquipableSlot(i);
|
||
}
|
||
if (num <= 2) return 6;
|
||
if (
|
||
player.hp <= 2 ||
|
||
!game.hasPlayer(current => {
|
||
if (player == current || get.attitude(player, current) < 0 || current.hp <= 1) return false;
|
||
return current.hp > 2 || current.countCards("hs") > 2;
|
||
})
|
||
)
|
||
return 1;
|
||
return 0;
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
var num = 0;
|
||
for (var i = 1; i < 6; i++) {
|
||
num += target.countEquipableSlot(i);
|
||
}
|
||
return num;
|
||
},
|
||
},
|
||
},
|
||
mark: true,
|
||
intro: {
|
||
content: "limited",
|
||
},
|
||
init: function (player) {
|
||
player.storage.xinfu_tunjun = false;
|
||
},
|
||
},
|
||
xinfu_tanbei: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: function (card, player, target) {
|
||
return player != target;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (target.countCards("hej") == 0) {
|
||
event._result = { index: 1 };
|
||
} else {
|
||
target
|
||
.chooseControl()
|
||
.set("choiceList", ["令" + get.translation(player) + "随机获得你区域内的一张牌，然后其本回合内不能再对你使用牌。", "令" + get.translation(player) + "本回合内对你使用牌没有次数与距离限制。"])
|
||
.set("ai", function () {
|
||
var list = [0, 1];
|
||
return list.randomGet();
|
||
});
|
||
}
|
||
"step 1";
|
||
player.addTempSkill("tanbei_effect3");
|
||
if (result.index == 0) {
|
||
var card = target.getCards("hej").randomGet();
|
||
player.gain(card, target, "giveAuto", "bySelf");
|
||
target.addTempSkill("tanbei_effect2");
|
||
} else {
|
||
target.addTempSkill("tanbei_effect1");
|
||
}
|
||
},
|
||
ai: {
|
||
order: function () {
|
||
return [2, 4, 6, 8, 10].randomGet();
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
return -2 - target.countCards("h");
|
||
},
|
||
},
|
||
threaten: 1.1,
|
||
},
|
||
},
|
||
tanbei_effect3: {
|
||
charlotte: true,
|
||
mod: {
|
||
targetInRange: function (card, player, target) {
|
||
if (target.hasSkill("tanbei_effect1")) {
|
||
return true;
|
||
}
|
||
},
|
||
cardUsableTarget: function (card, player, target) {
|
||
if (target.hasSkill("tanbei_effect1")) return true;
|
||
},
|
||
playerEnabled: function (card, player, target) {
|
||
if (target.hasSkill("tanbei_effect2")) return false;
|
||
},
|
||
},
|
||
},
|
||
xinfu_sidao: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: "useCardAfter",
|
||
},
|
||
filter: function (event, player) {
|
||
if (player.hasSkill("xinfu_sidaoy") || !player.countCards("hs")) return false;
|
||
if (!event.targets || !event.targets.length || !event.isPhaseUsing(player)) return false;
|
||
var history = player.getHistory("useCard");
|
||
var index = history.indexOf(event) - 1;
|
||
if (index < 0) return false;
|
||
var evt = history[index];
|
||
if (!evt || !evt.targets || !evt.targets.length || !evt.isPhaseUsing(player)) return false;
|
||
for (var i = 0; i < event.targets.length; i++) {
|
||
if (evt.targets.includes(event.targets[i]) && lib.filter.filterTarget({ name: "shunshou" }, player, event.targets[i])) return true;
|
||
}
|
||
return false;
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
var targets = player.getLastUsed(1).targets;
|
||
var next = player.chooseToUse();
|
||
next.set(
|
||
"targets",
|
||
game.filterPlayer(function (current) {
|
||
return targets.includes(current) && trigger.targets.includes(current);
|
||
})
|
||
);
|
||
next.set("openskilldialog", get.prompt2("xinfu_sidao"));
|
||
next.set("norestore", true);
|
||
next.set("_backupevent", "xinfu_sidaox");
|
||
next.set("custom", {
|
||
add: {},
|
||
replace: { window: function () {} },
|
||
});
|
||
next.backup("xinfu_sidaox");
|
||
},
|
||
},
|
||
xinfu_sidaox: {
|
||
audio: "xinfu_sidao",
|
||
filterCard: function (card) {
|
||
return get.itemtype(card) == "card";
|
||
},
|
||
position: "hs",
|
||
viewAs: {
|
||
name: "shunshou",
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return _status.event.targets && _status.event.targets.includes(target) && lib.filter.filterTarget.apply(this, arguments);
|
||
},
|
||
prompt: "将一张手牌当顺手牵羊使用",
|
||
check: function (card) {
|
||
return 7 - get.value(card);
|
||
},
|
||
onuse: function (links, player) {
|
||
player.addTempSkill("xinfu_sidaoy");
|
||
},
|
||
},
|
||
xinfu_sidaoy: {},
|
||
tanbei_effect1: {
|
||
charlotte: true,
|
||
},
|
||
tanbei_effect2: {
|
||
charlotte: true,
|
||
},
|
||
xinfu_tunan: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: function (card, player, target) {
|
||
return target != player;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.cards = get.cards(1);
|
||
player.showCards(get.translation(player) + "对" + get.translation(target) + "发动了【图南】", event.cards);
|
||
"step 1";
|
||
var card = cards[0];
|
||
var bool1 = game.hasPlayer(function (current) {
|
||
return target.canUse(card, current, false);
|
||
});
|
||
var bool2 = game.hasPlayer(function (current) {
|
||
return target.canUse({ name: "sha" }, current);
|
||
});
|
||
if (bool1 && bool2) {
|
||
target
|
||
.chooseControl(function () {
|
||
return 0;
|
||
})
|
||
.set("choiceList", ["使用" + get.translation(cards) + "。（没有距离限制）", "将" + get.translation(cards) + "当做【杀】使用。"])
|
||
.set("ai", function () {
|
||
return _status.event.choice;
|
||
})
|
||
.set("choice", target.getUseValue(card, false) > target.getUseValue({ name: "sha", cards: cards }) ? 0 : 1);
|
||
} else if (bool1) {
|
||
event.directindex = 0;
|
||
} else if (bool2) {
|
||
event.directindex = 1;
|
||
} else {
|
||
ui.cardPile.insertBefore(card, ui.cardPile.firstChild);
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
var card = cards[0];
|
||
if (result && typeof event.directindex != "number") {
|
||
event.directindex = result.index;
|
||
}
|
||
if (event.directindex == 1) {
|
||
target.chooseUseTarget({ name: "sha" }, cards, true, false).viewAs = false;
|
||
} else {
|
||
target.chooseUseTarget(card, true, false, "nodistance");
|
||
}
|
||
},
|
||
ai: {
|
||
order: 7,
|
||
result: {
|
||
target: 1,
|
||
},
|
||
},
|
||
},
|
||
xinfu_bijing: {
|
||
audio: 2,
|
||
subSkill: {
|
||
lose: {
|
||
trigger: {
|
||
global: "phaseDiscardBegin",
|
||
},
|
||
audio: "xinfu_bijing",
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
if (event.player == player) return false;
|
||
return (
|
||
player.getHistory("lose", function (evt) {
|
||
for (var i in evt.gaintag_map) {
|
||
if (evt.gaintag_map[i].includes("xinfu_bijing")) return true;
|
||
}
|
||
}).length > 0 && event.player.countCards("he") > 0
|
||
);
|
||
},
|
||
forced: true,
|
||
logTarget: "player",
|
||
content: function () {
|
||
trigger.player.chooseToDiscard(2, true, "he");
|
||
},
|
||
sub: true,
|
||
},
|
||
discard: {
|
||
trigger: {
|
||
player: "phaseZhunbeiBegin",
|
||
},
|
||
forced: true,
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
return player.hasCard(card => card.hasGaintag("xinfu_bijing") && player.canRecast(card), "h");
|
||
},
|
||
content: function () {
|
||
player.recast(player.getCards("h", card => card.hasGaintag("xinfu_bijing") && player.canRecast(card)));
|
||
},
|
||
sub: true,
|
||
},
|
||
},
|
||
trigger: {
|
||
player: "phaseJieshuBegin",
|
||
},
|
||
direct: true,
|
||
filter: function (player, event) {
|
||
return event.countCards("h") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.chooseCard(get.prompt2("xinfu_bijing"), "h", [1, 2]).set("ai", function (card) {
|
||
if (card.name == "shan") return 6;
|
||
return 6 - get.value(card);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.logSkill("xinfu_bijing");
|
||
player.addGaintag(result.cards, "xinfu_bijing");
|
||
player.addSkill("xinfu_bijing_lose");
|
||
player.addSkill("xinfu_bijing_discard");
|
||
}
|
||
},
|
||
},
|
||
xinfu_zhenxing: {
|
||
audio: 2,
|
||
trigger: {
|
||
player: ["damageEnd", "phaseJieshuBegin"],
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseControl("一张", "两张", "三张", "cancel2")
|
||
.set("prompt", get.prompt2("xinfu_zhenxing"))
|
||
.set("", function () {
|
||
return 0;
|
||
});
|
||
"step 1";
|
||
if (result.control == "cancel2") event.finish();
|
||
else {
|
||
player.logSkill("xinfu_zhenxing");
|
||
event.num = { 一张: 1, 两张: 2, 三张: 3 }[result.control];
|
||
}
|
||
"step 2";
|
||
event.cards = get.cards(num);
|
||
player
|
||
.chooseButton(["【镇行】：请选择要获得的牌", event.cards])
|
||
.set("filterButton", function (button) {
|
||
var cards = _status.event.cards;
|
||
for (var i = 0; i < cards.length; i++) {
|
||
if (button.link != cards[i] && get.suit(cards[i]) == get.suit(button.link)) return false;
|
||
}
|
||
return true;
|
||
})
|
||
.set("ai", function (button) {
|
||
return get.value(button.link);
|
||
})
|
||
.set("cards", event.cards);
|
||
"step 3";
|
||
var tothrow = [];
|
||
for (var i = event.cards.length - 1; i >= 0; i--) {
|
||
if (result.bool && result.links.includes(event.cards[i])) {
|
||
player.gain(event.cards[i], "gain2");
|
||
} else {
|
||
event.cards[i].fix();
|
||
ui.cardPile.insertBefore(event.cards[i], ui.cardPile.childNodes[0]);
|
||
}
|
||
}
|
||
game.updateRoundNumber();
|
||
},
|
||
},
|
||
xinfu_qianxin: {
|
||
audio: 2,
|
||
group: ["xinfu_qianxin2"],
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
onChooseToUse: function (event) {
|
||
if (!game.online) {
|
||
var num1 = game.players.length - 1;
|
||
var player = event.player;
|
||
var num2 = ui.cardPile.childElementCount;
|
||
var num3 = num2;
|
||
if (num1 > num2) num3 = 0;
|
||
else if (player.storage.xinfu_qianxin) {
|
||
for (var i = 0; i < num2; i++) {
|
||
if (player.storage.xinfu_qianxin.includes(ui.cardPile.childNodes[i])) {
|
||
num3 = 0;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
event.set("qianxinNum", num3);
|
||
}
|
||
},
|
||
filter: function (event, player) {
|
||
return event.qianxinNum && event.qianxinNum > 0;
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target != player;
|
||
},
|
||
filterCard: true,
|
||
selectCard: function () {
|
||
var num1 = game.players.length - 1;
|
||
var num2 = _status.event.qianxinNum;
|
||
return [1, Math.floor(num2 / num1)];
|
||
},
|
||
discard: false,
|
||
check: function () {
|
||
return -1;
|
||
},
|
||
delay: false,
|
||
lose: false,
|
||
prompt: function () {
|
||
return "选择一名角色并将任意张手牌放置于牌堆中" + get.cnNumber(game.players.length) + "倍数的位置（先选择的牌在上）";
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.$throw(cards.length);
|
||
player.storage.xinfu_qianxin = cards.slice(0);
|
||
player.storage.xinfu_qianxin2 = target;
|
||
//cards.reverse();
|
||
player.lose(cards, ui.cardPile).insert_index = function (event, card) {
|
||
var num1 = game.players.length,
|
||
i = event.cards.indexOf(card);
|
||
var num3 = num1 * (i + 1) - 1;
|
||
return ui.cardPile.childNodes[num3];
|
||
};
|
||
"step 1";
|
||
game.updateRoundNumber();
|
||
game.log(player, "把", get.cnNumber(cards.length), "张牌放在了牌堆里");
|
||
game.delayx();
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
result: {
|
||
target: -1,
|
||
},
|
||
},
|
||
},
|
||
xinfu_qianxin2: {
|
||
subSkill: {
|
||
dis: {
|
||
mod: {
|
||
maxHandcard: function (player, num) {
|
||
return num - 2;
|
||
},
|
||
},
|
||
sub: true,
|
||
},
|
||
},
|
||
forced: true,
|
||
locked: false,
|
||
audio: "xinfu_qianxin",
|
||
logTarget: "player",
|
||
trigger: {
|
||
global: "phaseDiscardBegin",
|
||
},
|
||
filter: function (event, player) {
|
||
if (player.storage.xinfu_qianxin2 != event.player) return false;
|
||
if (!player.storage.xinfu_qianxin) return false;
|
||
var hs = event.player.getCards("h");
|
||
var cs = player.storage.xinfu_qianxin;
|
||
var bool = false;
|
||
var history = event.player.getHistory("gain");
|
||
for (var i = 0; i < history.length; i++) {
|
||
for (var j = 0; j < history[i].cards.length; j++) {
|
||
var card = history[i].cards[j];
|
||
if (hs.includes(card) && cs.includes(card)) return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
delete player.storage.xinfu_qianxin2;
|
||
if (player.countCards("h") >= 4) {
|
||
event._result = { index: 1 };
|
||
} else {
|
||
trigger.player
|
||
.chooseControl()
|
||
.set("choiceList", ["令" + get.translation(player) + "将手牌摸至四张", "令自己本回合的手牌上限-2"])
|
||
.set("ai", function () {
|
||
var player = _status.event.player;
|
||
var source = _status.event.getParent().player;
|
||
if (get.attitude(player, source) > 0) return 0;
|
||
if (player.hp - player.countCards("h") > 1) return 1;
|
||
return [0, 1].randomGet();
|
||
});
|
||
}
|
||
"step 1";
|
||
if (result.index == 0) {
|
||
player.drawTo(4);
|
||
} else {
|
||
trigger.player.addTempSkill("xinfu_qianxin2_dis");
|
||
}
|
||
},
|
||
},
|
||
xinfu_fuhai: {
|
||
subSkill: {
|
||
next: {},
|
||
previous: {},
|
||
},
|
||
audio: 2,
|
||
group: ["fuhai_clear"],
|
||
intro: {
|
||
content: "已指定过#个目标",
|
||
},
|
||
enable: "phaseUse",
|
||
filter: function (event, player) {
|
||
if (player.hasSkill("xinfu_fuhai_next") && player.hasSkill("xinfu_fuhai_previous")) return false;
|
||
return player.countCards("h") > 0;
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
if (![player.next, player.previous].includes(target) || target.countCards("h") == 0) return false;
|
||
if (player.hasSkill("xinfu_fuhai_next")) return target == player.previous;
|
||
if (player.hasSkill("xinfu_fuhai_previous")) return target == player.next;
|
||
return true;
|
||
},
|
||
line: false,
|
||
content: function () {
|
||
"step 0";
|
||
event.side = target == player.next ? "next" : "previous";
|
||
event.current = target;
|
||
if (!player.storage.xinfu_fuhai) player.storage.xinfu_fuhai = 1;
|
||
player.addTempSkill("xinfu_fuhai_" + event.side, "phaseUseAfter");
|
||
"step 1";
|
||
if (player.countCards("h") == 0 || event.current.countCards("h") == 0 || event.current == player) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
var next = event.current[event.side];
|
||
if (get.attitude(event.current, player) > 0) {
|
||
if (get.attitude(next, target) <= 0 || next.countCards("h") == 0 || player.countCards("h") == 1) {
|
||
event.stopm = true;
|
||
event.stopt = true;
|
||
} else {
|
||
event.stopm = false;
|
||
event.stopt = false;
|
||
}
|
||
} else {
|
||
if (get.attitude(next, target) >= 0) {
|
||
event.stopt = true;
|
||
event.stopm = false;
|
||
} else {
|
||
event.stopt = false;
|
||
event.stopm = false;
|
||
}
|
||
}
|
||
player.markSkill("xinfu_fuhai");
|
||
player.line(event.current, "green");
|
||
player
|
||
.chooseCard("请选择要展示的牌", true)
|
||
.set("ai", function (card) {
|
||
if (_status.event.stop) return 14 - get.number(card);
|
||
return get.number(card);
|
||
})
|
||
.set("stop", event.stopm);
|
||
"step 2";
|
||
event.mes = result.cards[0];
|
||
player.showCards(event.mes);
|
||
"step 3";
|
||
event.current
|
||
.chooseCard("请选择要展示的牌", true)
|
||
.set("ai", function (card) {
|
||
if (_status.event.stop) return get.number(card);
|
||
return 14 - get.number(card);
|
||
})
|
||
.set("stop", event.stopt);
|
||
"step 4";
|
||
event.tes = result.cards[0];
|
||
event.current.showCards(event.tes);
|
||
"step 5";
|
||
var num1 = get.number(event.mes);
|
||
var num2 = get.number(event.tes);
|
||
if (num1 < num2) {
|
||
event.current.discard(event.tes);
|
||
game.asyncDraw([player, event.current], player.storage.xinfu_fuhai);
|
||
player.addTempSkill("xinfu_fuhai_next", "phaseUseAfter");
|
||
player.addTempSkill("xinfu_fuhai_previous", "phaseUseAfter");
|
||
player.unmarkSkill("xinfu_fuhai");
|
||
} else {
|
||
player.discard(event.mes);
|
||
player.storage.xinfu_fuhai++;
|
||
event.current = event.current[event.side];
|
||
if (player.countCards("h") > 0 && event.current.countCards("h") > 0 && event.current != player) event.goto(1);
|
||
}
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
result: {
|
||
player: function (player, target) {
|
||
var hs = player.countCards("h");
|
||
var side = target == player.next ? "next" : "previous";
|
||
var current = player;
|
||
for (var i = 0; i < hs; i++) {
|
||
current = current[side];
|
||
if (current == player || !current.countCards("h")) return 0;
|
||
if (get.attitude(current, player) > 0) return 1;
|
||
}
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
fuhai_clear: {
|
||
trigger: {
|
||
player: "phaseAfter",
|
||
},
|
||
forced: true,
|
||
silent: true,
|
||
popup: false,
|
||
filter: function (event, player) {
|
||
return player.storage.xinfu_fuhai != undefined;
|
||
},
|
||
content: function () {
|
||
player.unmarkSkill("xinfu_fuhai");
|
||
delete player.storage.xinfu_fuhai;
|
||
},
|
||
},
|
||
xz_xunxun: {
|
||
filter: function (event, player) {
|
||
var num = game.countPlayer(function (current) {
|
||
return current.isDamaged();
|
||
});
|
||
return num >= 1 && !player.hasSkill("xunxun");
|
||
},
|
||
audio: 2,
|
||
trigger: {
|
||
player: "phaseDrawBegin1",
|
||
},
|
||
//priority:10,
|
||
content: function () {
|
||
"step 0";
|
||
var cards = get.cards(4);
|
||
game.cardsGotoOrdering(cards);
|
||
var next = player.chooseToMove("恂恂：将两张牌置于牌堆顶", true);
|
||
next.set("list", [["牌堆顶", cards], ["牌堆底"]]);
|
||
next.set("filterMove", function (from, to, moved) {
|
||
if (to == 1 && moved[1].length >= 2) return false;
|
||
return true;
|
||
});
|
||
next.set("filterOk", function (moved) {
|
||
return moved[1].length == 2;
|
||
});
|
||
next.set("processAI", function (list) {
|
||
var cards = list[0][1].slice(0).sort(function (a, b) {
|
||
return get.value(b) - get.value(a);
|
||
});
|
||
return [cards, cards.splice(2)];
|
||
});
|
||
"step 1";
|
||
var top = result.moved[0];
|
||
var bottom = result.moved[1];
|
||
top.reverse();
|
||
for (var i = 0; i < top.length; i++) {
|
||
ui.cardPile.insertBefore(top[i], ui.cardPile.firstChild);
|
||
}
|
||
for (i = 0; i < bottom.length; i++) {
|
||
ui.cardPile.appendChild(bottom[i]);
|
||
}
|
||
game.updateRoundNumber();
|
||
game.delayx();
|
||
},
|
||
},
|
||
xinfu_xingzhao: {
|
||
audio: true,
|
||
group: ["xz_xunxun", "xinfu_xingzhao2", "xinfu_xingzhao3"],
|
||
mark: true,
|
||
intro: {
|
||
content: function (storage, player) {
|
||
var num = game.countPlayer(function (current) {
|
||
return current.isDamaged();
|
||
});
|
||
var str = "暂无任何效果";
|
||
if (num >= 1) {
|
||
str = "<li>视为拥有技能“恂恂”";
|
||
}
|
||
if (num >= 2) {
|
||
str += "；使用装备牌时摸一张牌";
|
||
}
|
||
if (num >= 3) {
|
||
str += "；始终跳过弃牌阶段";
|
||
}
|
||
if (num == 0 || num >= 4) {
|
||
str += "；造成的伤害+1";
|
||
}
|
||
return str;
|
||
},
|
||
},
|
||
trigger: {
|
||
player: "useCard",
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (get.type(event.card) != "equip") return false;
|
||
var num = game.countPlayer(function (current) {
|
||
return current.isDamaged();
|
||
});
|
||
return num >= 2;
|
||
},
|
||
content: function () {
|
||
player.draw();
|
||
},
|
||
},
|
||
xinfu_xingzhao2: {
|
||
audio: true,
|
||
trigger: {
|
||
player: ["phaseJudgeBefore", "phaseDiscardBefore"],
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
var num = game.countPlayer(function (current) {
|
||
return current.isDamaged();
|
||
});
|
||
return num >= 3;
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
game.log(player, "跳过了" + (trigger.name == "phaseJudge" ? "判定" : "弃牌") + "阶段");
|
||
},
|
||
},
|
||
xinfu_xingzhao3: {
|
||
audio: "xinfu_xingzhao",
|
||
trigger: {
|
||
source: "damageBegin1",
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
var num = game.countPlayer(function (current) {
|
||
return current.isDamaged();
|
||
});
|
||
return num == 0 || num >= 4;
|
||
},
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
},
|
||
xinfu_dianhu: {
|
||
audio: 2,
|
||
trigger: {
|
||
global: "phaseBefore",
|
||
player: "enterGame",
|
||
},
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return game.hasPlayer(current => current != player) && (event.name != "phase" || game.phaseNumber == 0);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget("选择【点虎】的目标", lib.translate.xinfu_dianhu_info, true, function (card, player, target) {
|
||
return target != player && !target.hasSkill("xinfu_dianhu2");
|
||
})
|
||
.set("ai", function (target) {
|
||
var att = get.attitude(_status.event.player, target);
|
||
if (att < 0) return -att + 3;
|
||
return Math.random();
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
var target = result.targets[0];
|
||
player.line(target, "green");
|
||
game.log(target, "成为了", "【点虎】", "的目标");
|
||
target.storage.xinfu_dianhu2 = player;
|
||
target.addTempSkill("xinfu_dianhu2", { player: "die" });
|
||
}
|
||
},
|
||
},
|
||
xinfu_dianhu2: {
|
||
mark: "character",
|
||
intro: {
|
||
content: "当你受到来自$的伤害或回复体力后，$摸一张牌",
|
||
},
|
||
nopop: true,
|
||
trigger: {
|
||
player: ["damageEnd", "recoverEnd"],
|
||
},
|
||
forced: true,
|
||
popup: false,
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
if (player.storage.xinfu_dianhu2 && player.storage.xinfu_dianhu2.isIn()) {
|
||
if (event.name == "damage") return event.source == player.storage.xinfu_dianhu2;
|
||
return true;
|
||
}
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var target = player.storage.xinfu_dianhu2;
|
||
target.logSkill("xinfu_dianhu");
|
||
target.draw();
|
||
},
|
||
onremove: true,
|
||
},
|
||
xinfu_jianji: {
|
||
audio: 2,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterTarget: function (card, player, target) {
|
||
return target != player;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
target.draw();
|
||
"step 1";
|
||
var card = result[0];
|
||
if (
|
||
card &&
|
||
game.hasPlayer(function (current) {
|
||
return target.canUse(card, current);
|
||
}) &&
|
||
get.owner(card) == target
|
||
) {
|
||
target.chooseToUse({
|
||
prompt: "是否使用" + get.translation(card) + "？",
|
||
filterCard: function (cardx, player, target) {
|
||
return cardx == _status.event.cardx;
|
||
},
|
||
cardx: card,
|
||
});
|
||
}
|
||
},
|
||
ai: {
|
||
order: 7.5,
|
||
result: {
|
||
target: 1,
|
||
},
|
||
},
|
||
},
|
||
xinfu_lianpian: {
|
||
audio: 2,
|
||
usable: 3,
|
||
trigger: {
|
||
player: "useCardToPlayered",
|
||
},
|
||
frequent: true,
|
||
filter: function (event, player) {
|
||
if (!event.targets || !event.targets.length || event.getParent().triggeredTargets3.length > 1 || !event.isPhaseUsing(player)) return false;
|
||
var evt = player.getLastUsed(1);
|
||
if (!evt || !evt.targets || !evt.targets.length || !evt.isPhaseUsing(player)) return false;
|
||
for (var i = 0; i < event.targets.length; i++) {
|
||
if (evt.targets.includes(event.targets[i])) return true;
|
||
}
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.draw();
|
||
"step 1";
|
||
event.card = result[0];
|
||
var ablers = player.getLastUsed(1).targets.slice(0);
|
||
for (var i = 0; i < ablers.length; i++) {
|
||
if (ablers[i] == player || !trigger.targets.includes(ablers[i])) ablers.splice(i--, 1);
|
||
}
|
||
if (event.card && get.owner(event.card) == player && ablers.length) {
|
||
player
|
||
.chooseTarget("是否将" + get.translation(event.card) + "交给其他角色？", function (card, player, target) {
|
||
return _status.event.ablers.includes(target) && target != player;
|
||
})
|
||
.set("ablers", ablers).ai = function () {
|
||
return false;
|
||
};
|
||
} else event.finish();
|
||
"step 2";
|
||
if (result.bool) {
|
||
player.give(event.card, result.targets[0], true);
|
||
}
|
||
},
|
||
locked: false,
|
||
mod: {
|
||
aiOrder: function (player, card, num) {
|
||
if (player.isPhaseUsing() && (!player.storage.counttrigger || !player.storage.counttrigger.xinfu_lianpian || !player.storage.counttrigger.xinfu_lianpian < 3)) {
|
||
var evt = player.getLastUsed();
|
||
if (
|
||
evt &&
|
||
evt.targets &&
|
||
evt.targets.length &&
|
||
evt.isPhaseUsing(player) &&
|
||
game.hasPlayer(function (current) {
|
||
return evt.targets.includes(current) && player.canUse(card, current) && get.effect(current, card, player, player) > 0;
|
||
})
|
||
) {
|
||
return num + 10;
|
||
}
|
||
}
|
||
},
|
||
},
|
||
ai: {
|
||
effect: {
|
||
player: function (card, player, target) {
|
||
var evt = player.getLastUsed();
|
||
if (evt && evt.targets.includes(target) && (!player.storage.counttrigger || !player.storage.counttrigger.xinfu_lianpian || !player.storage.counttrigger.xinfu_lianpian < 3) && player.isPhaseUsing(player)) return [1.5, 0];
|
||
},
|
||
},
|
||
},
|
||
},
|
||
//糜芳傅士仁
|
||
fengshi: {
|
||
audio: "mffengshi",
|
||
audioname: ["sp_mifangfushiren"],
|
||
trigger: { player: "useCardToPlayered" },
|
||
filter(event, player) {
|
||
if (!event.isFirstTarget) return false;
|
||
return event.targets.some(target => {
|
||
return (
|
||
player.countCards("h") > target.countCards("h") &&
|
||
target.countCards("he") > 0 &&
|
||
player.hasCard(card => {
|
||
return lib.filter.cardDiscardable(card, player, "fengshi");
|
||
}, "he")
|
||
);
|
||
});
|
||
},
|
||
direct: true,
|
||
async content(event, trigger, player) {
|
||
const {
|
||
result: { bool, targets },
|
||
} = await player
|
||
.chooseTarget(get.prompt("fengshi"), "弃置你与一名目标角色的各一张牌，然后令" + get.translation(event.card) + "对其造成的伤害+1", (card, player, target) => {
|
||
const targets = get.event().getTrigger().targets;
|
||
if (!targets.includes(target)) return false;
|
||
return (
|
||
player.countCards("h") > target.countCards("h") &&
|
||
target.countCards("he") > 0 &&
|
||
player.hasCard(card => {
|
||
return lib.filter.cardDiscardable(card, player, "fengshi");
|
||
}, "he")
|
||
);
|
||
})
|
||
.set("ai", target => {
|
||
const player = get.event("player");
|
||
const card = get.event().getTrigger().card;
|
||
if (!get.info("dcmffengshi").check({ card: card, target: target })) return 0;
|
||
return get.effect(target, { name: "guohe_copy2" }, player, player);
|
||
});
|
||
if (bool) {
|
||
const target = targets[0];
|
||
player.logSkill("fengshi", target);
|
||
await player.chooseToDiscard("he", true);
|
||
await player.discardPlayerCard(target, "he", true);
|
||
if (get.tag(trigger.card, "damage")) {
|
||
var id = target.playerid;
|
||
var map = trigger.getParent().customArgs;
|
||
if (!map[id]) map[id] = {};
|
||
if (typeof map[id].extraDamage != "number") map[id].extraDamage = 0;
|
||
map[id].extraDamage++;
|
||
}
|
||
}
|
||
},
|
||
group: "fengshi_target",
|
||
subSkill: {
|
||
target: {
|
||
inherit: "dcmffengshi",
|
||
trigger: { target: "useCardToTargeted" },
|
||
filter(event, player) {
|
||
if (event.player == event.target) return false;
|
||
return (
|
||
event.player.countCards("h") > player.countCards("h") &&
|
||
event.player.countCards("he") > 0 &&
|
||
player.hasCard(card => {
|
||
return lib.filter.cardDiscardable(card, player, "fengshi");
|
||
}, "he")
|
||
);
|
||
},
|
||
async content(event, trigger, player) {
|
||
const target = trigger.player;
|
||
await player.chooseToDiscard("he", true);
|
||
await player.discardPlayerCard(target, "he", true);
|
||
if (get.tag(trigger.card, "damage")) {
|
||
var id = player.playerid;
|
||
var map = trigger.getParent().customArgs;
|
||
if (!map[id]) map[id] = {};
|
||
if (typeof map[id].extraDamage != "number") map[id].extraDamage = 0;
|
||
map[id].extraDamage++;
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
dcmffengshi: {
|
||
audio: "mffengshi",
|
||
audioname: ["sp_mifangfushiren"],
|
||
trigger: {
|
||
player: "useCardToPlayered",
|
||
target: "useCardToTargeted",
|
||
},
|
||
filter: function (event, player, name) {
|
||
if (event.player == event.target || event.targets.length != 1) return false;
|
||
return (
|
||
event.player.countCards("h") > event.target.countCards("h") &&
|
||
event.target.countCards("he") > 0 &&
|
||
player.hasCard(function (card) {
|
||
return lib.filter.cardDiscardable(card, player, "dcmffengshi");
|
||
}, "he")
|
||
);
|
||
},
|
||
logTarget: function (event, player) {
|
||
return player == event.player ? event.target : event.player;
|
||
},
|
||
prompt2: function (event, player) {
|
||
var target = lib.skill.dcmffengshi.logTarget(event, player);
|
||
return "弃置你与" + get.translation(target) + "的各一张牌，然后令" + get.translation(event.card) + "的伤害+1";
|
||
},
|
||
check: function (event, player) {
|
||
var viewer = player,
|
||
player = event.player,
|
||
target = event.target;
|
||
if (viewer == player) {
|
||
if (get.attitude(viewer, target) >= 0) return false;
|
||
if (player.countCards("he", card => get.value(card, player) < 5)) return true;
|
||
var card = get.event().getTrigger().card;
|
||
if ((get.tag(card, "damage") || target.countCards("he", card => get.value(card, target) > 6)) && player.countCards("he", card => get.value(card, player) < 7)) return true;
|
||
return false;
|
||
} else {
|
||
if (get.attitude(viewer, player) >= 0) return false;
|
||
if (!get.tag(card, "damage")) return false;
|
||
if (viewer.countCards("he") > player.countCards("he")) return true;
|
||
if (viewer.countCards("he", card => get.value(card, target) > 6)) return false;
|
||
return true;
|
||
}
|
||
},
|
||
content: function () {
|
||
if (get.tag(trigger.card, "damage")) trigger.getParent().baseDamage++;
|
||
var target = lib.skill.dcmffengshi.logTarget(trigger, player);
|
||
player.chooseToDiscard("he", true);
|
||
player.discardPlayerCard(target, "he", true);
|
||
},
|
||
},
|
||
mffengshi: {
|
||
audio: 2,
|
||
audioname: ["sp_mifangfushiren"],
|
||
trigger: {
|
||
player: "useCardToPlayered",
|
||
target: "useCardToTargeted",
|
||
},
|
||
direct: true,
|
||
preHidden: true,
|
||
filter: function (event, player) {
|
||
if (event.player == event.target || event.targets.length != 1) return false;
|
||
if (player != event.player && !player.hasSkill("mffengshi")) return false;
|
||
return event.player.countCards("h") > event.target.countCards("h") && event.target.countCards("he") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.source = trigger.player;
|
||
event.target = player == trigger.target ? trigger.player : trigger.target;
|
||
var str;
|
||
if (player == trigger.player) str = "弃置自己的和该角色";
|
||
else str = "令其弃置其与你的";
|
||
var next = trigger.player.chooseBool("是否对" + get.translation(trigger.target) + "发动【锋势】？", str + "的各一张牌，然后令" + get.translation(trigger.card) + "的伤害+1").set("ai", function () {
|
||
var player = _status.event.getParent().player;
|
||
var target = _status.event.getParent().target;
|
||
var viewer = _status.event.player;
|
||
if (viewer == player) {
|
||
if (get.attitude(viewer, target) >= 0) return false;
|
||
if (player.countCards("he", card => get.value(card, player) < 5)) return true;
|
||
var card = _status.event.getTrigger().card;
|
||
if ((get.tag(card, "damage") || target.countCards("he", card => get.value(card, target) > 6)) && player.countCards("he", card => get.value(card, player) < 7)) return true;
|
||
return false;
|
||
} else {
|
||
if (get.attitude(viewer, player) >= 0) return false;
|
||
if (!get.tag(card, "damage")) return false;
|
||
if (viewer.countCards("he") > player.countCards("he")) return true;
|
||
if (viewer.countCards("he", card => get.value(card, target) > 6)) return false;
|
||
return true;
|
||
}
|
||
});
|
||
if (player == next.player) next.setHiddenSkill("mffengshi");
|
||
"step 1";
|
||
if (result.bool) {
|
||
if (player == source) player.logSkill("mffengshi", target);
|
||
else {
|
||
player.logSkill("mffengshi");
|
||
source.line(player, "green");
|
||
}
|
||
if (get.tag(trigger.card, "damage")) trigger.getParent().baseDamage++;
|
||
player.chooseToDiscard("he", true);
|
||
} else event.finish();
|
||
"step 2";
|
||
if (target.countDiscardableCards(player, "he") > 0) player.discardPlayerCard(target, "he", true);
|
||
},
|
||
},
|
||
};
|
||
|
||
export default skills;
|