import { lib, game, ui, get, ai, _status } from "../noname.js";
game.import("character", function () {
	return {
		name: "xianjian",
		character: {
			pal_lixiaoyao: ["male", "qun", 4, ["tianjian", "xjyufeng"]],
			pal_zhaoliner: ["female", "wei", 3, ["huimeng", "tianshe"]],
			pal_linyueru: ["female", "wei", 3, ["guiyuan", "qijian"]],
			pal_anu: ["female", "wu", 3, ["lingdi", "anwugu"]],

			pal_wangxiaohu: ["male", "qun", 4, ["husha"]],
			pal_sumei: ["female", "shu", 3, ["sheying", "dujiang", "huahu"]],
			pal_shenqishuang: ["female", "wei", 3, ["qixia", "jianzhen", "binxin"]],

			pal_jingtian: ["male", "wu", 3, ["sajin", "jtjubao"]],
			pal_xuejian: ["female", "shu", 3, ["xshuangren", "shenmu", "duci"]],
			pal_longkui: ["female", "qun", 3, ["fenxing", "diewu", "lingyu"]],
			pal_zixuan: ["female", "wei", 3, ["shuiyun", "wangyou", "changnian"]],
			pal_changqing: ["male", "wei", 4, ["luanjian", "ctianfu"]],

			pal_nangonghuang: ["male", "wei", 3, ["zhaoyao", "sheling", "zhangmu"]],
			pal_wenhui: ["female", "shu", 4, ["huxi", "longxiang"]],
			pal_wangpengxu: ["female", "shu", 3, ["duxinshu", "feixu"]],
			pal_xingxuan: ["male", "wei", 3, ["feizhua", "leiyu", "lingxue"]],
			pal_leiyuange: ["male", "shu", 4, ["feng", "ya", "song"]],

			pal_yuntianhe: ["male", "wu", 4, ["longxi", "zhuyue", "guanri"]],
			pal_hanlingsha: ["female", "shu", 3, ["tannang", "tuoqiao"]],
			pal_liumengli: ["female", "wei", 3, ["tianxian", "runxin", "xjzhimeng"]],
			pal_murongziying: ["male", "wei", 4, ["xuanning", "poyun", "qianfang"]],
			pal_xuanxiao: ["male", "wei", 4, ["xuanyan", "ningbin", "xfenxin"]],

			pal_jiangyunfan: ["male", "wei", 4, ["xunying", "liefeng"]],
			pal_tangyurou: ["female", "shu", 3, ["txianqu", "qiongguang"]],
			pal_longyou: ["male", "wei", 4, ["yuexing", "minsha"]],
			pal_xiaoman: ["female", "shu", 3, ["anwugu", "lingquan", "shenwu"]],

			pal_xiahoujinxuan: ["male", "shu", 3, ["xuanmo", "danqing"]],
			pal_muchanglan: ["female", "wu", 3, ["feixia", "lueying"]],
			pal_xia: ["female", "shu", 3, ["xjzongyu", "fanling"]],
			pal_jiangcheng: ["male", "qun", 4, ["yanzhan", "fenshi"]],

			pal_yuejinzhao: ["male", "wei", 4, ["ywuhun", "xjyingfeng"]],
			pal_yueqi: ["female", "wei", 3, ["tianwu", "liguang", "shiying"]],
			pal_mingxiu: ["female", "shu", 3, ["linghuo", "guijin", "chengxin"]],
			pal_xianqing: ["male", "qun", 4, ["xtanxi", "xiaoyue"]],
			pal_luozhaoyan: ["female", "shu", 4, ["fenglue", "tanhua"]],
			pal_jushifang: ["male", "shu", 3, ["yujia", "xiepan", "yanshi"]],
		},
		characterIntro: {
			pal_lixiaoyao:
				"一个天资聪颖的乡下客栈店小二，因一壶酒被酒剑仙传授了蜀山仙剑派剑术，在仙灵岛与赵灵儿相遇，自此经历重重磨难成长为一代旷世奇侠。灵儿牺牲以后他悲痛欲绝。后出任蜀山掌门，取道号一贫，从此御剑行遍天下，行侠仗义、斩妖除魔。多年后因魔教之乱，故引咎卸职，成为蜀山七圣之一。而后虽心力交瘁，但仍竭力保护天下苍生。",
			pal_zhaoliner:
				"林青儿与巫王之女，亦是女娲族人。自幼与世隔绝，跟随姥姥隐居仙灵岛修炼，躲避仇人的追杀。难以告人的神秘身世，让她逃不过命运的捉弄，注定在滚滚红尘中历尽千灾万劫。在最终，赵灵儿为了消灭拜月水魔兽，与其同归于尽。但在王小虎、李忆如决战大魔头千叶禅师的结尾，出现了她的声音。",
			pal_linyueru:
				"天资灵秀，聪敏慧黠，情深义重。身为江南武林魁首林家堡之武门千金，与李逍遥不打不相识，并在此后的寻人旅途中相知相恋。在经历过重重艰辛和生离死别后，遥月二人终于携手而共结连理，与高堂娇儿共享天伦。",

			pal_wangxiaohu:
				"李逍遥的同乡，自小仰慕李逍遥，想要拜在他门下，得知拜师无望之后，遂跟随李大婶学习排云掌法。之后前往杭州拜“三大神捕”之一的”神眼魔刀”盛尊武为师，并习得魔刀刀法。热血少年，敢作敢当，嫉恶如仇，相信人定胜天。他最后发现千叶禅师的阴谋，与众人合力击败千叶禅师。",
			pal_sumei:
				"蛇妖和狐精之女，其父母当年被李逍遥和林月如所杀，因此她一直想要报仇，可以说是为报仇而活着。爱上王小虎，认识李忆如之后，苏媚学会了宽恕，最后甚至为了朋友和爱人牺牲自己。",
			pal_shenqishuang:
				"乳名沈七七，峨嵋山仙霞派掌门清柔师太座下弟子，与四位师姊妹合称“仙霞五奇”，排行第四，个性拘谨温婉，对小虎心怀爱意却不敢开口表达。",

			pal_jingtian:
				"永安当的小伙计，司“管饰”一职，专门保管当铺收押的首饰珠宝类贵重物品。景天不但有鉴别古董珠宝的天赋，而且对买卖、帐目能很精通，对保管的当品更有过目不忘的本事。每日幻想有朝一日能富甲天下或成为人人景仰的蜀山剑仙。",
			pal_xuejian:
				"出身唐门，虽为大小姐，却备受家族内部排挤欺凌。后离开唐家堡，与景天等人一同浪迹江湖并探寻自己的身世秘密。经历各种事件后，与景天结为连理，并育有一子名为景小楼。",
			pal_longkui:
				"古时的姜国公主，景天前世龙阳的妹妹。因国破家亡而跳入铸剑炉，成为魔剑剑灵。龙葵拥有两种性格形态：蓝色龙葵温柔娴淑，红色龙葵火辣张扬。",
			pal_zixuan:
				"女娲族后裔，饱受情爱煎熬三生三世之苦。在面对为了天下苍生而牺牲生命的女娲族宿命时，她坦然接受，把自己用水灵珠修炼的内丹渡给徐长卿使他成为上仙，最后献出自己的生命封印锁妖塔。",
			pal_changqing:
				"蜀山仙剑派俗家弟子。自幼被蜀山掌门清微收为入室弟子，武学天赋极高。与紫萱相恋三世，最终紫萱为修复锁妖塔而牺牲了自己并把自己用水灵珠修炼的内丹渡给徐长卿，使徐长卿迅速成仙并继任蜀山派第二十三代掌门，最后辞去了掌门职务归隐。",

			pal_nangonghuang:
				'出生不久后父母被为了追寻记忆而来燎日所误杀，后来被常纪带到蜀山抚养长大，视同己出。从小希望得到尊敬。后来奉蜀山掌门徐长卿之命开启地脉入口，疏通五灵，从而使蜀山"否极泰来"、回复混沌状态。',
			pal_wenhui:
				"爽朗大方，性情如同男子，极富正义感；内心却是天真少女般剔透明净。因为不愿嫁去室韦而逃出家里，后与南宫煌相遇，并随其完成地脉任务。",
			pal_wangpengxu:
				"原形是一只娇小可爱的五毒兽。擅长读心术，可以看透人的心思。多次被南宫煌无意中救下，后跟随其恢复地脉。",
			pal_xingxuan:
				"南宫煌之兄，幼时被燎日带走并由其抚养长大。身体其实是一具尸体（尸体是其父赤炎的），不仅残缺而且带有剧毒。初，灵肉分离，身体毫无感觉，后经重楼相助灵肉合一。为使尸身不坏，使用剧毒保存，故无法进入人界，绝大多数时间身在里蜀山。有领导才能，凭借自身上位者的气质和才干，在里蜀山妖界占据了一定势力。",
			pal_leiyuange:
				"是个来历成谜的木讷男子，擅长使用弩、单手斧，有三只名为风雅颂的怪鸟时常出现在他的头顶代替其言语。生前为室韦族族长，死后尸体被鬼差附身。在胜洲与南宫煌与温慧等人结识，并成为好友。",

			pal_yuntianhe:
				"自幼孤身一人在黄山青鸾峰长大，从未下过山，对外界事物一无所知。一次偶然的机会与闯入父亲的墓室寻找宝藏的少女韩菱纱相遇。为了更多地了解父亲的过去、也为了成为剑仙，云天河与韩菱纱和柳梦璃一同拜入昆仑琼华派成为门下弟子。下山后云天河虽经历种种，但从未改变过“我命由我不由天”的想法。",
			pal_hanlingsha:
				"背负着家族命运而四处奔走的少女，自称是独行千里的陵墓大盗。年纪不大，却对辨识墓穴位置、破解奇诡机关、地脉风水之学颇有研究。",
			pal_liumengli: "妖界婵幽之女，因19年前妖界大战而失散，被云天青行侠救下后送至寿阳城县家抚养。",
			pal_murongziying:
				"昆仑琼华派弟子。很小就被家人送至琼华派修行，天赋极高，在同辈弟子中修为较深，已臻“以气御剑”的境界。性格外冷内热，稳重内敛；看似不易相处，实则是一个恩怨分明、极重情义的热血男儿。",
			pal_xuanxiao:
				"天赋异禀，资质极佳，是万中无一的修仙奇才，和夙玉用双剑束缚幻瞑界吸取灵力并引发琼华派与妖界之战。因夙玉离开昆仑，修炼双剑中断，他被邪火入侵而走火入魔，打伤数名师兄弟，被夙瑶联合青阳、重光与宗炼长老冰封19年，因此逢缘与云天河结拜。",

			// pal_jiangyunfan:'',
			// pal_tangyurou:'',
			// pal_longyou:'',
			// pal_xiaoman:'',

			pal_xiahoujinxuan:
				"夏侯世家的少主。因不喜舞枪弄剑，专爱趣闻逸史，让父亲深感恨铁不成钢；好在他对于仙术符法也有所涉略，没沦落到手无缚鸡之力的境地。",
			pal_muchanglan:
				"行走江湖买卖消息的佣兵，冷艳霸气，洞察力强。受人雇佣而加入夏侯瑾轩等一行人，虽然目的不纯，但通过相处，渐渐地被改变；同时通过夏侯瑾轩等人的帮助，完成了救治暮蔼村村民的心愿。",
			pal_xia:
				"走江湖卖艺为生的孤女，性格倔强，自尊心强，不喜欢被人小看，更不爱占别人的便宜。卖艺的艰辛让她深知人间冷暖，却仍保持善良天性。",
			pal_jiangcheng:
				"折剑山庄庄主欧阳英的得意门生，但因其蚩尤后人魔族的身份，令他无法被容于人界；再加上人界半魔同族饱受人类迫害，故最终成为净天教教主魔君“姜世离”，毅然肩负起保护同族的重任。",
		},
		skill: {
			lingquan: {
				trigger: { player: "phaseEnd" },
				forced: true,
				skillAnimation: true,
				animationColor: "water",
				unique: true,
				filter: function (event, player) {
					return game.roundNumber >= 3 && player.getHistory("useCard").length > player.hp;
				},
				content: function () {
					"step 0";
					player.awakenSkill("lingquan");
					player.draw(3);
					player.addSkill("shuiyun");
					"step 1";
					if (lib.filter.filterTrigger(trigger, player, "phaseEnd", "shuiyun"))
						game.createTrigger("phaseEnd", "shuiyun", player, trigger);
				},
			},
			shenwu: {
				trigger: { global: "phaseEnd" },
				forced: true,
				skillAnimation: true,
				animationColor: "water",
				unique: true,
				filter: function (event, player) {
					return player.storage.shuiyun_count >= 3;
				},
				content: function () {
					player.awakenSkill("shenwu");
					player.gainMaxHp();
					player.recover();
					player.addSkill("huimeng");
				},
			},
			qiongguang: {
				trigger: { player: "phaseDiscardEnd" },
				filter: function (event, player) {
					return event.cards && event.cards.length > 1;
				},
				content: function () {
					"step 0";
					event.targets = player.getEnemies().sortBySeat();
					"step 1";
					if (event.targets.length) {
						player.line(event.targets.shift().getDebuff(false).addExpose(0.1), "green");
						event.redo();
					}
					"step 2";
					game.delay();
				},
				ai: {
					threaten: 2,
					expose: 0.2,
					effect: {
						player: function (card, player) {
							if (_status.currentPhase != player) return;
							if (_status.event.name != "chooseToUse" || _status.event.player != player) return;
							var num = player.needsToDiscard();
							if (num > 2 || num == 1) return;
							if (get.type(card) == "basic" && num != 2) return;
							if (get.tag(card, "gain")) return;
							if (get.value(card, player, "raw") >= 7) return;
							if (player.hp <= 2) return;
							if (!player.hasSkill("jilue") || player.storage.renjie == 0) {
								return "zeroplayertarget";
							}
						},
					},
				},
			},
			txianqu: {
				trigger: { source: "damageBefore" },
				logTarget: "player",
				filter: function (event, player) {
					if (player.hasSkill("txianqu2")) return false;
					var evt = event.getParent("phaseUse");
					if (evt && evt.player == player) return true;
					return false;
				},
				check: function (event, player) {
					var target = event.player;
					if (get.attitude(player, target) >= 0 || get.damageEffect(target, player, player) <= 0)
						return true;
					if (target.hp > player.hp && player.isDamaged()) return true;
					return false;
				},
				content: function () {
					trigger.cancel();
					player.draw(2);
					player.recover();
					player.addTempSkill("txianqu2");
				},
				ai: {
					jueqing: true,
					skillTagFilter: function (player, tag, arg) {
						if (!arg) return false;
						if (player.hasSkill("txianqu2")) return false;
						if (get.attitude(player, arg) > 0) return false;
						var evt = _status.event.getParent("phaseUse");
						if (evt && evt.player == player) return true;
						return false;
					},
					effect: {
						player: function (card, player, target) {
							if (get.tag(card, "damage") && get.attitude(player, target) > 0) {
								if (
									player.hp == player.maxHp ||
									get.recoverEffect(player, player, player) <= 0
								)
									return "zeroplayertarget";
								return [0, 0, 0, 0.5];
							}
						},
					},
				},
			},
			txianqu2: {},
			xunying: {
				trigger: { player: "shaAfter" },
				direct: true,
				filter: function (event, player) {
					return player.canUse("sha", event.target) && player.hasSha() && event.target.isIn();
				},
				content: function () {
					"step 0";
					if (player.hasSkill("jiu")) {
						player.removeSkill("jiu");
						event.jiu = true;
					}
					player.chooseToUse(get.prompt("xunying"), { name: "sha" }, trigger.target, -1).logSkill =
						"xunying";
					"step 1";
					if (result.bool);
					else if (event.jiu) {
						player.addSkill("jiu");
					}
				},
			},
			liefeng: {
				trigger: { player: "useCard" },
				forced: true,
				popup: false,
				filter: function (event, player) {
					return _status.currentPhase == player && [2, 3, 4].includes(player.countUsed());
				},
				content: function () {
					var skill;
					switch (player.countUsed()) {
						case 2:
							skill = "yanzhan";
							break;
						case 3:
							skill = "tianjian";
							break;
						case 4:
							skill = "xjyufeng";
							break;
					}
					if (skill && !player.hasSkill(skill)) {
						player.addTempSkill(skill);
						player.popup(skill);
						game.log(player, "获得了", "【" + get.translation(skill) + "】");
						if (skill == "xjyufeng") {
							var nh = player.countCards("h");
							if (nh < 2) {
								player.draw(2 - nh);
								player.addSkill("counttrigger");
								if (!player.storage.counttrigger) {
									player.storage.counttrigger = {};
								}
								player.storage.counttrigger.xjyufeng = 1;
							}
						}
					}
				},
				ai: {
					effect: {
						player_use(card, player) {
							if (_status.currentPhase != player) return;
							if (get.type(card) == "basic") return;
							if (get.tag(card, "gain")) return;
							if (get.value(card, player, "raw") >= 7) return;
							if (player.hp <= 2) return;
							if (player.needsToDiscard()) return;
							if (player.countUsed() >= 2) return;
							return "zeroplayertarget";
						},
					},
				},
			},
			yuexing: {
				enable: "phaseUse",
				usable: 1,
				filterTarget: function (card, player, target) {
					return target != player;
				},
				content: function () {
					player.storage.yuexing2 = target;
					player.addTempSkill("yuexing2", "phaseUseAfter");
					target.storage.yuexing2 = player;
					target.addTempSkill("yuexing2", "phaseUseAfter");
				},
				ai: {
					order: function () {
						var player = _status.event.player;
						if (player.hasSkill("minsha")) return 6.5;
						return 2;
					},
					result: {
						target: function (player, target) {
							if (
								player.hasSkill("minsha") &&
								player.countCards("he") >= 3 &&
								target.hp > 1 &&
								get.damageEffect(target, player, player, "thunder") > 0
							) {
								var num1 = game.countPlayer(function (current) {
									if (
										get.distance(target, current) <= 1 &&
										current != player &&
										current != target
									) {
										return -get.sgn(get.attitude(player, current));
									}
								});
								var num2 = game.countPlayer(function (current) {
									if (
										get.distance(player, current) <= 1 &&
										current != player &&
										current != target
									) {
										return -get.sgn(get.attitude(player, current));
									}
								});
								if (num2 >= num1) return 0;
								return 2 * (num2 - num1);
							}
							return -_status.event.getRand();
						},
					},
				},
			},
			yuexing2: {
				mark: "character",
				intro: {
					content: "到其他角色的距离基数与$交换",
				},
				onremove: true,
				mod: {
					globalFrom: function (from, to, distance) {
						if (from.storage.yuexing2) {
							var dist1 = get.distance(from, to, "pure");
							var dist2 = get.distance(from.storage.yuexing2, to, "pure");
							return distance - dist1 + dist2;
						}
					},
				},
			},
			minsha: {
				enable: "phaseUse",
				usable: 1,
				filterCard: true,
				selectCard: 2,
				position: "he",
				filter: function (event, player) {
					return player.countCards("he") >= 2;
				},
				filterTarget: function (card, player, target) {
					return target != player && target.hp > 1;
				},
				line: "thunder",
				check: function (card) {
					return 8 - get.value(card);
				},
				content: function () {
					"step 0";
					target.damage("thunder");
					"step 1";
					event.targets = game
						.filterPlayer(function (current) {
							return (
								get.distance(target, current) <= 1 && current != target && current != player
							);
						})
						.sortBySeat(target);
					"step 2";
					if (event.targets.length) {
						event.targets.shift().randomDiscard(false);
						event.redo();
					}
				},
				ai: {
					order: 6,
					result: {
						player: function (player, target) {
							if (get.damageEffect(target, player, player, "thunder") > 0) {
								if (target == player.storage.yuexing2) {
									return 10;
								}
								var num =
									1 +
									game.countPlayer(function (current) {
										if (
											get.distance(target, current) <= 1 &&
											current != player &&
											current != target
										) {
											return -get.sgn(get.attitude(player, current));
										}
									});
								if (target.hp == 1) {
									num += 2;
								}
								if (target.hp < player.hp) {
									num += 0.5;
								}
								if (player.needsToDiscard()) num += 0.1;
								return num;
							}
						},
					},
				},
			},
			lingdi: {
				enable: "phaseUse",
				filter: function (event, player) {
					var num = 1 + (player.getStat().skill.lingdi || 0);
					if (
						game.hasPlayer(function (current) {
							return current != player && Math.max(1, get.distance(player, current)) == num;
						})
					) {
						var hs = player.getCards("h");
						var suits = player.storage.lingdi || [];
						for (var i = 0; i < hs.length; i++) {
							if (!suits.includes(get.suit(hs[i]))) {
								return true;
							}
						}
					}
					return false;
				},
				filterTarget: function (card, player, target) {
					return (
						target != player &&
						Math.max(1, get.distance(player, target)) == 1 + (player.getStat().skill.lingdi || 0)
					);
				},
				filterCard: function (card, player) {
					return !(player.storage.lingdi || []).includes(get.suit(card));
				},
				check: function (card) {
					return 8 - get.value(card);
				},
				content: function () {
					game.asyncDraw([player, target]);
					if (!player.storage.lingdi) {
						player.storage.lingdi = [];
					}
					player.storage.lingdi.add(get.suit(cards[0]));
				},
				ai: {
					threaten: 1.2,
					order: 7,
					result: {
						target: 1,
					},
				},
				group: "lingdi_clear",
				subSkill: {
					clear: {
						trigger: { player: "phaseAfter" },
						silent: true,
						content: function () {
							delete player.storage.lingdi;
						},
					},
				},
			},
			xiaoyue: {
				trigger: { global: "roundStart" },
				forced: true,
				filter: function (event, player) {
					return player.countCards("h", "sha");
				},
				content: function () {
					var card = player.getCards("h", "sha").randomGet();
					var target = player.getEnemies().randomGet();
					if (card && target) {
						target.addExpose(0.1);
						player.useCard(card, target, false);
						player.changeHujia();
					}
				},
				ai: {
					effect: {
						player: function (card, player, target) {
							if (_status.currentPhase != player) return;
							if (
								card.name == "sha" &&
								get.itemtype(card) == "card" &&
								!player.needsToDiscard() &&
								target.hp > 1 &&
								player.countCards("h", "sha") == 1
							) {
								return "zeroplayertarget";
							}
						},
					},
				},
			},
			xiaoyue2: {
				mod: {
					cardRespondable: function (card, player) {
						if (_status.event.getParent(4).name == "xiaoyue" && get.suit(card) != "heart")
							return false;
					},
				},
			},
			huanlei: {
				trigger: { player: "damageEnd" },
				check: function (event, player) {
					return get.damageEffect(event.source, player, player, "thunder") > 0;
				},
				filter: function (event, player) {
					return event.source && event.source.isIn() && event.source.hp > player.hp;
				},
				logTarget: "source",
				content: function () {
					"step 0";
					trigger.source.damage("thunder");
					"step 1";
					trigger.source.draw();
				},
			},
			anwugu: {
				trigger: { source: "damageEnd" },
				check: function (event, player) {
					return get.attitude(player, event.player) < 0;
				},
				filter: function (event, player) {
					if (event._notrigger.includes(event.player)) return false;
					return event.player != player && event.player.isIn() && !event.player.hasSkill("anwugu2");
				},
				logTarget: "player",
				content: function () {
					trigger.player.addSkill("anwugu2");
				},
			},
			anwugu2: {
				mod: {
					cardEnabled: function (card, player) {
						if (_status.currentPhase != player) return;
						if (player.countUsed() >= player.storage.anwugu2) return false;
					},
					maxHandcard: function (player, num) {
						return num - 1;
					},
				},
				mark: true,
				intro: {
					content: "手牌上限-1，每回合最多使用$张牌（剩余$回合）",
				},
				init: function (player) {
					player.storage.anwugu2 = 3;
				},
				trigger: { player: "phaseAfter" },
				silent: true,
				onremove: true,
				content: function () {
					player.storage.anwugu2--;
					if (player.storage.anwugu2 <= 0) {
						// player.loseHp();
						player.removeSkill("anwugu2");
					} else {
						player.updateMarks();
					}
				},
			},
			xtanxi: {
				enable: "phaseUse",
				usable: 1,
				filterCard: true,
				check: function (card) {
					var enemies = _status.event.player.getEnemies();
					var num1 = 0,
						num2 = 0;
					for (var i = 0; i < enemies.length; i++) {
						if (enemies[i].countCards("h", "sha")) num1++;
						if (enemies[i].countCards("h", "shan")) num2++;
						if (enemies[i].countCards("h") >= 3) {
							num1 += 0.5;
							num2 += 0.5;
						}
					}
					var rand = _status.event.getRand();
					if (num1 >= 1 && num2 >= 1) {
						if (card.name == "shan") return (rand += 0.4);
						if (card.name == "sha") return rand;
					} else if (num1 >= 1) {
						if (card.name == "sha") return rand;
					} else if (num2 >= 1) {
						if (card.name == "shan") return rand;
					}
					return 0;
				},
				content: function () {
					player.addExpose(0.1);
					var targets = player.getEnemies();
					for (var i = 0; i < targets.length; i++) {
						if (!targets[i].countCards("h", cards[0].name)) {
							targets.splice(i--, 1);
						}
					}
					if (targets.length) {
						var target = targets.randomGet();
						player.line(target, "green");
						target.addExpose(0.1);
						player.gainPlayerCard(target, "h", "visible");
					}
				},
				ai: {
					order: 4,
					result: {
						player: 1,
					},
				},
			},
			linghuo: {
				round: 2,
				trigger: { global: "phaseEnd" },
				filter: function (event, player) {
					return event.player.getStat("damage") && event.player != player;
				},
				check: function (event, player) {
					return get.damageEffect(event.player, player, player, "fire") > 0;
				},
				logTarget: "player",
				line: "fire",
				ai: {
					expose: 0.2,
					threaten: 1.3,
				},
				content: function () {
					trigger.player.damage("fire");
				},
			},
			guijin: {
				round: 3,
				enable: "phaseUse",
				delay: 0,
				content: function () {
					"step 0";
					event.cards = get.cards(4);
					"step 1";
					if (event.cards.length) {
						var more = false,
							remain = false,
							nomore = false;
						if (event.cards.length >= 3) {
							for (var i = 0; i < event.cards.length; i++) {
								var value = get.value(event.cards[i], player, "raw");
								if (value >= 8) {
									more = true;
								}
								if (event.cards.length >= 4 && value < 6) {
									if (remain === false) {
										remain = value;
									} else {
										remain = Math.min(remain, value);
									}
								}
							}
						}
						if (remain === false) {
							remain = 0;
						}
						if (
							!more &&
							!game.hasPlayer(function (current) {
								return (
									get.attitude(player, current) < 0 &&
									!current.skipList.includes("phaseDraw")
								);
							})
						) {
							var num = 0;
							for (var i = 0; i < event.cards.length; i++) {
								num += Math.max(0, get.value(event.cards[i], player, "raw"));
							}
							if (num >= 12) {
								more = true;
							} else {
								nomore = true;
							}
						}
						player.chooseCardButton("归烬", event.cards, [1, event.cards.length]).ai = function (
							button
						) {
							if (nomore) return 0;
							if (more) {
								return get.value(button.link, player, "raw") - remain;
							} else {
								if (ui.selected.buttons.length) return 0;
								return 8 - get.value(button.link, player, "raw");
							}
						};
					} else {
						event.goto(4);
					}
					"step 2";
					if (result.bool) {
						for (var i = 0; i < result.links.length; i++) {
							event.cards.remove(result.links[i]);
						}
						event.togive = result.links.slice(0);
						player.chooseTarget("将" + get.translation(result.links) + "交给一名角色", true).ai =
							function (target) {
								var att =
									get.attitude(player, target) / Math.sqrt(target.countCards("h") + 1);
								if (result.links.length > 1) {
									if (target == player && target.needsToDiscard(result.links) > 1)
										return att / 5;
									return att;
								} else {
									if (target.skipList.includes("phaseDraw")) return att / 5;
									return -att;
								}
							};
					} else {
						event.goto(4);
					}
					"step 3";
					if (result.targets.length) {
						result.targets[0].gain(event.togive, "draw");
						result.targets[0].skip("phaseDraw");
						result.targets[0].addTempSkill("guijin2", { player: "phaseBegin" });
						game.log(
							result.targets[0],
							"获得了" + get.cnNumber(event.togive.length) + "张",
							"#g“归烬”牌"
						);
						player.line(result.targets[0], "green");
						event.goto(1);
					}
					"step 4";
					while (event.cards.length) {
						ui.cardPile.insertBefore(event.cards.pop(), ui.cardPile.firstChild);
					}
				},
				ai: {
					order: 1,
					result: {
						player: function (player) {
							if (game.roundNumber == 1 && player.hasUnknown()) return 0;
							return 1;
						},
					},
				},
			},
			guijin2: {
				mark: true,
				intro: {
					content: "跳过下一个摸牌阶段",
				},
				ai: {
					effect: {
						target: function (card, player, target) {
							if (card.name == "bingliang" || card.name == "caomu") return 0;
						},
					},
				},
			},
			chengxin: {
				round: 4,
				enable: "chooseToUse",
				filter: function (event, player) {
					return event.type == "dying";
				},
				filterTarget: function (card, player, target) {
					return target == _status.event.dying;
				},
				selectTarget: -1,
				content: function () {
					target.recover(1 - target.hp);
					target.addTempSkill("chengxin2", { player: "phaseAfter" });
				},
				ai: {
					order: 6,
					threaten: 1.4,
					skillTagFilter: function (player) {
						if (4 - (game.roundNumber - player.storage.chengxin_roundcount) > 0) return false;
						if (!_status.event.dying) return false;
					},
					save: true,
					result: {
						target: 3,
					},
				},
			},
			chengxin2: {
				trigger: { player: "damageBefore" },
				mark: true,
				forced: true,
				content: function () {
					trigger.cancel();
				},
				ai: {
					nofire: true,
					nothunder: true,
					nodamage: true,
					effect: {
						target: function (card, player, target, current) {
							if (get.tag(card, "damage")) return [0, 0];
						},
					},
				},
				intro: {
					content: "防止一切伤害",
				},
			},
			tianwu: {
				trigger: { player: "useCardToBegin" },
				filter: function (event, player) {
					if (get.is.altered("tianwu") && player.hasSkill("tianwu2")) return false;
					return (
						event.targets &&
						event.targets.length == 1 &&
						player.getEnemies().includes(event.target)
					);
				},
				// alter:true,
				frequent: true,
				content: function () {
					trigger.target.getDebuff();
					player.addTempSkill("tianwu2");
				},
			},
			tianwu2: {},
			shiying: {
				trigger: { global: "dieBefore" },
				skillAnimation: "epic",
				animationColor: "water",
				unique: true,
				init: function (player) {
					player.storage.shiying = false;
				},
				mark: true,
				intro: {
					content: "limited",
				},
				check: function (event, player) {
					return get.attitude(player, event.player) >= 3;
				},
				filter: function (event, player) {
					return !player.storage.shiying && event.player != player;
				},
				logTarget: "player",
				content: function () {
					"step 0";
					trigger.cancel();
					player.awakenSkill("shiying");
					player.storage.shiying = true;

					player.maxHp = 3;
					player.hp = 3;
					trigger.player.maxHp = 3;
					trigger.player.hp = 3;

					player.clearSkills();
					trigger.player.clearSkills();
					"step 1";
					var hs = player.getCards("hej");
					player.$throw(hs);
					player.lose(player.getCards("hej"))._triggered = null;
					"step 2";
					var hs = trigger.player.getCards("hej");
					trigger.player.$throw(hs);
					trigger.player.lose(trigger.player.getCards("hej"))._triggered = null;
					"step 3";
					game.asyncDraw([player, trigger.player], 3);
				},
				ai: {
					threaten: 1.5,
				},
			},
			liguang: {
				trigger: { player: "phaseEnd" },
				filter: function (event, player) {
					if (!player.canMoveCard()) return false;
					if (
						!game.hasPlayer(function (current) {
							return current.countCards("ej");
						})
					) {
						return false;
					}
					return player.countCards("h") > 0;
				},
				direct: true,
				content: function () {
					"step 0";
					player
						.chooseToDiscard(
							get.prompt("liguang"),
							"弃置一张手牌并移动场上的一张牌",
							lib.filter.cardDiscardable
						)
						.set("ai", function (card) {
							if (!_status.event.check) return 0;
							return 7 - get.useful(card);
						})
						.set("check", player.canMoveCard(true))
						.set("logSkill", "liguang");
					"step 1";
					if (result.bool) {
						player.moveCard(true);
					} else {
						event.finish();
					}
				},
				ai: {
					expose: 0.2,
					threaten: 1.3,
				},
			},
			xiepan: {
				trigger: { player: "loseEnd" },
				direct: true,
				filter: function (event, player) {
					if (player.countCards("h", { type: "basic" })) return false;
					if (!player.countCards("h")) return false;
					for (var i = 0; i < event.cards.length; i++) {
						if (event.cards[i].original == "h" && get.type(event.cards[i]) == "basic")
							return true;
					}
					return false;
				},
				content: function () {
					"step 0";
					player
						.chooseToDiscard("h", get.prompt("xiepan"))
						.set("prompt2", "弃置一张手牌并获一件随机装备")
						.set("logSkill", "xiepan").ai = function (card) {
						return 8 - get.value(card);
					};
					"step 1";
					if (result.bool) {
						player.gain(game.createCard(get.inpile("equip").randomGet()), "draw");
					}
				},
			},
			yujia: {
				trigger: { player: "useCardAfter" },
				frequent: true,
				filter: function (event) {
					return get.type(event.card) == "equip" && lib.inpile.includes(event.card.name);
				},
				init: function (player) {
					player.storage.yujia = 0;
				},
				content: function () {
					"step 0";
					if (!player.storage.yujia) {
						player.storage.yujia = [];
					}
					var list = [];
					for (var i in lib.card) {
						if (lib.card[i].type == "jiguan") {
							list.push(i);
						}
					}
					if (list.length) {
						if (player.storage.yujia > 1) {
							list = list.randomGets(player.storage.yujia);
							for (var i = 0; i < list.length; i++) {
								list[i] = ["机关", "", list[i]];
							}
							player.chooseButton(true, ["御甲：选择一张机关牌获得之", [list, "vcard"]]).ai =
								function (button) {
									if (
										player.hasSkill("jiguanyaoshu_skill") &&
										button.link[2] == "jiguanyaoshu"
									)
										return 0;
									return get.value({ name: button.link[2] });
								};
						} else {
							var name = list.randomGet();
							player.gain(game.createCard(name), "draw");
							event.finish();
						}
					}
					"step 1";
					if (result.bool && result.links && result.links.length) {
						var list = [];
						for (var i = 0; i < result.links.length; i++) {
							list.push(game.createCard(result.links[i][2]));
						}
						player.gain(list, "draw");
					}
				},
				group: "yujia_count",
				subSkill: {
					count: {
						trigger: { player: "useCardAfter" },
						filter: function (event, player) {
							return get.type(event.card) == "jiguan";
						},
						silent: true,
						content: function () {
							player.storage.yujia++;
						},
					},
				},
				ai: {
					reverseEquip: true,
					threaten: 1.5,
					effect: {
						target_use(card, player, target, current) {
							if (get.type(card) == "equip") return [1, 3];
						},
					},
				},
			},
			yanshi: {
				trigger: { player: "phaseAfter" },
				forced: true,
				skillAnimation: true,
				init: function (player) {
					player.storage.yanshi = 0;
				},
				filter: function (event, player) {
					return player.storage.yanshi == 4;
				},
				intro: {
					content: "累计#个回合使用过机关牌",
				},
				content: function () {
					"step 0";
					player.awakenSkill("yanshi");
					player.gainMaxHp();
					"step 1";
					player.recover();
					var list = [];
					for (var i = 1; i <= 5; i++) {
						if (!player.getEquip(i)) {
							var name = get.inpile("equip" + i).randomGet();
							if (name) {
								var card = game.createCard(name);
								list.push(card);
								player.equip(card);
							}
						}
					}
					if (list.length) {
						player.$draw(list);
					}
				},
				group: "yanshi_count",
				subSkill: {
					count: {
						trigger: { player: "useCardAfter" },
						filter: function (event, player) {
							return get.type(event.card) == "jiguan" && !player.hasSkill("yanshi2");
						},
						silent: true,
						content: function () {
							player.storage.yanshi++;
							if (player.hasSkill("yanshi")) {
								player.markSkill("yanshi");
								player.updateMarks();
							}
							player.addTempSkill("yanshi2");
						},
					},
				},
			},
			yanshi2: {},
			tanhua: {
				trigger: { player: "recoverBefore" },
				forced: true,
				filter: function (event, player) {
					return player.hp > 0 && event.num > 0;
				},
				content: function () {
					trigger.cancel();
					player.draw(2 * trigger.num);
				},
				group: "tanhua_remove",
				subSkill: {
					remove: {
						trigger: { player: "dying" },
						priority: 10,
						forced: true,
						content: function () {
							player.recover();
							player.removeSkill("tanhua");
						},
					},
				},
			},
			xjyingfeng: {
				trigger: { player: "useCardAfter" },
				filter: function (event, player) {
					if (event.card.name != "sha") return false;
					if (event.parent.name == "xjyingfeng") return false;
					var enemies = player.getEnemies();
					return game.hasPlayer(function (current) {
						return (
							enemies.includes(current) &&
							!event.targets.includes(current) &&
							player.canUse("sha", current, false)
						);
					});
				},
				forced: true,
				content: function () {
					var enemies = player.getEnemies();
					enemies.remove(trigger.targets);
					if (enemies.length) {
						player.useCard({ name: "sha" }, enemies.randomGet().addExpose(0.2));
					}
				},
			},
			ywuhun: {
				trigger: { player: "phaseBefore" },
				forced: true,
				// alter:true,
				filter: function (event) {
					return event.parent.name != "ywuhun";
				},
				intro: {
					content: "回合结束后，场上及牌堆中的牌将恢复到回合前的状态",
				},
				video: function (player, data) {
					for (var i in data) {
						var current = game.playerMap[i];
						current.node.handcards1.innerHTML = "";
						current.node.handcards2.innerHTML = "";
						current.node.equips.innerHTML = "";
						current.node.judges.innerHTML = "";
						current.directgain(get.infoCards(data[i].h));
						var es = get.infoCards(data[i].e);
						for (var j = 0; j < es.length; j++) {
							current.$equip(es[j]);
						}
						var js = get.infoCards(data[i].j);
						for (var j = 0; j < js.length; j++) {
							current.node.judges.appendChild(js[j]);
						}
					}
				},
				content: function () {
					"step 0";
					var handcards1, handcards2, judges, equips, viewAs, i, j;
					event.data = [];
					event.cardPile = [];

					for (i = 0; i < game.players.length; i++) {
						viewAs = [];
						handcards1 = [];
						handcards2 = [];
						judges = [];
						equips = [];

						for (j = 0; j < game.players[i].node.handcards1.childNodes.length; j++)
							handcards1.push(game.players[i].node.handcards1.childNodes[j]);

						for (j = 0; j < game.players[i].node.handcards2.childNodes.length; j++)
							handcards2.push(game.players[i].node.handcards2.childNodes[j]);

						for (j = 0; j < game.players[i].node.judges.childNodes.length; j++) {
							viewAs.push(game.players[i].node.judges.childNodes[j].viewAs);
							judges.push(game.players[i].node.judges.childNodes[j]);
						}

						for (j = 0; j < game.players[i].node.equips.childNodes.length; j++)
							equips.push(game.players[i].node.equips.childNodes[j]);

						event.data.push({
							player: game.players[i],
							handcards1: handcards1,
							handcards2: handcards2,
							judges: judges,
							equips: equips,
							viewAs: viewAs,
							value: handcards1.length + handcards2.length + equips.length - judges.length,
						});
					}
					for (var i = 0; i < ui.cardPile.childElementCount; i++) {
						event.cardPile.push(ui.cardPile.childNodes[i]);
					}
					"step 1";
					player.markSkill("ywuhun");
					player.addSkill("ywuhun_end");
					player.phase("ywuhun");
					"step 2";
					player.removeSkill("ywuhun_end");
					game.delay(0.5);
					"step 3";
					game.animate.window(1);
					"step 4";
					player.unmarkSkill("ywuhun");
					var storage = event.data;
					for (var i = 0; i < storage.length; i++) {
						var current = storage[i].player;
						if (current.isAlive()) {
							current.removeEquipTrigger();
							var cards = current.getCards("hej");
							for (var j = 0; j < cards.length; j++) {
								cards[j].discard();
							}
						}
					}
					"step 5";
					var storage = event.data;
					var current;
					var i, j;
					for (i = 0; i < storage.length; i++) {
						current = storage[i].player;
						if (current.isAlive()) {
							for (j = 0; j < storage[i].handcards1.length; j++) {
								if (
									storage[i].handcards1[j].parentNode == ui.discardPile ||
									storage[i].handcards1[j].parentNode == ui.cardPile
								) {
									current.node.handcards1.appendChild(storage[i].handcards1[j]);
								} else {
									current.node.handcards1.appendChild(
										game.createCard(storage[i].handcards1[j])
									);
								}
							}
							for (j = 0; j < storage[i].handcards2.length; j++) {
								if (
									storage[i].handcards2[j].parentNode == ui.discardPile ||
									storage[i].handcards2[j].parentNode == ui.cardPile
								) {
									current.node.handcards2.appendChild(storage[i].handcards2[j]);
								} else {
									current.node.handcards2.appendChild(
										game.createCard(storage[i].handcards2[j])
									);
								}
							}
							for (j = 0; j < storage[i].equips.length; j++) {
								if (
									storage[i].equips[j].parentNode == ui.discardPile ||
									storage[i].equips[j].parentNode == ui.cardPile
								) {
									storage[i].equips[j].style.transform = "";
									current.$equip(storage[i].equips[j]);
								} else {
									current.$equip(game.createCard(storage[i].equips[j]));
								}
							}
							for (j = 0; j < storage[i].judges.length; j++) {
								if (
									storage[i].judges[j].parentNode == ui.discardPile ||
									storage[i].judges[j].parentNode == ui.cardPile
								) {
									storage[i].judges[j].style.transform = "";
									storage[i].judges[j].viewAs = storage[i].viewAs[j];
									if (
										storage[i].judges[j].viewAs &&
										storage[i].judges[j].viewAs != storage[i].judges[j].name &&
										storage[i].judges[j].classList.contains("fullskin")
									) {
										storage[i].judges[j].classList.add("fakejudge");
										storage[i].judges[j].node.background.innerHTML =
											lib.translate[storage[i].judges[j].viewAs + "_bg"] ||
											get.translation(storage[i].judges[j].viewAs)[0];
									}
									current.node.judges.appendChild(storage[i].judges[j]);
								}
							}
							current.update();
						}
					}
					var data = {};
					for (var i = 0; i < game.players.length; i++) {
						data[game.players[i].dataset.position] = {
							h: get.cardsInfo(game.players[i].getCards("h")),
							e: get.cardsInfo(game.players[i].getCards("e")),
							j: get.cardsInfo(game.players[i].getCards("j")),
						};
					}
					game.addVideo("skill", event.player, ["ywuhun", data]);
					game.animate.window(2);
					while (ui.cardPile.childElementCount) {
						ui.cardPile.firstChild.discard();
					}
					for (var i = 0; i < event.cardPile.length; i++) {
						if (event.cardPile[i].parentNode == ui.discardPile) {
							ui.cardPile.appendChild(event.cardPile[i]);
						} else {
							ui.cardPile.appendChild(game.createCard(event.cardPile[i]));
						}
					}
					ui.updatehl();
				},
				subSkill: {
					end: {
						trigger: { source: "damageEnd" },
						priority: 9,
						silent: true,
						content: function () {
							var evt = _status.event.getParent("ywuhun");
							if (evt) {
								_status.event = evt;
								game.resetSkills();
							}
						},
						ai: {
							jueqing: true,
						},
					},
				},
			},
			fenglue: {
				trigger: { player: "phaseUseBefore" },
				direct: true,
				filter: function (event, player) {
					var hs = player.getCards("h");
					return game.hasPlayer(function (current) {
						if (current != player) {
							for (var i = 0; i < hs.length; i++) {
								if (get.info(hs[i]).multitarget) continue;
								if (lib.filter.targetEnabled2(hs[i], player, current)) {
									return true;
								}
							}
						}
					});
				},
				content: function () {
					"step 0";
					var hs = player.getCards("h");
					player.chooseTarget(get.prompt("fenglue"), function (card, player, target) {
						if (player == target) return false;
						for (var i = 0; i < hs.length; i++) {
							if (get.info(hs[i]).multitarget) continue;
							if (lib.filter.targetEnabled2(hs[i], player, target)) {
								return true;
							}
						}
						return false;
					}).ai = function (target) {
						var use = [],
							eff = 0,
							damaged = false;
						for (var i = 0; i < hs.length; i++) {
							if (get.info(hs[i]).multitarget) continue;
							var hef;
							if (get.tag(hs[i], "damage") && damaged) {
								hef = -1;
							} else {
								hef = get.effect(target, hs[i], player, player);
							}
							if (lib.filter.targetEnabled2(hs[i], player, target) && hef > 0) {
								use.push(hs[i]);
								if (get.attitude(player, target) > 0) {
									hef /= 1.5;
									if (get.tag(hs[i], "damage")) {
										damaged = true;
									}
								}
								eff += hef;
							}
						}
						if (
							!player.needsToDiscard(0, (i, player) => {
								return !use.includes(i) && !player.canIgnoreHandcard(i);
							})
						)
							return eff;
						return 0;
					};
					"step 1";
					if (result.bool) {
						event.target = result.targets[0];
						var num = 0;
						player.chooseCard(
							[1, Infinity],
							"按顺序选择对" + get.translation(result.targets) + "使用的牌",
							function (card) {
								return lib.filter.targetEnabled2(card, player, event.target);
							}
						).ai = function (card) {
							if (get.effect(event.target, card, player, player) > 0) {
								if (get.attitude(player, event.target) > 0 && get.tag(card, "damage")) {
									for (var i = 0; i < ui.selected.cards.length; i++) {
										if (get.tag(ui.selected.cards[i], "damage")) {
											return 0;
										}
									}
								}
								return get.order(card);
							}
							return 0;
						};
					} else {
						event.finish();
					}
					"step 2";
					if (result.bool) {
						player.logSkill("fenglue", event.target);
						player.addSkill("fenglue_draw");
						player.storage.fenglue_draw_num = 0;
						player.storage.fenglue_draw = event.target;
						trigger.cancel();
						event.cards = result.cards.slice(0);
						player.lose(event.cards, ui.special);
					} else {
						event.finish();
					}
					"step 3";
					if (event.cards.length) {
						if (event.target.isIn()) {
							player.useCard(event.cards.shift(), event.target);
						} else {
							event.cards.shift().discard();
						}
						event.redo();
					}
					"step 4";
					if (player.storage.fenglue_draw_num) {
						player.draw(player.storage.fenglue_draw_num);
					}
					player.removeSkill("fenglue_draw");
					delete player.storage.fenglue_draw;
					delete player.storage.fenglue_draw_num;
				},
				subSkill: {
					draw: {
						trigger: { global: "damageEnd" },
						forced: true,
						popup: false,
						filter: function (event, player) {
							return event.player == player.storage.fenglue_draw;
						},
						content: function () {
							player.storage.fenglue_draw_num++;
						},
					},
				},
				ai: {
					threaten: 1.3,
				},
			},
			xjzongyu: {
				enable: "phaseUse",
				usable: 1,
				filterCard: { color: "black" },
				filter: function (event, player) {
					return lib.card.feibiao && player.countCards("he", { color: "black" });
				},
				check: function (card) {
					return 8 - get.value(card);
				},
				content: function () {
					var list = player.getEnemies();
					if (list.length) {
						player.useCard({ name: "feibiao" }, list.randomGets(2));
					}
				},
				ai: {
					threaten: 1.5,
					order: 6,
					result: {
						player: 1,
					},
				},
			},
			fanling: {
				trigger: { global: "loseHpAfter" },
				forced: true,
				usable: 1,
				filter: function (event, player) {
					return event.player != player && player.isDamaged();
				},
				content: function () {
					player.recover();
				},
				ai: {
					threaten: 1.5,
				},
			},
			dujiang: {
				enable: "phaseUse",
				usable: 1,
				position: "he",
				filterCard: { color: "black" },
				check: function (card) {
					return 6 - get.value(card);
				},
				content: function () {
					var list = player.getEnemies();
					if (list.length) {
						var target = list.randomGet();
						player.line(target, "green");
						target.gain(game.createCard("du"), "gain2");
					}
				},
				ai: {
					order: 1,
					result: {
						player: 1,
					},
					threaten: 1.5,
				},
			},
			sheying: {
				trigger: { source: "damageAfter" },
				filter: function (event, player) {
					return get.itemtype(event.cards) == "cards" && get.position(event.cards[0]) == "d";
				},
				usable: 1,
				prompt2: function (event) {
					return "进行一次判定，若结果为黑色，你获得" + get.translation(event.cards);
				},
				content: function () {
					"step 0";
					player.judge(function (card) {
						return get.color(card) == "black" ? 1 : -1;
					});
					"step 1";
					if (result.color == "black") {
						player.gain(trigger.cards);
						player.$gain2(trigger.cards);
					}
				},
			},
			huahu: {
				enable: "phaseUse",
				unique: true,
				mark: true,
				skillAnimation: true,
				animationColor: "metal",
				init: function (player) {
					player.storage.huahu = false;
				},
				filter: function (event, player) {
					if (player.storage.huahu) return false;
					return true;
				},
				filterTarget: function (card, player, target) {
					return target != player;
				},
				selectTarget: [1, Infinity],
				contentBefore: function () {
					player.awakenSkill("huahu");
					player.storage.huahu = true;
					player.loseMaxHp(true);
					player.clearSkills();
				},
				content: function () {
					target.recover();
					target.changeHujia();
					target.draw(false);
					target.$draw();
				},
				ai: {
					order: 1,
					result: {
						target: function (player, target) {
							if (player.hasUnknown()) return 0;
							var num = 0;
							var players = game.filterPlayer();
							for (var i = 0; i < players.length; i++) {
								if (
									get.attitude(player, players[i]) > 2 &&
									get.recoverEffect(players[i], player, player) > 0
								) {
									if (players[i].hp == 1) {
										if (player.hp < player.maxHp) {
											return 1;
										} else {
											num += 2;
										}
									} else if (players[i].hp <= 2) {
										num++;
									}
								}
							}
							if (num >= 3) return 1;
							return 0;
						},
					},
				},
				intro: {
					content: "limited",
				},
			},
			binxin: {
				trigger: { global: "phaseEnd" },
				check: function (event, player) {
					return get.attitude(player, event.player) > 0;
				},
				filter: function (event, player) {
					return event.player.hp == 1;
				},
				logTarget: "player",
				content: function () {
					trigger.player.changeHujia();
				},
				ai: {
					expose: 0.1,
				},
			},
			qixia: {
				trigger: { player: ["useCardAfter", "respondAfter"] },
				silent: true,
				init: function (player) {
					player.storage.qixia = [];
				},
				// mark:true,
				intro: {
					content: function (storage) {
						if (!storage.length) {
							return "未使用或打出过有花色的牌";
						} else {
							var str = "已使用过" + get.translation(storage[0] + "2");
							for (var i = 1; i < storage.length; i++) {
								str += "、" + get.translation(storage[i] + "2");
							}
							str += "牌";
							return str;
						}
					},
				},
				content: function () {
					var suit = get.suit(trigger.card);
					if (suit) {
						player.storage.qixia.add(suit);
						player.syncStorage("qixia");
						player.markSkill("qixia");
					}
				},
				group: "qixia_phase",
				subSkill: {
					phase: {
						trigger: { global: "phaseAfter" },
						priority: -50,
						forced: true,
						filter: function (event, player) {
							return player.storage.qixia.length >= 4;
						},
						content: function () {
							player.insertPhase();
							player.storage.qixia.length = 0;
							player.syncStorage("qixia");
							player.unmarkSkill("qixia");
						},
					},
				},
			},
			qixia_old: {
				trigger: { global: "damageAfter" },
				direct: true,
				filter: function (event, player) {
					return (
						!player.hasSkill("qixia2") &&
						event.source != player &&
						event.player.isIn() &&
						player.countCards("he", { color: "red" })
					);
				},
				content: function () {
					"step 0";
					player
						.chooseToDiscard("he", get.prompt("qixia", trigger.player), { color: "red" })
						.set("logSkill", ["qixia", trigger.player]).ai = function (card) {
						if (get.attitude(player, trigger.player) > 0) {
							if (trigger.player.hp == 1) {
								return 10 - get.value(card);
							}
							return 8 - get.value(card);
						}
					};
					"step 1";
					if (result.bool) {
						player.addTempSkill("qixia2");
						trigger.player.draw(2);
						if (trigger.player.hp == 1 && !trigger.player.hujia) {
							trigger.player.changeHujia();
						}
					}
				},
				ai: {
					threaten: 1.8,
				},
			},
			qixia2: {},
			jianzhen: {
				trigger: { player: "shaAfter" },
				forced: true,
				filter: function (event, player) {
					return (
						event.target.isIn() &&
						game.hasPlayer(function (current) {
							return current.canUse("sha", event.target, false) && current != player;
						})
					);
				},
				content: function () {
					"step 0";
					event.targets = game.filterPlayer(function (current) {
						return current.canUse("sha", trigger.target, false) && current != player;
					});
					event.targets.sortBySeat(trigger.player);
					"step 1";
					if (event.targets.length) {
						event.current = event.targets.shift();
						if (event.current.hasSha()) {
							event.current.chooseToUse(
								{ name: "sha" },
								"是否对" + get.translation(trigger.target) + "使用一张杀？",
								trigger.target,
								-1
							);
						} else {
							event.redo();
						}
					} else {
						event.finish();
					}
					"step 2";
					if (!result.bool) {
						event.goto(1);
					}
				},
				ai: {
					expose: 0.2,
					threaten: 1.4,
				},
			},
			husha: {
				trigger: { player: "phaseEnd" },
				direct: true,
				filter: function (event, player) {
					if (player.storage.husha == 1) {
						return game.hasPlayer(function (current) {
							return player.canUse("sha", current, false);
						});
					} else {
						return player.storage.husha > 0;
					}
				},
				content: function () {
					"step 0";
					var list = [];
					if (
						game.hasPlayer(function (current) {
							return player.canUse("sha", current, false);
						})
					) {
						list.push("移去1枚虎煞标记，视为使用一张杀");
					}
					if (player.storage.husha > 1) {
						list.push("移去2枚虎煞标记，视为使用一张南蛮入侵");
						if (player.storage.husha > 2) {
							list.push("移去3枚虎煞标记，视为对除你之外的角色使用一张元素毁灭");
						}
					}
					player
						.chooseControl("cancel2", function () {
							if (player.storage.husha > 2) {
								var num1 = game.countPlayer(function (current) {
									if (current != player && player.canUse("yuansuhuimie", current)) {
										return get.sgn(
											get.effect(current, { name: "yuansuhuimie" }, player, player)
										);
									}
								});
								var num2 = game.countPlayer(function (current) {
									if (current != player && player.canUse("yuansuhuimie", current)) {
										return get.effect(current, { name: "yuansuhuimie" }, player, player);
									}
								});
								if (num1 > 0 && num2 > 0) return "选项三";
							}
							if (player.storage.husha > 1) {
								var num = game.countPlayer(function (current) {
									if (current != player && player.canUse("nanman", current)) {
										return get.sgn(
											get.effect(current, { name: "nanman" }, player, player)
										);
									}
								});
								if (num > 0) return "选项二";
							}
							if (
								game.hasPlayer(function (current) {
									return (
										player.canUse("sha", current, false) &&
										get.effect(current, { name: "sha" }, player, player) > 0
									);
								})
							) {
								return "选项一";
							}
							return "cancel2";
						})
						.set("prompt", get.prompt("husha"))
						.set("choiceList", list);
					"step 1";
					if (result.control != "cancel2") {
						player.logSkill("husha");
						if (result.control == "选项一") {
							event.sha = true;
							player.storage.husha--;
							player.chooseTarget("选择出杀的目标", true, function (card, player, target) {
								return player.canUse("sha", target, false);
							}).ai = function (target) {
								return get.effect(target, { name: "sha" }, player, player);
							};
						} else if (result.control == "选项二") {
							var list = game.filterPlayer(function (current) {
								return player.canUse("nanman", current);
							});
							player.storage.husha -= 2;
							list.sortBySeat();
							player.useCard({ name: "nanman" }, list);
						} else {
							var list = game.filterPlayer(function (current) {
								return player.canUse("yuansuhuimie", current);
							});
							player.storage.husha -= 3;
							list.remove(player);
							list.sortBySeat();
							player.useCard({ name: "yuansuhuimie" }, list);
						}
						if (!player.storage.husha) {
							player.unmarkSkill("husha");
						} else {
							player.syncStorage("husha");
							player.updateMarks();
						}
					}
					"step 2";
					if (event.sha && result.targets && result.targets.length) {
						player.useCard({ name: "sha" }, result.targets[0]);
					}
				},
				init: function (player) {
					player.storage.husha = 0;
				},
				intro: {
					content: "mark",
				},
				group: "husha_count",
				subSkill: {
					count: {
						trigger: { source: "damageEnd" },
						forced: true,
						filter: function (event, player) {
							if (player.storage.husha < 3) {
								var evt = event.getParent("phaseUse");
								return evt && evt.player == player;
							}
							return false;
						},
						content: function () {
							player.storage.husha += trigger.num;
							if (player.storage.husha > 3) {
								player.storage.husha = 3;
							}
							player.markSkill("husha");
							player.syncStorage("husha");
							player.updateMarks();
						},
					},
				},
			},
			fenshi: {
				unique: true,
				skillAnimation: true,
				animationColor: "fire",
				trigger: { player: "dyingAfter" },
				forced: true,
				mark: true,
				derivation: "longhuo",
				intro: {
					content: "limited",
				},
				content: function () {
					player.awakenSkill("fenshi");
					player.changeHujia(2);
					player.draw(2);
					player.addSkill("longhuo");
				},
			},
			longhuo: {
				unique: true,
				trigger: { player: "phaseEnd" },
				check: function (event, player) {
					if (player.hp == 1 && player.hujia == 0) return false;
					var num = game.countPlayer(function (current) {
						var eff = get.sgn(get.damageEffect(current, player, player, "fire"));
						if (current.hp == 1 && current.hujia == 0) eff *= 1.5;
						return eff;
					});
					return num > 0;
				},
				content: function () {
					"step 0";
					event.targets = get.players(lib.sort.seat);
					"step 1";
					if (event.targets.length) {
						var current = event.targets.shift();
						if (current.isIn()) {
							player.line(current, "fire");
							current.damage("fire");
							event.redo();
						}
					}
				},
			},
			yanzhan: {
				enable: "phaseUse",
				viewAs: { name: "sha", nature: "fire" },
				usable: 1,
				position: "he",
				viewAsFilter: function (player) {
					if (!player.countCards("he", { color: "red" })) return false;
				},
				filterCard: { color: "red" },
				check: function (card) {
					if (get.suit(card) == "heart") return 7 - get.value(card);
					return 5 - get.value(card);
				},
				onuse: function (result) {
					if (result.targets) {
						for (var i = 0; i < result.targets.length; i++) {
							result.targets[i].addTempSkill("yanzhan3");
						}
					}
				},
				group: "yanzhan2",
				ai: {
					order: function () {
						return get.order({ name: "sha" }) + 0.15;
					},
				},
			},
			yanzhan2: {
				trigger: { source: "damageEnd" },
				forced: true,
				popup: false,
				filter: function (event) {
					return event.parent.skill == "yanzhan";
				},
				content: function () {
					player.addTempSkill("yanzhan4");
				},
			},
			yanzhan3: {
				mod: {
					cardRespondable: function (card, player) {
						if (
							_status.event.parent.skill == "yanzhan" &&
							get.suit(card) != get.suit(_status.event.parent.cards[0])
						)
							return false;
					},
				},
			},
			yanzhan4: {
				mod: {
					cardUsable: function (card, player, num) {
						if (card.name == "sha") return num + 1;
					},
				},
			},
			xjyufeng: {
				trigger: { player: "loseEnd" },
				forced: true,
				usable: 2,
				filter: function (event, player) {
					for (var i = 0; i < event.cards.length; i++) {
						if (event.cards[i].original == "h") return player.countCards("h") < 2;
					}
					return false;
				},
				content: function () {
					player.draw(2 - player.countCards("h"));
				},
				ai: {
					noh: true,
					skillTagFilter: function (player, tag) {
						var nh = player.countCards("h");
						if (tag == "noh" && (nh > 2 || nh == 0)) {
							return false;
						}
					},
				},
			},
			feixia: {
				enable: "phaseUse",
				usable: 1,
				filterCard: { color: "red" },
				position: "he",
				filter: function (event, player) {
					return player.countCards("he", { color: "red" }) > 0;
				},
				check: function (card) {
					return 7 - get.value(card);
				},
				content: function () {
					var targets = player.getEnemies();
					if (targets.length) {
						var target = targets.randomGet();
						target.addExpose(0.2);
						player.useCard({ name: "sha" }, target, false);
					}
				},
				ai: {
					order: 2.9,
					result: {
						player: 1,
					},
				},
			},
			lueying: {
				trigger: { player: "shaBegin" },
				filter: function (event, player) {
					if (event.target.countCards("he") > 0) {
						return game.hasPlayer(function (current) {
							return current != player && current != event.target && current.countCards("he");
						});
					}
					return false;
				},
				logTarget: "target",
				usable: 1,
				content: function () {
					"step 0";
					var card = trigger.target.getCards("he").randomGet();
					player.gain(card, trigger.target);
					if (get.position(card) == "e") {
						trigger.target.$give(card, player);
					} else {
						trigger.target.$giveAuto(card, player);
					}
					"step 1";
					if (
						game.hasPlayer(function (current) {
							return current != player && current != trigger.target && current.countCards("he");
						})
					) {
						trigger.target.chooseTarget(function (card, player, target) {
							return (
								target != player &&
								target != _status.event.parent.player &&
								target.countCards("he") > 0
							);
						}, "选择一名角色并令" + get.translation(player) + "弃置其一张牌").ai = function (
							target
						) {
							return -get.attitude(_status.event.player, target);
						};
					} else {
						event.finish();
					}
					"step 2";
					if (result.bool) {
						trigger.target.line(result.targets[0], "green");
						player.discardPlayerCard(result.targets[0], true, "he");
					}
				},
				ai: {
					threaten: 1.5,
					expose: 0.2,
				},
			},
			tianjian: {
				enable: "phaseUse",
				viewAs: { name: "wanjian" },
				filterCard: { name: "sha" },
				filter: function (event, player) {
					return player.countCards("h", "sha") > 0;
				},
				// alter:true,
				usable: 1,
				group: "tianjian_discard",
				subSkill: {
					discard: {
						trigger: { source: "damageEnd" },
						forced: true,
						filter: function (event) {
							if (event._notrigger.includes(event.player)) return false;
							if (get.is.altered("tianjian")) return false;
							return event.parent.skill == "tianjian" && event.player.countCards("he");
						},
						popup: false,
						content: function () {
							trigger.player.discard(trigger.player.getCards("he").randomGet());
						},
					},
				},
			},
			feng: {
				unique: true,
				init: function (player) {
					player.storage.feng = 0;
				},
				mark: true,
				intro: {
					content: "已累计摸#次牌",
				},
				trigger: { player: "drawBegin" },
				forced: true,
				popup: false,
				priority: 5,
				content: function () {
					if (player.storage.feng < 2) {
						player.storage.feng++;
					} else {
						trigger.num++;
						player.storage.feng = 0;
						player.logSkill("feng");
					}
					player.updateMarks();
				},
			},
			ya: {
				unique: true,
				init: function (player) {
					player.storage.ya = 0;
				},
				mark: true,
				intro: {
					content: "已累计受到#次伤害",
				},
				trigger: { player: "damageBegin" },
				filter: function (event, player) {
					if (player.storage.ya == 2) return event.num > 0;
					return true;
				},
				forced: true,
				popup: false,
				content: function () {
					if (player.storage.ya < 2) {
						player.storage.ya++;
					} else if (trigger.num > 0) {
						trigger.num--;
						player.storage.ya = 0;
						player.logSkill("ya");
					}
					player.updateMarks();
				},
			},
			song: {
				unique: true,
				init: function (player) {
					player.storage.song = 0;
				},
				mark: true,
				intro: {
					content: "已累计造成#次伤害",
				},
				trigger: { source: "damageBegin" },
				forced: true,
				popup: false,
				content: function () {
					if (player.storage.song < 2) {
						player.storage.song++;
					} else {
						trigger.num++;
						player.storage.song = 0;
						player.logSkill("song");
					}
					player.updateMarks();
				},
			},
			longxiang: {
				trigger: { player: "shaBegin" },
				filter: function (event, player) {
					return event.target.countCards("h") > player.countCards("h");
				},
				check: function (event, player) {
					return get.attitude(player, event.target) < 0;
				},
				logTarget: "target",
				content: function () {
					var hs = trigger.target.getCards("h");
					trigger.target.discard(hs.randomGets(hs.length - player.countCards("h")));
				},
			},
			huxi: {
				enable: "chooseToUse",
				viewAs: { name: "sha" },
				precontent: function () {
					"step 0";
					player.loseHp();
					"step 1";
					player.changeHujia();
				},
				filterCard: function () {
					return false;
				},
				selectCard: -1,
				prompt: "失去1点体力并获得1点护甲，视为使用一张杀",
				ai: {
					order: function () {
						var player = _status.event.player;
						if (player.hp <= 2) return 0;
						return 2;
					},
					skillTagFilter: function (player, tag, arg) {
						if (arg != "use") return false;
					},
					respondSha: true,
				},
			},
			xuanmo: {
				enable: "phaseUse",
				usable: 1,
				filterCard: function (card) {
					var type = get.type(card, "trick");
					return type == "basic" || type == "equip" || type == "trick";
				},
				check: function (card) {
					return 8 - get.value(card);
				},
				filter: function (event, player) {
					return player.countCards("h") > 0;
				},
				discard: false,
				prepare: "throw",
				content: function () {
					game.log(player, "将", cards, "置于牌堆顶");
					ui.cardPile.insertBefore(cards[0], ui.cardPile.firstChild);
					var list = get.inpile(get.type(cards[0], "trick"), "trick").randomGets(2);
					for (var i = 0; i < list.length; i++) {
						list[i] = game.createCard(list[i]);
					}
					player.gain(list, "draw");
				},
				ai: {
					threaten: 1.5,
					order: 5,
					result: {
						player: 1,
					},
				},
			},
			danqing: {
				trigger: { player: "phaseEnd" },
				init: function (player) {
					player.storage.danqing = [];
				},
				mark: true,
				direct: true,
				intro: {
					content: function (storage) {
						if (!storage.length) {
							return "未使用或打出过有花色的牌";
						} else {
							var str = "已使用过" + get.translation(storage[0] + "2");
							for (var i = 1; i < storage.length; i++) {
								str += "、" + get.translation(storage[i] + "2");
							}
							str += "牌";
							return str;
						}
					},
				},
				filter: function (event, player) {
					return player.storage.danqing.length == 4;
				},
				ai: {
					threaten: 1.2,
				},
				// alter:true,
				content: function () {
					"step 0";
					player.storage.danqing.length = 0;
					player.updateMarks();
					player.chooseTarget(get.prompt("danqing"), [1, get.is.altered("danqing") ? 2 : 4]).ai =
						function (target) {
							return get.attitude(player, target);
						};
					"step 1";
					if (result.bool) {
						player.logSkill("danqing", result.targets);
						for (var i = 0; i < result.targets.length; i++) {
							result.targets[i].getBuff(false);
						}
					} else {
						event.finish();
					}
					"step 2";
					game.delay();
				},
				group: "danqing_count",
			},
			danqing_count: {
				trigger: { player: "useCard" },
				silent: true,
				content: function () {
					var suit = get.suit(trigger.card);
					if (suit) {
						player.storage.danqing.add(suit);
						player.updateMarks();
					}
				},
			},
			danqing_old: {
				content: function () {
					"step 0";
					player.storage.danqing.length = 0;
					player.updateMarks();
					event.targets = [];
					"step 1";
					player.chooseTarget("令一名角色摸一张牌", function (card, player, target) {
						return !event.targets.includes(target);
					}).ai = function (target) {
						var att = get.attitude(player, target);
						if (att > 0) {
							return att + 1 / Math.sqrt(1 + target.countCards("h"));
						}
						return 0;
					};
					"step 2";
					if (result.bool) {
						player.line(result.targets[0], "green");
						result.targets[0].draw();
						event.targets.push(result.targets[0]);
						if (event.targets.length == game.players.length) {
							event.finish();
						} else {
							player.chooseTarget("令一名角色获得1点护甲", function (card, player, target) {
								return !event.targets.includes(target);
							}).ai = function (target) {
								var att = get.attitude(player, target);
								if (att > 0) {
									return att + 1 / Math.sqrt(1 + target.hp);
								}
								return 0;
							};
						}
					} else {
						event.finish();
					}
					"step 3";
					if (result.bool) {
						player.line(result.targets[0], "green");
						result.targets[0].changeHujia();
						game.delay();
						event.targets.push(result.targets[0]);
						if (event.targets.length == game.players.length) {
							event.finish();
						} else {
							player.chooseTarget(
								"令一名角色装备一件随机装备",
								function (card, player, target) {
									return !event.targets.includes(target);
								}
							).ai = function (target) {
								var att = get.attitude(player, target);
								if (att > 0 && !target.getEquip(5)) {
									return att;
								}
								return 0;
							};
						}
					} else {
						event.finish();
					}
					"step 4";
					if (result.bool) {
						player.line(result.targets[0], "green");
						game.delay();
						var list = [];
						for (var i = 0; i < lib.inpile.length; i++) {
							if (lib.card[lib.inpile[i]].type == "equip") {
								list.push(lib.inpile[i]);
							}
						}
						var card = game.createCard(list.randomGet());
						result.targets[0].equip(card);
						result.targets[0].$draw(card);
						event.targets.push(result.targets[0]);
						if (event.targets.length == game.players.length) {
							event.finish();
						} else {
							player.chooseTarget("令一名角色获得潜行", function (card, player, target) {
								return !event.targets.includes(target);
							}).ai = function (target) {
								var att = get.attitude(player, target);
								if (att > 0) {
									return att + 1 / Math.sqrt(1 + target.hp);
								}
								return 0;
							};
						}
					} else {
						event.finish();
					}
					"step 5";
					if (result.bool) {
						player.line(result.targets[0], "green");
						game.delay();
						result.targets[0].tempHide();
					}
				},
			},
			sheling: {
				trigger: { global: ["useCardAfter", "respondAfter", "discardAfter"] },
				filter: function (event, player) {
					if (player != _status.currentPhase || player == event.player) return false;
					if (event.cards) {
						for (var i = 0; i < event.cards.length; i++) {
							if (get.position(event.cards[i]) == "d") return true;
						}
					}
					return false;
				},
				frequent: "check",
				check: function (event) {
					for (var i = 0; i < event.cards.length; i++) {
						if (get.position(event.cards[i]) == "d" && event.cards[i].name == "du") return false;
					}
					return true;
				},
				usable: 3,
				content: function () {
					var cards = [];
					for (var i = 0; i < trigger.cards.length; i++) {
						if (get.position(trigger.cards[i]) == "d") {
							cards.push(trigger.cards[i]);
						}
					}
					player.gain(cards, "gain2");
				},
			},
			zhaoyao: {
				trigger: { global: "phaseDrawBegin" },
				filter: function (event, player) {
					return (
						event.player != player &&
						event.player.countCards("h") > 0 &&
						player.countCards("h") > 0
					);
				},
				check: function (event, player) {
					if (player.isUnseen()) return false;
					if (get.attitude(player, event.player) >= 0) return false;
					var hs = player.getCards("h");
					if (hs.length < event.player.countCards("h")) return false;
					for (var i = 0; i < hs.length; i++) {
						var val = get.value(hs[0]);
						if (hs[i].number >= 10 && val <= 6) return true;
						if (hs[i].number >= 8 && val <= 3) return true;
					}
					return false;
				},
				logTarget: "player",
				content: function () {
					"step 0";
					player.chooseToCompare(trigger.player);
					"step 1";
					if (result.bool) {
						player.draw(2);
					} else {
						event.finish();
					}
					"step 2";
					player.chooseCard("将两张牌置于牌堆顶（先选择的在上）", 2, "he", true);
					"step 3";
					if (result.bool) {
						player.lose(result.cards, ui.special);
						event.cards = result.cards;
					} else {
						event.finish();
					}
					"step 4";
					game.delay();
					var nodes = [];
					for (var i = 0; i < event.cards.length; i++) {
						var cardx = ui.create.card();
						cardx.classList.add("infohidden");
						cardx.classList.add("infoflip");
						nodes.push(cardx);
					}
					player.$throw(nodes, 700, "nobroadcast");
					game.log(player, "将" + get.cnNumber(event.cards.length) + "张牌置于牌堆顶");
					"step 5";
					for (var i = event.cards.length - 1; i >= 0; i--) {
						ui.cardPile.insertBefore(event.cards[i], ui.cardPile.firstChild);
					}
				},
				ai: {
					mingzhi: false,
					expose: 0.2,
				},
			},
			zhangmu: {
				trigger: { player: ["chooseToRespondBegin", "chooseToUseBegin"] },
				filter: function (event, player) {
					if (event.responded) return false;
					if (!event.filterCard({ name: "shan" }, player, event)) return false;
					return player.countCards("h", "shan") > 0;
				},
				direct: true,
				usable: 1,
				content: function () {
					"step 0";
					var goon = get.damageEffect(player, trigger.player, player) <= 0;
					player.chooseCard(get.prompt("zhangmu"), { name: "shan" }).ai = function () {
						return goon ? 1 : 0;
					};
					"step 1";
					if (result.bool) {
						player.logSkill("zhangmu");
						player.showCards(result.cards);
						trigger.untrigger();
						trigger.responded = true;
						trigger.result = { bool: true, card: { name: "shan" } };
						player.addSkill("zhangmu_ai");
					} else {
						player.storage.counttrigger.zhangmu--;
					}
				},
				ai: {
					respondShan: true,
					effect: {
						target: function (card, player, target, effect) {
							if (get.tag(card, "respondShan") && effect < 0) {
								if (target.hasSkill("zhangmu_ai")) return 0;
								if (target.countCards("h") >= 2) return 0.5;
							}
						},
					},
				},
			},
			zhangmu_ai: {
				trigger: { player: "loseAfter" },
				silent: true,
				filter: function (event, player) {
					return player.countCards("h", "shan") == 0;
				},
				content: function () {
					player.removeSkill("zhangmu_ai");
				},
			},
			leiyu: {
				trigger: { player: "phaseEnd" },
				direct: true,
				filter: function (event, player) {
					if (!player.countCards("h", { color: "black" })) return false;
					if (player.storage.leiyu) {
						for (var i = 0; i < player.storage.leiyu.length; i++) {
							if (player.storage.leiyu[i].isAlive()) return true;
						}
					}
					return false;
				},
				content: function () {
					"step 0";
					for (var i = 0; i < player.storage.leiyu.length; i++) {
						if (player.storage.leiyu[i].isDead()) {
							player.storage.leiyu.splice(i--, 1);
						}
					}
					var num = 0;
					var num2 = 0;
					for (var i = 0; i < player.storage.leiyu.length; i++) {
						if (!player.storage.leiyu[i].isIn()) continue;
						var eff = get.effect(
							player.storage.leiyu[i],
							{ name: "jingleishan", nature: "thunder" },
							player,
							player
						);
						num += eff;
						if (eff > 0) {
							num2++;
						} else if (eff < 0) {
							num2--;
						}
					}
					var next = player.chooseToDiscard(get.prompt("leiyu", player.storage.leiyu), {
						color: "black",
					});
					next.ai = function (card) {
						if (num > 0 && num2 >= 2) {
							return 7 - get.value(card);
						}
						return 0;
					};
					next.logSkill = ["leiyu", player.storage.leiyu];
					"step 1";
					if (result.bool) {
						player.storage.leiyu.sort(lib.sort.seat);
						player.useCard(
							{ name: "jingleishan", nature: "thunder" },
							player.storage.leiyu
						).animate = false;
					}
				},
				group: ["leiyu2", "leiyu4"],
				ai: {
					threaten: 1.3,
				},
			},
			leiyu2: {
				trigger: { player: "phaseUseBegin" },
				silent: true,
				content: function () {
					player.storage.leiyu = [];
				},
			},
			leiyu3: {
				trigger: { source: "dieAfter" },
				forced: true,
				popup: false,
				filter: function (event, player) {
					return player.storage.leiyu2 ? true : false;
				},
				content: function () {
					player.recover();
					delete player.storage.leiyu2;
				},
			},
			leiyu4: {
				trigger: { player: "useCardToBegin" },
				silent: true,
				filter: function (event, player) {
					return (
						_status.currentPhase == player &&
						Array.isArray(player.storage.leiyu) &&
						event.target &&
						event.target != player
					);
				},
				content: function () {
					player.storage.leiyu.add(trigger.target);
				},
			},
			feizhua: {
				trigger: { player: "useCard" },
				filter: function (event, player) {
					if (event.card.name != "sha") return false;
					if (event.targets.length != 1) return false;
					var target = event.targets[0];
					var players = game.filterPlayer(function (current) {
						return get.distance(target, current, "pure") == 1;
					});
					for (var i = 0; i < players.length; i++) {
						if (
							player != players[i] &&
							target != players[i] &&
							player.canUse("sha", players[i], false)
						) {
							return true;
						}
					}
					return false;
				},
				prompt: function (event, player) {
					var targets = [];
					var target = event.targets[0];
					var players = game.filterPlayer(function (current) {
						return get.distance(target, current, "pure") == 1;
					});
					for (var i = 0; i < players.length; i++) {
						if (
							player != players[i] &&
							target != players[i] &&
							player.canUse("sha", players[i], false)
						) {
							targets.push(players[i]);
						}
					}
					return get.prompt("feizhua", targets);
				},
				check: function (event, player) {
					var target = event.targets[0];
					var num = 0;
					var players = game.filterPlayer(function (current) {
						return get.distance(target, current, "pure") == 1;
					});
					for (var i = 0; i < players.length; i++) {
						if (
							player != players[i] &&
							target != players[i] &&
							player.canUse("sha", players[i], false)
						) {
							num += get.effect(players[i], { name: "sha" }, player, player);
						}
					}
					return num > 0;
				},
				content: function () {
					"step 0";
					var target = trigger.targets[0];
					var players = game.filterPlayer(function (current) {
						return get.distance(target, current, "pure") == 1;
					});
					for (var i = 0; i < players.length; i++) {
						if (
							player != players[i] &&
							target != players[i] &&
							player.canUse("sha", players[i], false)
						) {
							trigger.targets.push(players[i]);
							player.line(players[i], "green");
						}
					}
				},
			},
			lingxue: {
				trigger: { player: "recoverEnd" },
				forced: true,
				content: function () {
					player.changeHujia();
				},
			},
			diesha: {
				trigger: { source: "damageEnd" },
				forced: true,
				filter: function (event) {
					if (event._notrigger.includes(event.player)) return false;
					return event.player.isAlive() && event.card && event.card.name == "sha";
				},
				content: function () {
					trigger.player.loseHp();
					player.recover();
				},
				ai: {
					threaten: 1.5,
				},
			},
			guijiang: {
				enable: "phaseUse",
				usable: 1,
				filterTarget: function (card, player, target) {
					return target != player && !target.hasSkill("guijiang2");
				},
				filterCard: { color: "black" },
				filter: function (event, player) {
					return player.countCards("h", { color: "black" });
				},
				check: function (card) {
					return 5 - get.value(card);
				},
				content: function () {
					target.addSkill("guijiang2");
					target.storage.guijiang2 = player;
				},
				ai: {
					order: 4,
					threaten: 1.2,
					expose: 0.2,
					result: {
						target: function (player, target) {
							if (target.hp == 1) return -1;
							if (target.hp == 2) return -0.5;
							return 0;
						},
					},
				},
			},
			guijiang2: {
				mark: true,
				intro: {
					content: "不能成为回复牌的目标",
				},
				trigger: { global: ["dieBegin", "phaseBegin"] },
				forced: true,
				popup: false,
				filter: function (event, player) {
					return event.player == player.storage.guijiang2;
				},
				content: function () {
					player.removeSkill("guijiang2");
				},
				mod: {
					targetEnabled: function (card) {
						if (get.tag(card, "recover")) return false;
					},
				},
				global: "guijiang3",
			},
			guijiang3: {
				mod: {
					cardSavable: function (card, player) {
						if (_status.event.dying && _status.event.dying.hasSkill("guijiang2")) return false;
					},
				},
			},
			fenxing: {
				trigger: { player: "phaseBegin" },
				forced: true,
				unique: true,
				forceunique: true,
				filter: function () {
					return Math.random() < 0.5 && [player.name1, player.name2].includes("pal_longkui");
				},
				derivation: ["diesha", "guijiang"],
				content: function () {
					if (player.storage.fenxing) {
						player.storage.fenxing = false;
						player.removeSkill("guijiang");
						player.removeSkill("diesha");
						player.addSkill("diewu");
						player.addSkill("lingyu");
						player.setAvatar("pal_longkui", "pal_longkui");
					} else {
						player.storage.fenxing = true;
						player.removeSkill("diewu");
						player.removeSkill("lingyu");
						player.addSkill("guijiang");
						player.addSkill("diesha");
						player.setAvatar("pal_longkui", "pal_longkuigui");
					}
				},
			},
			diewu: {
				enable: "phaseUse",
				filter: function (event, player) {
					return player.countCards("h", "sha") > 0;
				},
				filterCard: { name: "sha" },
				filterTarget: function (card, player, target) {
					return target != player;
				},
				prepare: "give",
				discard: false,
				content: function () {
					target.gain(cards, player);
					if (!player.hasSkill("diewu2")) {
						player.draw();
						player.addTempSkill("diewu2");
					}
				},
				ai: {
					order: 2,
					expose: 0.2,
					result: {
						target: function (player, target) {
							if (!player.hasSkill("diewu2")) return 1;
							return 0;
						},
					},
				},
			},
			diewu2: {},
			lingyu: {
				trigger: { player: "phaseEnd" },
				direct: true,
				filter: function (event, player) {
					return game.hasPlayer(function (current) {
						return current != player && current.isDamaged();
					});
				},
				content: function () {
					"step 0";
					player.chooseTarget("灵愈：令一名其他角色回复1点体力", function (card, player, target) {
						return target != player && target.hp < target.maxHp;
					}).ai = function (target) {
						return get.recoverEffect(target, player, player);
					};
					"step 1";
					if (result.bool) {
						player.logSkill("lingyu", result.targets[0]);
						result.targets[0].recover();
					}
				},
				ai: {
					threaten: 1.5,
					expose: 0.2,
				},
			},
			duxinshu: {
				enable: "phaseUse",
				usable: 1,
				filterTarget: function (card, player, target) {
					return target != player && target.countCards("h");
				},
				content: function () {
					"step 0";
					if (player.countCards("h")) {
						player.chooseCardButton("读心", target.getCards("h")).ai = function (button) {
							return get.value(button.link) - 5;
						};
					} else {
						player.viewHandcards(target);
						event.finish();
					}
					"step 1";
					if (result.bool) {
						event.card = result.links[[0]];
						player.chooseCard("h", true, "用一张手牌替换" + get.translation(event.card)).ai =
							function (card) {
								return -get.value(card);
							};
					} else {
						event.finish();
					}
					"step 2";
					if (result.bool) {
						player.gain(event.card, target);
						target.gain(result.cards, player);
						player.$giveAuto(result.cards, target);
						target.$giveAuto(event.card, player);
						game.log(player, "与", target, "交换了一张手牌");
					}
				},
				ai: {
					threaten: 1.3,
					result: {
						target: function (player, target) {
							return -target.countCards("h");
						},
					},
					order: 10,
					expose: 0.2,
				},
			},
			feixu: {
				trigger: { global: ["useCard", "respond"] },
				filter: function (event, player) {
					return event.card && event.card.name == "shan";
				},
				check: function (event, player) {
					return get.attitude(player, event.player) > 0;
				},
				logTarget: "player",
				content: function () {
					trigger.player.draw();
				},
				ai: {
					mingzhi: false,
					threaten: 2,
					expose: 0.2,
				},
			},
			xuanyan: {
				// trigger:{source:'damageBefore'},
				// forced:true,
				// priority:5,
				// check:function(event,player){
				// 	return player.hp>3;
				// },
				// filter:function(event){
				// 	return event.card&&get.color(event.card)=='red';
				// },
				// content:function(){
				// 	trigger.nature='fire';
				// },
				group: ["xuanyan2", "xuanyan3"],
			},
			xuanyan2: {
				trigger: { source: "damageBegin" },
				forced: true,
				filter: function (event) {
					return event.hasNature("fire") && event.notLink();
				},
				content: function () {
					trigger.num++;
				},
			},
			xuanyan3: {
				trigger: { source: "damageEnd" },
				forced: true,
				popup: false,
				filter: function (event) {
					return event.hasNature("fire");
				},
				content: function () {
					player.loseHp();
				},
			},
			ningbin: {
				trigger: { player: "damageEnd" },
				forced: true,
				filter: function (event) {
					return event.hasNature("thunder");
				},
				content: function () {
					player.recover();
				},
				ai: {
					effect: {
						target: function (card, player, target) {
							if (get.tag(card, "thunderDamage")) {
								if (target.hp <= 1 || !target.hasSkill("xfenxin")) return [0, 0];
								return [0, 1.5];
							}
						},
					},
				},
			},
			xfenxin: {
				trigger: { player: "changeHp" },
				forced: true,
				filter: function (event) {
					return event.num != 0;
				},
				// alter:true,
				content: function () {
					if (get.is.altered("xfenxin")) {
						player.draw();
					} else {
						player.draw(Math.abs(trigger.num));
					}
				},
				ai: {
					effect: {
						target: function (card) {
							if (get.tag(card, "thunderDamage")) return;
							if (get.tag(card, "damage") || get.tag(card, "recover")) {
								return [1, 0.2];
							}
						},
					},
				},
				group: "xfenxin2",
			},
			xfenxin2: {
				trigger: { source: "dieAfter" },
				forced: true,
				filter: function () {
					return !get.is.altered("xfenxin");
				},
				content: function () {
					player.gainMaxHp();
					player.recover();
				},
			},
			luanjian: {
				enable: "phaseUse",
				filterCard: { name: "sha" },
				selectCard: 2,
				check: function (card) {
					var num = 0;
					var player = _status.event.player;
					var players = game.filterPlayer();
					for (var i = 0; i < players.length; i++) {
						if (
							lib.filter.targetEnabled({ name: "sha" }, player, players[i]) &&
							get.effect(players[i], { name: "sha" }, player) > 0
						) {
							num++;
							if (num > 1) return 8 - get.value(card);
						}
					}
					return 0;
				},
				viewAs: { name: "sha" },
				selectTarget: [1, Infinity],
				filterTarget: function (card, player, target) {
					return lib.filter.targetEnabled({ name: "sha" }, player, target);
				},
				ai: {
					order: function () {
						return get.order({ name: "sha" }) + 0.1;
					},
					effect: {
						player: function (card, player) {
							if (_status.currentPhase != player) return;
							if (
								card.name == "sha" &&
								player.countCards("h", "sha") < 2 &&
								!player.needsToDiscard()
							) {
								var num = 0;
								var player = _status.event.player;
								var players = game.filterPlayer();
								for (var i = 0; i < players.length; i++) {
									if (
										lib.filter.targetEnabled({ name: "sha" }, player, players[i]) &&
										get.attitude(player, players[i]) < 0
									) {
										num++;
										if (num > 1) return "zeroplayertarget";
									}
								}
							}
						},
					},
				},
				group: "luanjian2",
			},
			luanjian2: {
				trigger: { source: "damageBegin" },
				forced: true,
				popup: false,
				filter: function (event, player) {
					return event.card && event.card.name == "sha" && event.parent.skill == "luanjian";
				},
				content: function () {
					if (Math.random() < 0.5) trigger.num++;
				},
			},
			ctianfu: {
				enable: "phaseUse",
				filter: function (event, player) {
					return player.countCards("h", "shan") > 0;
				},
				usable: 1,
				filterCard: { name: "shan" },
				discard: false,
				prepare: "give",
				filterTarget: function (card, player, target) {
					return target != player && !target.hasSkill("ctianfu2");
				},
				check: function (card) {
					if (_status.event.player.hp >= 3) return 8 - get.value(card);
					return 7 - get.value(card);
				},
				content: function () {
					target.storage.ctianfu2 = cards[0];
					target.storage.ctianfu3 = player;
					game.addVideo("storage", target, ["ctianfu2", get.cardInfo(cards[0]), "card"]);
					target.addSkill("ctianfu2");
				},
				ai: {
					order: 2,
					result: {
						target: function (player, target) {
							var att = get.attitude(player, target);
							if (att >= 0) return 0;
							return get.damageEffect(target, player, target, "thunder");
						},
					},
					expose: 0.2,
				},
			},
			ctianfu2: {
				trigger: { source: "damageAfter" },
				forced: true,
				mark: "card",
				filter: function (event, player) {
					return player.storage.ctianfu2 && player.storage.ctianfu3;
				},
				content: function () {
					"step 0";
					if (player.storage.ctianfu3 && player.storage.ctianfu3.isAlive()) {
						player.damage(player.storage.ctianfu3);
						player.storage.ctianfu3.line(player, "thunder");
					} else {
						player.damage("nosource");
					}
					"step 1";
					var he = player.getCards("he");
					if (he.length) {
						player.discard(he.randomGet());
					}
					"step 2";
					player.$throw(player.storage.ctianfu2);
					player.storage.ctianfu2.discard();
					delete player.storage.ctianfu2;
					delete player.storage.ctianfu3;
					player.removeSkill("ctianfu2");
				},
				group: "ctianfu3",
				intro: {
					content: "card",
				},
			},
			ctianfu3: {
				trigger: { player: "dieBegin" },
				forced: true,
				popup: false,
				content: function () {
					player.storage.ctianfu2.discard();
					delete player.storage.ctianfu2;
					delete player.storage.ctianfu3;
					player.removeSkill("ctianfu2");
				},
			},
			shuiyun: {
				trigger: { player: "phaseEnd" },
				direct: true,
				init: function (player) {
					player.storage.shuiyun = [];
					player.storage.shuiyun_count = 0;
				},
				// alter:true,
				filter: function (event, player) {
					if (player.storage.shuiyun.length >= 3) return false;
					if (player.storage.shuiyun.length >= 2 && get.is.altered("shuiyun")) return false;
					var types = [];
					for (var i = 0; i < player.storage.shuiyun.length; i++) {
						types.add(get.type(player.storage.shuiyun[i], "trick"));
					}
					var cards = player.getCards("h");
					for (var i = 0; i < cards.length; i++) {
						if (!types.includes(get.type(cards[i], "trick"))) {
							return true;
						}
					}
					return false;
				},
				content: function () {
					"step 0";
					var types = [];
					var num = player.countCards("h");
					for (var i = 0; i < player.storage.shuiyun.length; i++) {
						types.add(get.type(player.storage.shuiyun[i], "trick"));
					}
					player.chooseCard(get.prompt2("shuiyun"), function (card) {
						return !types.includes(get.type(card, "trick"));
					}).ai = function (card) {
						return 11 - get.value(card);
					};
					"step 1";
					if (result.bool) {
						player.$throw(result.cards);
						var clone = result.cards[0].clone;
						setTimeout(function () {
							clone.moveDelete(player);
							game.addVideo("gain2", player, get.cardsInfo([clone]));
						}, 500);
						player.logSkill("shuiyun");
						player.storage.shuiyun.push(result.cards[0]);
						player.lose(result.cards, ui.special);
						player.markSkill("shuiyun");
						game.addVideo("storage", player, [
							"shuiyun",
							get.cardsInfo(player.storage.shuiyun),
							"cards",
						]);
					}
				},
				intro: {
					content: "cards",
					onunmark: function (storage, player) {
						if (storage && storage.length) {
							for (var i = 0; i < storage.length; i++) {
								storage[i].discard();
							}
							player.$throw(storage);
							delete player.storage.shuiyun;
						}
					},
				},
				ai: {
					effect: {
						player: function (card, player) {
							if (_status.currentPhase != player) return;
							if (get.is.altered("shuiyun")) return;
							if (
								card.name == "wuzhong" ||
								card.name == "yiyi" ||
								card.name == "yuanjiao" ||
								card.name == "shunshou"
							)
								return;
							if (!player.needsToDiscard()) {
								var types = [];
								for (var i = 0; i < player.storage.shuiyun.length; i++) {
									types.add(get.type(player.storage.shuiyun[i], "trick"));
								}
								if (!types.includes(get.type(card, "trick"))) {
									return "zeroplayertarget";
								}
							}
						},
					},
					threaten: 2.2,
				},
				group: ["shuiyun5"],
			},
			shuiyun5: {
				enable: "chooseToUse",
				filter: function (event, player) {
					return (
						event.type == "dying" &&
						event.dying &&
						event.dying.hp <= 0 &&
						player.storage.shuiyun.length > 0
					);
				},
				filterTarget: function (card, player, target) {
					return target == _status.event.dying;
				},
				delay: 0,
				selectTarget: -1,
				content: function () {
					"step 0";
					player.chooseCardButton(get.translation("shuiyun"), player.storage.shuiyun, true);
					"step 1";
					if (result.bool) {
						player.storage.shuiyun.remove(result.links[0]);
						if (!player.storage.shuiyun.length) {
							player.unmarkSkill("shuiyun");
						}
						player.$throw(result.links);
						result.links[0].discard();
						target.recover();
						if (typeof player.storage.shuiyun_count == "number") {
							player.storage.shuiyun_count++;
						}
						player.syncStorage("shuiyun");
					} else {
						event.finish();
					}
				},
				ai: {
					order: 6,
					skillTagFilter: function (player) {
						return player.storage.shuiyun.length > 0;
					},
					save: true,
					result: {
						target: 3,
					},
					threaten: 1.6,
				},
			},
			wangyou: {
				trigger: { global: "phaseEnd" },
				unique: true,
				gainable: true,
				direct: true,
				filter: function (event, player) {
					if (!player.countCards("he")) return false;
					if (player == event.player) return false;
					return game.hasPlayer(function (current) {
						return current.hasSkill("wangyou3");
					});
				},
				content: function () {
					"step 0";
					var targets = [];
					var num = 0;
					var players = game.filterPlayer();
					for (var i = 0; i < players.length; i++) {
						if (players[i].hasSkill("wangyou3")) {
							var att = get.attitude(player, players[i]);
							if (att > 0) num++;
							else if (att < 0) num--;
							targets.push(players[i]);
						}
					}
					event.targets = targets;
					var next = player.chooseToDiscard(get.prompt("wangyou", targets), "he");
					next.logSkill = ["wangyou", event.targets];
					next.ai = function (card) {
						if (num <= 0) return 0;
						switch (num) {
							case 1:
								return 5 - get.value(card);
							case 2:
								return 7 - get.value(card);
							default:
								return 8 - get.value(card);
						}
					};
					"step 1";
					if (result.bool) {
						event.targets.sort(lib.sort.seat);
						game.asyncDraw(event.targets);
					} else {
						event.finish();
					}
				},
				ai: {
					expose: 0.1,
					threaten: 1.2,
				},
				group: "wangyou2",
			},
			wangyou2: {
				trigger: { global: "damageEnd" },
				silent: true,
				filter: function (event) {
					return event.player.isAlive();
				},
				content: function () {
					trigger.player.addTempSkill("wangyou3");
				},
			},
			wangyou3: {},
			changnian: {
				forbid: ["boss"],
				trigger: { player: "dieBegin" },
				direct: true,
				unique: true,
				derivation: "changnian2",
				content: function () {
					"step 0";
					player.chooseTarget(get.prompt("changnian"), function (card, player, target) {
						return player != target;
					}).ai = function (target) {
						return get.attitude(player, target);
					};
					"step 1";
					if (result.bool) {
						var cards = player.getCards("hej");
						var target = result.targets[0];
						// if(player.storage.shuiyun&&player.storage.shuiyun.length){
						// 	target.gainMaxHp();
						// 	target.recover(player.storage.shuiyun.length);
						// 	cards=cards.concat(player.storage.shuiyun);
						// 	player.storage.shuiyun.length=0;
						// }
						player.$give(cards, target);
						target.gain(cards);
						target.addSkill("changnian2");
						player.logSkill("changnian", target);
						target.marks.changnian = target.markCharacter(player, {
							name: "长念",
							content:
								'<div class="skill">【追思】</div><div>锁定技，结束阶段，你摸一张牌</div>',
						});
						game.addVideo("markCharacter", target, {
							name: "长念",
							content:
								'<div class="skill">【追思】</div><div>锁定技，结束阶段，你摸一张牌</div>',
							id: "changnian",
							target: player.dataset.position,
						});
					}
				},
				ai: {
					threaten: 0.8,
				},
			},
			changnian2: {
				trigger: { player: "phaseEnd" },
				forced: true,
				nopop: true,
				content: function () {
					player.draw();
				},
			},
			sajin: {
				enable: "phaseUse",
				filterTarget: function (card, player, target) {
					return target.hp < target.maxHp;
				},
				selectTarget: [1, Infinity],
				filterCard: true,
				usable: 1,
				check: function (card) {
					var player = _status.currentPhase;
					if (player.countCards("h") > player.hp) {
						return 7 - get.value(card);
					}
					return 4 - get.value(card);
				},
				content: function () {
					"step 0";
					var color = get.color(cards[0]);
					target.judge(function (card) {
						return get.color(card) == color ? 1 : 0;
					});
					"step 1";
					if (result.bool) {
						target.recover();
					}
				},
				ai: {
					order: 3,
					result: {
						target: function (player, target) {
							return get.recoverEffect(target);
						},
					},
					threaten: 1.5,
				},
			},
			jtjubao: {
				trigger: { global: "discardAfter" },
				filter: function (event, player) {
					if (player.hasSkill("jtjubao2")) return false;
					if (event.player == player) return false;
					if (_status.currentPhase == player) return false;
					for (var i = 0; i < event.cards.length; i++) {
						if (get.type(event.cards[i]) != "basic" && get.position(event.cards[i]) == "d") {
							return true;
						}
					}
					return false;
				},
				frequent: true,
				content: function () {
					"step 0";
					if (trigger.delay == false) game.delay();
					"step 1";
					var cards = [];
					for (var i = 0; i < trigger.cards.length; i++) {
						if (get.type(trigger.cards[i]) != "basic" && get.position(trigger.cards[i]) == "d") {
							cards.push(trigger.cards[i]);
						}
					}
					if (cards.length) {
						var card = cards.randomGet();
						player.gain(card, "log");
						player.$gain2(card);
						player.addTempSkill("jtjubao2");
					}
				},
				ai: {
					threaten: 1.5,
				},
			},
			jtjubao2: {},
			duci: {
				trigger: { player: "loseEnd" },
				direct: true,
				filter: function (event, player) {
					for (var i = 0; i < event.cards.length; i++) {
						if (event.cards[i].original == "e") return true;
					}
					return false;
				},
				content: function () {
					"step 0";
					player.chooseTarget(get.prompt("duci"), function (card, player, target) {
						return player != target && get.distance(player, target) <= 1;
					}).ai = function (target) {
						return get.damageEffect(target, player, player);
					};
					"step 1";
					if (result.bool) {
						player.logSkill("duci", result.targets);
						result.targets[0].damage();
					}
				},
				ai: {
					expose: 0.2,
					threaten: 1.5,
					effect: {
						target: function (card, player, target, current) {
							if (get.type(card) == "equip") {
								var players = game.filterPlayer();
								for (var i = 0; i < players.length; i++) {
									if (
										player != players[i] &&
										get.distance(player, players[i]) <= 1 &&
										get.damageEffect(players[i], player, player) > 0
									) {
										return [1, 3];
									}
								}
							}
						},
					},
				},
			},
			xshuangren: {
				trigger: { player: ["loseEnd"] },
				filter: function (event, player) {
					if (!player.equiping) return false;
					for (var i = 0; i < event.cards.length; i++) {
						if (event.cards[i].original == "e" && get.subtype(event.cards[i]) == "equip1")
							return true;
					}
					return false;
				},
				content: function () {
					var card;
					for (var i = 0; i < trigger.cards.length; i++) {
						if (trigger.cards[i].original == "e" && get.subtype(trigger.cards[i]) == "equip1") {
							card = trigger.cards[i];
						}
					}
					if (card) {
						if (player.storage.xshuangren) {
							player.unmark(player.storage.xshuangren, "xshuangren");
							player.discard(player.storage.xshuangren);
							game.addVideo("unmarkId", player, [
								get.cardInfo(player.storage.xshuangren),
								"xshuangren",
							]);
						}
						if (card.clone) {
							card.clone.moveDelete(player);
							game.addVideo("gain2", player, get.cardsInfo([card.clone]));
							player.mark(card, "xshuangren");
							game.addVideo("markId", player, [get.cardInfo(card), "xshuangren"]);
						}
						ui.special.appendChild(card);
						player.storage.xshuangren = card;
						var info = get.info(card);
						if (info.skills) {
							player.addAdditionalSkill("xshuangren", info.skills);
						} else {
							player.removeAdditionalSkill("xshuangren");
						}
					}
				},
				ai: {
					effect: {
						target: function (card, player, target, current) {
							if (get.subtype(card) == "equip1") return [1, 3];
						},
					},
				},
				intro: {
					content: "card",
				},
				group: "xshuangren2",
			},
			xshuangren2: {
				trigger: { player: "dieBegin" },
				silent: true,
				filter: function (event, player) {
					return player.storage.xshuangren ? true : false;
				},
				content: function () {
					if (player.storage.xshuangren) {
						player.storage.xshuangren.discard();
						player.$throw(player.storage.xshuangren);
					}
				},
			},
			guiyuan: {
				enable: "phaseUse",
				usable: 1,
				filterCard: { name: "sha" },
				filter: function (event, player) {
					return player.hp < player.maxHp;
				},
				content: function () {
					player.recover();
					player.draw();
				},
				ai: {
					order: 5,
					result: {
						player: 1,
					},
				},
			},
			qijian: {
				trigger: { player: "phaseDiscardEnd" },
				direct: true,
				filter: function (event, player) {
					return event.cards && event.cards.length > 0;
				},
				content: function () {
					"step 0";
					player.chooseTarget(
						[1, trigger.cards.length],
						get.prompt("qijian"),
						function (card, player, target) {
							return player.canUse({ name: "sha" }, target, false);
						}
					).ai = function (target) {
						return get.effect(target, { name: "sha" }, player);
					};
					"step 1";
					if (result.bool) {
						player.logSkill("qijian");
						player.useCard({ name: "sha" }, result.targets);
					}
				},
			},
			shenmu: {
				trigger: { global: "dying" },
				priority: 6,
				filter: function (event, player) {
					return event.player.hp <= 0 && player.countCards("h", { color: "red" });
				},
				check: function (event, player) {
					if (get.attitude(player, event.player) <= 0) return false;
					var cards = player.getCards("h", { color: "red" });
					for (var i = 0; i < cards.length; i++) {
						if (cards[i].name == "tao") return false;
						if (get.value(cards[i]) > 7 && cards.length > 2) return false;
					}
				},
				content: function () {
					"step 0";
					player.showHandcards();
					"step 1";
					var cards = player.getCards("h", { color: "red" });
					event.num = cards.length;
					player.discard(cards);
					"step 2";
					trigger.player.recover();
					trigger.player.draw(event.num);
				},
				ai: {
					threaten: 1.6,
					expose: 0.2,
				},
			},
			qianfang: {
				trigger: { player: "phaseBegin" },
				direct: true,
				filter: function (event, player) {
					return player.storage.xuanning && player.countCards("he") + player.storage.xuanning >= 3;
				},
				// alter:true,
				content: function () {
					"step 0";
					// trigger.cancel();
					var ainum = 0;
					var num = 3 - player.storage.xuanning;
					var players = game.filterPlayer();
					event.targets = [];
					for (var i = 0; i < players.length; i++) {
						if (
							players[i] != player &&
							!players[i].isOut() &&
							lib.filter.targetEnabled({ name: "wanjian" }, player, players[i])
						) {
							ainum += get.effect(players[i], { name: "wanjian" });
							event.targets.push(players[i]);
						}
					}
					if (num) {
						var next = player.chooseToDiscard(num, get.prompt2("qianfang"), "he");
						next.ai = function (card) {
							if (ainum >= 0) {
								switch (num) {
									case 1:
										return 8 - get.value(card);
									case 2:
										return 6 - get.value(card);
									case 3:
										return 4 - get.value(card);
								}
							}
							return -1;
						};
						next.logSkill = "qianfang";
						event.logged = true;
					} else {
						player.chooseBool(get.prompt2("qianfang")).ai = function () {
							return ainum >= 0;
						};
					}
					"step 1";
					if (result.bool) {
						player.storage.xuanning = 0;
						player.unmarkSkill("xuanning");
						if (!event.logged) {
							player.logSkill("qianfang");
						}
						player.useCard({ name: "wanjian" }, "qianfang", event.targets);
					} else {
						event.finish();
					}
				},
				ai: {
					expose: 0.1,
					threaten: 1.5,
				},
				group: "qianfang_draw",
				subSkill: {
					draw: {
						trigger: { source: "damageEnd" },
						forced: true,
						filter: function (event, player) {
							if (event._notrigger.includes(event.player)) return false;
							if (!event.player.isEnemiesOf(player)) return false;
							return event.parent.skill == "qianfang";
						},
						popup: false,
						content: function () {
							player.draw();
						},
					},
				},
			},
			qianfang2: {
				trigger: { player: "phaseDrawBegin" },
				forced: true,
				popup: false,
				content: function () {
					trigger.num++;
				},
			},
			poyun: {
				trigger: { source: "damageEnd" },
				// alter:true,
				filter: function (event, player) {
					if (event._notrigger.includes(event.player)) return false;
					return player.storage.xuanning > 0 && event.player.countCards("he") > 0;
				},
				direct: true,
				content: function () {
					"step 0";
					player.discardPlayerCard(trigger.player, "he", get.prompt("poyun", trigger.player), [
						1,
						get.is.altered("poyun") ? 1 : 2,
					]).logSkill = ["poyun", trigger.player];
					"step 1";
					if (result.bool) {
						player.storage.xuanning--;
						if (!player.storage.xuanning) {
							player.unmarkSkill("xuanning");
						}
						player.syncStorage("xuanning");
					}
				},
				ai: {
					threaten: 1.3,
				},
			},
			poyun2: {
				trigger: { source: "damageEnd" },
				forced: true,
				popup: false,
				filter: function (event, player) {
					return player.storage.poyun ? true : false;
				},
				content: function () {
					player.draw();
					player.storage.poyun = false;
					player.removeSkill("poyun2");
				},
			},
			poyun3: {},
			zhuyue: {
				enable: "phaseUse",
				// alter:true,
				filter: function (event, player) {
					if (get.is.altered("zhuyue")) {
						return player.hasCard(function (card) {
							return get.color(card) == "black" && get.type(card) != "basic";
						});
					}
					return player.countCards("h", { type: "basic" }) < player.countCards("he");
				},
				init: function (player) {
					player.storage.zhuyue = [];
				},
				filterCard: function (card) {
					if (get.is.altered("zhuyue")) {
						return get.type(card) != "basic" && get.color(card) == "black";
					} else {
						return get.type(card) != "basic";
					}
				},
				selectTarget: [1, 2],
				filterTarget: function (card, player, target) {
					return player != target && target.countCards("he") > 0;
				},
				usable: 1,
				locked: false,
				check: function (card) {
					return 7 - get.value(card);
				},
				multitarget: true,
				multiline: true,
				content: function () {
					"step 0";
					targets.sort(lib.sort.seat);
					var target = targets[0];
					var cs = target.getCards("he");
					if (cs.length) {
						target.discard(cs.randomGet());
					}
					player.storage.zhuyue.add(target);
					if (targets.length < 2) {
						event.finish();
					}
					"step 1";
					var target = targets[1];
					var cs = target.getCards("he");
					if (cs.length) {
						target.discard(cs.randomGet());
					}
					player.storage.zhuyue.add(target);
				},
				ai: {
					result: {
						target: function (player, target) {
							if (!target.countCards("he")) return -0.2;
							return -1;
						},
					},
					order: 10,
					threaten: 1.2,
					exoise: 0.2,
				},
				mod: {
					targetInRange: function (card, player, target) {
						if (
							card.name == "sha" &&
							player.storage.zhuyue &&
							player.storage.zhuyue.includes(target)
						) {
							return true;
						}
					},
					selectTarget: function (card, player, range) {
						if (card.name == "sha" && player.storage.zhuyue && player.storage.zhuyue.length) {
							range[1] = -1;
							range[0] = -1;
						}
					},
					playerEnabled: function (card, player, target) {
						if (
							card.name == "sha" &&
							player.storage.zhuyue &&
							player.storage.zhuyue.length &&
							!player.storage.zhuyue.includes(target)
						) {
							return false;
						}
					},
				},
				intro: {
					content: "players",
				},
				group: "zhuyue2",
			},
			zhuyue2: {
				trigger: { player: "phaseUseEnd" },
				silent: true,
				content: function () {
					player.storage.zhuyue.length = 0;
				},
			},
			longxi: {
				trigger: { player: ["chooseToRespondBegin", "chooseToUseBegin"] },
				forced: true,
				popup: false,
				max: 2,
				filter: function (event, player) {
					return _status.currentPhase != player;
				},
				priority: 101,
				content: function () {
					var cards = [];
					var max = Math.min(ui.cardPile.childNodes.length, lib.skill.longxi.max);
					for (var i = 0; i < max; i++) {
						var card = ui.cardPile.childNodes[i];
						if (trigger.filterCard(card, player, trigger)) {
							cards.push(card);
						}
					}
					if (cards.length) {
						player.gain(cards, "draw");
						player.logSkill("longxi");
						game.log(player, "获得了" + get.cnNumber(cards.length) + "张牌");
					}
				},
				ai: {
					respondSha: true,
					respondShan: true,
					effect: {
						target: function (card, player, target, effect) {
							if (get.tag(card, "respondShan")) return 0.7;
							if (get.tag(card, "respondSha")) return 0.7;
						},
					},
				},
				hiddenCard: function (player, name) {
					if (_status.currentPhase == player) return false;
					var max = Math.min(ui.cardPile.childNodes.length, lib.skill.longxi.max);
					for (var i = 0; i < max; i++) {
						var card = ui.cardPile.childNodes[i];
						if (card.name == name) return true;
					}
					return false;
				},
			},
			guanri: {
				unique: true,
				enable: "phaseUse",
				filter: function (event, player) {
					return !player.storage.guanri && player.countCards("h", { color: "red" }) >= 2;
				},
				check: function (card) {
					return 8 - get.value(card);
				},
				filterCard: function (card) {
					return get.color(card) == "red";
				},
				selectCard: 2,
				filterTarget: function (card, player, target) {
					return player != target && target.hp >= player.hp;
				},
				intro: {
					content: "limited",
				},
				line: "fire",
				content: function () {
					"step 0";
					player.storage.guanri = true;
					player.loseHp();
					"step 1";
					target.damage(2, "fire");
					"step 2";
					if (target.isAlive()) {
						target.discard(target.getCards("e"));
					}
				},
				ai: {
					order: 1,
					result: {
						target: function (player, target) {
							var eff = get.damageEffect(target, player, target, "fire");
							if (player.hp > 2) return eff;
							if (player.hp == 2 && target.hp == 2) return eff;
							return 0;
						},
					},
					expose: 0.5,
				},
			},
			tianxian: {
				mod: {
					targetInRange: function (card, player, target, now) {
						if (card.name == "sha") return true;
					},
					selectTarget: function (card, player, range) {
						if (card.name == "sha" && range[1] != -1) range[1] = Infinity;
					},
				},
				priority: 5.5,
				trigger: { player: "useCardToBefore" },
				filter: function (event) {
					return event.card.name == "sha";
				},
				forced: true,
				check: function () {
					return false;
				},
				content: function () {
					"step 0";
					trigger.target.judge(function (card) {
						return get.color(card) == "black" ? 1 : 0;
					});
					"step 1";
					if (result.bool) {
						trigger.cancel();
					}
				},
			},
			runxin: {
				trigger: { player: ["useCard", "respondEnd"] },
				direct: true,
				filter: function (event) {
					if (get.suit(event.card) == "heart") {
						return game.hasPlayer(function (current) {
							return current.isDamaged();
						});
					}
					return false;
				},
				content: function () {
					"step 0";
					var noneed =
						trigger.card.name == "tao" &&
						trigger.targets[0] == player &&
						player.hp == player.maxHp - 1;
					player
						.chooseTarget(get.prompt("runxin"), function (card, player, target) {
							return target.hp < target.maxHp;
						})
						.set("autodelay", true).ai = function (target) {
						var num = get.attitude(player, target);
						if (num > 0) {
							if (noneed && player == target) {
								num = 0.5;
							} else if (target.hp == 1) {
								num += 3;
							} else if (target.hp == 2) {
								num += 1;
							}
						}
						return num;
					};
					"step 1";
					if (result.bool) {
						player.logSkill("runxin", result.targets);
						result.targets[0].recover();
					}
				},
				ai: {
					expose: 0.3,
					threaten: 1.5,
				},
			},
			xjzhimeng: {
				trigger: { player: "phaseEnd" },
				direct: true,
				locked: true,
				unique: true,
				gainable: true,
				// alter:true,
				group: "xjzhimeng3",
				content: function () {
					"step 0";
					player.chooseTarget(get.prompt("xjzhimeng"), function (card, player, target) {
						return player != target;
					}).ai = function (target) {
						var num = get.attitude(player, target);
						if (num > 0) {
							if (player == target) {
								num++;
							}
							if (target.hp == 1) {
								num += 3;
							}
							if (target.hp == 2) {
								num += 1;
							}
						}
						return num;
					};
					"step 1";
					if (result.bool) {
						var target = result.targets[0];
						if (get.is.altered("xjzhimeng")) {
							target.draw();
						} else {
							var card = get.cards()[0];
							target.$draw(card);
							target.storage.xjzhimeng2 = card;
							game.addVideo("storage", target, ["xjzhimeng2", get.cardInfo(card), "card"]);
							target.addSkill("xjzhimeng2");
						}
						player.logSkill("xjzhimeng", target);
					}
				},
				ai: {
					expose: 0.2,
				},
			},
			xjzhimeng2: {
				intro: {
					content: "card",
					onunmark: function (storage, player) {
						delete player.storage.xjzhimeng2;
					},
				},
				mark: "card",
				trigger: { target: "useCardToBegin" },
				frequent: true,
				filter: function (event, player) {
					return (
						player.storage.xjzhimeng2 &&
						get.type(event.card, "trick") == get.type(player.storage.xjzhimeng2, "trick")
					);
				},
				content: function () {
					player.draw();
				},
				ai: {
					effect: {
						target_use(card, player, target) {
							if (
								target.storage.xjzhimeng2 &&
								get.type(card, "trick") == get.type(target.storage.xjzhimeng2, "trick")
							) {
								return [1, 0.5];
							}
						},
					},
				},
			},
			xjzhimeng3: {
				trigger: { player: ["phaseBegin", "dieBegin"] },
				silent: true,
				content: function () {
					"step 0";
					event.players = game.filterPlayer();
					event.num = 0;
					"step 1";
					if (event.num < event.players.length) {
						var player = event.players[event.num];
						if (player.storage.xjzhimeng2) {
							if (trigger.name == "die" && player == trigger.player) {
								player.storage.xjzhimeng2.discard();
							} else {
								game.log(player, "发动织梦，获得了", player.storage.xjzhimeng2);
								player.gain(player.storage.xjzhimeng2, "gain2");
								player.popup("xjzhimeng");
							}
							player.removeSkill("xjzhimeng2");
						}
						event.num++;
						event.redo();
					}
				},
			},
			tannang: {
				enable: "chooseToUse",
				usable: 1,
				locked: false,
				filterCard: function (card) {
					return get.suit(card) == "club";
				},
				filter: function (event, player) {
					return player.countCards("h", { suit: "club" });
				},
				viewAs: { name: "shunshou" },
				viewAsFilter: function (player) {
					if (!player.countCards("h", { suit: "club" })) return false;
				},
				prompt: "将一张装备牌当顺手牵羊使用",
				check: function (card) {
					var player = _status.currentPhase;
					if (player.countCards("h", { subtype: get.subtype(card) }) > 1) {
						return 11 - get.equipValue(card);
					}
					if (player.countCards("h") < player.hp) {
						return 6 - get.value(card);
					}
					return 2 - get.equipValue(card);
				},
				mod: {
					targetInRange: function (card, player, target, now) {
						if (card.name == "shunshou") return true;
					},
				},
				ai: {
					order: 9.5,
					threaten: 1.5,
				},
			},
			tuoqiao: {
				enable: "chooseToUse",
				filterCard: { color: "black" },
				position: "he",
				viewAs: { name: "shihuifen" },
				viewAsFilter: function (player) {
					return player.countCards("he", { color: "black" }) > 0;
				},
				ai: {
					shihuifen: true,
					skillTagFilter: function (player) {
						return player.countCards("he", { color: "black" }) > 0;
					},
				},
			},
			tuoqiao_old: {
				filter: function (event, player) {
					return (
						game.players.length > 3 &&
						(event.player == player.next || event.player == player.previous)
					);
				},
				check: function (event, player) {
					return get.effect(player, event.card, event.player, player) < 0;
				},
				changeSeat: true,
				trigger: { target: "useCardToBefore" },
				content: function () {
					if (trigger.player == player.next) {
						game.swapSeat(player, player.previous);
					} else if (trigger.player == player.previous) {
						game.swapSeat(player, player.next);
					} else {
						return;
					}
					trigger.cancel();
					// player.popup('xiaoyao');
				},
				ai: {
					effect: {
						target_use(card, player, target, current) {
							if (target == player.next || target == player.previous) return 0.1;
						},
					},
				},
			},
			tianjian_old: {
				enable: "phaseUse",
				usable: 1,
				changeSeat: true,
				filterTarget: function (card, player, target) {
					return player != target && player.next != target;
				},
				filterCard: true,
				check: function (card) {
					return 4 - get.value(card);
				},
				content: function () {
					while (player.next != target) {
						game.swapSeat(player, player.next);
					}
				},
				ai: {
					order: 5,
					result: {
						player: function (player, target) {
							var att = get.attitude(player, target);
							if (target == player.previous && att > 0) return 1;
							if (target == player.next.next && get.attitude(player, player.next) < 0) return 1;
							return 0;
						},
					},
				},
			},
			huimeng: {
				trigger: { player: "recoverAfter" },
				frequent: true,
				content: function () {
					player.draw(2);
				},
				ai: {
					threaten: 0.8,
				},
			},
			tianshe: {
				group: ["tianshe2"],
				trigger: { player: "damageBefore" },
				filter: function (event) {
					if (event.hasNature()) return true;
					return false;
				},
				forced: true,
				content: function () {
					trigger.cancel();
				},
				ai: {
					nofire: true,
					nothunder: true,
					effect: {
						target: function (card, player, target, current) {
							if (card.name == "tiesuo") return 0;
							if (get.tag(card, "fireDamage")) return 0;
							if (get.tag(card, "thunderDamage")) return 0;
						},
					},
				},
			},
			tianshe2: {
				trigger: { source: "damageAfter" },
				filter: function (event, player) {
					if (event.hasNature() && player.hp < player.maxHp) return true;
				},
				forced: true,
				content: function () {
					player.recover();
				},
			},
		},
		translate: {
			pal_xiahoujinxuan: "夏侯瑾轩",
			pal_muchanglan: "暮菖兰",
			pal_xia: "瑕",
			pal_jiangcheng: "姜承",

			pal_jiangyunfan: "姜云凡",
			pal_tangyurou: "唐雨柔",
			pal_longyou: "龙幽",
			pal_xiaoman: "小蛮",

			pal_wangxiaohu: "王小虎",
			pal_sumei: "苏媚",
			pal_shenqishuang: "沈欺霜",
			pal_longkui: "龙葵",
			pal_nangonghuang: "南宫煌",
			pal_wenhui: "温慧",
			pal_wangpengxu: "王蓬絮",
			pal_xingxuan: "星璇",
			pal_leiyuange: "雷元戈",

			pal_zhaoliner: "赵灵儿",
			pal_linyueru: "林月如",
			pal_lixiaoyao: "李逍遥",

			pal_xuejian: "雪见",
			pal_jingtian: "景天",
			pal_zixuan: "紫萱",
			pal_anu: "阿奴",

			pal_yuntianhe: "云天河",
			pal_hanlingsha: "韩菱纱",
			pal_liumengli: "柳梦璃",
			pal_murongziying: "慕容紫英",
			pal_changqing: "长卿",
			pal_xuanxiao: "玄霄",

			pal_yuejinzhao: "越今朝",
			pal_yueqi: "越祈",
			pal_luozhaoyan: "洛昭言",
			pal_xianqing: "闲卿",
			pal_mingxiu: "明绣",
			pal_jushifang: "居十方",

			xyufeng: "御蜂",
			xyufeng_info: "出牌阶段限一次，可以将一张黑桃牌当作机关蜂使用。",
			lingquan: "灵泉",
			lingquan_info:
				"觉醒技，结束阶段，若游戏轮数不小于3且你本回合使用的牌数大于你的体力值，你摸三张牌，然后获得技能【水蕴】。",
			shenwu: "神舞",
			shenwu_info:
				"觉醒技，在一名角色的结束阶段，若你本局至少发动过3次【水蕴】，你增加1点体力和体力上限并获得2点护甲，然后获得技能【回梦】。",
			txianqu: "仙音",
			txianqu_info: "出牌阶段限一次，当你即将造成伤害时，你可以防止之，然后摸两张牌并回复1点体力。",
			qiongguang: "穹光",
			qiongguang_info:
				"弃牌阶段结束时，若你弃置了至少两张牌，你可以对所有敌方角色施加一个随机的负面效果。",
			xunying: "迅影",
			xunying_info: "每当你使用杀对一名目标结算完毕后，你可以继续对目标使用杀。",
			liefeng: "冽风",
			liefeng_info:
				"锁定技，当你在回合内使用第二张牌时，你本回合获得【炎斩】；当你在回合内使用第三张牌时，你本回合获得【天剑】；当你在回合内使用第四张牌时，你本回合获得【御风】。",
			yuexing: "越行",
			yuexing2: "越行",
			yuexing_info:
				"出牌阶段限一次，你可以指定一名角色，本阶段内将你与该角色到其他角色的距离基数互换。",
			lingdi: "灵笛",
			lingdi_info:
				"出牌阶段，你可以弃置一张本回合与此法弃置的牌花色均不同的手牌，然后选择一名与你距离为X的角色与其各摸一张牌，X为本回合发动灵笛的次数（含此次）。",
			xiaoyue: "啸月",
			xiaoyue_info:
				"锁定技，每轮开始时，若你手牌中有杀，你将手牌中的一张随机杀对一名随机敌方角色使用，然后获得1点护甲。",
			minsha: "冥煞",
			minsha_info:
				"出牌阶段限一次，你可以弃置两张牌，对一名体力值大于1的其他角色造成1点雷属性伤害，然后距离目标1以内的所有其他角色随机弃置一张牌。",
			xhuanlei: "唤雷",
			xhuanlei_info:
				"每当你受到一次伤害，若伤害来源体力值大于你，你可以对其造成1点雷属性伤害，然后其摸一张牌。",
			anwugu: "巫蛊",
			anwugu2: "蛊",
			anwugu_info:
				"每当你对其他角色造成一次伤害，你可以令目标获得三枚蛊标记；拥有蛊标记的角色手牌上限-1，每回合最多使用X张牌（X为蛊标记数），每个结束阶段失去一枚蛊标记。",
			xtanxi: "探息",
			xtanxi_info:
				"出牌阶段限一次，你可以弃置一张手牌，然后随机选择一名手牌中有与之同名的牌的敌方角色，观看其手牌并获得任意一张。",
			linghuo: "灵火",
			linghuo_info:
				"每两轮限一次，在一名其他角色的结束阶段，若其本回合内造成过伤害，你可以对其造成1点火属性伤害。",
			guijin: "归烬",
			guijin2: "归烬",
			guijin2_bg: "烬",
			guijin_info:
				"每三轮限一次，出牌阶段，你可以观看牌堆顶的四张牌，然后可以将其中任意张牌分配给任意角色，被分到牌的角色跳过下一摸牌阶段，然后将剩余牌以原顺序放回牌堆顶。",
			chengxin: "澄心",
			chengxin2: "澄心",
			chengxin2_bg: "心",
			chengxin_info:
				"每四轮限一次，当一名角色进入濒死状态时，你可以令其将体力值回复至1，然后该角色防止一切伤害直到下一回合结束。",
			tianwu: "天舞",
			tianwu_info: "每当你使用卡牌指定一名敌方角色为唯一目标，你可以对其施加一个随机的负面效果。",
			tianwu_info_alter:
				"每当你使用卡牌指定一名敌方角色为唯一目标，你可以对其施加一个随机的负面效果，每回合限发动一次。",
			liguang: "离光",
			liguang_info: "结束阶段，你可以弃置一张手牌并将场上的一张牌移动到另一个合理的位置。",
			shiying: "逝影",
			shiying_info:
				"限定技，在一名其他角色死亡前，你可以防止其死亡，然后你与该角色失去全部技能、将体力和体力上限变为3、移去所有牌并摸三张牌。",
			yujia: "御甲",
			yujia_info:
				"每当你使用一张未强化的装备牌，你可以随机观看X张机关牌，并选择一张获得之，X为你本局使用过的机关牌数且至少为1。",
			xiepan: "械磐",
			xiepan_info: "每当你失去最后一张基本牌，你可以弃置一张手牌，然后获得一张随机装备牌。",
			yanshi: "偃师",
			yanshi_info:
				"觉醒技，结束阶段，若你累计有4个回合使用过机关牌，你增加1点体力和体力上限，然后用随机装备填满你的装备区。",
			ywuhun: "雾魂",
			ywuhun_bg: "魂",
			ywuhun_info:
				"锁定技，回合开始前，你获得一个额外的回合，并在此回合结束后复原场上及牌堆中的所有牌；当你在此回合中造成伤害后，终止所有结算并结束此回合。",
			// ywuhun_info_alter:'锁定技，回合开始前，你获得一个额外的回合，并在此回合结束后复原场上及牌堆中的所有牌；当你在此回合中造成伤害后，终止所有结算并结束此回合。',
			feichen: "飞尘",
			feichen_info: "",
			tanhua: "昙华",
			tanhua_info:
				"锁定技，你回复体力的效果改为摸两张牌；当你进入濒死状态时，你回复1点体力并失去此技能。",
			xjyingfeng: "影锋",
			xjyingfeng_info:
				"锁定技，每当你使用一张杀结算完毕后，你随机对一名不是此杀目标的敌方角色使用一张杀。",
			fenglue: "风掠",
			fenglue_info:
				"你可以放弃出牌阶段，改为指定一名其他角色并选择任意张手牌，依次对该角色使用，若如此做，此阶段内该角色每受到1点伤害，你在结算后摸一张牌。",
			xjzongyu: "纵雨",
			xjzongyu_info:
				"出牌阶段限一次，你可以弃置一张黑色手牌，视为使用一张飞镖，随机指定两名敌方角色为目标。",
			fanling: "返灵",
			fanling_info: "锁定技，每当一名角色失去体力，你回复1点体力，每回合只能发动一次。",
			huahu: "化狐",
			huahu_bg: "狐",
			huahu_info:
				"限定技，你可以失去所有技能和1点体力上限，然后令任意名其他角色回复1点体力、获得1点护甲并摸一张牌。",
			sheying: "蛇影",
			sheying_info:
				"每回合限一次，当你使用卡牌造成一次伤害后，你可以进行一次判定，若结果为黑色，你收回此牌。",
			dujiang: "毒降",
			dujiang_info: "出牌阶段限一次，你可以弃置一张黑色牌令一名随机敌人获得一张毒。",
			binxin: "冰心",
			binxin_info: "在一名角色的结束阶段，若其体力值为1，你可以令其获得1点护甲。",
			qixia: "绮霞",
			qixia_info: "锁定技，当你累计使用或打出了4种不同花色的牌后，你于本回合结束后获得一个额外回合。",
			jianzhen: "剑阵",
			jianzhen_info:
				"锁定技，当你使用杀对目标结算完毕后，其他角色可以对该目标使用一张杀，当有人选择出杀后终止此结算。",
			husha: "虎煞",
			husha_bg: "煞",
			husha_info:
				"每当你于出牌阶段造成1点伤害，你获得一枚虎煞标记（标记数不超过3）；结束阶段，你可以选择一项：1. 移去一枚虎煞标记，视为对任意角色使用一张杀；2. 移去两枚虎煞标记，视为使用一张南蛮入侵；3. 移去三枚虎煞标记，视为对除你之外的角色使用一张元素毁灭。",
			longhuo: "龙火",
			longhuo_info: "结束阶段，你可以对所有角色各造成1点火焰伤害。",
			fenshi: "焚世",
			fenshi_info: "觉醒技，当你解除濒死状态时，你获得2点护甲，摸两张牌，然后获得技能龙火。",
			yanzhan: "炎斩",
			yanzhan_info:
				"出牌阶段限一次，你可以将一张红色牌当作火杀使用，此杀只能用与之花色相同的闪响应；若此杀造成了伤害，你本回合可以额外使用一张杀。",
			feixia: "飞霞",
			feixia_info: "出牌阶段限一次，你可以弃置一张红色牌视为对一名随机敌人使用一张不计入出杀次数的杀。",
			lueying: "掠影",
			lueying_info:
				"每当你使用一张杀，你可以随机获得目标的一张牌，然后目标可以指定一名其他角色，你弃置该角色一张牌（每回合限发动一次，没有弃牌目标时无法发动）。",
			feng: "风",
			feng_info: "锁定技，当你累计摸2次牌后，你下一次摸牌时摸牌数+1。",
			ya: "雅",
			ya_info: "锁定技，当你累计受到2次伤害后，你下一次受到的伤害-1。",
			song: "颂",
			song_info: "锁定技，当你累计造成2次伤害后，你下一次造成的伤害+1。",
			longxiang: "龙翔",
			longxiang_info: "当你使用杀指定目标后，你可以弃置目标若干张手牌直到其手牌数与你相同。",
			huxi: "虎袭",
			huxi_info: "你可以失去1点体力并获得1点护甲，视为使用一张杀。",
			xuanmo: "玄墨",
			xuanmo_info: "出牌阶段限一次，你可以将一张手牌置于牌堆顶并随机获得两张与之类别相同的牌。",
			danqing: "丹青",
			danqing_info:
				"结束阶段，若你累计使用了4张花色不同的牌，你可以选择至多4名角色随机获得一个正面效果。",
			danqing_info_alter:
				"结束阶段，若你累计使用了4张花色不同的牌，你可以选择至多2名角色随机获得一个正面效果。",
			zhangmu: "障目",
			zhangmu_info:
				"每回合限一次，当你需要使用或打出一张闪时，你可以展示一张闪，视为使用或打出了此闪。",
			feizhua: "飞爪",
			feizhua_info: "当你使用一张杀时，你可以将与目标相邻的角色追加为额外目标。",
			leiyu: "雷狱",
			leiyu_info:
				"结束阶段，你可以弃置一张黑色手牌，视为对本回合内所有成为过你的卡牌目标的角色使用一张惊雷闪。",
			lingxue: "灵血",
			lingxue_info: "锁定技，每当你回复1点体力，你获得1点护甲。",
			zhaoyao: "招摇",
			zhaoyao_info:
				"其他角色的摸牌阶段开始时，你可以与其拼点，若你赢，你摸两张牌，然后将两张牌置于牌堆顶。",
			sheling: "摄灵",
			sheling_info:
				"其他角色于你的回合内因使用、打出或弃置而失去牌时，你可以获得之（每回合最多发动三次）。",
			fenxing: "分形",
			fenxing_info: "锁定技，准备阶段，你有50%概率变身为另一形态。",
			guijiang: "鬼降",
			guijiang2: "鬼降",
			guijiang_info:
				"出牌阶段限一次，你可以弃置一张黑色牌，令一名其他角色无法成为回复牌的目标直到你下一回合开始。",
			diesha: "叠杀",
			diesha_info: "锁定技，每当你使用杀造成伤害，受伤害角色失去1点体力，你回复1点体力。",
			lingyu: "灵愈",
			lingyu_info: "结束阶段，你可以令一名其他角色回复1点体力。",
			diewu: "蝶舞",
			diewu_info: "出牌阶段，你可以将一张【杀】交给一名角色，若你于此阶段内首次如此做，你摸一张牌。",
			duxinshu: "读心",
			duxinshu_info: "出牌阶段限一次，你可以观看一名其他角色的手牌，然后可以用一张手牌替换其中的一张。",
			feixu: "飞絮",
			feixu_info: "每当一名角色使用或打出一张闪，你可以令其摸一张牌。",
			xuanyan: "玄炎",
			xuanyan2: "玄炎",
			xuanyan_info: "锁定技，你的火属性伤害+1；你造成火属性伤害后失去1点体力。",
			ningbin: "凝冰",
			ningbin_info: "锁定技，每当你受到1次雷属性伤害，你回复1点体力。",
			xfenxin: "焚心",
			xfenxin2: "焚心",
			xfenxin_info:
				"锁定技，每当你的体力值发生改变，你摸等量的牌；每当你杀死一名角色，你增加1点体力上限并回复1点体力。",
			xfenxin_info_alter: "锁定技，每当你的体力值发生改变，你摸一张牌。",
			luanjian: "乱剑",
			luanjian_info:
				"出牌阶段，你可以将两张杀当杀使用，此杀无视距离，可以指定任意名目标且有50%的机率伤害+1。",
			ctianfu: "天符",
			ctianfu2: "天符",
			ctianfu3: "天符",
			ctianfu_info:
				"出牌阶段，你可以将一张闪置于一名其他角色的武将牌上，该角色在下一次造成伤害时受到来自你的1点雷属性伤害并随机弃置一张牌，然后移去此牌。",
			shuiyun: "水蕴",
			shuiyun_bg: "蕴",
			shuiyun2: "水蕴",
			shuiyun5: "水蕴",
			shuiyun3: "水蕴",
			shuiyun_info:
				"结束阶段，你可以将一张与武将牌上的牌类别均不相同的手牌置于武将牌上称为“蕴”；任意一名角色处于濒死状态时，你可以弃置一张“蕴”令其回复1点体力。",
			shuiyun_info_alter:
				"结束阶段，你可以将一张与武将牌上的牌类别均不相同的手牌置于武将牌上称为“蕴”（不能超过2张）；任意一名角色处于濒死状态时，你可以弃置一张“蕴”令其回复1点体力。",
			wangyou: "忘忧",
			wangyou_info: "其他角色的结束阶段，你可以弃置一张牌，令此回合内受过伤害的所有角色各摸一张牌。",
			changnian: "长念",
			changnian2: "追思",
			changnian2_info: "锁定技，结束阶段，你摸一张牌。",
			changnian_info: "你死亡时，可以将所有牌交给一名其他角色，令其获得技能〖追思〗。",
			sajin: "洒金",
			sajin_info:
				"出牌阶段限一次，你可以弃置一张手牌并指定任意名角色进行判定，若判定颜色与你弃置的牌相同，该角色回复1点体力。",
			jtjubao: "聚宝",
			jtjubao_info: "当其他角色于你的回合外首次弃置非基本牌时，你可以获得其中的随机一张。",
			guiyuan: "归元",
			guiyuan_info: "出牌阶段限一次，你可以弃置一张杀，然后回复1点体力并摸一张牌。",
			xshuangren: "双刃",
			xshuangren_info:
				"当你的武器牌被替换时，你可以将其置于你的武将牌上，并获得此装备的武器效果（不含距离）。",
			duci: "毒刺",
			duci_info: "每当你失去一次装备牌，可以对距离1以内的一名其他角色造成1点伤害。",
			shenmu: "神木",
			shenmu_info:
				"任意一名角色濒死时，你可以展示你的手牌并弃置其中的所有红色牌（至少一张），若如此做，该角色回复1点体力，然后摸X张牌，X为你弃置的手牌数。",
			qijian: "气剑",
			qijian_info: "弃牌阶段结束时，你可以指定至多X名目标视为使用一张杀，X为你于此阶段弃置的卡牌数。",
			poyun: "破云",
			poyun_info: "每当你造成一次伤害，你可以弃置一枚玄凝标记，然后弃置对方两张牌。",
			poyun_info_alter: "每当你造成一次伤害，你可以弃置一枚玄凝标记，然后弃置对方一张牌。",
			qianfang: "千方",
			qianfang_info:
				"准备阶段，若你有玄凝标记，你可以弃置3-X张牌和所有玄凝标记，视为使用了一张【万箭齐发】，每当一名敌方角色因此牌受到伤害，你摸一张牌。X为你的玄凝标记数。",
			qianfang_info_alter:
				"准备阶段，若你有玄凝标记，可以弃置3-X张牌和所有玄凝标记，视为使用了一张【万箭齐发】，X为你的玄凝标记数。",
			longxi: "龙息",
			longxi2: "龙息",
			longxi_info:
				"锁定技，在回合外每当你需要使用或打出一张卡牌时，若牌堆顶的前两张中有可使用或打出的牌，你立即获得之。",
			zhuyue: "逐月",
			zhuyue_info:
				"出牌阶段限一次，你可以弃置一张非基本牌并指定至多两个目标各随机弃置一张牌，若如此做，你本回合使用的杀须指定选中角色为目标。",
			zhuyue_info_alter:
				"出牌阶段限一次，你可以弃置一张黑色非基本牌并指定至多两个目标各随机弃置一张牌，若如此做，你本回合使用的杀须指定选中角色为目标。",
			guanri: "贯日",
			guanri_info:
				"限制技，你可以弃置两张红色手牌并失去1点体力，然后对一名体力值不少于你的其他角色造成2点火焰伤害并弃置其所有装备牌。",
			tianxian: "天弦",
			tianxian_info:
				"锁定技，你的杀无视距离且可指定任意多个目标，目标须进行一次判定，若结果为黑色则取消之。",
			xjzhimeng: "织梦",
			xjzhimeng2: "织梦",
			xjzhimeng3: "织梦",
			xjzhimeng_info:
				"结束阶段，你可以选择一名其他角色将牌堆顶的一张牌置于该角色的武将牌上，直到你的下个准备阶段将其收入手牌。当一名角色武将牌上有织梦牌时，每当其成为与此牌类型相同的卡牌的目标，可以摸一张牌。",
			xjzhimeng_info_alter: "结束阶段，你可以令一名其他角色摸一张牌。",
			runxin: "润心",
			runxin_info: "每当你使用或打出一张红桃牌，你可以令一名角色回复1点体力。",
			tannang: "探囊",
			tannang_info: "出牌阶段限一次，你可以将一张梅花手牌当顺手牵羊使用；你的顺手牵羊无距离限制。",
			tuoqiao: "烟瘴",
			tuoqiao_info: "你可以将一张黑色牌当作石灰粉使用。",
			xiaoyao: "逍遥",
			xiaoyao_info: "每当你成为其他角色的卡牌目标，你可以弃置一张与之花色相同的手牌取消之。",
			tianjian: "天剑",
			tianjian_info: "出牌阶段限一次，你可以将一张杀当作万箭齐发使用，受到伤害的角色随机弃置一张牌。",
			tianjian_info_alter: "出牌阶段限一次，你可以将一张杀当作万箭齐发使用。",
			xjyufeng: "御风",
			xjyufeng_info: "锁定技，当你失去手牌后，若手牌数少于2，你将手牌数补至2（每回合最多发动两次）。",
			huimeng: "回梦",
			huimeng_info: "每当你回复1点体力，可以摸两张牌。",
			tianshe: "天蛇",
			tianshe2: "天蛇",
			tianshe_info: "锁定技，你防止即将受到的属性伤害，每当你造成一次属性伤害，你回复1点体力。",
		},
	};
});