1240 lines
35 KiB
JavaScript
1240 lines
35 KiB
JavaScript
import { lib, game, ui, get, ai, _status } from "../noname.js";
|
||
game.import("card", function () {
|
||
return {
|
||
name: "extra",
|
||
connect: true,
|
||
card: {
|
||
muniu: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip5",
|
||
nomod: true,
|
||
onEquip: function () {
|
||
if (card && card.cards && card.cards.length) {
|
||
player.directgains(card.cards, null, "muniu");
|
||
}
|
||
player.markSkill("muniu_skill");
|
||
},
|
||
forceDie: true,
|
||
onLose: function () {
|
||
delete player.getStat("skill").muniu_skill;
|
||
player.unmarkSkill("muniu_skill");
|
||
if (!card || !card.cards || !card.cards.length) return;
|
||
if (
|
||
(!event.getParent(2) || event.getParent(2).name != "swapEquip") &&
|
||
(event.getParent().type != "equip" || event.getParent().swapEquip)
|
||
) {
|
||
player.lose(card.cards, ui.discardPile);
|
||
player.$throw(card.cards, 1000);
|
||
player.popup("muniu");
|
||
game.log(card, "掉落了", card.cards);
|
||
card.cards.length = 0;
|
||
} else {
|
||
player.lose(card.cards, ui.special);
|
||
}
|
||
},
|
||
clearLose: true,
|
||
equipDelay: false,
|
||
loseDelay: false,
|
||
skills: ["muniu_skill", "muniu_skill7"],
|
||
ai: {
|
||
equipValue: function (card) {
|
||
if (card.card) return 7 + card.card.length;
|
||
return 7;
|
||
},
|
||
basic: {
|
||
equipValue: 7,
|
||
},
|
||
},
|
||
},
|
||
jiu: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "basic",
|
||
toself: true,
|
||
enable: function (event, player) {
|
||
//return !player.hasSkill('jiu');
|
||
return true;
|
||
},
|
||
lianheng: true,
|
||
logv: false,
|
||
savable: function (card, player, dying) {
|
||
return dying == player || player.hasSkillTag("jiuOther", null, dying, true);
|
||
},
|
||
usable: 1,
|
||
selectTarget: -1,
|
||
modTarget: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target == player;
|
||
},
|
||
content: function () {
|
||
if (typeof event.baseDamage != "number") event.baseDamage = 1;
|
||
if (target.isDying() || event.getParent(2).type == "dying") {
|
||
target.recover();
|
||
if (_status.currentPhase == target) {
|
||
target.getStat().card.jiu--;
|
||
}
|
||
} else {
|
||
game.addVideo("jiuNode", target, true);
|
||
if (cards && cards.length) {
|
||
card = cards[0];
|
||
}
|
||
if (!target.storage.jiu) target.storage.jiu = 0;
|
||
target.storage.jiu += event.baseDamage;
|
||
game.broadcastAll(
|
||
function (target, card, gain2) {
|
||
target.addSkill("jiu");
|
||
if (!target.node.jiu && lib.config.jiu_effect) {
|
||
target.node.jiu = ui.create.div(".playerjiu", target.node.avatar);
|
||
target.node.jiu2 = ui.create.div(".playerjiu", target.node.avatar2);
|
||
}
|
||
if (
|
||
gain2 &&
|
||
card.clone &&
|
||
(card.clone.parentNode == target.parentNode ||
|
||
card.clone.parentNode == ui.arena)
|
||
) {
|
||
card.clone.moveDelete(target);
|
||
}
|
||
},
|
||
target,
|
||
card,
|
||
target == targets[0] && cards.length == 1
|
||
);
|
||
if (target == targets[0] && cards.length == 1) {
|
||
if (
|
||
card.clone &&
|
||
(card.clone.parentNode == target.parentNode ||
|
||
card.clone.parentNode == ui.arena)
|
||
) {
|
||
game.addVideo("gain2", target, get.cardsInfo([card]));
|
||
}
|
||
}
|
||
}
|
||
},
|
||
ai: {
|
||
basic: {
|
||
useful: (card, i) => {
|
||
if (_status.event.player.hp > 1) {
|
||
if (i === 0) return 4;
|
||
return 1;
|
||
}
|
||
if (i === 0) return 7.3;
|
||
return 3;
|
||
},
|
||
value: (card, player, i) => {
|
||
if (player.hp > 1) {
|
||
if (i === 0) return 5;
|
||
return 1;
|
||
}
|
||
if (i === 0) return 7.3;
|
||
return 3;
|
||
},
|
||
},
|
||
order: () => {
|
||
if (_status.event.dying) return 9;
|
||
let sha = get.order({ name: "sha" });
|
||
if (sha > 0) return sha + 0.2;
|
||
return 0;
|
||
},
|
||
result: {
|
||
target: (player, target, card) => {
|
||
if (target && target.isDying()) return 2;
|
||
if (!target || target._jiu_temp || !target.isPhaseUsing()) return 0;
|
||
let usable = target.getCardUsable("sha");
|
||
if (
|
||
!usable ||
|
||
(lib.config.mode === "stone" &&
|
||
!player.isMin() &&
|
||
player.getActCount() + 1 >= player.actcount) ||
|
||
!target.mayHaveSha(player, "use", card)
|
||
)
|
||
return 0;
|
||
let effs = { order: 0 },
|
||
temp;
|
||
target.getCards("hs", (i) => {
|
||
if (get.name(i) !== "sha" || ui.selected.cards.includes(i)) return false;
|
||
temp = get.order(i, target);
|
||
if (temp < effs.order) return false;
|
||
if (temp > effs.order) effs = { order: temp };
|
||
effs[i.cardid] = {
|
||
card: i,
|
||
target: null,
|
||
eff: 0,
|
||
};
|
||
});
|
||
delete effs.order;
|
||
for (let i in effs) {
|
||
if (!lib.filter.filterCard(effs[i].card, target)) continue;
|
||
game.filterPlayer((current) => {
|
||
if (
|
||
get.attitude(target, current) >= 0 ||
|
||
!target.canUse(effs[i].card, current, null, true) ||
|
||
current.hasSkillTag("filterDamage", null, {
|
||
player: target,
|
||
card: effs[i].card,
|
||
jiu: true,
|
||
})
|
||
)
|
||
return false;
|
||
temp = get.effect(current, effs[i].card, target, player);
|
||
if (temp <= effs[i].eff) return false;
|
||
effs[i].target = current;
|
||
effs[i].eff = temp;
|
||
return false;
|
||
});
|
||
if (!effs[i].target) continue;
|
||
if (
|
||
target.hasSkillTag(
|
||
"directHit_ai",
|
||
true,
|
||
{
|
||
target: effs[i].target,
|
||
card: i,
|
||
},
|
||
true
|
||
) ||
|
||
(usable === 1 &&
|
||
(target.needsToDiscard() > Math.max(0, 3 - target.hp) ||
|
||
!effs[i].target.mayHaveShan(
|
||
player,
|
||
"use",
|
||
effs[i].target.getCards((i) => {
|
||
return i.hasGaintag("sha_notshan");
|
||
})
|
||
)))
|
||
) {
|
||
delete target._jiu_temp;
|
||
return 1;
|
||
}
|
||
}
|
||
delete target._jiu_temp;
|
||
return 0;
|
||
},
|
||
},
|
||
tag: {
|
||
save: 1,
|
||
recover: 0.1,
|
||
},
|
||
},
|
||
},
|
||
huogong: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
//cardnature:'fire',
|
||
filterTarget: function (card, player, target) {
|
||
//if(player!=game.me&&player.countCards('h')<2) return false;
|
||
return target.countCards("h") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (target.countCards("h") == 0) {
|
||
event.finish();
|
||
return;
|
||
} else if (target.countCards("h") == 1) event._result = { cards: target.getCards("h") };
|
||
else
|
||
target.chooseCard(true).ai = function (card) {
|
||
if (_status.event.getRand() < 0.5) return Math.random();
|
||
return get.value(card);
|
||
};
|
||
"step 1";
|
||
target.showCards(result.cards).setContent(function () {});
|
||
event.dialog = ui.create.dialog(get.translation(target) + "展示的手牌", result.cards);
|
||
event.videoId = lib.status.videoId++;
|
||
|
||
game.broadcast(
|
||
"createDialog",
|
||
event.videoId,
|
||
get.translation(target) + "展示的手牌",
|
||
result.cards
|
||
);
|
||
game.addVideo("cardDialog", null, [
|
||
get.translation(target) + "展示的手牌",
|
||
get.cardsInfo(result.cards),
|
||
event.videoId,
|
||
]);
|
||
event.card2 = result.cards[0];
|
||
game.log(target, "展示了", event.card2);
|
||
game.addCardKnower(result.cards, "everyone");
|
||
event._result = {};
|
||
player
|
||
.chooseToDiscard({ suit: get.suit(event.card2) }, function (card) {
|
||
var evt = _status.event.getParent();
|
||
if (get.damageEffect(evt.target, evt.player, evt.player, "fire") > 0) {
|
||
return 6.2 + Math.min(4, evt.player.hp) - get.value(card, evt.player);
|
||
}
|
||
return -1;
|
||
})
|
||
.set("prompt", false);
|
||
game.delay(2);
|
||
"step 2";
|
||
if (result.bool) {
|
||
target.damage("fire");
|
||
} else {
|
||
target.addTempSkill("huogong2");
|
||
}
|
||
event.dialog.close();
|
||
game.addVideo("cardDialog", null, event.videoId);
|
||
game.broadcast("closeDialog", event.videoId);
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 9.2,
|
||
value: [3, 1],
|
||
useful: 0.6,
|
||
},
|
||
wuxie: function (target, card, player, viewer, status) {
|
||
if (get.attitude(viewer, player._trueMe || player) > 0) return 0;
|
||
if (
|
||
status *
|
||
get.attitude(viewer, target) *
|
||
get.effect(target, card, player, target) >=
|
||
0
|
||
)
|
||
return 0;
|
||
if (_status.event.getRand("huogong_wuxie") * 4 > player.countCards("h")) return 0;
|
||
},
|
||
result: {
|
||
player: function (player) {
|
||
var nh = player.countCards("h");
|
||
if (nh <= player.hp && nh <= 4 && _status.event.name == "chooseToUse") {
|
||
if (
|
||
typeof _status.event.filterCard == "function" &&
|
||
_status.event.filterCard(
|
||
new lib.element.VCard({ name: "huogong" }),
|
||
player,
|
||
_status.event
|
||
)
|
||
) {
|
||
return -10;
|
||
}
|
||
if (_status.event.skill) {
|
||
var viewAs = get.info(_status.event.skill).viewAs;
|
||
if (viewAs == "huogong") return -10;
|
||
if (viewAs && viewAs.name == "huogong") return -10;
|
||
}
|
||
}
|
||
return 0;
|
||
},
|
||
target: function (player, target) {
|
||
if (target.hasSkill("huogong2") || target.countCards("h") == 0) return 0;
|
||
if (player.countCards("h") <= 1) return 0;
|
||
if (_status.event.player == player) {
|
||
if (target.isAllCardsKnown(player)) {
|
||
if (
|
||
!target.countCards("h", (card) => {
|
||
return player.countCards("h", (card2) => {
|
||
return get.suit(card2) == get.suit(card);
|
||
});
|
||
})
|
||
) {
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
if (target == player) {
|
||
if (
|
||
typeof _status.event.filterCard == "function" &&
|
||
_status.event.filterCard(
|
||
new lib.element.VCard({ name: "huogong" }),
|
||
player,
|
||
_status.event
|
||
)
|
||
) {
|
||
return -1.15;
|
||
}
|
||
if (_status.event.skill) {
|
||
var viewAs = get.info(_status.event.skill).viewAs;
|
||
if (viewAs == "huogong") return -1.15;
|
||
if (viewAs && viewAs.name == "huogong") return -1.15;
|
||
}
|
||
return 0;
|
||
}
|
||
return -1.15;
|
||
},
|
||
},
|
||
tag: {
|
||
damage: 1,
|
||
fireDamage: 1,
|
||
natureDamage: 1,
|
||
norepeat: 1,
|
||
},
|
||
},
|
||
},
|
||
tiesuo: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "trick",
|
||
enable: true,
|
||
filterTarget: true,
|
||
selectTarget: [1, 2],
|
||
complexTarget: true,
|
||
content: function () {
|
||
target.link();
|
||
},
|
||
recastable: true,
|
||
ai: {
|
||
wuxie: (target, card, player, viewer, status) => {
|
||
if (
|
||
status * get.attitude(viewer, player._trueMe || player) > 0 ||
|
||
target.hasSkillTag("nodamage") ||
|
||
target.hasSkillTag("nofire") ||
|
||
target.hasSkillTag("nothunder") ||
|
||
get.attitude(viewer, player) > 0 ||
|
||
(1 + target.countCards("hs")) * _status.event.getRand() > 1.57
|
||
)
|
||
return 0;
|
||
},
|
||
basic: {
|
||
order: 7.3,
|
||
useful: 1.2,
|
||
value: 4,
|
||
},
|
||
result: {
|
||
target: (player, target) => {
|
||
if (target.hasSkillTag("link")) return 0;
|
||
let curs = game.filterPlayer((current) => {
|
||
if (current.hasSkillTag("nodamage")) return false;
|
||
return !current.hasSkillTag("nofire") || !current.hasSkillTag("nothunder");
|
||
});
|
||
if (curs.length < 2) return 0;
|
||
let f = target.hasSkillTag("nofire"),
|
||
t = target.hasSkillTag("nothunder"),
|
||
res = 0.9;
|
||
if ((f && t) || target.hasSkillTag("nodamage")) return 0;
|
||
if (f || t) res = 0.45;
|
||
if (!f && target.getEquip("tengjia")) res *= 2;
|
||
if (!target.isLinked()) res = -res;
|
||
if (ui.selected.targets.length) return res;
|
||
let fs = 0,
|
||
es = 0,
|
||
att = get.attitude(player, target),
|
||
linkf = false,
|
||
alink = true;
|
||
curs.forEach((i) => {
|
||
let atti = get.attitude(player, i);
|
||
if (atti > 0) {
|
||
fs++;
|
||
if (i.isLinked()) linkf = true;
|
||
} else if (atti < 0) {
|
||
es++;
|
||
if (!i.isLinked()) alink = false;
|
||
}
|
||
});
|
||
if (es < 2 && !alink) {
|
||
if (att <= 0 || (att > 0 && linkf && fs < 2)) return 0;
|
||
}
|
||
return res;
|
||
},
|
||
},
|
||
tag: {
|
||
multitarget: 1,
|
||
multineg: 1,
|
||
norepeat: 1,
|
||
},
|
||
},
|
||
},
|
||
bingliang: {
|
||
audio: true,
|
||
fullskin: true,
|
||
type: "delay",
|
||
range: { global: 1 },
|
||
filterTarget: function (card, player, target) {
|
||
return lib.filter.judge(card, player, target) && player != target;
|
||
},
|
||
judge: function (card) {
|
||
if (get.suit(card) == "club") return 1;
|
||
return -2;
|
||
},
|
||
judge2: function (result) {
|
||
if (result.bool == false) return true;
|
||
return false;
|
||
},
|
||
effect: function () {
|
||
if (result.bool == false) {
|
||
if (get.is.changban()) player.addTempSkill("bingliang_changban");
|
||
else player.skip("phaseDraw");
|
||
}
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 1,
|
||
useful: 1,
|
||
value: 4,
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.hasJudge("caomu")) return 0;
|
||
return -2.7 / Math.sqrt(target.countCards("h") + 1);
|
||
},
|
||
},
|
||
tag: {
|
||
skip: "phaseDraw",
|
||
},
|
||
},
|
||
},
|
||
hualiu: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip3",
|
||
distance: { globalTo: 1 },
|
||
},
|
||
zhuque: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
//cardnature:'fire',
|
||
distance: { attackFrom: -3 },
|
||
ai: {
|
||
basic: {
|
||
equipValue: 2,
|
||
},
|
||
},
|
||
skills: ["zhuque_skill"],
|
||
},
|
||
guding: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
distance: { attackFrom: -1 },
|
||
ai: {
|
||
basic: {
|
||
equipValue: 2,
|
||
},
|
||
},
|
||
skills: ["guding_skill"],
|
||
},
|
||
tengjia: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip2",
|
||
//cardnature:'fire',
|
||
ai: {
|
||
value: function (card, player, index, method) {
|
||
if (player.isDisabled(2)) return 0.01;
|
||
if (player.getEquips("tengjia").includes(card)) {
|
||
if (player.hasSkillTag("noDirectDamage")) return 10;
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return (
|
||
current != player &&
|
||
get.attitude(current, player) < 0 &&
|
||
current.hasSkillTag("fireAttack", null, null, true)
|
||
);
|
||
})
|
||
)
|
||
return 0;
|
||
return 6;
|
||
}
|
||
var value = 0;
|
||
var info = get.info(card);
|
||
var current = player.getEquip(info.subtype);
|
||
if (current && card != current) {
|
||
value = get.value(current, player);
|
||
}
|
||
var equipValue = info.ai.equipValue;
|
||
if (equipValue == undefined) {
|
||
equipValue = info.ai.basic.equipValue;
|
||
}
|
||
if (typeof equipValue == "function") {
|
||
if (method == "raw") return equipValue(card, player);
|
||
if (method == "raw2") return equipValue(card, player) - value;
|
||
return Math.max(0.1, equipValue(card, player) - value);
|
||
}
|
||
if (typeof equipValue != "number") equipValue = 0;
|
||
if (method == "raw") return equipValue;
|
||
if (method == "raw2") return equipValue - value;
|
||
return Math.max(0.1, equipValue - value);
|
||
},
|
||
equipValue: function (card, player) {
|
||
if (player._tengjiaEv_temp) return Math.max(1, 6 - player.hp);
|
||
if (player.hasSkillTag("maixie") && player.hp > 1) return 0;
|
||
if (player.hasSkillTag("noDirectDamage")) return 10;
|
||
player._tengjiaEv_temp = true;
|
||
let eff = get.damageEffect(player, player, player, "fire");
|
||
delete player._tengjiaEv_temp;
|
||
if (eff >= 0) return 10;
|
||
let num =
|
||
4 -
|
||
game.countPlayer(function (current) {
|
||
if (get.attitude(current, player) < 0) {
|
||
if (current.hasSkillTag("fireAttack", null, null, true)) return 3;
|
||
return 1;
|
||
}
|
||
return false;
|
||
});
|
||
if (player.hp == 1) num += 3;
|
||
if (player.hp == 2) num += 1;
|
||
return num;
|
||
},
|
||
basic: {
|
||
equipValue: 3,
|
||
},
|
||
},
|
||
skills: ["tengjia1", "tengjia2", "tengjia3"],
|
||
},
|
||
baiyin: {
|
||
fullskin: true,
|
||
type: "equip",
|
||
subtype: "equip2",
|
||
loseDelay: false,
|
||
onLose: function () {
|
||
player.addTempSkill("baiyin_skill_lose");
|
||
},
|
||
skills: ["baiyin_skill"],
|
||
tag: {
|
||
recover: 1,
|
||
},
|
||
ai: {
|
||
order: 9.5,
|
||
equipValue: function (card, player) {
|
||
if (player.hp == player.maxHp) return 5;
|
||
if (player.countCards("h", "baiyin")) return 6;
|
||
return 0;
|
||
},
|
||
basic: {
|
||
equipValue: 5,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
skill: {
|
||
bingliang_changban: {
|
||
cardSkill: true,
|
||
unique: true,
|
||
trigger: { player: "phaseDrawBegin" },
|
||
silent: true,
|
||
content: function () {
|
||
trigger.num--;
|
||
},
|
||
group: "bingliang_changban2",
|
||
},
|
||
bingliang_changban2: {
|
||
cardSkill: true,
|
||
trigger: { player: "phaseDrawAfter" },
|
||
silent: true,
|
||
content: function () {
|
||
if (player.enemy) player.enemy.draw();
|
||
},
|
||
},
|
||
muniu_skill: {
|
||
equipSkill: true,
|
||
enable: "phaseUse",
|
||
usable: 1,
|
||
filterCard: true,
|
||
check: function (card) {
|
||
if (card.name == "du") return 20;
|
||
var player = _status.event.player;
|
||
var nh = player.countCards("h");
|
||
if (!player.needsToDiscard()) {
|
||
if (nh < 3) return 0;
|
||
if (nh == 3) return 5 - get.value(card);
|
||
return 7 - get.value(card);
|
||
}
|
||
return 10 - get.useful(card);
|
||
},
|
||
discard: false,
|
||
lose: false,
|
||
delay: false,
|
||
sync: function (muniu) {
|
||
if (game.online) {
|
||
return;
|
||
}
|
||
if (!muniu.cards) {
|
||
muniu.cards = [];
|
||
}
|
||
for (var i = 0; i < muniu.cards.length; i++) {
|
||
if (get.position(muniu.cards[i]) != "s") {
|
||
muniu.cards.splice(i--, 1);
|
||
}
|
||
}
|
||
game.broadcast(
|
||
function (muniu, cards) {
|
||
muniu.cards = cards;
|
||
},
|
||
muniu,
|
||
muniu.cards
|
||
);
|
||
},
|
||
filter: function (event, player) {
|
||
return player.countCards("h") > 0;
|
||
},
|
||
prepare: function (cards, player) {
|
||
player.$give(1, player, false);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.loseToSpecial(cards, "muniu");
|
||
"step 1";
|
||
for (var i = 0; i < cards.length; i++) {
|
||
if (
|
||
cards[i]._selfDestroyed ||
|
||
!cards[i].hasGaintag("muniu") ||
|
||
get.position(cards[i]) != "s"
|
||
) {
|
||
cards[i].remove();
|
||
cards.splice(i--, 1);
|
||
}
|
||
}
|
||
var muniu = player.getEquip("muniu");
|
||
if (!muniu || !cards.length) {
|
||
for (var i = 0; i < cards.length; i++) {
|
||
cards[i].discard();
|
||
}
|
||
event.finish();
|
||
return;
|
||
}
|
||
if (muniu.cards == undefined) muniu.cards = [];
|
||
muniu.cards.push(cards[0]);
|
||
game.broadcast(
|
||
function (muniu, cards) {
|
||
muniu.cards = cards;
|
||
},
|
||
muniu,
|
||
muniu.cards
|
||
);
|
||
game.delayx();
|
||
"step 2";
|
||
var muniu = player.getEquip("muniu");
|
||
var players = game.filterPlayer(function (current) {
|
||
if (
|
||
current.canEquip(muniu) &&
|
||
current != player &&
|
||
!current.isTurnedOver() &&
|
||
get.attitude(player, current) >= 3 &&
|
||
get.attitude(current, player) >= 3
|
||
) {
|
||
return true;
|
||
}
|
||
});
|
||
players.sort(lib.sort.seat);
|
||
var choice = players[0];
|
||
var next = player
|
||
.chooseTarget("是否移动木牛流马？", function (card, player, target) {
|
||
return (
|
||
!target.isMin() && player != target && target.canEquip(_status.event.muniu)
|
||
);
|
||
})
|
||
.set("muniu", muniu);
|
||
next.set("ai", function (target) {
|
||
return target == _status.event.choice ? 1 : -1;
|
||
});
|
||
next.set("choice", choice);
|
||
"step 3";
|
||
if (result.bool) {
|
||
var card = player.getEquip("muniu");
|
||
result.targets[0].equip(card);
|
||
player.$give(card, result.targets[0]);
|
||
player.line(result.targets, "green");
|
||
game.delay();
|
||
} else {
|
||
player.updateMarks();
|
||
}
|
||
},
|
||
ai: {
|
||
order: 1,
|
||
expose: 0.1,
|
||
result: {
|
||
player: 1,
|
||
},
|
||
},
|
||
mod: {
|
||
cardEnabled2: function (card, player) {
|
||
if (!ui.selected.cards.length) return;
|
||
var muniu = player.getEquip("muniu");
|
||
if (!muniu || !muniu.cards || !muniu.cards.length) return;
|
||
for (var i of ui.selected.cards) {
|
||
if (i == muniu && muniu.cards.includes(card)) return false;
|
||
if (muniu.cards.includes(i) && card == muniu) return false;
|
||
}
|
||
},
|
||
},
|
||
mark: true,
|
||
markimage2: "image/card/muniu_small.png",
|
||
intro: {
|
||
content: function (storage, player) {
|
||
var muniu = player.getEquip("muniu");
|
||
if (!muniu || !muniu.cards || !muniu.cards.length) return "共有零张牌";
|
||
if (player.isUnderControl(true)) {
|
||
return get.translation(muniu.cards);
|
||
} else {
|
||
return "共有" + get.cnNumber(muniu.cards.length) + "张牌";
|
||
}
|
||
},
|
||
mark: function (dialog, storage, player) {
|
||
var muniu = player.getEquip("muniu");
|
||
if (!muniu || !muniu.cards || !muniu.cards.length) return "共有零张牌";
|
||
if (player.isUnderControl(true)) {
|
||
dialog.addAuto(muniu.cards);
|
||
} else {
|
||
return "共有" + get.cnNumber(muniu.cards.length) + "张牌";
|
||
}
|
||
},
|
||
markcount: function (storage, player) {
|
||
var muniu = player.getEquip("muniu");
|
||
if (muniu && muniu.cards) return muniu.cards.length;
|
||
return 0;
|
||
},
|
||
},
|
||
},
|
||
muniu_skill7: {
|
||
trigger: { player: "loseEnd" },
|
||
firstDo: true,
|
||
forced: true,
|
||
//silent:true,
|
||
filter: function (event, player) {
|
||
if (!event.ss || !event.ss.length || event.parent.name == "lose_muniu") return false;
|
||
var muniu = player.getEquip("muniu");
|
||
if (!muniu || !muniu.cards) return false;
|
||
return (
|
||
event.ss.filter(function (card) {
|
||
return muniu.cards.includes(card);
|
||
}).length > 0
|
||
);
|
||
},
|
||
content: function () {
|
||
var muniu = player.getEquip("muniu");
|
||
if (muniu && muniu.cards) {
|
||
muniu.cards.removeArray(trigger.ss);
|
||
lib.skill.muniu_skill.sync(muniu);
|
||
}
|
||
player.updateMarks();
|
||
},
|
||
},
|
||
huogong2: { charlotte: true },
|
||
jiu: {
|
||
trigger: { player: "useCard1" },
|
||
filter: function (event) {
|
||
return event.card && event.card.name == "sha";
|
||
},
|
||
forced: true,
|
||
charlotte: true,
|
||
firstDo: true,
|
||
content: function () {
|
||
if (!trigger.baseDamage) trigger.baseDamage = 1;
|
||
trigger.baseDamage += player.storage.jiu;
|
||
trigger.jiu = true;
|
||
trigger.jiu_add = player.storage.jiu;
|
||
game.addVideo("jiuNode", player, false);
|
||
game.broadcastAll(function (player) {
|
||
player.removeSkill("jiu");
|
||
}, player);
|
||
},
|
||
temp: true,
|
||
vanish: true,
|
||
silent: true,
|
||
popup: false,
|
||
nopop: true,
|
||
onremove: function (player) {
|
||
if (player.node.jiu) {
|
||
player.node.jiu.delete();
|
||
player.node.jiu2.delete();
|
||
delete player.node.jiu;
|
||
delete player.node.jiu2;
|
||
}
|
||
delete player.storage.jiu;
|
||
},
|
||
ai: {
|
||
damageBonus: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
if (tag === "damageBonus") return arg && arg.card && arg.card.name === "sha";
|
||
},
|
||
},
|
||
group: "jiu2",
|
||
},
|
||
jiu2: {
|
||
trigger: { player: "useCardAfter", global: "phaseAfter" },
|
||
priority: 2,
|
||
firstDo: true,
|
||
charlotte: true,
|
||
filter: function (event, player) {
|
||
if (player.hasSkillTag("jiuSustain", null, event.name)) return false;
|
||
if (event.name == "useCard") return event.card && event.card.name == "sha";
|
||
return true;
|
||
},
|
||
forced: true,
|
||
popup: false,
|
||
audio: false,
|
||
content: function () {
|
||
game.broadcastAll(function (player) {
|
||
player.removeSkill("jiu");
|
||
}, player);
|
||
game.addVideo("jiuNode", player, false);
|
||
},
|
||
},
|
||
guding_skill: {
|
||
equipSkill: true,
|
||
audio: true,
|
||
trigger: { source: "damageBegin1" },
|
||
filter: function (event) {
|
||
if (event.parent.name == "_lianhuan" || event.parent.name == "_lianhuan2") return false;
|
||
if (event.card && event.card.name == "sha") {
|
||
if (event.player.countCards("h") == 0) return true;
|
||
}
|
||
return false;
|
||
},
|
||
forced: true,
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
ai: {
|
||
effect: {
|
||
player: function (card, player, target, current, isLink) {
|
||
if (
|
||
card.name == "sha" &&
|
||
!isLink &&
|
||
target.countCards("h") == 0 &&
|
||
!target.hasSkillTag("filterDamage", null, {
|
||
player: player,
|
||
card: card,
|
||
})
|
||
)
|
||
return [1, 0, 1, -3];
|
||
},
|
||
},
|
||
},
|
||
},
|
||
tengjia1: {
|
||
equipSkill: true,
|
||
trigger: { target: ["useCardToBefore"] },
|
||
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;
|
||
if (event.card.name == "nanman") return true;
|
||
if (event.card.name == "wanjian") return true;
|
||
//if(event.card.name=='chuqibuyi') return true;
|
||
return false;
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
},
|
||
ai: {
|
||
effect: {
|
||
target: function (card, player, target, current) {
|
||
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(card.name=='nanman'||card.name=='wanjian'||card.name=='chuqibuyi') return 'zerotarget';
|
||
if (card.name == "nanman" || card.name == "wanjian") return "zerotarget";
|
||
if (card.name == "sha") {
|
||
var equip1 = player.getEquip("zhuque");
|
||
if (equip1 && equip1.name == "zhuque") return 1.9;
|
||
if (!game.hasNature(card)) return "zerotarget";
|
||
}
|
||
},
|
||
},
|
||
},
|
||
},
|
||
tengjia2: {
|
||
equipSkill: true,
|
||
trigger: { player: "damageBegin3" },
|
||
filter: function (event, player) {
|
||
if (!event.hasNature("fire")) return false;
|
||
if (player.hasSkillTag("unequip2")) return false;
|
||
if (
|
||
event.source &&
|
||
event.source.hasSkillTag("unequip", false, {
|
||
name: event.card ? event.card.name : null,
|
||
target: player,
|
||
card: event.card,
|
||
})
|
||
)
|
||
return false;
|
||
return true;
|
||
},
|
||
audio: true,
|
||
forced: true,
|
||
content: function () {
|
||
trigger.num++;
|
||
},
|
||
ai: {
|
||
fireAttack: true,
|
||
effect: {
|
||
target: function (card, player, target, current) {
|
||
if (card.name == "sha") {
|
||
if (game.hasNature(card, "fire")) return 2;
|
||
if (player.hasSkill("zhuque_skill")) return 1.9;
|
||
}
|
||
if (get.tag(card, "fireDamage") && current < 0) return 2;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
tengjia3: {
|
||
equipSkill: true,
|
||
audio: "tengjia1",
|
||
trigger: { target: "shaBefore" },
|
||
forced: 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;
|
||
if (event.card.name == "sha" && !game.hasNature(event.card)) return true;
|
||
return false;
|
||
},
|
||
content: function () {
|
||
trigger.cancel();
|
||
},
|
||
},
|
||
baiyin_skill: {
|
||
equipSkill: true,
|
||
trigger: { player: "damageBegin4" },
|
||
forced: true,
|
||
audio: true,
|
||
filter: function (event, player) {
|
||
if (event.num <= 1) return false;
|
||
if (player.hasSkillTag("unequip2")) return false;
|
||
if (
|
||
event.source &&
|
||
event.source.hasSkillTag("unequip", false, {
|
||
name: event.card ? event.card.name : null,
|
||
target: player,
|
||
card: event.card,
|
||
})
|
||
)
|
||
return false;
|
||
return true;
|
||
},
|
||
//priority:-10,
|
||
content: function () {
|
||
trigger.num = 1;
|
||
},
|
||
subSkill: {
|
||
lose: {
|
||
audio: "baiyin_skill",
|
||
forced: true,
|
||
charlotte: true,
|
||
equipSkill: true,
|
||
trigger: {
|
||
player: "loseAfter",
|
||
global: [
|
||
"equipAfter",
|
||
"addJudgeAfter",
|
||
"gainAfter",
|
||
"loseAsyncAfter",
|
||
"addToExpansionAfter",
|
||
],
|
||
},
|
||
filter: (event, player) => {
|
||
if (player.isHealthy() || player.hasSkillTag("unequip2")) return false;
|
||
var evt = event.getl(player);
|
||
return evt && evt.es.some((card) => card.name == "baiyin");
|
||
},
|
||
content: function () {
|
||
var evt = trigger.getl(player);
|
||
evt.es.forEach((card) => {
|
||
if (card.name == "baiyin") {
|
||
player.recover();
|
||
}
|
||
});
|
||
},
|
||
},
|
||
},
|
||
ai: {
|
||
filterDamage: true,
|
||
skillTagFilter: function (player, tag, arg) {
|
||
if (player.hasSkillTag("unequip2")) return false;
|
||
if (arg && arg.player) {
|
||
if (
|
||
arg.player.hasSkillTag("unequip", false, {
|
||
name: arg.card ? arg.card.name : null,
|
||
target: player,
|
||
card: arg.card,
|
||
})
|
||
)
|
||
return false;
|
||
if (
|
||
arg.player.hasSkillTag("unequip_ai", false, {
|
||
name: arg.card ? arg.card.name : null,
|
||
target: player,
|
||
card: arg.card,
|
||
})
|
||
)
|
||
return false;
|
||
if (arg.player.hasSkillTag("jueqing", false, player)) return false;
|
||
}
|
||
},
|
||
},
|
||
},
|
||
zhuque_skill: {
|
||
equipSkill: true,
|
||
trigger: { player: "useCard1" },
|
||
//priority:7,
|
||
filter: function (event, player) {
|
||
if (event.card.name == "sha" && !game.hasNature(event.card)) return true;
|
||
},
|
||
audio: true,
|
||
check: function (event, player) {
|
||
var eff = 0;
|
||
for (var i = 0; i < event.targets.length; i++) {
|
||
var target = event.targets[i];
|
||
var eff1 = get.damageEffect(target, player, player);
|
||
var eff2 = get.damageEffect(target, player, player, "fire");
|
||
eff += eff2;
|
||
eff -= eff1;
|
||
}
|
||
return eff >= 0;
|
||
},
|
||
prompt2: function (event, player) {
|
||
return "将" + get.translation(event.card) + "改为火属性";
|
||
},
|
||
content: function () {
|
||
game.setNature(trigger.card, "fire");
|
||
if (get.itemtype(trigger.card) == "card") {
|
||
var next = game.createEvent("zhuque_clear");
|
||
next.card = trigger.card;
|
||
event.next.remove(next);
|
||
trigger.after.push(next);
|
||
next.setContent(function () {
|
||
game.setNature(trigger.card, []);
|
||
});
|
||
}
|
||
},
|
||
},
|
||
zhuque_skill2: {
|
||
trigger: { player: "useCardAfter" },
|
||
forced: true,
|
||
popup: false,
|
||
content: function () {
|
||
delete player.storage.zhuque_skill.nature;
|
||
},
|
||
},
|
||
huogon2: {},
|
||
},
|
||
translate: {
|
||
jiu: "酒",
|
||
jiu_info:
|
||
"①每回合限一次。出牌阶段，对你自己使用。本回合目标角色使用的下一张【杀】的伤害值基数+1。②当你处于濒死状态时，对你自己使用。目标角色回复1点体力。",
|
||
huogong: "火攻",
|
||
tiesuo: "铁索连环",
|
||
tiesuo_info: "此牌可被重铸。出牌阶段，对至多两名角色使用。目标角色横置。",
|
||
huogong_bg: "攻",
|
||
huogong_info:
|
||
"出牌阶段，对一名有手牌的角色使用。目标角色展示一张手牌A，然后你可以弃置一张与A花色相同的手牌，对目标造成1点火属性伤害。",
|
||
tiesuo_bg: "索",
|
||
bingliang: "兵粮寸断",
|
||
hualiu: "骅骝",
|
||
zhuque: "朱雀羽扇",
|
||
bingliang_bg: "粮",
|
||
bingliang_info:
|
||
"出牌阶段，对一名距离为1的其他角色使用。目标角色于其判定阶段进行判定：若判定结果不为梅花，则其跳过下一个摸牌阶段。",
|
||
hualiu_bg: "+马",
|
||
hualiu_info: "锁定技，其他角色计算与你的距离+1。",
|
||
zhuque_bg: "扇",
|
||
zhuque_skill: "朱雀羽扇",
|
||
zhuque_info: "当你声明使用普【杀】后，你可以为此【杀】赋予火属性。",
|
||
guding: "古锭刀",
|
||
guding_info: "锁定技，当你因执行【杀】的效果而对目标角色造成伤害时，若其没有手牌，则此伤害+1。",
|
||
guding_skill: "古锭刀",
|
||
tengjia: "藤甲",
|
||
//tengjia_info:'锁定技，【南蛮入侵】、【万箭齐发】、【出其不意】和普通【杀】对你无效。当你受到火焰伤害时，该伤害+1。',
|
||
tengjia_info:
|
||
"锁定技。①【南蛮入侵】、【万箭齐发】和普【杀】对你无效。②当你受到火属性伤害时，此伤害+1。",
|
||
tengjia1: "藤甲",
|
||
tengjia2: "藤甲",
|
||
tengjia3: "藤甲",
|
||
baiyin: "白银狮子",
|
||
baiyin_info:
|
||
"锁定技。①当你受到伤害时，若此伤害大于1，则你将伤害值扣减至1点。②当你失去装备区内的【白银狮子】后，你回复1点体力。",
|
||
baiyin_skill: "白银狮子",
|
||
|
||
muniu: "木牛流马",
|
||
muniu_bg: "牛",
|
||
muniu_skill: "木牛",
|
||
muniu_skill7: "木牛流马",
|
||
muniu_skill_bg: "辎",
|
||
muniu_info:
|
||
"①出牌阶段限一次，你可以将一张手牌扣置于你装备区里的【木牛流马】下，然后你可以将【木牛流马】移动到一名其他角色的装备区里。②你可以将【木牛流马】下的牌如手牌般使用或打出。③当你失去装备区的【木牛流马】后，你刷新〖木牛流马①〗的使用次数限制。若此牌不是因置入其他角色的装备区而失去的，则你将【木牛流马】下的所有牌置入弃牌堆。",
|
||
muniu_skill_info:
|
||
"将一张手牌扣置于你装备区里的【木牛流马】下，然后可以将此装备移动到一名其他角色的装备区里。",
|
||
},
|
||
list: [
|
||
["heart", 4, "sha", "fire"],
|
||
["heart", 7, "sha", "fire"],
|
||
["heart", 10, "sha", "fire"],
|
||
["diamond", 4, "sha", "fire"],
|
||
["diamond", 5, "sha", "fire"],
|
||
["spade", 4, "sha", "thunder"],
|
||
["spade", 5, "sha", "thunder"],
|
||
["spade", 6, "sha", "thunder"],
|
||
["spade", 7, "sha", "thunder"],
|
||
["spade", 8, "sha", "thunder"],
|
||
["club", 5, "sha", "thunder"],
|
||
["club", 6, "sha", "thunder"],
|
||
["club", 7, "sha", "thunder"],
|
||
["club", 8, "sha", "thunder"],
|
||
["heart", 8, "shan"],
|
||
["heart", 9, "shan"],
|
||
["heart", 11, "shan"],
|
||
["heart", 12, "shan"],
|
||
["diamond", 6, "shan"],
|
||
["diamond", 7, "shan"],
|
||
["diamond", 8, "shan"],
|
||
["diamond", 10, "shan"],
|
||
["diamond", 11, "shan"],
|
||
["heart", 5, "tao"],
|
||
["heart", 6, "tao"],
|
||
["diamond", 2, "tao"],
|
||
["diamond", 3, "tao"],
|
||
["diamond", 9, "jiu"],
|
||
["spade", 3, "jiu"],
|
||
["spade", 9, "jiu"],
|
||
["club", 3, "jiu"],
|
||
["club", 9, "jiu"],
|
||
|
||
["diamond", 13, "hualiu"],
|
||
["club", 1, "baiyin"],
|
||
["spade", 2, "tengjia"],
|
||
["club", 2, "tengjia"],
|
||
["spade", 1, "guding"],
|
||
["diamond", 1, "zhuque"],
|
||
|
||
["heart", 2, "huogong"],
|
||
["heart", 3, "huogong"],
|
||
["diamond", 12, "huogong"],
|
||
["spade", 11, "tiesuo"],
|
||
["spade", 12, "tiesuo"],
|
||
["club", 10, "tiesuo"],
|
||
["club", 11, "tiesuo"],
|
||
["club", 12, "tiesuo"],
|
||
["club", 13, "tiesuo"],
|
||
["heart", 1, "wuxie"],
|
||
["heart", 13, "wuxie"],
|
||
["spade", 13, "wuxie"],
|
||
["spade", 10, "bingliang"],
|
||
["club", 4, "bingliang"],
|
||
|
||
["diamond", 5, "muniu"],
|
||
],
|
||
};
|
||
});
|