pref: format @/character.

character/mtg.js

@@ -1,492 +1,516 @@
-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',
-		character:{
-			mtg_jiding:['male','qun',4,['mbaizhan','msilian']],
+		name: "mtg",
+		character: {
+			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:'金鬃阿耶尼是使用白色法术的鹏洛客。他长于净化身体与心灵的法术：用咒语来治疗、强化盟友，以及唤醒他人内在的心灵精华。',
+		characterIntro: {
+			mtg_jiding:
+				"这名白色魔法的使用者极其注重忠诚，正义和荣誉。他曾全力追捕茜卓纳拉，如今已不可思议地与这位火焰法师成为伙伴。",
+			mtg_qianzhuo:
+				"茜卓纳拉是使用红色法术力的旅法师。她擅长使用火焰：除了火焰，还是火焰。茜卓性格冲动、易怒、富有激情，不断增长的火焰法术能力随时都准备爆发。她的火花在还很年轻时便已点燃，如今已是相当有经验的烈焰术士和旅法师。",
+			mtg_jiesi:
+				"杰斯贝连是使用蓝色法术的鹏洛客。他擅长心灵法术：读取心灵，幻影，知识，以及欺瞒的咒语。",
+			mtg_lilianna:
+				"莉莲娜维斯是一位精通死灵术的旅法师，她擅长用黑色法术力来复活死者，腐化生者，并从死亡中召唤力量。",
+			mtg_nisha:
+				"赞迪卡妖精部落玖瑞加的一名战士，做事倾尽全力，与大地有密切的联系，还擅使元素魔法。她能够引导时空的魔法生机地脉，为土地赋予生命。",
+			mtg_ayeni:
+				"金鬃阿耶尼是使用白色法术的鹏洛客。他长于净化身体与心灵的法术：用咒语来治疗、强化盟友，以及唤醒他人内在的心灵精华。",
 		},
-		skill:{
-			mduohun:{
-				trigger:{player:'dyingAfter'},
-				forced:true,
-				filter:function(event,player){
-					return event.source&&event.source.isIn()&&event.source.hp>0;
+		skill: {
+			mduohun: {
+				trigger: { player: "dyingAfter" },
+				forced: true,
+				filter: function (event, player) {
+					return event.source && event.source.isIn() && event.source.hp > 0;
 				},
-				logTarget:'source',
-				content:function(){
+				logTarget: "source",
+				content: function () {
 					trigger.source.loseHp();
 				},
-				ai:{
-					threaten:function(player,target){
-						if(target.hp==1) return 0.6;
+				ai: {
+					threaten: function (player, target) {
+						if (target.hp == 1) return 0.6;
 						return 1;
 					},
-					effect:{
-						target:function(card,player,target,current){
-							if(!target.hasFriend()) return;
-							if(target.hp<=1&&get.tag(card,'damage')) return [1,0,0,-1];
-						}
-					}
-				}
+					effect: {
+						target: function (card, player, target, current) {
+							if (!target.hasFriend()) return;
+							if (target.hp <= 1 && get.tag(card, "damage")) return [1, 0, 0, -1];
+						},
+					},
+				},
 			},
-			lingyong:{
-				enable:'phaseUse',
-				filter:function(event,player){
-					return !player.hasSkill('subplayer')&&player.getSubPlayers('lingyong_get').length>0;
+			lingyong: {
+				enable: "phaseUse",
+				filter: function (event, player) {
+					return !player.hasSkill("subplayer") && player.getSubPlayers("lingyong_get").length > 0;
 				},
-				nosub:true,
-				group:'lingyong_get',
-				direct:true,
-				delay:0,
-				skillAnimation:true,
-				animationColor:'thunder',
-				content:function(){
-					player.callSubPlayer().set('tag','lingyong_get');
+				nosub: true,
+				group: "lingyong_get",
+				direct: true,
+				delay: 0,
+				skillAnimation: true,
+				animationColor: "thunder",
+				content: function () {
+					player.callSubPlayer().set("tag", "lingyong_get");
 				},
-				ai:{
-					order:1,
-					result:{
-						player:function(player,target){
+				ai: {
+					order: 1,
+					result: {
+						player: function (player, target) {
 							return 1;
 							// if(player.hp<=1) return 1;
 							// if(!player.needsToDiscard(player.hp-1)) return 1;
 							// return 0;
-						}
-					}
-				},
-				subSkill:{
-					get:{
-						trigger:{global:'dieAfter'},
-						forced:true,
-						filter:function(event,player){
-							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);
-							for(var i=0;i<skills.length;i++){
-								if(lib.skill[skills[i]].nosub){
-									skills.splice(i--,1);
+					},
+				},
+				subSkill: {
+					get: {
+						trigger: { global: "dieAfter" },
+						forced: true,
+						filter: function (event, player) {
+							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);
+							for (var i = 0; i < skills.length; i++) {
+								if (lib.skill[skills[i]].nosub) {
+									skills.splice(i--, 1);
 								}
 							}
 							player.addSubPlayer({
-								name:trigger.player.name,
-								skills:skills,
-								hs:get.cards(2),
-								intro:'出牌阶段，你可以调遣此随从（直到随从死亡不可再次切换）'
+								name: trigger.player.name,
+								skills: skills,
+								hs: get.cards(2),
+								intro: "出牌阶段，你可以调遣此随从（直到随从死亡不可再次切换）",
 							});
-						}
-					}
-				}
-			},
-			mhuanyi:{
-				round:2,
-				trigger:{player:'phaseEnd'},
-				direct:true,
-				addintro:function(storage,player){
-					if(player.hasSkill('mhuanyi_target')){
-						return '直到下一回合开始，当成为某类型的卡牌的惟一目标时，将目标转移给某名其他角色；'
-					}
-					return '';
+						},
+					},
 				},
-				content:function(){
-					'step 0'
-					var rand=Math.random();
-					player.chooseTarget(get.prompt2('mhuanyi'),function(card,player,target){
-						return target!=player;
-					}).set('ai',function(target){
-						if(get.attitude(player,target)<0){
-							return rand;
-						}
-						return 0;
-					});
-					'step 1'
-					if(result.bool){
-						event.target=result.targets[0];
-						if(player.isUnderControl(true)){
-							player.line(event.target,'green');
-						}
-						player.chooseControl('基本牌','非基本牌','cancel2',function(){
-							return Math.floor(Math.random()*2);
-						}).set('prompt','选择一种卡牌类型');
+			},
+			mhuanyi: {
+				round: 2,
+				trigger: { player: "phaseEnd" },
+				direct: true,
+				addintro: function (storage, player) {
+					if (player.hasSkill("mhuanyi_target")) {
+						return "直到下一回合开始，当成为某类型的卡牌的惟一目标时，将目标转移给某名其他角色；";
 					}
-					else{
+					return "";
+				},
+				content: function () {
+					"step 0";
+					var rand = Math.random();
+					player
+						.chooseTarget(get.prompt2("mhuanyi"), function (card, player, target) {
+							return target != player;
+						})
+						.set("ai", function (target) {
+							if (get.attitude(player, target) < 0) {
+								return rand;
+							}
+							return 0;
+						});
+					("step 1");
+					if (result.bool) {
+						event.target = result.targets[0];
+						if (player.isUnderControl(true)) {
+							player.line(event.target, "green");
+						}
+						player
+							.chooseControl("基本牌", "非基本牌", "cancel2", function () {
+								return Math.floor(Math.random() * 2);
+							})
+							.set("prompt", "选择一种卡牌类型");
+					} else {
 						event.finish();
 					}
-					'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'});
+					("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" });
 					}
 				},
-				subSkill:{
-					target:{
-						trigger:{target:'useCardToBefore'},
-						priority:6,
-						forced:true,
-						onremove:true,
-						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(player.storage.mhuanyi_target[1]!=0) return false;
+				subSkill: {
+					target: {
+						trigger: { target: "useCardToBefore" },
+						priority: 6,
+						forced: true,
+						onremove: true,
+						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 (player.storage.mhuanyi_target[1] != 0) return false;
+							} else {
+								if (player.storage.mhuanyi_target[1] != 1) return false;
 							}
-							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;
 						},
-						logTarget:function(event,player){
+						logTarget: function (event, player) {
 							return player.storage.mhuanyi_target[0];
 						},
-						content:function(){
-							trigger.target=player.storage.mhuanyi_target[0];
-							player.removeSkill('mhuanyi_target');
-						}
-					},
-					die:{
-						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 () {
+							trigger.target = player.storage.mhuanyi_target[0];
+							player.removeSkill("mhuanyi_target");
 						},
-						content:function(){
-							player.removeSkill('mhuanyi_target');
-						}
-					}
-				}
+					},
+					die: {
+						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");
+						},
+					},
+				},
 			},
-			msuoling:{
-				trigger:{global:'useCard'},
-				direct:true,
-				priority:5.5,
-				round:1,
-				filter:function(event,player){
-					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;
+			msuoling: {
+				trigger: { global: "useCard" },
+				direct: true,
+				priority: 5.5,
+				round: 1,
+				filter: function (event, player) {
+					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;
 						return true;
 					}
 					return false;
 				},
-				content:function(){
-					'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){
-						return get.suit(card)==suit;
-					}).set('autodelay',true).set('logSkill',['msuoling',trigger.player]).ai=function(card){
-						if(att<0){
-							return 8-get.value(card);
+				content: function () {
+					"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) {
+							return get.suit(card) == suit;
+						})
+						.set("autodelay", true)
+						.set("logSkill", ["msuoling", trigger.player]).ai = function (card) {
+						if (att < 0) {
+							return 8 - get.value(card);
 						}
 						return 0;
 					};
-					'step 1'
-					if(result.bool){
+					("step 1");
+					if (result.bool) {
 						trigger.cancel();
-						player.chooseUseTarget(true,trigger.card);
+						player.chooseUseTarget(true, trigger.card);
 					}
-				}
+				},
 			},
-			msuoling_old:{
-				enable:'phaseUse',
-				usable:1,
-				subSkill:{
-					ai:{
-						onremove:true
-					}
+			msuoling_old: {
+				enable: "phaseUse",
+				usable: 1,
+				subSkill: {
+					ai: {
+						onremove: true,
+					},
 				},
-				filter:function(event,player){
-					var nh=player.countCards('h');
-					if(nh<=1||nh>=5) return false;
-					return lib.skill.msuoling.getc(player).number>0;
+				filter: function (event, player) {
+					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');
-					for(var i=0;i<hs.length;i++){
-						if(hs[i].mtongnian_link){
+				getc: function (player) {
+					var hs = player.getCards("h");
+					for (var i = 0; i < hs.length; i++) {
+						if (hs[i].mtongnian_link) {
 							return hs[i];
 						}
 					}
 					return -1;
 				},
-				getn:function(player){
-					var hs=player.getCards('h');
-					var ns=[];
-					for(var i=0;i<hs.length;i++){
-						if(!hs[i].mtongnian_link){
+				getn: function (player) {
+					var hs = player.getCards("h");
+					var ns = [];
+					for (var i = 0; i < hs.length; i++) {
+						if (!hs[i].mtongnian_link) {
 							ns.push(hs[i].number);
 						}
 					}
 					return ns;
 				},
-				test:function(player){
-					var cs=lib.skill.msuoling.getc(player).number;
-					var ns=lib.skill.msuoling.getn(player);
-					return lib.skill.msuoling.calc(ns,cs);
+				test: function (player) {
+					var cs = lib.skill.msuoling.getc(player).number;
+					var ns = lib.skill.msuoling.getn(player);
+					return lib.skill.msuoling.calc(ns, cs);
 				},
-				calc:function(arr, num){
-					for(var i=0;i<arr.length;i++){
-						if(arr[i]==num){
+				calc: function (arr, num) {
+					for (var i = 0; i < arr.length; i++) {
+						if (arr[i] == num) {
 							return true;
 						}
 					}
-					if(arr.length>1){
-						for(var i=0;i<arr.length-1;i++){
-							for(var j=i+1;j<arr.length;j++){
-								var brr=[];
-								for(var k=0;k<arr.length;k++){
-									if(k!=i&&k!=j){
+					if (arr.length > 1) {
+						for (var i = 0; i < arr.length - 1; i++) {
+							for (var j = i + 1; j < arr.length; j++) {
+								var brr = [];
+								for (var k = 0; k < arr.length; k++) {
+									if (k != i && k != j) {
 										brr.push(arr[k]);
 									}
 								}
-								if(lib.skill.msuoling.calc(brr.concat([arr[i]+arr[j]]),num)) return true;
-								if(lib.skill.msuoling.calc(brr.concat([arr[i]-arr[j]]),num)) return true;
-								if(lib.skill.msuoling.calc(brr.concat([arr[i]*arr[j]]),num)) return true;
-								if(lib.skill.msuoling.calc(brr.concat([arr[i]/arr[j]]),num)) return true;
+								if (lib.skill.msuoling.calc(brr.concat([arr[i] + arr[j]]), num)) return true;
+								if (lib.skill.msuoling.calc(brr.concat([arr[i] - arr[j]]), num)) return true;
+								if (lib.skill.msuoling.calc(brr.concat([arr[i] * arr[j]]), num)) return true;
+								if (lib.skill.msuoling.calc(brr.concat([arr[i] / arr[j]]), num)) return true;
 							}
 						}
 					}
 					return false;
 				},
-				check:function(card){
+				check: function (card) {
 					// if(player.isUnderControl(true)) return 0;
-					var player=_status.event.player;
-					if(player.hasSkill('msuoling_ai')){
+					var player = _status.event.player;
+					if (player.hasSkill("msuoling_ai")) {
 						return false;
 					}
-					if(lib.skill.msuoling.test(player)){
+					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'
+				content: function () {
+					"step 0";
 					player.showHandcards();
-					'step 1'
-					if(lib.skill.msuoling.test(player)){
-						var card=lib.skill.msuoling.getc(player);
-						card.classList.remove('glow');
+					("step 1");
+					if (lib.skill.msuoling.test(player)) {
+						var card = lib.skill.msuoling.getc(player);
+						card.classList.remove("glow");
 						delete card.mtongnian_link;
 						delete card._destroy;
 
-						var list=lib.skill.mtongnian.getList(player);
-						if(list.length){
-							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';
+						var list = lib.skill.mtongnian.getList(player);
+						if (list.length) {
+							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";
 						}
 					}
 				},
-				selectCard:[1,Infinity],
-				ai:{
-					order:11
-				}
+				selectCard: [1, Infinity],
+				ai: {
+					order: 11,
+				},
 			},
-			mtongnian:{
-				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;
+			mtongnian: {
+				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;
 					}
 					return false;
 				},
-				getList:function(player){
-					var list=[];
-					var enemies=player.getEnemies();
-					for(var i=0;i<enemies.length;i++){
-						list.addArray(enemies[i].getCards('h'));
+				getList: function (player) {
+					var list = [];
+					var enemies = player.getEnemies();
+					for (var i = 0; i < enemies.length; i++) {
+						list.addArray(enemies[i].getCards("h"));
 					}
 					return list;
 				},
-				content:function(){
-					var list=lib.skill.mtongnian.getList(player);
-					if(list.length){
-						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';
+				content: function () {
+					var list = lib.skill.mtongnian.getList(player);
+					if (list.length) {
+						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";
 					}
 				},
-				group:['mtongnian_change','mtongnian_use','mtongnian_lose'],
-				subSkill:{
-					change:{
-						trigger:{player:'useCard'},
-						silent:true,
-						filter:function(event,player){
-							return player.hasCard(function(card){
-								return card.mtongnian_link?true:false;
-							},'h');
+				group: ["mtongnian_change", "mtongnian_use", "mtongnian_lose"],
+				subSkill: {
+					change: {
+						trigger: { player: "useCard" },
+						silent: true,
+						filter: function (event, player) {
+							return player.hasCard(function (card) {
+								return card.mtongnian_link ? true : false;
+							}, "h");
 						},
-						content:function(){
-							var list=lib.skill.mtongnian.getList(player);
-							var hs=player.getCards('h',function(card){
-								return card.mtongnian_link?true:false;
+						content: function () {
+							var list = lib.skill.mtongnian.getList(player);
+							var hs = player.getCards("h", function (card) {
+								return card.mtongnian_link ? true : false;
 							});
-							for(var i=0;i<hs.length;i++){
-								var current=hs[i].mtongnian_link;
-								hs[i].mtongnian_link=list.randomGet(current);
-								if(!hs[i].mtongnian_link){
-									hs[i].mtongnian_link=current;
+							for (var i = 0; i < hs.length; i++) {
+								var current = hs[i].mtongnian_link;
+								hs[i].mtongnian_link = list.randomGet(current);
+								if (!hs[i].mtongnian_link) {
+									hs[i].mtongnian_link = current;
 								}
 								hs[i].init(hs[i].mtongnian_link);
 							}
-						}
-					},
-					use:{
-						trigger:{player:'useCardBefore'},
-						silent:true,
-						filter:function(event,player){
-							return event.card.mtongnian_link?true:false;
 						},
-						content:function(){
-							var link=trigger.card.mtongnian_link;
-							var target=get.owner(link);
-							if(target&&target!=player){
+					},
+					use: {
+						trigger: { player: "useCardBefore" },
+						silent: true,
+						filter: function (event, player) {
+							return event.card.mtongnian_link ? true : false;
+						},
+						content: function () {
+							var link = trigger.card.mtongnian_link;
+							var target = get.owner(link);
+							if (target && target != player) {
 								trigger.cards.add(trigger.card);
-								player.lose(trigger.cards,ui.discardPile);
-								trigger.card=link;
-								trigger.cards.length=0;
+								player.lose(trigger.cards, ui.discardPile);
+								trigger.card = link;
+								trigger.cards.length = 0;
 								trigger.cards.push(link);
-								target.lose(link,ui.discardPile);
-								player.logSkill('mtongnian',target);
-								game.log(target,'失去了',link);
+								target.lose(link, ui.discardPile);
+								player.logSkill("mtongnian", target);
+								game.log(target, "失去了", link);
 								game.delayx();
-							}
-							else{
+							} else {
 								player.lose(trigger.card);
 								trigger.cancel();
 							}
-						}
+						},
 					},
-					lose:{
-						trigger:{player:'phaseUseEnd',global:'loseEnd'},
-						silent:true,
-						filter:function(event,player){
-							if(event.name=='lose'){
-								return lib.skill.mtongnian.getList(player).length==0;
+					lose: {
+						trigger: { player: "phaseUseEnd", global: "loseEnd" },
+						silent: true,
+						filter: function (event, player) {
+							if (event.name == "lose") {
+								return lib.skill.mtongnian.getList(player).length == 0;
 							}
 							return true;
 						},
-						content:function(){
-							var hs=player.getCards('h',function(card){
-								return card.mtongnian_link?true:false;
+						content: function () {
+							var hs = player.getCards("h", function (card) {
+								return card.mtongnian_link ? true : false;
 							});
-							if(hs.length){
-								player.lose(hs)._triggered=null;
+							if (hs.length) {
+								player.lose(hs)._triggered = null;
 							}
-						}
-					}
+						},
+					},
+				},
+				ai: {
+					threaten: 1.3,
 				},
-				ai:{
-					threaten:1.3
-				}
 			},
-			mbaizhan:{
-				trigger:{source:'damageEnd'},
-				forced:true,
-				filter:function(event){
-					return event.num>0;
+			mbaizhan: {
+				trigger: { source: "damageEnd" },
+				forced: true,
+				filter: function (event) {
+					return event.num > 0;
 				},
-				content:function(){
+				content: function () {
 					player.changeHujia(trigger.num);
 				},
-				ai:{
-					damageBonus:true
-				}
+				ai: {
+					damageBonus: true,
+				},
 			},
-			msilian:{
-				trigger:{player:'phaseEnd'},
-				filter:function(event,player){
-					return player.hujia>0;
+			msilian: {
+				trigger: { player: "phaseEnd" },
+				filter: function (event, player) {
+					return player.hujia > 0;
 				},
-				check:function(event,player){
-					return player.hujia>1&&player.hp>1;
+				check: function (event, player) {
+					return player.hujia > 1 && player.hp > 1;
 				},
-				content:function(){
-					player.storage.msilian=player.hujia;
+				content: function () {
+					player.storage.msilian = player.hujia;
 					player.changeHujia(-player.hujia);
 					player.insertPhase();
 				},
-				group:['msilian_hp','msilian_draw'],
-				subSkill:{
-					hp:{
-						trigger:{player:'phaseAfter'},
-						silent:true,
-						filter:function(event,player){
-							return event.skill=='msilian'&&!player.getStat('damage');
+				group: ["msilian_hp", "msilian_draw"],
+				subSkill: {
+					hp: {
+						trigger: { player: "phaseAfter" },
+						silent: true,
+						filter: function (event, player) {
+							return event.skill == "msilian" && !player.getStat("damage");
 						},
-						content:function(){
+						content: function () {
 							player.loseHp();
-						}
-					},
-					draw:{
-						trigger:{player:'phaseDrawBegin'},
-						filter:function(event){
-							return event.getParent('phase').skill=='msilian';
 						},
-						silent:true,
-						content:function(){
-							trigger.num+=player.storage.msilian-2;
-						}
-					}
-				}
-			}
+					},
+					draw: {
+						trigger: { player: "phaseDrawBegin" },
+						filter: function (event) {
+							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:'阿耶尼',
+		translate: {
+			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,118 +1,123 @@
-import { lib, game, ui, get, ai, _status } from '../noname.js';
-game.import('character', function () {
-	return {
-		name:'xiake',
-		character:{
-			// xk_dongfangweiming:['male','shu',4,[]],
-			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']],
-		},
-		skill:{
-			zhongzhan:{
-				trigger:{source:'damageBegin'},
-				logTarget:'player',
-				check:function(event,player){
-					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;
-				},
-				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;
-					}
-				},
-				enable:'phaseUse',
-				position:'e',
-				filter:function(event,player){
-					return player.hasCard(card=>lib.skill.rouquan.filterCard(card,player),lib.skill.rouquan.position);
-				},
-				filterCard:lib.filter.cardRecastable,
-				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)});
-					for(var i=0;i<cards.length;i++){
-						if(get.equipValue(cards[i])>=val){
-							return 1;
-						}
-					}
-					return 0;
-				},
-				content:function(){
-					player.recast(cards);
-				},
-				ai:{
-					order:9.5,
-					result:{
-						player:1
-					}
-				}
-			},
-			gzhenji:{
-				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';
-				},
-				content:function(){
-					player.draw();
-					player.addTempSkill('gzhenji3');
-				}
-			},
-			gzhenji3:{
-				mod:{
-					cardUsable:function(card,player,num){
-						if(card.name=='sha') return num+1;
-					}
-				},
-			},
-			zitong:{
-				trigger:{player:'useCard'},
-				frequent:true,
-				filter:function(event,player){
-					return _status.currentPhase==player&&player.countUsed()==3;
-				},
-				content:function(){
-					var card=get.cardPile('chuansongmen');
-					if(!card){
-						card=game.createCard('chuansongmen');
-					}
-					player.gain(card,'gain2');
-				},
-				ai:{
-					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:'当你于自己的回合内使用第三张牌时，你可以将一张传送门置于你的手牌。',
-		},
-	};
-});
+import { lib, game, ui, get, ai, _status } from "../noname.js";
+game.import("character", function () {
+	return {
+		name: "xiake",
+		character: {
+			// xk_dongfangweiming:['male','shu',4,[]],
+			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"]],
+		},
+		skill: {
+			zhongzhan: {
+				trigger: { source: "damageBegin" },
+				logTarget: "player",
+				check: function (event, player) {
+					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;
+				},
+				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;
+					},
+				},
+				enable: "phaseUse",
+				position: "e",
+				filter: function (event, player) {
+					return player.hasCard(
+						(card) => lib.skill.rouquan.filterCard(card, player),
+						lib.skill.rouquan.position
+					);
+				},
+				filterCard: lib.filter.cardRecastable,
+				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) });
+					for (var i = 0; i < cards.length; i++) {
+						if (get.equipValue(cards[i]) >= val) {
+							return 1;
+						}
+					}
+					return 0;
+				},
+				content: function () {
+					player.recast(cards);
+				},
+				ai: {
+					order: 9.5,
+					result: {
+						player: 1,
+					},
+				},
+			},
+			gzhenji: {
+				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";
+				},
+				content: function () {
+					player.draw();
+					player.addTempSkill("gzhenji3");
+				},
+			},
+			gzhenji3: {
+				mod: {
+					cardUsable: function (card, player, num) {
+						if (card.name == "sha") return num + 1;
+					},
+				},
+			},
+			zitong: {
+				trigger: { player: "useCard" },
+				frequent: true,
+				filter: function (event, player) {
+					return _status.currentPhase == player && player.countUsed() == 3;
+				},
+				content: function () {
+					var card = get.cardPile("chuansongmen");
+					if (!card) {
+						card = game.createCard("chuansongmen");
+					}
+					player.gain(card, "gain2");
+				},
+				ai: {
+					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: "当你于自己的回合内使用第三张牌时，你可以将一张传送门置于你的手牌。",
+		},
+	};
+});

character/zhuogui.js

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