4876 lines
144 KiB
JavaScript
4876 lines
144 KiB
JavaScript
import { lib, game, ui, get, ai, _status } from "../noname.js";
|
||
game.import("card", function () {
|
||
return {
|
||
name: "standard",
|
||
connect: true,
|
||
card: {
|
||
damage: {
|
||
ai: {
|
||
result: {
|
||
target: -1.5,
|
||
},
|
||
tag: {
|
||
damage: 1,
|
||
},
|
||
},
|
||
},
|
||
draw: {
|
||
ai: {
|
||
result: {
|
||
target: 1,
|
||
},
|
||
tag: {
|
||
draw: 1,
|
||
},
|
||
},
|
||
},
|
||
losehp: {
|
||
ai: {
|
||
result: {
|
||
target: -1.5,
|
||
},
|
||
tag: {
|
||
loseHp: 1,
|
||
},
|
||
},
|
||
},
|
||
recover: {
|
||
ai: {
|
||
result: {
|
||
target: 1.5,
|
||
},
|
||
tag: {
|
||
recover: 1,
|
||
},
|
||
},
|
||
},
|
||
firedamage: {
|
||
ai: {
|
||
result: {
|
||
target: -1.5,
|
||
},
|
||
tag: {
|
||
damage: 1,
|
||
fireDamage: 1,
|
||
natureDamage: 1,
|
||
},
|
||
},
|
||
},
|
||
thunderdamage: {
|
||
ai: {
|
||
result: {
|
||
target: -1.5,
|
||
},
|
||
tag: {
|
||
damage: 1,
|
||
thunderDamage: 1,
|
||
natureDamage: 1,
|
||
},
|
||
},
|
||
},
|
||
icedamage: {
|
||
ai: {
|
||
result: {
|
||
target: -1.5,
|
||
},
|
||
tag: {
|
||
damage: 1,
|
||
iceDamage: 1,
|
||
natureDamage: 1,
|
||
},
|
||
},
|
||
},
|
||
respondShan: {
|
||
ai: {
|
||
result: {
|
||
target: -1.5,
|
||
},
|
||
tag: {
|
||
respond: 1,
|
||
respondShan: 1,
|
||
damage: 1,
|
||
},
|
||
},
|
||
},
|
||
sha: {
|
||
audio: true,
|
||
fullskin: true,
|
||
nature: ["thunder", "fire", "kami", "ice"],
|
||
type: "basic",
|
||
enable: true,
|
||
usable: 1,
|
||
updateUsable: "phaseUse",
|
||
global: "icesha_skill",
|
||
range: function (card, player, target) {
|
||
return player.inRange(target);
|
||
},
|
||
selectTarget: 1,
|
||
cardPrompt: function (card) {
|
||
var natures = get.natureList(Array.isArray(card) ? card[3] : card);
|
||
if (lib.translate["sha_nature_" + natures[0] + "_info"])
|
||
return lib.translate["sha_nature_" + natures[0] + "_info"];
|
||
var str = "出牌阶段，对你攻击范围内的一名角色使用。其须使用一张【闪】，";
|
||
if (natures.includes("stab")) {
|
||
str += "且在此之后需弃置一张手牌（没有则不弃），";
|
||
}
|
||
str += "否则你对其造成1点";
|
||
var linked = lib.linked.filter((n) => natures.includes(n));
|
||
if (linked.length) str += get.translation(get.nature(linked)) + "属性";
|
||
str += "伤害。";
|
||
return str;
|
||
},
|
||
defaultYingbianEffect: "add",
|
||
filterTarget: function (card, player, target) {
|
||
return player != target;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (
|
||
typeof event.shanRequired != "number" ||
|
||
!event.shanRequired ||
|
||
event.shanRequired < 0
|
||
) {
|
||
event.shanRequired = 1;
|
||
}
|
||
if (typeof event.baseDamage != "number") event.baseDamage = 1;
|
||
if (typeof event.extraDamage != "number") event.extraDamage = 0;
|
||
"step 1";
|
||
if (
|
||
event.directHit ||
|
||
event.directHit2 ||
|
||
(!_status.connectMode && lib.config.skip_shan && !target.hasShan())
|
||
) {
|
||
event._result = { bool: false };
|
||
} else if (event.skipShan) {
|
||
event._result = { bool: true, result: "shaned" };
|
||
} else {
|
||
var next = target.chooseToUse("请使用一张闪响应杀");
|
||
next.set("type", "respondShan");
|
||
next.set("filterCard", function (card, player) {
|
||
if (get.name(card) != "shan") return false;
|
||
return lib.filter.cardEnabled(card, player, "forceEnable");
|
||
});
|
||
if (event.shanRequired > 1) {
|
||
next.set("prompt2", "（共需使用" + event.shanRequired + "张闪）");
|
||
} else if (game.hasNature(event.card, "stab")) {
|
||
next.set("prompt2", "（在此之后仍需弃置一张手牌）");
|
||
}
|
||
next.set("ai1", function (card) {
|
||
if (_status.event.useShan) return get.order(card);
|
||
return 0;
|
||
}).set("shanRequired", event.shanRequired);
|
||
next.set("respondTo", [player, card]);
|
||
next.set(
|
||
"useShan",
|
||
(() => {
|
||
if (target.hasSkillTag("noShan", null, event)) return false;
|
||
if (target.hasSkillTag("useShan", null, event)) return true;
|
||
if (
|
||
target.isLinked() &&
|
||
game.hasNature(event.card) &&
|
||
get.attitude(target, player._trueMe || player) > 0
|
||
)
|
||
return false;
|
||
if (
|
||
event.baseDamage + event.extraDamage <= 0 &&
|
||
!game.hasNature(event.card, "ice")
|
||
)
|
||
return false;
|
||
if (
|
||
event.baseDamage + event.extraDamage >=
|
||
target.hp +
|
||
(player.hasSkillTag("jueqing", false, target) ||
|
||
target.hasSkill("gangzhi")
|
||
? target.hujia
|
||
: 0)
|
||
)
|
||
return true;
|
||
if (
|
||
!game.hasNature(event.card, "ice") &&
|
||
get.damageEffect(target, player, target, get.nature(event.card)) >= 0
|
||
)
|
||
return false;
|
||
if (
|
||
event.shanRequired > 1 &&
|
||
target.mayHaveShan(target, "use", null, "count") <
|
||
event.shanRequired - (event.shanIgnored || 0)
|
||
)
|
||
return false;
|
||
return true;
|
||
})()
|
||
);
|
||
//next.autochoose=lib.filter.autoRespondShan;
|
||
}
|
||
"step 2";
|
||
if (!result || !result.bool || !result.result || result.result != "shaned") {
|
||
event.trigger("shaHit");
|
||
} else {
|
||
event.shanRequired--;
|
||
if (event.shanRequired > 0) {
|
||
event.goto(1);
|
||
} else if (game.hasNature(event.card, "stab") && target.countCards("h") > 0) {
|
||
event.responded = result;
|
||
event.goto(4);
|
||
} else {
|
||
event.trigger("shaMiss");
|
||
event.responded = result;
|
||
}
|
||
}
|
||
"step 3";
|
||
if (
|
||
(!result || !result.bool || !result.result || result.result != "shaned") &&
|
||
!event.unhurt
|
||
) {
|
||
if (
|
||
!event.directHit &&
|
||
!event.directHit2 &&
|
||
lib.filter.cardEnabled(
|
||
new lib.element.VCard({ name: "shan" }),
|
||
target,
|
||
"forceEnable"
|
||
) &&
|
||
target.countCards("hs") > 0 &&
|
||
get.damageEffect(target, player, target) < 0
|
||
)
|
||
target.addGaintag(target.getCards("hs"), "sha_notshan");
|
||
target.damage(get.nature(event.card));
|
||
event.result = { bool: true };
|
||
event.trigger("shaDamage");
|
||
} else {
|
||
event.result = { bool: false };
|
||
event.trigger("shaUnhirt");
|
||
}
|
||
event.finish();
|
||
"step 4";
|
||
target
|
||
.chooseToDiscard("刺杀：请弃置一张牌，否则此【杀】依然造成伤害")
|
||
.set("ai", function (card) {
|
||
var target = _status.event.player;
|
||
var evt = _status.event.getParent();
|
||
var bool = true;
|
||
if (get.damageEffect(target, evt.player, target, evt.card.nature) >= 0)
|
||
bool = false;
|
||
if (bool) {
|
||
return 8 - get.useful(card);
|
||
}
|
||
return 0;
|
||
});
|
||
"step 5";
|
||
if ((!result || !result.bool) && !event.unhurt) {
|
||
target.damage(get.nature(event.card));
|
||
event.result = { bool: true };
|
||
event.trigger("shaDamage");
|
||
event.finish();
|
||
} else {
|
||
event.trigger("shaMiss");
|
||
}
|
||
"step 6";
|
||
if ((!result || !result.bool) && !event.unhurt) {
|
||
target.damage(get.nature(event.card));
|
||
event.result = { bool: true };
|
||
event.trigger("shaDamage");
|
||
event.finish();
|
||
} else {
|
||
event.result = { bool: false };
|
||
event.trigger("shaUnhirt");
|
||
}
|
||
},
|
||
ai: {
|
||
yingbian: function (card, player, targets, viewer) {
|
||
if (get.attitude(viewer, player) <= 0) return 0;
|
||
var base = 0,
|
||
hit = false;
|
||
if (get.cardtag(card, "yingbian_hit")) {
|
||
hit = true;
|
||
if (
|
||
targets.some((target) => {
|
||
return (
|
||
target.mayHaveShan(
|
||
viewer,
|
||
"use",
|
||
target.getCards("h", (i) => {
|
||
return i.hasGaintag("sha_notshan");
|
||
})
|
||
) &&
|
||
get.attitude(viewer, target) < 0 &&
|
||
get.damageEffect(target, player, viewer, get.natureList(card)) > 0
|
||
);
|
||
})
|
||
)
|
||
base += 5;
|
||
}
|
||
if (get.cardtag(card, "yingbian_add")) {
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return (
|
||
!targets.includes(current) &&
|
||
lib.filter.targetEnabled2(card, player, current) &&
|
||
get.effect(current, card, player, player) > 0
|
||
);
|
||
})
|
||
)
|
||
base += 5;
|
||
}
|
||
if (get.cardtag(card, "yingbian_damage")) {
|
||
if (
|
||
targets.some((target) => {
|
||
return (
|
||
get.attitude(player, target) < 0 &&
|
||
(hit ||
|
||
!target.mayHaveShan(
|
||
viewer,
|
||
"use",
|
||
target.getCards("h", (i) => {
|
||
return i.hasGaintag("sha_notshan");
|
||
})
|
||
) ||
|
||
player.hasSkillTag(
|
||
"directHit_ai",
|
||
true,
|
||
{
|
||
target: target,
|
||
card: card,
|
||
},
|
||
true
|
||
)) &&
|
||
!target.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
jiu: true,
|
||
})
|
||
);
|
||
})
|
||
)
|
||
base += 5;
|
||
}
|
||
return base;
|
||
},
|
||
canLink: function (player, target, card) {
|
||
if (!target.isLinked() && !player.hasSkill("wutiesuolian_skill")) return false;
|
||
if (
|
||
player.hasSkill("jueqing") ||
|
||
player.hasSkill("gangzhi") ||
|
||
target.hasSkill("gangzhi")
|
||
)
|
||
return false;
|
||
return true;
|
||
},
|
||
basic: {
|
||
useful: [5, 3, 1],
|
||
value: [5, 3, 1],
|
||
},
|
||
order(item, player) {
|
||
let res = 3.2;
|
||
if (player.hasSkillTag("presha", true, null, true)) res = 10;
|
||
if (
|
||
typeof item !== "object" ||
|
||
!game.hasNature(item, "linked") ||
|
||
game.countPlayer((cur) => cur.isLinked()) < 2
|
||
)
|
||
return res;
|
||
//let used = player.getCardUsable('sha') - 1.5, natures = ['thunder', 'fire', 'ice', 'kami'];
|
||
let uv = player.getUseValue(item, true);
|
||
if (uv <= 0) return res;
|
||
let temp = player.getUseValue("sha", true) - uv;
|
||
if (temp < 0) return res + 0.15;
|
||
if (temp > 0) return res - 0.15;
|
||
return res;
|
||
},
|
||
result: {
|
||
target: function (player, target, card, isLink) {
|
||
let eff = -1.5,
|
||
odds = 1.35,
|
||
num = 1;
|
||
if (isLink) {
|
||
let cache = _status.event.getTempCache("sha_result", "eff");
|
||
if (typeof cache !== "object" || cache.card !== get.translation(card))
|
||
return eff;
|
||
if (cache.odds < 1.35 && cache.bool) return 1.35 * cache.eff;
|
||
return cache.odds * cache.eff;
|
||
}
|
||
if (
|
||
player.hasSkill("jiu") ||
|
||
player.hasSkillTag("damageBonus", true, {
|
||
target: target,
|
||
card: card,
|
||
})
|
||
) {
|
||
if (
|
||
target.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
jiu: true,
|
||
})
|
||
)
|
||
eff = -0.5;
|
||
else {
|
||
num = 2;
|
||
if (get.attitude(player, target) > 0) eff = -7;
|
||
else eff = -4;
|
||
}
|
||
}
|
||
if (
|
||
!player.hasSkillTag(
|
||
"directHit_ai",
|
||
true,
|
||
{
|
||
target: target,
|
||
card: card,
|
||
},
|
||
true
|
||
)
|
||
)
|
||
odds -=
|
||
0.7 *
|
||
target.mayHaveShan(
|
||
player,
|
||
"use",
|
||
target.getCards("h", (i) => {
|
||
return i.hasGaintag("sha_notshan");
|
||
}),
|
||
"odds"
|
||
);
|
||
_status.event.putTempCache("sha_result", "eff", {
|
||
bool: target.hp > num && get.attitude(player, target) > 0,
|
||
card: get.translation(card),
|
||
eff: eff,
|
||
odds: odds,
|
||
});
|
||
return odds * eff;
|
||
},
|
||
},
|
||
tag: {
|
||
respond: 1,
|
||
respondShan: 1,
|
||
damage: function (card) {
|
||
if (game.hasNature(card, "poison")) return;
|
||
return 1;
|
||
},
|
||
natureDamage: function (card) {
|
||
if (game.hasNature(card, "linked")) return 1;
|
||
},
|
||
fireDamage: function (card, nature) {
|
||
if (game.hasNature(card, "fire")) return 1;
|
||
},
|
||
thunderDamage: function (card, nature) {
|
||
if (game.hasNature(card, "thunder")) return 1;
|
||
},
|
||
poisonDamage: function (card, nature) {
|
||
if (game.hasNature(card, "poison")) return 1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
shacopy: {
|
||
ai: {
|
||
basic: {
|
||
useful: [5, 3, 1],
|
||
value: [5, 3, 1],
|
||
},
|
||
order: 3,
|
||
result: {
|
||
target: -1.5,
|
||
},
|
||
tag: {
|
||
respond: 1,
|
||
respondShan: 1,
|
||
damage: function (card) {
|
||
if (game.hasNature(card, "poison")) return;
|
||
return 1;
|
||
},
|
||
natureDamage: function (card) {
|
||
if (game.hasNature(card)) return 1;
|
||
},
|
||
fireDamage: function (card, nature) {
|
||
if (game.hasNature(card, "fire")) return 1;
|
||
},
|
||
thunderDamage: function (card, nature) {
|
||
if (game.hasNature(card, "thunder")) return 1;
|
||
},
|
||
poisonDamage: function (card, nature) {
|
||
if (game.hasNature(card, "poison")) return 1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
shan: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "basic",
|
||
cardcolor: "red",
|
||
notarget: true,
|
||
nodelay: true,
|
||
defaultYingbianEffect: "draw",
|
||
content: function () {
|
||
event.result = "shaned";
|
||
event.getParent().delayx = false;
|
||
game.delay(0.5);
|
||
},
|
||
ai: {
|
||
order: 3,
|
||
basic: {
|
||
useful: (card, i) => {
|
||
let player = _status.event.player,
|
||
basic = [7, 5.1, 2],
|
||
num = basic[Math.min(2, i)];
|
||
if (player.hp > 2 && player.hasSkillTag("maixie")) num *= 0.57;
|
||
if (
|
||
player.hasSkillTag("freeShan", false, null, true) ||
|
||
player.getEquip("rewrite_renwang")
|
||
)
|
||
num *= 0.8;
|
||
return num;
|
||
},
|
||
value: [7, 5.1, 2],
|
||
},
|
||
result: { player: 1 },
|
||
//expose:0.2
|
||
},
|
||
},
|
||
tao: {
|
||
fullskin: true,
|
||
type: "basic",
|
||
cardcolor: "red",
|
||
toself: true,
|
||
enable: function (card, player) {
|
||
return player.hp < player.maxHp;
|
||
},
|
||
savable: true,
|
||
selectTarget: -1,
|
||
filterTarget: function (card, player, target) {
|
||
return target == player && target.hp < target.maxHp;
|
||
},
|
||
modTarget: function (card, player, target) {
|
||
return target.hp < target.maxHp;
|
||
},
|
||
content: function () {
|
||
target.recover();
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: (card, player) => {
|
||
if (player.hasSkillTag("pretao")) return 9;
|
||
return 2;
|
||
},
|
||
useful: (card, i) => {
|
||
let player = _status.event.player;
|
||
if (!game.checkMod(card, player, "unchanged", "cardEnabled2", player))
|
||
return 2 / (1 + i);
|
||
let fs = game.filterPlayer((current) => {
|
||
return get.attitude(player, current) > 0 && current.hp <= 2;
|
||
}),
|
||
damaged = 0,
|
||
needs = 0;
|
||
fs.forEach((f) => {
|
||
if (f.hp > 3 || !lib.filter.cardSavable(card, player, f)) return;
|
||
if (f.hp > 1) damaged++;
|
||
else needs++;
|
||
});
|
||
if (needs && damaged) return 5 * needs + 3 * damaged;
|
||
if (needs + damaged > 1 || player.hasSkillTag("maixie")) return 8;
|
||
if (player.hp / player.maxHp < 0.7)
|
||
return 7 + Math.abs(player.hp / player.maxHp - 0.5);
|
||
if (needs) return 7;
|
||
if (damaged) return Math.max(3, 7.8 - i);
|
||
return Math.max(1, 7.2 - i);
|
||
},
|
||
value: (card, player) => {
|
||
let fs = game.filterPlayer((current) => {
|
||
return get.attitude(_status.event.player, current) > 0;
|
||
}),
|
||
damaged = 0,
|
||
needs = 0;
|
||
fs.forEach((f) => {
|
||
if (!player.canUse("tao", f)) return;
|
||
if (f.hp <= 1) needs++;
|
||
else if (f.hp == 2) damaged++;
|
||
});
|
||
if ((needs && damaged) || player.hasSkillTag("maixie"))
|
||
return Math.max(9, 5 * needs + 3 * damaged);
|
||
if (needs || damaged > 1) return 8;
|
||
if (damaged) return 7.5;
|
||
return Math.max(5, 9.2 - player.hp);
|
||
},
|
||
},
|
||
result: {
|
||
target: (player, target) => {
|
||
if (target.hasSkillTag("maixie")) return 3;
|
||
return 2;
|
||
},
|
||
target_use: (player, target, card) => {
|
||
let mode = get.mode(),
|
||
taos = player.getCards(
|
||
"hs",
|
||
(i) =>
|
||
get.name(i) === "tao" &&
|
||
lib.filter.cardEnabled(i, target, "forceEnable")
|
||
);
|
||
if (target !== _status.event.dying) {
|
||
if (
|
||
!player.isPhaseUsing() ||
|
||
player.hasSkillTag(
|
||
"nokeep",
|
||
true,
|
||
{
|
||
card: card,
|
||
target: target,
|
||
},
|
||
true
|
||
)
|
||
)
|
||
return 2;
|
||
let min = 7.2 - (4 * player.hp) / player.maxHp,
|
||
nd = player.needsToDiscard(0, (i, player) => {
|
||
return (
|
||
!player.canIgnoreHandcard(i) &&
|
||
(taos.includes(i) || get.value(i) >= min)
|
||
);
|
||
}),
|
||
keep = nd ? 0 : 2;
|
||
if (
|
||
nd > 2 ||
|
||
(taos.length > 1 && (nd > 1 || (nd && player.hp < 1 + taos.length))) ||
|
||
(target.identity === "zhu" &&
|
||
(nd || target.hp < 3) &&
|
||
(mode === "identity" || mode === "versus" || mode === "chess")) ||
|
||
!player.hasFriend()
|
||
)
|
||
return 2;
|
||
if (
|
||
game.hasPlayer((current) => {
|
||
return (
|
||
player !== current &&
|
||
current.identity === "zhu" &&
|
||
current.hp < 3 &&
|
||
(mode === "identity" || mode === "versus" || mode === "chess") &&
|
||
get.attitude(player, current) > 0
|
||
);
|
||
})
|
||
)
|
||
keep = 3;
|
||
else if (nd === 2 || player.hp < 2) return 2;
|
||
if (nd === 2 && player.hp <= 1) return 2;
|
||
if (keep === 3) return 0;
|
||
if (taos.length <= player.hp / 2) keep = 1;
|
||
if (
|
||
keep &&
|
||
game.countPlayer((current) => {
|
||
if (
|
||
player !== current &&
|
||
current.hp < 3 &&
|
||
player.hp > current.hp &&
|
||
get.attitude(player, current) > 2
|
||
) {
|
||
keep += player.hp - current.hp;
|
||
return true;
|
||
}
|
||
return false;
|
||
})
|
||
) {
|
||
if (keep > 2) return 0;
|
||
}
|
||
return 2;
|
||
}
|
||
if (target.isZhu2() || target === game.boss) return 2;
|
||
if (player !== target) {
|
||
if (target.hp < 0 && taos.length + target.hp <= 0) return 0;
|
||
if (Math.abs(get.attitude(player, target)) < 1) return 0;
|
||
}
|
||
if (!player.getFriends().length) return 2;
|
||
let tri = _status.event.getTrigger(),
|
||
num = game.countPlayer((current) => {
|
||
if (get.attitude(current, target) > 0)
|
||
return current.countCards(
|
||
"hs",
|
||
(i) =>
|
||
get.name(i) === "tao" &&
|
||
lib.filter.cardEnabled(i, target, "forceEnable")
|
||
);
|
||
}),
|
||
dis = 1,
|
||
t = _status.currentPhase || game.me;
|
||
while (t !== target) {
|
||
let att = get.attitude(player, t);
|
||
if (att < -2) dis++;
|
||
else if (att < 1) dis += 0.45;
|
||
t = t.next;
|
||
}
|
||
if (mode === "identity") {
|
||
if (tri && tri.name === "dying") {
|
||
if (target.identity === "fan") {
|
||
if (
|
||
(!tri.source && player !== target) ||
|
||
(tri.source &&
|
||
tri.source !== target &&
|
||
player.getFriends().includes(tri.source.identity))
|
||
) {
|
||
if (
|
||
num > dis ||
|
||
(player === target &&
|
||
player.countCards("hs", { type: "basic" }) > 1.6 * dis)
|
||
)
|
||
return 2;
|
||
return 0;
|
||
}
|
||
} else if (
|
||
tri.source &&
|
||
tri.source.isZhu &&
|
||
(target.identity === "zhong" || target.identity === "mingzhong") &&
|
||
(tri.source.countCards("he") > 2 ||
|
||
(player === tri.source &&
|
||
player.hasCard((i) => i.name !== "tao", "he")))
|
||
)
|
||
return 2;
|
||
//if(player!==target&&!target.isZhu&&target.countCards('hs')<dis) return 0;
|
||
}
|
||
if (player.identity === "zhu") {
|
||
if (
|
||
player.hp <= 1 &&
|
||
player !== target &&
|
||
taos + player.countCards("hs", "jiu") <=
|
||
Math.min(
|
||
dis,
|
||
game.countPlayer((current) => {
|
||
return current.identity === "fan";
|
||
})
|
||
)
|
||
)
|
||
return 0;
|
||
}
|
||
} else if (
|
||
mode === "stone" &&
|
||
target.isMin() &&
|
||
player !== target &&
|
||
tri &&
|
||
tri.name === "dying" &&
|
||
player.side === target.side &&
|
||
tri.source !== target.getEnemy()
|
||
)
|
||
return 0;
|
||
return 2;
|
||
},
|
||
},
|
||
tag: {
|
||
recover: 1,
|
||
save: 1,
|
||
},
|
||
},
|
||
},
|
||
bagua: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip2",
|
||
ai: {
|
||
basic: {
|
||
equipValue: 7.5,
|
||
},
|
||
},
|
||
skills: ["bagua_skill"],
|
||
},
|
||
jueying: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip3",
|
||
distance: { globalTo: 1 },
|
||
},
|
||
dilu: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip3",
|
||
distance: { globalTo: 1 },
|
||
},
|
||
zhuahuang: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip3",
|
||
distance: { globalTo: 1 },
|
||
},
|
||
chitu: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip4",
|
||
distance: { globalFrom: -1 },
|
||
},
|
||
dawan: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip4",
|
||
distance: { globalFrom: -1 },
|
||
},
|
||
zixin: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip4",
|
||
distance: { globalFrom: -1 },
|
||
},
|
||
zhuge: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
ai: {
|
||
order: function () {
|
||
return get.order({ name: "sha" }) - 0.1;
|
||
},
|
||
equipValue: function (card, player) {
|
||
if (player._zhuge_temp) return 1;
|
||
player._zhuge_temp = true;
|
||
var result = (function () {
|
||
if (
|
||
!game.hasPlayer(function (current) {
|
||
return (
|
||
get.distance(player, current) <= 1 &&
|
||
player.canUse("sha", current) &&
|
||
get.effect(current, { name: "sha" }, player, player) > 0
|
||
);
|
||
})
|
||
) {
|
||
return 1;
|
||
}
|
||
if (player.hasSha() && _status.currentPhase == player) {
|
||
if (
|
||
(player.getEquip("zhuge") && player.countUsed("sha")) ||
|
||
player.getCardUsable("sha") == 0
|
||
) {
|
||
return 10;
|
||
}
|
||
}
|
||
var num = player.countCards("h", "sha");
|
||
if (num > 1) return 6 + num;
|
||
return 3 + num;
|
||
})();
|
||
delete player._zhuge_temp;
|
||
return result;
|
||
},
|
||
basic: {
|
||
equipValue: 5,
|
||
},
|
||
tag: {
|
||
valueswap: 1,
|
||
},
|
||
},
|
||
skills: ["zhuge_skill"],
|
||
},
|
||
cixiong: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -1 },
|
||
ai: {
|
||
basic: {
|
||
equipValue: 2,
|
||
},
|
||
},
|
||
skills: ["cixiong_skill"],
|
||
},
|
||
qinggang: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -1 },
|
||
ai: {
|
||
basic: {
|
||
equipValue: 2,
|
||
},
|
||
},
|
||
skills: ["qinggang_skill"],
|
||
},
|
||
qinglong: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -2 },
|
||
ai: {
|
||
equipValue: function (card, player) {
|
||
return Math.min(2.5 + player.countCards("h", "sha"), 4);
|
||
},
|
||
basic: {
|
||
equipValue: 3.5,
|
||
},
|
||
},
|
||
skills: ["qinglong_skill", "qinglong_guozhan"],
|
||
},
|
||
zhangba: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -2 },
|
||
ai: {
|
||
equipValue: function (card, player) {
|
||
var num = 2.5 + player.countCards("h") / 3;
|
||
return Math.min(num, 4);
|
||
},
|
||
basic: {
|
||
equipValue: 3.5,
|
||
},
|
||
},
|
||
skills: ["zhangba_skill"],
|
||
},
|
||
guanshi: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -2 },
|
||
ai: {
|
||
equipValue: function (card, player) {
|
||
var num = 2.5 + (player.countCards("h") + player.countCards("e")) / 2.5;
|
||
return Math.min(num, 5);
|
||
},
|
||
basic: {
|
||
equipValue: 4.5,
|
||
},
|
||
},
|
||
skills: ["guanshi_skill"],
|
||
},
|
||
fangtian: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -3 },
|
||
ai: {
|
||
basic: {
|
||
equipValue: 2.5,
|
||
},
|
||
},
|
||
skills: ["fangtian_skill", "fangtian_guozhan"],
|
||
},
|
||
qilin: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -4 },
|
||
ai: {
|
||
basic: {
|
||
equipValue: 3,
|
||
},
|
||
},
|
||
skills: ["qilin_skill"],
|
||
},
|
||
wugu: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
cardcolor: "red",
|
||
selectTarget: -1,
|
||
filterTarget: true,
|
||
contentBefore: function () {
|
||
"step 0";
|
||
if (!targets.length) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
if ((card.storage && card.storage.chooseDirection) || get.is.versus()) {
|
||
player
|
||
.chooseControl("顺时针", "逆时针", function (event, player) {
|
||
if (
|
||
(get.event("isVersus") && player.next.side == player.side) ||
|
||
get.attitude(player, player.next) > get.attitude(player, player.previous)
|
||
)
|
||
return "逆时针";
|
||
return "顺时针";
|
||
})
|
||
.set("prompt", "选择" + get.translation(card) + "的结算方向")
|
||
.set("isVersus", get.is.versus());
|
||
} else {
|
||
event.goto(2);
|
||
}
|
||
"step 1";
|
||
if (result && result.control == "顺时针") {
|
||
var evt = event.getParent(),
|
||
sorter = _status.currentPhase || player;
|
||
evt.fixedSeat = true;
|
||
evt.targets.sortBySeat(sorter);
|
||
evt.targets.reverse();
|
||
if (evt.targets[evt.targets.length - 1] == sorter) {
|
||
evt.targets.unshift(evt.targets.pop());
|
||
}
|
||
}
|
||
"step 2";
|
||
ui.clear();
|
||
var cards;
|
||
if (card.storage && Array.isArray(card.storage.fixedShownCards)) {
|
||
cards = card.storage.fixedShownCards.slice();
|
||
var lose_list = [],
|
||
cards2 = [];
|
||
cards.forEach((card) => {
|
||
var owner = get.owner(card);
|
||
if (owner) {
|
||
var arr = lose_list.find((i) => i[0] == owner);
|
||
if (arr) arr[1].push(card);
|
||
else lose_list.push([owner, [card]]);
|
||
} else cards2.add(card);
|
||
});
|
||
if (lose_list.length) {
|
||
lose_list.forEach((list) => {
|
||
list[0].$throw(list[1]);
|
||
game.log(list[0], "将", list[1], "置于了处理区");
|
||
});
|
||
game.loseAsync({
|
||
lose_list: lose_list,
|
||
}).setContent("chooseToCompareLose");
|
||
}
|
||
if (cards2.length) game.cardsGotoOrdering(cards2);
|
||
game.delayex();
|
||
} else {
|
||
var num;
|
||
if (event.targets) {
|
||
num = event.targets.length;
|
||
} else {
|
||
num = game.countPlayer();
|
||
}
|
||
if (card.storage && typeof card.storage.extraCardsNum == "number")
|
||
num += card.storage.extraCardsNum;
|
||
cards = get.cards(num);
|
||
game.cardsGotoOrdering(cards).relatedEvent = event.getParent();
|
||
}
|
||
var dialog = ui.create.dialog("五谷丰登", cards, true);
|
||
_status.dieClose.push(dialog);
|
||
dialog.videoId = lib.status.videoId++;
|
||
game.addVideo("cardDialog", null, ["五谷丰登", get.cardsInfo(cards), dialog.videoId]);
|
||
event.getParent().preResult = dialog.videoId;
|
||
game.broadcast(
|
||
function (cards, id) {
|
||
var dialog = ui.create.dialog("五谷丰登", cards, true);
|
||
_status.dieClose.push(dialog);
|
||
dialog.videoId = id;
|
||
},
|
||
cards,
|
||
dialog.videoId
|
||
);
|
||
game.log(event.card, "亮出了", cards);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
for (var i = 0; i < ui.dialogs.length; i++) {
|
||
if (ui.dialogs[i].videoId == event.preResult) {
|
||
event.dialog = ui.dialogs[i];
|
||
break;
|
||
}
|
||
}
|
||
if (!event.dialog || event.dialog.buttons.length == 0) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
if (event.dialog.buttons.length > 1) {
|
||
var next = target.chooseButton(true, function (button) {
|
||
return get.value(button.link, _status.event.player);
|
||
});
|
||
next.set("dialog", event.preResult);
|
||
next.set("closeDialog", false);
|
||
next.set("dialogdisplay", true);
|
||
} else {
|
||
event.directButton = event.dialog.buttons[0];
|
||
}
|
||
"step 1";
|
||
var dialog = event.dialog;
|
||
var card;
|
||
if (event.directButton) {
|
||
card = event.directButton.link;
|
||
} else {
|
||
for (var i of dialog.buttons) {
|
||
if (i.link == result.links[0]) {
|
||
card = i.link;
|
||
break;
|
||
}
|
||
}
|
||
if (!card) card = event.dialog.buttons[0].link;
|
||
}
|
||
var button;
|
||
for (var i = 0; i < dialog.buttons.length; i++) {
|
||
if (dialog.buttons[i].link == card) {
|
||
button = dialog.buttons[i];
|
||
button.querySelector(".info").innerHTML = (function (target) {
|
||
if (target._tempTranslate) return target._tempTranslate;
|
||
var name = target.name;
|
||
if (lib.translate[name + "_ab"]) return lib.translate[name + "_ab"];
|
||
return get.translation(name);
|
||
})(target);
|
||
dialog.buttons.remove(button);
|
||
break;
|
||
}
|
||
}
|
||
var capt = get.translation(target) + "选择了" + get.translation(button.link);
|
||
if (card) {
|
||
target.gain(card, "visible");
|
||
target.$gain2(card);
|
||
game.broadcast(
|
||
function (card, id, name, capt) {
|
||
var dialog = get.idDialog(id);
|
||
if (dialog) {
|
||
dialog.content.firstChild.innerHTML = capt;
|
||
for (var i = 0; i < dialog.buttons.length; i++) {
|
||
if (dialog.buttons[i].link == card) {
|
||
dialog.buttons[i].querySelector(".info").innerHTML = name;
|
||
dialog.buttons.splice(i--, 1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
card,
|
||
dialog.videoId,
|
||
(function (target) {
|
||
if (target._tempTranslate) return target._tempTranslate;
|
||
var name = target.name;
|
||
if (lib.translate[name + "_ab"]) return lib.translate[name + "_ab"];
|
||
return get.translation(name);
|
||
})(target),
|
||
capt
|
||
);
|
||
}
|
||
dialog.content.firstChild.innerHTML = capt;
|
||
game.addVideo("dialogCapt", null, [dialog.videoId, dialog.content.firstChild.innerHTML]);
|
||
game.log(target, "选择了", button.link);
|
||
game.delay();
|
||
},
|
||
contentAfter: function () {
|
||
for (var i = 0; i < ui.dialogs.length; i++) {
|
||
if (ui.dialogs[i].videoId == event.preResult) {
|
||
var dialog = ui.dialogs[i];
|
||
dialog.close();
|
||
_status.dieClose.remove(dialog);
|
||
if (dialog.buttons.length) {
|
||
event.remained = [];
|
||
for (var i = 0; i < dialog.buttons.length; i++) {
|
||
event.remained.push(dialog.buttons[i].link);
|
||
}
|
||
event.trigger("wuguRemained");
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
game.broadcast(function (id) {
|
||
var dialog = get.idDialog(id);
|
||
if (dialog) {
|
||
dialog.close();
|
||
_status.dieClose.remove(dialog);
|
||
}
|
||
}, event.preResult);
|
||
game.addVideo("cardDialog", null, event.preResult);
|
||
},
|
||
ai: {
|
||
wuxie: function () {
|
||
if (Math.random() < 0.5) return 0;
|
||
},
|
||
basic: {
|
||
order: 3,
|
||
useful: 0.5,
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
var sorter = _status.currentPhase || player;
|
||
if (get.is.versus()) {
|
||
if (target == sorter) return 1.5;
|
||
return 1;
|
||
}
|
||
if (player.hasUnknown(2)) {
|
||
return 0;
|
||
}
|
||
return (1 - get.distance(sorter, target, "absolute") / game.countPlayer()) *
|
||
get.attitude(player, target) >
|
||
0
|
||
? 0.5
|
||
: 0.7;
|
||
},
|
||
},
|
||
tag: {
|
||
draw: 1,
|
||
multitarget: 1,
|
||
},
|
||
},
|
||
},
|
||
taoyuan: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
selectTarget: -1,
|
||
cardcolor: "red",
|
||
reverseOrder: true,
|
||
defaultYingbianEffect: "remove",
|
||
filterTarget: function (card, player, target) {
|
||
//return target.hp<target.maxHp;
|
||
return true;
|
||
},
|
||
ignoreTarget: function (card, player, target) {
|
||
return target.isHealthy();
|
||
},
|
||
content: function () {
|
||
target.recover();
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: (item, player) => {
|
||
if (
|
||
game.hasPlayer(
|
||
(current) =>
|
||
current.hp <= 1 &&
|
||
get.recoverEffect(current, player, _status.event.player) < 0
|
||
)
|
||
)
|
||
return 1;
|
||
return 10;
|
||
},
|
||
useful: [3, 1],
|
||
value: 0,
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
return target.hp < target.maxHp ? 2 : 0;
|
||
},
|
||
},
|
||
tag: {
|
||
recover: 0.5,
|
||
multitarget: 1,
|
||
},
|
||
},
|
||
},
|
||
nanman: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
selectTarget: -1,
|
||
defaultYingbianEffect: "remove",
|
||
filterTarget: function (card, player, target) {
|
||
return target != player;
|
||
},
|
||
reverseOrder: true,
|
||
content: function () {
|
||
"step 0";
|
||
if (typeof event.shaRequired != "number" || !event.shaRequired || event.shaRequired < 0)
|
||
event.shaRequired = 1;
|
||
if (typeof event.baseDamage != "number") event.baseDamage = 1;
|
||
"step 1";
|
||
if (event.directHit) event._result = { bool: false };
|
||
else {
|
||
var next = target.chooseToRespond({ name: "sha" });
|
||
if (event.shaRequired > 1) {
|
||
next.set("prompt2", "共需打出" + event.shaRequired + "张杀");
|
||
}
|
||
next.set("ai", function (card) {
|
||
var evt = _status.event.getParent();
|
||
if (get.damageEffect(evt.target, evt.player, evt.target) >= 0) return 0;
|
||
if (evt.player.hasSkillTag("notricksource")) return 0;
|
||
if (evt.target.hasSkillTag("notrick")) return 0;
|
||
return get.order(card);
|
||
});
|
||
next.autochoose = lib.filter.autoRespondSha;
|
||
}
|
||
"step 2";
|
||
if (result.bool == false) {
|
||
target.damage();
|
||
} else {
|
||
event.shaRequired--;
|
||
if (event.shaRequired > 0) event.goto(1);
|
||
}
|
||
},
|
||
ai: {
|
||
wuxie(target, card, player, viewer, status) {
|
||
let att = get.attitude(viewer, target),
|
||
eff = get.effect(target, card, player, target);
|
||
if (Math.abs(att) < 1 || status * eff * att >= 0) return 0;
|
||
let evt = _status.event.getParent("useCard"),
|
||
pri = 1,
|
||
bonus = player.hasSkillTag("damageBonus", true, {
|
||
target: target,
|
||
card: card,
|
||
}),
|
||
damage = 1,
|
||
isZhu = function (tar) {
|
||
return (
|
||
tar.isZhu ||
|
||
tar === game.boss ||
|
||
tar === game.trueZhu ||
|
||
tar === game.falseZhu
|
||
);
|
||
},
|
||
canSha = function (tar, blur) {
|
||
let known = tar.getKnownCards(viewer);
|
||
if (!blur)
|
||
return known.some((card) => {
|
||
let name = get.name(card, tar);
|
||
return (
|
||
(name === "sha" || name === "hufu" || name === "yuchanqian") &&
|
||
lib.filter.cardRespondable(card, tar)
|
||
);
|
||
});
|
||
if (
|
||
tar.countCards("hs", (i) => !known.includes(i)) >
|
||
4.67 - (2 * tar.hp) / tar.maxHp
|
||
)
|
||
return true;
|
||
if (!tar.hasSkillTag("respondSha", true, "respond", true)) return false;
|
||
if (tar.hp <= damage) return false;
|
||
if (tar.hp <= damage + 1) return isZhu(tar);
|
||
return true;
|
||
},
|
||
self = false;
|
||
if (canSha(target)) return 0;
|
||
if (
|
||
bonus &&
|
||
!viewer.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
})
|
||
)
|
||
damage = 2;
|
||
if (
|
||
(viewer.hp <= damage || (viewer.hp <= damage + 1 && isZhu(viewer))) &&
|
||
!canSha(viewer)
|
||
) {
|
||
if (viewer === target) return status;
|
||
let fv = true;
|
||
if (evt && evt.targets)
|
||
for (let i of evt.targets) {
|
||
if (fv) {
|
||
if (target === i) fv = false;
|
||
continue;
|
||
}
|
||
if (viewer == i) {
|
||
if (isZhu(viewer)) return 0;
|
||
self = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
let maySha = canSha(target, true);
|
||
if (
|
||
bonus &&
|
||
!target.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
})
|
||
)
|
||
damage = 2;
|
||
else damage = 1;
|
||
if (isZhu(target)) {
|
||
if (eff < 0) {
|
||
if (target.hp <= damage + 1 || (!maySha && target.hp <= damage + 2)) return 1;
|
||
if (maySha && target.hp > damage + 2) return 0;
|
||
else if (maySha || target.hp > damage + 2) pri = 3;
|
||
else pri = 4;
|
||
} else if (target.hp > damage + 1) pri = 2;
|
||
else return 0;
|
||
} else if (self) return 0;
|
||
else if (eff < 0) {
|
||
if (!maySha && target.hp <= damage) pri = 5;
|
||
else if (maySha) return 0;
|
||
else if (target.hp > damage + 1) pri = 2;
|
||
else if (target.hp === damage + 1) pri = 3;
|
||
else pri = 4;
|
||
} else if (target.hp <= damage) return 0;
|
||
let find = false;
|
||
if (evt && evt.targets)
|
||
for (let i = 0; i < evt.targets.length; i++) {
|
||
if (!find) {
|
||
if (evt.targets[i] === target) find = true;
|
||
continue;
|
||
}
|
||
let att1 = get.attitude(viewer, evt.targets[i]),
|
||
eff1 = get.effect(evt.targets[i], card, player, evt.targets[i]),
|
||
temp = 1;
|
||
if (Math.abs(att1) < 1 || att1 * eff1 >= 0 || canSha(evt.targets[i]))
|
||
continue;
|
||
maySha = canSha(evt.targets[i], true);
|
||
if (
|
||
bonus &&
|
||
!evt.targets[i].hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
})
|
||
)
|
||
damage = 2;
|
||
else damage = 1;
|
||
if (isZhu(evt.targets[i])) {
|
||
if (eff1 < 0) {
|
||
if (
|
||
evt.targets[i].hp <= damage + 1 ||
|
||
(!maySha && evt.targets[i].hp <= damage + 2)
|
||
)
|
||
return 0;
|
||
if (maySha && evt.targets[i].hp > damage + 2) continue;
|
||
if (maySha || evt.targets[i].hp > damage + 2) temp = 3;
|
||
else temp = 4;
|
||
} else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
else continue;
|
||
} else if (eff1 < 0) {
|
||
if (!maySha && evt.targets[i].hp <= damage) temp = 5;
|
||
else if (maySha) continue;
|
||
else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
else if (evt.targets[i].hp === damage + 1) temp = 3;
|
||
else temp = 4;
|
||
} else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
if (temp > pri) return 0;
|
||
}
|
||
return 1;
|
||
},
|
||
basic: {
|
||
order: 9,
|
||
useful: [5, 1],
|
||
value: 5,
|
||
},
|
||
result: {
|
||
player(player, target) {
|
||
if (player._nanman_temp || player.hasSkillTag("jueqing", false, target)) return 0;
|
||
player._nanman_temp = true;
|
||
let eff = get.effect(
|
||
target,
|
||
new lib.element.VCard({ name: "nanman" }),
|
||
player,
|
||
target
|
||
);
|
||
delete player._nanman_temp;
|
||
if (eff >= 0) return 0;
|
||
if (
|
||
target.hp > 2 ||
|
||
(target.hp > 1 &&
|
||
!target.isZhu &&
|
||
target != game.boss &&
|
||
target != game.trueZhu &&
|
||
target != game.falseZhu)
|
||
)
|
||
return 0;
|
||
if (target.hp > 1 && target.hasSkillTag("respondSha", true, "respond", true))
|
||
return 0;
|
||
let known = target.getKnownCards(player);
|
||
if (
|
||
known.some((card) => {
|
||
let name = get.name(card, target);
|
||
if (name === "sha" || name === "hufu" || name === "yuchanqian")
|
||
return lib.filter.cardRespondable(card, target);
|
||
if (name === "wuxie")
|
||
return lib.filter.cardEnabled(card, target, "forceEnable");
|
||
})
|
||
)
|
||
return 0;
|
||
if (
|
||
target.hp > 1 ||
|
||
target.countCards("hs", (i) => !known.includes(i)) >
|
||
4.67 - (2 * target.hp) / target.maxHp
|
||
)
|
||
return 0;
|
||
let res = 0,
|
||
att = get.sgnAttitude(player, target);
|
||
res -= att * (0.8 * target.countCards("hs") + 0.6 * target.countCards("e") + 3.6);
|
||
if (get.mode() === "identity" && target.identity === "fan") res += 2.4;
|
||
if (
|
||
(get.mode() === "guozhan" &&
|
||
player.identity !== "ye" &&
|
||
player.identity === target.identity) ||
|
||
(get.mode() === "identity" &&
|
||
player.identity === "zhu" &&
|
||
(target.identity === "zhong" || target.identity === "mingzhong"))
|
||
)
|
||
res -= 0.8 * player.countCards("he");
|
||
return res;
|
||
},
|
||
target(player, target) {
|
||
let zhu =
|
||
(get.mode() === "identity" && target.isZhu) || target.identity === "zhu";
|
||
if (!lib.filter.cardRespondable({ name: "sha" }, target)) {
|
||
if (zhu) {
|
||
if (target.hp < 2) return -99;
|
||
if (target.hp === 2) return -3.6;
|
||
}
|
||
return -2;
|
||
}
|
||
let known = target.getKnownCards(player);
|
||
if (
|
||
known.some((card) => {
|
||
let name = get.name(card, target);
|
||
if (name === "sha" || name === "hufu" || name === "yuchanqian")
|
||
return lib.filter.cardRespondable(card, target);
|
||
if (name === "wuxie")
|
||
return lib.filter.cardEnabled(card, target, "forceEnable");
|
||
})
|
||
)
|
||
return -1.2;
|
||
let nh = target.countCards("hs", (i) => !known.includes(i));
|
||
if (zhu && target.hp <= 1) {
|
||
if (nh === 0) return -99;
|
||
if (nh === 1) return -60;
|
||
if (nh === 2) return -36;
|
||
if (nh === 3) return -12;
|
||
if (nh === 4) return -8;
|
||
return -5;
|
||
}
|
||
if (target.hasSkillTag("respondSha", true, "respond", true)) return -1.35;
|
||
if (!nh) return -2;
|
||
if (nh === 1) return -1.8;
|
||
return -1.5;
|
||
},
|
||
},
|
||
tag: {
|
||
respond: 1,
|
||
respondSha: 1,
|
||
damage: 1,
|
||
multitarget: 1,
|
||
multineg: 1,
|
||
},
|
||
},
|
||
},
|
||
wanjian: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
selectTarget: -1,
|
||
reverseOrder: true,
|
||
defaultYingbianEffect: "remove",
|
||
filterTarget: function (card, player, target) {
|
||
return target != player;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (
|
||
typeof event.shanRequired != "number" ||
|
||
!event.shanRequired ||
|
||
event.shanRequired < 0
|
||
)
|
||
event.shanRequired = 1;
|
||
if (typeof event.baseDamage != "number") event.baseDamage = 1;
|
||
"step 1";
|
||
if (event.directHit) event._result = { bool: false };
|
||
else {
|
||
var next = target.chooseToRespond({ name: "shan" });
|
||
if (event.shanRequired > 1) {
|
||
next.set("prompt2", "共需打出" + event.shanRequired + "张闪");
|
||
}
|
||
next.set("ai", function (card) {
|
||
var evt = _status.event.getParent();
|
||
if (get.damageEffect(evt.target, evt.player, evt.target) >= 0) return 0;
|
||
if (evt.player.hasSkillTag("notricksource")) return 0;
|
||
if (evt.target.hasSkillTag("notrick")) return 0;
|
||
if (evt.target.hasSkillTag("noShan")) {
|
||
return -1;
|
||
}
|
||
return get.order(card);
|
||
});
|
||
next.autochoose = lib.filter.autoRespondShan;
|
||
}
|
||
"step 2";
|
||
if (result.bool == false) {
|
||
target.damage();
|
||
} else {
|
||
event.shanRequired--;
|
||
if (event.shanRequired > 0) event.goto(1);
|
||
}
|
||
},
|
||
ai: {
|
||
wuxie(target, card, player, viewer, status) {
|
||
let att = get.attitude(viewer, target),
|
||
eff = get.effect(target, card, player, target);
|
||
if (Math.abs(att) < 1 || status * eff * att >= 0) return 0;
|
||
let evt = _status.event.getParent("useCard"),
|
||
pri = 1,
|
||
bonus = player.hasSkillTag("damageBonus", true, {
|
||
target: target,
|
||
card: card,
|
||
}),
|
||
damage = 1,
|
||
isZhu = function (tar) {
|
||
return (
|
||
tar.isZhu ||
|
||
tar === game.boss ||
|
||
tar === game.trueZhu ||
|
||
tar === game.falseZhu
|
||
);
|
||
},
|
||
canShan = function (tar, blur) {
|
||
let known = tar.getKnownCards(viewer);
|
||
if (!blur)
|
||
return known.some((card) => {
|
||
let name = get.name(card, tar);
|
||
return (
|
||
(name === "shan" || name === "hufu") &&
|
||
lib.filter.cardRespondable(card, tar)
|
||
);
|
||
});
|
||
if (
|
||
tar.countCards("hs", (i) => !known.includes(i)) >
|
||
3.67 - (2 * tar.hp) / tar.maxHp
|
||
)
|
||
return true;
|
||
if (!tar.hasSkillTag("respondShan", true, "respond", true)) return false;
|
||
if (tar.hp <= damage) return false;
|
||
if (tar.hp <= damage + 1) return isZhu(tar);
|
||
return true;
|
||
},
|
||
self = false;
|
||
if (canShan(target)) return 0;
|
||
if (
|
||
bonus &&
|
||
!viewer.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
})
|
||
)
|
||
damage = 2;
|
||
if (
|
||
(viewer.hp <= damage || (viewer.hp <= damage + 1 && isZhu(viewer))) &&
|
||
!canShan(viewer)
|
||
) {
|
||
if (viewer === target) return status;
|
||
let fv = true;
|
||
if (evt && evt.targets)
|
||
for (let i of evt.targets) {
|
||
if (fv) {
|
||
if (target === i) fv = false;
|
||
continue;
|
||
}
|
||
if (viewer == i) {
|
||
if (isZhu(viewer)) return 0;
|
||
self = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
let mayShan = canShan(target, true);
|
||
if (
|
||
bonus &&
|
||
!target.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
})
|
||
)
|
||
damage = 2;
|
||
else damage = 1;
|
||
if (isZhu(target)) {
|
||
if (eff < 0) {
|
||
if (target.hp <= damage + 1 || (!mayShan && target.hp <= damage + 2))
|
||
return 1;
|
||
if (mayShan && target.hp > damage + 2) return 0;
|
||
else if (mayShan || target.hp > damage + 2) pri = 3;
|
||
else pri = 4;
|
||
} else if (target.hp > damage + 1) pri = 2;
|
||
else return 0;
|
||
} else if (self) return 0;
|
||
else if (eff < 0) {
|
||
if (!mayShan && target.hp <= damage) pri = 5;
|
||
else if (mayShan) return 0;
|
||
else if (target.hp > damage + 1) pri = 2;
|
||
else if (target.hp === damage + 1) pri = 3;
|
||
else pri = 4;
|
||
} else if (target.hp <= damage) return 0;
|
||
let find = false;
|
||
if (evt && evt.targets)
|
||
for (let i = 0; i < evt.targets.length; i++) {
|
||
if (!find) {
|
||
if (evt.targets[i] === target) find = true;
|
||
continue;
|
||
}
|
||
let att1 = get.attitude(viewer, evt.targets[i]),
|
||
eff1 = get.effect(evt.targets[i], card, player, evt.targets[i]),
|
||
temp = 1;
|
||
if (Math.abs(att1) < 1 || att1 * eff1 >= 0 || canShan(evt.targets[i]))
|
||
continue;
|
||
mayShan = canShan(evt.targets[i], true);
|
||
if (
|
||
bonus &&
|
||
!evt.targets[i].hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
})
|
||
)
|
||
damage = 2;
|
||
else damage = 1;
|
||
if (isZhu(evt.targets[i])) {
|
||
if (eff1 < 0) {
|
||
if (
|
||
evt.targets[i].hp <= damage + 1 ||
|
||
(!mayShan && evt.targets[i].hp <= damage + 2)
|
||
)
|
||
return 0;
|
||
if (mayShan && evt.targets[i].hp > damage + 2) continue;
|
||
if (mayShan || evt.targets[i].hp > damage + 2) temp = 3;
|
||
else temp = 4;
|
||
} else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
else continue;
|
||
} else if (eff1 < 0) {
|
||
if (!mayShan && evt.targets[i].hp <= damage) temp = 5;
|
||
else if (mayShan) continue;
|
||
else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
else if (evt.targets[i].hp === damage + 1) temp = 3;
|
||
else temp = 4;
|
||
} else if (evt.targets[i].hp > damage + 1) temp = 2;
|
||
if (temp > pri) return 0;
|
||
}
|
||
return 1;
|
||
},
|
||
basic: {
|
||
order: 9,
|
||
useful: 1,
|
||
value: 5,
|
||
},
|
||
result: {
|
||
player(player, target) {
|
||
if (player._wanjian_temp || player.hasSkillTag("jueqing", false, target))
|
||
return 0;
|
||
player._wanjian_temp = true;
|
||
let eff = get.effect(
|
||
target,
|
||
new lib.element.VCard({ name: "wanjian" }),
|
||
player,
|
||
target
|
||
);
|
||
delete player._wanjian_temp;
|
||
if (eff >= 0) return 0;
|
||
if (
|
||
target.hp > 2 ||
|
||
(target.hp > 1 &&
|
||
!target.isZhu &&
|
||
target != game.boss &&
|
||
target != game.trueZhu &&
|
||
target != game.falseZhu)
|
||
)
|
||
return 0;
|
||
if (target.hp > 1 && target.hasSkillTag("respondShan", true, "respond", true))
|
||
return 0;
|
||
let known = target.getKnownCards(player);
|
||
if (
|
||
known.some((card) => {
|
||
let name = get.name(card, target);
|
||
if (name === "shan" || name === "hufu")
|
||
return lib.filter.cardRespondable(card, target);
|
||
if (name === "wuxie")
|
||
return lib.filter.cardEnabled(card, target, "forceEnable");
|
||
})
|
||
)
|
||
return 0;
|
||
if (
|
||
target.hp > 1 ||
|
||
target.countCards("hs", (i) => !known.includes(i)) >
|
||
3.67 - (2 * target.hp) / target.maxHp
|
||
)
|
||
return 0;
|
||
let res = 0,
|
||
att = get.sgnAttitude(player, target);
|
||
res -= att * (0.8 * target.countCards("hs") + 0.6 * target.countCards("e") + 3.6);
|
||
if (get.mode() === "identity" && target.identity === "fan") res += 2.4;
|
||
if (
|
||
(get.mode() === "guozhan" &&
|
||
player.identity !== "ye" &&
|
||
player.identity === target.identity) ||
|
||
(get.mode() === "identity" &&
|
||
player.identity === "zhu" &&
|
||
(target.identity === "zhong" || target.identity === "mingzhong"))
|
||
)
|
||
res -= 0.8 * player.countCards("he");
|
||
return res;
|
||
},
|
||
target(player, target) {
|
||
let zhu =
|
||
(get.mode() === "identity" && target.isZhu) || target.identity === "zhu";
|
||
if (!lib.filter.cardRespondable({ name: "shan" }, target)) {
|
||
if (zhu) {
|
||
if (target.hp < 2) return -99;
|
||
if (target.hp === 2) return -3.6;
|
||
}
|
||
return -2;
|
||
}
|
||
let known = target.getKnownCards(player);
|
||
if (
|
||
known.some((card) => {
|
||
let name = get.name(card, target);
|
||
if (name === "shan" || name === "hufu")
|
||
return lib.filter.cardRespondable(card, target);
|
||
if (name === "wuxie")
|
||
return lib.filter.cardEnabled(card, target, "forceEnable");
|
||
})
|
||
)
|
||
return -1.2;
|
||
let nh = target.countCards("hs", (i) => !known.includes(i));
|
||
if (zhu && target.hp <= 1) {
|
||
if (nh === 0) return -99;
|
||
if (nh === 1) return -60;
|
||
if (nh === 2) return -36;
|
||
if (nh === 3) return -8;
|
||
return -5;
|
||
}
|
||
if (target.hasSkillTag("respondShan", true, "respond", true)) return -1.35;
|
||
if (!nh) return -2;
|
||
if (nh === 1) return -1.65;
|
||
return -1.5;
|
||
},
|
||
},
|
||
tag: {
|
||
respond: 1,
|
||
respondShan: 1,
|
||
damage: 1,
|
||
multitarget: 1,
|
||
multineg: 1,
|
||
},
|
||
},
|
||
},
|
||
wuzhong: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
selectTarget: -1,
|
||
cardcolor: "red",
|
||
toself: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target == player;
|
||
},
|
||
modTarget: true,
|
||
content: function () {
|
||
if (get.is.versus()) {
|
||
if (game.friend.includes(target)) {
|
||
if (game.friend.length < game.enemy.length) {
|
||
target.draw(3);
|
||
return;
|
||
}
|
||
} else {
|
||
if (game.friend.length > game.enemy.length) {
|
||
target.draw(3);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
target.draw(2);
|
||
},
|
||
ai: {
|
||
wuxie: function (target, card, player, viewer) {
|
||
if (get.mode() == "guozhan") {
|
||
if (!_status._aozhan) {
|
||
if (!player.isMajor()) {
|
||
if (!viewer.isMajor()) return 0;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
basic: {
|
||
order: 7.2,
|
||
useful: 4.5,
|
||
value: 9.2,
|
||
},
|
||
result: {
|
||
target: 2,
|
||
},
|
||
tag: {
|
||
draw: 2,
|
||
},
|
||
},
|
||
},
|
||
juedou: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
defaultYingbianEffect: "hit",
|
||
filterTarget: function (card, player, target) {
|
||
return target != player;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (event.turn == undefined) event.turn = target;
|
||
if (typeof event.baseDamage != "number") event.baseDamage = 1;
|
||
if (typeof event.extraDamage != "number") {
|
||
event.extraDamage = 0;
|
||
}
|
||
if (!event.shaReq) event.shaReq = {};
|
||
if (typeof event.shaReq[player.playerid] != "number") event.shaReq[player.playerid] = 1;
|
||
if (typeof event.shaReq[target.playerid] != "number") event.shaReq[target.playerid] = 1;
|
||
event.playerCards = [];
|
||
event.targetCards = [];
|
||
"step 1";
|
||
event.trigger("juedou");
|
||
event.shaRequired = event.shaReq[event.turn.playerid];
|
||
"step 2";
|
||
if (event.directHit) {
|
||
event._result = { bool: false };
|
||
} else {
|
||
var next = event.turn.chooseToRespond({ name: "sha" });
|
||
if (event.shaRequired > 1)
|
||
next.set("prompt2", "共需打出" + event.shaRequired + "张杀");
|
||
next.set("ai", function (card) {
|
||
let event = _status.event,
|
||
player = event.splayer,
|
||
target = event.starget;
|
||
if (player.hasSkillTag("notricksource") || target.hasSkillTag("notrick"))
|
||
return 0;
|
||
if (event.shaRequired > 1 && player.countCards("h", "sha") < event.shaRequired)
|
||
return 0;
|
||
if (event.player === target) {
|
||
if (_status.event.tdamage >= 0 || player.hasSkill("naman")) return -1;
|
||
if (
|
||
get.attitude(target, player) <= 0 ||
|
||
(event.player.hp <= 1 && _status.event.tdamage < _status.event.pdamage)
|
||
) {
|
||
return get.order(card);
|
||
}
|
||
return -1;
|
||
} else {
|
||
if (_status.event.pdamage >= 0 || target.hasSkill("naman")) return -1;
|
||
if (
|
||
get.attitude(player, target) <= 0 ||
|
||
(event.player.hp <= 1 && _status.event.tdamage > _status.event.pdamage)
|
||
) {
|
||
return get.order(card);
|
||
}
|
||
return -1;
|
||
}
|
||
});
|
||
next.set("splayer", player);
|
||
next.set("starget", target);
|
||
next.set("pdamage", get.damageEffect(player, target, event.turn));
|
||
next.set("tdamage", get.damageEffect(target, player, event.turn));
|
||
next.set("shaRequired", event.shaRequired);
|
||
next.autochoose = lib.filter.autoRespondSha;
|
||
if (event.turn == target) {
|
||
next.source = player;
|
||
} else {
|
||
next.source = target;
|
||
}
|
||
}
|
||
"step 3";
|
||
if (result.bool) {
|
||
event.shaRequired--;
|
||
if (event.turn == target) {
|
||
if (result.cards) event.targetCards.addArray(result.cards);
|
||
if (event.shaRequired > 0) event.goto(2);
|
||
else {
|
||
event.turn = player;
|
||
event.goto(1);
|
||
}
|
||
} else {
|
||
if (result.cards) event.playerCards.addArray(result.cards);
|
||
if (event.shaRequired > 0) event.goto(2);
|
||
else {
|
||
event.turn = target;
|
||
event.goto(1);
|
||
}
|
||
}
|
||
} else {
|
||
if (event.turn == target) {
|
||
target.damage();
|
||
} else {
|
||
player.damage(target);
|
||
}
|
||
}
|
||
event._result = {};
|
||
},
|
||
ai: {
|
||
wuxie: function (target, card, player, viewer, status) {
|
||
if (player === game.me && get.attitude(viewer, player._trueMe || player) > 0)
|
||
return 0;
|
||
if (
|
||
status *
|
||
get.attitude(viewer, target) *
|
||
get.effect(target, card, player, target) >=
|
||
0
|
||
)
|
||
return 0;
|
||
},
|
||
basic: {
|
||
order: 5,
|
||
useful: 1,
|
||
value: 5.5,
|
||
},
|
||
result: {
|
||
player(player, target, card) {
|
||
if (
|
||
player.hasSkillTag(
|
||
"directHit_ai",
|
||
true,
|
||
{
|
||
target: target,
|
||
card: card,
|
||
},
|
||
true
|
||
)
|
||
)
|
||
return 0;
|
||
if (get.damageEffect(target, player, target) >= 0) return 0;
|
||
let pd = get.damageEffect(player, target, player),
|
||
att = get.attitude(player, target);
|
||
if (att > 0 && get.damageEffect(target, player, player) > pd) return 0;
|
||
let ts = target.mayHaveSha(player, "respond", null, "count"),
|
||
ps = player.mayHaveSha(
|
||
player,
|
||
"respond",
|
||
player.getCards("h", (i) => {
|
||
return (
|
||
card === i ||
|
||
(card.cards && card.cards.includes(i)) ||
|
||
ui.selected.cards.includes(i)
|
||
);
|
||
}),
|
||
"count"
|
||
);
|
||
if (ts < 1 && ts << 3 < Math.pow(player.hp, 2)) return 0;
|
||
if (att > 0) {
|
||
if (ts < 1) return 0;
|
||
return -2;
|
||
}
|
||
if (ts - ps + Math.exp(0.8 - player.hp) < 1) return -ts;
|
||
if (pd >= 0) return pd / get.attitude(player, player);
|
||
return -2 - ts;
|
||
},
|
||
target(player, target, card) {
|
||
if (
|
||
player.hasSkillTag(
|
||
"directHit_ai",
|
||
true,
|
||
{
|
||
target: target,
|
||
card: card,
|
||
},
|
||
true
|
||
)
|
||
)
|
||
return -2;
|
||
let td = get.damageEffect(target, player, target);
|
||
if (td >= 0) return td / get.attitude(target, target);
|
||
let pd = get.damageEffect(player, target, player),
|
||
att = get.attitude(player, target);
|
||
if (att > 0 && get.damageEffect(target, player, player) > pd) return -2;
|
||
let ts = target.mayHaveSha(player, "respond", null, "count"),
|
||
ps = player.mayHaveSha(
|
||
player,
|
||
"respond",
|
||
player.getCards("h", (i) => {
|
||
return (
|
||
card === i ||
|
||
(card.cards && card.cards.includes(i)) ||
|
||
ui.selected.cards.includes(i)
|
||
);
|
||
}),
|
||
"count"
|
||
);
|
||
if (ts < 1) return -1.5;
|
||
if (att > 0) return -2;
|
||
if (ts - ps < 1) return -2 - ts;
|
||
if (pd >= 0) return -1;
|
||
return -ts;
|
||
},
|
||
},
|
||
tag: {
|
||
respond: 2,
|
||
respondSha: 2,
|
||
damage: 1,
|
||
},
|
||
},
|
||
},
|
||
shunshou: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
range: { global: 1 },
|
||
selectTarget: 1,
|
||
postAi: function (targets) {
|
||
return targets.length == 1 && targets[0].countCards("j");
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
if (player == target) return false;
|
||
return target.hasCard(
|
||
(card) => lib.filter.canBeGained(card, player, target),
|
||
get.is.single() ? "he" : "hej"
|
||
);
|
||
},
|
||
content: function () {
|
||
let pos = get.is.single() ? "he" : "hej";
|
||
if (target.countGainableCards(player, pos))
|
||
player
|
||
.gainPlayerCard(pos, target, true)
|
||
.set("target", target)
|
||
.set("complexSelect", false)
|
||
.set("ai", lib.card.shunshou.ai.button);
|
||
},
|
||
ai: {
|
||
wuxie: function (target, card, player, viewer) {
|
||
if (get.attitude(viewer, player._trueMe || player) > 0) return 0;
|
||
},
|
||
basic: {
|
||
order: 7.5,
|
||
useful: (card, i) => 8 / (3 + i),
|
||
value: (card, player) => {
|
||
let max = 0;
|
||
game.countPlayer((cur) => {
|
||
max = Math.max(
|
||
max,
|
||
lib.card.shunshou.ai.result.target(player, cur) *
|
||
get.attitude(player, cur)
|
||
);
|
||
});
|
||
if (max <= 0) return 2;
|
||
return 0.53 * max;
|
||
},
|
||
},
|
||
button: (button) => {
|
||
let player = _status.event.player,
|
||
target = _status.event.target;
|
||
if (!lib.filter.canBeGained(button.link, player, target)) return 0;
|
||
let att = get.attitude(player, target),
|
||
val = get.value(button.link, player) / 60,
|
||
btv = get.buttonValue(button),
|
||
pos = get.position(button.link),
|
||
name = get.name(button.link);
|
||
if (pos == "j") {
|
||
if (name == "lebu") {
|
||
let needs = target.needsToDiscard(2);
|
||
btv *= 1.08 + 0.2 * needs;
|
||
} else if (name == "shandian" || name == "fulei" || name == "plague") btv /= 2;
|
||
}
|
||
if (get.attitude(player, get.owner(button.link)) > 0) btv = -btv;
|
||
if (pos != "e") {
|
||
if (pos == "h" && !player.hasSkillTag("viewHandcard", null, target, true))
|
||
return btv + 0.1;
|
||
return btv + val;
|
||
}
|
||
let sub = get.subtype(button.link);
|
||
if (sub == "equip1") return (btv * Math.min(3.6, target.hp)) / 3;
|
||
if (sub == "equip2") {
|
||
if (name == "baiyin" && pos == "e" && target.isDamaged()) {
|
||
let by = 3 - 0.6 * Math.min(5, target.hp);
|
||
return get.sgn(get.recoverEffect(target, player, player)) * by;
|
||
}
|
||
return 1.57 * btv + val;
|
||
}
|
||
if (
|
||
att <= 0 &&
|
||
(sub == "equip3" || sub == "equip4") &&
|
||
(player.hasSkill("shouli") || player.hasSkill("psshouli"))
|
||
)
|
||
return 0;
|
||
if (
|
||
sub == "equip3" &&
|
||
!game.hasPlayer((cur) => !cur.inRange(target) && get.attitude(cur, target) < 0)
|
||
)
|
||
return 0.4 * btv + val;
|
||
if (sub == "equip4") return btv / 2 + val;
|
||
return btv + val;
|
||
},
|
||
result: {
|
||
player: function (player, target) {
|
||
let att = get.attitude(player, target),
|
||
hs = target.hasCard(
|
||
(card) => lib.filter.canBeGained(card, player, target),
|
||
"h"
|
||
),
|
||
lose = hs,
|
||
gain = att > 0 ? 0.52 : 1.28;
|
||
if (Math.abs(att) < 5.03) {
|
||
let temp = 0.015 * att * att;
|
||
if (att < 0) gain = 0.9 + temp;
|
||
else gain = 0.9 - temp;
|
||
}
|
||
target.countCards("e", function (card) {
|
||
if (
|
||
card.name != "jinhe" &&
|
||
lib.filter.canBeGained(card, player, target) &&
|
||
att * get.value(card, target) < 0
|
||
) {
|
||
lose = true;
|
||
let val = get.value(card, player);
|
||
if (val > 0) gain = Math.max(gain, val / 7);
|
||
}
|
||
});
|
||
target.countCards("j", function (card) {
|
||
let cardj = card.viewAs ? new lib.element.VCard({ name: card.viewAs }) : card;
|
||
if (
|
||
lib.filter.canBeGained(card, player, target) &&
|
||
att * get.effect(target, cardj, target, target) < 0
|
||
) {
|
||
lose = true;
|
||
if (cardj.name == "lebu") {
|
||
let needs = target.needsToDiscard(2);
|
||
if (att > 0) gain = Math.max(gain, 1.6 + needs / 10);
|
||
} else if (
|
||
cardj.name == "shandian" ||
|
||
cardj.name == "fulei" ||
|
||
cardj.name == "plague"
|
||
)
|
||
gain = Math.max(gain, 1.5 / Math.max(1, target.hp));
|
||
else if (att > 0) gain = Math.max(gain, 1.7);
|
||
}
|
||
});
|
||
if (!lose) return 0;
|
||
return gain;
|
||
},
|
||
target: function (player, target) {
|
||
let att = get.attitude(player, target),
|
||
hs = target.countCards("h", (card) =>
|
||
lib.filter.canBeGained(card, player, target)
|
||
),
|
||
es = target.countCards("e", (card) =>
|
||
lib.filter.canBeGained(card, player, target)
|
||
),
|
||
js = target.countCards("j", (card) =>
|
||
lib.filter.canBeGained(card, player, target)
|
||
),
|
||
noh = !hs || target.hasSkillTag("noh"),
|
||
noe = !es || target.hasSkillTag("noe"),
|
||
check = [-1, att > 0 ? -1.3 : 1.3, att > 0 ? -2.5 : 2.5],
|
||
idx = -1;
|
||
if (hs) {
|
||
idx = 0;
|
||
if (noh) check[0] = 0.7;
|
||
}
|
||
if (es) {
|
||
if (idx < 0) idx = 1;
|
||
if (
|
||
target.getEquip("baiyin") &&
|
||
target.isDamaged() &&
|
||
lib.filter.canBeGained(target.getEquip("baiyin"), player, target)
|
||
) {
|
||
let rec = get.recoverEffect(target, player, target);
|
||
if (es == 1 || att * rec > 0) {
|
||
let val = 3 - 0.6 * Math.min(5, target.hp);
|
||
if (rec > 0) check[1] = val;
|
||
else if (rec < 0) check[1] = -val;
|
||
}
|
||
}
|
||
target.countCards("e", function (card) {
|
||
let val = get.value(card, target);
|
||
if (
|
||
card.name == "jinhe" ||
|
||
att * val >= 0 ||
|
||
!lib.filter.canBeGained(card, player, target)
|
||
)
|
||
return false;
|
||
if (att > 0) {
|
||
check[1] = Math.max(1.3, check[1]);
|
||
return true;
|
||
}
|
||
let sub = get.subtype(card);
|
||
if (sub == "equip2" || sub == "equip5") val += 4;
|
||
else if (sub == "equip1") val *= 0.4 * Math.min(3.6, target.hp);
|
||
else val *= 0.6;
|
||
if (target.hp < 3 && sub != "equip2" && sub != "equip5") val *= 0.4;
|
||
check[1] = Math.min(-0.16 * val, check[1]);
|
||
});
|
||
if (noe) check[1] += 0.9;
|
||
}
|
||
if (js) {
|
||
let func = function (num) {
|
||
if (att > 0) check[2] = Math.max(check[2], num);
|
||
else check[2] = Math.min(check[2], 0.6 - num);
|
||
};
|
||
if (idx < 0) idx = 2;
|
||
target.countCards("j", function (card) {
|
||
let cardj = card.viewAs
|
||
? new lib.element.VCard({ name: card.viewAs })
|
||
: card;
|
||
if (
|
||
!lib.filter.canBeGained(card, player, target) ||
|
||
att * get.effect(target, cardj, target, target) >= 0
|
||
)
|
||
return false;
|
||
if (cardj.name == "lebu") func(2.1 + 0.4 * target.needsToDiscard(2));
|
||
else if (cardj.name == "bingliang") func(2.4);
|
||
else if (
|
||
cardj.name == "shandian" ||
|
||
cardj.name == "fulei" ||
|
||
cardj.name == "plague"
|
||
)
|
||
func(Math.abs(check[2]) / (1 + target.hp));
|
||
else func(2.1);
|
||
});
|
||
}
|
||
if (idx < 0) return 0;
|
||
for (let i = idx + 1; i < 3; i++) {
|
||
if ((i == 1 && !es) || (i == 2 && !js)) continue;
|
||
if ((att > 0 && check[i] > check[idx]) || (att <= 0 && check[i] < check[idx]))
|
||
idx = i;
|
||
}
|
||
return check[idx];
|
||
},
|
||
},
|
||
tag: {
|
||
loseCard: 1,
|
||
gain: 1,
|
||
},
|
||
},
|
||
},
|
||
shunshou_copy: {
|
||
ai: {
|
||
basic: {
|
||
order: 7.5,
|
||
useful: 4,
|
||
value: 9,
|
||
},
|
||
result: {
|
||
target: function (player, target, card) {
|
||
let position = "hej";
|
||
if (card && card.position) position = card.position;
|
||
const hs = position.includes("h") ? target.getGainableCards(player, "h") : [];
|
||
const es = position.includes("e") ? target.getGainableCards(player, "e") : [];
|
||
const js = position.includes("j") ? target.getGainableCards(player, "j") : [];
|
||
if (get.attitude(player, target) <= 0) {
|
||
if (hs.length > 0) return -1.5;
|
||
return es.some((card) => {
|
||
return get.value(card, target) > 0 && card != target.getEquip("jinhe");
|
||
}) ||
|
||
js.some((card) => {
|
||
var cardj = card.viewAs ? { name: card.viewAs } : card;
|
||
return get.effect(target, cardj, target, player) < 0;
|
||
})
|
||
? -1.5
|
||
: 1.5;
|
||
}
|
||
return es.some((card) => {
|
||
return get.value(card, target) <= 0;
|
||
}) ||
|
||
js.some((card) => {
|
||
var cardj = card.viewAs ? { name: card.viewAs } : card;
|
||
return get.effect(target, cardj, target, player) < 0;
|
||
})
|
||
? 1.5
|
||
: -1.5;
|
||
},
|
||
player: function (player, target, card) {
|
||
let position = "hej";
|
||
if (card && card.position) position = card.position;
|
||
const hs = position.includes("h") ? target.getGainableCards(player, "h") : [];
|
||
const es = position.includes("e") ? target.getGainableCards(player, "e") : [];
|
||
const js = position.includes("j") ? target.getGainableCards(player, "j") : [];
|
||
const att = get.attitude(player, target);
|
||
if (att < 0) {
|
||
if (
|
||
!hs.length &&
|
||
!es.some((card) => {
|
||
return (
|
||
get.value(card, target) > 0 && card != target.getEquip("jinhe")
|
||
);
|
||
}) &&
|
||
!js.some((card) => {
|
||
var cardj = card.viewAs ? { name: card.viewAs } : card;
|
||
return get.effect(target, cardj, target, player) < 0;
|
||
})
|
||
)
|
||
return 0;
|
||
} else if (att > 1) {
|
||
return es.some((card) => {
|
||
return get.value(card, target) <= 0;
|
||
}) ||
|
||
js.some((card) => {
|
||
var cardj = card.viewAs ? { name: card.viewAs } : card;
|
||
return get.effect(target, cardj, target, player) < 0;
|
||
})
|
||
? 1.5
|
||
: 0;
|
||
}
|
||
return 1;
|
||
},
|
||
},
|
||
tag: {
|
||
loseCard: 1,
|
||
gain: 1,
|
||
},
|
||
},
|
||
},
|
||
shunshou_copy2: {
|
||
ai: {
|
||
basic: {
|
||
order: 7.5,
|
||
useful: 4,
|
||
value: 9,
|
||
},
|
||
result: {
|
||
target: function (player, target, card, isLink) {
|
||
return lib.card.shunshou_copy.ai.result.target(
|
||
player,
|
||
target,
|
||
{
|
||
name: "shunshou_copy",
|
||
position: "he",
|
||
},
|
||
isLink
|
||
);
|
||
},
|
||
player: function (player, target, card, isLink) {
|
||
return lib.card.shunshou_copy.ai.result.player(
|
||
player,
|
||
target,
|
||
{
|
||
name: "shunshou_copy",
|
||
position: "he",
|
||
},
|
||
isLink
|
||
);
|
||
},
|
||
},
|
||
tag: {
|
||
loseCard: 1,
|
||
gain: 1,
|
||
},
|
||
},
|
||
},
|
||
guohe: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
selectTarget: 1,
|
||
postAi: function (targets) {
|
||
return targets.length == 1 && targets[0].countCards("j");
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
if (player == target) return false;
|
||
return target.hasCard(
|
||
(card) => lib.filter.canBeDiscarded(card, player, target),
|
||
get.is.single() ? "he" : "hej"
|
||
);
|
||
},
|
||
defaultYingbianEffect: "add",
|
||
content: function () {
|
||
"step 0";
|
||
if (get.is.single()) {
|
||
let bool1 = target.countDiscardableCards(player, "h"),
|
||
bool2 = target.countDiscardableCards(player, "e");
|
||
if (bool1 && bool2)
|
||
player
|
||
.chooseControl("手牌区", "装备区")
|
||
.set("ai", function () {
|
||
return Math.random() < 0.5 ? 1 : 0;
|
||
})
|
||
.set(
|
||
"prompt",
|
||
"弃置" +
|
||
get.translation(target) +
|
||
"装备区的一张牌，或观看其手牌并弃置其中的一张牌。"
|
||
);
|
||
else event._result = { control: bool1 ? "手牌区" : "装备区" };
|
||
} else event._result = { control: "所有区域" };
|
||
"step 1";
|
||
let pos,
|
||
vis = "visible";
|
||
if (result.control == "手牌区") pos = "h";
|
||
else if (result.control == "装备区") pos = "e";
|
||
else {
|
||
pos = "hej";
|
||
vis = undefined;
|
||
}
|
||
if (target.countDiscardableCards(player, pos))
|
||
player
|
||
.discardPlayerCard(pos, target, true, vis)
|
||
.set("target", target)
|
||
.set("complexSelect", false)
|
||
.set("ai", lib.card.guohe.ai.button);
|
||
},
|
||
ai: {
|
||
wuxie: (target, card, player, viewer, status) => {
|
||
if (
|
||
status * get.attitude(viewer, player._trueMe || player) > 0 ||
|
||
(target.hp > 2 &&
|
||
!target.hasCard((i) => {
|
||
let val = get.value(i, target),
|
||
subtypes = get.subtypes(i);
|
||
if (
|
||
val < 8 &&
|
||
target.hp < 2 &&
|
||
!subtypes.includes("equip2") &&
|
||
!subtypes.includes("equip5")
|
||
)
|
||
return false;
|
||
return val > 3 + Math.min(5, target.hp);
|
||
}, "e") &&
|
||
target.countCards("h") * _status.event.getRand("guohe_wuxie") > 1.57)
|
||
)
|
||
return 0;
|
||
},
|
||
basic: {
|
||
order: 9,
|
||
useful: (card, i) => 10 / (3 + i),
|
||
value: (card, player) => {
|
||
let max = 0;
|
||
game.countPlayer((cur) => {
|
||
max = Math.max(
|
||
max,
|
||
lib.card.guohe.ai.result.target(player, cur) * get.attitude(player, cur)
|
||
);
|
||
});
|
||
if (max <= 0) return 5;
|
||
return 0.42 * max;
|
||
},
|
||
},
|
||
yingbian: function (card, player, targets, viewer) {
|
||
if (get.attitude(viewer, player) <= 0) return 0;
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return (
|
||
!targets.includes(current) &&
|
||
lib.filter.targetEnabled2(card, player, current) &&
|
||
get.effect(current, card, player, player) > 0
|
||
);
|
||
})
|
||
)
|
||
return 6;
|
||
return 0;
|
||
},
|
||
button: (button) => {
|
||
let player = _status.event.player,
|
||
target = _status.event.target;
|
||
if (!lib.filter.canBeDiscarded(button.link, player, target)) return 0;
|
||
let att = get.attitude(player, target),
|
||
val = get.buttonValue(button),
|
||
pos = get.position(button.link),
|
||
name = get.name(button.link);
|
||
if (pos === "j") {
|
||
if (name === "lebu") {
|
||
let needs = target.needsToDiscard(2);
|
||
val *= 1.08 + 0.2 * needs;
|
||
} else if (name == "shandian" || name == "fulei" || name == "plague") val /= 2;
|
||
}
|
||
if (get.attitude(player, get.owner(button.link)) > 0) val = -val;
|
||
if (pos !== "e") return val;
|
||
let sub = get.subtypes(button.link);
|
||
if (sub.includes("equip1")) return (val * Math.min(3.6, target.hp)) / 3;
|
||
if (sub.includes("equip2")) {
|
||
if (name === "baiyin" && pos === "e" && target.isDamaged()) {
|
||
let by = 3 - 0.6 * Math.min(5, target.hp);
|
||
return get.sgn(get.recoverEffect(target, player, player)) * by;
|
||
}
|
||
return 1.57 * val;
|
||
}
|
||
if (
|
||
att <= 0 &&
|
||
(sub.includes("equip3") || sub.includes("equip4")) &&
|
||
(player.hasSkill("shouli") || player.hasSkill("psshouli"))
|
||
)
|
||
return 0;
|
||
if (sub.includes("equip6")) return val;
|
||
if (sub.includes("equip4")) return val / 2;
|
||
if (
|
||
sub.includes("equip3") &&
|
||
!game.hasPlayer((cur) => {
|
||
return !cur.inRange(target) && get.attitude(cur, target) < 0;
|
||
})
|
||
)
|
||
return 0.4 * val;
|
||
return val;
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
let att = get.attitude(player, target),
|
||
hs = target.countCards("h", (card) =>
|
||
lib.filter.canBeDiscarded(card, player, target)
|
||
),
|
||
es = target.countCards("e", (card) =>
|
||
lib.filter.canBeDiscarded(card, player, target)
|
||
),
|
||
js = target.countCards("j", (card) =>
|
||
lib.filter.canBeDiscarded(card, player, target)
|
||
),
|
||
noh = !hs || target.hasSkillTag("noh"),
|
||
noe = !es || target.hasSkillTag("noe"),
|
||
check = [-1, att > 0 ? -1.3 : 1.3, att > 0 ? -2.5 : 2.5],
|
||
idx = -1;
|
||
if (hs) {
|
||
idx = 0;
|
||
if (noh) check[0] = 0.7;
|
||
}
|
||
if (es) {
|
||
if (idx < 0) idx = 1;
|
||
if (
|
||
target.getEquip("baiyin") &&
|
||
target.isDamaged() &&
|
||
lib.filter.canBeDiscarded(target.getEquip("baiyin"), player, target)
|
||
) {
|
||
let rec = get.recoverEffect(target, player, target);
|
||
if (es == 1 || att * rec > 0) {
|
||
let val = 3 - 0.6 * Math.min(5, target.hp);
|
||
if (rec > 0) check[1] = val;
|
||
else if (rec < 0) check[1] = -val;
|
||
}
|
||
}
|
||
target.countCards("e", function (card) {
|
||
let val = get.value(card, target);
|
||
if (
|
||
card.name == "jinhe" ||
|
||
att * val >= 0 ||
|
||
!lib.filter.canBeDiscarded(card, player, target)
|
||
)
|
||
return false;
|
||
if (att > 0) {
|
||
check[1] = Math.max(1.3, check[1]);
|
||
return true;
|
||
}
|
||
let sub = get.subtype(card);
|
||
if (sub == "equip2" || sub == "equip5") val += 4;
|
||
else if (sub == "equip1") val *= 0.4 * Math.min(3.6, target.hp);
|
||
else val *= 0.6;
|
||
if (target.hp < 3 && sub != "equip2" && sub != "equip5") val *= 0.4;
|
||
check[1] = Math.min(-0.16 * val, check[1]);
|
||
});
|
||
if (noe) check[1] += 0.9;
|
||
}
|
||
if (js) {
|
||
let func = function (num) {
|
||
if (att > 0) check[2] = Math.max(check[2], num);
|
||
else check[2] = Math.min(check[2], 0.6 - num);
|
||
};
|
||
if (idx < 0) idx = 2;
|
||
target.countCards("j", function (card) {
|
||
let cardj = card.viewAs
|
||
? new lib.element.VCard({ name: card.viewAs })
|
||
: card;
|
||
if (
|
||
!lib.filter.canBeDiscarded(card, player, target) ||
|
||
att * get.effect(target, cardj, target, target) >= 0
|
||
)
|
||
return false;
|
||
if (cardj.name == "lebu") func(2.1 + 0.4 * target.needsToDiscard(2));
|
||
else if (cardj.name == "bingliang") func(2.4);
|
||
else if (
|
||
cardj.name == "shandian" ||
|
||
cardj.name == "fulei" ||
|
||
cardj.name == "plague"
|
||
)
|
||
func(Math.abs(check[2]) / (1 + target.hp));
|
||
else func(2.1);
|
||
});
|
||
}
|
||
if (idx < 0) return 0;
|
||
for (let i = idx + 1; i < 3; i++) {
|
||
if ((i == 1 && !es) || (i == 2 && !js)) continue;
|
||
if ((att > 0 && check[i] > check[idx]) || (att <= 0 && check[i] < check[idx]))
|
||
idx = i;
|
||
}
|
||
return check[idx];
|
||
},
|
||
},
|
||
tag: {
|
||
loseCard: 1,
|
||
discard: 1,
|
||
},
|
||
},
|
||
},
|
||
guohe_copy: {
|
||
ai: {
|
||
basic: {
|
||
order: 9,
|
||
useful: 5,
|
||
value: 5,
|
||
},
|
||
result: {
|
||
target: function (player, target, card) {
|
||
let position = "hej";
|
||
if (card && card.position) position = card.position;
|
||
const att = get.attitude(player, target);
|
||
const hs = position.includes("h") ? target.getDiscardableCards(player, "h") : [];
|
||
const es = position.includes("e") ? target.getDiscardableCards(player, "e") : [];
|
||
const js = position.includes("j") ? target.getDiscardableCards(player, "j") : [];
|
||
if (!hs.length && !es.length && !js.length) return 0;
|
||
if (att > 0) {
|
||
if (
|
||
js.some((card) => {
|
||
const cardj = card.viewAs ? { name: card.viewAs } : card;
|
||
return get.effect(target, cardj, target, player) < 0;
|
||
})
|
||
)
|
||
return 3;
|
||
if (
|
||
target.isDamaged() &&
|
||
es.some((card) => card.name == "baiyin") &&
|
||
get.recoverEffect(target, player, player) > 0
|
||
) {
|
||
if (target.hp == 1 && !target.hujia) return 1.6;
|
||
}
|
||
if (
|
||
es.some((card) => {
|
||
return get.value(card, target) < 0;
|
||
})
|
||
)
|
||
return 1;
|
||
return -1.5;
|
||
} else {
|
||
const noh = hs.length == 0 || target.hasSkillTag("noh");
|
||
const noe = es.length == 0 || target.hasSkillTag("noe");
|
||
const noe2 =
|
||
noe ||
|
||
!es.some((card) => {
|
||
return get.value(card, target) > 0;
|
||
});
|
||
const noj =
|
||
js.length == 0 ||
|
||
!js.some((card) => {
|
||
const cardj = card.viewAs ? { name: card.viewAs } : card;
|
||
return get.effect(target, cardj, target, player) < 0;
|
||
});
|
||
if (noh && noe2 && noj) return 1.5;
|
||
return -1.5;
|
||
}
|
||
},
|
||
},
|
||
tag: {
|
||
loseCard: 1,
|
||
discard: 1,
|
||
},
|
||
},
|
||
},
|
||
guohe_copy2: {
|
||
ai: {
|
||
basic: {
|
||
order: 9,
|
||
useful: 5,
|
||
value: 5,
|
||
},
|
||
result: {
|
||
target: function (player, target, card, isLink) {
|
||
return lib.card.guohe_copy.ai.result.target(
|
||
player,
|
||
target,
|
||
{
|
||
name: "guohe_copy",
|
||
position: "he",
|
||
},
|
||
isLink
|
||
);
|
||
},
|
||
},
|
||
tag: {
|
||
loseCard: 1,
|
||
discard: 1,
|
||
},
|
||
},
|
||
},
|
||
jiedao: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
singleCard: true,
|
||
targetprompt: ["被借刀", "出杀目标"],
|
||
complexSelect: true,
|
||
complexTarget: true,
|
||
multicheck: function () {
|
||
var card = { name: "sha", isCard: true };
|
||
return game.hasPlayer(function (current) {
|
||
if (current.getEquips(1).length > 0) {
|
||
return game.hasPlayer(function (current2) {
|
||
return (
|
||
current.inRange(current2) &&
|
||
lib.filter.targetEnabled(card, current, current2)
|
||
);
|
||
});
|
||
}
|
||
});
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
var card = { name: "sha", isCard: true };
|
||
return (
|
||
player != target &&
|
||
target.getEquips(1).length > 0 &&
|
||
game.hasPlayer(function (current) {
|
||
return (
|
||
target != current &&
|
||
target.inRange(current) &&
|
||
lib.filter.targetEnabled(card, target, current)
|
||
);
|
||
})
|
||
);
|
||
},
|
||
filterAddedTarget: function (card, player, target, preTarget) {
|
||
var card = { name: "sha", isCard: true };
|
||
return (
|
||
target != preTarget &&
|
||
preTarget.inRange(target) &&
|
||
lib.filter.targetEnabled(card, preTarget, target)
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (
|
||
event.directHit ||
|
||
!event.addedTarget ||
|
||
(!_status.connectMode && lib.config.skip_shan && !target.hasSha())
|
||
) {
|
||
event.directfalse = true;
|
||
} else {
|
||
target
|
||
.chooseToUse(
|
||
"对" +
|
||
get.translation(event.addedTarget) +
|
||
"使用一张杀，或令" +
|
||
get.translation(player) +
|
||
"获得你的武器牌",
|
||
function (card, player) {
|
||
if (get.name(card) != "sha") return false;
|
||
return lib.filter.filterCard.apply(this, arguments);
|
||
}
|
||
)
|
||
.set("targetRequired", true)
|
||
.set("complexSelect", true)
|
||
.set("filterTarget", function (card, player, target) {
|
||
if (
|
||
target != _status.event.sourcex &&
|
||
!ui.selected.targets.includes(_status.event.sourcex)
|
||
)
|
||
return false;
|
||
return lib.filter.filterTarget.apply(this, arguments);
|
||
})
|
||
.set("sourcex", event.addedTarget)
|
||
.set("addCount", false)
|
||
.set("respondTo", [player, card]);
|
||
}
|
||
"step 1";
|
||
if (event.directfalse || result.bool == false) {
|
||
var cards = target.getEquips(1);
|
||
if (cards.length) player.gain(cards, target, "give", "bySelf");
|
||
}
|
||
},
|
||
ai: {
|
||
wuxie: function (target, card, player, viewer) {
|
||
if (player == game.me && get.attitude(viewer, player._trueMe || player) > 0) return 0;
|
||
},
|
||
basic: {
|
||
order: 8,
|
||
value: 2,
|
||
useful: 1,
|
||
},
|
||
result: {
|
||
player: (player, target) => {
|
||
if (!target.hasSkillTag("noe") && get.attitude(player, target) > 0) return 0;
|
||
return (
|
||
(player.hasSkillTag("noe") ? 0.32 : 0.15) *
|
||
target.getEquips(1).reduce((num, i) => {
|
||
return num + get.value(i, player);
|
||
}, 0)
|
||
);
|
||
},
|
||
target: (player, target, card) => {
|
||
let targets = [].concat(ui.selected.targets);
|
||
if (_status.event.preTarget) targets.add(_status.event.preTarget);
|
||
if (targets.length) {
|
||
let preTarget = targets.lastItem,
|
||
pre = _status.event.getTempCache("jiedao_result", preTarget.playerid);
|
||
if (pre && pre.card === card && pre.target.isIn())
|
||
return target === pre.target ? pre.eff : 0;
|
||
return (
|
||
get.effect(target, { name: "sha" }, preTarget, player) /
|
||
get.attitude(player, target)
|
||
);
|
||
}
|
||
let arms =
|
||
(target.hasSkillTag("noe") ? 0.32 : -0.15) *
|
||
target.getEquips(1).reduce((num, i) => {
|
||
return num + get.value(i, target);
|
||
}, 0);
|
||
if (!target.mayHaveSha(player, "use")) return arms;
|
||
let sha = game.filterPlayer(get.info({ name: "jiedao" }).filterAddedTarget),
|
||
addTar = null;
|
||
sha = sha.reduce((num, current) => {
|
||
let eff = get.effect(current, { name: "sha" }, target, player);
|
||
if (eff <= num) return num;
|
||
addTar = current;
|
||
return eff;
|
||
}, -100);
|
||
if (!addTar) return arms;
|
||
sha /= get.attitude(player, target);
|
||
_status.event.putTempCache("jiedao_result", target.playerid, {
|
||
card: card,
|
||
target: addTar,
|
||
eff: sha,
|
||
});
|
||
return Math.max(arms, sha);
|
||
},
|
||
},
|
||
tag: {
|
||
gain: 1,
|
||
use: 1,
|
||
useSha: 1,
|
||
loseCard: 1,
|
||
},
|
||
},
|
||
},
|
||
wuxie: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
ai: {
|
||
basic: {
|
||
useful: [6, 4, 3],
|
||
value: [6, 4, 3],
|
||
},
|
||
result: { player: 1 },
|
||
expose: 0.2,
|
||
},
|
||
notarget: true,
|
||
finalDelay: false,
|
||
defaultYingbianEffect: "draw",
|
||
contentBefore: function () {
|
||
"step 0";
|
||
if (get.mode() == "guozhan" && get.cardtag(card, "guo")) {
|
||
var trigger = event.getParent(2)._trigger;
|
||
if (
|
||
trigger.name != "phaseJudge" &&
|
||
trigger.card.name != "wuxie" &&
|
||
trigger.targets.length > 1
|
||
) {
|
||
player
|
||
.chooseControl("对单体使用", "对势力使用")
|
||
.set("prompt", "请选择" + get.translation(card) + "的使用方式")
|
||
.set("ai", function () {
|
||
return "对势力使用";
|
||
});
|
||
} else event.finish();
|
||
} else event.finish();
|
||
"step 1";
|
||
if (result.control == "对势力使用") {
|
||
player.chat("对势力使用");
|
||
event.getParent().guowuxie = true;
|
||
}
|
||
},
|
||
content: function () {
|
||
var trigger = event.getParent(2)._trigger;
|
||
if (trigger.name == "phaseJudge") {
|
||
trigger.untrigger("currentOnly");
|
||
trigger.cancelled = true;
|
||
} else {
|
||
trigger.neutralize();
|
||
if (event.getParent().guowuxie == true) {
|
||
trigger.getParent().excluded.addArray(
|
||
game.filterPlayer(function (current) {
|
||
return current.isFriendOf(trigger.target);
|
||
})
|
||
);
|
||
}
|
||
}
|
||
/*
|
||
event.result={
|
||
wuxied:true,
|
||
directHit:evt.directHit||[],
|
||
nowuxie:evt.nowuxie,
|
||
};*/
|
||
if (player.isOnline()) {
|
||
player.send(function (player) {
|
||
if (ui.tempnowuxie && !player.hasWuxie()) {
|
||
ui.tempnowuxie.close();
|
||
delete ui.tempnowuxie;
|
||
}
|
||
}, player);
|
||
} else if (player == game.me) {
|
||
if (ui.tempnowuxie && !player.hasWuxie()) {
|
||
ui.tempnowuxie.close();
|
||
delete ui.tempnowuxie;
|
||
}
|
||
}
|
||
},
|
||
},
|
||
lebu: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "delay",
|
||
filterTarget: function (card, player, target) {
|
||
return lib.filter.judge(card, player, target) && player != target;
|
||
},
|
||
judge: function (card) {
|
||
if (get.suit(card) == "heart") return 1;
|
||
return -2;
|
||
},
|
||
judge2: function (result) {
|
||
if (result.bool == false) return true;
|
||
return false;
|
||
},
|
||
effect: function () {
|
||
if (result.bool == false) {
|
||
player.skip("phaseUse");
|
||
}
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 1,
|
||
useful: 1,
|
||
value: 8,
|
||
},
|
||
result: {
|
||
ignoreStatus: true,
|
||
target: (player, target) => {
|
||
if (target === _status.currentPhase && target.skipList.includes("phaseUse")) {
|
||
let evt = _status.event.getParent("phase");
|
||
if (evt && evt.phaseList.indexOf("phaseJudge") <= evt.num) return 0;
|
||
}
|
||
let num = target.needsToDiscard(3),
|
||
cf = Math.pow(get.threaten(target, player), 2);
|
||
if (!num) return -0.01 * cf;
|
||
if (target.hp > 2) num--;
|
||
let dist = Math.sqrt(get.distance(player, target, "absolute"));
|
||
if (dist < 1) dist = 1;
|
||
if (target.isTurnedOver()) dist++;
|
||
return (Math.min(-0.1, -num) * cf) / dist;
|
||
},
|
||
},
|
||
tag: {
|
||
skip: "phaseUse",
|
||
},
|
||
},
|
||
},
|
||
shandian: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "delay",
|
||
cardnature: "thunder",
|
||
modTarget: function (card, player, target) {
|
||
return lib.filter.judge(card, player, target);
|
||
},
|
||
enable: function (card, player) {
|
||
return player.canAddJudge(card);
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return lib.filter.judge(card, player, target) && player == target;
|
||
},
|
||
selectTarget: [-1, -1],
|
||
toself: true,
|
||
judge: function (card) {
|
||
if (get.suit(card) == "spade" && get.number(card) > 1 && get.number(card) < 10) return -5;
|
||
return 1;
|
||
},
|
||
judge2: function (result) {
|
||
if (result.bool == false) return true;
|
||
return false;
|
||
},
|
||
effect: function () {
|
||
if (result.bool == false) {
|
||
player.damage(3, "thunder", "nosource");
|
||
} else {
|
||
player.addJudgeNext(card);
|
||
}
|
||
},
|
||
cancel: function () {
|
||
player.addJudgeNext(card);
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 1,
|
||
useful: 0,
|
||
value: 0,
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
var num = game.countPlayer(function (current) {
|
||
//var skills=current.getSkills();
|
||
for (var j = 0; j < current.skills.length; j++) {
|
||
var rejudge = get.tag(current.skills[j], "rejudge", current);
|
||
if (rejudge != undefined) {
|
||
if (
|
||
get.attitude(target, current) > 0 &&
|
||
get.attitude(current, target) > 0
|
||
) {
|
||
return rejudge;
|
||
} else {
|
||
return -rejudge;
|
||
}
|
||
}
|
||
}
|
||
});
|
||
if (num > 0) return num;
|
||
if (num == 0) {
|
||
var mode = get.mode();
|
||
if (mode == "identity") {
|
||
if (target.identity == "nei") return 1;
|
||
var situ = get.situation();
|
||
if (target.identity == "fan") {
|
||
if (situ > 1) return 1;
|
||
} else {
|
||
if (situ < -1) return 1;
|
||
}
|
||
} else if (mode == "guozhan") {
|
||
if (target.identity == "ye") return 1;
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return current.identity == "unknown";
|
||
})
|
||
) {
|
||
return -1;
|
||
}
|
||
if (get.population(target.identity) == 1) {
|
||
if (target.maxHp > 2 && target.hp < 2) return 1;
|
||
if (game.countPlayer() < 3) return -1;
|
||
if (target.hp <= 2 && target.countCards("he") <= 3) return 1;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
},
|
||
},
|
||
tag: {
|
||
damage: 0.16,
|
||
natureDamage: 0.16,
|
||
thunderDamage: 0.16,
|
||
},
|
||
},
|
||
},
|
||
hanbing: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -1 },
|
||
skills: ["hanbing_skill"],
|
||
ai: {
|
||
basic: {
|
||
equipValue: 2,
|
||
},
|
||
},
|
||
},
|
||
renwang: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip2",
|
||
skills: ["renwang_skill"],
|
||
ai: {
|
||
basic: {
|
||
equipValue: 7.5,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
skill: {
|
||
qinglong_guozhan: {
|
||
equipSkill: true,
|
||
trigger: { player: "useCard" },
|
||
forced: true,
|
||
audio: "qinglong_skill",
|
||
filter: function (event, player) {
|
||
return get.mode() == "guozhan" && event.card.name == "sha";
|
||
},
|
||
content: function () {
|
||
if (!_status.qinglong_guozhan) _status.qinglong_guozhan = [];
|
||
_status.qinglong_guozhan.add(trigger);
|
||
game.countPlayer2(function (current) {
|
||
current.addTempSkill("qinglong_guozhan_mingzhi");
|
||
});
|
||
game.broadcast(
|
||
function (list) {
|
||
_status.qinglong_guozhan = list;
|
||
},
|
||
_status.qinglong_guozhan.map(function (i) {
|
||
return { targets: i.targets };
|
||
})
|
||
);
|
||
var next = game.createEvent("qinglong_guozhan");
|
||
event.next.remove(next);
|
||
trigger.after.add(next);
|
||
next.setContent(function () {
|
||
_status.qinglong_guozhan.remove(event.parent);
|
||
game.broadcast(
|
||
function (list) {
|
||
_status.qinglong_guozhan = list;
|
||
},
|
||
_status.qinglong_guozhan.map(function (i) {
|
||
return { targets: i.targets };
|
||
})
|
||
);
|
||
});
|
||
},
|
||
},
|
||
qinglong_guozhan_mingzhi: {
|
||
ai: {
|
||
nomingzhi: true,
|
||
skillTagFilter: function (player) {
|
||
if (_status.qinglong_guozhan) {
|
||
for (var i = 0; i < _status.qinglong_guozhan.length; i++) {
|
||
if (_status.qinglong_guozhan[i].targets.includes(player)) return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
},
|
||
},
|
||
hanbing_skill: {
|
||
equipSkill: true,
|
||
trigger: { source: "damageBegin2" },
|
||
//direct:true,
|
||
audio: true,
|
||
filter: function (event) {
|
||
return (
|
||
event.card &&
|
||
event.card.name == "sha" &&
|
||
event.notLink() &&
|
||
event.player.getCards("he").length > 0
|
||
);
|
||
},
|
||
//priority:1,
|
||
check: function (event, player) {
|
||
var target = event.player;
|
||
var eff = get.damageEffect(target, player, player, event.nature);
|
||
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 ||
|
||
player.hasSkill("tianxianjiu") ||
|
||
player.hasSkill("luoyi2") ||
|
||
player.hasSkill("reluoyi2")
|
||
)
|
||
return false;
|
||
if (target.countCards("he") < 2) return false;
|
||
var num = 0;
|
||
var cards = target.getCards("he");
|
||
for (var i = 0; i < cards.length; i++) {
|
||
if (get.value(cards[i]) > 6) num++;
|
||
}
|
||
if (num >= 2) return true;
|
||
return false;
|
||
},
|
||
logTarget: "player",
|
||
content: function () {
|
||
"step 0";
|
||
trigger.cancel();
|
||
"step 1";
|
||
if (trigger.player.countDiscardableCards(player, "he")) {
|
||
player.line(trigger.player);
|
||
player.discardPlayerCard("he", trigger.player, true);
|
||
}
|
||
"step 2";
|
||
if (trigger.player.countDiscardableCards(player, "he")) {
|
||
player.line(trigger.player);
|
||
player.discardPlayerCard("he", trigger.player, true);
|
||
}
|
||
},
|
||
},
|
||
icesha_skill: {
|
||
inherit: "hanbing_skill",
|
||
trigger: { source: "damageBegin3" },
|
||
equipSkill: false,
|
||
ruleSkill: true,
|
||
filter: function (event) {
|
||
return (
|
||
event.hasNature("ice") && event.notLink() && event.player.getCards("he").length > 0
|
||
);
|
||
},
|
||
},
|
||
renwang_skill: {
|
||
equipSkill: true,
|
||
trigger: { target: "shaBegin" },
|
||
forced: true,
|
||
priority: 6,
|
||
audio: true,
|
||
filter: function (event, player) {
|
||
if (player.hasSkillTag("unequip2")) return false;
|
||
if (
|
||
event.player.hasSkillTag("unequip", false, {
|
||
name: event.card ? event.card.name : null,
|
||
target: player,
|
||
card: event.card,
|
||
})
|
||
)
|
||
return false;
|
||
return event.card.name == "sha" && get.color(event.card) == "black";
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
},
|
||
ai: {
|
||
effect: {
|
||
target: function (card, player, target) {
|
||
if (typeof card !== "object" || target.hasSkillTag("unequip2")) return;
|
||
if (
|
||
player.hasSkillTag("unequip", false, {
|
||
name: card ? card.name : null,
|
||
target: target,
|
||
card: card,
|
||
}) ||
|
||
player.hasSkillTag("unequip_ai", false, {
|
||
name: card ? card.name : null,
|
||
target: target,
|
||
card: card,
|
||
})
|
||
)
|
||
return;
|
||
if (card.name == "sha" && get.color(card) == "black") return "zeroplayertarget";
|
||
},
|
||
},
|
||
},
|
||
},
|
||
zhuge_skill: {
|
||
equipSkill: true,
|
||
audio: true,
|
||
firstDo: true,
|
||
trigger: { player: "useCard1" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
!event.audioed &&
|
||
event.card.name == "sha" &&
|
||
player.countUsed("sha", true) > 1 &&
|
||
event.getParent().type == "phase"
|
||
);
|
||
},
|
||
content: function () {
|
||
trigger.audioed = true;
|
||
},
|
||
mod: {
|
||
cardUsable: function (card, player, num) {
|
||
var cards = player.getEquips("zhuge");
|
||
if (card.name == "sha") {
|
||
if (
|
||
!cards.length ||
|
||
player.hasSkill("zhuge_skill", null, false) ||
|
||
cards.some(
|
||
(card) => card != _status.zhuge_temp && !ui.selected.cards.includes(card)
|
||
)
|
||
) {
|
||
if (get.is.versus() || get.is.changban()) {
|
||
return num + 3;
|
||
}
|
||
return Infinity;
|
||
}
|
||
}
|
||
},
|
||
cardEnabled2: function (card, player) {
|
||
if (!_status.event.addCount_extra || player.hasSkill("zhuge_skill", null, false))
|
||
return;
|
||
var cards = player.getEquips("zhuge");
|
||
if (card && cards.includes(card)) {
|
||
try {
|
||
var cardz = get.card();
|
||
} catch (e) {
|
||
return;
|
||
}
|
||
if (!cardz || cardz.name != "sha") return;
|
||
_status.zhuge_temp = card;
|
||
var bool = lib.filter.cardUsable(
|
||
get.autoViewAs({ name: "sha" }, ui.selected.cards.concat([card])),
|
||
player
|
||
);
|
||
delete _status.zhuge_temp;
|
||
if (!bool) return false;
|
||
}
|
||
},
|
||
},
|
||
},
|
||
cixiong_skill: {
|
||
equipSkill: true,
|
||
trigger: { player: "useCardToPlayered" },
|
||
audio: true,
|
||
logTarget: "target",
|
||
check: function (event, player) {
|
||
if (get.attitude(player, event.target) > 0) return true;
|
||
var target = event.target;
|
||
return target.countCards("h") == 0 || !target.hasSkillTag("noh");
|
||
},
|
||
filter: function (event, player) {
|
||
if (event.card.name != "sha") return false;
|
||
return player.differentSexFrom(event.target);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (!trigger.target.countCards("h")) event._result = { bool: false };
|
||
else
|
||
trigger.target
|
||
.chooseToDiscard("弃置一张手牌，或令" + get.translation(player) + "摸一张牌")
|
||
.set("ai", function (card) {
|
||
var trigger = _status.event.getTrigger();
|
||
return (
|
||
-get.attitude(trigger.target, trigger.player) -
|
||
get.value(card) -
|
||
Math.max(0, 4 - trigger.target.hp) * 2
|
||
);
|
||
});
|
||
"step 1";
|
||
if (result.bool == false) player.draw();
|
||
},
|
||
},
|
||
qinggang_skill: {
|
||
equipSkill: true,
|
||
audio: true,
|
||
trigger: {
|
||
player: "useCardToPlayered",
|
||
},
|
||
filter: function (event) {
|
||
return event.card.name == "sha";
|
||
},
|
||
forced: true,
|
||
logTarget: "target",
|
||
content: function () {
|
||
trigger.target.addTempSkill("qinggang2");
|
||
trigger.target.storage.qinggang2.add(trigger.card);
|
||
trigger.target.markSkill("qinggang2");
|
||
},
|
||
ai: {
|
||
unequip_ai: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
if (arg && arg.name == "sha") return true;
|
||
return false;
|
||
},
|
||
},
|
||
},
|
||
qinggang2: {
|
||
firstDo: true,
|
||
ai: { unequip2: true },
|
||
init: function (player, skill) {
|
||
if (!player.storage[skill]) player.storage[skill] = [];
|
||
},
|
||
onremove: true,
|
||
trigger: {
|
||
player: ["damage", "damageCancelled", "damageZero"],
|
||
source: ["damage", "damageCancelled", "damageZero"],
|
||
target: ["shaMiss", "useCardToExcluded", "useCardToEnd", "eventNeutralized"],
|
||
global: ["useCardEnd"],
|
||
},
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
player.storage.qinggang2 &&
|
||
event.card &&
|
||
player.storage.qinggang2.includes(event.card) &&
|
||
(event.name != "damage" || event.notLink())
|
||
);
|
||
},
|
||
silent: true,
|
||
forced: true,
|
||
popup: false,
|
||
priority: 12,
|
||
content: function () {
|
||
player.storage.qinggang2.remove(trigger.card);
|
||
if (!player.storage.qinggang2.length) player.removeSkill("qinggang2");
|
||
},
|
||
marktext: "※",
|
||
intro: { content: "当前防具技能已失效" },
|
||
},
|
||
qinglong_skill: {
|
||
equipSkill: true,
|
||
trigger: { player: ["shaMiss", "eventNeutralized"] },
|
||
direct: true,
|
||
filter: function (event, player) {
|
||
if (get.mode() == "guozhan" || !event.card || event.card.name != "sha") return false;
|
||
return (
|
||
event.target.isIn() &&
|
||
player.canUse("sha", event.target, false) &&
|
||
(player.hasSha() || (_status.connectMode && player.countCards("hs")))
|
||
);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseToUse(
|
||
get.prompt("qinglong", trigger.target),
|
||
function (card, player, event) {
|
||
if (get.name(card) != "sha") return false;
|
||
if (!player.hasSkill("qinglong_skill", null, false)) {
|
||
var cards = player.getEquips("qinglong");
|
||
if (
|
||
!cards.some(
|
||
(card2) => card2 != card && !ui.selected.cards.includes(card2)
|
||
)
|
||
)
|
||
return false;
|
||
}
|
||
return lib.filter.filterCard.apply(this, arguments);
|
||
},
|
||
trigger.target,
|
||
-1
|
||
)
|
||
.set("addCount", false).logSkill = "qinglong_skill";
|
||
},
|
||
},
|
||
zhangba_skill: {
|
||
equipSkill: true,
|
||
enable: ["chooseToUse", "chooseToRespond"],
|
||
filterCard: true,
|
||
selectCard: 2,
|
||
position: "hs",
|
||
viewAs: { name: "sha" },
|
||
complexCard: true,
|
||
filter: function (event, player) {
|
||
return player.countCards("hs") >= 2;
|
||
},
|
||
audio: true,
|
||
prompt: "将两张手牌当杀使用或打出",
|
||
check: function (card) {
|
||
let player = _status.event.player;
|
||
if (
|
||
player.hasCard(function (card) {
|
||
return get.name(card) == "sha";
|
||
})
|
||
)
|
||
return 0;
|
||
if (
|
||
_status.event &&
|
||
_status.event.name == "chooseToRespond" &&
|
||
player.hp < 3 &&
|
||
!player.countCards("hs", function (card) {
|
||
return get.name(card) != "tao" && get.name(card) != "jiu";
|
||
})
|
||
)
|
||
return (player.hp > 1 ? 10 : 8) - get.value(card);
|
||
return Math.max(5, 8 - 0.7 * player.hp) - get.value(card);
|
||
},
|
||
ai: {
|
||
respondSha: true,
|
||
skillTagFilter: function (player) {
|
||
return player.countCards("hs") >= 2;
|
||
},
|
||
},
|
||
},
|
||
guanshi_skill: {
|
||
equipSkill: true,
|
||
trigger: {
|
||
player: ["shaMiss", "eventNeutralized"],
|
||
},
|
||
direct: true,
|
||
audio: true,
|
||
filter: function (event, player) {
|
||
if (event.type != "card" || event.card.name != "sha" || !event.target.isIn())
|
||
return false;
|
||
var min = 2;
|
||
if (!player.hasSkill("guanshi_skill", null, false))
|
||
min += get.sgn(player.getEquips("guanshi").length);
|
||
return player.countCards("he") >= min;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
//装备区内可能有多个贯石斧 或者玩家可能通过其他渠道获得贯石斧技能 只要留一张贯石斧不扔掉即可
|
||
var next = player
|
||
.chooseToDiscard(get.prompt("guanshi"), 2, "he", function (card, player) {
|
||
if (_status.event.ignoreCard) return true;
|
||
var cards = player.getEquips("guanshi");
|
||
if (!cards.includes(card)) return true;
|
||
return cards.some((cardx) => cardx != card && !ui.selected.cards.includes(cardx));
|
||
})
|
||
.set("ignoreCard", player.hasSkill("guanshi_skill", null, false))
|
||
.set("complexCard", true);
|
||
next.logSkill = "guanshi_skill";
|
||
next.set("ai", function (card) {
|
||
var evt = _status.event.getTrigger();
|
||
if (get.attitude(evt.player, evt.target) < 0) {
|
||
if (evt.player.needsToDiscard()) return 15 - get.value(card);
|
||
if (evt.baseDamage + evt.extraDamage >= Math.min(2, evt.target.hp))
|
||
return 8 - get.value(card);
|
||
return 5 - get.value(card);
|
||
}
|
||
return -1;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
if (event.triggername == "shaMiss") {
|
||
trigger.untrigger();
|
||
trigger.trigger("shaHit");
|
||
trigger._result.bool = false;
|
||
trigger._result.result = null;
|
||
} else {
|
||
trigger.unneutralize();
|
||
}
|
||
}
|
||
},
|
||
ai: {
|
||
directHit_ai: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
if (player._guanshi_temp) return;
|
||
player._guanshi_temp = true;
|
||
var bool =
|
||
get.attitude(player, arg.target) < 0 &&
|
||
arg.card &&
|
||
arg.card.name == "sha" &&
|
||
player.countCards("he", function (card) {
|
||
return (
|
||
card != player.getEquip("guanshi") &&
|
||
card != arg.card &&
|
||
(!arg.card.cards || !arg.card.cards.includes(card)) &&
|
||
get.value(card) < 5
|
||
);
|
||
}) > 1;
|
||
delete player._guanshi_temp;
|
||
return bool;
|
||
},
|
||
},
|
||
},
|
||
fangtian_skill: {
|
||
equipSkill: true,
|
||
audio: true,
|
||
trigger: { player: "useCard1" },
|
||
forced: true,
|
||
firstDo: true,
|
||
filter: function (event, player) {
|
||
if (event.card.name != "sha" || get.mode() == "guozhan") 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 && event.targets.length > range[1];
|
||
},
|
||
content: function () {},
|
||
mod: {
|
||
selectTarget: function (card, player, range) {
|
||
if (card.name != "sha") return;
|
||
if (get.mode() == "guozhan") return;
|
||
if (range[1] == -1) return;
|
||
var cards = player.getCards("h");
|
||
if (!cards.length) return;
|
||
for (var i = 0; i < cards.length; i++) {
|
||
if (cards[i].classList.contains("selected") == false) return;
|
||
}
|
||
range[1] += 2;
|
||
},
|
||
},
|
||
},
|
||
fangtian_guozhan: {
|
||
equipSkill: true,
|
||
trigger: { player: "useCard2" },
|
||
filter: function (event, player) {
|
||
if (get.mode() != "guozhan") return false;
|
||
if (event.card.name != "sha") return false;
|
||
return game.hasPlayer(function (target) {
|
||
if (event.targets.includes(target)) return false;
|
||
if (!lib.filter.filterTarget(event.card, player, target)) return false;
|
||
if (target.identity == "ye" || target.identity == "unknown") return true;
|
||
for (var i = 0; i < event.targets.length; i++) {
|
||
if (target.identity == event.targets[i].identity) return false;
|
||
}
|
||
return true;
|
||
});
|
||
},
|
||
direct: true,
|
||
content: function () {
|
||
"step 0";
|
||
player
|
||
.chooseTarget(
|
||
get.prompt2("fangtian"),
|
||
[1, Infinity],
|
||
function (card, player, target) {
|
||
var cardx = _status.event.cardx;
|
||
if (!lib.filter.filterTarget(cardx, player, target)) return false;
|
||
var targets = _status.event.targets.slice(0).concat(ui.selected.targets);
|
||
if (targets.includes(target)) return false;
|
||
if (target.identity == "ye" || target.identity == "unknown") return true;
|
||
for (var i = 0; i < targets.length; i++) {
|
||
if (target.identity == targets[i].identity) return false;
|
||
}
|
||
return true;
|
||
}
|
||
)
|
||
.set("promptbar", "none")
|
||
.set("cardx", trigger.card)
|
||
.set("targets", trigger.targets)
|
||
.set("ai", function (target) {
|
||
var player = _status.event.player;
|
||
return get.effect(target, _status.event.cardx, player, player);
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.logSkill("fangtian_skill", result.targets);
|
||
if (!player.storage.fangtian_guozhan_trigger)
|
||
player.storage.fangtian_guozhan_trigger = [];
|
||
player.storage.fangtian_guozhan_trigger.add(trigger.card);
|
||
trigger.targets.addArray(result.targets);
|
||
player.addTempSkill("fangtian_guozhan_trigger");
|
||
}
|
||
},
|
||
},
|
||
fangtian_guozhan_trigger: {
|
||
trigger: { player: "shaMiss" },
|
||
silent: true,
|
||
onremove: true,
|
||
content: function () {
|
||
if (player.storage[event.name].includes(trigger.card))
|
||
trigger.getParent().excluded.addArray(trigger.getParent().targets);
|
||
},
|
||
group: "fangtian_guozhan_remove",
|
||
},
|
||
fangtian_guozhan_remove: {
|
||
trigger: { player: ["useCardAfter", "useCardCancelled"] },
|
||
silent: true,
|
||
filter: function (event, player) {
|
||
return (
|
||
player.storage.fangtian_guozhan_trigger &&
|
||
player.storage.fangtian_guozhan_trigger.includes(event.card)
|
||
);
|
||
},
|
||
content: function () {
|
||
player.storage.fangtian_guozhan_trigger.remove(trigger.card);
|
||
},
|
||
},
|
||
qilin_skill: {
|
||
equipSkill: true,
|
||
trigger: { source: "damageBegin2" },
|
||
filter: function (event, player) {
|
||
return (
|
||
event.card &&
|
||
event.card.name == "sha" &&
|
||
event.notLink() &&
|
||
event.player.getCards("e", { subtype: ["equip3", "equip4", "equip6"] }).length > 0
|
||
);
|
||
},
|
||
direct: true,
|
||
audio: true,
|
||
content: function () {
|
||
"step 0";
|
||
var att = get.attitude(player, trigger.player) <= 0;
|
||
var next = player.chooseButton();
|
||
next.set("att", att);
|
||
next.set("createDialog", [
|
||
"是否发动【麒麟弓】，弃置" + get.translation(trigger.player) + "的一张坐骑牌？",
|
||
trigger.player.getCards("e", { subtype: ["equip3", "equip4", "equip6"] }),
|
||
]);
|
||
next.set("ai", function (button) {
|
||
if (_status.event.att) return get.buttonValue(button);
|
||
return 0;
|
||
});
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.logSkill("qilin_skill", trigger.player);
|
||
trigger.player.discard(result.links[0]);
|
||
}
|
||
},
|
||
},
|
||
bagua_skill: {
|
||
equipSkill: true,
|
||
trigger: { player: ["chooseToRespondBegin", "chooseToUseBegin"] },
|
||
filter: function (event, player) {
|
||
if (event.responded) return false;
|
||
if (event.bagua_skill) return false;
|
||
if (!event.filterCard || !event.filterCard({ name: "shan" }, player, event)) return false;
|
||
if (
|
||
event.name == "chooseToRespond" &&
|
||
!lib.filter.cardRespondable({ name: "shan" }, player, event)
|
||
)
|
||
return false;
|
||
if (player.hasSkillTag("unequip2")) return false;
|
||
var evt = event.getParent();
|
||
if (
|
||
evt.player &&
|
||
evt.player.hasSkillTag("unequip", false, {
|
||
name: evt.card ? evt.card.name : null,
|
||
target: player,
|
||
card: evt.card,
|
||
})
|
||
)
|
||
return false;
|
||
return true;
|
||
},
|
||
audio: true,
|
||
check: function (event, player) {
|
||
if (!event) return true;
|
||
if (event.ai) {
|
||
var ai = event.ai;
|
||
var tmp = _status.event;
|
||
_status.event = event;
|
||
var result = ai({ name: "shan" }, _status.event.player, event);
|
||
_status.event = tmp;
|
||
return result > 0;
|
||
}
|
||
let evt = event.getParent();
|
||
if (player.hasSkillTag("noShan", null, evt)) return false;
|
||
if (!evt || !evt.card || !evt.player || player.hasSkillTag("useShan", null, evt))
|
||
return true;
|
||
if (
|
||
evt.card &&
|
||
evt.player &&
|
||
player.isLinked() &&
|
||
game.hasNature(evt.card) &&
|
||
get.attitude(player, evt.player._trueMe || evt.player) > 0
|
||
)
|
||
return false;
|
||
return true;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
trigger.bagua_skill = true;
|
||
player.judge("bagua", function (card) {
|
||
return get.color(card) == "red" ? 1.5 : -0.5;
|
||
}).judge2 = function (result) {
|
||
return result.bool;
|
||
};
|
||
"step 1";
|
||
if (result.judge > 0) {
|
||
trigger.untrigger();
|
||
trigger.set("responded", true);
|
||
trigger.result = { bool: true, card: { name: "shan", isCard: true } };
|
||
}
|
||
},
|
||
ai: {
|
||
respondShan: true,
|
||
freeShan: true,
|
||
skillTagFilter(player, tag, arg) {
|
||
if (tag !== "respondShan" && tag !== "freeShan") return;
|
||
if (player.hasSkillTag("unequip2")) return false;
|
||
if (!arg || !arg.player) return true;
|
||
if (
|
||
arg.player.hasSkillTag("unequip", false, {
|
||
target: player,
|
||
})
|
||
)
|
||
return false;
|
||
return true;
|
||
},
|
||
effect: {
|
||
target: function (card, player, target, effect) {
|
||
if (target.hasSkillTag("unequip2")) return;
|
||
if (
|
||
player.hasSkillTag("unequip", false, {
|
||
name: card ? card.name : null,
|
||
target: target,
|
||
card: card,
|
||
}) ||
|
||
player.hasSkillTag("unequip_ai", false, {
|
||
name: card ? card.name : null,
|
||
target: target,
|
||
card: card,
|
||
})
|
||
)
|
||
return;
|
||
if (get.tag(card, "respondShan")) return 0.5;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
_wuxie: {
|
||
trigger: { player: ["useCardToBegin", "phaseJudge"] },
|
||
priority: 5,
|
||
popup: false,
|
||
forced: true,
|
||
silent: true,
|
||
filter: function (event, player) {
|
||
if (event.card.storage && event.card.storage.nowuxie) return false;
|
||
var card = event.card;
|
||
if (event.name == "phaseJudge" && card.viewAs) card = { name: card.viewAs };
|
||
var info = get.info(card);
|
||
if (info.wuxieable === false) return false;
|
||
if (event.name != "phaseJudge") {
|
||
if (event.getParent().nowuxie) return false;
|
||
if (event.player.hasSkillTag("playernowuxie", false, event.card)) return false;
|
||
if (get.type(event.card) != "trick" && !info.wuxieable) return false;
|
||
}
|
||
return true;
|
||
},
|
||
forceLoad: true,
|
||
forceDie: true,
|
||
content: function () {
|
||
"step 0";
|
||
delete event.wuxieresult;
|
||
delete event.wuxieresult2;
|
||
//创建map存储各种信息，用于hasHiddenWuxie判断
|
||
var map = {};
|
||
event._info_map = map;
|
||
var card = trigger.card;
|
||
var state = true;
|
||
if (trigger.name == "phaseJudge") {
|
||
if (get.itemtype(card) == "card" && card.viewAs)
|
||
card = get.autoViewAs({ name: card.viewAs }, [card]);
|
||
map.target = trigger.player;
|
||
map.isJudge = true;
|
||
} else {
|
||
map.player = trigger.player;
|
||
if (trigger.multitarget) map.multitargets = true;
|
||
map.target = trigger.target;
|
||
map.targets = trigger.targets;
|
||
map.tempnowuxie =
|
||
trigger.targets && trigger.targets.length > 1 && !trigger.multitarget;
|
||
map.noai = Boolean(trigger.getParent().noai);
|
||
//如果对拼无懈，获取历史数据
|
||
if (card.name == "wuxie") {
|
||
var evt = event;
|
||
while (true) {
|
||
evt = evt.getParent(5);
|
||
if (evt && evt.name == "_wuxie") {
|
||
state = !state;
|
||
var evtmap = evt._info_map;
|
||
if (evtmap.card.name != "wuxie") {
|
||
map._source = evtmap;
|
||
}
|
||
} else break;
|
||
}
|
||
}
|
||
}
|
||
map.card = card;
|
||
map.state = state ? 1 : -1;
|
||
map.id2 = trigger.getParent().id;
|
||
event._global_waiting = true;
|
||
//发送函数
|
||
event.send = function (player, map, skillState) {
|
||
//获取技能数据
|
||
if (skillState) {
|
||
player.applySkills(skillState);
|
||
}
|
||
//生成描述提示
|
||
var prompt = "",
|
||
evtmap = map,
|
||
state = map.state;
|
||
if (map._source) evtmap = map._source;
|
||
if (evtmap.isJudge) {
|
||
prompt +=
|
||
get.translation(evtmap.target) +
|
||
"的" +
|
||
get.translation(evtmap.card) +
|
||
"即将" +
|
||
(state > 0 ? "生" : "失") +
|
||
"效。";
|
||
} else {
|
||
prompt += get.translation(evtmap.player);
|
||
if (evtmap.multitarget) {
|
||
if (evtmap.targets.length) {
|
||
prompt += "对";
|
||
prompt += get.translation(evtmap.targets);
|
||
}
|
||
} else if (evtmap.target) {
|
||
prompt += "对";
|
||
prompt +=
|
||
evtmap.target == evtmap.player ? "自己" : get.translation(evtmap.target);
|
||
}
|
||
prompt += "使用的" + get.translation(evtmap.card);
|
||
prompt += "即将" + (state > 0 ? "生" : "失") + "效。";
|
||
}
|
||
prompt += "是否使用【无懈可击】？";
|
||
if (
|
||
player.isUnderControl(true) &&
|
||
!_status.auto &&
|
||
!ui.tempnowuxie &&
|
||
map.tempnowuxie
|
||
) {
|
||
var translation = get.translation(map.card.name);
|
||
if (translation.length >= 4) {
|
||
translation = lib.translate[map.card.name + "_ab"] || translation.slice(0, 2);
|
||
}
|
||
ui.tempnowuxie = ui.create.control(
|
||
"不无懈" + translation,
|
||
ui.click.tempnowuxie,
|
||
"stayleft"
|
||
);
|
||
ui.tempnowuxie._origin = map.id2;
|
||
}
|
||
var next = player.chooseToUse({
|
||
filterCard: function (card, player) {
|
||
if (get.name(card) != "wuxie") return false;
|
||
return lib.filter.cardEnabled(card, player, "forceEnable");
|
||
},
|
||
prompt: prompt,
|
||
type: "wuxie",
|
||
_global_waiting: true,
|
||
ai1: function () {
|
||
if (map.isJudge) {
|
||
var card = evtmap.card,
|
||
source = evtmap.target;
|
||
var name = card.viewAs || card.name;
|
||
var info = lib.card[name];
|
||
if (info && info.ai && info.ai.wuxie) {
|
||
var aiii = info.ai.wuxie(
|
||
source,
|
||
card,
|
||
source,
|
||
_status.event.player,
|
||
state
|
||
);
|
||
if (typeof aiii == "number") return aiii;
|
||
}
|
||
if (Math.abs(get.attitude(_status.event.player, source)) < 3) return 0;
|
||
if (
|
||
source.hasSkillTag("nowuxie_judge") ||
|
||
(source.hasSkillTag("guanxing") &&
|
||
(source != player || !source.hasSkill("guanxing_fail")))
|
||
)
|
||
return 0;
|
||
if (name != "lebu" && name != "bingliang") {
|
||
if (source != _status.event.player) {
|
||
return 0;
|
||
}
|
||
}
|
||
if (
|
||
name == "bingliang" &&
|
||
source.countCards("j") > 0 &&
|
||
source.countCards("h") >= source.hp - 1
|
||
) {
|
||
return 0;
|
||
}
|
||
var card2;
|
||
if (name != card.name) {
|
||
card2 = { name: name };
|
||
} else {
|
||
card2 = card;
|
||
}
|
||
var eff = get.effect(source, card2, source, source);
|
||
if (eff >= 0) return 0;
|
||
return state * get.attitude(_status.event.player, source);
|
||
} else if (evtmap.target) {
|
||
var triggerevent = _status.event.getTrigger();
|
||
if (
|
||
triggerevent &&
|
||
triggerevent.parent &&
|
||
triggerevent.parent.postAi &&
|
||
triggerevent.player.isUnknown(_status.event.player)
|
||
) {
|
||
return 0;
|
||
}
|
||
var card = evtmap.card,
|
||
target = evtmap.target,
|
||
source = evtmap.player;
|
||
var info = get.info(card);
|
||
if (info.ai && info.ai.wuxie) {
|
||
var aiii = info.ai.wuxie(
|
||
target,
|
||
card,
|
||
source,
|
||
_status.event.player,
|
||
state
|
||
);
|
||
if (typeof aiii == "number") return aiii;
|
||
}
|
||
if (info.multitarget && targets) {
|
||
var eff = 0;
|
||
for (var i = 0; i < targets.length; i++) {
|
||
eff += get.effect(targets[i], card, source, _status.event.player);
|
||
}
|
||
return -eff * state;
|
||
}
|
||
if (Math.abs(get.attitude(_status.event.player, target)) < 3) return 0;
|
||
return -get.effect(target, card, source, _status.event.player) * state;
|
||
} else {
|
||
var triggerevent = _status.event.getTrigger();
|
||
if (
|
||
triggerevent &&
|
||
triggerevent.parent &&
|
||
triggerevent.parent.postAi &&
|
||
triggerevent.player.isUnknown(_status.event.player)
|
||
) {
|
||
return 0;
|
||
}
|
||
var card = evtmap.card,
|
||
source = evtmap.player;
|
||
var info = get.info(card);
|
||
if (info.ai && info.ai.wuxie) {
|
||
var aiii = info.ai.wuxie(
|
||
target,
|
||
card,
|
||
source,
|
||
_status.event.player,
|
||
state
|
||
);
|
||
if (typeof aiii == "number") return aiii;
|
||
}
|
||
if (Math.abs(get.attitude(_status.event.player, source)) < 3) return 0;
|
||
return -get.attitude(_status.event.player, source) * state;
|
||
}
|
||
},
|
||
source: evtmap.target,
|
||
source2: evtmap.targets,
|
||
id: map.id,
|
||
id2: map.id2,
|
||
state: state,
|
||
info_map: map,
|
||
});
|
||
if (map.card && map.player) next.respondTo = [map.player, map.card];
|
||
if (game.online) {
|
||
_status.event._resultid = map.id;
|
||
game.resume();
|
||
} else {
|
||
next.nouse = true;
|
||
}
|
||
};
|
||
"step 1";
|
||
//判断谁有无懈
|
||
var map = event._info_map;
|
||
var list = game.filterPlayer(function (current) {
|
||
if (event.triggername == "phaseJudge") {
|
||
if (
|
||
game.checkMod(
|
||
map.card,
|
||
map.target,
|
||
current,
|
||
"unchanged",
|
||
"wuxieJudgeEnabled",
|
||
current
|
||
) == false
|
||
)
|
||
return false;
|
||
if (
|
||
game.checkMod(
|
||
map.card,
|
||
map.target,
|
||
current,
|
||
"unchanged",
|
||
"wuxieJudgeRespondable",
|
||
map.target
|
||
) == false
|
||
)
|
||
return false;
|
||
} else {
|
||
if (trigger.getParent().directHit.includes(current)) return false;
|
||
if (
|
||
game.checkMod(
|
||
map.card,
|
||
map.player,
|
||
map.target,
|
||
current,
|
||
"unchanged",
|
||
"wuxieEnabled",
|
||
current
|
||
) == false
|
||
)
|
||
return false;
|
||
if (
|
||
game.checkMod(
|
||
map.card,
|
||
map.player,
|
||
map.target,
|
||
current,
|
||
"unchanged",
|
||
"wuxieRespondable",
|
||
map.player
|
||
) == false
|
||
)
|
||
return false;
|
||
}
|
||
return current.hasWuxie(map);
|
||
});
|
||
event.list = list;
|
||
event.id = get.id();
|
||
map.id = event.id;
|
||
list.sortBySeat(_status.currentPhase);
|
||
"step 2";
|
||
if (event.list.length == 0) {
|
||
event.finish();
|
||
} else if (
|
||
_status.connectMode &&
|
||
(event.list[0].isOnline() || event.list[0] == game.me)
|
||
) {
|
||
event.goto(4);
|
||
} else {
|
||
event.current = event.list.shift();
|
||
event.send(event.current, event._info_map);
|
||
}
|
||
"step 3";
|
||
if (result.bool) {
|
||
event.wuxieresult = event.current;
|
||
event.wuxieresult2 = result;
|
||
event.goto(8);
|
||
} else {
|
||
event.goto(2);
|
||
}
|
||
"step 4";
|
||
var id = event.id;
|
||
var sendback = function (result, player) {
|
||
if (result && result.id == id && !event.wuxieresult && result.bool) {
|
||
event.wuxieresult = player;
|
||
event.wuxieresult2 = result;
|
||
game.broadcast("cancel", id);
|
||
return function () {
|
||
if (
|
||
_status.event.id == id &&
|
||
_status.event.name == "chooseToUse" &&
|
||
_status.paused
|
||
)
|
||
event.resultOL = _status.event.resultOL;
|
||
if (_status.event._parent_id == id) {
|
||
ui.click.cancel();
|
||
}
|
||
if (_status.event.id == id) {
|
||
if (_status.event._backup) ui.click.cancel();
|
||
ui.click.cancel();
|
||
if (ui.confirm) {
|
||
ui.confirm.close();
|
||
}
|
||
if (_status.event.result) {
|
||
_status.event.result.id = id;
|
||
}
|
||
}
|
||
};
|
||
} else {
|
||
if (
|
||
_status.event.id == id &&
|
||
_status.event.name == "chooseToUse" &&
|
||
_status.paused
|
||
) {
|
||
return function () {
|
||
event.resultOL = _status.event.resultOL;
|
||
};
|
||
}
|
||
}
|
||
};
|
||
|
||
var withme = false;
|
||
var withol = false;
|
||
var list = event.list;
|
||
for (var i = 0; i < list.length; i++) {
|
||
if (list[i].isOnline()) {
|
||
withol = true;
|
||
list[i].wait(sendback);
|
||
list[i].send(event.send, list[i], event._info_map, get.skillState(list[i]));
|
||
list.splice(i--, 1);
|
||
} else if (list[i] == game.me) {
|
||
withme = true;
|
||
event.send(list[i], event._info_map);
|
||
list.splice(i--, 1);
|
||
}
|
||
}
|
||
if (!withme) {
|
||
event.goto(6);
|
||
}
|
||
if (_status.connectMode) {
|
||
if (withme || withol) {
|
||
for (var i = 0; i < game.players.length; i++) {
|
||
game.players[i].showTimer();
|
||
}
|
||
}
|
||
}
|
||
event.withol = withol;
|
||
"step 5";
|
||
if (result && result.bool && !event.wuxieresult) {
|
||
game.broadcast("cancel", event.id);
|
||
event.wuxieresult = game.me;
|
||
event.wuxieresult2 = result;
|
||
}
|
||
"step 6";
|
||
if (event.withol && !event.resultOL) {
|
||
game.pause();
|
||
}
|
||
"step 7";
|
||
for (var i = 0; i < game.players.length; i++) {
|
||
game.players[i].hideTimer();
|
||
}
|
||
"step 8";
|
||
if (event.wuxieresult2 && event.wuxieresult2._sendskill)
|
||
lib.skill[event.wuxieresult2._sendskill[0]] = event.wuxieresult2._sendskill[1];
|
||
if (event.wuxieresult && event.wuxieresult2 && event.wuxieresult2.skill) {
|
||
var info = get.info(event.wuxieresult2.skill);
|
||
if (info && info.precontent && !game.online) {
|
||
var next = game.createEvent("pre_" + event.wuxieresult2.skill);
|
||
next.setContent(info.precontent);
|
||
next.set("result", event.wuxieresult2);
|
||
next.set("player", event.wuxieresult);
|
||
}
|
||
}
|
||
"step 9";
|
||
if (event.wuxieresult) {
|
||
var next = event.wuxieresult.useResult(event.wuxieresult2);
|
||
if (event.triggername != "phaseJudge") {
|
||
next.respondTo = [trigger.player, trigger.card];
|
||
}
|
||
}
|
||
},
|
||
},
|
||
/*
|
||
_wuxie:{
|
||
trigger:{player:['useCardToBegin','phaseJudge']},
|
||
priority:5,
|
||
popup:false,
|
||
forced:true,
|
||
filter:function(event,player){
|
||
if(event.card.storage&&event.card.storage.nowuxie) return false;
|
||
var card=event.card;
|
||
if(event.name=='phaseJudge'&&card.viewAs) card={name:card.viewAs};
|
||
var info=get.info(card);
|
||
if(info.wuxieable===false) return false;
|
||
if(event.name!='phaseJudge'){
|
||
if(event.getParent().nowuxie) return false;
|
||
if(!event.target){
|
||
if(info.wuxieable) return true;
|
||
return false;
|
||
}
|
||
if(event.player.hasSkillTag('playernowuxie',false,event.card)) return false;
|
||
if(get.type(event.card)!='trick'&&!info.wuxieable) return false;
|
||
}
|
||
return true;
|
||
},
|
||
forceLoad:true,
|
||
content:function(){
|
||
'step 0'
|
||
delete event.wuxieresult;
|
||
delete event.wuxieresult2;
|
||
if(trigger.multitarget){
|
||
event.targets=trigger.targets;
|
||
}
|
||
event.target=trigger.target;
|
||
if(event.triggername=='phaseJudge'){
|
||
event.target=trigger.player;
|
||
}
|
||
event.sourcex=event.targets||event.target;
|
||
if(!event.targets&&trigger.targets&&trigger.targets.length==1){
|
||
event.sourcex2=trigger.player;
|
||
}
|
||
event.source=trigger.player;
|
||
if(event.state==undefined) event.state=true;
|
||
event.card=trigger.card;
|
||
event._global_waiting=true;
|
||
event.tempnowuxie=(trigger.targets&&trigger.targets.length>1&&!trigger.multitarget);
|
||
event.filterCard=function(card,player){
|
||
if(get.name(card)!='wuxie') return false;
|
||
return lib.filter.cardEnabled(card,player,'forceEnable');
|
||
};
|
||
event.send=function(player,state,isJudge,card,source,target,targets,id,id2,tempnowuxie,skillState,respondInfo){
|
||
if(skillState){
|
||
player.applySkills(skillState);
|
||
}
|
||
state=state?1:-1;
|
||
var str='';
|
||
if(isJudge){
|
||
str+=get.translation(source)+'的';
|
||
}
|
||
if(isJudge){
|
||
str+=get.translation(card,'viewAs');
|
||
}
|
||
else{
|
||
str+=get.translation(card);
|
||
}
|
||
if((targets||target)&&!isJudge){
|
||
str+='对'+get.translation(targets||target);
|
||
}
|
||
str+='将'+(state>0?'生效':'失效')+'，是否无懈？';
|
||
|
||
if(player.isUnderControl(true)&&!_status.auto&&!ui.tempnowuxie&&tempnowuxie){
|
||
var translation=get.translation(card.name);
|
||
if(translation.length>=4){
|
||
translation=lib.translate[card.name+'_ab']||translation.slice(0,2);
|
||
}
|
||
ui.tempnowuxie=ui.create.control('不无懈'+translation,ui.click.tempnowuxie,'stayleft');
|
||
ui.tempnowuxie._origin=id2;
|
||
}
|
||
var next=player.chooseToUse({
|
||
filterCard:function(card,player){
|
||
if(get.name(card)!='wuxie') return false;
|
||
return lib.filter.cardEnabled(card,player,'forceEnable');
|
||
},
|
||
prompt:str,
|
||
type:'wuxie',
|
||
state:state,
|
||
_global_waiting:true,
|
||
ai1:function(){
|
||
if(isJudge){
|
||
var name=card.viewAs||card.name;
|
||
var info=lib.card[name];
|
||
if(info&&info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(source,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,source))<3) return 0;
|
||
if(source.hasSkillTag('nowuxie_judge')||source.hasSkillTag('guanxing')&&(source!=player||!source.hasSkill('guanxing_fail'))) return 0;
|
||
if(name!='lebu'&&name!='bingliang'){
|
||
if(source!=_status.event.player){
|
||
return 0;
|
||
}
|
||
}
|
||
var card2;
|
||
if(name!=card.name){
|
||
card2={name:name};
|
||
}
|
||
else{
|
||
card2=card;
|
||
}
|
||
var eff=get.effect(source,card2,source,source);
|
||
if(eff>=0) return 0;
|
||
return state*get.attitude(_status.event.player,source);
|
||
}
|
||
else if(target){
|
||
var triggerevent=_status.event.getTrigger();
|
||
if(triggerevent&&triggerevent.parent&&
|
||
triggerevent.parent.postAi&&
|
||
triggerevent.player.isUnknown(_status.event.player)){
|
||
return 0;
|
||
}
|
||
var info=get.info(card);
|
||
if(info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(target,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(info.multitarget&&targets){
|
||
var eff=0;
|
||
for(var i=0;i<targets.length;i++){
|
||
eff+=get.effect(targets[i],card,source,_status.event.player)
|
||
}
|
||
return -eff*state;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,target))<3) return 0;
|
||
return -get.effect(target,card,source,_status.event.player)*state;
|
||
}
|
||
else{
|
||
var triggerevent=_status.event.getTrigger();
|
||
if(triggerevent&&triggerevent.parent&&
|
||
triggerevent.parent.postAi&&
|
||
triggerevent.player.isUnknown(_status.event.player)){
|
||
return 0;
|
||
}
|
||
var info=get.info(card);
|
||
if(info.ai&&info.ai.wuxie){
|
||
var aiii=info.ai.wuxie(target,card,source,_status.event.player,state);
|
||
if(typeof aiii=='number') return aiii;
|
||
}
|
||
if(Math.abs(get.attitude(_status.event.player,source))<3) return 0;
|
||
return -get.attitude(_status.event.player,source)*state;
|
||
}
|
||
},
|
||
source:target,
|
||
source2:targets,
|
||
id:id,
|
||
id2:id2,
|
||
respondInfo:respondInfo,
|
||
});
|
||
if(event.stateplayer&&event.statecard) next.set('respondTo',[event.stateplayer,event.statecard]);
|
||
else if(!isJudge){
|
||
next.set('respondTo',[source,card]);
|
||
}
|
||
if(game.online){
|
||
_status.event._resultid=id;
|
||
game.resume();
|
||
}
|
||
else{
|
||
next.nouse=true;
|
||
}
|
||
};
|
||
event.settle=function(){
|
||
if(event.respondWuxie) event.trigger('eventNeutralized');
|
||
if(!event.state){
|
||
if(event.triggername=='phaseJudge'){
|
||
trigger.untrigger();
|
||
trigger.cancelled=true;
|
||
}
|
||
else{
|
||
trigger.neutralize();
|
||
if(event.guowuxie==true){
|
||
trigger.getParent().excluded.addArray(game.filterPlayer(function(current){
|
||
return current.isFriendOf(trigger.target);
|
||
}));
|
||
}
|
||
}
|
||
}
|
||
event.finish();
|
||
};
|
||
'step 1'
|
||
var info={};
|
||
if(event.statecard){
|
||
info.player=event.stateplayer;
|
||
info.card=event.statecard;
|
||
}
|
||
else if(event.triggername=='phaseJudge'){
|
||
info.card=trigger.card;
|
||
info.target=trigger.player;
|
||
}
|
||
else{
|
||
info.player=trigger.player;
|
||
info.card=trigger.card;
|
||
if(trigger.multitarget){
|
||
info.targets=trigger.targets;
|
||
}
|
||
else info.target=trigger.target;
|
||
}
|
||
event.respond_info=info;
|
||
var list=game.filterPlayer(function(current){
|
||
if(event.nowuxie) return false;
|
||
if(event.directHit&&event.directHit.includes(current)) return false;
|
||
if(event.triggername=='phaseJudge'){
|
||
if(game.checkMod(trigger.card,player,current,'unchanged','wuxieJudgeEnabled',current)==false) return false;
|
||
if(game.checkMod(trigger.card,player,current,'unchanged','wuxieJudgeRespondable',player)==false) return false;
|
||
if(event.stateplayer&&event.statecard&&(game.checkMod(event.statecard,event.stateplayer,player,current,'unchanged','wuxieRespondable',event.stateplayer)==false)) return false;
|
||
}
|
||
else{
|
||
if(!event.statecard&&trigger.getParent().directHit.includes(current)) return false;
|
||
if(game.checkMod(trigger.card,player,trigger.target,current,'unchanged','wuxieEnabled',current)==false) return false;
|
||
if(game.checkMod(trigger.card,player,trigger.target,current,'unchanged','wuxieRespondable',player)==false) return false;
|
||
if(event.stateplayer&&event.statecard&&(game.checkMod(event.statecard,event.stateplayer,trigger.player,current,'unchanged','wuxieRespondable',event.stateplayer)==false)) return false;
|
||
}
|
||
return current.hasWuxie(info);
|
||
});
|
||
event.list=list;
|
||
event.id=get.id();
|
||
list.sort(function(a,b){
|
||
return get.distance(event.source,a,'absolute')-get.distance(event.source,b,'absolute');
|
||
});
|
||
'step 2'
|
||
if(event.list.length==0){
|
||
event.settle();
|
||
}
|
||
else if(_status.connectMode&&(event.list[0].isOnline()||event.list[0]==game.me)){
|
||
event.goto(4);
|
||
}
|
||
else{
|
||
event.current=event.list.shift();
|
||
event.send(event.current,event.state,event.triggername=='phaseJudge',
|
||
event.card,event.source,event.target,event.targets,event.id,trigger.parent.id,event.tempnowuxie,null,event.respond_info);
|
||
}
|
||
'step 3'
|
||
if(result.bool){
|
||
event.wuxieresult=event.current;
|
||
event.wuxieresult2=result;
|
||
event.goto(8);
|
||
}
|
||
else{
|
||
event.goto(2);
|
||
}
|
||
'step 4'
|
||
var id=event.id;
|
||
var sendback=function(result,player){
|
||
if(result&&result.id==id&&!event.wuxieresult&&result.bool){
|
||
event.wuxieresult=player;
|
||
event.wuxieresult2=result;
|
||
game.broadcast('cancel',id);
|
||
return (function(){
|
||
if(_status.event.id==id&&_status.event.name=='chooseToUse'&&_status.paused) event.resultOL=_status.event.resultOL;
|
||
if(_status.event._parent_id==id){
|
||
ui.click.cancel();
|
||
}
|
||
if(_status.event.id==id){
|
||
if(_status.event._backup) ui.click.cancel();
|
||
ui.click.cancel();
|
||
if(ui.confirm){
|
||
ui.confirm.close();
|
||
}
|
||
if(_status.event.result){
|
||
_status.event.result.id=id;
|
||
}
|
||
}
|
||
});
|
||
}
|
||
else{
|
||
if(_status.event.id==id&&_status.event.name=='chooseToUse'&&_status.paused){
|
||
return (function(){
|
||
event.resultOL=_status.event.resultOL;
|
||
});
|
||
}
|
||
}
|
||
};
|
||
var withme=false;
|
||
var withol=false;
|
||
var list=event.list;
|
||
for(var i=0;i<list.length;i++){
|
||
if(list[i].isOnline()){
|
||
withol=true;
|
||
list[i].wait(sendback);
|
||
list[i].send(event.send,list[i],event.state,event.triggername=='phaseJudge',
|
||
event.card,event.source,event.target,event.targets,event.id,trigger.parent.id,event.tempnowuxie,get.skillState(list[i]),event.respond_info);
|
||
list.splice(i--,1);
|
||
}
|
||
else if(list[i]==game.me){
|
||
withme=true;
|
||
event.send(list[i],event.state,event.triggername=='phaseJudge',
|
||
event.card,event.source,event.target,event.targets,event.id,trigger.parent.id,event.tempnowuxie,null,respondInfo);
|
||
list.splice(i--,1);
|
||
}
|
||
}
|
||
if(!withme){
|
||
event.goto(6);
|
||
}
|
||
if(_status.connectMode){
|
||
if(withme||withol){
|
||
for(var i=0;i<game.players.length;i++){
|
||
game.players[i].showTimer();
|
||
}
|
||
}
|
||
}
|
||
event.withol=withol;
|
||
'step 5'
|
||
if(result&&result.bool&&!event.wuxieresult){
|
||
game.broadcast('cancel',event.id);
|
||
event.wuxieresult=game.me;
|
||
event.wuxieresult2=result;
|
||
}
|
||
'step 6'
|
||
if(event.withol&&!event.resultOL){
|
||
game.pause();
|
||
}
|
||
'step 7'
|
||
for(var i=0;i<game.players.length;i++){
|
||
game.players[i].hideTimer();
|
||
}
|
||
'step 8'
|
||
if(event.wuxieresult2&&event.wuxieresult2._sendskill) lib.skill[event.wuxieresult2._sendskill[0]]=event.wuxieresult2._sendskill[1];
|
||
if(event.wuxieresult&&event.wuxieresult2&&event.wuxieresult2.skill){
|
||
var info=get.info(event.wuxieresult2.skill);
|
||
if(info&&info.precontent&&!game.online){
|
||
var next=game.createEvent('pre_'+event.wuxieresult2);
|
||
next.setContent(info.precontent);
|
||
next.set('result',event.wuxieresult2);
|
||
next.set('player',event.wuxieresult);
|
||
}
|
||
}
|
||
'step 9'
|
||
if(event.wuxieresult){
|
||
var next=event.wuxieresult.useResult(event.wuxieresult2);
|
||
if(event.stateplayer&&event.statecard){
|
||
event.respondWuxie=true;
|
||
next.respondTo=[event.stateplayer,event.statecard];
|
||
}
|
||
else if(event.triggername!='phaseJudge'){
|
||
next.respondTo=[trigger.player,trigger.card];
|
||
}
|
||
}
|
||
'step 10'
|
||
if(event.wuxieresult){
|
||
if(result.wuxied){
|
||
event.nowuxie=result.nowuxie;
|
||
event.directHit=result.directHit;
|
||
event.stateplayer=event.wuxieresult;
|
||
if(event.wuxieresult2&&event.wuxieresult2.used){
|
||
event.statecard=event.wuxieresult2.used;
|
||
}
|
||
else{
|
||
event.statecard=true;
|
||
}
|
||
event.state=!event.state;
|
||
event.goto(1);
|
||
}
|
||
else event.settle();
|
||
}
|
||
else if(event.list.length){
|
||
event.goto(2);
|
||
}
|
||
else{
|
||
event.settle();
|
||
}
|
||
delete event.resultOL;
|
||
delete event.wuxieresult;
|
||
delete event.wuxieresult2;
|
||
}
|
||
},*/
|
||
},
|
||
translate: {
|
||
sha: "杀",
|
||
huosha: "火杀",
|
||
leisha: "雷杀",
|
||
icesha: "冰杀",
|
||
kamisha: "神杀",
|
||
cisha: "刺杀",
|
||
shan: "闪",
|
||
tao: "桃",
|
||
bagua: "八卦阵",
|
||
bagua_bg: "卦",
|
||
bagua_skill: "八卦阵",
|
||
jueying: "绝影",
|
||
dilu: "的卢",
|
||
zhuahuang: "爪黄飞电",
|
||
jueying_bg: "+马",
|
||
dilu_bg: "+马",
|
||
zhuahuang_bg: "+马",
|
||
chitu: "赤兔",
|
||
chitu_bg: "-马",
|
||
dawan: "大宛",
|
||
dawan_bg: "-马",
|
||
zixin: "紫骍",
|
||
zixin_bg: "-马",
|
||
zhuge: "诸葛连弩",
|
||
cixiong: "雌雄双股剑",
|
||
zhuge_bg: "弩",
|
||
cixiong_bg: "双",
|
||
qinggang: "青釭剑",
|
||
qinglong: "青龙偃月刀",
|
||
zhangba: "丈八蛇矛",
|
||
qinglong_bg: "偃",
|
||
zhangba_bg: "蛇",
|
||
guanshi: "贯石斧",
|
||
fangtian: "方天画戟",
|
||
qilin: "麒麟弓",
|
||
qilin_bg: "弓",
|
||
zhuge_skill: "诸葛连弩",
|
||
cixiong_skill: "雌雄双股剑",
|
||
qinggang_skill: "青釭剑",
|
||
qinglong_skill: "青龙偃月刀",
|
||
qinglong_guozhan: "青龙偃月刀",
|
||
zhangba_skill: "丈八蛇矛",
|
||
guanshi_skill: "贯石斧",
|
||
fangtian_skill: "方天画戟",
|
||
qilin_skill: "麒麟弓",
|
||
wugu: "五谷丰登",
|
||
taoyuan: "桃园结义",
|
||
nanman: "南蛮入侵",
|
||
wanjian: "万箭齐发",
|
||
wuzhong: "无中生有",
|
||
juedou: "决斗",
|
||
wugu_bg: "谷",
|
||
taoyuan_bg: "园",
|
||
nanman_bg: "蛮",
|
||
wanjian_bg: "箭",
|
||
wuzhong_bg: "生",
|
||
juedou_bg: "斗",
|
||
shunshou: "顺手牵羊",
|
||
guohe: "过河拆桥",
|
||
guohe_bg: "拆",
|
||
jiedao: "借刀杀人",
|
||
wuxie: "无懈可击",
|
||
wuxie_bg: "懈",
|
||
lebu: "乐不思蜀",
|
||
shandian: "闪电",
|
||
shandian_bg: "电",
|
||
hanbing: "寒冰剑",
|
||
renwang: "仁王盾",
|
||
hanbing_bg: "冰",
|
||
renwang_bg: "盾",
|
||
hanbing_skill: "寒冰剑",
|
||
renwang_skill: "仁王盾",
|
||
hanbing_info:
|
||
"当你因执行【杀】的效果而造成伤害时，若目标角色有能被弃置的牌，则你可以防止此伤害，然后依次弃置目标角色的两张牌。",
|
||
hanbing_skill_info:
|
||
"当你因执行【杀】的效果而造成伤害时，若目标角色有能被弃置的牌，则你可以防止此伤害，然后依次弃置目标角色的两张牌。",
|
||
renwang_info: "锁定技，黑色【杀】对你无效。",
|
||
renwang_skill_info: "锁定技，黑色【杀】对你无效。",
|
||
sha_info: "出牌阶段，对你攻击范围内的一名角色使用。其须使用一张【闪】，否则你对其造成1点伤害。",
|
||
shan_info: "抵消一张【杀】。",
|
||
tao_info:
|
||
"①出牌阶段，对自己使用，目标角色回复1点体力。②当有角色处于濒死状态时，对该角色使用。目标角色回复1点体力。",
|
||
bagua_info:
|
||
"当你需要使用或打出一张【闪】时，你可以进行判定。若结果为红色，则你视为使用或打出一张【闪】。",
|
||
bagua_skill_info:
|
||
"当你需要使用或打出一张【闪】时，你可以进行判定。若结果为红色，则你视为使用或打出一张【闪】。",
|
||
jueying_info: "锁定技，其他角色计算与你的距离+1。",
|
||
dilu_info: "锁定技，其他角色计算与你的距离+1。",
|
||
zhuahuang_info: "锁定技，其他角色计算与你的距离+1。",
|
||
chitu_info: "锁定技，你计算与其他角色的距离-1。",
|
||
dawan_info: "锁定技，你计算与其他角色的距离-1。",
|
||
zixin_info: "锁定技，你计算与其他角色的距离-1。",
|
||
zhuge_skill_info: "锁定技，你于出牌阶段内使用【杀】无次数限制。",
|
||
zhuge_info: "锁定技，你于出牌阶段内使用【杀】无次数限制。",
|
||
cixiong_skill_info:
|
||
"当你使用【杀】指定一名异性的目标角色后，你可以令其选择一项：1.弃置一张手牌；2.令你摸一张牌。",
|
||
cixiong_info:
|
||
"当你使用【杀】指定一名异性的目标角色后，你可以令其选择一项：1.弃置一张手牌；2.令你摸一张牌。",
|
||
qinggang_skill_info:
|
||
"锁定技，当你使用【杀】指定一名目标角色后，你令其防具技能无效直到此【杀】被抵消或造成伤害。",
|
||
qinggang_info:
|
||
"锁定技，当你使用【杀】指定一名目标角色后，你令其防具技能无效直到此【杀】被抵消或造成伤害。",
|
||
qinglong_skill_info:
|
||
"当你使用的【杀】被目标角色使用的【闪】抵消时，你可以对其使用一张【杀】（无距离限制）。",
|
||
qinglong_guozhan_info:
|
||
"锁定技，当你使用【杀】指定目标后，所有目标角色不能明置武将牌直到此【杀】结算完毕为止。",
|
||
qinglong_info:
|
||
"当你使用的【杀】被目标角色使用的【闪】抵消时，你可以对其使用一张【杀】（无距离限制）。",
|
||
qinglong_info_guozhan:
|
||
"锁定技，当你使用【杀】指定目标后，所有目标角色不能明置武将牌直到此【杀】结算完毕为止。",
|
||
zhangba_skill_info: "你可以将两张手牌当【杀】使用或打出。",
|
||
zhangba_info: "你可以将两张手牌当【杀】使用或打出。",
|
||
guanshi_skill_info:
|
||
"当你使用的【杀】被目标角色使用的【闪】抵消时，你可以弃置两张牌，令此【杀】依然对其造成伤害。",
|
||
guanshi_info:
|
||
"当你使用的【杀】被目标角色使用的【闪】抵消时，你可以弃置两张牌，令此【杀】依然对其造成伤害。",
|
||
fangtian_skill_info: "你使用的【杀】若是你最后的手牌，你可以额外选择至多两个目标。",
|
||
fangtian_info: "你使用的【杀】若是你最后的手牌，你可以额外选择至多两个目标。",
|
||
fangtian_info_guozhan:
|
||
"你使用【杀】可以指定任意名角色为目标（不能包含势力相同的角色），若任意一名目标角色使用【闪】抵消了此【杀】，则此【杀】对剩余的目标角色无效。",
|
||
qilin_skill_info: "当你使用【杀】对目标角色造成伤害时，你可以弃置其装备区里的一张坐骑牌。",
|
||
qilin_info: "当你使用【杀】对目标角色造成伤害时，你可以弃置其装备区里的一张坐骑牌。",
|
||
wugu_info:
|
||
"出牌阶段，对所有角色使用。（选择目标后）你从牌堆顶亮出等同于目标数量的牌，每名目标角色获得这些牌中（剩余的）的任意一张。",
|
||
taoyuan_info: "出牌阶段，对所有角色使用。每名目标角色回复1点体力。",
|
||
nanman_info: "出牌阶段，对所有其他角色使用。每名目标角色需打出一张【杀】，否则受到1点伤害。",
|
||
wanjian_info: "出牌阶段，对所有其他角色使用。每名目标角色需打出一张【闪】，否则受到1点伤害。",
|
||
wuzhong_info: "出牌阶段，对你使用。你摸两张牌。",
|
||
juedou_info:
|
||
"出牌阶段，对一名其他角色使用。由其开始，其与你轮流打出一张【杀】，直到其中一方未打出【杀】为止。未打出【杀】的一方受到另一方对其造成的1点伤害。",
|
||
shunshou_info: "出牌阶段，对距离为1且区域里有牌的一名其他角色使用。你获得其区域里的一张牌。",
|
||
guohe_info: "出牌阶段，对区域里有牌的一名其他角色使用。你弃置其区域里的一张牌。",
|
||
jiedao_info:
|
||
"出牌阶段，对装备区里有武器牌且有使用【杀】的目标的一名其他角色使用。令其对你指定的一名角色使用一张【杀】，否则将其装备区里的武器牌交给你。",
|
||
jiedao_append: '<span class="text" style="font-family: yuanli">这是一种十分含蓄的计谋。</span>',
|
||
wuxie_info:
|
||
"一张锦囊牌生效前，对此牌使用。抵消此牌对一名角色产生的效果，或抵消另一张【无懈可击】产生的效果。",
|
||
lebu_info: "出牌阶段，对一名其他角色使用。若判定结果不为红桃，跳过其出牌阶段。",
|
||
shandian_info:
|
||
"出牌阶段，对自己使用。若判定结果为黑桃2~9，则目标角色受到3点雷电伤害。若判定不为黑桃2~9，将之移动到下家的判定区里。",
|
||
icesha_skill: "冰冻",
|
||
icesha_skill_info: "防止即将造成的伤害，改为依次弃置其两张牌。",
|
||
sha_notshan: "invisible",
|
||
qinggang2: "破防",
|
||
},
|
||
list: [
|
||
["spade", 7, "sha"],
|
||
["spade", 8, "sha"],
|
||
["spade", 8, "sha"],
|
||
["spade", 9, "sha"],
|
||
["spade", 9, "sha"],
|
||
["spade", 10, "sha"],
|
||
["spade", 10, "sha"],
|
||
["club", 2, "sha"],
|
||
["club", 3, "sha"],
|
||
["club", 4, "sha"],
|
||
["club", 5, "sha"],
|
||
["club", 6, "sha"],
|
||
["club", 7, "sha"],
|
||
["club", 8, "sha"],
|
||
["club", 8, "sha"],
|
||
["club", 9, "sha"],
|
||
["club", 9, "sha"],
|
||
["club", 10, "sha"],
|
||
["club", 10, "sha"],
|
||
["club", 11, "sha"],
|
||
["club", 11, "sha"],
|
||
["heart", 10, "sha"],
|
||
["heart", 10, "sha"],
|
||
["heart", 11, "sha"],
|
||
["diamond", 6, "sha"],
|
||
["diamond", 7, "sha"],
|
||
["diamond", 8, "sha"],
|
||
["diamond", 9, "sha"],
|
||
["diamond", 10, "sha"],
|
||
["diamond", 13, "sha"],
|
||
["heart", 2, "shan"],
|
||
["heart", 2, "shan"],
|
||
["heart", 13, "shan"],
|
||
["diamond", 2, "shan"],
|
||
["diamond", 2, "shan"],
|
||
["diamond", 3, "shan"],
|
||
["diamond", 4, "shan"],
|
||
["diamond", 5, "shan"],
|
||
["diamond", 6, "shan"],
|
||
["diamond", 7, "shan"],
|
||
["diamond", 8, "shan"],
|
||
["diamond", 9, "shan"],
|
||
["diamond", 10, "shan"],
|
||
["diamond", 11, "shan"],
|
||
["diamond", 11, "shan"],
|
||
["heart", 3, "tao"],
|
||
["heart", 4, "tao"],
|
||
["heart", 6, "tao"],
|
||
["heart", 7, "tao"],
|
||
["heart", 8, "tao"],
|
||
["heart", 9, "tao"],
|
||
["heart", 12, "tao"],
|
||
["diamond", 12, "tao"],
|
||
|
||
["spade", 2, "bagua"],
|
||
["club", 2, "bagua"],
|
||
["spade", 5, "jueying"],
|
||
["club", 5, "dilu"],
|
||
["heart", 13, "zhuahuang"],
|
||
["heart", 5, "chitu"],
|
||
["spade", 13, "dawan"],
|
||
["diamond", 13, "zixin"],
|
||
["club", 1, "zhuge"],
|
||
["diamond", 1, "zhuge"],
|
||
["spade", 2, "cixiong"],
|
||
["spade", 6, "qinggang"],
|
||
["spade", 5, "qinglong"],
|
||
["spade", 12, "zhangba"],
|
||
["diamond", 5, "guanshi"],
|
||
["diamond", 12, "fangtian"],
|
||
["heart", 5, "qilin"],
|
||
|
||
["heart", 3, "wugu"],
|
||
["heart", 4, "wugu"],
|
||
["heart", 1, "taoyuan"],
|
||
["spade", 7, "nanman"],
|
||
["spade", 13, "nanman"],
|
||
["club", 7, "nanman"],
|
||
["heart", 1, "wanjian"],
|
||
["spade", 1, "juedou"],
|
||
["club", 1, "juedou"],
|
||
["diamond", 1, "juedou"],
|
||
["heart", 7, "wuzhong"],
|
||
["heart", 8, "wuzhong"],
|
||
["heart", 9, "wuzhong"],
|
||
["heart", 11, "wuzhong"],
|
||
["spade", 3, "shunshou"],
|
||
["spade", 4, "shunshou"],
|
||
["spade", 11, "shunshou"],
|
||
["diamond", 3, "shunshou"],
|
||
["diamond", 4, "shunshou"],
|
||
["spade", 3, "guohe"],
|
||
["spade", 4, "guohe"],
|
||
["spade", 12, "guohe"],
|
||
["club", 3, "guohe"],
|
||
["club", 4, "guohe"],
|
||
["heart", 12, "guohe"],
|
||
["club", 12, "jiedao"],
|
||
["club", 13, "jiedao"],
|
||
["spade", 11, "wuxie"],
|
||
["club", 12, "wuxie"],
|
||
["club", 13, "wuxie"],
|
||
["spade", 6, "lebu"],
|
||
["club", 6, "lebu"],
|
||
["heart", 6, "lebu"],
|
||
["spade", 1, "shandian"],
|
||
["spade", 2, "hanbing"],
|
||
["club", 2, "renwang"],
|
||
["heart", 12, "shandian"],
|
||
["diamond", 12, "wuxie"],
|
||
],
|
||
};
|
||
});
|