2447 lines
64 KiB
JavaScript
2447 lines
64 KiB
JavaScript
import { lib, game, ui, get, ai, _status } from "../noname.js";
|
||
game.import("card", function () {
|
||
return {
|
||
name: "gwent",
|
||
card: {
|
||
gw_dieyi: {
|
||
fullskin: true,
|
||
},
|
||
gw_dieyi_equip1: {
|
||
fullskin: true,
|
||
vanish: true,
|
||
hidden: true,
|
||
cardimage: "gw_dieyi",
|
||
type: "equip",
|
||
subtype: "equip1",
|
||
onLose: function () {
|
||
lib.skill.gw_dieyi.process(player);
|
||
},
|
||
loseDelay: false,
|
||
skills: [],
|
||
ai: {
|
||
equipValue: 0,
|
||
},
|
||
},
|
||
gw_dieyi_equip2: {
|
||
fullskin: true,
|
||
vanish: true,
|
||
hidden: true,
|
||
cardimage: "gw_dieyi",
|
||
type: "equip",
|
||
subtype: "equip2",
|
||
onLose: function () {
|
||
lib.skill.gw_dieyi.process(player);
|
||
},
|
||
loseDelay: false,
|
||
skills: [],
|
||
ai: {
|
||
equipValue: 0,
|
||
},
|
||
},
|
||
gw_dieyi_equip3: {
|
||
fullskin: true,
|
||
vanish: true,
|
||
hidden: true,
|
||
cardimage: "gw_dieyi",
|
||
type: "equip",
|
||
subtype: "equip3",
|
||
onLose: function () {
|
||
lib.skill.gw_dieyi.process(player);
|
||
},
|
||
loseDelay: false,
|
||
skills: [],
|
||
ai: {
|
||
equipValue: 0,
|
||
},
|
||
},
|
||
gw_dieyi_equip4: {
|
||
fullskin: true,
|
||
vanish: true,
|
||
hidden: true,
|
||
cardimage: "gw_dieyi",
|
||
type: "equip",
|
||
subtype: "equip4",
|
||
onLose: function () {
|
||
lib.skill.gw_dieyi.process(player);
|
||
},
|
||
loseDelay: false,
|
||
skills: [],
|
||
ai: {
|
||
equipValue: 0,
|
||
},
|
||
},
|
||
gw_dieyi_equip5: {
|
||
fullskin: true,
|
||
vanish: true,
|
||
hidden: true,
|
||
cardimage: "gw_dieyi",
|
||
type: "equip",
|
||
subtype: "equip5",
|
||
onLose: function () {
|
||
lib.skill.gw_dieyi.process(player);
|
||
},
|
||
loseDelay: false,
|
||
skills: [],
|
||
ai: {
|
||
equipValue: 0,
|
||
},
|
||
},
|
||
gw_dieyi_judge: {
|
||
fullskin: true,
|
||
vanish: true,
|
||
hidden: true,
|
||
cardimage: "gw_dieyi",
|
||
enable: true,
|
||
type: "delay",
|
||
filterTarget: true,
|
||
effect: function () {
|
||
lib.skill.gw_dieyi.process(player);
|
||
},
|
||
},
|
||
gw_hudiewu: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: function (card, player) {
|
||
return game.hasPlayer(function (current) {
|
||
return current != player && current.countCards("ej");
|
||
});
|
||
},
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("蝴蝶舞", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.targets = game
|
||
.filterPlayer(function (current) {
|
||
return current.countCards("ej");
|
||
})
|
||
.sortBySeat();
|
||
event.targets.remove(player);
|
||
"step 1";
|
||
if (event.targets.length) {
|
||
var target = event.targets.shift();
|
||
var ej = target.getCards("ej");
|
||
player.line(target);
|
||
target.removeEquipTrigger();
|
||
for (var i = 0; i < ej.length; i++) {
|
||
game.createCard(ej[i]).discard();
|
||
ej[i].init([
|
||
ej[i].suit,
|
||
ej[i].number,
|
||
"gw_dieyi_" + (get.subtype(ej[i]) || "judge"),
|
||
]);
|
||
}
|
||
event.redo();
|
||
}
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 6,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: function (player) {
|
||
return game.countPlayer(function (current) {
|
||
if (current == player) return;
|
||
return (
|
||
-(current.countCards("e") - current.countCards("j") / 3) *
|
||
get.sgn(get.attitude(player, current))
|
||
);
|
||
});
|
||
},
|
||
},
|
||
order: 0.7,
|
||
},
|
||
},
|
||
gw_yigeniyin: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: true,
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("伊格尼印", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var enemies = player.getEnemies();
|
||
var target = get.max(enemies, "hp", "list").randomGet();
|
||
if (target) {
|
||
player.line(target, "fire");
|
||
target.damage("fire");
|
||
game.delay();
|
||
}
|
||
"step 1";
|
||
event.targets = game
|
||
.filterPlayer(function (current) {
|
||
return current.isMaxHp();
|
||
})
|
||
.sortBySeat();
|
||
player.line(event.targets, "fire");
|
||
"step 2";
|
||
if (event.targets.length) {
|
||
var target = event.targets.shift();
|
||
player.line(target, "fire");
|
||
target.damage("fire");
|
||
event.redo();
|
||
}
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: function (player) {
|
||
var enemies = player.getEnemies();
|
||
var players = game.filterPlayer();
|
||
var func = function (current) {
|
||
if (current) return current.hp;
|
||
return 0;
|
||
};
|
||
var max1 = get.max(enemies, func);
|
||
for (var i = 0; i < players.length; i++) {
|
||
if (players[i].hp == max1) {
|
||
players.splice(i, 1);
|
||
break;
|
||
}
|
||
}
|
||
var max2 = get.max(players, func);
|
||
if (max1 - 1 > max2) {
|
||
return get.damageEffect(
|
||
get.max(enemies, func, "item"),
|
||
player,
|
||
player,
|
||
"fire"
|
||
);
|
||
} else {
|
||
var num;
|
||
if (max1 > max2) {
|
||
num = get.sgn(
|
||
get.damageEffect(
|
||
get.max(enemies, func, "item"),
|
||
player,
|
||
player,
|
||
"fire"
|
||
)
|
||
);
|
||
} else if (max1 == max2) {
|
||
num = 0;
|
||
} else {
|
||
num = 1;
|
||
}
|
||
return (
|
||
num +
|
||
game.countPlayer(function (current) {
|
||
if (current.hp >= max2) {
|
||
return get.sgn(get.damageEffect(current, player, player, "fire"));
|
||
}
|
||
})
|
||
);
|
||
}
|
||
},
|
||
},
|
||
order: 0.7,
|
||
},
|
||
},
|
||
gw_leizhoushu: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: true,
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("雷咒术", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
if (player.hasSkill("gw_leizhoushu")) {
|
||
if (typeof player.storage.gw_leizhoushu != "number") {
|
||
player.storage.gw_leizhoushu = 2;
|
||
} else {
|
||
player.storage.gw_leizhoushu++;
|
||
}
|
||
player.syncStorage("gw_leizhoushu");
|
||
player.updateMarks();
|
||
} else {
|
||
player.addSkill("gw_leizhoushu");
|
||
}
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: function (player) {
|
||
return (
|
||
1 +
|
||
game.countPlayer(function (current) {
|
||
if (current != player && current.isMaxHandcard()) {
|
||
return -get.sgn(get.attitude(player, current));
|
||
}
|
||
})
|
||
);
|
||
},
|
||
},
|
||
order: 0.5,
|
||
},
|
||
},
|
||
gw_aerdeyin: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: function (card, player) {
|
||
var enemies = player.getEnemies();
|
||
return enemies.length > 0;
|
||
},
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("阿尔德印", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var enemies = player.getEnemies();
|
||
event.list = [enemies.randomGet()];
|
||
"step 1";
|
||
if (event.list.length) {
|
||
var target = event.list.shift();
|
||
event.target = target;
|
||
player.line(target, "green");
|
||
target.damage();
|
||
} else {
|
||
delete event.target;
|
||
}
|
||
"step 2";
|
||
if (event.target) {
|
||
if (!event.target.isTurnedOver()) {
|
||
event.target.turnOver();
|
||
event.target.addSkill("gw_aerdeyin");
|
||
}
|
||
event.goto(1);
|
||
}
|
||
"step 3";
|
||
game.delay();
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: function (player) {
|
||
return game.countPlayer(function (current) {
|
||
if (get.distance(player, current, "pure") == 1) {
|
||
var att = get.sgn(get.attitude(player, current));
|
||
if (current == player.next) {
|
||
return -att * 1.5;
|
||
}
|
||
return -att;
|
||
}
|
||
});
|
||
},
|
||
},
|
||
order: 0.5,
|
||
},
|
||
},
|
||
gw_ansha: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: function (card, player) {
|
||
var enemies = player.getEnemies();
|
||
return game.hasPlayer(function (current) {
|
||
return current.hp == 1 && enemies.includes(current);
|
||
});
|
||
},
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("暗杀", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
var enemies = player.getEnemies();
|
||
var list = game.filterPlayer(function (current) {
|
||
return current.hp == 1 && enemies.includes(current);
|
||
});
|
||
if (list.length) {
|
||
var target = list.randomGet();
|
||
player.line(target);
|
||
target.die();
|
||
}
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: 1,
|
||
},
|
||
order: 0.6,
|
||
},
|
||
},
|
||
gw_xinsheng: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: function (card, player) {
|
||
return game.hasPlayer(function (current) {
|
||
return !current.isUnseen();
|
||
});
|
||
},
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("新生", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var target = get.max(
|
||
game
|
||
.filterPlayer(function (current) {
|
||
return !current.isUnseen();
|
||
}, "list")
|
||
.randomSort(),
|
||
function (current) {
|
||
var att = get.attitude(player, current);
|
||
if (att < 0 && current.isDamaged() && current.hp <= 3) {
|
||
return -10;
|
||
}
|
||
var rank = get.rank(current, true);
|
||
if (current.maxHp >= 3) {
|
||
if (current.hp <= 1) {
|
||
if (att > 0) return att * 3 + 2;
|
||
return att * 3;
|
||
} else if (current.hp == 2) {
|
||
if (att > 0) {
|
||
att *= 1.5;
|
||
} else {
|
||
att /= 1.5;
|
||
}
|
||
}
|
||
}
|
||
if (rank >= 7) {
|
||
if (att > 0) {
|
||
return att / 10;
|
||
}
|
||
return -att / 5;
|
||
} else if (rank <= 4) {
|
||
if (att < 0) {
|
||
return -att / 10;
|
||
}
|
||
return att;
|
||
}
|
||
return Math.abs(att / 2);
|
||
},
|
||
"item"
|
||
);
|
||
event.aitarget = target;
|
||
var list = [];
|
||
for (var i in lib.character) {
|
||
if (!lib.filter.characterDisabled(i) && !lib.filter.characterDisabled2(i)) {
|
||
list.push(i);
|
||
}
|
||
}
|
||
var players = game.players.concat(game.dead);
|
||
for (var i = 0; i < players.length; i++) {
|
||
list.remove(players[i].name);
|
||
list.remove(players[i].name1);
|
||
list.remove(players[i].name2);
|
||
}
|
||
var dialog = ui.create.dialog("选择一张武将牌", "hidden");
|
||
dialog.add([list.randomGets(12), "character"]);
|
||
player.chooseButton(dialog, true).ai = function (button) {
|
||
if (get.attitude(player, event.aitarget) > 0) {
|
||
return get.rank(button.link, true);
|
||
} else {
|
||
return -get.rank(button.link, true);
|
||
}
|
||
};
|
||
"step 1";
|
||
event.nametarget = result.links[0];
|
||
player.chooseTarget(
|
||
true,
|
||
"使用" + get.translation(event.nametarget) + "替换一名角色的武将牌",
|
||
function (card, player, target) {
|
||
return !target.isUnseen() && !target.isMin();
|
||
}
|
||
).ai = function (target) {
|
||
if (target == event.aitarget) {
|
||
return 1;
|
||
} else {
|
||
return 0;
|
||
}
|
||
};
|
||
"step 2";
|
||
var target = result.targets[0];
|
||
var hp = target.hp;
|
||
target.reinit(target.name, event.nametarget);
|
||
target.hp = Math.min(hp + 1, target.maxHp);
|
||
target.update();
|
||
player.line(target, "green");
|
||
"step 3";
|
||
game.triggerEnter(target);
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: 1,
|
||
},
|
||
order: 0.5,
|
||
},
|
||
},
|
||
gw_niuquzhijing: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: function (card, player) {
|
||
return game.hasPlayer(function (current) {
|
||
return current.hp != player.hp;
|
||
});
|
||
},
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
var list1 = game.filterPlayer(function (current) {
|
||
return current.isMaxHp();
|
||
});
|
||
var list2 = game.filterPlayer(function (current) {
|
||
return current.isMinHp();
|
||
});
|
||
player.line(list1);
|
||
for (var i = 0; i < list1.length; i++) {
|
||
list1[i].addTempClass("target");
|
||
}
|
||
setTimeout(function () {
|
||
var list11 = list1.slice(0);
|
||
var list22 = list2.slice(0);
|
||
while (list22.length > list11.length) {
|
||
list11.push(list1.randomGet());
|
||
}
|
||
while (list22.length < list11.length) {
|
||
list22.push(list2.randomGet());
|
||
}
|
||
list11.sortBySeat();
|
||
list22.sortBySeat();
|
||
while (list11.length) {
|
||
list11.shift().line(list22.shift(), "green");
|
||
}
|
||
}, 500);
|
||
player.$skill("纽曲之镜", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
var max = null,
|
||
min = null;
|
||
for (var i = 0; i < game.players.length; i++) {
|
||
if (game.players[i].isMaxHp()) {
|
||
max = game.players[i].hp;
|
||
break;
|
||
}
|
||
}
|
||
for (var i = 0; i < game.players.length; i++) {
|
||
if (game.players[i].isMinHp()) {
|
||
min = game.players[i].hp;
|
||
break;
|
||
}
|
||
}
|
||
var targets = game.filterPlayer();
|
||
if (max != min && max != null && min != null) {
|
||
for (var i = 0; i < targets.length; i++) {
|
||
if (targets[i].hp == max) {
|
||
targets[i].hp--;
|
||
targets[i].maxHp--;
|
||
targets[i].$damagepop(-1);
|
||
} else if (targets[i].hp == min) {
|
||
targets[i].hp++;
|
||
targets[i].maxHp++;
|
||
targets[i].$damagepop(1, "wood");
|
||
}
|
||
targets[i].update();
|
||
}
|
||
}
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: function (player, target) {
|
||
return game.countPlayer(function (current) {
|
||
if (current.isMaxHp()) {
|
||
return -get.sgn(get.attitude(player, current));
|
||
}
|
||
if (current.isMinHp()) {
|
||
return get.sgn(get.attitude(player, current));
|
||
}
|
||
});
|
||
},
|
||
},
|
||
order: 3.5,
|
||
},
|
||
},
|
||
gw_zhongmozhizhan: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: true,
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.line(game.filterPlayer());
|
||
player.$skill("终末之战", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.num = 0;
|
||
event.targets = game.filterPlayer().sortBySeat();
|
||
"step 1";
|
||
if (event.num < targets.length) {
|
||
ui.clear();
|
||
var target = targets[event.num];
|
||
var cards = target.getCards("hej");
|
||
target.lose(cards)._triggered = null;
|
||
target.$throw(cards);
|
||
event.num++;
|
||
event.redo();
|
||
game.delay(0.7);
|
||
}
|
||
"step 2";
|
||
ui.clear();
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: function (player, target) {
|
||
if (player.hasUnknown()) return 0;
|
||
return -game.countPlayer(function (current) {
|
||
return current.countCards("he") * get.sgn(get.attitude(player, current));
|
||
});
|
||
},
|
||
},
|
||
order: 0.5,
|
||
},
|
||
},
|
||
gw_ganhan: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: true,
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.line(game.filterPlayer());
|
||
player.$skill("干旱", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.num = 0;
|
||
event.targets = game.filterPlayer().sortBySeat();
|
||
"step 1";
|
||
if (event.num < targets.length) {
|
||
ui.clear();
|
||
var target = targets[event.num];
|
||
target.loseMaxHp(true);
|
||
event.num++;
|
||
event.redo();
|
||
}
|
||
"step 2";
|
||
ui.clear();
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 7,
|
||
useful: [5, 1],
|
||
result: {
|
||
player: function (player, target) {
|
||
if (player.hasUnknown()) return 0;
|
||
return game.countPlayer(function (current) {
|
||
var att = -get.sgn(get.attitude(player, current));
|
||
if (current.isHealthy()) {
|
||
switch (current.hp) {
|
||
case 1:
|
||
return att * 3;
|
||
case 2:
|
||
return att * 2;
|
||
case 3:
|
||
return att * 1.5;
|
||
case 4:
|
||
return att;
|
||
default:
|
||
return att * 0.5;
|
||
}
|
||
} else if (current.maxHp - current.hp == 1) {
|
||
switch (current.hp) {
|
||
case 1:
|
||
return att * 0.5;
|
||
case 2:
|
||
return att * 0.3;
|
||
case 3:
|
||
return att * 0.2;
|
||
default:
|
||
return att * 0.15;
|
||
}
|
||
} else {
|
||
return att * 0.1;
|
||
}
|
||
});
|
||
},
|
||
},
|
||
order: 0.5,
|
||
},
|
||
},
|
||
gw_huangjiashenpan: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: true,
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("皇家审判", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var list = get.libCard(function (info) {
|
||
return info.subtype == "spell_gold";
|
||
});
|
||
list.remove("gw_huangjiashenpan");
|
||
if (list.length) {
|
||
player.chooseVCardButton(list, true, "notype").ai = function () {
|
||
return Math.random();
|
||
};
|
||
}
|
||
"step 1";
|
||
if (result.bool) {
|
||
player.gain(game.createCard(result.links[0][2]), "draw");
|
||
}
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: 1,
|
||
},
|
||
order: 0.1,
|
||
},
|
||
},
|
||
gw_tunshi: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: function (event, player) {
|
||
if (player.maxHp == 1) return false;
|
||
var list = player.getEnemies();
|
||
for (var i = 0; i < list.length; i++) {
|
||
if (list[i].isMin()) continue;
|
||
if (list[i].getStockSkills().length) return true;
|
||
}
|
||
},
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("吞噬", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
var list = player.getEnemies();
|
||
for (var i = 0; i < list.length; i++) {
|
||
if (list[i].isMin() || !list[i].getStockSkills().length) {
|
||
list.splice(i--, 1);
|
||
}
|
||
}
|
||
if (list.length) {
|
||
var target = list.randomGet();
|
||
target.addExpose(0.1);
|
||
player.line(target);
|
||
var skill = target.getStockSkills().randomGet();
|
||
target.popup(skill);
|
||
player.addSkill(skill);
|
||
target.removeSkill(skill);
|
||
player.loseHp();
|
||
player.loseMaxHp(true);
|
||
target.gainMaxHp(true);
|
||
target.recover();
|
||
}
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: function (player) {
|
||
if (player.hp <= 2) return 0;
|
||
return 1;
|
||
},
|
||
},
|
||
order: 0.4,
|
||
},
|
||
},
|
||
gw_chongci: {
|
||
fullborder: "gold",
|
||
type: "spell",
|
||
subtype: "spell_gold",
|
||
vanish: true,
|
||
enable: true,
|
||
notarget: true,
|
||
contentBefore: function () {
|
||
player.$skill("冲刺", "legend", "metal");
|
||
game.delay(2);
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
event.hs = player.getCards("h");
|
||
event.es = player.getCards("e");
|
||
player.discard(event.hs.concat(event.es));
|
||
"step 1";
|
||
var hs2 = [];
|
||
for (var i = 0; i < event.hs.length; i++) {
|
||
var type = get.type(event.hs[i], "trick");
|
||
var cardname = event.hs[i].name;
|
||
var list = game.findCards(function (name) {
|
||
if (cardname == name) return;
|
||
if (get.type({ name: name }, "trick") == type) {
|
||
return true;
|
||
}
|
||
});
|
||
if (!list.length) {
|
||
list = [cardname];
|
||
}
|
||
hs2.push(game.createCard(list.randomGet()));
|
||
}
|
||
var list = get.libCard(function (info) {
|
||
return info.type == "spell" && info.subtype != "spell_gold";
|
||
});
|
||
if (list.length) {
|
||
hs2.push(game.createCard(list.randomGet()));
|
||
}
|
||
if (hs2.length) {
|
||
player.gain(hs2, "draw");
|
||
}
|
||
"step 2";
|
||
var es2 = [];
|
||
for (var i = 0; i < event.es.length; i++) {
|
||
var subtype = get.subtype(event.es[i]);
|
||
var cardname = event.es[i].name;
|
||
var list = game.findCards(function (name) {
|
||
if (cardname == name) return;
|
||
if (get.subtype({ name: name }) == subtype) {
|
||
return true;
|
||
}
|
||
});
|
||
if (!list.length) {
|
||
list = [cardname];
|
||
}
|
||
es2.push(game.createCard(list.randomGet()));
|
||
}
|
||
if (es2.length) {
|
||
game.delay();
|
||
player.$draw(es2);
|
||
for (var i = 0; i < es2.length; i++) {
|
||
player.equip(es2[i]);
|
||
}
|
||
}
|
||
"step 3";
|
||
player.tempHide();
|
||
},
|
||
contentAfter: function () {
|
||
var evt = _status.event.getParent("phaseUse");
|
||
if (evt && evt.name == "phaseUse") {
|
||
evt.skipped = true;
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: 1,
|
||
},
|
||
order: 0.2,
|
||
},
|
||
},
|
||
gw_youer: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
vanish: true,
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && target.countCards("h") > 0;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
var cards = target.getCards("h");
|
||
target.lose(cards, ui.special);
|
||
target.storage.gw_youer = cards;
|
||
target.addSkill("gw_youer");
|
||
"step 1";
|
||
player.draw();
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 10,
|
||
value: 7,
|
||
useful: [3, 1],
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.hasSkillTag("noh")) return 3;
|
||
var num = -Math.sqrt(target.countCards("h"));
|
||
if (player.hasSha() && player.canUse("sha", target)) {
|
||
num -= 2;
|
||
}
|
||
return num;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gw_tongdi: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
vanish: true,
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target != player && target.countCards("h");
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
player.gainPlayerCard(target, "h", true, "visible").set("ai", function (button) {
|
||
return get.value(button.link);
|
||
});
|
||
"step 1";
|
||
target.gain(game.createCard("sha"), "gain2");
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 8,
|
||
value: 9.5,
|
||
useful: [5, 1],
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.getEquip(4)) return -2;
|
||
return -1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gw_fuyuan: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
vanish: true,
|
||
savable: true,
|
||
selectTarget: -1,
|
||
content: function () {
|
||
target.recover();
|
||
target.draw();
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 6,
|
||
useful: 10,
|
||
value: [8, 6.5, 5, 4],
|
||
},
|
||
result: {
|
||
target: 2,
|
||
},
|
||
tag: {
|
||
recover: 1,
|
||
save: 1,
|
||
},
|
||
},
|
||
},
|
||
gw_zhuoshao: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
vanish: true,
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target.isMaxHp();
|
||
},
|
||
cardnature: "fire",
|
||
selectTarget: [1, Infinity],
|
||
content: function () {
|
||
target.damage("fire");
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 8.5,
|
||
value: 7.5,
|
||
useful: [4, 1],
|
||
},
|
||
result: {
|
||
target: -1,
|
||
},
|
||
tag: {
|
||
damage: 1,
|
||
fireDamage: 1,
|
||
natureDamage: 1,
|
||
},
|
||
},
|
||
},
|
||
gw_butianshu: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
vanish: true,
|
||
enable: true,
|
||
filterTarget: true,
|
||
// contentBefore:function(){
|
||
// player.$skill('卜天术','legend','water');
|
||
// game.delay(2);
|
||
// },
|
||
content: function () {
|
||
"step 0";
|
||
var list = [];
|
||
for (var i in lib.card) {
|
||
if (lib.card[i].mode && lib.card[i].mode.includes(lib.config.mode) == false) continue;
|
||
if (lib.card[i].vanish) continue;
|
||
if (lib.card[i].type == "delay") list.push([cards[0].suit, cards[0].number, i]);
|
||
}
|
||
var dialog = ui.create.dialog("卜天术", [list, "vcard"]);
|
||
var bing = target.countCards("h") <= 1;
|
||
player.chooseButton(dialog, true, function (button) {
|
||
if (get.effect(target, { name: button.link[2] }, player, player) > 0) {
|
||
if (button.link[2] == "bingliang") {
|
||
if (bing) return 2;
|
||
return 0.7;
|
||
}
|
||
if (button.link[2] == "lebu") {
|
||
return 1;
|
||
}
|
||
if (button.link[2] == "guiyoujie") {
|
||
return 0.5;
|
||
}
|
||
if (button.link[2] == "caomu") {
|
||
return 0.3;
|
||
}
|
||
return 0.2;
|
||
}
|
||
return 0;
|
||
}).filterButton = function (button) {
|
||
return !target.hasJudge(button.link[2]);
|
||
};
|
||
"step 1";
|
||
var card = game.createCard(result.links[0][2]);
|
||
event.judgecard = card;
|
||
target.$draw(card);
|
||
game.delay(0.7);
|
||
"step 2";
|
||
target.addJudge(event.judgecard);
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [5, 1],
|
||
result: {
|
||
player: function (player, target) {
|
||
var eff = 0;
|
||
for (var i in lib.card) {
|
||
if (lib.card[i].type == "delay") {
|
||
var current = get.effect(target, { name: i }, player, player);
|
||
if (current > eff) {
|
||
eff = current;
|
||
}
|
||
}
|
||
}
|
||
return eff;
|
||
},
|
||
},
|
||
order: 6,
|
||
},
|
||
},
|
||
gw_shizizhaohuan: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
vanish: true,
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target == player;
|
||
},
|
||
selectTarget: -1,
|
||
// contentBefore:function(){
|
||
// player.$skill('十字召唤','legend','water');
|
||
// game.delay(2);
|
||
// },
|
||
content: function () {
|
||
var list = [];
|
||
list.push(get.cardPile2("juedou"));
|
||
list.push(get.cardPile2("huogong"));
|
||
list.push(get.cardPile2("nanman"));
|
||
list.push(get.cardPile2("huoshaolianying"));
|
||
for (var i = 0; i < list.length; i++) {
|
||
if (!list[i]) list.splice(i--, 1);
|
||
}
|
||
list = [list.randomGet()];
|
||
var sha = get.cardPile2("sha");
|
||
if (sha) {
|
||
if (list.length) {
|
||
list.push(sha);
|
||
} else {
|
||
sha.remove();
|
||
list.push(sha);
|
||
var sha2 = get.cardPile2("sha");
|
||
if (sha2) {
|
||
list.push(sha2);
|
||
}
|
||
}
|
||
}
|
||
if (list.length) {
|
||
target.gain(list, "gain2", "log");
|
||
}
|
||
},
|
||
ai: {
|
||
value: 8,
|
||
useful: [6, 1],
|
||
result: {
|
||
player: 1,
|
||
},
|
||
order: 6,
|
||
},
|
||
},
|
||
gw_zuihouyuanwang: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
vanish: true,
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target == player;
|
||
},
|
||
selectTarget: -1,
|
||
// contentBefore:function(){
|
||
// player.$skill('最后愿望','legend','water');
|
||
// game.delay(2);
|
||
// },
|
||
content: function () {
|
||
"step 0";
|
||
event.num = game.countPlayer();
|
||
player.draw(event.num);
|
||
"step 1";
|
||
player.chooseToDiscard(true, event.num, "he");
|
||
},
|
||
ai: {
|
||
value: 6,
|
||
useful: [4, 1],
|
||
result: {
|
||
player: function (player) {
|
||
var num = player.countCards("he");
|
||
if (num <= 1) return 0;
|
||
if (num <= 3 && !player.needsToDiscard()) return 0;
|
||
return 1;
|
||
},
|
||
},
|
||
order: 7,
|
||
},
|
||
},
|
||
gw_zirankuizeng: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
vanish: true,
|
||
enable: true,
|
||
notarget: true,
|
||
// contentBefore:function(){
|
||
// player.$skill('自然馈赠','legend','water');
|
||
// game.delay(2);
|
||
// },
|
||
content: function () {
|
||
"step 0";
|
||
var list = [];
|
||
for (var i in lib.card) {
|
||
if (lib.card[i].subtype == "spell_bronze")
|
||
list.push([cards[0].suit, cards[0].number, i]);
|
||
}
|
||
var dialog = ui.create.dialog("自然馈赠", [list, "vcard"]);
|
||
var rand = get.rand();
|
||
var aozu = game.hasPlayer(function (current) {
|
||
return (
|
||
player.canUse("gw_aozuzhilei", current) &&
|
||
current.hp <= 3 &&
|
||
get.effect(current, { name: "gw_aozuzhilei" }, player, player) > 0
|
||
);
|
||
});
|
||
var aozu2 = game.hasPlayer(function (current) {
|
||
return (
|
||
player.canUse("gw_aozuzhilei", current) &&
|
||
current.hp <= 2 &&
|
||
get.effect(current, { name: "gw_aozuzhilei" }, player, player) > 0
|
||
);
|
||
});
|
||
var aozu3 = game.hasPlayer(function (current) {
|
||
return (
|
||
player.canUse("gw_aozuzhilei", current) &&
|
||
get.effect(current, { name: "gw_aozuzhilei" }, player, player) > 0
|
||
);
|
||
});
|
||
var baoxue = game.hasPlayer(function (current) {
|
||
return (
|
||
player.canUse("gw_baoxueyaoshui", current) &&
|
||
get.attitude(player, current) < 0 &&
|
||
[2, 3].includes(current.countCards("h")) &&
|
||
!current.hasSkillTag("noh")
|
||
);
|
||
});
|
||
var baoxue2 = game.hasPlayer(function (current) {
|
||
return (
|
||
player.canUse("gw_baoxueyaoshui", current) &&
|
||
get.attitude(player, current) < 0 &&
|
||
[2].includes(current.countCards("h")) &&
|
||
!current.hasSkillTag("noh")
|
||
);
|
||
});
|
||
var baoxue3 = game.hasPlayer(function (current) {
|
||
return (
|
||
player.canUse("gw_baoxueyaoshui", current) &&
|
||
get.attitude(player, current) < 0 &&
|
||
current.countCards("h") >= 2 &&
|
||
!current.hasSkillTag("noh")
|
||
);
|
||
});
|
||
var nongwu = game.hasPlayer(function (current) {
|
||
return (
|
||
get.attitude(player, current) < 0 &&
|
||
(get.attitude(player, current.getNext()) < 0 ||
|
||
get.attitude(player, current.getPrevious()) < 0)
|
||
);
|
||
});
|
||
var nongwu2 = game.hasPlayer(function (current) {
|
||
return (
|
||
get.attitude(player, current) < 0 &&
|
||
get.attitude(player, current.getNext()) < 0 &&
|
||
get.attitude(player, current.getPrevious()) < 0
|
||
);
|
||
});
|
||
var yanzi = game.hasPlayer(function (current) {
|
||
return get.attitude(player, current) > 0 && current.isMinHandcard();
|
||
});
|
||
player.chooseButton(dialog, true, function (button) {
|
||
var name = button.link[2];
|
||
switch (name) {
|
||
case "gw_ciguhanshuang":
|
||
if (nongwu2) return 3;
|
||
if (nongwu) return 1;
|
||
return 0;
|
||
case "gw_baoxueyaoshui":
|
||
if (baoxue2) return 2;
|
||
if (baoxue) return 1.5;
|
||
if (baoxue3) return 0.5;
|
||
return 0;
|
||
case "gw_aozuzhilei":
|
||
if (aozu2) return 2.5;
|
||
if (aozu) return 1.2;
|
||
if (aozu3) return 0.2;
|
||
return 0;
|
||
case "gw_yanziyaoshui":
|
||
if (yanzi) return 2;
|
||
return 0.6;
|
||
}
|
||
if (
|
||
game.hasPlayer(function (current) {
|
||
return (
|
||
player.canUse(name, current) &&
|
||
get.effect(current, { name: name }, player, player) > 0
|
||
);
|
||
})
|
||
) {
|
||
return Math.random();
|
||
}
|
||
return 0;
|
||
}).filterButton = function (button) {
|
||
var name = button.link[2];
|
||
if (!lib.card[name].notarget) {
|
||
return game.hasPlayer(function (current) {
|
||
return player.canUse(name, current);
|
||
});
|
||
}
|
||
return true;
|
||
};
|
||
"step 1";
|
||
player.chooseUseTarget(
|
||
true,
|
||
game.createCard(result.links[0][2], get.suit(card), get.number(card))
|
||
);
|
||
},
|
||
ai: {
|
||
value: 7,
|
||
useful: [4, 1],
|
||
result: {
|
||
player: function (player) {
|
||
return 1;
|
||
},
|
||
},
|
||
order: 7,
|
||
},
|
||
},
|
||
gw_nuhaifengbao: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return !target.hasSkill("gw_nuhaifengbao");
|
||
},
|
||
content: function () {
|
||
target.addSkill("gw_nuhaifengbao");
|
||
},
|
||
ai: {
|
||
value: [7, 1],
|
||
useful: [4, 1],
|
||
result: {
|
||
target: function (player, target) {
|
||
return -2 / Math.sqrt(1 + target.hp);
|
||
},
|
||
},
|
||
order: 1.2,
|
||
},
|
||
},
|
||
gw_baishuang: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return !target.hasSkill("gw_ciguhanshuang");
|
||
},
|
||
selectTarget: [1, 3],
|
||
content: function () {
|
||
target.addSkill("gw_ciguhanshuang");
|
||
},
|
||
ai: {
|
||
value: [7.5, 1],
|
||
useful: [5, 1],
|
||
result: {
|
||
target: -1,
|
||
},
|
||
order: 1.2,
|
||
},
|
||
},
|
||
gw_baobaoshu: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return !target.hasSkill("gw_baobaoshu");
|
||
},
|
||
selectTarget: [1, 2],
|
||
content: function () {
|
||
target.addTempSkill("gw_baobaoshu", { player: "phaseAfter" });
|
||
},
|
||
ai: {
|
||
value: [7.5, 1],
|
||
useful: [5, 1],
|
||
result: {
|
||
target: function (player, target) {
|
||
return -Math.sqrt(target.countCards("h")) - 0.5;
|
||
},
|
||
},
|
||
order: 1.2,
|
||
},
|
||
},
|
||
gw_guaiwuchaoxue: {
|
||
fullborder: "silver",
|
||
type: "spell",
|
||
subtype: "spell_silver",
|
||
enable: true,
|
||
usable: 1,
|
||
updateUsable: "phaseUse",
|
||
forceUsable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target == player;
|
||
},
|
||
selectTarget: -1,
|
||
content: function () {
|
||
var list = get.gainableSkills(function (info, skill) {
|
||
return !info.notemp && info.ai && info.ai.maixie_hp && !player.hasSkill(skill);
|
||
});
|
||
list.remove("guixin");
|
||
if (list.length) {
|
||
var skill = list.randomGet();
|
||
player.popup(skill);
|
||
player.addTempSkill(skill, { player: "phaseBegin" });
|
||
var enemies = player.getEnemies();
|
||
if (enemies.length) {
|
||
var source = enemies.randomGet();
|
||
source.line(player);
|
||
source.addExpose(0.1);
|
||
player.damage(source);
|
||
player.recover();
|
||
}
|
||
}
|
||
},
|
||
ai: {
|
||
value: [8, 1],
|
||
useful: [3, 1],
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.hp <= 1 || target.hujia) return 0;
|
||
return 1;
|
||
},
|
||
},
|
||
order: 1,
|
||
},
|
||
},
|
||
gw_qinpendayu: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return !target.hasSkill("gw_qinpendayu");
|
||
},
|
||
changeTarget: function (player, targets) {
|
||
game.filterPlayer(function (current) {
|
||
return get.distance(targets[0], current, "pure") == 1;
|
||
}, targets);
|
||
},
|
||
content: function () {
|
||
target.addSkill("gw_qinpendayu");
|
||
},
|
||
ai: {
|
||
value: [5, 1],
|
||
useful: [3, 1],
|
||
result: {
|
||
target: function (player, current) {
|
||
if (current.hasSkill("gw_qinpendayu")) return 0;
|
||
return Math.max(-1, -0.1 - 0.3 * current.needsToDiscard(2));
|
||
},
|
||
},
|
||
order: 1.2,
|
||
},
|
||
},
|
||
gw_birinongwu: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return !target.hasSkill("gw_birinongwu");
|
||
},
|
||
changeTarget: function (player, targets) {
|
||
game.filterPlayer(function (current) {
|
||
return get.distance(targets[0], current, "pure") == 1;
|
||
}, targets);
|
||
},
|
||
content: function () {
|
||
target.addSkill("gw_birinongwu");
|
||
},
|
||
ai: {
|
||
value: [5, 1],
|
||
useful: [3, 1],
|
||
result: {
|
||
player: function (player, current) {
|
||
if (current.hasSkill("gw_birinongwu")) return 0;
|
||
return -1;
|
||
},
|
||
},
|
||
order: 1.2,
|
||
},
|
||
},
|
||
gw_ciguhanshuang: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return !target.hasSkill("gw_ciguhanshuang");
|
||
},
|
||
changeTarget: function (player, targets) {
|
||
game.filterPlayer(function (current) {
|
||
return get.distance(targets[0], current, "pure") == 1;
|
||
}, targets);
|
||
},
|
||
content: function () {
|
||
target.addSkill("gw_ciguhanshuang");
|
||
},
|
||
ai: {
|
||
value: [5, 1],
|
||
useful: [3, 1],
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.hasSkill("gw_ciguhanshuang")) return 0;
|
||
return -1;
|
||
},
|
||
},
|
||
order: 1.2,
|
||
},
|
||
},
|
||
gw_baoxueyaoshui: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: true,
|
||
content: function () {
|
||
"step 0";
|
||
target.chooseToDiscard("h", 2, true).delay = false;
|
||
"step 1";
|
||
target.draw();
|
||
},
|
||
ai: {
|
||
value: 6,
|
||
useful: [3, 1],
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.hasSkillTag("noh")) return 0.1;
|
||
switch (target.countCards("h")) {
|
||
case 0:
|
||
return 0.5;
|
||
case 1:
|
||
return 0;
|
||
case 2:
|
||
return -1.5;
|
||
default:
|
||
return -1;
|
||
}
|
||
},
|
||
},
|
||
order: 8,
|
||
tag: {
|
||
loseCard: 1,
|
||
discard: 1,
|
||
},
|
||
},
|
||
},
|
||
gw_zhihuanjun: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target.isDamaged();
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
target.loseMaxHp(true);
|
||
"step 1";
|
||
if (target.isDamaged() && target.countCards("h") < target.maxHp) {
|
||
event.goto(0);
|
||
}
|
||
},
|
||
ai: {
|
||
value: [4, 1],
|
||
useful: [3, 1],
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.maxHp - target.hp == 1) {
|
||
return -1 / target.maxHp;
|
||
} else {
|
||
return -1 / target.maxHp / 3;
|
||
}
|
||
},
|
||
},
|
||
order: 2,
|
||
},
|
||
},
|
||
gw_zumoshoukao: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target.hujia || !target.hasSkill("fengyin");
|
||
},
|
||
content: function () {
|
||
target.addTempSkill("fengyin", { player: "phaseAfter" });
|
||
// if(target.hujia){
|
||
// target.changeHujia(-1);
|
||
// }
|
||
},
|
||
ai: {
|
||
value: [4.5, 1],
|
||
useful: [4, 1],
|
||
result: {
|
||
target: function (player, target) {
|
||
var threaten = get.threaten(target, player, true);
|
||
if (target.hasSkill("fengyin")) {
|
||
return 0;
|
||
}
|
||
if (target.hasSkillTag("maixie_hp")) {
|
||
threaten *= 1.5;
|
||
}
|
||
return -threaten;
|
||
},
|
||
},
|
||
order: 9.5,
|
||
},
|
||
},
|
||
gw_aozuzhilei: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
cardnature: "thunder",
|
||
filterTarget: function (card, player, target) {
|
||
return target.hp >= player.hp;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
target.damage("thunder");
|
||
"step 1";
|
||
if (target.isIn()) {
|
||
target.draw();
|
||
}
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 1.8,
|
||
value: [5, 1],
|
||
useful: [4, 1],
|
||
},
|
||
result: {
|
||
target: -1,
|
||
},
|
||
tag: {
|
||
damage: 1,
|
||
thunderDamage: 1,
|
||
natureDamage: 1,
|
||
},
|
||
},
|
||
},
|
||
gw_poxiao: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
notarget: true,
|
||
content: function () {
|
||
"step 0";
|
||
var choice = 1;
|
||
if (
|
||
game.countPlayer(function (current) {
|
||
if (current.countCards("j") || current.hasSkillTag("weather")) {
|
||
if (get.attitude(player, current) > 0) {
|
||
choice = 0;
|
||
}
|
||
return true;
|
||
}
|
||
})
|
||
) {
|
||
player
|
||
.chooseControl(function () {
|
||
return choice;
|
||
})
|
||
.set("choiceList", [
|
||
"解除任意名角色的天气效果并移除其判定区内的牌",
|
||
"随机获得一张铜卡法术（破晓除外）并展示之",
|
||
]);
|
||
} else {
|
||
event.directfalse = true;
|
||
}
|
||
"step 1";
|
||
if (!event.directfalse && result.index == 0) {
|
||
player.chooseTarget(
|
||
true,
|
||
[1, Infinity],
|
||
"解除任意名角色的天气效果并移除其判定区内的牌",
|
||
function (card, player, target) {
|
||
return target.countCards("j") || target.hasSkillTag("weather");
|
||
}
|
||
).ai = function (target) {
|
||
return get.attitude(player, target);
|
||
};
|
||
} else {
|
||
var list = get.libCard(function (info, name) {
|
||
return name != "gw_poxiao" && info.subtype == "spell_bronze";
|
||
});
|
||
if (list.length) {
|
||
player.gain(game.createCard(list.randomGet()), "gain2");
|
||
} else {
|
||
player.draw();
|
||
}
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
event.list = result.targets.slice(0).sortBySeat();
|
||
"step 3";
|
||
if (event.list.length) {
|
||
var target = event.list.shift();
|
||
player.line(target, "green");
|
||
var cards = target.getCards("j");
|
||
if (cards.length) {
|
||
target.discard(cards);
|
||
}
|
||
if (target.hasSkillTag("weather")) {
|
||
var skills = target.getSkills();
|
||
for (var i = 0; i < skills.length; i++) {
|
||
var info = get.info(skills[i]);
|
||
if (info && info.ai && info.ai.weather) {
|
||
target.removeSkill(skills[i]);
|
||
game.log(
|
||
target,
|
||
"解除了",
|
||
"【" + get.translation(skills[i]) + "】",
|
||
"的效果"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
event.redo();
|
||
}
|
||
},
|
||
ai: {
|
||
order: 4,
|
||
value: [5, 1],
|
||
useful: [4, 1],
|
||
result: {
|
||
player: 1,
|
||
},
|
||
},
|
||
},
|
||
gw_kunenfayin: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return !target.hasSkill("gw_kunenfayin");
|
||
},
|
||
content: function () {
|
||
target.addSkill("gw_kunenfayin");
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 2,
|
||
value: [5, 1],
|
||
useful: [4, 1],
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target == player) return get.threaten(target, player) / 1.5;
|
||
return get.threaten(target, player);
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gw_yanziyaoshui: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: true,
|
||
content: function () {
|
||
if (target.isMinHandcard()) {
|
||
target.draw(2);
|
||
} else {
|
||
target.draw();
|
||
}
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 6,
|
||
value: [6, 1],
|
||
useful: [4, 1],
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.isMinHandcard()) return 2;
|
||
return 1;
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gw_wenyi: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: true,
|
||
filterTarget: function (card, player, target) {
|
||
return target.isMinHp();
|
||
},
|
||
selectTarget: -1,
|
||
content: function () {
|
||
if (target.countCards("h")) {
|
||
target.randomDiscard("h");
|
||
} else {
|
||
target.loseHp();
|
||
}
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 6,
|
||
value: [6, 1],
|
||
useful: [4, 1],
|
||
},
|
||
result: {
|
||
target: function (player, target) {
|
||
if (target.countCards("h")) return -1;
|
||
return -2;
|
||
},
|
||
},
|
||
tag: {
|
||
multitarget: 1,
|
||
multineg: 1,
|
||
},
|
||
},
|
||
},
|
||
gw_shanbengshu: {
|
||
fullborder: "bronze",
|
||
type: "spell",
|
||
subtype: "spell_bronze",
|
||
enable: function (event, player) {
|
||
var list = player.getEnemies();
|
||
for (var i = 0; i < list.length; i++) {
|
||
if (list[i].countCards("e")) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
filterTarget: function (card, player, target) {
|
||
return target == player;
|
||
},
|
||
selectTarget: -1,
|
||
content: function () {
|
||
var list = target.getEnemies();
|
||
var equips = [];
|
||
for (var i = 0; i < list.length; i++) {
|
||
equips.addArray(list[i].getCards("e"));
|
||
}
|
||
equips = equips.randomGets(2);
|
||
if (equips.length == 2) {
|
||
var target1 = get.owner(equips[0]);
|
||
var target2 = get.owner(equips[1]);
|
||
if (target1 == target2) {
|
||
target1.discard(equips);
|
||
player.line(target1);
|
||
} else {
|
||
target1.discard(equips[0]).delay = false;
|
||
target2.discard(equips[1]);
|
||
player.line(target1);
|
||
player.line(target2);
|
||
}
|
||
} else if (equips.length) {
|
||
var target1 = get.owner(equips[0]);
|
||
target1.discard(equips[0]);
|
||
player.line(target1);
|
||
}
|
||
},
|
||
ai: {
|
||
basic: {
|
||
order: 9,
|
||
value: [6, 1],
|
||
useful: [4, 1],
|
||
},
|
||
result: {
|
||
target: 1,
|
||
},
|
||
tag: {
|
||
multitarget: 1,
|
||
multineg: 1,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
skill: {
|
||
gw_aerdeyin: {
|
||
trigger: { global: "roundStart" },
|
||
silent: true,
|
||
mark: true,
|
||
intro: {
|
||
content:
|
||
"新的一轮开始时，若武将牌正面朝上，则在当前回合结束后进行一个额外回合，否则将武将牌翻回正面",
|
||
},
|
||
content: function () {
|
||
if (player.isTurnedOver()) {
|
||
player.turnOver();
|
||
player.removeSkill("gw_aerdeyin");
|
||
player.logSkill("gw_aerdeyin");
|
||
} else {
|
||
player.insertPhase();
|
||
}
|
||
},
|
||
group: "gw_aerdeyin_phase",
|
||
subSkill: {
|
||
phase: {
|
||
trigger: { player: "phaseBefore" },
|
||
silent: true,
|
||
filter: function (event, player) {
|
||
return event.skill == "gw_aerdeyin";
|
||
},
|
||
content: function () {
|
||
player.removeSkill("gw_aerdeyin");
|
||
player.logSkill("gw_aerdeyin");
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gw_kunenfayin: {
|
||
mark: true,
|
||
nopop: true,
|
||
intro: {
|
||
content: "防止所有非属性伤害（剩余个#角色的回合）",
|
||
},
|
||
init: function (player) {
|
||
player.storage.gw_kunenfayin = Math.min(5, game.countPlayer());
|
||
},
|
||
trigger: { player: "damageBefore" },
|
||
filter: function (event) {
|
||
return !event.nature;
|
||
},
|
||
forced: true,
|
||
content: function () {
|
||
trigger.cancel();
|
||
},
|
||
ai: {
|
||
nodamage: true,
|
||
effect: {
|
||
target: function (card, player, target, current) {
|
||
if (get.tag(card, "damage") && !get.tag(card, "natureDamage")) return [0, 0];
|
||
},
|
||
},
|
||
},
|
||
subSkill: {
|
||
count: {
|
||
trigger: { global: "phaseEnd" },
|
||
silent: true,
|
||
content: function () {
|
||
player.storage.gw_kunenfayin--;
|
||
if (player.storage.gw_kunenfayin > 0) {
|
||
player.updateMarks();
|
||
} else {
|
||
player.removeSkill("gw_kunenfayin");
|
||
}
|
||
},
|
||
},
|
||
},
|
||
group: "gw_kunenfayin_count",
|
||
onremove: true,
|
||
},
|
||
gw_baobaoshu: {
|
||
mark: true,
|
||
nopop: true,
|
||
intro: {
|
||
content: "每使用一张基本牌或锦囊牌，需弃置一张牌",
|
||
},
|
||
trigger: { player: "useCard" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
if (player.countCards("he") == 0) return false;
|
||
var type = get.type(event.card, "trick");
|
||
return type == "basic" || type == "trick";
|
||
},
|
||
content: function () {
|
||
if (!event.isMine()) game.delay(0.5);
|
||
player.chooseToDiscard(true, "he");
|
||
},
|
||
ai: {
|
||
weather: true,
|
||
effect: {
|
||
player_use(card, player) {
|
||
if (!player.needsToDiscard()) return "zeroplayertarget";
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gw_nuhaifengbao: {
|
||
mark: true,
|
||
intro: {
|
||
content: "结束阶段随机弃置一张牌（剩余#回合）",
|
||
},
|
||
init: function (player) {
|
||
player.storage.gw_nuhaifengbao = 2;
|
||
},
|
||
trigger: { player: "phaseEnd" },
|
||
forced: true,
|
||
nopop: true,
|
||
content: function () {
|
||
player.randomDiscard();
|
||
player.storage.gw_nuhaifengbao--;
|
||
if (player.storage.gw_nuhaifengbao > 0) {
|
||
player.updateMarks();
|
||
} else {
|
||
player.removeSkill("gw_nuhaifengbao");
|
||
}
|
||
},
|
||
onremove: true,
|
||
ai: {
|
||
neg: true,
|
||
weather: true,
|
||
},
|
||
},
|
||
gw_youer: {
|
||
trigger: { global: "phaseEnd", player: "dieBegin" },
|
||
forced: true,
|
||
audio: false,
|
||
mark: true,
|
||
intro: {
|
||
content: "cards",
|
||
},
|
||
content: function () {
|
||
if (player.storage.gw_youer) {
|
||
if (trigger.name == "phase") {
|
||
player.gain(player.storage.gw_youer);
|
||
} else {
|
||
player.$throw(player.storage.gw_youer, 1000);
|
||
for (var i = 0; i < player.storage.gw_youer.length; i++) {
|
||
player.storage.gw_youer[i].discard();
|
||
}
|
||
game.log(player, "弃置了", player.storage.gw_youer);
|
||
}
|
||
}
|
||
delete player.storage.gw_youer;
|
||
player.removeSkill("gw_youer");
|
||
},
|
||
},
|
||
gw_qinpendayu: {
|
||
mark: true,
|
||
nopop: true,
|
||
intro: {
|
||
content: "手牌上限-1直到下一个弃牌阶段结束",
|
||
},
|
||
mod: {
|
||
maxHandcard: function (player, num) {
|
||
return num - 1;
|
||
},
|
||
},
|
||
ai: {
|
||
weather: true,
|
||
},
|
||
group: "gw_qinpendayu_clear",
|
||
subSkill: {
|
||
clear: {
|
||
trigger: { player: "phaseDiscardAfter" },
|
||
silent: true,
|
||
content: function () {
|
||
player.removeSkill("gw_qinpendayu");
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gw_birinongwu: {
|
||
mark: true,
|
||
nopop: true,
|
||
intro: {
|
||
content: "不能使用杀直到下一个出牌阶段结束",
|
||
},
|
||
mod: {
|
||
cardEnabled: function (card) {
|
||
if (card.name == "sha") return false;
|
||
},
|
||
},
|
||
ai: {
|
||
weather: true,
|
||
},
|
||
group: "gw_birinongwu_clear",
|
||
subSkill: {
|
||
clear: {
|
||
trigger: { player: "phaseUseAfter" },
|
||
silent: true,
|
||
content: function () {
|
||
player.removeSkill("gw_birinongwu");
|
||
},
|
||
},
|
||
},
|
||
},
|
||
gw_ciguhanshuang: {
|
||
trigger: { player: "phaseDrawBegin" },
|
||
forced: true,
|
||
mark: true,
|
||
nopop: true,
|
||
intro: {
|
||
content: "下个摸牌阶段摸牌数-1",
|
||
},
|
||
filter: function (event) {
|
||
return event.num > 0;
|
||
},
|
||
content: function () {
|
||
trigger.num--;
|
||
player.removeSkill("gw_ciguhanshuang");
|
||
},
|
||
ai: {
|
||
weather: true,
|
||
},
|
||
},
|
||
gw_dieyi: {
|
||
init: function (player) {
|
||
player.storage.gw_dieyi = 1;
|
||
},
|
||
onremove: true,
|
||
trigger: { global: "phaseEnd" },
|
||
forced: true,
|
||
mark: true,
|
||
nopop: true,
|
||
process: function (player) {
|
||
if (player.hasSkill("gw_dieyi")) {
|
||
player.storage.gw_dieyi++;
|
||
} else {
|
||
player.addSkill("gw_dieyi");
|
||
}
|
||
player.syncStorage("gw_dieyi");
|
||
player.updateMarks();
|
||
},
|
||
intro: {
|
||
content: "在当前回合的结束阶段，你随机弃置#张牌",
|
||
},
|
||
content: function () {
|
||
player.randomDiscard(player.storage.gw_dieyi);
|
||
player.removeSkill("gw_dieyi");
|
||
},
|
||
},
|
||
gw_leizhoushu: {
|
||
mark: true,
|
||
intro: {
|
||
content: function (storage, player) {
|
||
if (storage >= 2) {
|
||
return (
|
||
"锁定技，准备阶段，你令手牌数为全场最多的所有其他角色各随机弃置一张手牌，若目标不包含敌方角色，将一名随机敌方角色追加为额外目标（重复" +
|
||
storage +
|
||
"次）"
|
||
);
|
||
} else {
|
||
return "锁定技，准备阶段，你令手牌数为全场最多的所有其他角色各随机弃置一张手牌，若目标不包含敌方角色，将一名随机敌方角色追加为额外目标";
|
||
}
|
||
},
|
||
},
|
||
nopop: true,
|
||
trigger: { player: "phaseBegin" },
|
||
forced: true,
|
||
filter: function (event, player) {
|
||
var list = game.filterPlayer();
|
||
for (var i = 0; i < list.length; i++) {
|
||
if (list[i] != player && list[i].isMaxHandcard()) return true;
|
||
}
|
||
return false;
|
||
},
|
||
content: function () {
|
||
"step 0";
|
||
if (typeof player.storage.gw_leizhoushu == "number") {
|
||
event.num = player.storage.gw_leizhoushu;
|
||
} else {
|
||
event.num = 1;
|
||
}
|
||
"step 1";
|
||
if (event.num) {
|
||
var max = 0;
|
||
var maxp = null;
|
||
var list = game
|
||
.filterPlayer(function (current) {
|
||
return current.isMaxHandcard();
|
||
})
|
||
.sortBySeat();
|
||
var enemies = player.getEnemies();
|
||
for (var i = 0; i < enemies.length; i++) {
|
||
if (list.includes(enemies[i])) {
|
||
break;
|
||
}
|
||
}
|
||
if (i == enemies.length) {
|
||
list.push(enemies.randomGet());
|
||
}
|
||
list.remove(player);
|
||
if (!list.length) {
|
||
event.finish();
|
||
return;
|
||
}
|
||
player.line(list, "green");
|
||
for (var i = 0; i < list.length; i++) {
|
||
list[i].randomDiscard("h", false);
|
||
}
|
||
} else {
|
||
event.finish();
|
||
}
|
||
"step 2";
|
||
event.num--;
|
||
event.goto(1);
|
||
game.delay();
|
||
},
|
||
},
|
||
_gainspell: {
|
||
trigger: { player: "drawBegin" },
|
||
silent: true,
|
||
priority: -11,
|
||
filter: function (event, player) {
|
||
if (_status.connectMode) return false;
|
||
if (!lib.config.cards.includes("gwent")) return false;
|
||
if (player.isMin()) return false;
|
||
if (game.fixedPile) return false;
|
||
return event.num > 0 && event.parent.name == "phaseDraw";
|
||
},
|
||
content: function () {
|
||
if (!player.storage.spell_gain || Math.max.apply(null, player.storage.spell_gain) < 0) {
|
||
var tmp = player.storage.spell_gain2;
|
||
player.storage.spell_gain = [
|
||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||
].randomGets(3);
|
||
player.storage.spell_gain2 = Math.floor(
|
||
(15 - Math.max.apply(null, player.storage.spell_gain)) / 2
|
||
);
|
||
if (tmp) {
|
||
for (var i = 0; i < 3; i++) {
|
||
player.storage.spell_gain[i] += tmp;
|
||
}
|
||
}
|
||
}
|
||
for (var i = 0; i < 3; i++) {
|
||
if (player.storage.spell_gain[i] == 0) {
|
||
var list;
|
||
if (i == 0) {
|
||
list = get.libCard(function (info) {
|
||
return info.subtype == "spell_gold";
|
||
});
|
||
if (get.mode() == "stone") {
|
||
list.remove("gw_aerdeyin");
|
||
list.remove("gw_niuquzhijing");
|
||
}
|
||
} else {
|
||
list = get.libCard(function (info) {
|
||
return info.subtype == "spell_silver";
|
||
});
|
||
if (get.mode() == "stone") {
|
||
list.remove("gw_butianshu");
|
||
}
|
||
}
|
||
if (list && list.length) {
|
||
ui.cardPile.insertBefore(
|
||
game.createCard(list.randomGet()),
|
||
ui.cardPile.firstChild
|
||
);
|
||
}
|
||
}
|
||
player.storage.spell_gain[i]--;
|
||
}
|
||
},
|
||
},
|
||
},
|
||
help: {
|
||
昆特牌:
|
||
"<ul><li>法术为分金、银、铜三类，金卡和银卡不出现在牌堆中<li>" +
|
||
"摸牌阶段有一定概率摸到银卡，在16个摸牌阶段中至少会摸到2张银卡<li>" +
|
||
"摸牌阶段有一定概率摸到金卡，在16个摸牌阶段中至少会摸到1张金卡<li>" +
|
||
"金卡无视调虎离山、潜行等免疫目标的效果<li>" +
|
||
"进行洗牌时金卡、银卡将从弃牌堆中消失，不进入牌堆",
|
||
},
|
||
translate: {
|
||
spell: "法术",
|
||
spell_gold: "金卡法术",
|
||
spell_silver: "银卡法术",
|
||
spell_bronze: "铜卡法术",
|
||
|
||
gw_youlanzhimeng: "幽蓝之梦",
|
||
gw_guaiwuchaoxue: "怪物巢穴",
|
||
gw_guaiwuchaoxue_info:
|
||
"出牌阶段限用一次，随机获得一个卖血技能直到下一回合开始；令一名随机敌方角色对你造成1点伤害，然后你回复1点体力。",
|
||
gw_baobaoshu: "雹暴术",
|
||
gw_baobaoshu_info:
|
||
"天气牌，出牌阶段对至多两名角色使用，目标每使用一张基本牌或锦囊牌，需弃置一张牌，直到下一回合结束。",
|
||
gw_baishuang: "白霜",
|
||
gw_baishuang_info: "天气牌，出牌阶段对至多三名角色使用，目标下个摸牌阶段摸牌数-1。",
|
||
gw_nuhaifengbao: "怒海风暴",
|
||
gw_nuhaifengbao_bg: "海",
|
||
gw_nuhaifengbao_info: "天气牌，出牌阶段对一名角色使用，目标在结束阶段随机弃置一张牌，持续2回合。",
|
||
gw_ganhan: "干旱",
|
||
gw_ganhan_info: "所有角色减少1点体力上限（不触发技能），然后结束出牌阶段。",
|
||
gw_huangjiashenpan: "皇家审判",
|
||
gw_huangjiashenpan_info: "获得任意一张金卡法术（皇家审判除外），然后结束出牌阶段。",
|
||
gw_chongci: "冲刺",
|
||
gw_chongci_info:
|
||
"弃置所有牌并随机获得一张非金法术牌，每弃置一张手牌，便随机获得一张类别相同的牌；每弃置一张装备区内的牌，随机装备一件类别相同的装备；获得潜行直到下一回合开始，然后结束出牌阶段。",
|
||
gw_tunshi: "吞噬",
|
||
gw_tunshi_info:
|
||
"随机移除一名敌方角色的一个随机技能，你获得此技能并减少1点体力和体力上限，被移除技能的角色增加1点体力和体力上限，然后结束出牌阶段。",
|
||
gw_dieyi: "蝶翼",
|
||
gw_dieyi_equip1: "蝶翼·器",
|
||
gw_dieyi_equip2: "蝶翼·衣",
|
||
gw_dieyi_equip3: "蝶翼·攻",
|
||
gw_dieyi_equip4: "蝶翼·防",
|
||
gw_dieyi_equip5: "蝶翼·宝",
|
||
gw_dieyi_judge: "蝶翼·判",
|
||
gw_dieyi_equip1_info:
|
||
"在你从装备区中失去此牌后，你获得一枚“蝶翼”标记；在任意角色的结束阶段，你移去所有“蝶翼”标记，并随机弃置等量的牌。",
|
||
gw_dieyi_equip2_info:
|
||
"在你从装备区中失去此牌后，你获得一枚“蝶翼”标记；在任意角色的结束阶段，你移去所有“蝶翼”标记，并随机弃置等量的牌。",
|
||
gw_dieyi_equip3_info:
|
||
"在你从装备区中失去此牌后，你获得一枚“蝶翼”标记；在任意角色的结束阶段，你移去所有“蝶翼”标记，并随机弃置等量的牌。",
|
||
gw_dieyi_equip4_info:
|
||
"在你从装备区中失去此牌后，你获得一枚“蝶翼”标记；在任意角色的结束阶段，你移去所有“蝶翼”标记，并随机弃置等量的牌。",
|
||
gw_dieyi_equip5_info:
|
||
"在你从装备区中失去此牌后，你获得一枚“蝶翼”标记；在任意角色的结束阶段，你移去所有“蝶翼”标记，并随机弃置等量的牌。",
|
||
gw_dieyi_judge_info:
|
||
"你在判定阶段移去此牌，并获得一枚“蝶翼”标记；在任意角色的结束阶段，你移去所有“蝶翼”标记，并随机弃置等量的牌。",
|
||
gw_hudiewu: "蝴蝶舞",
|
||
gw_hudiewu_info:
|
||
"将其他角色在场上的所有牌替换为蝶翼（每当你失去一张蝶翼，你获得一枚“蝶翼”标记；在任意角色的结束阶段，你移去所有“蝶翼”标记，并随机弃置等量的牌），然后结束出牌阶段。",
|
||
gw_yigeniyin: "伊格尼印",
|
||
gw_yigeniyin_info:
|
||
"对敌方角色中体力值最高的一名随机角色造成1点火焰伤害，然后对场上体力值最高的所有角色各造成1点火焰伤害，然后结束出牌阶段。",
|
||
gw_leizhoushu: "雷咒术",
|
||
gw_leizhoushu_info:
|
||
"获得技能雷咒术（在每个准备阶段令全场牌数最多的所有其他角色各随机弃置一张牌，若目标不包含敌方角色，将一名随机敌方角色追加为额外目标，结算X次，X为本局获得此技能的次数），然后结束出牌阶段。",
|
||
gw_aerdeyin: "阿尔德印",
|
||
gw_aerdeyin_bg: "印",
|
||
gw_aerdeyin_info:
|
||
"对一名随机敌方角色造成1点伤害，若目标武将牌正面朝上，则将其翻面；新的一轮开始时，若目标武将牌正面朝上，则在当前回合结束后进行一个额外回合，否则将武将牌翻回正面。",
|
||
gw_xinsheng: "新生",
|
||
gw_xinsheng_info:
|
||
"选择一名角色，随机观看12张武将牌，选择一张替代其武将牌，并令其增加1点体力，然后结束出牌阶段。",
|
||
gw_zhongmozhizhan: "终末之战",
|
||
gw_zhongmozhizhan_info: "将所有角色区域内的所有牌置入弃牌堆（不触发技能），然后结束出牌阶段。",
|
||
gw_butianshu: "卜天术",
|
||
gw_butianshu_info: "出牌阶段对任意角色使用，将任意一张延时锦囊牌置入其判定区。",
|
||
gw_zhihuanjun: "致幻菌",
|
||
gw_zhihuanjun_info:
|
||
"出牌阶段对一名已受伤角色使用，令其减少1点体力上限；若该角色仍处于受伤状态且手牌数小于体力上限，则重复此结算。",
|
||
gw_niuquzhijing: "纽曲之镜",
|
||
gw_niuquzhijing_info:
|
||
"令全场体力最多的角色减少1点体力和体力上限，体力最少的角色增加1点体力和体力上限（不触发技能），然后结束出牌阶段。",
|
||
gw_ansha: "暗杀",
|
||
gw_ansha_info: "令一名体力为1的随机敌方角立即死亡，然后结束出牌阶段。",
|
||
gw_shizizhaohuan: "十字召唤",
|
||
gw_shizizhaohuan_info: "从牌堆中获得一张杀以及决斗、火攻、火烧连营、南蛮入侵四张牌中的随机一张。",
|
||
gw_zuihouyuanwang: "最后愿望",
|
||
gw_zuihouyuanwang_info: "摸X张牌并弃置X张牌，X为存活角色数。",
|
||
gw_zirankuizeng: "自然馈赠",
|
||
gw_zirankuizeng_info: "选择任意一张铜卡法术使用。",
|
||
gw_poxiao: "破晓",
|
||
gw_poxiao_info:
|
||
"选择一项：解除任意名角色的天气效果并移除其判定区内的牌，或随机获得一张铜卡法术（破晓除外）并展示之。",
|
||
gw_zumoshoukao: "阻魔手铐",
|
||
gw_zumoshoukao_info: "令一名角色非锁定技失效直到下一回合结束。",
|
||
gw_aozuzhilei: "奥祖之雷",
|
||
gw_aozuzhilei_info: "对一名体力值不小于你的角色造成1点雷属性伤害，然后该角色摸一张牌。",
|
||
gw_zhuoshao: "灼烧",
|
||
gw_zhuoshao_info: "对任意名体力值为全场最高的角色使用，造成1点火属性伤害。",
|
||
gw_fuyuan: "复原",
|
||
gw_fuyuan_info: "对一名濒死状态角色使用，目标回复1点体力并摸一张牌。",
|
||
gw_youer: "诱饵",
|
||
gw_youer_bg: "饵",
|
||
gw_youer_info:
|
||
"将一名其他角色的所有手牌移出游戏，然后摸一张牌，当前回合结束后该角色将以此法失去的牌收回手牌。",
|
||
gw_tongdi: "通敌",
|
||
gw_tongdi_info: "观看一名其他角色的手牌并获得其中一张，然后令目标获得一张杀。",
|
||
gw_baoxueyaoshui: "暴雪药水",
|
||
gw_baoxueyaoshui_info: "令一名角色弃置两张手牌并摸一张牌。",
|
||
gw_birinongwu: "蔽日浓雾",
|
||
gw_birinongwu_bg: "雾",
|
||
gw_birinongwu_info:
|
||
"天气牌，出牌阶段对一名角色及其相邻角色使用，目标不能使用杀直到下一个出牌阶段结束。",
|
||
gw_qinpendayu: "倾盆大雨",
|
||
gw_qinpendayu_bg: "雨",
|
||
gw_qinpendayu_info:
|
||
"天气牌，出牌阶段对一名角色及其相邻角色使用，目标手牌上限-1直到下一个弃牌阶段结束。",
|
||
gw_ciguhanshuang: "刺骨寒霜",
|
||
gw_ciguhanshuang_bg: "霜",
|
||
gw_ciguhanshuang_info: "天气牌，出牌阶段对一名角色及其相邻角色使用，目标下个摸牌阶段摸牌数-1。",
|
||
gw_wenyi: "瘟疫",
|
||
gw_wenyi_info: "令所有体力值为全场最少的角色随机弃置一张手牌；若没有手牌，改为失去1点体力。",
|
||
gw_yanziyaoshui: "燕子药水",
|
||
gw_yanziyaoshui_info: "令一名角色摸一张牌，若其手牌数为全场最少或之一，改为摸两张。",
|
||
gw_shanbengshu: "山崩术",
|
||
gw_shanbengshu_info: "出牌阶段对自己使用，随机弃置两件敌方角色场上的装备。",
|
||
gw_kunenfayin: "昆恩法印",
|
||
gw_kunenfayin_info:
|
||
"出牌阶段对一名角色使用，目标防止所有非属性伤害，持续X个角色的回合（X为存活角色数且最多为5）。",
|
||
},
|
||
cardType: {
|
||
spell: 0.5,
|
||
spell_bronze: 0.2,
|
||
spell_silver: 0.3,
|
||
spell_gold: 0.4,
|
||
},
|
||
list: [
|
||
["club", 3, "gw_zhihuanjun"],
|
||
["spade", 2, "gw_zhihuanjun"],
|
||
|
||
["heart", 7, "gw_poxiao"],
|
||
["diamond", 4, "gw_poxiao"],
|
||
|
||
["spade", 9, "gw_aozuzhilei", "thunder"],
|
||
["club", 7, "gw_aozuzhilei", "thunder"],
|
||
|
||
["club", 1, "gw_zumoshoukao"],
|
||
["spade", 1, "gw_zumoshoukao"],
|
||
|
||
["diamond", 5, "gw_qinpendayu"],
|
||
["club", 7, "gw_qinpendayu"],
|
||
|
||
["spade", 9, "gw_birinongwu"],
|
||
["heart", 13, "gw_birinongwu"],
|
||
|
||
["diamond", 11, "gw_ciguhanshuang"],
|
||
["club", 7, "gw_ciguhanshuang"],
|
||
|
||
["heart", 4, "gw_baoxueyaoshui"],
|
||
["spade", 8, "gw_baoxueyaoshui"],
|
||
|
||
["spade", 8, "gw_shanbengshu"],
|
||
["spade", 2, "gw_kunenfayin"],
|
||
["club", 3, "gw_wenyi"],
|
||
["heart", 8, "gw_yanziyaoshui"],
|
||
],
|
||
};
|
||
});
|