观看下家副将：' + (lib.configOL.viewnext ? "开启" : "关闭")
);
last.style.paddingBottom = "8px";
},
addRecord: function (bool) {
if (typeof bool == "boolean") {
var data = lib.config.gameRecord.guozhan.data;
var identity = game.me.identity;
if (!data[identity]) {
data[identity] = [0, 0];
}
if (bool) {
data[identity][0]++;
} else {
data[identity][1]++;
}
var list = lib.group.slice(0);
list.add("ye");
var str = "";
for (var i = 0; i < list.length; i++) {
if (list[i] != "shen" && data[list[i]]) {
str +=
lib.translate[list[i] + "2"] +
"：" +
data[list[i]][0] +
"胜" +
" " +
data[list[i]][1] +
"负
";
}
}
lib.config.gameRecord.guozhan.str = str;
game.saveConfig("gameRecord", lib.config.gameRecord);
}
},
getIdentityList: function (player) {
if (!player.isUnseen()) return;
if (player == game.me) return;
var list = {
wei: "魏",
shu: "蜀",
wu: "吴",
qun: "群",
ye: "野",
unknown: "猜",
};
var num = Math.floor((game.players.length + game.dead.length) / 2);
var noye = true;
if (get.population("wei") >= num) {
delete list.wei;
noye = false;
}
if (get.population("shu") >= num) {
delete list.shu;
noye = false;
}
if (get.population("wu") >= num) {
delete list.wu;
noye = false;
}
if (get.population("qun") >= num) {
delete list.qun;
noye = false;
}
if (noye) {
delete list.ye;
}
return list;
},
getIdentityList2: function (list) {
for (var i in list) {
switch (i) {
case "unknown":
list[i] = "未知";
break;
case "ye":
list[i] = "野心家";
break;
case "qun":
list[i] += "雄";
break;
case "key":
list[i] = "Key";
break;
case "jin":
list[i] += "朝";
break;
default:
list[i] += "国";
}
}
},
getVideoName: function () {
var str = get.translation(game.me.name1) + "/" + get.translation(game.me.name2);
var str2 = _status.separatism
? get.modetrans({
mode: lib.config.mode,
separatism: true,
})
: get.cnNumber(parseInt(get.config("player_number"))) +
"人" +
get.translation(lib.config.mode);
if (game.me.identity == "ye") {
str2 += " - 野心家";
}
var name = [str, str2];
return name;
},
showIdentity: function (started) {
if (game.phaseNumber == 0 && !started) return;
for (var i = 0; i < game.players.length; i++) {
game.players[i].showCharacter(2, false);
}
},
tryResult: function () {
var map = {},
sides = [],
pmap = _status.connectMode ? lib.playerOL : game.playerMap,
hiddens = [];
for (var i of game.players) {
if (i.identity == "unknown") {
hiddens.push(i);
continue;
}
var added = false;
for (var j of sides) {
if (i.isFriendOf(pmap[j])) {
added = true;
map[j].push(i);
break;
}
}
if (!added) {
map[i.playerid] = [i];
sides.push(i.playerid);
}
}
if (!sides.length) return;
else if (sides.length > 1) {
if (!hiddens.length && sides.length == 2) {
if (
map[sides[0]].length == 1 &&
!map[sides[1]].filter(function (i) {
return i.identity != "ye" && i.isUnseen(0);
}).length
)
map[sides[0]][0].showGiveup();
if (
map[sides[1]].length == 1 &&
!map[sides[0]].filter(function (i) {
return i.identity != "ye" && i.isUnseen(0);
}).length
)
map[sides[1]][0].showGiveup();
}
} else {
var isYe = function (player) {
return player.identity != "ye" && lib.character[player.name1][1] == "ye";
};
if (!hiddens.length) {
if (map[sides[0]].length > 1) {
for (var i of map[sides[0]]) {
if (isYe(i)) {
game.showYexings();
return;
}
}
}
game.broadcastAll(function (id) {
game.winner_id = id;
}, sides[0]);
game.checkResult();
} else {
var identity = map[sides[0]][0].identity;
if (identity == "ye") return;
for (var i of map[sides[0]]) {
if (isYe(i)) return;
}
for (var ind = 0; ind < hiddens.length; ind++) {
var current = hiddens[ind];
if (
isYe(current) ||
current.getGuozhanGroup(2) != identity ||
!current.wontYe(null, ind + 1)
)
return;
}
game.broadcastAll(function (id) {
game.winner_id = id;
}, sides[0]);
game.checkResult();
}
}
},
checkResult: function () {
_status.overing = true;
var me = game.me._trueMe || game.me;
for (var i = 0; i < game.players.length; i++) {
game.players[i].showCharacter(2);
}
var winner = (_status.connectMode ? lib.playerOL : game.playerMap)[game.winner_id];
game.over(winner && winner.isFriendOf(me) ? true : false);
game.showIdentity();
},
checkOnlineResult: function (player) {
var winner = lib.playerOL[game.winner_id];
return winner && winner.isFriendOf(game.me);
},
chooseCharacter: function () {
var next = game.createEvent("chooseCharacter");
next.showConfig = true;
next.addPlayer = true;
next.ai = function (player, list, back) {
if (_status.brawl && _status.brawl.chooseCharacterAi) {
if (_status.brawl.chooseCharacterAi(player, list, back) !== false) {
return;
}
}
var filterChoice = function (name1, name2) {
if (_status.separatism) return true;
var group1 = lib.character[name1][1];
var group2 = lib.character[name2][1];
var doublex = get.is.double(name1, true);
if (doublex) {
var double = get.is.double(name2, true);
if (double) return doublex.some((group) => double.includes(group));
return doublex.includes(group2);
} else {
if (group1 == "ye") return group2 != "ye";
var double = get.is.double(name2, true);
if (double) return double.includes(group1);
return group1 == group2;
}
};
for (var i = 0; i < list.length - 1; i++) {
for (var j = i + 1; j < list.length; j++) {
if (filterChoice(list[i], list[j]) || filterChoice(list[j], list[i])) {
var mainx = list[i];
var vicex = list[j];
if (
!filterChoice(mainx, vicex) ||
(filterChoice(vicex, mainx) && get.guozhanReverse(mainx, vicex))
) {
mainx = list[j];
vicex = list[i];
}
player.init(mainx, vicex, false);
if (get.is.double(mainx, true)) {
if (!get.is.double(vicex, true))
player.trueIdentity = lib.character[vicex][1];
else if (
get.is.double(mainx, true).removeArray(get.is.double(vicex, true))
.length == 0 ||
get.is.double(vicex, true).removeArray(get.is.double(mainx, true))
.length == 0
)
player.trueIdentity = get.is
.double(vicex, true)
.filter((group) => get.is.double(mainx, true).includes(group))
.randomGet();
else
player.trueIdentity = get.is
.double(mainx, true)
.find((group) => get.is.double(vicex, true).includes(group));
} else if (lib.character[mainx][1] == "ye" && get.is.double(vicex, true))
player.trueIdentity = get.is.double(vicex, true).randomGet();
if (back) {
list.remove(player.name1);
list.remove(player.name2);
for (var i = 0; i < list.length; i++) {
back.push(list[i]);
}
}
return;
}
}
}
};
next.setContent(function () {
"step 0";
ui.arena.classList.add("choose-character");
var addSetting = function (dialog) {
dialog.add("选择座位").classList.add("add-setting");
var seats = document.createElement("table");
seats.classList.add("add-setting");
seats.style.margin = "0";
seats.style.width = "100%";
seats.style.position = "relative";
for (var i = 1; i <= game.players.length; i++) {
var td = ui.create.div(".shadowed.reduce_radius.pointerdiv.tdnode");
td.innerHTML = "
" + get.cnNumber(i, true) + "";
td.link = i - 1;
seats.appendChild(td);
td.addEventListener(lib.config.touchscreen ? "touchend" : "click", function () {
if (_status.dragged) return;
if (_status.justdragged) return;
if (_status.cheat_seat) {
_status.cheat_seat.classList.remove("bluebg");
if (_status.cheat_seat == this) {
delete _status.cheat_seat;
return;
}
}
this.classList.add("bluebg");
_status.cheat_seat = this;
});
}
dialog.content.appendChild(seats);
if (game.me == game.zhu) {
seats.previousSibling.style.display = "none";
seats.style.display = "none";
}
dialog.add(ui.create.div(".placeholder.add-setting"));
dialog.add(ui.create.div(".placeholder.add-setting"));
if (get.is.phoneLayout()) dialog.add(ui.create.div(".placeholder.add-setting"));
};
var removeSetting = function () {
var dialog = _status.event.dialog;
if (dialog) {
dialog.style.height = "";
delete dialog._scrollset;
var list = Array.from(dialog.querySelectorAll(".add-setting"));
while (list.length) {
list.shift().remove();
}
ui.update();
}
};
event.addSetting = addSetting;
event.removeSetting = removeSetting;
var chosen = lib.config.continue_name || [];
game.saveConfig("continue_name");
event.chosen = chosen;
var i;
event.list = [];
for (i in lib.character) {
if (i.indexOf("gz_shibing") == 0) continue;
if (chosen.includes(i)) continue;
if (lib.filter.characterDisabled(i)) continue;
if (get.config("onlyguozhan")) {
if (!lib.characterGuozhanFilter.some((pack) => lib.characterPack[pack][i]))
continue;
if (get.is.jun(i)) continue;
}
if (lib.character[i][4].includes("hiddenSkill")) continue;
if (lib.character[i][2] == 3 || lib.character[i][2] == 4 || lib.character[i][2] == 5)
event.list.push(i);
}
_status.characterlist = event.list.slice(0);
_status.yeidentity = [];
if (_status.brawl && _status.brawl.chooseCharacterFilter) {
event.list = _status.brawl.chooseCharacterFilter(event.list);
}
event.list.randomSort();
// var list=event.list.splice(0,parseInt(get.config('choice_num')));
var list;
if (_status.brawl && _status.brawl.chooseCharacter) {
list = _status.brawl.chooseCharacter(event.list, game.me);
} else {
list = game.getCharacterChoice(event.list, parseInt(get.config("choice_num")));
}
if (_status.auto) {
event.ai(game.me, list);
lib.init.onfree();
} else if (chosen.length) {
game.me.init(chosen[0], chosen[1], false);
lib.init.onfree();
} else {
var dialog = ui.create.dialog("选择角色", "hidden", [list, "character"]);
if (!_status.brawl || !_status.brawl.noAddSetting) {
if (get.config("change_identity")) {
addSetting(dialog);
}
}
var next = game.me.chooseButton(dialog, true, 2).set("onfree", true);
next.filterButton = function (button) {
if (ui.dialog.buttons.length <= 10) {
for (var i = 0; i < ui.dialog.buttons.length; i++) {
if (ui.dialog.buttons[i] != button) {
if (
lib.element.player.perfectPair.call(
{
name1: button.link,
name2: ui.dialog.buttons[i].link,
},
true
)
) {
button.classList.add("glow2");
}
}
}
}
if (lib.character[button.link][4].includes("hiddenSkill")) return false;
var filterChoice = function (name1, name2) {
if (_status.separatism) return true;
var group1 = lib.character[name1][1];
var group2 = lib.character[name2][1];
var doublex = get.is.double(name1, true);
if (doublex) {
var double = get.is.double(name2, true);
if (double) return doublex.some((group) => double.includes(group));
return doublex.includes(group2);
} else {
if (group1 == "ye") return group2 != "ye";
var double = get.is.double(name2, true);
if (double) return double.includes(group1);
return group1 == group2;
}
};
if (!ui.selected.buttons.length) {
return ui.dialog.buttons.some((but) => {
if (but == button) return false;
return filterChoice(button.link, but.link);
});
}
return filterChoice(ui.selected.buttons[0].link, button.link);
};
next.switchToAuto = function () {
event.ai(game.me, list);
ui.arena.classList.remove("selecting");
};
var createCharacterDialog = function () {
event.dialogxx = ui.create.characterDialog(
"heightset",
function (i) {
if (i.indexOf("gz_shibing") == 0) return true;
if (get.config("onlyguozhan")) {
if (
!lib.characterGuozhanFilter.some(
(pack) => lib.characterPack[pack][i]
)
)
return true;
if (get.is.jun(i)) return true;
}
},
get.config("onlyguozhanexpand") ? "expandall" : undefined,
get.config("onlyguozhan") ? "onlypack:mode_guozhan" : undefined
);
if (ui.cheat2) {
ui.cheat2.addTempClass("controlpressdownx", 500);
ui.cheat2.classList.remove("disabled");
}
};
if (lib.onfree) {
lib.onfree.push(createCharacterDialog);
} else {
createCharacterDialog();
}
ui.create.cheat2 = function () {
ui.cheat2 = ui.create.control("自由选将", function () {
if (this.dialog == _status.event.dialog) {
if (game.changeCoin) {
game.changeCoin(10);
}
this.dialog.close();
_status.event.dialog = this.backup;
this.backup.open();
delete this.backup;
game.uncheck();
game.check();
if (ui.cheat) {
ui.cheat.addTempClass("controlpressdownx", 500);
ui.cheat.classList.remove("disabled");
}
} else {
if (game.changeCoin) {
game.changeCoin(-10);
}
this.backup = _status.event.dialog;
_status.event.dialog.close();
_status.event.dialog = _status.event.parent.dialogxx;
this.dialog = _status.event.dialog;
this.dialog.open();
game.uncheck();
game.check();
if (ui.cheat) {
ui.cheat.classList.add("disabled");
}
}
});
if (lib.onfree) {
ui.cheat2.classList.add("disabled");
}
};
ui.create.cheat = function () {
_status.createControl = ui.cheat2;
ui.cheat = ui.create.control("更换", function () {
if (ui.cheat2 && ui.cheat2.dialog == _status.event.dialog) {
return;
}
if (game.changeCoin) {
game.changeCoin(-3);
}
event.list = event.list.concat(list);
event.list.randomSort();
// list=event.list.splice(0,parseInt(get.config('choice_num')));
list = game.getCharacterChoice(
event.list,
parseInt(get.config("choice_num"))
);
var buttons = ui.create.div(".buttons");
var node = _status.event.dialog.buttons[0].parentNode;
_status.event.dialog.buttons = ui.create.buttons(list, "character", buttons);
_status.event.dialog.content.insertBefore(buttons, node);
buttons.addTempClass("start");
node.remove();
game.uncheck();
game.check();
});
delete _status.createControl;
};
if (!_status.brawl || !_status.brawl.chooseCharacterFixed) {
if (!ui.cheat && get.config("change_choice")) ui.create.cheat();
if (!ui.cheat2 && get.config("free_choose")) ui.create.cheat2();
}
}
"step 1";
if (ui.cheat) {
ui.cheat.close();
delete ui.cheat;
}
if (ui.cheat2) {
ui.cheat2.close();
delete ui.cheat2;
}
if (result.buttons) {
var name1 = result.buttons[0].link,
name2 = result.buttons[1].link;
event.choosen = [name1, name2];
if (get.is.double(name1, true)) {
if (!get.is.double(name2, true))
event._result = { control: lib.character[name2][1] };
else if (
get.is.double(name1, true).removeArray(get.is.double(name2, true)).length ==
0 ||
get.is.double(name2, true).removeArray(get.is.double(name1, true)).length == 0
)
game.me
.chooseControl(
get.is
.double(name2, true)
.filter((group) => get.is.double(name1, true).includes(group))
)
.set("prompt", "请选择你代表的势力")
.set("ai", () => _status.event.controls.randomGet());
else
event._result = {
control: get.is
.double(name1, true)
.find((group) => get.is.double(name2, true).includes(group)),
};
} else if (lib.character[name1][1] == "ye" && get.is.double(name2, true))
game.me
.chooseControl(get.is.double(name2, true))
.set("prompt", "请选择副将代表的势力")
.set("ai", () => _status.event.controls.randomGet());
}
"step 2";
if (result && result.control) game.me.trueIdentity = result.control;
if (event.choosen) {
game.me.init(event.choosen[0], event.choosen[1], false);
game.addRecentCharacter(event.choosen[0], event.choosen[1]);
}
event.list.remove(game.me.name1);
event.list.remove(game.me.name2);
for (var i = 0; i < game.players.length; i++) {
if (game.players[i] != game.me) {
event.ai(
game.players[i],
game.getCharacterChoice(event.list, parseInt(get.config("choice_num"))),
event.list
);
}
}
for (var i = 0; i < game.players.length; i++) {
game.players[i].classList.add("unseen");
game.players[i].classList.add("unseen2");
_status.characterlist.remove(game.players[i].name);
_status.characterlist.remove(game.players[i].name2);
if (game.players[i] != game.me) {
game.players[i].node.identity.firstChild.innerHTML = "猜";
game.players[i].node.identity.dataset.color = "unknown";
game.players[i].node.identity.classList.add("guessing");
}
game.players[i].hiddenSkills = lib.character[game.players[i].name1][3].slice(0);
var hiddenSkills2 = lib.character[game.players[i].name2][3];
for (var j = 0; j < hiddenSkills2.length; j++) {
game.players[i].hiddenSkills.add(hiddenSkills2[j]);
}
for (var j = 0; j < game.players[i].hiddenSkills.length; j++) {
if (!lib.skill[game.players[i].hiddenSkills[j]]) {
game.players[i].hiddenSkills.splice(j--, 1);
}
}
game.players[i].group = "unknown";
game.players[i].sex = "unknown";
game.players[i].name1 = game.players[i].name;
game.players[i].name = "unknown";
game.players[i].identity = "unknown";
game.players[i].node.name.show();
game.players[i].node.name2.show();
for (var j = 0; j < game.players[i].hiddenSkills.length; j++) {
game.players[i].addSkillTrigger(game.players[i].hiddenSkills[j], true);
}
}
setTimeout(function () {
ui.arena.classList.remove("choose-character");
}, 500);
});
},
chooseCharacterOL: function () {
var next = game.createEvent("chooseCharacter");
next.setContent(function () {
"step 0";
game.broadcastAll(function () {
ui.arena.classList.add("choose-character");
for (var i = 0; i < game.players.length; i++) {
game.players[i].classList.add("unseen");
game.players[i].classList.add("unseen2");
}
});
var list = [];
for (var i in lib.characterPack.mode_guozhan) {
if (i.indexOf("gz_shibing") == 0) continue;
if (get.is.jun(i)) continue;
if (lib.config.guozhan_banned && lib.config.guozhan_banned.includes(i)) continue;
list.push(i);
}
_status.characterlist = list.slice(0);
_status.yeidentity = [];
event.list = list.slice(0);
var list2 = [];
var num;
if (lib.configOL.number * 6 > list.length) {
num = 5;
} else if (lib.configOL.number * 7 > list.length) {
num = 6;
} else {
num = 7;
}
var filterButton = function (button) {
if (ui.dialog) {
if (ui.dialog.buttons.length <= 10) {
for (var i = 0; i < ui.dialog.buttons.length; i++) {
if (ui.dialog.buttons[i] != button) {
if (
lib.element.player.perfectPair.call(
{
name1: button.link,
name2: ui.dialog.buttons[i].link,
},
true
)
) {
button.classList.add("glow2");
}
}
}
}
}
var filterChoice = function (name1, name2) {
if (_status.separatism) return true;
var group1 = lib.character[name1][1];
var group2 = lib.character[name2][1];
var doublex = get.is.double(name1, true);
if (doublex) {
var double = get.is.double(name2, true);
if (double) return doublex.some((group) => double.includes(group));
return doublex.includes(group2);
} else {
if (group1 == "ye") return group2 != "ye";
var double = get.is.double(name2, true);
if (double) return double.includes(group1);
return group1 == group2;
}
};
if (!ui.selected.buttons.length) {
return ui.dialog.buttons.some((but) => {
if (but == button) return false;
return filterChoice(button.link, but.link);
});
}
return filterChoice(ui.selected.buttons[0].link, button.link);
};
list.randomSort();
for (var i = 0; i < game.players.length; i++) {
list2.push([
game.players[i],
["选择角色", [game.getCharacterChoice(list, num), "character"]],
2,
true,
function () {
return Math.random();
},
filterButton,
]);
}
game.me
.chooseButtonOL(list2, function (player, result) {
if (game.online || player == game.me)
player.init(result.links[0], result.links[1], false);
})
.set("switchToAuto", function () {
_status.event.result = "ai";
})
.set("processAI", function () {
var buttons = _status.event.dialog.buttons;
var filterChoice = function (name1, name2) {
if (_status.separatism) return true;
var group1 = lib.character[name1][1];
var group2 = lib.character[name2][1];
var doublex = get.is.double(name1, true);
if (doublex) {
var double = get.is.double(name2, true);
if (double) return doublex.some((group) => double.includes(group));
return doublex.includes(group2);
} else {
if (group1 == "ye") return group2 != "ye";
var double = get.is.double(name2, true);
if (double) return double.includes(group1);
return group1 == group2;
}
};
for (var i = 0; i < buttons.length - 1; i++) {
for (var j = i + 1; j < buttons.length; j++) {
if (
filterChoice(buttons[i].link, buttons[j].link) ||
filterChoice(buttons[j].link, buttons[i].link)
) {
var mainx = buttons[i].link;
var vicex = buttons[j].link;
if (
!filterChoice(mainx, vicex) ||
(filterChoice(vicex, mainx) && get.guozhanReverse(mainx, vicex))
) {
mainx = buttons[j].link;
vicex = buttons[i].link;
}
var list = [mainx, vicex];
return {
bool: true,
links: list,
};
}
}
}
});
"step 1";
var sort = true,
chosen = [],
chosenCharacter = [];
for (var i in result) {
if (result[i] && result[i].links) {
for (var j = 0; j < result[i].links.length; j++) {
event.list.remove(result[i].links[j]);
}
}
}
for (var i in result) {
if (result[i] == "ai" || !result[i].links || result[i].links.length < 1) {
if (sort) {
sort = false;
event.list.randomSort();
}
result[i] = [event.list.shift()];
var group = lib.character[result[i][0]][1];
for (var j = 0; j < event.list.length; j++) {
if (lib.character[event.list[j]][1] == group) {
result[i].push(event.list[j]);
event.list.splice(j--, 1);
break;
}
}
} else {
result[i] = result[i].links;
}
var name1 = result[i][0],
name2 = result[i][1];
if (get.is.double(name1, true)) {
if (!get.is.double(name2, true))
lib.playerOL[i].trueIdentity = lib.character[name2][1];
else if (
get.is.double(name1, true).removeArray(get.is.double(name2, true)).length ==
0 ||
get.is.double(name2, true).removeArray(get.is.double(name1, true)).length == 0
) {
chosen.push(lib.playerOL[i]);
chosenCharacter.push([name1, name2]);
} else
lib.playerOL[i].trueIdentity = get.is
.double(name1, true)
.find((group) => get.is.double(name2, true).includes(group));
} else if (lib.character[name1][1] == "ye" && get.is.double(name2, true)) {
chosen.push(lib.playerOL[i]);
chosenCharacter.push([name1, name2]);
}
}
event.result2 = result;
if (chosen.length) {
for (var i = 0; i < chosen.length; i++) {
var name1 = chosenCharacter[i][0],
name2 = chosenCharacter[i][1],
str,
choice;
if (get.is.double(name1, true)) {
str = "请选择你代表的势力";
choice = get.is
.double(name2, true)
.filter((group) => get.is.double(name1, true).includes(group));
}
if (lib.character[name1][1] == "ye") {
str = "请选择你的副将代表的势力";
choice = get.is.double(name2, true);
}
chosen[i] = [
chosen[i],
[
str,
[
choice.map(function (i) {
return ["", "", "group_" + i];
}),
"vcard",
],
],
1,
true,
];
}
game.me
.chooseButtonOL(chosen, function (player, result) {
if (player == game.me) player.trueIdentity = result.links[0][2].slice(6);
})
.set("switchToAuto", function () {
_status.event.result = "ai";
})
.set("processAI", function () {
return {
bool: true,
links: [_status.event.dialog.buttons.randomGet().link],
};
});
} else event._result = {};
"step 2";
if (!result) result = {};
var result2 = event.result2;
game.broadcastAll(
function (result, result2) {
for (var i = 0; i < game.players.length; i++) {
var current = game.players[i],
id = current.playerid;
if (result[id] && !current.name) {
current.init(result[id][0], result[id][1], false);
}
if (result2[id] && result2[id].length) {
current.trueIdentity = result2[id][0][2].slice(6);
}
if (game.players[i] != game.me) {
game.players[i].node.identity.firstChild.innerHTML = "猜";
game.players[i].node.identity.dataset.color = "unknown";
game.players[i].node.identity.classList.add("guessing");
}
game.players[i].hiddenSkills =
lib.character[game.players[i].name1][3].slice(0);
var hiddenSkills2 = lib.character[game.players[i].name2][3];
for (var j = 0; j < hiddenSkills2.length; j++) {
game.players[i].hiddenSkills.add(hiddenSkills2[j]);
}
for (var j = 0; j < game.players[i].hiddenSkills.length; j++) {
if (!lib.skill[game.players[i].hiddenSkills[j]]) {
game.players[i].hiddenSkills.splice(j--, 1);
}
}
game.players[i].group = "unknown";
game.players[i].sex = "unknown";
game.players[i].name1 = game.players[i].name;
game.players[i].name = "unknown";
game.players[i].identity = "unknown";
game.players[i].node.name.show();
game.players[i].node.name2.show();
}
setTimeout(function () {
ui.arena.classList.remove("choose-character");
}, 500);
},
result2,
result
);
});
},
},
ui: {
click: {
// identity:function(){
// if(this.touched) {this.touched=false;return;}
// _status.clicked=true;
// if(this.parentNode.isUnseen()&&this.parentNode!=game.me){
// switch(this.firstChild.innerHTML){
// case '魏':this.firstChild.innerHTML='蜀';this.dataset.color='shu';break;
// case '蜀':this.firstChild.innerHTML='吴';this.dataset.color='wu';break;
// case '吴':this.firstChild.innerHTML='群';this.dataset.color='qun';break;
// case '群':this.firstChild.innerHTML='野';this.dataset.color='ye';break;
// case '野':this.firstChild.innerHTML='猜';this.dataset.color='unknown';break;
// default:this.firstChild.innerHTML='魏';this.dataset.color='wei';break;
// }
// }
// }
},
},
dynamicTranslate: {
gzzhaosong: function (player) {
var storage = player.getStorage("gzzhaosong");
var list1 = ["效果①", "效果②", "效果③"];
var str = "每局游戏每项限一次。";
var list2 = [
"①一名角色进入濒死状态时，你可以令其回复至2点体力并摸一张牌。",
"②出牌阶段，你可观看一名其他角色的所有暗置武将牌和手牌，然后可以获得其区域内的一张牌。",
"③一名角色使用【杀】选择唯一目标后，你可以为此【杀】增加两个目标。",
];
for (var i = 0; i < 3; i++) {
var bool = storage.includes(list1[i]);
if (bool) str += '
';
str += list2[i];
if (bool) str += "";
}
return str;
},
gzshiyong: function (player) {
return player.awakenedSkills.includes("gzyaowu")
? lib.translate.gzshiyongx_info
: lib.translate.gzshiyong_info;
},
fakejuzhan(player) {
let str = "转换技。",
storage = player.storage.fakejuzhan;
if (!storage) str += '
';
str +=
"阴：当你成为【杀】的目标后，你可以与使用者各摸X张牌，然后若使用者的武将牌均明置，则你可以暗置其一张武将牌，且其本回合不能明置此武将牌。";
if (!storage) str += "";
if (storage) str += '
';
str +=
"阳，当你使用【杀】指定目标后，你可以获得目标角色的X张牌，然后若你的武将牌均明置，则其可以暗置此武将牌，且你本回合不能明置此武将牌。";
if (storage) str += "";
return str + "（X为使用者已损失的体力值且X至少为1）";
},
fakeweirong(player) {
let str = "转换技，每轮限一次，出牌阶段。",
storage = player.storage.fakeweirong;
if (!storage) str += '
';
str += "阴：你可以弃置X张牌，然后当你于本轮不因此法得到牌后，你摸一张牌。";
if (!storage) str += "";
if (storage) str += '
';
str += "阳：你可以摸X张牌，然后当你于本轮不因此法失去牌后，你弃置一张牌。";
if (storage) str += "";
return str + "（X为你上一轮以此法摸和弃置的牌数之和，且X至少为1，至多为你的体力上限）";
},
},
translate: {
ye: "野",
ye2: "野心家",
yexinjia_mark: "野心家",
bumingzhi: "不明置",
mingzhizhujiang: "明置主将",
mingzhifujiang: "明置副将",
tongshimingzhi: "同时明置",
mode_guozhan_character_config: "国战武将",
_zhenfazhaohuan: "阵法召唤",
_zhenfazhaohuan_info:
"由拥有阵法技的角色发起，满足此阵法技条件的未确定势力角色均可按逆时针顺序依次明置其一张武将牌(响应阵法召唤)，以发挥阵法技的效果。",
junling: "军令",
junling1: "军令一",
junling1_bg: "令",
junling1_info: "若被执行，执行者对发起者指定的一名角色造成1点伤害。",
junling2: "军令二",
junling2_bg: "令",
junling2_info: "若被执行，执行者摸一张牌，然后依次交给发起者两张牌。",
junling3: "军令三",
junling3_bg: "令",
junling3_info: "若被执行，执行者失去1点体力。",
junling4: "军令四",
junling4_bg: "令",
junling4_info: "若被执行，直到回合结束，执行者不能使用或打出手牌且非锁定技全部失效。",
junling4_eff: "军令四",
junling5: "军令五",
junling5_bg: "令",
junling5_info: "若被执行，执行者将武将牌叠置，且不能回复体力直到回合结束。",
junling5_eff: "军令五",
junling6: "军令六",
junling6_bg: "令",
junling6_info: "若被执行，执行者选择一张手牌和一张装备区内牌（若有），然后弃置其余的牌。",
gz_miheng: "祢衡",
gzshensu: "神速",
gzshensu_info:
"①判定阶段开始时，你可跳过此阶段和摸牌阶段，视为使用一张【杀】（无距离限制）。②出牌阶段开始时，你可跳过此阶段并弃置一张装备牌，视为使用一张【杀】（无距离限制）。③弃牌开始时，你可跳过此阶段并失去1点体力，视为使用一张【杀】（无距离限制）。",
gzwushuang: "无双",
gzwushuang_info:
"锁定技。①当你使用【杀】或【决斗】指定目标后/成为【决斗】的目标后，你令此牌需要依次使用或打出两张【闪】或【杀】响应。②当你使用非转化的【决斗】选择目标后，你可为此【决斗】增加两个目标。",
gzkuangfu: "狂斧",
gzkuangfu_info:
"出牌阶段限一次。当你使用【杀】指定目标后，你可获得目标角色装备区内的一张牌。然后若此【杀】未造成伤害，则你弃置两张手牌。",
gzliegong: "烈弓",
gzliegong_info:
"①你对手牌数不大于你的角色使用【杀】不受距离关系的限制。②当你使用【杀】指定目标后，若其体力值不小于你，则你可以选择一项：⒈令此【杀】对其的伤害值基数+1。⒉令其不可响应此【杀】。",
gzhongyan: "红颜",
gzhongyan_info:
"锁定技。①你区域内的黑桃牌和黑桃判定牌的花色视为红桃。②若你的装备区内有红桃牌，则你的手牌上限+1。",
gztianxiang: "天香",
gztianxiang_info:
"每回合限一次。当你受到伤害时，你可以弃置一张红桃手牌，防止此次伤害并选择一名其他角色，然后你选择一项：1.令其受到伤害来源对其造成的1点伤害，然后摸X张牌（X为其已损失体力值且至多为5）；2.令其失去1点体力，然后获得你弃置的牌。",
gzluoyi: "裸衣",
gzluoyi_info:
"摸牌阶段结束时，你可弃置一张牌，然后你于本回合内造成渠道为【杀】或【决斗】的伤害+1。",
gzqiangxi: "强袭",
gzqiangxi_info:
"出牌阶段限一次，你可以弃置一张武器牌或失去1点体力，然后对一名其他角色造成1点伤害。",
gz_sp_duyu: "杜预",
gzpozhen: "破阵",
gzpozhen_info:
"限定技，其他角色的回合开始时，你可以令其本回合不可使用、打出或重铸手牌；若其处于队列或围攻关系中，你可依次弃置此队列或参与围攻关系的其他角色的一张牌。",
gzjiancai: "荐才",
gzjiancai_info:
"副将技，此武将牌上单独的阴阳鱼个数-1。与你势力相同的角色即将受到伤害而进入濒死状态时，你可以防止此伤害，若如此做，你须变更副将；与你势力相同的角色变更副将时，其额外获得两张备选武将牌。",
gzzhuhai: "诛害",
gzzhuhai_info:
"其他角色的结束阶段，若其本回合内造成过伤害，则你可以对其使用一张【杀】（无距离限制）。若其本回合内对与你势力相同的角色造成过伤害，则此【杀】无视防具，且当其抵消此【杀】后，其须弃置一张牌。",
gzzhuosheng: "擢升",
gzzhuosheng2: "擢升",
gzzhuosheng_info:
"当一名与你势力相同的角色受到伤害后，你可令其摸一张牌。然后直到其下个结束阶段前，其使用此牌根据类型执行以下效果：1. 基本牌，不计入次数且无距离限制；2. 普通锦囊牌，此牌目标可+1或-1；3. 装备牌，可摸一张牌。",
gzzhaoxin: "昭心",
gzzhaoxin_info: "当你受到伤害后，你可展示所有手牌，然后与一名手牌数不大于你的其他角色交换手牌。",
gzsuzhi: "夙智",
gzsuzhi_info:
"锁定技，每回合累计限三次；①当你于回合内因执行【杀】或【决斗】造成伤害时，此伤害+1；②你于回合内使用非转化的锦囊牌时摸一张牌，且无距离限制；③当有其他角色于你的回合内弃置牌后，你获得该角色的一张牌；④结束阶段，你获得〖反馈〗直到下回合开始。",
gzhuaiyi: "怀异",
gzhuaiyi_info:
"出牌阶段限一次，你可以展示所有手牌。若其中包含两种颜色，则你可以弃置其中一种颜色的所有牌，然后获得至多等量名角色的各一张牌。然后你将以此法得到的装备牌置于武将牌上，称为“异”。",
gzzisui: "恣睢",
gzzisui_info:
"锁定技，摸牌阶段，你多摸X张牌。结束阶段，若X大于你的体力上限，你死亡（X为“异”数）。",
gz_tangzi: "唐咨",
gz_mengda: "孟达",
gz_liuqi: "刘琦",
gz_mifangfushiren: "糜芳傅士仁",
gz_shixie: "士燮",
gz_zhanglu: "张鲁",
wenqin: "文钦",
fengxi: "冯熙",
liuba: "刘巴",
pengyang: "彭羕",
sunchen: "孙綝",
gz_dengzhi: "邓芝",
gzshenwei: "神威",
gzshenwei_info:
"主将技。此武将牌的阴阳鱼个数减0.5。摸牌阶段，若你的手牌数为全场最多，则你令额定摸牌数+2。你的手牌上限+2。",
gzzhuangrong: "妆戎",
gzzhuangrong_info: "出牌阶段限一次。你可弃置一张锦囊牌并获得〖无双〗至出牌阶段结束。",
gzfenglve: "锋略",
gzfenglve_info:
"出牌阶段限一次，你可以和一名其他角色进行拼点。若你赢，其将区域内的两张牌交给你；若你输，你交给其一张牌。",
gzfenglve_zongheng: "锋略·纵横",
gzfenglve_zongheng_info:
"出牌阶段限一次，你可以和一名其他角色进行拼点。若你赢，其将区域内的一张牌交给你；若你输，你交给其两张牌。",
gzanyong: "暗涌",
gzanyong_info:
"每回合限一次。当己方角色对其他角色造成伤害时，你可令伤害值翻倍。然后若受伤角色：武将牌均明置，则你失去1点体力并失去〖暗涌〗；有一张明置的武将牌，则你弃置两张手牌。",
gzzhukou: "逐寇",
gzzhukou_info:
"当你于一名角色的出牌阶段第一次造成伤害后，你可以摸X张牌（X为本回合你已使用的牌数且至多为5）。",
gzduannian: "断念",
gzduannian_info: "出牌阶段结束时，若你有手牌，你可以弃置所有手牌，然后将手牌摸至体力上限。",
gzlianyou: "莲佑",
gzlianyou_info: "你死亡时，可以选择一名其他角色。该角色获得技能“兴火”。",
gzxinghuo: "兴火",
gzxinghuo_info: "锁定技，你造成的火焰伤害+1。",
gzgongxiu: "共修",
gzgongxiu_info:
"摸牌阶段，你可以少摸一张牌，然后选择一个与上次不同的选项：①令至多X名角色各摸一张牌。②令至多X名角色各弃置一张牌。（X为你的体力上限）",
gzjinghe: "经合",
gzjinghe_info:
"出牌阶段限一次，你可以展示至多X张牌名各不相同的手牌（X为你的体力上限），并选择等量有明置武将牌的角色。然后每名角色可以从“写满技能的天书”中选择并获得一个技能直到你的下回合开始。",
gzshilu: "嗜戮",
gzshilu_info:
"①一名角色死亡时，你可以将其所有武将牌置于你的武将牌上，称为“戮”，若杀死其的角色是你，则你从剩余的武将牌堆随机额外获得两张“戮”。②准备阶段，你可以弃置至多X张牌，然后摸等量的牌（X为“戮”数）。",
gzxiongnve: "凶虐",
gzxiongnve_info:
"①出牌阶段开始时，你可以将一张“戮”置入武将牌堆并选择一项：1. 本回合对“戮”对应的势力的角色造成的伤害+1；2. 本回合对“戮”对应的势力的角色造成伤害时，你获得其一张牌；3. 本回合对“戮”对应的势力的角色使用牌无次数限制。②出牌阶段结束时，你可以将两张“戮”置入武将牌堆并获得以下效果直到你的下个回合开始前：当你受到其他角色造成的伤害时,此伤害-1。",
gzjianliang: "简亮",
gzjianliang_info:
"摸牌阶段开始时，若你的手牌数为全场最少，则你可以令所有与你势力相同的角色各摸一张牌。",
gzweimeng: "危盟",
gzweimeng_info:
"出牌阶段限一次，你可以获得一名其他角色的至多X张手牌，然后交给其等量的牌（X为你的体力值）。",
gzweimeng_zongheng: "危盟·纵横",
gzweimeng_zongheng_info: "出牌阶段限一次，你可以获得一名其他角色的一张手牌，然后交给其一张牌。",
gzjuejue: "决绝",
gzjuejue_info:
"①弃牌阶段开始时，你可失去1点体力。然后若你于此阶段内弃置过你的牌，则你令其他角色各选择一项：1.将X张手牌置入弃牌堆（X为你于此阶段内弃置过的牌数）；2.受到你造成的1点伤害。②你杀死与你势力相同的角色不执行奖惩。",
gzfangyuan: "方圆",
gzfangyuan_info:
"阵法技，若你在一个围攻关系中：①是围攻角色，则所有围攻角色的手牌上限+1且被围攻角色手牌上限-1；②是被围攻角色，则结束阶段，你视为对一名围攻角色使用【杀】。",
daming: "达命",
daming_info:
"一名己方角色A的出牌阶段开始时，你可弃置一张锦囊牌，横置一名角色并摸X张牌（X为拥有横置角色的势力数）。然后你选择一项：①令A回复1点体力；②令A视为对由你选择的另一名角色使用一张雷【杀】。",
xiaoni: "嚣逆",
xiaoni_info:
"锁定技，当你使用牌时，或成为其他角色使用牌的目标后，若场上存在其他己方角色且这些角色的手牌数均不大于你，则目标角色/你不可响应此牌。",
gztongduo: "统度",
gztongduo_info: "己方角色的结束阶段，其可以摸X张牌（X为其本回合弃牌阶段弃置的牌数且至多为3）。",
qingyin: "清隐",
qingyin_info: "限定技，出牌阶段，你可令所有己方角色将体力值回满，然后移除此武将牌。",
gzlianpian: "联翩",
gzlianpian_info:
"①结束阶段，若你于此回合内弃置过所有角色的牌数之和大于你的体力值，你可令一名与你势力相同的角色将手牌补至X张（X为其体力上限）。②其他角色的结束阶段，若其于此回合内弃置过所有角色的牌数之和大于你的体力值，其可选择：1.弃置你的一张牌；2.令你回复1点体力。",
gzyusui: "玉碎",
gzyusui_info:
"当你成为其他势力的角色使用黑色牌的目标后，你可以失去1点体力，然后选择一项：①令其弃置X张手牌（X为其体力上限）；②令其失去Y点体力（Y为其的体力值减去你的体力值，不为正时不可选择）。",
gzboyan: "驳言",
gzboyan_info:
"出牌阶段限一次，你可令一名其他角色将手牌摸至体力上限（至多摸五张），然后其本回合不能使用或打出手牌。",
gzboyan_zongheng: "驳言·纵横",
gzboyan_zongheng_info: "出牌阶段限一次，你可令一名其他角色本回合不能使用或打出手牌。",
gzjinfa: "矜伐",
gzjinfa_info:
"出牌阶段限一次，你可弃置一张牌并令一名其他角色选择一项：①交给你一张装备牌，若你以此法得到了♠牌，则其视为对你使用一张【杀】。②你获得其一张牌。",
gzduwu: "黩武",
gzduwu_info:
"限定技，出牌阶段，你可以选择一个“军令”。你令攻击范围内所有的非己方角色选择是否执行。若有角色选择否，则你对其造成1点伤害且你摸一张牌。若有角色于此技能结算过程中进入濒死状态且存活，则你失去1点体力。",
gzxishe: "袭射",
gzxishe_info:
"其他角色的准备阶段，你可将装备区内的一张牌当做【杀】对其使用且可重复此流程。若你的体力值大于该角色，则此【杀】不可被响应。若该角色于此技能的结算流程中死亡，则你可以变更副将（不展示）。",
gzcongcha: "聪察",
gzcongcha2: "聪察",
gzcongcha_info:
"①准备阶段，你可以选择一名未确定势力的其他角色。当其于你的下回合开始前首次明置武将牌后，若其：与你势力相同，则你与其各摸两张牌；与你势力不同，则其失去1点体力。②摸牌阶段开始时，若场上所有角色均有明置的武将牌，则你可以令额定摸牌数+2。",
gzchenglve: "成略",
gzchenglve_info:
"己方角色使用牌结算结束后，若此牌的目标数大于1，则你可以令其摸一张牌。若你受到过渠道为此牌的伤害，则你可以令一名没有国战标记的己方角色获得一枚“阴阳鱼”。",
gzbaolie: "豹烈",
gzbaolie_info:
"锁定技，出牌阶段开始时，你令所有攻击范围内包含你的非己方角色依次选择：①对你使用一张【杀】；②令你弃置其一张牌。锁定技，你对体力值不小于你的角色使用【杀】没有距离和次数限制。",
gzshicai: "恃才",
gzshicai_info: "锁定技，当你受到的伤害后，若伤害值：为1，你摸一张牌；大于1，你弃置两张牌。",
gzxingzhao: "兴棹",
gzxingzhao_info:
"锁定技：①摸牌阶段开始时，若X不小于1，则你可以发动〖恂恂〗的效果。②当你受到伤害后或使用装备牌时，若X不小于2且你的手牌数不为全场最多，则你摸一张牌。③若X不小于3，则你的手牌上限+4。④当你失去装备区的牌后，若X不小于4，则你摸一张牌。（X为场上有受伤角色的势力数）",
gzxingzhao_old_info:
"锁定技：①摸牌阶段开始时，若X不小于1，则你可以发动〖恂恂〗的效果。②当你受到伤害后，若X不小于2且你和伤害来源的手牌数不相等，则你于伤害来源中手牌数较少的角色摸一张牌。③若X不小于3，则你的手牌上限+4。④当你失去装备区的牌后，若X不小于4，则你摸一张牌。（X为场上有受伤角色的势力数）",
qiuan: "求安",
qiuan_info:
"当你受到伤害后，若此伤害的渠道有对应的实体牌且你的武将牌上没有“函”，则你可以防止此伤害并将这些牌置于你的武将牌上，称为“函”。",
liangfan: "量反",
liangfan2: "量反",
liangfan_info:
"锁定技，准备阶段，若你的武将牌上有“函”，则你获得这些牌，然后失去1点体力。当你于此回合内因使用实体牌中包含“函”的牌且执行这些牌的效果而对目标角色造成伤害时，你可以获得目标角色的一张牌。",
gzwenji: "问计",
gzwenji_info:
"出牌阶段开始时，你可令一名其他角色交给你一张牌。然后若该角色：未确定势力或势力与你相同，则你于本回合内使用实体牌包含“问计”牌的牌无距离和次数限制，且不可被其他角色响应。与你势力不同，则你交给其一张不为“问计”牌的牌或令其摸一张牌。",
gztunjiang: "屯江",
gztunjiang_info:
"结束阶段，若你于本回合的出牌阶段内使用过牌且这些牌均未指定其他角色为目标，则你可摸X张牌（X为势力数）。",
gzbushi: "布施",
gzbushi_info:
"当你受到1点伤害后，你可摸一张牌。当你对其他势力的角色造成伤害后，其可摸一张牌，然后你摸一张牌。",
gzbushi_old_info:
"锁定技，当你受到1点伤害后，你令一名与你势力相同的角色摸一张牌；当你对其他角色造成伤害后，你令一名与该角色势力相同的角色摸一张牌。",
gzmidao: "米道",
gzmidao_info:
"与你势力相同的角色的出牌阶段限一次。该角色使用伤害性基本牌或普通锦囊牌指定第一个目标后，其可令你改变此牌的花色和伤害属性。",
gzmidao_old_info:
"与你势力相同的其他角色的出牌阶段限一次。该角色使用伤害性基本牌或普通锦囊牌指定第一个目标后，其可交给你一张手牌，然后你可改变此牌的花色和伤害属性。",
gzbiluan: "避乱",
gzbiluan_info: "锁定技。其他角色计算至你的距离时+X（X为你装备区内的牌数）。",
gzrelixia: "礼下",
gzrelixia_info:
"锁定技。与你势力不同的角色的准备阶段，若你不在其攻击范围内，则其选择一项：①弃置你装备区内的一张牌并失去1点体力。②令你摸一张牌。",
gzlixia: "礼下",
gzlixia_info:
"与你势力不同的角色的准备阶段，其可弃置你装备区内的一张牌，然后其选择一项：①弃置两张手牌。②失去1点体力。③令你摸两张牌。",
gzrekuangcai: "狂才",
gzrekuangcai_info:
"锁定技，你于回合内使用牌无距离和次数限制；弃牌阶段开始时，若你本回合内：未使用过牌，则你本局游戏的手牌上限+1；使用过牌但未造成过伤害，则你本局游戏的手牌上限-1。",
gzkuangcai: "狂才",
gzkuangcai_info:
"锁定技，你的回合内，你使用牌无距离和次数限制，无视防具且不能被【无懈可击】响应；弃牌阶段开始时，若你本回合使用过牌但没造成伤害，本回合你的手牌上限-2；若你本回合造成的伤害点数不小于你使用的牌数，你将手牌摸至体力上限且本回合手牌上限+2。",
gzshejian: "舌箭",
gzshejian_info:
"当你成为其他角色使用牌的唯一目标后，你可以弃置所有手牌。若如此做，你选择一项：⒈弃置其等量的牌。⒉对其造成1点伤害。",
gzzhidao: "雉盗",
gzzhidao2: "雉盗",
gzzhidao_info:
"锁定技，出牌阶段开始时，你选择一名其他角色，然后直到此回合结束，你与其的距离视为1且你不能使用牌指定除你与其外的角色为目标；当你于出牌阶段内首次对其造成伤害后，你获得其区域内的一张牌。",
gzyjili: "寄篱",
gzyjili2: "寄篱",
gzyjili_info:
"锁定技。当你成为红色基本牌或红色普通锦囊牌的唯一目标后，你令此牌的使用者于此牌结算完成后视为对你使用一张牌名和属性相同的牌。当你于一个阶段内第二次受到伤害时，你防止此伤害并移除此武将牌。",
wujing: "吴景",
donggui: "调归",
donggui_info:
"出牌阶段限一次，你可以暗置武将牌均明置的一名其他角色一张武将牌，视为对其使用【调虎离山】，且其本回合不能明置此武将牌。若因此形成队列，你摸X张牌（X为该队列中的角色数）。",
fengyang: "风扬",
fengyang_info: "阵法技，结束阶段，你所在队列的角色可以依次弃置一张装备区里的牌，然后摸两张牌。",
fengyang_old: "风扬",
fengyang_old_info:
"阵法技，与你势力不同的角色不能弃置或获得与你处于同一队列的角色的装备区里的牌。",
dongzhao: "董昭",
quanjin: "劝进",
quanjin_info:
"出牌阶段限一次，你可将一张手牌交给一名本回合内受到过伤害其他角色，然后令其执行一项“军令”。若其执行，则你摸一张牌。若其不执行，则你将手牌摸至与全场最多相等（至多摸五张）。",
zaoyun: "凿运",
zaoyun_info:
"出牌阶段限一次，你可以弃置X张手牌并选择一名距离为X+1的敌方角色。你对其造成1点伤害且至其的距离视为1至回合结束。",
gzdeshao: "德劭",
gzdeshao_info:
"每回合限X次（X为你的体力值）。其他角色使用黑色牌指定你为唯一目标后，若其暗置的武将牌数大于等于你，则你可以弃置其一张牌。",
gzmingfa: "明伐",
gzmingfa_info:
"出牌阶段限一次，你可以选择一名敌方角色。该角色的下个回合结束时，若其手牌数：小于你，你对其造成1点伤害并获得其一张手牌；大于你，你摸X张牌（X为你与其的手牌数之差且至多为5）。",
gzjilei_info:
"当你受到有来源的伤害后，你可以声明一种牌的类别。若如此做，你令伤害来源不能使用、打出或弃置此类别的手牌直到回合结束。",
gzdanlao_info:
"当你成为普通锦囊牌的目标后，若此牌的目标数大于1，则你可以摸一张牌，令此牌对你无效。",
gz_cuimao: "崔琰毛玠",
gzzhengbi: "征辟",
gzzhengbi_info:
"出牌阶段开始时，你可以选择一项：选择一名未确定势力的角色，此出牌阶段结束时，若其有明置的武将牌，则你获得其每个区域内的各一张牌；或将一张基本牌交给一名有明置武将牌的角色，然后其交给你一张非基本牌或两张基本牌。",
gzfengying: "奉迎",
gzfengying_info:
"限定技，你可以将所有手牌当【挟天子以令诸侯】使用（无视大势力限制），然后所有与你势力相同的角色将手牌补至体力上限。",
gz_yujin: "于禁",
gzjieyue: "节钺",
gzjieyue_info:
"准备阶段，你可以将一张手牌交给一名非魏势力角色，然后选择一个“军令”并令其选择一项：执行该军令，然后你摸一张牌；或令你于此回合摸牌阶段额外摸三张牌。",
gz_wangping: "王平",
jianglue: "将略",
jianglue_info:
"限定技，出牌阶段，你可以选择一个“军令”，然后与你势力相同的其他角色可以执行该军令（未确定势力角色可以在此时明置一张单势力武将牌）。你与所有执行该军令的角色增加1点体力上限，然后回复1点体力，然后你摸X张牌（X为以此法回复了体力的角色数）。",
gz_fazheng: "法正",
gzxuanhuo: "眩惑",
gzxuanhuo_info:
"与你势力相同的其他角色的出牌阶段限一次，其可弃置一张手牌，然后选择获得以下一项技能直到回合结束：〖武圣〗、〖咆哮〗、〖龙胆〗、〖铁骑〗、〖烈弓〗、〖狂骨〗。",
gzenyuan: "恩怨",
gzenyuan_info:
"锁定技，当其他角色对你使用【桃】时，该角色摸一张牌；当你受到伤害后，伤害来源须交给你一张手牌或失去1点体力。",
gzbuyi: "补益",
gzbuyi_info:
"每回合限一次，当一名与你势力相同的角色脱离濒死状态后，你可以选择一个“军令”，令伤害来源选择一项：执行该军令，或令该脱离濒死状态的角色回复1点体力。",
gz_lukang: "陆抗",
keshou: "恪守",
keshou_info:
"当你受到伤害时，你发动此技能。你可弃置两张颜色相同的牌，若如此做，此伤害-1。你的势力已确定且场上没有与你势力相同的其他角色，则你进行判定，若结果为红色，你摸一张牌。",
zhuwei: "筑围",
zhuwei_info:
"当你的判定牌生效后，你可以获得之。然后，你可令当前回合角色本回合内使用【杀】的次数上限和手牌上限+1。",
gz_yuanshu: "袁术",
gzweidi: "伪帝",
gzweidi_info:
"出牌阶段限一次，你可以指定一名本回合从牌堆得到过牌的其他角色并选择一个“军令”，令其选择一项：执行该军令；或令你获得其所有手牌，然后交给其等量的牌。",
gzyongsi: "庸肆",
gzyongsi_info:
"锁定技，若场上没有【玉玺】，则视为你装备了【玉玺】；当你成为【知己知彼】的目标时，你展示你的所有手牌。",
//gzyongsi_eff1:'玉玺',
//gzyongsi_eff2:'玉玺',
gz_zhangxiu: "张绣",
gzfudi: "附敌",
gzfudi_info:
"当你受到伤害后，你可以交给伤害来源一张手牌。若如此做，你对其势力中体力值最大且不小于你的一名角色造成1点伤害。",
gzcongjian: "从谏",
gzcongjian_info: "锁定技，当你于回合外造成伤害，或于回合内受到伤害时，此伤害+1。",
gz_jun_caocao: "君曹操",
gz_jun_caocao_prefix: "君",
jianan: "建安",
jianan_info: "君主技，只要此武将处于明置状态，你便拥有“五子良将纛”。",
g_jianan: "五子良将纛",
wuziliangjiangdao: "五子良将纛",
wuziliangjiangdao_ab: "将纛",
wuziliangjiangdao_bg: "纛",
wuziliangjiangdao_info:
"魏势力角色的准备阶段，其可以弃置一张牌。若如此做，其选择一张暗置的武将牌（若没有，则选择一张暗置），然后获得下列技能中的一项（其他角色已有的技能无法选择）且不能明置选择的武将牌直到你的下个回合开始：〖突袭〗，〖巧变〗，〖骁果〗，〖节钺〗，〖断粮〗。",
huibian: "挥鞭",
huibian_info:
"出牌阶段限一次，你可以选择一名魏势力角色和另一名已受伤的魏势力角色。若如此做，你对前者造成1点伤害，然后其摸两张牌，然后后者回复1点体力。",
gzzongyu: "总御",
gzzongyu_info:
"当【六龙骖驾】进入其他角色的装备区后，你可以将你装备区内所有坐骑牌（至少一张）与【六龙骖驾】交换位置。锁定技，当你使用坐骑牌后，若场上或弃牌堆中有【六龙骖驾】，则将【六龙骖驾】置入你的装备区。",
yigui: "役鬼",
yigui_info:
"当你首次明置此武将牌时，你将剩余武将牌堆的两张牌置于武将牌上，称为“魂”；你可以展示一张武将牌上的“魂”并将其置入剩余武将牌堆，视为使用一张本回合内未以此法使用过的基本牌或普通锦囊牌。（此牌须指定目标，且目标须为未确定势力的角色或野心家或与此“魂”势力相同的角色）",
yigui_init: "役鬼",
yigui_init_info: "",
yigui_refrain: "役鬼",
yigui_refrain_info: "",
yigui_shan: "役鬼",
yigui_wuxie: "役鬼",
yigui_gzshan: "役鬼",
yigui_gzwuxie: "役鬼",
jihun: "汲魂",
jihun_info:
"当你受到伤害后，或与你势力不同的角色脱离濒死状态后，你可以将剩余武将牌堆的一张牌置于武将牌上，称为“魂”。",
_guozhan_marks: "标记",
_guozhan_marks_backup: "标记",
xianqu_mark: "先驱",
zhulianbihe_mark: "珠联璧合",
yinyang_mark: "阴阳鱼",
_zhulianbihe_mark_tao: "珠联",
_yinyang_mark_add: "阴阳鱼",
yinyang_add: "阴阳鱼",
gzjushou: "据守",
gzjushou_info:
"结束阶段，你可以摸X张牌（X为亮明势力数），然后弃置一张手牌。若以此法弃置的牌为装备牌，则改为使用此牌。若X大于2，则你将武将牌叠置。",
new_duanliang: "断粮",
new_duanliang_info:
"出牌阶段，你可以将一张黑色基本牌或黑色装备牌当做【兵粮寸断】使用。你使用【兵粮寸断】没有距离限制。若你对距离超过2的角色发动了〖断粮〗，则本回合不能再发动〖断粮〗。",
new_shushen: "淑慎",
new_shushen_info: "当你回复1点体力后，你可令一名其他角色摸一张牌。",
new_luanji: "乱击",
new_luanji_info:
"你可以将两张与你本回合以此法转化的花色均不相同的手牌当【万箭齐发】使用。当一名与你势力相同的角色因响应此牌而打出【闪】时，该角色摸一张牌。",
new_qingcheng: "倾城",
new_qingcheng_info:
"出牌阶段，你可以弃置一张黑色牌并选择一名武将牌均明置的其他角色，然后你暗置其一张武将牌。若你以此法弃置的牌为装备牌，则你可以暗置另一名武将牌均明置的角色的一张武将牌。",
huoshui: "祸水",
huoshui_info:
"锁定技。你的回合内，①其他角色不能明置武将牌。②当你使用【杀】或【万箭齐发】指定目标后，若目标角色与你势力不同且有暗置武将牌，则其不能使用或出【闪】直到此牌结算结束。",
new_kongcheng: "空城",
new_kongcheng_info:
"锁定技，若你没有手牌，1.当你成为【杀】或【决斗】的目标时，取消之；2.你的回合外，其他角色交给你牌后，你将这些牌置于你的武将牌上。摸牌阶段开始时，你获得武将牌上的这些牌。",
new_keji: "克己",
new_keji_info: "锁定技，若你没有在出牌阶段内使用过颜色不同的牌，则你本回合的手牌上限+4。",
keji_add: "克己",
keji_add_info: "",
new_mouduan: "谋断",
new_mouduan_info:
"结束阶段，若你于本回合内使用过四种花色或三种类别的牌，则你可以移动场上的一张牌。",
new_longdan: "龙胆",
new_longdan_info:
"你可以将【杀】当【闪】，【闪】当【杀】使用或打出。当你发动〖龙胆〗使用的【杀】被【闪】抵消时，你可以对另一名角色造成1点伤害；当你发动〖龙胆〗使用的【闪】抵消了【杀】时，你可以令一名其他角色回复1点体力（不能是【杀】的使用者）。",
fz_new_longdan: "龙胆",
fz_new_longdan_info:
"你可以将【杀】当【闪】，【闪】当【杀】使用或打出。当你发动〖龙胆〗使用的【杀】被【闪】抵消时，你可以对另一名角色造成1点伤害；当你发动〖龙胆〗使用的【闪】抵消了【杀】时，你可以令一名其他角色回复1点体力（不能是【杀】的使用者）。",
gzpaoxiao: "咆哮",
gzpaoxiao_info: "锁定技，你使用【杀】无数量限制；当你于一回合内使用第二张【杀】时，摸一张牌。",
new_kurou: "苦肉",
new_kurou_info:
"出牌阶段限一次，你可以弃置一张牌，然后失去1点体力并摸三张牌，本回合使用【杀】的次数上限+1。",
kurou_effect: "苦肉",
kurou_effect_info: "",
new_chuli: "除疠",
new_chuli_info:
"出牌阶段限一次，若你有牌，你可以选择至多三名势力各不相同或未确定势力的其他角色，你弃置你和这些角色的各一张牌。然后所有以此法弃置过黑桃牌的角色各摸一张牌。",
baka_hunshang: "魂殇",
baka_hunshang_info:
"副将技，此武将牌减少半个阴阳鱼；准备阶段，若你的体力值不大于1，则你获得〖英姿〗和〖英魂〗直到回合结束。",
baka_yinghun: "英魂",
baka_yinghun_info:
"准备阶段，你可令一名其他角色执行一项：摸X张牌，然后弃置一张牌；或摸一张牌，然后弃置X张牌（X为你已损失的体力值）。",
baka_yingzi: "英姿",
baka_yingzi_info: "锁定技，摸牌阶段摸，你多摸一张牌；你的手牌上限+X（X为你已损失的体力值）。",
gzyiji: "遗计",
gzyiji_info: "当你受到伤害后，你可以观看牌堆顶的两张牌，并将其交给任意角色。",
gzjieming: "节命",
gzjieming_info: "当你受到伤害后，你可以令一名角色将手牌摸至X张（X为其体力上限且最多为5）。",
gzfangzhu: "放逐",
gzfangzhu_info:
"当你受到伤害后，你可以令一名其他角色选择一项：⒈摸X张牌并将武将牌叠置；⒉弃置X张牌并失去1点体力（X为你已损失的体力值）。",
fengyin_main: "封印[主将]",
fengyin_main_info: "",
fengyin_vice: "封印[副将]",
fengyin_vice_info: "",
new_tieji: "铁骑",
new_tieji_info:
"当你使用【杀】指定目标后，你可以令其一张明置的武将牌上的非锁定技于本回合内失效，然后你进行判定，除非该角色弃置与结果花色相同的一张牌，否则其不能使用【闪】响应此【杀】。",
hmkyuanyu: "远域",
hmkyuanyu_info: "锁定技，当你受到伤害时，若伤害来源与你的座次不相邻，防止此伤害。",
hmkguishu: "鬼术",
hmkguishu_info:
"出牌阶段，你可以将一张黑桃手牌当作【知己知彼】或【远交近攻】使用。若你本局游戏内已经发动过了〖鬼术〗，则你必须选择与上次不同的选项。",
_mingzhisuodingji: "亮将",
_mingzhisuodingji_info: "出牌阶段，你可以明置拥有“锁定技”的武将牌。",
gz_jun_liubei: "君刘备",
gz_jun_liubei_prefix: "君",
gz_jun_zhangjiao: "君张角",
gz_jun_zhangjiao_prefix: "君",
gz_jun_sunquan: "君孙权",
gz_jun_sunquan_prefix: "君",
gz_liqueguosi: "李傕郭汜",
gz_bianfuren: "卞夫人",
gz_lvfan: "吕范",
gz_shamoke: "沙摩柯",
gz_masu: "马谡",
gz_yuji: "于吉",
gzshushen: "淑慎",
gzshushen_info: "当你回复1点体力时，你可令与你势力相同的一名其他角色摸一张牌。",
_lianheng: "合纵",
lianheng_tag: "合纵",
guo_tag: "国",
qianhuan: "千幻",
qianhuan_bg: "幻",
qianhuan_info:
"当与你势力相同的一名角色受到伤害后，你可以将一张与你武将牌上花色均不同的牌置于你的武将牌上。当一名与你势力相同的角色成为基本牌或锦囊牌的唯一目标时，你可以移去一张“千幻”牌，取消之。",
gzsanyao_info: "出牌阶段限一次。你可以弃置一张牌，对一名手牌数或体力值大于你的角色造成1点伤害。",
gzzhiman: "制蛮",
gzzhiman_info:
"当你对其他角色造成伤害时，你可以防止此伤害。若如此做，你获得其装备区或判定区里的一张牌。然后若该角色与你势力相同，该角色可以变更副将。",
gzdiancai: "典财",
gzdiancai_info:
"其他角色的出牌阶段结束时，若你于此阶段失去了x张或更多的牌，则你可以将手牌摸至体力上限。若如此做，你可以变更副将（x为你的体力值）。",
xuanlve: "旋略",
xuanlve_info: "当你失去装备区里的牌后，你可以弃置一名其他角色的一张牌。",
lianzi: "敛资",
lianzi_info:
"出牌阶段限一次，你可以弃置一张手牌，然后亮出牌堆顶X张牌（X为吴势力角色装备区里的牌和“烽火”的总和），获得其中所有与你弃置牌类别相同的牌，将其余的牌置入弃牌堆，若你以此法一次获得了三张或更多的牌，则你失去技能〖敛资〗并获得技能〖制衡〗。",
gzqice: "奇策",
gzqice_backup: "奇策",
gzqice_info:
"出牌阶段限一次，你可以将所有手牌当做任意一张普通锦囊牌使用（此牌的目标数不能超过你的手牌数）。然后，你可以变更副将。",
gzyuejian: "约俭",
gzyuejian_info:
"锁定技，与你势力相同角色的弃牌阶段开始时，若其本回合未使用牌指定过其他势力的角色为目标，则该角色本回合手牌上限+X（X为其已损失的体力值）。",
gzxiongsuan: "凶算",
gzxiongsuan_info:
"限定技，出牌阶段，你可以弃置一张手牌并选择与你势力相同的一名角色，对其造成1点伤害，然后你摸三张牌。若该角色有已发动的限定技，则你选择其中一个限定技，此回合结束后视为该限定技未发动过。",
gzhuashen: "化身",
gzhuashen_info:
"准备阶段，若你的“化身”不足两张，则你可以观看剩余武将牌堆中的五张牌，然后扣置其中至多两张武将牌在你的武将旁，称为“化身”；若“化身”有两张以上，则你可以用剩余武将牌堆顶的一张牌替换一张“化身”。你可以于相应的时机明置并发动“化身”的一个技能，技能结算完成后将该“化身”放回剩余武将牌堆。你每个时机只能发动一张“化身”的技能，且不能发动带有技能类型的技能（锁定技、限定技等）。",
gzxinsheng: "新生",
gzxinsheng_info: "当你受到伤害后，你可以从剩余武将牌堆中扣置一张牌加入到“化身”牌中。",
jubao: "聚宝",
jubao_info:
"锁定技，你装备区里的宝物牌不能被其他角色获得。结束阶段，若场上或弃牌堆有【定澜夜明珠】，则你摸一张牌，然后获得装备区里有【定澜夜明珠】角色的一张牌。",
jiahe: "嘉禾",
jiahe_info: "君主技，只要此武将牌处于明置状态，你便拥有“缘江烽火图”。",
jiahe_put: "烽火",
jiahe_put_info: "出牌阶段限一次，你可以将一张装备牌置于“缘江烽火图”上，称之为“烽火”。",
jiahe_skill: "缘江烽火图",
yuanjiangfenghuotu: "缘江烽火图",
yuanjiangfenghuotu_info:
"每名吴势力角色的出牌阶段限一次，该角色可以将一张装备牌置于“缘江烽火图”上，称之为“烽火”。
根据“烽火”的数量，所有吴势力角色可于其准备阶段选择并获得其中一个技能直到回合结束：一张以上：〖英姿〗；两张以上：〖好施〗；三张以上：〖涉猎〗；四张以上：〖度势〗；五张以上：可额外选择一项。
锁定技，当你受到【杀】或锦囊牌造成的伤害后，你将一张“烽火”置入弃牌堆。",
yuanjiangfenghuotu_ab: "江图",
yuanjiangfenghuotu_bg: "图",
wuxin: "悟心",
wuxin_info:
"摸牌阶段开始时，你可以观看牌堆顶的X张牌（X为群势力角色的数量），然后将这些牌以任意顺序置于牌堆顶。",
hongfa: "弘法",
hongfa_use: "天兵",
hongfa_respond: "天兵",
hongfa_info:
"君主技，锁定技，此武将牌明置时，你获得“黄巾天兵符”；准备阶段，若没有“天兵”，你将牌堆顶的X张牌置于“黄巾天兵符”上，称为“天兵”（X为群势力角色的数量）。",
wendao: "问道",
wendao_info:
"出牌阶段限一次，你可以弃置一张不为【太平要术】的红色牌，然后获得弃牌堆或场上的一张【太平要术】。",
huangjintianbingfu: "黄巾天兵符",
huangjintianbingfu_ab: "兵符",
huangjintianbingfu_bg: "符",
huangjintianbingfu_info:
"锁定技，当你计算群势力角色数时，每一张“天兵”均可视为一名群势力角色。
当你失去体力时，你可改为将一张“天兵”置入弃牌堆。
与你势力相同的角色可将一张“天兵”当作【杀】使用或打出。",
wuhujiangdaqi: "五虎将大旗",
wuhujiangdaqi_ab: "将旗",
wuhujiangdaqi_bg: "旗",
wuhujiangdaqi_info:
"存活的蜀势力角色的技能按以下规则改动：
武圣：将“红色牌”改为“任意牌”
咆哮：增加描述“你使用的【杀】无视其他角色的防具”
龙胆：增加描述“你发动〖龙胆〗使用或打出牌时摸一张牌”
烈弓：增加描述“你的攻击范围+1”
铁骑：将“一张明置的武将牌”改为“所有明置的武将牌”",
zhangwu: "章武",
zhangwu_info:
"锁定技。当【飞龙夺凤】进入弃牌堆或其他角色的装备区后，你获得之。当你不因使用而失去【飞龙夺风】时，你展示此牌，将此牌置于牌堆底并摸两张牌。",
shouyue: "授钺",
shouyue_info: "君主技。只要此武将牌处于明置状态，你便拥有“五虎将大旗”。",
jizhao: "激诏",
jizhao_bg: "诏",
jizhao_info:
"限定技。当你处于濒死状态时，你可以将手牌补至体力上限，体力回复至2点，失去技能〖授钺〗并获得技能〖仁德〗。",
gzshoucheng: "守成",
gzshoucheng_info:
"当与你势力相同的一名角色于其回合外失去手牌时，若其没有手牌，则你可以令其摸一张牌。",
gzmingshi: "名士",
gzmingshi_info: "锁定技，当你受到伤害时，若伤害来源有暗置的武将牌，此伤害-1。",
fengshi: "锋矢",
fengshi_sha: "锋矢",
fengshi_info:
"阵法技，在一个围攻关系中，若你是围攻角色，则你或另一名围攻角色使用【杀】指定被围攻角色为目标后，可令该角色弃置装备区内的一张牌。",
gzsuishi: "随势",
gzsuishi2: "随势",
gzsuishi_info:
"锁定技，其他角色进入濒死状态时，若伤害来源与你势力相同，你摸一张牌；其他角色死亡时，若其与你势力相同，你失去1点体力。",
baoling: "暴凌",
baoling_info:
"主将技，锁定技，出牌阶段结束时，若你有副将，则你移除副将，然后加3点体力上限，回复3点体力，失去技能〖暴凌〗并获得〖崩坏〗。",
yingyang: "鹰扬",
yingyang_info: "当你的拼点牌亮出后，你可以令此牌的点数+3或-3（至多为K，至少为1）。",
hunshang: "魂殇",
hunshang_info:
"副将技，此武将牌减少半个阴阳鱼；准备阶段，若你的体力值不大于1，则你本回合获得“英姿”和“英魂”。",
gzguixiu: "闺秀",
gzguixiu_info: "当你明置此武将牌时，你可以摸两张牌；当你移除此武将牌时，你可以回复1点体力。",
gzcunsi: "存嗣",
gzcunsi_info:
"出牌阶段，你可以移除此武将牌并选择一名角色，然后其获得技能〖勇决〗，若你选择的目标角色不是自己，则其摸两张牌。",
gzyongjue: "勇决",
gzyongjue_info:
"与你势力相同的一名角色于其回合内使用【杀】结算完成后，若此牌是其本回合内使用的第一张牌，则其可以获得此牌对应的所有实体牌。",
gzqianxi: "潜袭",
gzqianxi_info:
"准备阶段，你可以进行判定，然后你选择距离为1的一名角色，直到回合结束，该角色不能使用或打出与结果颜色相同的手牌。",
gzshangyi: "尚义",
gzshangyi_info:
"出牌阶段限一次，你可以令一名其他角色观看你的手牌。若如此做，你选择一项：1.观看其手牌并可以弃置其中的一张黑色牌；2.观看其所有暗置的武将牌。",
niaoxiang: "鸟翔",
niaoxiang_sha: "鸟翔",
niaoxiang_info:
"阵法技，在同一个围攻关系中，若你是围攻角色，则你或另一名围攻角色使用【杀】指定被围攻角色为目标后，该角色需依次使用两张【闪】才能抵消。",
yicheng: "疑城",
yicheng_info:
"当与你势力相同的一名角色成为【杀】的目标后，你可以令该角色摸一张牌，然后弃置一张牌。",
gzyicheng: "疑城",
gzyicheng_info:
"阵法技。当你和你队列中的角色使用【杀】指定第一个目标后，或成为【杀】的目标后，其可以摸一张牌，然后弃置一张牌。",
yizhi: "遗志",
yizhi_info:
"副将技，此武将牌减少半个阴阳鱼。若你的主将拥有技能〖观星〗，则将其描述中的X改为5；若你的主将没有技能〖观星〗，则你视为拥有技能〖观星〗。",
tianfu: "天覆",
tianfu_info: "主将技，阵法技，若当前回合角色与你处于同一队列，则你视为拥有技能〖看破〗。",
ziliang: "资粮",
ziliang_info: "副将技，当与你势力相同的一名角色受到伤害后，你可以将一张“田”交给该角色。",
gzjixi: "急袭",
gzjixi_info: "主将技，此武将牌减少半个阴阳鱼。你可以将一张“田”当作【顺手牵羊】使用。",
huyuan: "护援",
huyuan_info:
"结束阶段，你可以将一张装备牌置入一名角色的装备区，然后你可以弃置该角色距离为1的一名角色的一张牌。",
heyi: "鹤翼",
heyi_info: "阵法技。与你处于同一队列的角色视为拥有技能〖飞影〗。",
gzhuyuan: "护援",
gzhuyuan_info:
"结束阶段，你可以选择一项：⒈将一张非装备牌交给一名其他角色。⒉将一张装备牌置入其他角色的装备区内，然后你可以弃置场上的一张牌。",
gz_shibing1wei: "魏兵",
gz_shibing2wei: "魏兵",
gz_shibing1shu: "蜀兵",
gz_shibing2shu: "蜀兵",
gz_shibing1wu: "吴兵",
gz_shibing2wu: "吴兵",
gz_shibing1qun: "群兵",
gz_shibing2qun: "群兵",
gz_shibing1jin: "晋兵",
gz_shibing2jin: "晋兵",
gz_shibing1ye: "士兵",
gz_shibing2ye: "士兵",
gz_shibing1key: "键兵",
gz_shibing2key: "键兵",
gzduanchang: "断肠",
gzduanchang_info: "锁定技，当你死亡时，你令杀死你的角色失去一张武将牌上的所有技能。",
gzweimu: "帷幕",
gzweimu_info:
"锁定技，当你成为黑色普通锦囊牌的目标时，或有黑色延时锦囊牌进入你的判定区时，取消之。",
gzqianxun: "谦逊",
gzqianxun_info:
"锁定技，当你成为【顺手牵羊】的目标时，或有【乐不思蜀】进入你的判定区时，取消之。",
gzkongcheng: "空城",
gzkongcheng_info: "锁定技，当你成为【杀】或【决斗】的目标时，若你没有手牌，则取消之。",
gzxiaoji: "枭姬",
gzxiaoji_info: "当你失去装备区里的牌后，你可以摸一张牌。若你不是当前回合角色，则你改为摸三张牌。",
gzrende: "仁德",
gzrende_info:
"出牌阶段，你可以将任意张手牌交给其他角色，然后若你于此阶段内给出第三张“仁德”牌时，你回复1点体力。",
gzzhiheng: "制衡",
gzzhiheng_info: "出牌阶段限一次，你可以弃置至多X张牌（X为你的体力上限），然后摸等量的牌。",
duoshi: "度势",
duoshi_info: "出牌阶段限四次，你可以将一张红色手牌当做【以逸待劳】使用。",
gzxiaoguo: "骁果",
gzxiaoguo_info:
"其他角色的结束阶段，你可以弃置一张基本牌，令该角色选择一项：1.弃置一张装备牌；2.受到你对其造成的1点伤害。",
gzdangxian: "当先",
gzdangxian_info:
"锁定技。当你首次明置此武将牌时，你获得一枚“先驱”标记。回合开始时，你获得一个额外的出牌阶段。",
gzhuanshi: "缓释",
gzhuanshi_info: "一名己方角色的判定牌生效前，你可打出一张牌代替之。",
gzhongyuan: "弘援",
gzhongyuan_info:
"①出牌阶段限一次。你可以令一张没有「合纵」标签的卡牌视为拥有「合纵」标签直到本回合结束。②当你即将因合纵效果摸牌时，你可放弃摸牌，并令一名己方角色摸等量的牌。",
gzmingzhe: "明哲",
gzmingzhe_info:
"你的回合外，当你使用或打出红色手牌，或失去装备区内的红色装备牌时，你可摸一张牌。",
gzxiongzhi: "雄志",
gzxiongzhi_info: "限定技。出牌阶段，你可依次展示牌堆顶的X张牌并使用之（X为你的体力上限）。",
gzquanbian: "权变",
gzquanbian_info:
"当你于出牌阶段内使用/打出手牌时，若此牌有花色且你本回合内未使用/打出过该花色的其他手牌，则你可以观看牌堆顶X张牌，选择获得其中的一张并展示之。若你本回合使用过与得到的牌花色相同的牌，则你本回合内不能再发动〖权变〗。",
gzhuishi: "慧识",
gzhuishi_info:
"摸牌阶段，你可以放弃摸牌，改为观看牌堆顶的X张牌，获得其中的一半（向下取整），然后将其余牌置入牌堆底。（X为弃牌堆顶的两张牌的名称字数之和）",
gzqingleng: "清冷",
gzqingleng_info:
"一名角色的回合结束时，若其有未明置的武将牌，则你可将一张牌当无距离限制的冰属性【杀】对其使用；若其所有武将牌均未明置，则你摸一张牌。",
gzchoufa: "筹伐",
gzchoufa_info:
"出牌阶段限一次，你可展示一名其他角色的一张手牌A。你令其所有类型与A不同的手牌的牌名均视为【杀】且均视为无属性直到本回合结束。",
gzbolan: "博览",
gzbolan_info:
"每名角色的出牌阶段限一次。其可以随机展示武将牌堆顶的一张武将牌，然后根据此武将牌包含的势力选择获得一个技能直到回合结束：魏:〖奇策〗；蜀:〖挑衅〗；吴:〖制衡〗；群:〖除疠〗；晋:〖三陈〗。若该角色不为你，则其失去1点体力。",
gzsanchen: "三陈",
gzsanchen_info:
"出牌阶段，你可选择一名本回合内未选择过的角色。其摸三张牌，然后弃置三张牌。若其未以此法弃置牌或以此法弃置的牌的类别均不相同，则你于本回合获得一枚“陈”且其摸一张牌；否则你本阶段内不能再发动〖三陈〗。",
gzpozhu: "破竹",
gzpozhu_info:
"主将技。此武将牌减少半个阴阳鱼。出牌阶段，你可以移去一枚“陈”并将一张手牌当做【出其不意】使用。",
gzyimie: "夷灭",
gzyimie_info:
"主将技，此武将牌减少一整个阴阳鱼。每回合限一次，当你对其他角色造成伤害时，若伤害值X小于Y，则你可失去1点体力，将伤害值改为Y。此伤害结算结束后，其回复(Y-X)点体力。（Y为其体力值）",
gztairan: "泰然",
gztairan_info:
"出牌阶段开始时，你可以失去任意点体力并弃置任意张牌（弃牌数不能大于你已损失的体力值）。若如此做，本回合结束时，你回复等量的体力并摸等量的牌。",
gzxuanbei: "选备",
gzxuanbei_info:
"①当你首次明置此武将牌时，你获得两张拥有“应变”或“合纵”标签的牌（不足则摸牌），且你本回合内使用带有“应变”标签的牌时直接强化，使用带有“合纵”标签的牌时摸一张牌。②当你死亡时，你可以令一名其他角色变更副将。",
gzzhaosong: "诏颂",
gzzhaosong_info:
"每局游戏每项限一次。①一名角色进入濒死状态时，你可以令其回复至2点体力并摸一张牌。②出牌阶段，你可观看一名其他角色的所有暗置武将牌和手牌，然后可以获得其区域内的一张牌。③一名角色使用【杀】选择唯一目标后，你可以为此【杀】增加两个目标。",
gzlisi: "离思",
gzlisi_info: "一名己方角色死亡后，你可以选择〖诏颂〗中的一个已发动过的选项，令其视为未发动过。",
gzcaiyuan: "才媛",
gzcaiyuan_info:
"锁定技。结束阶段，若你的手牌数大于本回合开始时的手牌数，则你摸两张牌或回复1点体力。",
gzwanyi: "婉嫕",
gzwanyi_info:
"出牌阶段每项各限一次。你可以将一张带有“合纵”标签的牌当做【联军盛宴】/【火烧连营】/【挟天子以令诸侯】/【戮力同心】使用。",
gzwanyi_info_guozhan_yingbian:
"出牌阶段每项各限一次。你可以将一张带有“应变”标签的牌当做【逐近弃远】/【洞烛先机】/【水淹七军】/【出其不意】使用。",
gzmaihuo: "埋祸",
gzmaihuo_info:
"限定技。当有己方角色成为【杀】的目标时，你可以取消此【杀】的所有目标。然后此【杀】的使用者下回合开始时，其视为对你使用一张【杀】。若此【杀】对你造成伤害，则你防止此伤害，摸两张牌并移除此武将牌（若此武将牌为副将则改为变更副将）。",
gzzhenxi: "震袭",
gzzhenxi_info:
"当你使用【杀】指定目标后，你可以选择一项：1.弃置目标角色一张牌；2.将一张♦非锦囊牌当做【乐不思蜀】或♣非锦囊牌当做【兵粮寸断】对目标角色使用；3.背水：若其有暗置的武将牌且你的武将牌均明置，则你可以依次执行这两项。",
gzjiansu: "俭素",
gzjiansu_tag: "俭",
gzjiansu_info:
"副将技。此武将牌减少半个阴阳鱼。①当你于回合外得到牌后，你可以展示这些牌，称为“俭”。②出牌阶段开始时，你可以弃置任意张“俭”，令一名体力值不大于X的角色回复1点体力（X为你以此法弃置的牌数）。",
gzzhuidu: "追妒",
gzzhuidu_info:
"出牌阶段限一次。当你造成伤害时，你可以令受伤角色选择一项：1.此伤害+1；2.弃置装备区里的所有牌。若该角色为女性，则你可以弃置一张牌，改为令其选择两项。",
gzshigong: "示恭",
gzshigong_info:
"限定技。当你于回合外进入濒死状态时，你可以移除副将，然后令当前回合角色选择一项：1.获得你以此法移除的副将武将牌上的一个没有技能标签的技能，然后令你将体力值回复至体力上限；2.令你将体力值回复至1点。",
gz_old_huaxiong: "华雄",
gzyaowu: "耀武",
gzyaowu_info:
"限定技。当你造成伤害后，你可以明置此武将牌，然后你加2点体力上限并回复2点体力，修改〖恃勇〗，且当你死亡后，所有与你势力相同的角色失去1点体力。",
gzshiyong: "恃勇",
gzshiyong_info: "锁定技。当你受到牌造成的伤害后，若此牌不为红色，你摸一张牌。",
gzshiyongx: "恃勇·改",
gzshiyongx_info: "锁定技。当你受到牌造成的伤害后，若此牌不为黑色，伤害来源摸一张牌。",
gztanfeng: "探锋",
gztanfeng_info:
"准备阶段，你可以弃置与你势力不同的一名角色区域内的一张牌，然后其可以令你对其造成1点火焰伤害，并令你跳过本回合的一个阶段（准备阶段和结束阶段除外）。",
//官盗「群雄割据」
gzduanshi: "断势",
gzduanshi_info:
"主将技，锁定技。此武将牌减少半个阴阳鱼。当一名角色因杀死与你势力相同的角色而摸牌时，其少摸一张牌。然后你摸一张牌。",
gzjingce: "精策",
gzjingce_info:
"回合结束时，若于本回合内进入弃牌堆的牌数不小于X，你可以执行一个额外的摸牌阶段；若你本回合使用过的牌数不小于X，你可以执行一个额外的出牌阶段（X为你的体力值）。",
gzzhengrong: "征荣",
gzzhengrong_info:
"锁定技。①你至大势力角色的距离-1。②当你选择“军令”时，你令可选军令数量+1。③当你造成或受到伤害时，若你没有存活的队友，则此伤害+1。",
gzhongju: "鸿举",
gzhongju_info:
"限定技。出牌阶段，你可以选择一名其他角色A并选择一个“军令”。你执行该军令，然后令除A以外的所有其他角色依次选择一项：⒈执行该军令。⒉于本回合视为移出游戏。",
gzbiaozhao: "表召",
gzbiaozhao_info:
"出牌阶段限一次。你可以选择两名势力不同的其他角色A和B。你视为对A使用一张【知己知彼】，然后将一张牌交给B并摸一张牌。",
gzyechou: "业仇",
gzyechou_info:
"锁定技。当你死亡时，你视为对杀死你的角色依次使用三张【杀】，其中第一张不可被响应，第二张无视防具，第三张对其造成的伤害+1。若其以此法进入濒死状态，则于本次濒死结算中除其外与其势力相同的角色不能对其使用【桃】。",
//官盗「十年经典」
gzdianhu: "点虎",
gzdianhu_info:
"锁定技。当你首次明置此武将牌时，你选择一名其他角色。与你势力相同的角色对其造成伤害后，伤害来源摸一张牌。",
gzjianji: "谏计",
gzjianji_info: "出牌阶段限一次。你可以令一名角色摸一张牌并展示之，然后其可以使用此牌。",
gzgongjian: "攻坚",
gzgongjian_info:
"①当其他角色的牌因弃置而进入弃牌堆后，若令其弃置这些牌的角色为你，你获得其中所有的【杀】。②每回合限一次，当一名角色使用【杀】指定目标后，若有目标与本局游戏上一张被使用的【杀】相同，你可以令这些目标弃置两张牌。",
gzkuimang: "溃蟒",
gzkuimang_info: "锁定技。当你杀死与你势力不同且处于队列的角色时，你摸两张牌。",
gzyinpan: "引叛",
gzyinpan_info:
"出牌阶段限一次。你可以选择一名其他角色，令所有与其势力不同的角色依次选择是否对其使用一张【杀】。然后其下回合使用【杀】的次数上限+X（X为其以此法受到的伤害次数），若其以此法进入过濒死状态，其回复1点体力。",
gzxingmou: "兴谋",
gzxingmou_info:
"锁定技。①你杀死其他角色或其他角色杀死你均不执行奖惩。②其他角色因执行奖惩而摸牌时，你摸一张牌。",
//官正「十年踪迹十年心」
gzyouyan: "诱言",
gzyouyan_info:
"回合内限一次。当你的牌因弃置而进入弃牌堆后，你可以展示牌堆顶的四张牌，然后获得其中与你此次弃置的牌花色均不同的牌。",
gzzhuihuan: "追还",
gzzhuihuan_info:
"结束阶段，你可以选择至多两名角色，然后依次为被选择的角色标记A或B（字母不能重复标记）。直到你的下回合开始，当A第一次受到伤害后，其对来源造成1点伤害；当B第一次受到伤害后，来源弃置两张手牌。",
//插个眼，手杀国战新张鲁
gzrebushi: "布施",
gzrebushi_info:
"①回合结束后，你获得X个“义舍”标记（X为你的体力值）。②其他角色的准备阶段，你可以失去1个“义舍”标记，交给其一张牌并摸两张牌。③准备阶段，你须弃置Y张牌，然后失去所有“义舍”标记（Y为场上存活人数-你的体力值-2）。",
gzremidao: "米道",
gzremidao_info:
"①结束阶段，若你的武将牌上没有“米”，则你可以摸两张牌。若如此做，你将两张牌置于武将牌上，称为“米”。②一名角色的判定牌生效前，你可以打出一张“米”作为新的判定牌，然后你获得原判定牌。",
jiahe_reyingzi: "英姿",
jiahe_haoshi: "好施",
jiahe_shelie: "涉猎",
jiahe_duoshi: "度势",
//国战典藏2023
gzdiaodu: "调度",
gzdiaodu_info:
"①与你势力相同的角色使用装备牌时，其可以摸一张牌。②出牌阶段开始时，你可以获得一名与你势力相同的角色的装备区里的一张牌，然后你将此牌交给另一名角色。",
gzqiance: "谦策",
gzqiance_info:
"与你势力相同的角色使用锦囊牌指定第一个目标后，你可以令其中的所有大势力角色无法响应此牌。",
gzjujian: "举荐",
gzjujian_info:
"副将技，锁定技。①此武将牌计算体力上限时减少半个阴阳鱼。②与你势力相同的角色进入濒死状态时，你可以令其将体力值回复至1点，然后你变更副将。",
gztongling: "通令",
gztongling_info:
"出牌阶段限一次，当你对一名与你势力不同的角色A造成伤害后，你可以选择一名与你势力相同的角色B，令B选择是否对A使用一张牌。若B选择使用，则此牌结算后，若此牌造成过伤害，你和B各摸两张牌，否则A获得你对其造成伤害的牌。",
gzjinyu: "近谀",
gzjinyu_info:
"当你明置此武将牌后，你令所有与你距离为1以内的角色依次执行以下效果：若其武将牌均明置，则其选择一张武将牌暗置，否则其弃置两张牌。",
gzrehuaiyi: "怀异",
gzrehuaiyi_info:
"出牌阶段限一次，你可以展示所有手牌。若其中至少包含两种颜色，则你可以弃置其中一种颜色的所有牌，然后获得至多等量名角色的各一张牌。然后你将以此法得到的装备牌置于武将牌上，称为“异”。你可以将“异”如手牌般使用或打出。",
gzrezisui: "恣睢",
gzrezisui_info:
"锁定技。①摸牌阶段，你多摸X张牌。②结束阶段，若X大于你的体力上限，你死亡（X为你武将牌上的“异”数）。",
gztaidan: "太丹",
gztaidan_taipingyaoshu: "太丹",
gztaidan_info: "锁定技，若你的防具栏为空且你的防具栏未被废除，你视为装备【太平要术】。",
gzrejinghe: "经合",
gzrejinghe_info:
"出牌阶段限一次，你可以转动“天书”，然后令一名角色获得“天书”向上一面的技能直到你的下个回合开始。",
gzrejinghe_faq: "转动“天书”",
gzrejinghe_faq_info:
"
若游戏未拥有“天书”，系统将[雷击，阴兵，活气，鬼助，仙授，论道，观月，言政]以顺时针方向组成圆环作为“天书”，并转动圆环将随机一个技能至于最上面。
若游戏已拥有“天书”，则以逆时针方向转动转动“天书”至下个技能于最上面。",
gz_key_ushio: "冈崎汐",
ushio_huanxin: "幻心",
ushio_huanxin_info:
"当你受到伤害后/使用【杀】造成伤害后/使用装备牌后，你可进行判定。然后你获得判定牌并弃置一张牌。",
ushio_xilv: "汐旅",
ushio_xilv2: "汐旅",
ushio_xilv_info:
"锁定技，此武将牌可作为任意单势力武将牌的副将。当你进行判定后，你令你的手牌上限+1直至你的下个结束阶段。",
//官盗2023
fakexiaoguo: "骁果",
fakexiaoguo_info:
"一名其他角色的准备阶段，你可以弃置任意张基本牌，然后弃置其装备区等量的牌，若其装备区的牌数小于你弃置的牌数，则你对其造成1点伤害。",
fakeduanbing: "短兵",
fakeduanbing_info:
"①你使用【杀】可以额外指定一名距离为1或以内的目标。②当你使用【杀】指定唯一目标后，你令目标角色需要额外使用一张【闪】响应此【杀】。",
fakeduoshi: "度势",
fakeduoshi_info:
"每轮限一次，友方角色可以将一张红色手牌当作【以逸待劳】使用，然后若你为小势力角色，你可以令一名友方角色将X张手牌当作不可被响应的【火烧连营】使用（X为此【以逸待劳】指定的目标数）。",
fakehanzhan: "酣战",
fakehanzhan_info: "有你参与的拼点事件结束后，没赢的角色可以获得对方装备区的一张牌。",
fakeshuangxiong: "双雄",
fakeshuangxiong_info:
"①摸牌阶段，你可以放弃摸牌并进行判定，本回合你可以将一张与此牌颜色不同的手牌当作【决斗】使用。②当你的判定牌于回合内生效后，你获得此牌。",
fakeyicheng: "疑城",
fakeyicheng_info:
"与你势力相同的角色成为【杀】的目标后，你可以令其摸一张牌，然后其可以使用一张装备牌，其于此回合结束时弃置X张牌（X为你本回合对其发动此技能的次数）。",
fakefenming: "奋命",
fakefenming_info:
"出牌阶段限一次，若你处于横置状态，你可以弃置所有处于横置状态的角色的各一张牌。",
fakebaoling: "暴凌",
fakebaoling_info:
"主将技，锁定技，出牌阶段结束时，若你有副将，则你移除副将，加3点体力上限并回复3点体力，然后获得〖崩坏〗。",
fakebenghuai: "崩坏",
fakebenghuai_info:
"结束阶段，若你的体力值不为全场最低，则你选择一项：①失去1点体力；②减1点体力上限；③背水：执行一个额外的摸牌阶段。",
fakediaodu: "调度",
fakediaodu_info:
"①每回合每种牌的类别限一次，与你势力相同的角色使用牌时，若此牌有目标且包含其，则其可以摸一张牌。②出牌阶段开始时，你可以获得与你势力相同的一名角色装备区内的一张牌，然后你可以将此牌交给另一名与你势力相同的其他角色。",
fakeyigui: "役鬼",
fakeyigui_info:
"①当你首次明置此武将牌时，你将剩余武将牌堆的两张牌称为“魂”置于武将牌上。②你可以展示一张武将牌上的“魂”并将其置入剩余武将牌堆，视为使用一张本回合内未以此法使用过的类别的基本牌或普通锦囊牌（此牌须指定目标，且目标须为未确定势力的角色或野心家或与此“魂”势力相同的角色）。",
fakejihun: "汲魂",
fakejihun_info:
"①当你受到伤害后，或与你势力不同的角色脱离濒死状态后，你可以将剩余武将牌堆的一张牌称为“魂”置于武将牌上。②准备阶段，你可以将至多两张“魂”置入剩余武将牌堆，然后将剩余武将牌堆的等量张牌称为“魂”置于武将牌上。",
fakejueyan: "决堰",
fakejizhi: "集智",
fakejueyan_info:
"主将技。①此武将牌计算体力上限时减少半个阴阳鱼。②准备阶段，你可以选择一个区域并于本回合的结束阶段弃置此区域的所有牌，然后你于本回合获得以下对应效果：⒈判定区：跳过判定阶段，获得〖集智〗直到回合结束；⒉装备区：摸三张牌，本回合手牌上限+3；⒊本回合使用【杀】的额定次数+3。",
fakequanji: "权计",
fakequanji_info:
"①每回合每项各限一次，当你造成或受到伤害后，你可以摸X张牌，然后将等量的牌称为“权”置于武将牌上。②你的手牌上限+X（X为你武将牌上的“权”数）。",
fakepaiyi: "排异",
fakepaiyi_info:
"出牌阶段限一次，你可以选择一名角色，然后选择一个军令令其选择是否执行。若其执行，则你摸X张牌，然后将一张“权”置入弃牌堆；若其不执行，则你可以对至多X名与其势力相同的角色各造成1点伤害，然后将等量的“权”置入弃牌堆。（X为你武将牌上的“权”数）",
fakeshilu: "嗜戮",
fakeshilu_info:
"①出牌阶段结束时，若你有副将且本阶段未发动过副将武将牌上的非锁定技，则你更换副将至你武将牌上的“戮”未包含的势力并将原副将称为“戮”置于武将牌上。②准备阶段，你弃置X张手牌，然后摸X张牌（X为你武将牌上的“戮”数，少牌全弃，无牌不弃）。",
fakexiongnve: "凶虐",
fakexiongnve_info:
"①当你使用【杀】造成伤害时或受到【杀】造成的伤害时，若你武将牌上的“戮”包含伤害来源的势力，则你令此伤害+1。②当你受到不为【杀】造成的伤害时，若你武将牌上的“戮”包含伤害来源的势力，则此伤害-1。",
fakehuaiyi: "怀异",
fakehuaiyi_info:
"出牌阶段限一次，你可以移除副将或弃置一个区域的所有牌，然后令所有大势力角色依次交给你至少一张牌，然后若存在多个大势力，则你移除一个此次交给你牌总数唯一最少的势力的其中一名角色的副将。",
fakezisui: "恣睢",
fakezisui_info:
"锁定技。①一名角色被你移除副将后，你将被移除的武将牌称为“异”置于武将牌上。②摸牌阶段，你多摸X张牌。③结束阶段，若X大于你的体力上限，你死亡。（X为你武将牌上的“异”数）",
fakejujian: "举荐",
fakejujian_info:
"副将技。①此武将牌计算体力上限时减少半个阴阳鱼。②结束阶段，你可以弃置一张非基本牌并选择一名友方角色，令其选择摸两张牌或回复1点体力，然后其可以变更副将。",
fakexibing: "息兵",
fakexibing_info:
"当一名其他角色在其出牌阶段内使用第一张黑色【杀】或黑色普通锦囊牌指定唯一角色为目标后，你可令该角色将手牌摸至体力值且本回合不能再使用手牌。若你与其均明置了所有武将牌，则你可以暗置你与其各一张武将牌且本回合不能再明置此武将牌。",
fakechengshang: "承赏",
fakechengshang_info:
"出牌阶段限一次，当你使用存在花色和点数且指定了其他势力角色为目标的牌结算完毕后，若你未因此牌造成过伤害，则你可以摸一张牌，然后本阶段你可以将一张手牌当作初始游戏牌堆中与此牌花色和点数相同的另一张基本牌或普通锦囊牌使用一次。",
fakezhente: "贞特",
fakezhente_info:
"每回合限一次，当你成为其他角色使用普通锦囊牌或黑色基本牌的目标后，你可令使用者选择一项：1.本回合不能再使用与此牌颜色相同的牌；2.令此牌对你无效。",
fakezhiwei: "至微",
fakezhiwei_info:
"你明置此武将牌时，选择一名其他角色。该角色造成伤害后，你摸一张牌，该角色受到伤害后，你随机弃置一张手牌。你弃牌阶段弃置的牌均被该角色获得。该角色死亡时，若你的两个武将牌均明置，你暗置此武将牌。若该角色未死亡，则此武将牌被暗置前，取消之。",
fakekuangcai: "狂才",
fakekuangcai_info:
"锁定技，你于回合内使用牌无距离和次数限制；弃牌阶段开始时，若你本回合内：未使用过牌，则你本回合手牌上限+1；使用过牌但未造成过伤害，则你本回合手牌上限-1。",
faketunchu: "屯储",
faketunchu_info:
"摸牌阶段，你可以额外摸两张牌，然后你将一至两张牌称为“粮”置于武将牌上。若如此做，你本回合不能使用【杀】。",
fakeshuliang: "输粮",
fakeshuliang_info:
"友方角色的结束阶段，若你与其的距离不大于你武将牌上的“粮”数，则你可以移去一张“粮”，然后令其摸两张牌。",
fakedujin: "独进",
fakedujin_info:
"①摸牌阶段，你可以额外摸X张牌（X为你装备区的牌数的一半，向上取整）。②当你首次明置此武将牌时，若你为你们势力第一个明置武将牌的角色，则你获得1个“先驱”标记。",
fakezhufu: "注傅",
fakezhufu_info:
"出牌阶段，你可以弃置一张本阶段未以此法弃置过的花色的牌，然后根据此牌的花色为你使用的下一张牌添加对应的应变效果：红桃，助战、目标+1；方片，富甲、不可被响应；黑桃，残躯、摸一张牌；草花，空巢、伤害+1。",
fakeguishu: "鬼术",
fakeguishu_info:
"出牌阶段限一次，你可以将一张黑桃手牌当作【知己知彼】或【远交近攻】使用。若你本局游戏内已经发动过了〖鬼术〗，则你必须选择与上次不同的选项。",
fakeyuanyu: "远域",
fakeyuanyu_info: "锁定技，当你受到伤害时，若你不在伤害来源的攻击范围内，则防止此伤害。",
fakemibei: "秘备",
fakemibei_info:
"①准备阶段，若你的手牌数不为全场最多，则你须选择一名手牌数为全场最多的角色，令其对你发起军令。②当你执行军令后，你将手牌数摸至与发起者相同（至多摸五张）。③当你拒绝执行军令后，你展示一至三张牌，然后你本回合可以将其中一张牌当作另一张基本牌或非延时锦囊牌使用一次。",
fakeqizhi: "奇制",
fakeqizhi_info:
"当你于回合内声明使用非装备牌A时，你可以弃置不是此牌目标的一名角色的一张牌B，然后其摸一张牌。若A具有应变效果，且A和B的花色相同，则你无视条件触发A的应变效果。",
fakejinqu: "进趋",
fakejinqu_info:
"结束阶段，你可以摸两张牌，然后你将手牌弃置至X张（X为你本回合发动过〖奇制〗的次数）。",
fakejuzhan: "拒战",
fakejuzhan_info:
"转换技。阴：当你成为【杀】的目标后，你可以与使用者各摸X张牌，然后若使用者的武将牌均明置，则你可以暗置其一张武将牌，且其本回合不能明置此武将牌。阳，当你使用【杀】指定目标后，你可以获得目标角色的X张牌，然后若你的武将牌均明置，则其可以暗置此武将牌，且你本回合不能明置此武将牌。（X为使用者已损失的体力值且X至少为1）",
fakedanshou: "胆守",
fakedanshou_info:
"每轮限一次，一名角色的准备阶段，你可以弃置一个区域的所有牌。若如此做，本回合其每个阶段开始时（准备阶段和结束阶段除外），你摸一张牌或令本回合以此法摸牌数+1，然后若你选择了摸牌且你本次至少摸了四张牌，则你可以对其造成1点伤害。",
fakexunxi: "迅析",
fakexunxi_info: "其他角色于回合外明置武将牌时，你可以视为对其使用一张【杀】（无距离限制）。",
fakehuanjia: "擐甲",
fakehuanjia_info:
"锁定技，每回合每项各限一次。①当你成为【杀】的目标后，本回合你视为装备此牌使用者的防具，直到你的装备区中有防具。②当你使用【杀】指定唯一目标后，本回合你视为装备目标角色的武器，直到你的装备区中有武器。",
fakexiongshu: "凶竖",
fakexiongshu_info:
"每回合限一次，一名角色使用【杀】或伤害类锦囊牌指定第一个目标后，若你为/不为此牌使用者，则你可以摸一张牌并令一名其他角色成为此牌的伤害来源/弃置一张牌并成为此牌的伤害来源。",
fakejianhui: "奸回",
fakejianhui_info:
"当一名角色受到其势力相同的另一名角色造成的伤害后，你可以令其中一名角色摸一张牌，然后弃置其中另一名角色的一张牌。",
fakechongxin: "崇信",
fakechongxin_info:
"出牌阶段限一次，你可以选择一名与你势力不同的角色，视为你使用一张指定你与其为目标的【以逸待劳】。",
fakeweirong: "卫戎",
fakeweirong_info:
"转换技，每轮限一次，出牌阶段。阴：你可以弃置X张牌，然后当你于本轮不因此法得到牌后，你摸一张牌。阳：你可以摸X张牌，然后当你于本轮不因此法失去牌后，你弃置一张牌。（X为你上一轮以此法摸和弃置的牌数之和，且X至少为1，至多为你的体力上限）",
gz_re_taishici: "太史慈",
gz_xin_zhuran: "朱然",
gz_jin_jiachong: "贾充",
gz_jin_yanghu: "羊祜",
gz_wangling: "王淩",
fakequanbian: "权变",
fakequanbian_tag: "牌堆顶",
fakequanbian_info:
"当你于回合内使用或打出牌时，你可以将一张手牌与牌堆顶X张牌的其中一张进行交换（X为你的体力上限）。",
fakezhouting: "骤霆",
fakezhouting_info:
"限定技，出牌阶段，你可以依次使用牌堆顶X张牌中所有可以使用的牌，然后获得其中不能使用的牌，然后若有角色因此死亡，则你重置〖骤霆〗（X为你的体力上限）。",
fakexuanbei: "选备",
fakexuanbei_info:
"①当你首次明置此武将牌时，你摸两张牌，且你本回合内使用带有“应变”标签的牌时直接强化。②每回合限一次，当你使用带有“应变”标签的牌结算完毕后，你可以令一名其他角色获得此牌对应的所有实体牌。③当你死亡时，你可以令一名其他角色变更副将。",
fakeqingleng: "清冷",
fakeqingleng_info:
"其他角色的结束阶段，若其武将牌均明置，则你可以将一张牌当作冰【杀】对其使用（无距离限制）。然后若此牌未对其造成伤害，则你暗置其一张武将牌，且直到其下个回合开始，其明置此武将牌时，你对其造成1点伤害。",
fakexijue: "袭爵",
fakexijue_info:
"①当你首次明置此武将牌时，你获得2枚“爵”标记。②回合结束时，若你本回合造成过伤害，则你获得1枚“爵”标记。③你可以于合适的时机发动〖突袭〗或〖骁果〗（至多弃置X张基本牌），然后移去1枚“爵”标记。④摸牌阶段，你改为摸X张牌。（X为你的“爵”标记数，且X至多为你的体力上限）",
fakexijue_xiaoguo: "骁果",
fakexijue_xiaoguo_info:
"一名其他角色的准备阶段，你可以弃置至多X张基本牌（X为你的“爵”标记数，且X至多为你的体力上限），然后弃置其装备区等量的牌，若其装备区的牌数小于你弃置的牌数，则你对其造成1点伤害。",
fakeqimei: "齐眉",
fakeqimei_info:
"准备阶段，你可以选择一名其他角色。若如此做，直到回合结束：当你或其获得牌/失去手牌后，若你与其手牌数相等，则另一名角色回复1点体力；当你或其的体力值变化后，若你与其体力值相等，则另一名角色摸一张牌。",
fakebaoqie: "宝箧",
fakebaoqie_info:
"①当你受到伤害时，若此武将牌未明置过，则你可以明置此武将牌并防止此伤害。②当你首次明置此武将牌时，你可以获得一名角色装备区里所有的宝物牌，然后你可以使用其中的一张牌。",
fakeciwei: "慈威",
fakeciwei_info:
"其他角色于一回合内使用第偶数张牌时，你可以弃置一张牌并取消此牌的所有目标，然后若此牌为装备牌，你可以获得之且你可以使用之。",
fakehuirong: "慧容",
fakehuirong_info:
"①当你受到伤害时，若此武将牌未明置过，则你可以明置此武将牌并防止此伤害。②当你首次明置此武将牌时，你可以令一名角色将手牌数调整至其体力值。",
fakeyanxi: "宴戏",
fakeyanxi_info:
"出牌阶段限一次，你可以展示一名其他角色的一张手牌和牌堆顶的两张牌，然后你获得其中一种颜色或类别的所有牌且本回合手牌上限+X（X为你获得的牌数），然后其获得剩余的牌。",
fakeshiren: "识人",
fakeshiren_info:
"①当你受到伤害时，若此武将牌未明置过，则你可以明置此武将牌并防止此伤害。②当你首次明置此武将牌时，你可以发动一次〖宴戏〗。",
fakecanmou: "参谋",
fakecanmou_info:
"每回合每项限一次，一名角色使用普通锦囊牌指定第一个目标时，若其手牌数为全场唯一最多，则你可以为此牌增加或减少一个目标（目标数至少为1）。",
fakezhuosheng: "擢升",
fakezhuosheng_info:
"每回合每种牌名限一次，你可以将至少两张手牌当作任意基本牌使用，若你以此法使用的牌中包含具有应变效果的牌，则你令此牌无视条件获得对应的应变效果。",
fakejuhou: "拒后",
fakejuhou_info:
"阵法技，与你处于同一队列的角色成为【杀】或普通锦囊牌的目标后，你可以令其将任意张牌置于其武将牌上，然后其于此牌结算完毕后获得这些牌。",
gznaxiang: "纳降",
gznaxiang_info:
"锁定技，当你受到其他角色造成的伤害后，或你对其他角色造成伤害后，你对其发动〖才望〗时的“弃置”改为“获得”直到你的下回合开始。",
fakecaiwang: "才望",
fakecaiwang_info:
"①你可以助战自己。②每回合每项各限一次，当你响应助战后，若你弃置的牌和被强化的牌：颜色相同，你可以弃置一名其他角色的一张牌；颜色不同，你摸一张牌。",
fakenaxiang: "纳降",
fakenaxiang_info:
"锁定技。①当你对与你势力不同的角色造成伤害后，或受到与你势力不同的角色对你造成的伤害后。你对其发起军令，若其不执行，则你不能对其发动〖纳降①〗直到你的下个回合开始。②你响应助战弃牌无类别限制，且你触发具有应变的卡牌的条件均视为助战。",
fakehuyuan: "护援",
fakehuyuan_info:
"①你的回合内，当一张装备牌进入一名角色的装备区后，你可以弃置与其距离为1以内的另一名角色区域里的一张牌。②结束阶段，你可以将一张装备牌置入一名角色的装备区。",
fakekeshou: "恪守",
fakekeshou_info:
"①当你受到伤害时，你可以弃置两张颜色相同的牌并令此伤害-1。②当你因弃置而一次性失去至少两张牌后，若你的势力已确定且场上没有与你势力相同的其他角色，则你可以进行判定，若结果判定为红色，你摸一张牌。",
guozhan_default: "国战标准",
guozhan_zhen: "君临天下·阵",
guozhan_shi: "君临天下·势",
guozhan_bian: "君临天下·变",
guozhan_quan: "君临天下·权",
guozhan_jun: "君主武将",
guozhan_jin: "文德武备",
guozhan_single: "君临天下EX",
guozhan_double: "双势力武将",
guozhan_yexinjia: "野心家武将",
guozhan_zongheng: "纵横捭阖",
guozhan_tw: "海外服专属",
guozhan_mobile: "移动版",
guozhan_qunxiong: "群雄割据",
guozhan_decade: "十年踪迹十年心",
guozhan_others: "其他",
},
junList: ["liubei", "zhangjiao", "sunquan", "caocao"],
guozhanPile_yingbian: [
//黑桃普通
["spade", 1, "shandian"],
["spade", 1, "xietianzi"],
["spade", 1, "juedou"],
["spade", 2, "bagua"],
["spade", 2, "heiguangkai"],
["spade", 2, "cixiong"],
["spade", 2, "taigongyinfu"],
["spade", 3, "zhujinqiyuan", null, ["yingbian_zhuzhan", "yingbian_add"]],
["spade", 3, "huoshaolianying"],
["spade", 3, "shuiyanqijunx", null, ["yingbian_zhuzhan", "yingbian_add"]],
["spade", 4, "guohe"],
["spade", 4, "sha"],
["spade", 4, "shuiyanqijunx", null, ["yingbian_zhuzhan", "yingbian_add"]],
["spade", 5, "jueying"],
["spade", 5, "qinglong"],
["spade", 5, "sha"],
["spade", 6, "qinggang"],
["spade", 6, "jiu"],
["spade", 6, "sha", "ice"],
["spade", 7, "sha"],
["spade", 7, "sha"],
["spade", 7, "sha", "ice"],
["spade", 8, "sha", "ice"],
["spade", 8, "sha", "ice"],
["spade", 8, "sha"],
["spade", 9, "jiu"],
["spade", 9, "sha", "thunder"],
["spade", 9, "sha"],
["spade", 10, "bingliang"],
["spade", 10, "sha", "thunder"],
["spade", 10, "sha", null, ["yingbian_canqu", "yingbian_add"]],
["spade", 11, "wuxie", null, ["yingbian_kongchao", "yingbian_draw"]],
["spade", 11, "sha", null, ["yingbian_canqu", "yingbian_add"]],
["spade", 11, "sha", "thunder"],
["spade", 12, "zhangba"],
["spade", 12, "lulitongxin"],
["spade", 12, "tiesuo"],
["spade", 13, "wutiesuolian"],
["spade", 13, "wuxie"],
["spade", 13, "nanman", null, ["yingbian_fujia", "yingbian_remove"]],
//草花普通
["club", 1, "juedou"],
["club", 1, "yuxi"],
["club", 1, "huxinjing"],
["club", 2, "sha"],
["club", 2, "tianjitu"],
["club", 2, "renwang"],
["club", 2, "tengjia"],
["club", 3, "sha"],
["club", 3, "chiling"],
["club", 3, "zhibi"],
["club", 4, "sha", null, ["yingbian_kongchao", "yingbian_add"]],
["club", 4, "sha", "thunder"],
["club", 4, "zhibi"],
["club", 5, "sha", null, ["yingbian_kongchao", "yingbian_add"]],
["club", 5, "sha", "thunder"],
["club", 5, "tongque"],
["club", 6, "sha", "thunder"],
["club", 6, "sha", null, ["yingbian_kongchao", "yingbian_add"]],
["club", 6, "lebu"],
["club", 7, "sha", "thunder"],
["club", 7, "sha"],
["club", 7, "nanman", null, ["yingbian_fujia", "yingbian_remove"]],
["club", 8, "sha", "thunder"],
["club", 8, "sha", null, ["yingbian_canqu", "yingbian_add"]],
["club", 8, "sha"],
["club", 9, "sha"],
["club", 9, "jiu"],
["club", 9, "jiu"],
["club", 10, "bingliang"],
["club", 10, "lulitongxin"],
["club", 10, "sha"],
["club", 11, "sha"],
["club", 11, "huoshaolianying"],
["club", 11, "sha"],
["club", 12, "zhujinqiyuan", null, ["yingbian_zhuzhan", "yingbian_add"]],
["club", 12, "jiedao", null, ["yingbian_fujia", "yingbian_hit"]],
["club", 12, "tiesuo"],
["club", 13, "tiesuo"],
["club", 13, "wuxie", null, ["guo"]],
["club", 13, "wuxie", null, ["guo"]],
//红桃普通
["heart", 1, "wanjian"],
["heart", 1, "taoyuan"],
["heart", 1, "lianjunshengyan"],
["heart", 2, "shan"],
["heart", 2, "chuqibuyi", null, ["yingbian_zhuzhan", "yingbian_add"]],
["heart", 2, "diaohulishan"],
["heart", 3, "chuqibuyi", null, ["yingbian_zhuzhan", "yingbian_add"]],
["heart", 3, "wugu"],
["heart", 3, "jingfanma"],
["heart", 4, "tao"],
["heart", 4, "sha", "fire", ["yingbian_canqu", "yingbian_damage"]],
["heart", 4, "shan"],
["heart", 5, "qilin"],
["heart", 5, "chitu"],
["heart", 5, "shan", null, ["yingbian_kongchao", "yingbian_draw"]],
["heart", 6, "lebu"],
["heart", 6, "tao"],
["heart", 6, "shan", null, ["yingbian_kongchao", "yingbian_draw"]],
["heart", 7, "tao"],
["heart", 7, "dongzhuxianji"],
["heart", 7, "shan"],
["heart", 8, "tao"],
["heart", 8, "dongzhuxianji"],
["heart", 8, "tao"],
["heart", 9, "tao"],
["heart", 9, "yuanjiao"],
["heart", 9, "tao"],
["heart", 10, "sha"],
["heart", 10, "shan"],
["heart", 10, "sha"],
["heart", 11, "yiyi"],
["heart", 11, "tao"],
["heart", 11, "sha", null, ["yingbian_zhuzhan", "yingbian_add"]],
["heart", 12, "tao"],
["heart", 12, "sha"],
["heart", 12, "huoshaolianying"],
["heart", 13, "zhuahuang"],
["heart", 13, "shan"],
["heart", 13, "huogong", null, ["yingbian_zhuzhan", "yingbian_add"]],
//方片普通
["diamond", 1, "wuxinghelingshan"],
["diamond", 1, "zhuge"],
["diamond", 1, "xietianzi"],
["diamond", 2, "shan"],
["diamond", 2, "tao"],
["diamond", 2, "tao"],
["diamond", 3, "shunshou"],
["diamond", 3, "shan"],
["diamond", 3, "tao"],
["diamond", 4, "yiyi"],
["diamond", 4, "sha", "fire", ["yingbian_canqu", "yingbian_damage"]],
["diamond", 4, "sha", "fire", ["yingbian_zhuzhan", "yingbian_add"]],
["diamond", 5, "guanshi"],
["diamond", 5, "sha", "fire"],
["diamond", 5, "muniu"],
["diamond", 6, "wuliu"],
["diamond", 6, "shan"],
["diamond", 6, "shan"],
["diamond", 7, "shan", null, ["yingbian_kongchao", "yingbian_draw"]],
["diamond", 7, "shan", null, ["yingbian_kongchao", "yingbian_draw"]],
["diamond", 7, "shan"],
["diamond", 8, "shan", null, ["yingbian_kongchao", "yingbian_draw"]],
["diamond", 8, "shan", null, ["yingbian_kongchao", "yingbian_draw"]],
["diamond", 8, "sha", "fire"],
["diamond", 9, "jiu"],
["diamond", 9, "shan"],
["diamond", 9, "sha", "fire"],
["diamond", 10, "shan"],
["diamond", 10, "sha"],
["diamond", 10, "diaohulishan"],
["diamond", 11, "sha"],
["diamond", 11, "shan"],
["diamond", 11, "wuxie", null, ["guo"]],
["diamond", 12, "sha"],
["diamond", 12, "sanjian"],
["diamond", 12, "wuxie", null, ["guo"]],
["diamond", 12, "fangtian"],
["diamond", 13, "zixin"],
["diamond", 13, "shan"],
["diamond", 13, "shan"],
//特殊
["heart", 3, "taipingyaoshu"],
["diamond", 4, "dinglanyemingzhu"],
["heart", 5, "liulongcanjia"],
["spade", 6, "feilongduofeng"],
["club", 12, "gz_wenheluanwu"],
["heart", 1, "gz_guguoanbang"],
["spade", 12, "gz_haolingtianxia"],
["diamond", 1, "gz_kefuzhongyuan"],
],
guozhanPile_old: [
["spade", 1, "juedou"],
["spade", 1, "shandian"],
["spade", 2, "cixiong"],
["spade", 2, "bagua"],
["spade", 2, "hanbing"],
["spade", 3, "guohe"],
["spade", 3, "shunshou"],
["spade", 4, "guohe"],
["spade", 4, "shunshou"],
["spade", 5, "sha"],
["spade", 5, "jueying"],
["spade", 6, "qinggang"],
["spade", 6, "sha", "thunder"],
["spade", 7, "sha"],
["spade", 7, "sha", "thunder"],
["spade", 8, "sha"],
["spade", 8, "sha"],
["spade", 9, "sha"],
["spade", 9, "jiu"],
["spade", 10, "sha"],
["spade", 10, "bingliang"],
["spade", 11, "sha"],
["spade", 11, "wuxie"],
["spade", 12, "zhangba"],
["spade", 12, "tiesuo"],
["spade", 13, "nanman"],
["spade", 13, "dawan"],
["club", 1, "juedou"],
["club", 1, "baiyin"],
["club", 2, "sha"],
["club", 2, "tengjia"],
["club", 2, "renwang"],
["club", 3, "sha"],
["club", 3, "zhibi"],
["club", 4, "sha"],
["club", 4, "zhibi"],
["club", 5, "sha"],
["club", 5, "dilu"],
["club", 6, "lebu"],
["club", 6, "sha", "thunder"],
["club", 7, "nanman"],
["club", 7, "sha", "thunder"],
["club", 8, "sha"],
["club", 8, "sha", "thunder"],
["club", 9, "sha"],
["club", 9, "jiu"],
["club", 10, "sha"],
["club", 10, "bingliang"],
["club", 11, "sha"],
["club", 11, "sha"],
["club", 12, "jiedao"],
["club", 12, "tiesuo"],
["club", 13, "wuxie", null, ["guo"]],
["club", 13, "tiesuo"],
["diamond", 1, "zhuge"],
["diamond", 1, "zhuque"],
["diamond", 2, "shan"],
["diamond", 2, "tao"],
["diamond", 3, "shan"],
["diamond", 3, "shunshou"],
["diamond", 4, "yiyi"],
["diamond", 4, "sha", "fire"],
["diamond", 5, "guanshi"],
["diamond", 5, "sha", "fire"],
["diamond", 6, "shan"],
["diamond", 6, "wuliu"],
["diamond", 7, "shan"],
["diamond", 7, "shan"],
["diamond", 8, "shan"],
["diamond", 8, "shan"],
["diamond", 9, "shan"],
["diamond", 9, "jiu"],
["diamond", 10, "shan"],
["diamond", 10, "sha"],
["diamond", 11, "shan"],
["diamond", 11, "sha"],
["diamond", 12, "sha"],
["diamond", 12, "sanjian"],
["diamond", 12, "wuxie", null, ["guo"]],
["diamond", 13, "shan"],
["diamond", 13, "zixin"],
["heart", 1, "taoyuan"],
["heart", 1, "wanjian"],
["heart", 2, "shan"],
["heart", 2, "huogong"],
["heart", 3, "wugu"],
["heart", 3, "huogong"],
["heart", 4, "tao"],
["heart", 4, "sha", "fire"],
["heart", 5, "qilin"],
["heart", 5, "chitu"],
["heart", 6, "tao"],
["heart", 6, "lebu"],
["heart", 7, "tao"],
["heart", 7, "wuzhong"],
["heart", 8, "tao"],
["heart", 8, "wuzhong"],
["heart", 9, "tao"],
["heart", 9, "yuanjiao"],
["heart", 10, "tao"],
["heart", 10, "sha"],
["heart", 11, "shan"],
["heart", 11, "yiyi"],
["heart", 12, "tao"],
["heart", 12, "sha"],
["heart", 12, "guohe"],
["heart", 13, "shan"],
["heart", 13, "zhuahuang"],
],
guozhanPile: [
["spade", 1, "juedou"],
["spade", 1, "shandian"],
["spade", 2, "feilongduofeng"],
["spade", 2, "bagua"],
["spade", 2, "hanbing"],
["spade", 3, "guohe"],
["spade", 3, "shunshou"],
["spade", 4, "guohe"],
["spade", 4, "shunshou"],
["spade", 5, "sha"],
["spade", 5, "jueying"],
["spade", 6, "qinggang"],
["spade", 6, "sha", "thunder"],
["spade", 7, "sha"],
["spade", 7, "sha", "thunder"],
["spade", 8, "sha"],
["spade", 8, "sha"],
["spade", 9, "sha"],
["spade", 9, "jiu"],
["spade", 10, "sha"],
["spade", 10, "bingliang"],
["spade", 11, "sha"],
["spade", 11, "wuxie"],
["spade", 12, "zhangba"],
["spade", 12, "tiesuo"],
["spade", 13, "nanman"],
["spade", 13, "dawan"],
["club", 1, "juedou"],
["club", 1, "baiyin"],
["club", 2, "sha"],
["club", 2, "tengjia"],
["club", 2, "renwang"],
["club", 3, "sha"],
["club", 3, "zhibi"],
["club", 4, "sha"],
["club", 4, "zhibi"],
["club", 5, "sha"],
["club", 5, "dilu"],
["club", 6, "lebu"],
["club", 6, "sha", "thunder"],
["club", 7, "nanman"],
["club", 7, "sha", "thunder"],
["club", 8, "sha"],
["club", 8, "sha", "thunder"],
["club", 9, "sha"],
["club", 9, "jiu"],
["club", 10, "sha"],
["club", 10, "bingliang"],
["club", 11, "sha"],
["club", 11, "sha"],
["club", 12, "jiedao"],
["club", 12, "tiesuo"],
["club", 13, "wuxie", null, ["guo"]],
["club", 13, "tiesuo"],
["diamond", 1, "zhuge"],
["diamond", 1, "zhuque"],
["diamond", 2, "shan"],
["diamond", 2, "tao"],
["diamond", 3, "shan"],
["diamond", 3, "shunshou"],
["diamond", 4, "yiyi"],
["diamond", 4, "sha", "fire"],
["diamond", 5, "guanshi"],
["diamond", 5, "sha", "fire"],
["diamond", 6, "shan"],
["diamond", 6, "wuliu"],
["diamond", 7, "shan"],
["diamond", 7, "shan"],
["diamond", 8, "shan"],
["diamond", 8, "shan"],
["diamond", 9, "shan"],
["diamond", 9, "jiu"],
["diamond", 10, "shan"],
["diamond", 10, "sha"],
["diamond", 11, "shan"],
["diamond", 11, "sha"],
["diamond", 12, "sha"],
["diamond", 12, "sanjian"],
["diamond", 12, "wuxie", null, ["guo"]],
["diamond", 13, "shan"],
["diamond", 13, "zixin"],
["heart", 1, "taoyuan"],
["heart", 1, "wanjian"],
["heart", 2, "shan"],
["heart", 2, "huogong"],
["heart", 3, "wugu"],
["heart", 3, "taipingyaoshu"],
["heart", 3, "huogong"],
["heart", 4, "tao"],
["heart", 4, "sha", "fire"],
["heart", 5, "qilin"],
["heart", 5, "chitu"],
["heart", 6, "tao"],
["heart", 6, "lebu"],
["heart", 7, "tao"],
["heart", 7, "wuzhong"],
["heart", 8, "tao"],
["heart", 8, "wuzhong"],
["heart", 9, "tao"],
["heart", 9, "yuanjiao"],
["heart", 10, "tao"],
["heart", 10, "sha"],
["heart", 11, "shan"],
["heart", 11, "yiyi"],
["heart", 12, "tao"],
["heart", 12, "sha"],
["heart", 12, "guohe"],
["heart", 13, "shan"],
["heart", 13, "zhuahuang"],
["spade", 1, "xietianzi", null, ["lianheng"]],
["spade", 2, "minguangkai"],
["spade", 3, "huoshaolianying", null, ["lianheng"]],
["spade", 4, "sha"],
["spade", 5, "qinglong"],
["spade", 6, "jiu", null, ["lianheng"]],
["spade", 7, "sha"],
["spade", 8, "sha"],
["spade", 9, "sha", "thunder"],
["spade", 10, "sha", "thunder"],
["spade", 11, "sha", "thunder", ["lianheng"]],
["spade", 12, "lulitongxin"],
["spade", 13, "wuxie"],
["heart", 1, "lianjunshengyan"],
["heart", 2, "diaohulishan"],
["heart", 3, "jingfanma", null, ["lianheng"]],
["heart", 4, "shan"],
["heart", 5, "shan"],
["heart", 6, "shan"],
["heart", 7, "shan"],
["heart", 8, "tao"],
["heart", 9, "tao"],
["heart", 10, "sha"],
["heart", 11, "sha"],
["heart", 12, "huoshaolianying", null, ["lianheng"]],
["heart", 13, "shuiyanqijunx"],
["club", 1, "yuxi"],
["club", 2, "huxinjing", null, ["lianheng"]],
["club", 3, "chiling"],
["club", 4, "sha"],
["club", 5, "sha", "thunder", ["lianheng"]],
["club", 6, "sha"],
["club", 7, "sha"],
["club", 8, "sha"],
["club", 9, "jiu"],
["club", 10, "lulitongxin"],
["club", 11, "huoshaolianying", null, ["lianheng"]],
["club", 12, "shuiyanqijunx"],
["club", 13, "wuxie", null, ["guo"]],
["diamond", 1, "xietianzi", null, ["lianheng"]],
["diamond", 2, "tao"],
["diamond", 3, "tao", null, ["lianheng"]],
["diamond", 4, "xietianzi", null, ["lianheng"]],
["diamond", 5, "muniu"],
["diamond", 6, "shan"],
["diamond", 7, "shan"],
["diamond", 8, "sha", "fire"],
["diamond", 9, "sha", "fire"],
["diamond", 10, "diaohulishan", null, ["lianheng"]],
["diamond", 11, "wuxie", null, ["guo"]],
["diamond", 12, "fangtian"],
["diamond", 13, "shan"],
["diamond", 6, "dinglanyemingzhu"],
["heart", 13, "liulongcanjia"],
//['spade',12,'gz_haolingtianxia'],
//['diamond',1,'gz_kefuzhongyuan'],
//['heart',1,'gz_guguoanbang'],
//['club',12,'gz_wenheluanwu'],
],
element: {
content: {
hideCharacter: function () {
game.addVideo("hideCharacter", player, num);
var skills,
log = event.log;
switch (num) {
case 0:
if (log !== false) game.log(player, "暗置了主将" + get.translation(player.name1));
skills = lib.character[player.name1][3];
player.name = player.name2;
player.sex = lib.character[player.name2][0];
player.classList.add("unseen");
break;
case 1:
if (log !== false) game.log(player, "暗置了副将" + get.translation(player.name2));
skills = lib.character[player.name2][3];
player.classList.add("unseen2");
break;
}
game.broadcast(
function (player, name, sex, num, skills) {
player.name = name;
player.sex = sex;
switch (num) {
case 0:
player.classList.add("unseen");
break;
case 1:
player.classList.add("unseen2");
break;
}
for (var i = 0; i < skills.length; i++) {
if (!player.skills.includes(skills[i])) continue;
player.hiddenSkills.add(skills[i]);
player.skills.remove(skills[i]);
}
},
player,
player.name,
player.sex,
num,
skills
);
for (var i = 0; i < skills.length; i++) {
if (!player.skills.includes(skills[i])) continue;
player.hiddenSkills.add(skills[i]);
var info = get.info(skills[i]);
if (info.ondisable && info.onremove) {
info.onremove(player);
}
player.skills.remove(skills[i]);
}
player.checkConflict();
},
chooseJunlingFor: function () {
"step 0";
var list = ["junling1", "junling2", "junling3", "junling4", "junling5", "junling6"];
list = list.randomGets(event.num).sort();
for (var i = 0; i < list.length; i++) list[i] = ["军令", "", list[i]];
var prompt = event.prompt || "选择一张军令牌";
if (target != undefined && !event.prompt) {
var str = target == player ? "（你）" : "";
prompt += "，令" + get.translation(target) + str + "选择是否执行";
}
player.chooseButton([prompt, [list, "vcard"]], true).set("ai", function (button) {
return get.junlingEffect(
_status.event.player,
button.link[2],
_status.event.getParent().target,
[],
_status.event.player
);
});
"step 1";
event.result = {
junling: result.links[0][2],
targets: [],
};
if (result.links[0][2] == "junling1")
player
.chooseTarget("选择一名角色，做为若该军令被执行，受到伤害的角色", true)
.set("ai", function (_target) {
return get.damageEffect(_target, target, player);
});
"step 2";
if (result.targets.length) {
player.line(result.targets, "green");
event.result.targets = result.targets;
}
},
chooseJunlingControl: function () {
"step 0";
var dialog = [];
var str1 = source == player ? "（你）" : "";
var str2 = event.targets
? "（被指定的角色为" + get.translation(event.targets) + "）"
: "";
if (!event.prompt)
dialog.add(get.translation(event.source) + str1 + "选择的军令" + str2 + "为");
else {
dialog.add(event.prompt);
dialog.add(get.translation(event.source) + str1 + "选择的军令" + str2 + "为");
}
dialog.add([[event.junling], "vcard"]);
var controls = [];
if (event.choiceList) {
for (var i = 0; i < event.choiceList.length; i++) {
dialog.add(
'"
);
controls.push("选项" + get.cnNumber(i + 1, true));
}
} else if (event.controls) controls = event.controls;
else controls = ["执行该军令", "不执行该军令"];
if (!event.ai)
event.ai = function () {
return Math.floor(controls.length * Math.random());
};
player.chooseControl(controls).set("dialog", dialog).set("ai", event.ai);
"step 1";
event.result = {
index: result.index,
control: result.control,
};
},
carryOutJunling: function () {
"step 0";
switch (event.junling) {
case "junling1": {
if (targets[0].isAlive()) {
player.line(targets, "green");
targets[0].damage(player);
}
break;
}
case "junling2":
player.draw();
event.num = 1;
break;
case "junling3":
player.loseHp();
break;
case "junling4":
player.addTempSkill("junling4_eff");
player.addTempSkill("fengyin_vice");
player.addTempSkill("fengyin_main");
break;
case "junling5":
player.turnOver();
player.addTempSkill("junling5_eff");
break;
}
"step 1";
if (event.junling == "junling2" && source != player && player.countCards("he") > 0) {
player.chooseCard(
"交给" +
get.translation(source) +
"第" +
get.cnNumber(event.num) +
"张牌（共两张）",
"he",
true
);
event.ing = true;
}
if (event.junling == "junling6") {
var position = "",
num0 = 0;
if (player.countCards("h")) {
position += "h";
num0++;
}
if (player.countCards("e")) {
position += "e";
num0++;
}
player
.chooseCard(
"选择一张手牌和一张装备区内牌（若有），然后弃置其余的牌",
position,
num0,
function (card) {
if (ui.selected.cards.length)
return get.position(card) != get.position(ui.selected.cards[0]);
return true;
},
true
)
.set("complexCard", true)
.set("ai", function (card) {
return get.value(card);
});
}
"step 2";
if (event.junling == "junling2" && source != player) {
if (result.cards.length && event.ing) {
player.give(result.cards, source);
}
event.num++;
if (event.num < 3) {
event.ing = false;
event.goto(1);
}
}
if (event.junling == "junling6") {
var cards = player.getCards("he");
for (var i = 0; i < result.cards.length; i++) cards.remove(result.cards[i]);
player.discard(cards);
}
},
doubleDraw: function () {
if (!player.hasMark("yinyang_mark")) player.addMark("yinyang_mark", 1);
},
changeViceOnline: function () {
"step 0";
player.showCharacter(2);
var group = lib.character[player.name1][1];
_status.characterlist.randomSort();
var name = false;
for (var i = 0; i < _status.characterlist.length; i++) {
var goon = false,
group2 = lib.character[_status.characterlist[i]][1];
if (group == "ye") {
if (group2 != "ye") goon = true;
} else {
if (group == group2) goon = true;
else {
var double = get.is.double(_status.characterlist[i], true);
if (double && double.includes(group)) goon = true;
}
}
if (goon) {
name = _status.characterlist[i];
break;
}
}
if (!name) {
event.finish();
return;
}
_status.characterlist.remove(name);
if (player.hasViceCharacter()) {
event.change = true;
_status.characterlist.add(player.name2);
}
event.toRemove = player.name2;
event.toChange = name;
if (event.change) event.trigger("removeCharacterBefore");
"step 1";
if (event.hidden) {
if (!player.isUnseen(1)) player.hideCharacter(1);
}
"step 2";
var name = event.toChange;
if (event.hidden) game.log(player, "替换了副将", "#g" + get.translation(player.name2));
else
game.log(
player,
"将副将从",
"#g" + get.translation(player.name2),
"变更为",
"#g" + get.translation(name)
);
player.viceChanged = true;
player.reinitCharacter(player.name2, name, false);
},
changeVice: function () {
"step 0";
player.showCharacter(2);
if (!event.num) event.num = 3;
var group = player.identity;
if (!lib.group.includes(group)) group = lib.character[player.name1][1];
_status.characterlist.randomSort();
event.tochange = [];
for (var i = 0; i < _status.characterlist.length; i++) {
if (_status.characterlist[i].indexOf("gz_jun_") == 0) continue;
var goon = false,
group2 = lib.character[_status.characterlist[i]][1];
if (group == "ye") {
if (group2 != "ye") goon = true;
} else {
if (group == group2) goon = true;
else {
var double = get.is.double(_status.characterlist[i], true);
if (double && double.includes(group)) goon = true;
}
}
if (goon) {
event.tochange.push(_status.characterlist[i]);
if (event.tochange.length == event.num) break;
}
}
if (!event.tochange.length) event.finish();
else {
if (event.tochange.length == 1)
event._result = {
bool: true,
links: event.tochange,
};
else
player.chooseButton(true, [
"选择要变更的武将牌",
[event.tochange, "character"],
]).ai = function (button) {
return get.guozhanRank(button.link);
};
}
"step 1";
var name = result.links[0];
_status.characterlist.remove(name);
if (player.hasViceCharacter()) {
event.change = true;
_status.characterlist.add(player.name2);
}
event.toRemove = player.name2;
event.toChange = name;
if (event.change) event.trigger("removeCharacterBefore");
if (event.hidden) {
if (!player.isUnseen(1)) player.hideCharacter(1);
}
"step 2";
var name = event.toChange;
if (event.hidden) game.log(player, "替换了副将", "#g" + get.translation(player.name2));
else
game.log(
player,
"将副将从",
"#g" + get.translation(player.name2),
"变更为",
"#g" + get.translation(name)
);
player.viceChanged = true;
player.reinitCharacter(player.name2, name, false);
},
/*----分界线----*/
mayChangeVice: function () {
"step 0";
player.chooseBool("是否变更副将？").set("ai", function () {
var player = _status.event.player;
return get.guozhanRank(player.name2, player) <= 3;
});
"step 1";
if (result.bool) {
if (!event.repeat) {
if (!_status.changedSkills[player.playerid])
_status.changedSkills[player.playerid] = [];
_status.changedSkills[player.playerid].add(event.skill);
}
player.changeVice(event.hidden);
}
},
zhulian: function () {
player.popup("珠联璧合");
if (!player.hasMark("zhulianbihe_mark")) player.addMark("zhulianbihe_mark", 1);
},
},
player: {
getGuozhanGroup: function (num) {
if (this.trueIdentity) {
if (lib.character[this.name1][1] != "ye" || num == 1) return this.trueIdentity;
return "ye";
}
if (get.is.double(this.name2)) return lib.character[this.name1][1];
if (num == 1) return lib.character[this.name2][1];
return lib.character[this.name1][1];
},
chooseJunlingFor: function (target) {
var next = game.createEvent("chooseJunlingFor");
next.player = this;
next.target = target;
next.num = 2;
next.setContent("chooseJunlingFor");
return next;
},
chooseJunlingControl: function (source, junling, targets) {
var next = game.createEvent("chooseJunlingControl");
next.player = this;
next.source = source;
next.junling = junling;
if (targets.length) next.targets = targets;
next.setContent("chooseJunlingControl");
return next;
},
carryOutJunling: function (source, junling, targets) {
var next = game.createEvent("carryOutJunling");
next.source = source;
next.player = this;
if (targets.length) next.targets = targets;
next.junling = junling;
next.setContent("carryOutJunling");
return next;
},
/**/
mayChangeVice: function (repeat, hidden) {
if (!_status.changedSkills) _status.changedSkills = {};
var skill = _status.event.name;
if (
repeat ||
!_status.changedSkills[this.playerid] ||
!_status.changedSkills[this.playerid].includes(skill)
) {
var next = game.createEvent("mayChangeVice");
next.setContent("mayChangeVice");
next.player = this;
next.skill = skill;
if (repeat || (!_status.connectMode && get.config("changeViceType") == "online"))
next.repeat = true;
if (hidden == "hidden") next.hidden = true;
return next;
}
},
differentIdentityFrom: function (target, self) {
if (this == target) return false;
if (this.getStorage("yexinjia_friend").includes(target)) return false;
if (target.getStorage("yexinjia_friend").includes(this)) return false;
if (self) {
if (target.identity == "unknown") return false;
if (target.identity == "ye" || this.identity == "ye") return true;
if (this.identity == "unknown") {
var identity = lib.character[this.name1][1];
if (this.wontYe()) return identity != target.identity;
return true;
}
} else {
if (this.identity == "unknown" || target.identity == "unknown") return false;
if (this.identity == "ye" || target.identity == "ye") return true;
}
return this.identity != target.identity;
},
sameIdentityAs: function (target, shown) {
if (this.getStorage("yexinjia_friend").includes(target)) return true;
if (target.getStorage("yexinjia_friend").includes(this)) return true;
if (shown) {
if (this.identity == "ye" || this.identity == "unknown") return false;
} else {
if (this == target) return true;
if (target.identity == "unknown" || target.identity == "ye" || this.identity == "ye")
return false;
if (this.identity == "unknown") {
var identity = lib.character[this.name1][1];
if (this.wontYe()) return identity == target.identity;
return false;
}
}
return this.identity == target.identity;
},
getModeState: function () {
return {
unseen: this.isUnseen(0),
unseen2: this.isUnseen(1),
};
},
setModeState: function (info) {
if (info.mode.unseen) this.classList.add("unseen");
if (info.mode.unseen2) this.classList.add("unseen2");
if (!info.name) return;
// if(info.name.indexOf('unknown')==0){
// if(this==game.me){
// lib.translate[info.name]+='（你）';
// }
// }
this.init(info.name1, info.name2, false);
this.name1 = info.name1;
this.name = info.name;
this.node.name_seat = ui.create.div(
".name.name_seat",
get.verticalStr(lib.translate[this.name].slice(0, 3)),
this
);
if (info.identityShown) {
this.setIdentity(info.identity);
this.node.identity.classList.remove("guessing");
} else if (this != game.me) {
this.node.identity.firstChild.innerHTML = "猜";
this.node.identity.dataset.color = "unknown";
this.node.identity.classList.add("guessing");
}
},
dieAfter2: function (source) {
var that = this;
if (that.hasSkillTag("noDieAfter", null, source)) return;
if (source && source.hasSkillTag("noDieAfter2", null, that)) return;
if (source && source.shijun) {
source.discard(source.getCards("he"));
delete source.shijun;
} else if (source && source.identity != "unknown") {
if (source.identity == "ye" && !source.getStorage("yexinjia_friend").length)
source.draw(3);
else if (source.shijun2) {
delete source.shijun2;
source.draw(
1 +
game.countPlayer(function (current) {
return current.group == that.group;
})
);
} else if (that.identity == "ye") {
if (
that.getStorage("yexinjia_friend").includes(source) ||
source.getStorage("yexinjia_friend").includes(that)
)
source.discard(source.getCards("he"));
else
source.draw(
1 +
game.countPlayer(function (current) {
if (current == that) return false;
if (current.getStorage("yexinjia_friend").includes(that))
return true;
if (that.getStorage("yexinjia_friend").includes(current))
return true;
return false;
})
);
} else if (that.identity != source.identity)
source.draw(get.population(that.identity) + 1);
else source.discard(source.getCards("he"));
}
},
dieAfter: function (source) {
this.showCharacter(2);
if (get.is.jun(this.name1)) {
if (source && source.identity == this.identity) source.shijun = true;
else if (source && source.identity != "ye") source.shijun2 = true;
var yelist = [];
for (var i = 0; i < game.players.length; i++) {
if (game.players[i].identity == this.identity) {
yelist.push(game.players[i]);
}
}
game.broadcastAll(function (list) {
for (var i = 0; i < list.length; i++) {
list[i].identity = "ye";
list[i].setIdentity();
}
}, yelist);
_status.yeidentity.add(this.identity);
}
game.tryResult();
},
viewCharacter: function (target, num) {
if (num != 0 && num != 1) {
num = 2;
}
if (!target.isUnseen(num)) {
return;
}
var next = game.createEvent("viewCharacter");
next.player = this;
next.target = target;
next.num = num;
next.setContent(function () {
if (!player.storage.zhibi) {
player.storage.zhibi = [];
}
player.storage.zhibi.add(target);
var content,
str = get.translation(target) + "的";
if (event.num == 0 || !target.isUnseen(1)) {
content = [str + "主将", [[target.name1], "character"]];
game.log(player, "观看了", target, "的主将");
} else if (event.num == 1 || !target.isUnseen(0)) {
content = [str + "副将", [[target.name2], "character"]];
game.log(player, "观看了", target, "的副将");
} else {
content = [str + "主将和副将", [[target.name1, target.name2], "character"]];
game.log(player, "观看了", target, "的主将和副将");
}
player.chooseControl("ok").set("dialog", content);
});
},
checkViceSkill: function (skill, disable) {
if (game.expandSkills(lib.character[this.name2][3].slice(0)).includes(skill)) {
return true;
} else {
if (disable !== false) {
this.awakenSkill(skill);
}
return false;
}
},
checkMainSkill: function (skill, disable) {
if (game.expandSkills(lib.character[this.name1][3].slice(0)).includes(skill)) {
return true;
} else {
if (disable !== false) {
this.awakenSkill(skill);
}
return false;
}
},
removeMaxHp: function (num) {
if (game.online) return;
if (!num) num = 1;
while (num > 0) {
num--;
if (typeof this.singleHp == "boolean") {
if (this.singleHp) {
this.singleHp = false;
} else {
this.singleHp = true;
this.maxHp--;
}
} else {
this.maxHp--;
}
}
this.update();
},
hideCharacter: function (num, log) {
if (this.isUnseen(2)) return;
var name = this["name" + (num + 1)];
var next = game.createEvent("hideCharacter");
next.player = this;
next.toHide = name;
next.num = num;
next.log = log;
next.setContent("hideCharacter");
return next;
},
removeCharacter: function (num) {
var name = this["name" + (num + 1)];
var next = game.createEvent("removeCharacter");
next.player = this;
next.toRemove = name;
next.num = num;
next.setContent("removeCharacter");
return next;
},
$removeCharacter: function (num) {
var name = this["name" + (num + 1)];
var info = lib.character[name];
if (!info) return;
var to = "gz_shibing" + (info[0] == "male" ? 1 : 2) + info[1];
game.log(this, "移除了" + (num ? "副将" : "主将"), "#b" + name);
this.reinit(name, to, false);
this.showCharacter(num, false);
_status.characterlist.add(name);
},
changeVice: function (hidden) {
var next = game.createEvent("changeVice");
next.player = this;
next.setContent("changeVice");
next.num = !_status.connectMode && get.config("changeViceType") == "online" ? 1 : 3;
if (hidden) next.hidden = true;
return next;
},
hasMainCharacter: function () {
return this.name1.indexOf("gz_shibing") != 0;
},
hasViceCharacter: function () {
return this.name2.indexOf("gz_shibing") != 0;
},
$showCharacter: function (num, log) {
var showYe = false;
if (num == 0 && !this.isUnseen(0)) {
return;
}
if (num == 1 && !this.isUnseen(1)) {
return;
}
if (!this.isUnseen(2)) {
return;
}
game.addVideo("showCharacter", this, num);
if (
this.identity == "unknown" ||
((num == 0 || num == 2) && lib.character[this.name1][1] == "ye")
) {
this.group = this.getGuozhanGroup(num);
if ((num == 0 || num == 2) && lib.character[this.name1][1] == "ye") {
this.identity = "ye";
if (!this._ye) {
this._ye = true;
showYe = true;
}
} else if (get.is.jun(this.name1) && this.isAlive()) {
this.identity = this.group;
} else if (this.wontYe(this.group)) {
this.identity = this.group;
} else {
this.identity = "ye";
}
this.setIdentity(this.identity);
this.ai.shown = 1;
this.node.identity.classList.remove("guessing");
if (_status.clickingidentity && _status.clickingidentity[0] == this) {
for (var i = 0; i < _status.clickingidentity[1].length; i++) {
_status.clickingidentity[1][i].delete();
_status.clickingidentity[1][i].style.transform = "";
}
delete _status.clickingidentity;
}
game.addVideo("setIdentity", this, this.identity);
}
var skills;
switch (num) {
case 0:
if (log !== false) game.log(this, "展示了主将", "#b" + this.name1);
this.name = this.name1;
skills = lib.character[this.name][3];
this.sex = lib.character[this.name][0];
this.classList.remove("unseen");
break;
case 1:
if (log !== false) game.log(this, "展示了副将", "#b" + this.name2);
skills = lib.character[this.name2][3];
if (this.sex == "unknown") this.sex = lib.character[this.name2][0];
if (this.name.indexOf("unknown") == 0) this.name = this.name2;
this.classList.remove("unseen2");
break;
case 2:
if (log !== false)
game.log(this, "展示了主将", "#b" + this.name1, "、副将", "#b" + this.name2);
this.name = this.name1;
skills = lib.character[this.name][3].concat(lib.character[this.name2][3]);
this.sex = lib.character[this.name][0];
this.classList.remove("unseen");
this.classList.remove("unseen2");
break;
}
game.broadcast(
function (player, name, sex, num, identity, group) {
player.identityShown = true;
player.group = group;
player.name = name;
player.sex = sex;
player.node.identity.classList.remove("guessing");
switch (num) {
case 0:
player.classList.remove("unseen");
break;
case 1:
player.classList.remove("unseen2");
break;
case 2:
player.classList.remove("unseen");
player.classList.remove("unseen2");
break;
}
player.ai.shown = 1;
player.identity = identity;
player.setIdentity(identity);
if (_status.clickingidentity && _status.clickingidentity[0] == player) {
for (var i = 0; i < _status.clickingidentity[1].length; i++) {
_status.clickingidentity[1][i].delete();
_status.clickingidentity[1][i].style.transform = "";
}
delete _status.clickingidentity;
}
},
this,
this.name,
this.sex,
num,
this.identity,
this.group
);
this.identityShown = true;
for (var i = 0; i < skills.length; i++) {
this.hiddenSkills.remove(skills[i]);
this.addSkill(skills[i]);
}
this.checkConflict();
if (!this.viceChanged) {
var initdraw = get.config("initshow_draw");
if (_status.connectMode) initdraw = lib.configOL.initshow_draw;
if (
!_status.initshown &&
!_status.overing &&
initdraw != "off" &&
this.isAlive() &&
_status.mode != "mingjiang"
) {
this.popup("首亮");
if (initdraw == "draw") {
game.log(this, "首先明置武将，得到奖励");
game.log(this, "摸了两张牌");
this.draw(2).log = false;
} else {
this.addMark("xianqu_mark", 1);
}
_status.initshown = true;
}
if (!this.isUnseen(2) && !this._mingzhied) {
this._mingzhied = true;
if (this.singleHp) {
this.doubleDraw();
}
if (this.perfectPair()) {
var next = game.createEvent("guozhanDraw");
next.player = this;
next.setContent("zhulian");
}
}
if (showYe) {
this.addMark("yexinjia_mark", 1);
}
}
game.tryResult();
},
wontYe: function (group, numOfReadyToShow) {
if (!group) {
if (this.trueIdentity) group = this.trueIdentity;
else group = lib.character[this.name1][1];
}
if (_status.yeidentity && _status.yeidentity.includes(group)) return false;
if (get.zhu(this, null, group)) return true;
if (!numOfReadyToShow) numOfReadyToShow = 1;
return (
get.totalPopulation(group) + numOfReadyToShow <=
(_status.separatism ? Math.max(get.population() / 2 - 1, 1) : get.population() / 2)
);
},
perfectPair: function (choosing) {
if (_status.connectMode) {
if (!lib.configOL.zhulian) return false;
} else {
if (!get.config("zhulian")) return false;
}
var name1 = this.name1;
var name2 = this.name2;
if (name1.indexOf("gz_shibing") == 0) return false;
if (name2.indexOf("gz_shibing") == 0) return false;
if (get.is.jun(this.name1)) return true;
if (
choosing &&
lib.character[name1][1] != "ye" &&
lib.character[name2][1] != "ye" &&
lib.character[name1][1] != lib.character[name2][1]
)
return false;
if (name1.indexOf("gz_") == 0) {
name1 = name1.slice(name1.indexOf("_") + 1);
} else {
while (name1.indexOf("_") != -1 && !lib.perfectPair[name1]) {
name1 = name1.slice(name1.indexOf("_") + 1);
}
}
if (name2.indexOf("gz_") == 0) {
name2 = name2.slice(name2.indexOf("_") + 1);
} else {
while (name2.indexOf("_") != -1 && !lib.perfectPair[name2]) {
name2 = name2.slice(name2.indexOf("_") + 1);
}
}
var list = Object.keys(lib.perfectPair).concat(Object.values(lib.perfectPair)).flat();
if (!list.includes(name1) || !list.includes(name2)) return false;
return (
(lib.perfectPair[name1] && lib.perfectPair[name1].flat(Infinity).includes(name2)) ||
(lib.perfectPair[name2] && lib.perfectPair[name2].flat(Infinity).includes(name1))
);
},
siege: function (player) {
if (this.identity == "unknown" || this.hasSkill("undist")) return false;
if (!player) {
var next = this.getNext();
if (next && next.sieged()) return true;
var previous = this.getPrevious();
if (previous && previous.sieged()) return true;
return false;
} else {
return player.sieged() && (player.getNext() == this || player.getPrevious() == this);
}
},
sieged: function (player) {
if (this.identity == "unknown") return false;
if (player) {
return player.siege(this);
} else {
var next = this.getNext();
var previous = this.getPrevious();
if (next && previous && next != previous) {
if (next.identity == "unknown" || next.isFriendOf(this)) return false;
return next.isFriendOf(previous);
}
return false;
}
},
inline: function () {
if (this.identity == "unknown" || this.identity == "ye" || this.hasSkill("undist"))
return false;
var next = this,
previous = this;
var list = [];
for (var i = 0; next || previous; i++) {
if (next) {
next = next.getNext();
if (!next.isFriendOf(this) || next == this) {
next = null;
} else {
list.add(next);
}
}
if (previous) {
previous = previous.getPrevious();
if (!previous.isFriendOf(this) || previous == this) {
previous = null;
} else {
list.add(previous);
}
}
}
if (!list.length) return false;
for (var i = 0; i < arguments.length; i++) {
if (!list.includes(arguments[i]) && arguments[i] != this) return false;
}
return true;
},
isMajor: function () {
if (this.identity == "unknown") return false;
var list = game.filterPlayer(function (current) {
return current.identity != "unknown" && current.hasSkillTag("forceMajor");
});
if (list.length) {
for (var i of list) {
if (i.isFriendOf(this)) return true;
}
return false;
}
var map = {},
sides = [],
pmap = _status.connectMode ? lib.playerOL : game.playerMap,
player;
for (var i of game.players) {
if (i.identity == "unknown") continue;
var added = false;
for (var j of sides) {
if (i.isFriendOf(pmap[j])) {
added = true;
map[j].push(i);
if (i == this) player = j;
break;
}
}
if (!added) {
map[i.playerid] = [i];
sides.push(i.playerid);
if (i == this) player = i.playerid;
}
}
if (!player || map[player].length < 2) return false;
for (var i in map) {
if (map[i].length > map[player].length) return false;
}
return true;
},
isNotMajor: function () {
for (var i = 0; i < game.players.length; i++) {
if (game.players[i].isMajor()) {
return !this.isMajor();
}
}
return false;
},
isMinor: function (nomajor) {
if (this.identity == "unknown" || (!nomajor && this.isMajor())) return false;
if (
!nomajor &&
!game.hasPlayer(function (current) {
return current.isMajor();
})
) {
return false;
}
var map = {},
sides = [],
pmap = _status.connectMode ? lib.playerOL : game.playerMap,
player;
for (var i of game.players) {
if (i.identity == "unknown") continue;
var added = false;
for (var j of sides) {
if (i.isFriendOf(pmap[j])) {
added = true;
map[j].push(i);
if (i == this) player = j;
break;
}
}
if (!added) {
map[i.playerid] = [i];
sides.push(i.playerid);
if (i == this) player = i.playerid;
}
}
for (var i in map) {
if (map[i].length < map[player].length) return false;
}
return true;
},
logAi: function (targets, card) {
if (this.ai.shown == 1 || this.isMad()) return;
if (typeof targets == "number") {
this.ai.shown += targets;
} else {
var effect = 0,
c,
shown;
var info = get.info(card);
if (info.ai && info.ai.expose) {
if (_status.event.name == "_wuxie") {
if (_status.event.source && _status.event.source.ai.shown) {
this.ai.shown += 0.2;
}
} else {
this.ai.shown += info.ai.expose;
}
}
if (targets.length > 0) {
for (var i = 0; i < targets.length; i++) {
shown = Math.abs(targets[i].ai.shown);
if (shown < 0.2 || targets[i].identity == "nei") c = 0;
else if (shown < 0.4) c = 0.5;
else if (shown < 0.6) c = 0.8;
else c = 1;
effect += get.effect(targets[i], card, this) * c;
}
}
if (effect > 0) {
if (effect < 1) c = 0.5;
else c = 1;
if (targets.length == 1 && targets[0] == this);
else if (targets.length == 1) this.ai.shown += 0.2 * c;
else this.ai.shown += 0.1 * c;
}
}
if (this.ai.shown > 0.95) this.ai.shown = 0.95;
if (this.ai.shown < -0.5) this.ai.shown = -0.5;
},
},
},
get: {
guozhanReverse: function (name1, name2) {
if (get.is.double(name2)) return false;
if (["gz_xunyou", "gz_lvfan", "gz_liubei"].includes(name2)) return true;
if (name1 == "gz_re_xushu") return true;
if (name2 == "gz_dengai") return lib.character[name1][2] % 2 == 1;
if (["gz_sunce", "gz_jiangwei"].includes(name1))
return name2 == "gz_zhoutai" || lib.character[name2][2] % 2 == 1;
return false;
},
guozhanRank: function (name, player) {
if (name.indexOf("gz_shibing") == 0) return -1;
if (name.indexOf("gz_jun_") == 0) return 7;
if (player) {
var skills = lib.character[name][3].slice(0);
for (var i = 0; i < skills.length; i++) {
if (lib.skill[skills[i]].limited && player.awakenedSkills.includes(skills[i]))
return skills.length - 1;
}
}
if (_status._aozhan) {
for (var i in lib.aozhanRank) {
if (lib.aozhanRank[i].includes(name)) return parseInt(i);
}
}
for (var i in lib.guozhanRank) {
if (lib.guozhanRank[i].includes(name)) return parseInt(i);
}
return 0;
},
junlingEffect: function (source, junling, performer, targets, viewer) {
var att1 = get.attitude(viewer, source),
att2 = get.attitude(viewer, performer);
var eff1 = 0,
eff2 = 0;
switch (junling) {
case "junling1":
if (
!targets.length &&
game.countPlayer(function (current) {
return get.damageEffect(viewer, current, viewer) > 0;
})
)
eff1 = 2;
else {
if (get.damageEffect(targets[0], performer, source) >= 0) eff1 = 2;
else eff1 = -2;
if (get.damageEffect(targets[0], source, performer) >= 0) eff2 = 2;
else eff2 = -2;
}
break;
case "junling2":
if (performer.countCards("he")) {
eff1 = 1;
eff2 = 0;
} else {
eff1 = 2;
eff2 = -1;
}
break;
case "junling3":
if (performer.hp == 1 && !performer.hasSkillTag("save", true)) eff2 = -5;
else {
if (performer == viewer) {
if (performer.hasSkillTag("maihp", true)) eff2 = 3;
else eff2 = -2;
} else {
if (performer.hasSkillTag("maihp", false)) eff2 = 3;
else eff2 = -2;
}
}
break;
case "junling4":
eff1 = 0;
eff2 = -2;
break;
case "junling5":
var td = performer.isTurnedOver();
if (td) {
if (performer == viewer) {
if (_status.currentPhase == performer && performer.hasSkill("jushou"))
eff2 = -3;
else eff2 = 3;
} else eff2 = 3;
} else {
if (performer == viewer) {
if (performer.hasSkillTag("noturn", true)) eff2 = 0;
else eff2 = -3;
} else {
if (performer.hasSkillTag("noturn", false)) eff2 = 0;
else eff2 = -3;
}
}
break;
case "junling6":
if (performer.countCards("h") > 1) eff2 += 1 - performer.countCards("h");
if (performer.countCards("e") > 1) eff2 += 1 - performer.countCards("e");
break;
}
return Math.sign(att1) * eff1 + Math.sign(att2) * eff2;
},
realAttitude: function (from, to, difficulty, toidentity) {
var getIdentity = function (player) {
if (player.isUnseen()) {
if (!player.wontYe()) return "ye";
return player.getGuozhanGroup(0);
}
return player.identity;
};
var fid = getIdentity(from);
if (fid == toidentity && toidentity != "ye") {
return 4 + difficulty;
}
if (from.identity == "unknown" && fid == toidentity) {
if (from.wontYe()) return 4 + difficulty;
}
var groups = [];
var map = {},
sides = [],
pmap = _status.connectMode ? lib.playerOL : game.playerMap,
player;
for (var i of game.players) {
if (i.identity == "unknown") continue;
var added = false;
for (var j of sides) {
if (i.isFriendOf(pmap[j])) {
added = true;
map[j].push(i);
if (i == this) player = j;
break;
}
}
if (!added) {
map[i.playerid] = [i];
sides.push(i.playerid);
if (i == this) player = i.playerid;
}
}
for (var i in map) {
var num = map[i].length;
groups.push(num);
}
var max = Math.max.apply(this, groups);
if (max <= 1) return -3;
var from_p;
if (from.identity == "unknown" && from.wontYe()) from_p = get.population(fid);
else
from_p = game.countPlayer(function (current) {
return current.isFriendOf(from);
});
var to_p = game.countPlayer(function (current) {
return current.isFriendOf(to);
});
if (to.identity == "ye") to_p += 1.5;
if (to_p >= max) return -5;
if (from_p >= max) return -2 - to_p;
if (max >= game.players.length / 2) {
if (to_p <= from_p) {
return 0.5;
}
return 0;
}
if (to_p < max - 1) return 0;
return -0.5;
},
rawAttitude: function (from, to) {
var getIdentity = function (player) {
if (player.isUnseen()) {
if (!player.wontYe()) return "ye";
return player.getGuozhanGroup(0);
}
return player.identity;
};
var fid = getIdentity(from),
tid = getIdentity(to);
if (to.identity == "unknown" && game.players.length == 2) return -5;
if (
_status.currentPhase == from &&
from.ai.tempIgnore &&
from.ai.tempIgnore.includes(to) &&
to.identity == "unknown" &&
(!from.storage.zhibi || !from.storage.zhibi.includes(to))
)
return 0;
var difficulty = 0;
if (to == game.me) difficulty = (2 - get.difficulty()) * 1.5;
if (from == to) return 5 + difficulty;
if (from.isFriendOf(to)) return 5 + difficulty;
if (from.identity == "unknown" && fid == to.identity) {
if (from.wontYe()) return 4 + difficulty;
}
var att = get.realAttitude(from, to, difficulty, tid);
if (from.storage.zhibi && from.storage.zhibi.includes(to)) {
return att;
}
if (to.ai.shown >= 0.5) return att * to.ai.shown;
var nshown = 0;
for (var i = 0; i < game.players.length; i++) {
if (game.players[i] != from && game.players[i].identity == "unknown") {
nshown++;
}
}
if (to.ai.shown == 0) {
if (nshown >= game.players.length / 2 && att >= 0) {
return 0;
}
return Math.min(0, Math.random() - 0.5) + difficulty;
}
if (to.ai.shown >= 0.2) {
if (att > 2) {
return Math.max(0, Math.random() - 0.5) + difficulty;
}
if (att >= 0) {
return 0;
}
return Math.min(0, Math.random() - 0.7) + difficulty;
}
if (att > 2) {
return Math.max(0, Math.random() - 0.7) + difficulty;
}
if (att >= 0) {
return Math.min(0, Math.random() - 0.3) + difficulty;
}
return Math.min(0, Math.random() - 0.5) + difficulty;
},
},
help: {
国战模式:
'声明
- 以下所有规则均为根据公开爆料整理，经村规改动后制定的临时规则。不代表任何官方意见。请以后续发布的官方规则作为标准。
' +
'双势力武将
- 双势力武将牌可以和野心家武将牌/包含势力单武将牌/含有重叠势力的其他双势力武将牌组合，若你的主将为双势力武将，则：若你的副将为单势力武将牌，你的势力视为此势力；若你的副将为双势力武将，你的势力视为两张武将牌上的重叠势力（若重叠势力不止一个则需在游戏开始时选择一个作为自己的势力）；野心家武将牌为主将，双势力武将牌为副将时，游戏开始时需选择一个副将所含势力作为副将的势力。
- 变更副将时，可以选择包含原势力的双势力武将牌。左慈发动〖役鬼〗时，可以使用双势力武将牌同时指定两个不同势力的角色为目标。
- 特殊地，“冈崎汐”作为多势力武将牌，结算流程和规则与其他双势力武将相同。
' +
'野心家武将
- 野心家武将只能放在主将位置。副将可以为任意非野心家武将牌。
- 选择了野心家武将牌的角色（以下简称“野心家角色”）仅明置副将时，若副将为单势力武将牌，则势力暂时视为与该武将牌相同。若副将为双势力武将牌，则势力视为游戏开始时选择的副将代表的势力。
- 野心家角色明置主将时，其势力改为野心家。若其是首次明置该武将牌，则其获得一个“野心家”标记。
- “野心家”标记可以当做“先驱”标记，“阴阳鱼”标记或是“珠联璧合”标记使用。当同时拥有两种标记时，优先弃置原装标记，下次发动时才弃置“野心家”标记。
- 野心家角色变更副将时，若其主将未明置过，则按照副将的势力进行变更。若主将已经明置过，则可以选择所有的非野心家武将牌。左慈发动〖役鬼〗时，可以使用野心家武将牌同时指定所有势力的角色为目标。' +
"
- 当场上触发了胜利条件时，若这些角色中存在未明置过主将的野心家角色，则这些野心家角色选择是否“暴露野心”。若无人选择“是”且场上存在非野心家角色存活，则所有非野心家角色胜利，野心家角色失败。若有人选择“是”，则这些角色明置主将，然后选择是否发起“拉拢人心”。
- 选择发起“拉拢人心”的野心家角色选择一个新的势力作为自己的势力，弃置“野心家”标记，令所有其他非野心家角色且非君主且非已“结盟”角色依次选择是否和该野心家角色“结盟”。选择“是”的角色将势力改为和该野心家势力相同。此次“拉拢人心”对所有其他角色询问结束后，所有选择“否”的角色将手牌摸至四张并回复1点体力。
" +
'纵横捭阖
- 当一名角色对目标角色发动具有拥有“纵横”衍生技的技能时，其可以令对方获得“纵横”衍生技直到其下回合结束。
',
},
};
});