pref: format @/character.

character/jiange.js

@@ -1,30 +1,30 @@
-import { lib, game, ui, get, ai, _status } from '../noname.js';
-game.import('character', function () {
+import { lib, game, ui, get, ai, _status } from "../noname.js";
+game.import("character", function () {
 	return {
-		name:'jiange',
+		name: "jiange",
 		character: {
-			jg_pangtong:['male','shu',3,['qiwu','tianyu']],
-			jg_huangyueying:['female','shu',3,['zhinang','jingmiao']],
-			jg_zhugeliang:['male','shu',3,['biantian','bazhen']],
-			jg_liubei:['male','shu',4,['jizhen','lingfeng']],
-			jg_xiahouyuan:['male','wei',4,['xinshensu','juechen']],
-			jg_caozhen:['male','wei',4,['chiying','jingfan']],
-			jg_zhanghe:['male','wei',4,['huodi','jueji']],
-			jg_simayi:['male','wei',5,['xuanlei','sfanshi','konghun']],
+			jg_pangtong: ["male", "shu", 3, ["qiwu", "tianyu"]],
+			jg_huangyueying: ["female", "shu", 3, ["zhinang", "jingmiao"]],
+			jg_zhugeliang: ["male", "shu", 3, ["biantian", "bazhen"]],
+			jg_liubei: ["male", "shu", 4, ["jizhen", "lingfeng"]],
+			jg_xiahouyuan: ["male", "wei", 4, ["xinshensu", "juechen"]],
+			jg_caozhen: ["male", "wei", 4, ["chiying", "jingfan"]],
+			jg_zhanghe: ["male", "wei", 4, ["huodi", "jueji"]],
+			jg_simayi: ["male", "wei", 5, ["xuanlei", "sfanshi", "konghun"]],
 		},
 		skill: {
 			sfanshi: {
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				forced: true,
 				check: function () {
 					return false;
 				},
 				content: function () {
 					player.loseHp();
-				}
+				},
 			},
 			konghun: {
-				trigger:{player:'phaseUseBegin'},
+				trigger: { player: "phaseUseBegin" },
 				direct: true,
 				filter: function (event, player) {
 					if (game.players.length >= 6) {
@@ -33,147 +33,165 @@ game.import('character', function () {
 					return player.hp <= 1;
 				},
 				content: function () {
-					"step 0"
-					player.chooseTarget(get.prompt('konghun'),function(card,player,target){
+					"step 0";
+					player.chooseTarget(
+						get.prompt("konghun"),
+						function (card, player, target) {
 							return player != target;
-					},[1,Math.min(4,Math.floor((game.players.length-1)/2))]).ai=function(target){
-						return get.damageEffect(target,player,player,'thunder')+1;
-					}
-					"step 1"
+						},
+						[1, Math.min(4, Math.floor((game.players.length - 1) / 2))]
+					).ai = function (target) {
+						return get.damageEffect(target, player, player, "thunder") + 1;
+					};
+					("step 1");
 					if (result.bool) {
 						event.targets = result.targets.slice(0);
-						player.logSkill('konghun',event.targets,'thunder');
+						player.logSkill("konghun", event.targets, "thunder");
 						event.targets.sort(lib.sort.seat);
 						event.num = 0;
-					}
-					else{
+					} else {
 						event.finish();
 					}
-					"step 2"
+					("step 2");
 					if (event.num < event.targets.length) {
-						event.targets[event.num].damage('thunder');
+						event.targets[event.num].damage("thunder");
 						event.num++;
 						event.redo();
 					}
-					"step 3"
+					("step 3");
 					player.recover(event.targets.length);
-				}
+				},
 			},
 			xuanlei: {
-				trigger:{player:'phaseBegin'},
+				trigger: { player: "phaseBegin" },
 				forced: true,
 				filter: function (event, player) {
 					for (var i = 0; i < game.players.length; i++) {
-						if(game.players[i]!=player&&game.players[i].countCards('j')) return true;
+						if (game.players[i] != player && game.players[i].countCards("j")) return true;
 					}
 					return false;
 				},
 				content: function () {
-					"step 0"
+					"step 0";
 					event.targets = [];
 					for (var i = 0; i < game.players.length; i++) {
-						if(game.players[i]!=player&&game.players[i].countCards('j')){
+						if (game.players[i] != player && game.players[i].countCards("j")) {
 							event.targets.push(game.players[i]);
 						}
 					}
 					event.targets.sort(lib.sort.seat);
-					"step 1"
+					("step 1");
 					if (event.targets.length) {
-						event.targets.shift().damage('thunder');
+						event.targets.shift().damage("thunder");
 						event.redo();
 					}
-				}
+				},
 			},
 			jueji: {
-				trigger:{global:'phaseDrawBegin'},
+				trigger: { global: "phaseDrawBegin" },
 				direct: true,
 				filter: function (event, player) {
-					return event.num>0&&event.player!=player&&event.player.hp<event.player.maxHp&&player.countCards('he');
+					return (
+						event.num > 0 &&
+						event.player != player &&
+						event.player.hp < event.player.maxHp &&
+						player.countCards("he")
+					);
 				},
 				content: function () {
-					"step 0"
-					var next=player.chooseToDiscard('he','是否弃置一张牌令'+get.translation(trigger.player)+'的摸牌数-1？');
+					"step 0";
+					var next = player.chooseToDiscard(
+						"he",
+						"是否弃置一张牌令" + get.translation(trigger.player) + "的摸牌数-1？"
+					);
 					next.ai = function (card) {
 						if (get.attitude(player, trigger.player) < 0) {
 							return 6 - get.value(card);
 						}
 						return 0;
-					}
-					next.logSkill=['jueji',trigger.player];
-					"step 1"
+					};
+					next.logSkill = ["jueji", trigger.player];
+					("step 1");
 					if (result.bool) {
 						trigger.num--;
 					}
 				},
 				ai: {
 					expose: 0.2,
-					threaten:1.8
-				}
+					threaten: 1.8,
+				},
 			},
 			huodi: {
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				direct: true,
 				filter: function (event, player) {
-					return !player.hasSkill('huodi3');
+					return !player.hasSkill("huodi3");
 				},
 				content: function () {
-					"step 0"
-					player.chooseTarget(get.prompt('huodi'),function(card,player,target){
-						return target.countCards('he')&&player!=target;
+					"step 0";
+					player.chooseTarget(get.prompt("huodi"), function (card, player, target) {
+						return target.countCards("he") && player != target;
 					}).ai = function (target) {
 						return -get.attitude(player, target);
-					}
-					"step 1"
+					};
+					("step 1");
 					if (result.bool) {
-						player.logSkill('huodi',result.targets);
-						player.discardPlayerCard(result.targets[0],true,'he');
+						player.logSkill("huodi", result.targets);
+						player.discardPlayerCard(result.targets[0], true, "he");
 					}
 				},
 				ai: {
 					expose: 0.2,
-					threaten:1.2
+					threaten: 1.2,
 				},
-				group:'huodi2'
+				group: "huodi2",
 			},
 			huodi2: {
-				trigger:{player:'useCard'},
+				trigger: { player: "useCard" },
 				filter: function (event, player) {
-					return _status.currentPhase==player&&event.targets&&(event.targets.length>1||event.targets[0]!=player);
+					return (
+						_status.currentPhase == player &&
+						event.targets &&
+						(event.targets.length > 1 || event.targets[0] != player)
+					);
 				},
 				silent: true,
 				content: function () {
-					player.addTempSkill('huodi3');
-				}
+					player.addTempSkill("huodi3");
+				},
 			},
 			huodi3: {},
 			jingfan: {
-				trigger:{player:'phaseUseEnd'},
+				trigger: { player: "phaseUseEnd" },
 				unique: true,
 				direct: true,
 				content: function () {
-					"step 0"
-					var num=player.countUsed()-player.countCards('h');
+					"step 0";
+					var num = player.countUsed() - player.countCards("h");
 					event.num = num;
 					if (num > 0) {
 						player.draw(num);
 					}
-					"step 1"
+					("step 1");
 					if (event.num > 0) {
-						player.chooseTarget('选择至多'+get.cnNumber(event.num)+'名角色令其进攻距离+1',[1,event.num],function(card,player,target){
+						player.chooseTarget(
+							"选择至多" + get.cnNumber(event.num) + "名角色令其进攻距离+1",
+							[1, event.num],
+							function (card, player, target) {
 								return player != target;
-						}).ai=function(target){
+							}
+						).ai = function (target) {
 							return get.attitude(player, target);
-						}
-					}
-					else{
+						};
+					} else {
 						event.finish();
 					}
-					"step 2"
+					("step 2");
 					if (result.bool && result.targets) {
-						player.logSkill('jingfan',result.targets);
+						player.logSkill("jingfan", result.targets);
 						for (var i = 0; i < result.targets.length; i++) {
-							result.targets[i].addSkill('jingfan2');
-							result.targets[i].popup('jingfan');
+							result.targets[i].addSkill("jingfan2");
+							result.targets[i].popup("jingfan");
 						}
 					}
 				},
@@ -182,26 +200,26 @@ game.import('character', function () {
 						if (_status.currentPhase == from) {
 							return distance - from.countUsed();
 						}
-					}
+					},
 				},
 				ai: {
-					expose:0.1
-				}
+					expose: 0.1,
+				},
 			},
 			jingfan2: {
 				mod: {
 					globalFrom: function (from, to, distance) {
 						return distance - 1;
-					}
 					},
-				trigger:{player:'phaseEnd'},
+				},
+				trigger: { player: "phaseEnd" },
 				forced: true,
 				content: function () {
-					player.removeSkill('jingfan2');
-				}
+					player.removeSkill("jingfan2");
+				},
 			},
 			chiying: {
-				trigger:{global:'damageBegin2'},
+				trigger: { global: "damageBegin2" },
 				check: function (event, player) {
 					return get.attitude(player, event.player) > 0;
 				},
@@ -212,40 +230,46 @@ game.import('character', function () {
 				content: function () {
 					trigger.num = 1;
 					if (trigger.source) {
-						trigger.source.addTempSkill('chiying2','damageAfter');
-					}
+						trigger.source.addTempSkill("chiying2", "damageAfter");
 					}
 				},
+			},
 			chiying2: {
-				trigger:{source:'damageEnd'},
+				trigger: { source: "damageEnd" },
 				forced: true,
 				popup: false,
 				content: function () {
 					player.draw();
-				}
+				},
 			},
 			juechen: {
-				trigger:{player:'useCard'},
+				trigger: { player: "useCard" },
 				filter: function (event, player) {
-					return event.card.name=='sha';
+					return event.card.name == "sha";
 				},
 				direct: true,
 				content: function () {
-					"step 0"
-					player.chooseTarget(get.prompt('juechen'),function(card,player,target){
-						return player!=target&&!trigger.targets.includes(target)&&target.countCards('he')>0;
-					}).set('autodelay',true).ai=function(target){
+					"step 0";
+					player
+						.chooseTarget(get.prompt("juechen"), function (card, player, target) {
+							return (
+								player != target &&
+								!trigger.targets.includes(target) &&
+								target.countCards("he") > 0
+							);
+						})
+						.set("autodelay", true).ai = function (target) {
 						return -get.attitude(player, target);
-					}
-					"step 1"
+					};
+					("step 1");
 					if (result.bool) {
-						player.logSkill('juechen',result.targets);
-						player.discardPlayerCard(true,result.targets[0],'he');
-					}
+						player.logSkill("juechen", result.targets);
+						player.discardPlayerCard(true, result.targets[0], "he");
 					}
 				},
+			},
 			lingfeng: {
-				trigger:{player:'phaseDrawBefore'},
+				trigger: { player: "phaseDrawBefore" },
 				check: function (event, player) {
 					for (var i = 0; i < game.players.length; i++) {
 						if (player != game.players[i]) {
@@ -255,92 +279,95 @@ game.import('character', function () {
 					return false;
 				},
 				content: function () {
-					"step 0"
+					"step 0";
 					trigger.cancel();
 					event.cards = get.cards(2);
 					player.showCards(event.cards);
-					"step 1"
+					("step 1");
 					if (get.color(event.cards[0]) != get.color(event.cards[1])) {
-						player.chooseTarget('是否弃置一名角色一张牌？',function(card,player,target){
-							return player!=target&&target.countCards('he')>0;
+						player.chooseTarget("是否弃置一名角色一张牌？", function (card, player, target) {
+							return player != target && target.countCards("he") > 0;
 						}).ai = function (target) {
 							return -get.attitude(player, target);
+						};
 					}
-					}
-					"step 2"
+					("step 2");
 					if (result.bool && result.targets && result.targets.length) {
-						player.discardPlayerCard(result.targets[0],'he',true);
+						player.discardPlayerCard(result.targets[0], "he", true);
 					}
-					"step 3"
+					("step 3");
 					player.gain(event.cards);
 					player.$draw(event.cards);
 					game.delay();
 				},
 				ai: {
-					threaten:1.1
-				}
+					threaten: 1.1,
+				},
 			},
 			biantian4: {
-				trigger:{player:'dieBegin'},
+				trigger: { player: "dieBegin" },
 				forced: true,
 				popup: false,
 				content: function () {
 					for (var i = 0; i < game.players.length; i++) {
-						if(game.players[i].hasSkill('biantian3')){
-							game.players[i].removeSkill('biantian3');
-							game.players[i].popup('biantian3');
-						}
+						if (game.players[i].hasSkill("biantian3")) {
+							game.players[i].removeSkill("biantian3");
+							game.players[i].popup("biantian3");
 						}
 					}
 				},
+			},
 			biantian: {
-				trigger:{player:'phaseBegin'},
+				trigger: { player: "phaseBegin" },
 				forced: true,
 				unique: true,
-				group:'biantian4',
+				group: "biantian4",
 				content: function () {
-					"step 0"
-					player.removeSkill('biantian2');
+					"step 0";
+					player.removeSkill("biantian2");
 					for (var i = 0; i < game.players.length; i++) {
-						if(game.players[i].hasSkill('biantian3')){
-							game.players[i].removeSkill('biantian3');
-							game.players[i].popup('biantian3');
+						if (game.players[i].hasSkill("biantian3")) {
+							game.players[i].removeSkill("biantian3");
+							game.players[i].popup("biantian3");
 						}
 					}
 					player.judge(function (card) {
-						if(get.color(card)=='red') return 1;
-						if(get.suit(card)=='spade') return 3;
+						if (get.color(card) == "red") return 1;
+						if (get.suit(card) == "spade") return 3;
 						return -1;
 					});
-					"step 1"
-					if(result.color=='red'){
-						player.chooseTarget('选择至多三名角色获得狂风标记',[1,3],function(card,player,target){
+					("step 1");
+					if (result.color == "red") {
+						player.chooseTarget(
+							"选择至多三名角色获得狂风标记",
+							[1, 3],
+							function (card, player, target) {
 								return player != target;
-						}).ai=function(target){
-							if(target.hasSkillTag('nofire')) return 0;
+							}
+						).ai = function (target) {
+							if (target.hasSkillTag("nofire")) return 0;
 							return -get.attitude(player, target);
 						};
-					}
-					else{
+					} else {
 						event.finish();
-						if(result.suit=='spade'){
-							player.addSkill('biantian2');
+						if (result.suit == "spade") {
+							player.addSkill("biantian2");
 						}
 					}
-					"step 2"
+					("step 2");
 					if (result.bool && result.targets) {
 						for (var i = 0; i < result.targets.length; i++) {
-							result.targets[i].addSkill('biantian3');
-							result.targets[i].popup('kuangfeng');
-						}
-						player.logSkill('kuangfeng',result.targets,'fire');
+							result.targets[i].addSkill("biantian3");
+							result.targets[i].popup("kuangfeng");
 						}
+						player.logSkill("kuangfeng", result.targets, "fire");
 					}
 				},
+			},
 			biantian2: {
-				trigger:{player:'damageBefore'},
+				trigger: { player: "damageBefore" },
 				filter: function (event) {
-					if(event.nature!='thunder') return true;
+					if (event.nature != "thunder") return true;
 					return false;
 				},
 				forced: true,
@@ -352,15 +379,15 @@ game.import('character', function () {
 					nodamage: true,
 					effect: {
 						target: function (card, player, target, current) {
-							if(get.tag(card,'damage')&&!get.tag(card,'thunderDamage')) return [0,0];
-						}
-					}
-				}
+							if (get.tag(card, "damage") && !get.tag(card, "thunderDamage")) return [0, 0];
+						},
+					},
+				},
 			},
 			biantian3: {
-				trigger:{player:'damageBegin'},
+				trigger: { player: "damageBegin" },
 				filter: function (event) {
-					if(event.nature=='fire') return true;
+					if (event.nature == "fire") return true;
 					return false;
 				},
 				forced: true,
@@ -370,88 +397,90 @@ game.import('character', function () {
 				ai: {
 					effect: {
 						target: function (card, player, target, current) {
-							if(get.tag(card,'fireDamage')) return 1.5;
-						}
-					}
-				}
+							if (get.tag(card, "fireDamage")) return 1.5;
+						},
+					},
+				},
 			},
 			jingmiao: {
-				trigger:{global:'useCardAfter'},
+				trigger: { global: "useCardAfter" },
 				direct: true,
 				filter: function (event, player) {
-					return event.player!=player&&event.card.name=='wuxie'&&event.player.countCards('he')>0;
+					return (
+						event.player != player &&
+						event.card.name == "wuxie" &&
+						event.player.countCards("he") > 0
+					);
 				},
 				content: function () {
-					"step 0"
-					player.choosePlayerCard(trigger.player,get.prompt('jingmiao',trigger.player),'he');
-					"step 1"
+					"step 0";
+					player.choosePlayerCard(trigger.player, get.prompt("jingmiao", trigger.player), "he");
+					("step 1");
 					if (result.bool) {
-						player.logSkill('jingmiao',trigger.player);
+						player.logSkill("jingmiao", trigger.player);
 						trigger.player.discard(result.links);
 					}
 				},
 				ai: {
-					expose:0.2
-				}
+					expose: 0.2,
+				},
 			},
 			zhinang: {
-				trigger:{player:'phaseBegin'},
+				trigger: { player: "phaseBegin" },
 				frequent: true,
 				content: function () {
-					"step 0"
+					"step 0";
 					event.cards = get.cards(3);
 					event.cards2 = [];
 					for (var i = 0; i < event.cards.length; i++) {
 						var type = get.type(event.cards[i]);
-						if(type=='trick'||type=='equip'){
+						if (type == "trick" || type == "equip") {
 							event.cards2.push(event.cards[i]);
 						}
 					}
 					if (!event.isMine() || event.cards2.length == 0) {
 						player.showCards(event.cards);
 					}
-					"step 1"
+					("step 1");
 					if (event.cards2.length == 0) {
 						event.finish();
-					}
-					else{
-						var dialog=ui.create.dialog('将三张牌中的锦囊牌或装备牌交给一名角色','hidden');
+					} else {
+						var dialog = ui.create.dialog("将三张牌中的锦囊牌或装备牌交给一名角色", "hidden");
 						dialog.add(event.cards);
 						for (var i = 0; i < dialog.buttons.length; i++) {
 							if (event.cards2.includes(dialog.buttons[i].link)) {
 								dialog.buttons[i].style.opacity = 1;
-							}
-							else{
+							} else {
 								dialog.buttons[i].style.opacity = 0.5;
 							}
 						}
 						var next = player.chooseTarget(true, dialog);
 						next.ai = function (target) {
-							if(player.hasJudge('lebu')){
+							if (player.hasJudge("lebu")) {
 								if (target == player) return 0.1;
 							}
 							var att = get.attitude(player, target);
-							if(player.countCards('h')>player.hp){
+							if (player.countCards("h") > player.hp) {
 								if (target == player) return Math.max(1, att - 2);
 							}
 							if (target == player) return att + 5;
 							return att;
+						};
 					}
-					}
-					"step 2"
+					("step 2");
 					if (result && result.targets && result.targets.length) {
 						event.target = result.targets[0];
 					}
 					if (event.cards2.length) {
-						event.target.gain(event.cards2,'gain2');
+						event.target.gain(event.cards2, "gain2");
 					}
 				},
 				ai: {
-					threaten:1.3
-				}
+					threaten: 1.3,
+				},
 			},
 			tianyu: {
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				direct: true,
 				filter: function (event, player) {
 					for (var i = 0; i < game.players.length; i++) {
@@ -461,28 +490,27 @@ game.import('character', function () {
 					}
 				},
 				content: function () {
-					"step 0"
+					"step 0";
 					var num = 0;
 					for (var i = 0; i < game.players.length; i++) {
 						if (!game.players[i].isLinked() && player != game.players[i]) {
 							num++;
 						}
 					}
-					player.chooseTarget(get.prompt('tianyu'),[1,num],function(card,player,target){
+					player.chooseTarget(get.prompt("tianyu"), [1, num], function (card, player, target) {
 						return !target.isLinked() && player != target;
 					}).ai = function (target) {
 						return -get.attitude(player, target);
-					}
-					"step 1"
+					};
+					("step 1");
 					if (result.bool) {
-						player.logSkill('tianyu',result.targets);
+						player.logSkill("tianyu", result.targets);
 						event.targets = result.targets;
 						event.num = 0;
-					}
-					else{
+					} else {
 						event.finish();
 					}
-					"step 2"
+					("step 2");
 					if (event.num < event.targets.length) {
 						event.targets[event.num].link();
 						event.num++;
@@ -490,11 +518,11 @@ game.import('character', function () {
 					}
 				},
 				ai: {
-					expose:0.3
-				}
+					expose: 0.3,
+				},
 			},
 			jizhen: {
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				direct: true,
 				filter: function (event, player) {
 					for (var i = 0; i < game.players.length; i++) {
@@ -505,72 +533,77 @@ game.import('character', function () {
 					return false;
 				},
 				content: function () {
-					"step 0"
+					"step 0";
 					var num = 0;
 					for (var i = 0; i < game.players.length; i++) {
 						if (!game.players[i].isLinked() && player != game.players[i]) {
 							num++;
 						}
 					}
-					player.chooseTarget(get.prompt('jizhen'),[1,2],function(card,player,target){
+					player.chooseTarget(get.prompt("jizhen"), [1, 2], function (card, player, target) {
 						return target.hp < target.maxHp && player != target;
 					}).ai = function (target) {
 						return get.attitude(player, target);
-					}
-					"step 1"
+					};
+					("step 1");
 					if (result.bool) {
-						player.logSkill('jizhen',result.targets);
+						player.logSkill("jizhen", result.targets);
 						game.asyncDraw(result.targets);
 					}
 				},
 				ai: {
 					expose: 0.3,
-					threaten:1.3
-				}
+					threaten: 1.3,
+				},
 			},
 		},
 		translate: {
-			jg_pangtong:'浴火士元',
-			jg_huangyueying:'工神月英',
-			jg_zhugeliang:'天侯孔明',
-			jg_liubei:'烈帝玄德',
-			jg_xiahouyuan:'绝尘妙才',
-			jg_caozhen:'佳人子丹',
-			jg_zhanghe:'巧魁儁乂',
-			jg_simayi:'断狱仲达',
-			tianyu:'天狱',
-			zhinang:'智囊',
-			jingmiao:'精妙',
-			biantian:'变天',
-			biantian2:'大雾',
-			biantian3:'狂风',
-			jizhen:'激阵',
-			xuanlei:'玄雷',
-			xuanlei_info:'锁定技，准备阶段，你令所有判定区内有牌的其他角色受到1点雷电伤害。',
-			sfanshi:'反噬',
-			sfanshi_info:'锁定技，结束阶段，你失去1点体力。',
-			konghun:'控魂',
-			konghun_info:'出牌阶段开始时，若你的体力值不大于1（场上存活角色数不小于6时改为2），你可以对至多X名角色各造成1点雷电伤害，然后你恢复等量体力，X为场上其他存活角色数的一半（向下取整且至多为4）。',
-			jizhen_info:'结束阶段，你可以令所至多两名已受伤角色摸一张牌。',
+			jg_pangtong: "浴火士元",
+			jg_huangyueying: "工神月英",
+			jg_zhugeliang: "天侯孔明",
+			jg_liubei: "烈帝玄德",
+			jg_xiahouyuan: "绝尘妙才",
+			jg_caozhen: "佳人子丹",
+			jg_zhanghe: "巧魁儁乂",
+			jg_simayi: "断狱仲达",
+			tianyu: "天狱",
+			zhinang: "智囊",
+			jingmiao: "精妙",
+			biantian: "变天",
+			biantian2: "大雾",
+			biantian3: "狂风",
+			jizhen: "激阵",
+			xuanlei: "玄雷",
+			xuanlei_info: "锁定技，准备阶段，你令所有判定区内有牌的其他角色受到1点雷电伤害。",
+			sfanshi: "反噬",
+			sfanshi_info: "锁定技，结束阶段，你失去1点体力。",
+			konghun: "控魂",
+			konghun_info:
+				"出牌阶段开始时，若你的体力值不大于1（场上存活角色数不小于6时改为2），你可以对至多X名角色各造成1点雷电伤害，然后你恢复等量体力，X为场上其他存活角色数的一半（向下取整且至多为4）。",
+			jizhen_info: "结束阶段，你可以令所至多两名已受伤角色摸一张牌。",
 			// biantian2_info:'已获得大雾标记',
 			// biantian3_info:'已获得狂风标记',
-			lingfeng:'灵锋',
-			jueji:'绝汲',
-			huodi:'惑敌',
-			huodi_info:'结束阶段，若你本回合内没有使用过指定其他角色为目标的卡牌，你可以弃置一名其他角色的一张牌。',
-			jueji_info:'其他角色的摸牌阶段开始时，若其已受伤，你可以弃置一张牌令其摸牌数-1。',
-			lingfeng_info:'摸牌阶段，你可以弃置摸牌，改为亮出牌堆顶的两张牌并获得之，若两张牌颜色不同，你可以弃置一名角色的一张牌。',
-			biantian_info:'锁定技，准备阶段，你进行一次判定，若为红色，你可以选择至多三名角色进入“狂风”状态直到你的下一回合开始，若为黑桃，直到下个回合开始前，你处于“大雾”状态。',
-			jingmiao_info:'每当有一名其他角色使用无懈可击，你可以弃置其一张牌。',
-			zhinang_info:'准备阶段，你可以亮出牌堆顶的三张牌，你可以将其中锦囊或装备牌交给一名角色。',
-			tianyu_info:'结束阶段，你可以将任意名未横置的其他角色横置。',
-			juechen:'绝尘',
-			juechen_info:'每当你使用一张杀，可以弃置一名其他角色的一张牌（不能是杀的目标）。',
-			chiying:'持盈',
-			chiying_info:'每当一名角色受到多于1伤害时，你可以令其防止其余伤害，然后令伤害来源摸一张牌。',
-			jingfan:'惊帆',
-			jingfan2:'惊帆',
-			jingfan_info:'回合内，每当你使用一张卡牌，你的进攻距离+1；出牌阶段结束时，你可以将手牌数补至X，并指定至多X名角色令其进攻距离+1直到其下一回合结束，X为你回合内使用的卡牌数。',
+			lingfeng: "灵锋",
+			jueji: "绝汲",
+			huodi: "惑敌",
+			huodi_info:
+				"结束阶段，若你本回合内没有使用过指定其他角色为目标的卡牌，你可以弃置一名其他角色的一张牌。",
+			jueji_info: "其他角色的摸牌阶段开始时，若其已受伤，你可以弃置一张牌令其摸牌数-1。",
+			lingfeng_info:
+				"摸牌阶段，你可以弃置摸牌，改为亮出牌堆顶的两张牌并获得之，若两张牌颜色不同，你可以弃置一名角色的一张牌。",
+			biantian_info:
+				"锁定技，准备阶段，你进行一次判定，若为红色，你可以选择至多三名角色进入“狂风”状态直到你的下一回合开始，若为黑桃，直到下个回合开始前，你处于“大雾”状态。",
+			jingmiao_info: "每当有一名其他角色使用无懈可击，你可以弃置其一张牌。",
+			zhinang_info: "准备阶段，你可以亮出牌堆顶的三张牌，你可以将其中锦囊或装备牌交给一名角色。",
+			tianyu_info: "结束阶段，你可以将任意名未横置的其他角色横置。",
+			juechen: "绝尘",
+			juechen_info: "每当你使用一张杀，可以弃置一名其他角色的一张牌（不能是杀的目标）。",
+			chiying: "持盈",
+			chiying_info: "每当一名角色受到多于1伤害时，你可以令其防止其余伤害，然后令伤害来源摸一张牌。",
+			jingfan: "惊帆",
+			jingfan2: "惊帆",
+			jingfan_info:
+				"回合内，每当你使用一张卡牌，你的进攻距离+1；出牌阶段结束时，你可以将手牌数补至X，并指定至多X名角色令其进攻距离+1直到其下一回合结束，X为你回合内使用的卡牌数。",
 		},
 	};
 });

character/mtg.js

@@ -1,31 +1,37 @@
-import { lib, game, ui, get, ai, _status } from '../noname.js';
-game.import('character', function () {
+import { lib, game, ui, get, ai, _status } from "../noname.js";
+game.import("character", function () {
 	return {
-		name:'mtg',
+		name: "mtg",
 		character: {
-			mtg_jiding:['male','qun',4,['mbaizhan','msilian']],
+			mtg_jiding: ["male", "qun", 4, ["mbaizhan", "msilian"]],
 			// mtg_qianzhuo:['female','shu',3,[]],
-			mtg_jiesi:['male','wei',3,['mtongnian','msuoling','mhuanyi']],
-			mtg_lilianna:['female','qun',3,['lingyong','mduohun']],
+			mtg_jiesi: ["male", "wei", 3, ["mtongnian", "msuoling", "mhuanyi"]],
+			mtg_lilianna: ["female", "qun", 3, ["lingyong", "mduohun"]],
 			// mtg_nisha:['female','wu',3,[]],
 			// mtg_ayeni:['male','qun',4,[]],
 		},
 		characterIntro: {
-			mtg_jiding:'这名白色魔法的使用者极其注重忠诚，正义和荣誉。他曾全力追捕茜卓纳拉，如今已不可思议地与这位火焰法师成为伙伴。',
-			mtg_qianzhuo:'茜卓纳拉是使用红色法术力的旅法师。她擅长使用火焰：除了火焰，还是火焰。茜卓性格冲动、易怒、富有激情，不断增长的火焰法术能力随时都准备爆发。她的火花在还很年轻时便已点燃，如今已是相当有经验的烈焰术士和旅法师。',
-			mtg_jiesi:'杰斯贝连是使用蓝色法术的鹏洛客。他擅长心灵法术：读取心灵，幻影，知识，以及欺瞒的咒语。',
-			mtg_lilianna:'莉莲娜维斯是一位精通死灵术的旅法师，她擅长用黑色法术力来复活死者，腐化生者，并从死亡中召唤力量。',
-			mtg_nisha:'赞迪卡妖精部落玖瑞加的一名战士，做事倾尽全力，与大地有密切的联系，还擅使元素魔法。她能够引导时空的魔法生机地脉，为土地赋予生命。',
-			mtg_ayeni:'金鬃阿耶尼是使用白色法术的鹏洛客。他长于净化身体与心灵的法术：用咒语来治疗、强化盟友，以及唤醒他人内在的心灵精华。',
+			mtg_jiding:
+				"这名白色魔法的使用者极其注重忠诚，正义和荣誉。他曾全力追捕茜卓纳拉，如今已不可思议地与这位火焰法师成为伙伴。",
+			mtg_qianzhuo:
+				"茜卓纳拉是使用红色法术力的旅法师。她擅长使用火焰：除了火焰，还是火焰。茜卓性格冲动、易怒、富有激情，不断增长的火焰法术能力随时都准备爆发。她的火花在还很年轻时便已点燃，如今已是相当有经验的烈焰术士和旅法师。",
+			mtg_jiesi:
+				"杰斯贝连是使用蓝色法术的鹏洛客。他擅长心灵法术：读取心灵，幻影，知识，以及欺瞒的咒语。",
+			mtg_lilianna:
+				"莉莲娜维斯是一位精通死灵术的旅法师，她擅长用黑色法术力来复活死者，腐化生者，并从死亡中召唤力量。",
+			mtg_nisha:
+				"赞迪卡妖精部落玖瑞加的一名战士，做事倾尽全力，与大地有密切的联系，还擅使元素魔法。她能够引导时空的魔法生机地脉，为土地赋予生命。",
+			mtg_ayeni:
+				"金鬃阿耶尼是使用白色法术的鹏洛客。他长于净化身体与心灵的法术：用咒语来治疗、强化盟友，以及唤醒他人内在的心灵精华。",
 		},
 		skill: {
 			mduohun: {
-				trigger:{player:'dyingAfter'},
+				trigger: { player: "dyingAfter" },
 				forced: true,
 				filter: function (event, player) {
 					return event.source && event.source.isIn() && event.source.hp > 0;
 				},
-				logTarget:'source',
+				logTarget: "source",
 				content: function () {
 					trigger.source.loseHp();
 				},
@@ -37,24 +43,24 @@ game.import('character', function () {
 					effect: {
 						target: function (card, player, target, current) {
 							if (!target.hasFriend()) return;
-							if(target.hp<=1&&get.tag(card,'damage')) return [1,0,0,-1];
-						}
-					}
-				}
+							if (target.hp <= 1 && get.tag(card, "damage")) return [1, 0, 0, -1];
+						},
+					},
+				},
 			},
 			lingyong: {
-				enable:'phaseUse',
+				enable: "phaseUse",
 				filter: function (event, player) {
-					return !player.hasSkill('subplayer')&&player.getSubPlayers('lingyong_get').length>0;
+					return !player.hasSkill("subplayer") && player.getSubPlayers("lingyong_get").length > 0;
 				},
 				nosub: true,
-				group:'lingyong_get',
+				group: "lingyong_get",
 				direct: true,
 				delay: 0,
 				skillAnimation: true,
-				animationColor:'thunder',
+				animationColor: "thunder",
 				content: function () {
-					player.callSubPlayer().set('tag','lingyong_get');
+					player.callSubPlayer().set("tag", "lingyong_get");
 				},
 				ai: {
 					order: 1,
@@ -64,15 +70,18 @@ game.import('character', function () {
 							// if(player.hp<=1) return 1;
 							// if(!player.needsToDiscard(player.hp-1)) return 1;
 							// return 0;
-						}
-					}
+						},
+					},
 				},
 				subSkill: {
 					get: {
-						trigger:{global:'dieAfter'},
+						trigger: { global: "dieAfter" },
 						forced: true,
 						filter: function (event, player) {
-							return !event.player.isMin()&&![player.name,player.name1,player.name2].includes(event.player.name);
+							return (
+								!event.player.isMin() &&
+								![player.name, player.name1, player.name2].includes(event.player.name)
+							);
 						},
 						content: function () {
 							var skills = lib.character[trigger.player.name][3].slice(0);
@@ -85,70 +94,78 @@ game.import('character', function () {
 								name: trigger.player.name,
 								skills: skills,
 								hs: get.cards(2),
-								intro:'出牌阶段，你可以调遣此随从（直到随从死亡不可再次切换）'
+								intro: "出牌阶段，你可以调遣此随从（直到随从死亡不可再次切换）",
 							});
-						}
-					}
-				}
+						},
+					},
+				},
 			},
 			mhuanyi: {
 				round: 2,
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				direct: true,
 				addintro: function (storage, player) {
-					if(player.hasSkill('mhuanyi_target')){
-						return '直到下一回合开始，当成为某类型的卡牌的惟一目标时，将目标转移给某名其他角色；'
+					if (player.hasSkill("mhuanyi_target")) {
+						return "直到下一回合开始，当成为某类型的卡牌的惟一目标时，将目标转移给某名其他角色；";
 					}
-					return '';
+					return "";
 				},
 				content: function () {
-					'step 0'
+					"step 0";
 					var rand = Math.random();
-					player.chooseTarget(get.prompt2('mhuanyi'),function(card,player,target){
+					player
+						.chooseTarget(get.prompt2("mhuanyi"), function (card, player, target) {
 							return target != player;
-					}).set('ai',function(target){
+						})
+						.set("ai", function (target) {
 							if (get.attitude(player, target) < 0) {
 								return rand;
 							}
 							return 0;
 						});
-					'step 1'
+					("step 1");
 					if (result.bool) {
 						event.target = result.targets[0];
 						if (player.isUnderControl(true)) {
-							player.line(event.target,'green');
+							player.line(event.target, "green");
 						}
-						player.chooseControl('基本牌','非基本牌','cancel2',function(){
+						player
+							.chooseControl("基本牌", "非基本牌", "cancel2", function () {
 								return Math.floor(Math.random() * 2);
-						}).set('prompt','选择一种卡牌类型');
-					}
-					else{
+							})
+							.set("prompt", "选择一种卡牌类型");
+					} else {
 						event.finish();
 					}
-					'step 2'
-					if(result.control&&result.control!='cancel2'){
-						player.logSkill('mhuanyi');
+					("step 2");
+					if (result.control && result.control != "cancel2") {
+						player.logSkill("mhuanyi");
 						player.storage.mhuanyi_target = [event.target, result.index];
-						player.addTempSkill('mhuanyi_target',{player:'phaseBegin'});
+						player.addTempSkill("mhuanyi_target", { player: "phaseBegin" });
 					}
 				},
 				subSkill: {
 					target: {
-						trigger:{target:'useCardToBefore'},
+						trigger: { target: "useCardToBefore" },
 						priority: 6,
 						forced: true,
 						onremove: true,
-						group:'mhuanyi_die',
+						group: "mhuanyi_die",
 						filter: function (event, player) {
 							if (!player.storage.mhuanyi_target) return false;
 							if (event.player == player.storage.mhuanyi_target[0]) return false;
-							if(get.type(event.card)=='basic'){
+							if (get.type(event.card) == "basic") {
 								if (player.storage.mhuanyi_target[1] != 0) return false;
-							}
-							else{
+							} else {
 								if (player.storage.mhuanyi_target[1] != 1) return false;
 							}
-							if(!lib.filter.targetEnabled2(event.card,event.player,player.storage.mhuanyi_target[0])){
+							if (
+								!lib.filter.targetEnabled2(
+									event.card,
+									event.player,
+									player.storage.mhuanyi_target[0]
+								)
+							) {
 								return false;
 							}
 							return true;
@@ -158,69 +175,72 @@ game.import('character', function () {
 						},
 						content: function () {
 							trigger.target = player.storage.mhuanyi_target[0];
-							player.removeSkill('mhuanyi_target');
-						}
+							player.removeSkill("mhuanyi_target");
+						},
 					},
 					die: {
-						trigger:{global:'dieAfter'},
+						trigger: { global: "dieAfter" },
 						silent: true,
 						filter: function (event, player) {
 							if (!player.storage.mhuanyi_target) return false;
 							return event.player == player.storage.mhuanyi_target[0];
 						},
 						content: function () {
-							player.removeSkill('mhuanyi_target');
-						}
-					}
-				}
+							player.removeSkill("mhuanyi_target");
+						},
+					},
+				},
 			},
 			msuoling: {
-				trigger:{global:'useCard'},
+				trigger: { global: "useCard" },
 				direct: true,
 				priority: 5.5,
 				round: 1,
 				filter: function (event, player) {
-					if(get.type(event.card)=='trick'&&event.card.isCard){
+					if (get.type(event.card) == "trick" && event.card.isCard) {
 						if (event.player == player) return false;
-						if(!player.countCards('he',{suit:get.suit(event.card)})) return false;
+						if (!player.countCards("he", { suit: get.suit(event.card) })) return false;
 						return true;
 					}
 					return false;
 				},
 				content: function () {
-					'step 0'
+					"step 0";
 					var att = get.attitude(player, trigger.player);
 					var suit = get.suit(trigger.card);
-					player.chooseToDiscard('he',get.prompt2('msuoling',trigger.player),function(card){
+					player
+						.chooseToDiscard("he", get.prompt2("msuoling", trigger.player), function (card) {
 							return get.suit(card) == suit;
-					}).set('autodelay',true).set('logSkill',['msuoling',trigger.player]).ai=function(card){
+						})
+						.set("autodelay", true)
+						.set("logSkill", ["msuoling", trigger.player]).ai = function (card) {
 						if (att < 0) {
 							return 8 - get.value(card);
 						}
 						return 0;
 					};
-					'step 1'
+					("step 1");
 					if (result.bool) {
 						trigger.cancel();
 						player.chooseUseTarget(true, trigger.card);
 					}
-				}
+				},
 			},
 			msuoling_old: {
-				enable:'phaseUse',
+				enable: "phaseUse",
 				usable: 1,
 				subSkill: {
 					ai: {
-						onremove:true
-					}
+						onremove: true,
+					},
 				},
 				filter: function (event, player) {
-					var nh=player.countCards('h');
+					var nh = player.countCards("h");
 					if (nh <= 1 || nh >= 5) return false;
 					return lib.skill.msuoling.getc(player).number > 0;
 				},
 				getc: function (player) {
-					var hs=player.getCards('h');
+					var hs = player.getCards("h");
 					for (var i = 0; i < hs.length; i++) {
 						if (hs[i].mtongnian_link) {
 							return hs[i];
@@ -229,7 +249,7 @@ game.import('character', function () {
 					return -1;
 				},
 				getn: function (player) {
-					var hs=player.getCards('h');
+					var hs = player.getCards("h");
 					var ns = [];
 					for (var i = 0; i < hs.length; i++) {
 						if (!hs[i].mtongnian_link) {
@@ -270,24 +290,23 @@ game.import('character', function () {
 				check: function (card) {
 					// if(player.isUnderControl(true)) return 0;
 					var player = _status.event.player;
-					if(player.hasSkill('msuoling_ai')){
+					if (player.hasSkill("msuoling_ai")) {
 						return false;
 					}
 					if (lib.skill.msuoling.test(player)) {
 						return true;
-					}
-					else{
-						player.addTempSkill('msuoling_ai',{player:['gainAfter','phaseAfter']});
+					} else {
+						player.addTempSkill("msuoling_ai", { player: ["gainAfter", "phaseAfter"] });
 						return false;
 					}
 				},
 				content: function () {
-					'step 0'
+					"step 0";
 					player.showHandcards();
-					'step 1'
+					("step 1");
 					if (lib.skill.msuoling.test(player)) {
 						var card = lib.skill.msuoling.getc(player);
-						card.classList.remove('glow');
+						card.classList.remove("glow");
 						delete card.mtongnian_link;
 						delete card._destroy;
 
@@ -296,24 +315,24 @@ game.import('character', function () {
 							var card = list.randomGet();
 							var fake = game.createCard(card);
 							fake.mtongnian_link = card;
-							player.gain(fake,'draw')._triggered=null;
-							fake.classList.add('glow');
-							fake._destroy='mtongnian';
+							player.gain(fake, "draw")._triggered = null;
+							fake.classList.add("glow");
+							fake._destroy = "mtongnian";
 						}
 					}
 				},
 				selectCard: [1, Infinity],
 				ai: {
-					order:11
-				}
+					order: 11,
+				},
 			},
 			mtongnian: {
-				trigger:{player:'phaseUseBegin'},
+				trigger: { player: "phaseUseBegin" },
 				forced: true,
 				filter: function (event, player) {
 					var enemies = player.getEnemies();
 					for (var i = 0; i < enemies.length; i++) {
-						if(enemies[i].countCards('h')) return true;
+						if (enemies[i].countCards("h")) return true;
 					}
 					return false;
 				},
@@ -321,7 +340,7 @@ game.import('character', function () {
 					var list = [];
 					var enemies = player.getEnemies();
 					for (var i = 0; i < enemies.length; i++) {
-						list.addArray(enemies[i].getCards('h'));
+						list.addArray(enemies[i].getCards("h"));
 					}
 					return list;
 				},
@@ -331,24 +350,24 @@ game.import('character', function () {
 						var card = list.randomGet();
 						var fake = game.createCard(card);
 						fake.mtongnian_link = card;
-						player.gain(fake,'draw')._triggered=null;
-						fake.classList.add('glow');
-						fake._destroy='mtongnian';
+						player.gain(fake, "draw")._triggered = null;
+						fake.classList.add("glow");
+						fake._destroy = "mtongnian";
 					}
 				},
-				group:['mtongnian_change','mtongnian_use','mtongnian_lose'],
+				group: ["mtongnian_change", "mtongnian_use", "mtongnian_lose"],
 				subSkill: {
 					change: {
-						trigger:{player:'useCard'},
+						trigger: { player: "useCard" },
 						silent: true,
 						filter: function (event, player) {
 							return player.hasCard(function (card) {
 								return card.mtongnian_link ? true : false;
-							},'h');
+							}, "h");
 						},
 						content: function () {
 							var list = lib.skill.mtongnian.getList(player);
-							var hs=player.getCards('h',function(card){
+							var hs = player.getCards("h", function (card) {
 								return card.mtongnian_link ? true : false;
 							});
 							for (var i = 0; i < hs.length; i++) {
@@ -359,10 +378,10 @@ game.import('character', function () {
 								}
 								hs[i].init(hs[i].mtongnian_link);
 							}
-						}
+						},
 					},
 					use: {
-						trigger:{player:'useCardBefore'},
+						trigger: { player: "useCardBefore" },
 						silent: true,
 						filter: function (event, player) {
 							return event.card.mtongnian_link ? true : false;
@@ -377,41 +396,40 @@ game.import('character', function () {
 								trigger.cards.length = 0;
 								trigger.cards.push(link);
 								target.lose(link, ui.discardPile);
-								player.logSkill('mtongnian',target);
-								game.log(target,'失去了',link);
+								player.logSkill("mtongnian", target);
+								game.log(target, "失去了", link);
 								game.delayx();
-							}
-							else{
+							} else {
 								player.lose(trigger.card);
 								trigger.cancel();
 							}
-						}
+						},
 					},
 					lose: {
-						trigger:{player:'phaseUseEnd',global:'loseEnd'},
+						trigger: { player: "phaseUseEnd", global: "loseEnd" },
 						silent: true,
 						filter: function (event, player) {
-							if(event.name=='lose'){
+							if (event.name == "lose") {
 								return lib.skill.mtongnian.getList(player).length == 0;
 							}
 							return true;
 						},
 						content: function () {
-							var hs=player.getCards('h',function(card){
+							var hs = player.getCards("h", function (card) {
 								return card.mtongnian_link ? true : false;
 							});
 							if (hs.length) {
 								player.lose(hs)._triggered = null;
 							}
-						}
-					}
+						},
+					},
 				},
 				ai: {
-					threaten:1.3
-				}
+					threaten: 1.3,
+				},
 			},
 			mbaizhan: {
-				trigger:{source:'damageEnd'},
+				trigger: { source: "damageEnd" },
 				forced: true,
 				filter: function (event) {
 					return event.num > 0;
@@ -420,11 +438,11 @@ game.import('character', function () {
 					player.changeHujia(trigger.num);
 				},
 				ai: {
-					damageBonus:true
-				}
+					damageBonus: true,
+				},
 			},
 			msilian: {
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				filter: function (event, player) {
 					return player.hujia > 0;
 				},
@@ -436,57 +454,63 @@ game.import('character', function () {
 					player.changeHujia(-player.hujia);
 					player.insertPhase();
 				},
-				group:['msilian_hp','msilian_draw'],
+				group: ["msilian_hp", "msilian_draw"],
 				subSkill: {
 					hp: {
-						trigger:{player:'phaseAfter'},
+						trigger: { player: "phaseAfter" },
 						silent: true,
 						filter: function (event, player) {
-							return event.skill=='msilian'&&!player.getStat('damage');
+							return event.skill == "msilian" && !player.getStat("damage");
 						},
 						content: function () {
 							player.loseHp();
-						}
+						},
 					},
 					draw: {
-						trigger:{player:'phaseDrawBegin'},
+						trigger: { player: "phaseDrawBegin" },
 						filter: function (event) {
-							return event.getParent('phase').skill=='msilian';
+							return event.getParent("phase").skill == "msilian";
 						},
 						silent: true,
 						content: function () {
 							trigger.num += player.storage.msilian - 2;
-						}
-					}
-				}
-			}
+						},
+					},
+				},
+			},
 		},
 		translate: {
-			mtg_jiding:'基定',
-			mtg_qianzhuo:'茜卓',
-			mtg_jiesi:'杰斯',
-			mtg_lilianna:'莉莲娜',
-			mtg_nisha:'妮莎',
-			mtg_ayeni:'阿耶尼',
+			mtg_jiding: "基定",
+			mtg_qianzhuo: "茜卓",
+			mtg_jiesi: "杰斯",
+			mtg_lilianna: "莉莲娜",
+			mtg_nisha: "妮莎",
+			mtg_ayeni: "阿耶尼",
 
-			mduohun:'夺魂',
-			mduohun_info:'锁定技，当你解除濒死状态后，令你进入濒死状态的角色失去1点体力。',
-			lingyong:'灵俑',
-			lingyong2:'灵俑',
-			lingyong3:'灵俑',
-			lingyong3_bg:'俑',
-			lingyong_info:'锁定技，每当一名其他角色死亡，你获得一个与该角色同名且体力上限为1、初始手牌为2的随从；出牌阶段，你可以调遣以此法获得的随从（直到随从死亡不可再次切换）。',
-			mbaizhan:'百战',
-			mbaizhan_info:'锁定技，每当你造成1点伤害，你获得1点护甲。',
-			msilian:'祀炼',
-			msilian_info:'结束阶段，若你有护甲，你可以移去全部护甲，然后进行一个额外回合；在额外回合中，你的摸牌阶段摸牌基数为你移去的护甲数；额外回合结束后，若你未造成伤害，你失去1点体力。',
-			mtongnian:'通念',
-			mtongnian_info:'锁定技，出牌阶段开始时，你获得一张替身牌，此牌对应一名随机敌人的一张随机手牌；每当你使用一张非替身牌，随机更换替身牌对应的牌；当你使用替身牌时，改为使用替身牌对应的牌；当出牌阶段结束，或替身牌离开手牌区，或敌方角色没有手牌时，销毁替身牌。',
-			msuoling:'塑灵',
-			msuoling_info:'每轮限一次，当一名其他角色使用一张非转化的普通锦囊牌时，你可以弃置一张与之花色相同的牌取消之，然后你视为使用该锦囊牌。',
-			msuoling_old_info:'出牌阶段限一次，若你手牌中有替身牌且手牌数不超过5，你可以展示手牌，若其中的非替身手牌能通过四则运算得到你的替身牌的点数，你将替身牌转化为非替身牌，然后获得一张新的替身牌（此技能托管无效）。',
-			mhuanyi:'幻逸',
-			mhuanyi_info:'每两轮限一次，结束阶段，你可以选择一名其他角色和一种卡牌类型（选择结果对其他角色不可见），直到下一回合开始，当你首次成为该类型卡牌的惟一目标时，你将目标转移给你指定的角色（目标须合法）。',
+			mduohun: "夺魂",
+			mduohun_info: "锁定技，当你解除濒死状态后，令你进入濒死状态的角色失去1点体力。",
+			lingyong: "灵俑",
+			lingyong2: "灵俑",
+			lingyong3: "灵俑",
+			lingyong3_bg: "俑",
+			lingyong_info:
+				"锁定技，每当一名其他角色死亡，你获得一个与该角色同名且体力上限为1、初始手牌为2的随从；出牌阶段，你可以调遣以此法获得的随从（直到随从死亡不可再次切换）。",
+			mbaizhan: "百战",
+			mbaizhan_info: "锁定技，每当你造成1点伤害，你获得1点护甲。",
+			msilian: "祀炼",
+			msilian_info:
+				"结束阶段，若你有护甲，你可以移去全部护甲，然后进行一个额外回合；在额外回合中，你的摸牌阶段摸牌基数为你移去的护甲数；额外回合结束后，若你未造成伤害，你失去1点体力。",
+			mtongnian: "通念",
+			mtongnian_info:
+				"锁定技，出牌阶段开始时，你获得一张替身牌，此牌对应一名随机敌人的一张随机手牌；每当你使用一张非替身牌，随机更换替身牌对应的牌；当你使用替身牌时，改为使用替身牌对应的牌；当出牌阶段结束，或替身牌离开手牌区，或敌方角色没有手牌时，销毁替身牌。",
+			msuoling: "塑灵",
+			msuoling_info:
+				"每轮限一次，当一名其他角色使用一张非转化的普通锦囊牌时，你可以弃置一张与之花色相同的牌取消之，然后你视为使用该锦囊牌。",
+			msuoling_old_info:
+				"出牌阶段限一次，若你手牌中有替身牌且手牌数不超过5，你可以展示手牌，若其中的非替身手牌能通过四则运算得到你的替身牌的点数，你将替身牌转化为非替身牌，然后获得一张新的替身牌（此技能托管无效）。",
+			mhuanyi: "幻逸",
+			mhuanyi_info:
+				"每两轮限一次，结束阶段，你可以选择一名其他角色和一种卡牌类型（选择结果对其他角色不可见），直到下一回合开始，当你首次成为该类型卡牌的惟一目标时，你将目标转移给你指定的角色（目标须合法）。",
 		},
 	};
 });

character/xiake.js

@@ -1,21 +1,23 @@
-import { lib, game, ui, get, ai, _status } from '../noname.js';
-game.import('character', function () {
+import { lib, game, ui, get, ai, _status } from "../noname.js";
+game.import("character", function () {
 	return {
-		name:'xiake',
+		name: "xiake",
 		character: {
 			// xk_dongfangweiming:['male','shu',4,[]],
-			xk_guyuexuan:['male','qun',4,['rouquan','gzhenji']],
-			xk_jinji:['male','shu',4,['zhongzhan','lianpo']],
+			xk_guyuexuan: ["male", "qun", 4, ["rouquan", "gzhenji"]],
+			xk_jinji: ["male", "shu", 4, ["zhongzhan", "lianpo"]],
 			// xk_shenxiangyun:['female','wei',3,['zhenjiu']],
-			xk_fujianhan:['male','qun',4,['zuijian','zitong']],
+			xk_fujianhan: ["male", "qun", 4, ["zuijian", "zitong"]],
 		},
 		skill: {
 			zhongzhan: {
-				trigger:{source:'damageBegin'},
-				logTarget:'player',
+				trigger: { source: "damageBegin" },
+				logTarget: "player",
 				check: function (event, player) {
-					if(get.damageEffect(event.player,player,player)>0&&
-						get.attitude(player,event.player)<0){
+					if (
+						get.damageEffect(event.player, player, player) > 0 &&
+						get.attitude(player, event.player) < 0
+					) {
 						return player.hp > event.player.hp && player.hp >= 2;
 					}
 					return false;
@@ -23,28 +25,31 @@ game.import('character', function () {
 				content: function () {
 					player.loseHp();
 					trigger.num++;
-				}
+				},
 			},
 			rouquan: {
 				mod: {
 					selectTarget: function (card, player, range) {
-						if(card.name=='sha'&&!player.getEquip(1)&&range[1]!=-1) range[1]=Infinity;
-					}
+						if (card.name == "sha" && !player.getEquip(1) && range[1] != -1) range[1] = Infinity;
 					},
-				enable:'phaseUse',
-				position:'e',
+				},
+				enable: "phaseUse",
+				position: "e",
 				filter: function (event, player) {
-					return player.hasCard(card=>lib.skill.rouquan.filterCard(card,player),lib.skill.rouquan.position);
+					return player.hasCard(
+						(card) => lib.skill.rouquan.filterCard(card, player),
+						lib.skill.rouquan.position
+					);
 				},
 				filterCard: lib.filter.cardRecastable,
-				prompt:'将要重铸的牌置入弃牌堆并摸一张牌',
+				prompt: "将要重铸的牌置入弃牌堆并摸一张牌",
 				discard: false,
 				lose: false,
 				delay: false,
 				check: function (card, player) {
 					var val = get.equipValue(card);
 					var player = _status.event.player;
-					var cards=player.getCards('h',{subtype:get.subtype(card)});
+					var cards = player.getCards("h", { subtype: get.subtype(card) });
 					for (var i = 0; i < cards.length; i++) {
 						if (get.equipValue(cards[i]) >= val) {
 							return 1;
@@ -58,61 +63,61 @@ game.import('character', function () {
 				ai: {
 					order: 9.5,
 					result: {
-						player:1
-					}
-				}
+						player: 1,
+					},
+				},
 			},
 			gzhenji: {
-				trigger:{source:'damageEnd'},
+				trigger: { source: "damageEnd" },
 				frequent: true,
 				filter: function (event, player) {
 					if (event._notrigger.includes(event.player)) return false;
-					return _status.currentPhase==player&&event.card&&event.card.name=='sha';
+					return _status.currentPhase == player && event.card && event.card.name == "sha";
 				},
 				content: function () {
 					player.draw();
-					player.addTempSkill('gzhenji3');
-				}
+					player.addTempSkill("gzhenji3");
+				},
 			},
 			gzhenji3: {
 				mod: {
 					cardUsable: function (card, player, num) {
-						if(card.name=='sha') return num+1;
-					}
+						if (card.name == "sha") return num + 1;
+					},
 				},
 			},
 			zitong: {
-				trigger:{player:'useCard'},
+				trigger: { player: "useCard" },
 				frequent: true,
 				filter: function (event, player) {
 					return _status.currentPhase == player && player.countUsed() == 3;
 				},
 				content: function () {
-					var card=get.cardPile('chuansongmen');
+					var card = get.cardPile("chuansongmen");
 					if (!card) {
-						card=game.createCard('chuansongmen');
+						card = game.createCard("chuansongmen");
 					}
-					player.gain(card,'gain2');
+					player.gain(card, "gain2");
 				},
 				ai: {
-					threaten:1.2
-				}
-			}
+					threaten: 1.2,
+				},
+			},
 		},
 		translate: {
-			xk_dongfangweiming:'东方未明',
-			xk_guyuexuan:'谷月轩',
-			xk_jinji:'荆棘',
-			xk_shenxiangyun:'沈湘芸',
-			xk_fujianhan:'傅剑寒',
-			zhongzhan:'重斩',
-			zhongzhan_info:'每当你即将造成伤害，你可失去1点体力令伤害+1。',
-			gzhenji:'震击',
-			gzhenji_info:'你使用杀造成伤害后，可以摸一张牌，并且本回合内可以额外使用一张杀。',
-			rouquan:'柔拳',
-			rouquan_info:'你可以重铸装备区内的牌；当你没有武器牌时，你的杀可以指定任意个目标。',
-			zitong:'通悟',
-			zitong_info:'当你于自己的回合内使用第三张牌时，你可以将一张传送门置于你的手牌。',
+			xk_dongfangweiming: "东方未明",
+			xk_guyuexuan: "谷月轩",
+			xk_jinji: "荆棘",
+			xk_shenxiangyun: "沈湘芸",
+			xk_fujianhan: "傅剑寒",
+			zhongzhan: "重斩",
+			zhongzhan_info: "每当你即将造成伤害，你可失去1点体力令伤害+1。",
+			gzhenji: "震击",
+			gzhenji_info: "你使用杀造成伤害后，可以摸一张牌，并且本回合内可以额外使用一张杀。",
+			rouquan: "柔拳",
+			rouquan_info: "你可以重铸装备区内的牌；当你没有武器牌时，你的杀可以指定任意个目标。",
+			zitong: "通悟",
+			zitong_info: "当你于自己的回合内使用第三张牌时，你可以将一张传送门置于你的手牌。",
 		},
 	};
 });

character/zhuogui.js

@@ -1,96 +1,96 @@
-import { lib, game, ui, get, ai, _status } from '../noname.js';
-game.import('character', function () {
+import { lib, game, ui, get, ai, _status } from "../noname.js";
+game.import("character", function () {
 	return {
-		name:'zhuogui',
+		name: "zhuogui",
 		character: {
-			nianshou:['male','shu',4,['nianrui','qixiang']],
-			mamian:['male','qun',4,['lianyu','guiji']],
-			niutou:['male','shu',4,['manjia','xiaoshou']],
-			baiwuchang:['male','qun',3,['qiangzheng','moukui']],
-			heiwuchang:['male','qun',3,['suoling','xixing']],
+			nianshou: ["male", "shu", 4, ["nianrui", "qixiang"]],
+			mamian: ["male", "qun", 4, ["lianyu", "guiji"]],
+			niutou: ["male", "shu", 4, ["manjia", "xiaoshou"]],
+			baiwuchang: ["male", "qun", 3, ["qiangzheng", "moukui"]],
+			heiwuchang: ["male", "qun", 3, ["suoling", "xixing"]],
 		},
 		skill: {
 			qixiang: {
-				group:['qixiang1','qixiang2'],
+				group: ["qixiang1", "qixiang2"],
 				ai: {
 					effect: {
 						target: function (card, player, target, current) {
-							if(card.name=='lebu'&&card.name=='bingliang') return 0.8;
-						}
-					}
-				}
+							if (card.name == "lebu" && card.name == "bingliang") return 0.8;
+						},
+					},
+				},
 			},
 			qixiang1: {
-				trigger:{player:'judge'},
+				trigger: { player: "judge" },
 				forced: true,
 				filter: function (event, player) {
 					if (event.card) {
 						if (event.card.viewAs) {
-							return event.card.viewAs=='lebu';
-						}
-						else{
-							return event.card.name=='lebu';
+							return event.card.viewAs == "lebu";
+						} else {
+							return event.card.name == "lebu";
 						}
 					}
 				},
 				content: function () {
-					player.addTempSkill('qixiang3','phaseJudgeAfter');
-				}
+					player.addTempSkill("qixiang3", "phaseJudgeAfter");
+				},
 			},
 			qixiang2: {
-				trigger:{player:'judge'},
+				trigger: { player: "judge" },
 				forced: true,
 				filter: function (event, player) {
 					if (event.card) {
 						if (event.card.viewAs) {
-							return event.card.viewAs=='bingliang';
-						}
-						else{
-							return event.card.name=='bingliang';
+							return event.card.viewAs == "bingliang";
+						} else {
+							return event.card.name == "bingliang";
 						}
 					}
 				},
 				content: function () {
-					player.addTempSkill('qixiang4','phaseJudgeAfter');
-				}
+					player.addTempSkill("qixiang4", "phaseJudgeAfter");
+				},
 			},
 			qixiang3: {
 				mod: {
 					suit: function (card, suit) {
-						if(suit=='diamond') return 'heart';
-					}
-				}
+						if (suit == "diamond") return "heart";
+					},
+				},
 			},
 			qixiang4: {
 				mod: {
 					suit: function (card, suit) {
-						if(suit=='spade') return 'club';
-					}
-				}
+						if (suit == "spade") return "club";
+					},
+				},
 			},
 			nianrui: {
-				trigger:{player:['phaseBegin','phaseEnd']},
+				trigger: { player: ["phaseBegin", "phaseEnd"] },
 				content: function () {
-					"step 0"
+					"step 0";
 					player.judge(function (card) {
-						return get.color(card)=='red'?1:0;
+						return get.color(card) == "red" ? 1 : 0;
 					});
-					"step 1"
+					("step 1");
 					if (result.bool) {
 						player.draw();
 					}
-				}
+				},
 			},
 			lianyu: {
-				enable:'phaseUse',
+				enable: "phaseUse",
 				usable: 1,
-				filterCard:{color:'red'},
-				check:function(card){return 6-get.value(card)},
+				filterCard: { color: "red" },
+				check: function (card) {
+					return 6 - get.value(card);
+				},
 				filterTarget: true,
 				selectTarget: -1,
-				line:'fire',
+				line: "fire",
 				content: function () {
-					target.damage('fire');
+					target.damage("fire");
 				},
 				ai: {
 					result: {
@@ -98,20 +98,20 @@ game.import('character', function () {
 							var eff = 0;
 							for (var i = 0; i < game.players.length; i++) {
 								if (!game.players[i].isOut()) {
-									eff+=get.damageEffect(game.players[i],player,player,'fire');
+									eff += get.damageEffect(game.players[i], player, player, "fire");
 								}
 							}
 							return eff;
-						}
 						},
-					expose:0.1
-				}
+					},
+					expose: 0.1,
+				},
 			},
 			manjia: {
-				group:['manjia1','manjia2']
+				group: ["manjia1", "manjia2"],
 			},
 			manjia1: {
-				trigger:{target:'useCardToBefore'},
+				trigger: { target: "useCardToBefore" },
 				forced: true,
 				priority: 6,
 				filter: function (event, player) {
@@ -126,15 +126,15 @@ game.import('character', function () {
 						target: function (card, player, target, current) {
 							if (target.getEquip(2)) return;
 							return lib.skill.tengjia1.ai.effect.target.apply(this, arguments);
-						}
-					}
-				}
+						},
+					},
+				},
 			},
 			manjia2: {
-				trigger:{player:'damageBegin'},
+				trigger: { player: "damageBegin" },
 				filter: function (event, player) {
 					if (player.getEquip(2)) return false;
-					if(event.hasNature('fire')) return true;
+					if (event.hasNature("fire")) return true;
 				},
 				forced: true,
 				check: function () {
@@ -148,12 +148,12 @@ game.import('character', function () {
 						target: function (card, player, target, current) {
 							if (target.getEquip(2)) return;
 							return lib.skill.tengjia2.ai.effect.target.apply(this, arguments);
-						}
-					}
-				}
+						},
+					},
+				},
 			},
 			xiaoshou: {
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				filter: function (event, player) {
 					var players = game.players.slice(0);
 					players.sort(function (a, b) {
@@ -166,14 +166,14 @@ game.import('character', function () {
 					players.sort(function (a, b) {
 						return b.hp - a.hp;
 					});
-					return get.damageEffect(players[0],player,player,'fire')>0;
+					return get.damageEffect(players[0], player, player, "fire") > 0;
 				},
 				prompt: function () {
 					var players = game.players.slice(0);
 					players.sort(function (a, b) {
 						return b.hp - a.hp;
 					});
-					return '枭首：是否对'+get.translation(players[0])+'造成1点火焰伤害？';
+					return "枭首：是否对" + get.translation(players[0]) + "造成1点火焰伤害？";
 				},
 				content: function () {
 					var players = game.players.slice(0);
@@ -181,63 +181,63 @@ game.import('character', function () {
 						return b.hp - a.hp;
 					});
 					if (players[0].hp > players[1].hp && players[0] != player) {
-						players[0].damage('fire');
-						player.line(players[0],'fire');
+						players[0].damage("fire");
+						player.line(players[0], "fire");
 					}
 				},
 				ai: {
-					expose:0.2
-				}
+					expose: 0.2,
+				},
 			},
 			guiji: {
-				trigger:{player:'phaseJudgeBegin'},
+				trigger: { player: "phaseJudgeBegin" },
 				forced: true,
 				content: function () {
-					player.discard(player.getCards('j').randomGet());
+					player.discard(player.getCards("j").randomGet());
 				},
 				filter: function (event, player) {
-					return player.countCards('j')>0;
+					return player.countCards("j") > 0;
 				},
 				ai: {
 					effect: {
 						target: function (card, player, target, current) {
-							if(get.type(card)=='delay'&&target.countCards('j')==0) return 0.1;
-						}
-					}
-				}
+							if (get.type(card) == "delay" && target.countCards("j") == 0) return 0.1;
+						},
+					},
+				},
 			},
 			qiangzheng: {
 				audio: 2,
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				direct: true,
 				forced: true,
 				filter: function (event, player) {
 					for (var i = 0; i < game.players.length; i++) {
-						if(game.players[i]!=player&&game.players[i].countCards('h')) return true;
+						if (game.players[i] != player && game.players[i].countCards("h")) return true;
 					}
 					return false;
 				},
 				content: function () {
-					"step 0"
-					player.chooseTarget('获得一名角色的一张手牌',true,function(card,player,target){
-						return player!=target&&target.countCards('h')>0;
+					"step 0";
+					player.chooseTarget("获得一名角色的一张手牌", true, function (card, player, target) {
+						return player != target && target.countCards("h") > 0;
 					}).ai = function (target) {
 						return -get.attitude(player, target);
 					};
-					"step 1"
+					("step 1");
 					if (result.targets && result.targets.length) {
-						player.logSkill('qiangzheng',result.targets);
-						player.gain(result.targets[0].getCards('h').randomGet(),result.targets[0]);
+						player.logSkill("qiangzheng", result.targets);
+						player.gain(result.targets[0].getCards("h").randomGet(), result.targets[0]);
 						result.targets[0].$give(1, player);
 						game.delay();
 					}
 				},
 				ai: {
-					threaten:1.7
-				}
+					threaten: 1.7,
+				},
 			},
 			suoling: {
-				trigger:{player:'phaseEnd'},
+				trigger: { player: "phaseEnd" },
 				forced: true,
 				filter: function (event, player) {
 					if (player.isLinked()) return true;
@@ -249,12 +249,12 @@ game.import('character', function () {
 					return false;
 				},
 				content: function () {
-					"step 0"
+					"step 0";
 					event.targets = game.players.slice(0);
 					event.targets.remove(player);
 					event.targets.sort(lib.sort.seat);
 					if (player.isLinked()) player.link();
-					"step 1"
+					("step 1");
 					if (event.targets.length) {
 						var target = event.targets.shift();
 						if (!target.isLinked()) {
@@ -262,10 +262,10 @@ game.import('character', function () {
 						}
 						event.redo();
 					}
-				}
+				},
 			},
 			xixing: {
-				enable:'phaseUse',
+				enable: "phaseUse",
 				usable: 1,
 				filterCard: function (card) {
 					var type = get.type(card);
@@ -276,7 +276,7 @@ game.import('character', function () {
 				},
 				complexCard: true,
 				selectCard: 3,
-				position:'he',
+				position: "he",
 				filterTarget: function (card, player, target) {
 					return player != target;
 				},
@@ -287,9 +287,9 @@ game.import('character', function () {
 					return 10 - get.value(card);
 				},
 				content: function () {
-					"step 0"
+					"step 0";
 					target.damage();
-					"step 1"
+					("step 1");
 					player.recover();
 				},
 				ai: {
@@ -297,46 +297,47 @@ game.import('character', function () {
 					result: {
 						target: function (player, target) {
 							return get.damageEffect(target, player);
-						}
 						},
-					expose:0.2
-				}
-			}
+					},
+					expose: 0.2,
+				},
+			},
 		},
 		translate: {
-			nianshou:'年兽',
-			nianrui:'年瑞',
-			qixiang:'祺祥',
-			qixiang1:'祺祥',
-			qixiang2:'祺祥',
-			nianrui_info:'准备阶段和结束阶段，你可以进行一次判定，若结果为红色则摸一张牌。',
-			qixiang_info:'乐不思蜀判定时，你的方块判定牌视为红桃；兵粮寸断判定时，你的黑桃判定牌视为草花。',
+			nianshou: "年兽",
+			nianrui: "年瑞",
+			qixiang: "祺祥",
+			qixiang1: "祺祥",
+			qixiang2: "祺祥",
+			nianrui_info: "准备阶段和结束阶段，你可以进行一次判定，若结果为红色则摸一张牌。",
+			qixiang_info: "乐不思蜀判定时，你的方块判定牌视为红桃；兵粮寸断判定时，你的黑桃判定牌视为草花。",
 
-			mamian:'马面',
-			lianyu:'炼狱',
-			lianyu_info:'出牌阶段限一次，你可以弃置一张红色手牌令场上所有角色受到1点火焰伤害。',
+			mamian: "马面",
+			lianyu: "炼狱",
+			lianyu_info: "出牌阶段限一次，你可以弃置一张红色手牌令场上所有角色受到1点火焰伤害。",
 
-			niutou:'牛头',
-			manjia:'蛮甲',
-			manjia1:'蛮甲',
-			manjia2:'蛮甲',
-			manjia_info:'锁定技，若你的装备区内没有防具牌，则你视为装备了【藤甲】。',
-			xiaoshou:'枭首',
-			xiaoshou_info:'结束阶段，若场上体力值最多的角色只有一个，你可以对其造成1点火焰伤害。',
-			guiji:'诡计',
-			guiji_info:'锁定技，准备阶段结束时，若你的判定区内有牌，你随机弃置其中一张牌。',
+			niutou: "牛头",
+			manjia: "蛮甲",
+			manjia1: "蛮甲",
+			manjia2: "蛮甲",
+			manjia_info: "锁定技，若你的装备区内没有防具牌，则你视为装备了【藤甲】。",
+			xiaoshou: "枭首",
+			xiaoshou_info: "结束阶段，若场上体力值最多的角色只有一个，你可以对其造成1点火焰伤害。",
+			guiji: "诡计",
+			guiji_info: "锁定技，准备阶段结束时，若你的判定区内有牌，你随机弃置其中一张牌。",
 
-			baiwuchang:'白无常',
-			qiangzheng:'强征',
-			qiangzheng_info:'锁定技，结束阶段，你获得一名其他角色的一张手牌。',
-			zuijiu:'醉酒',
-			zuijiu_info:'锁定技，你的黑杀造成的伤害+1，造成伤害后须弃置一张手牌。',
+			baiwuchang: "白无常",
+			qiangzheng: "强征",
+			qiangzheng_info: "锁定技，结束阶段，你获得一名其他角色的一张手牌。",
+			zuijiu: "醉酒",
+			zuijiu_info: "锁定技，你的黑杀造成的伤害+1，造成伤害后须弃置一张手牌。",
 
-			heiwuchang:'黑无常',
-			suoling:'索令',
-			suoling_info:'锁定技，结束阶段，你解除横置状态，除你之外的所有角色进入横置状态。',
-			xixing:'吸星',
-			xixing_info:'出牌阶段限一次，你可以弃置三张不同类别的牌，对一名其他角色造成1点伤害，然后回复1点体力。',
+			heiwuchang: "黑无常",
+			suoling: "索令",
+			suoling_info: "锁定技，结束阶段，你解除横置状态，除你之外的所有角色进入横置状态。",
+			xixing: "吸星",
+			xixing_info:
+				"出牌阶段限一次，你可以弃置三张不同类别的牌，对一名其他角色造成1点伤害，然后回复1点体力。",
 		},
 	};
 });